BaseDAO.scala

package xyz.x5ff.bklg.data.dao

trait BaseDAO[DomainType] {
  def save(obj: DomainType): DomainType
  def del(obj: DomainType): DomainType
  def createTable(): Any
  def dropTable(): Any
}

LocalDBTest.scala

package xyz.x5ff.bklg

import xyz.x5ff.bklg.common.dto.User
import xyz.x5ff.bklg.data.dao.sql.SQLUserDAOComponent
import xyz.x5ff.bklg.data.dao.sql.crate.CrateSQLDriver

object LocalDBTest extends App {
  val username = "[email protected]"

  val userDaoComponent = new SQLUserDAOComponent with CrateSQLDriver {}
  val dao = userDaoComponent.userDao
  
  dao.createTable()

  dao.save(User(username))

  println(dao.getByName(username))

  dao.del(User(username))

  dao.dropTable()
}

SQLUserDAOComponent.scala

package xyz.x5ff.bklg.data.dao.sql

import xyz.x5ff.bklg.common._
import xyz.x5ff.bklg.data.dao.{DatabaseDriver, UserDAOComponent}
import scalikejdbc._

object User extends SQLSyntaxSupport[dto.User] {
  override def schemaName = Option("bklg")
  override def tableName = "Users"

  def apply(ws: WrappedResultSet) =
    new dto.User(ws.string("name"))

  def apply(o: SyntaxProvider[dto.User])(rs: WrappedResultSet): dto.User =
    apply(o.resultName)(rs)

  def apply(o: ResultName[dto.User])(ws: WrappedResultSet): dto.User = {
    new dto.User(ws.string(o.name))
  }
}

trait SQLUserDAOComponent extends UserDAOComponent {
  this: DatabaseDriver =>

  override def userDao = new SQLUserDAO

  class SQLUserDAO extends UserDAOInterface {
    implicit val session = AutoSession
    val c = User.column

    override def save(obj: dto.User): dto.User = {
      withSQL {
        insert.into(User).namedValues(
          c.name -> obj.name
        )
      }.update.apply()
      obj
    }

    override def createTable(): Any = {
      SQL(s"create table if not exists ${User.tableNameWithSchema} (name string primary key)").execute.apply()
    }

    override def del(obj: dto.User): dto.User = {
      withSQL {
        delete.from(User).where.eq(c.name, obj.name)
      }.update.apply()
      obj
    }

    override def getByName(name: String): Option[dto.User] = {
      val u = User.syntax("u")
      withSQL {
        select
          .from(User as u)
          .where
          .eq(c.name, name)
      }.map(User(u)).single.apply()
    }

    override def dropTable(): Any = SQL(s"drop table ${User.tableNameWithSchema}").execute.apply()
  }
}

User.scala

package xyz.x5ff.bklg.common.dto

case class User(name: String)

UserDAO.scala

package xyz.x5ff.bklg.data.dao

import xyz.x5ff.bklg.common.dto.User

trait UserDAO extends BaseDAO[User] {
  def getByName(name: String): Option[User]
}

trait UserDAOComponent {
  def userDao: UserDAOInterface
  trait UserDAOInterface extends UserDAO
}