UserDao.scala

package me.scf37.rediska.dao

import java.sql.Connection
import java.sql.Timestamp
import java.time.Instant

import cats.Applicative
import me.scf37.db.sql.SqlEffectLift
import me.scf37.rediska.dao.meta.Sequences
import me.scf37.rediska.dao.meta.Tables.USER
import me.scf37.rediska.model.PasswordHash
import me.scf37.rediska.model.User
import org.jooq.DSLContext
import org.jooq.SQLDialect
import org.jooq.impl.DSL

trait UserDao[F[_]] {
  def get(id: User.Id): F[Option[User]]
  def getByEmail(email: String): F[Option[User]]
  def create(user: User, hash: PasswordHash): F[User]
  def update(user: User, hash: Option[PasswordHash]): F[Option[User]]
  def delete(userId: User.Id): F[Boolean]
}

class UserDaoImpl[F[_]: Applicative, DbEffect[_]](
  implicit val DB: SqlEffectLift[F, DbEffect]
) extends UserDao[DbEffect] {

  protected def ctx(conn: Connection): DSLContext = DSL.using(conn, SQLDialect.POSTGRES_9_5)

  override def get(id: User.Id): DbEffect[Option[User]] = DB.cacheRead("user", id){ conn =>
    Option(ctx(conn)
      .selectFrom(USER)
      .where(USER.ID equal id.id)
      .fetchOne()).map(Converters.userFromRecord)
  }

  override def getByEmail(email: String): DbEffect[Option[User]] = DB.lift[Option[User]] { conn =>
    Option(ctx(conn)
      .selectFrom(USER)
      .where(USER.EMAIL_NORM equal User.normalizeEmail(email))
      .fetchOne()).map(Converters.userFromRecord)
  }

  override def create(user: User, passwordHash: PasswordHash): DbEffect[User] = DB.cacheCreate[User]("user", _.id) { conn =>
    val r = Converters.userToRecord(user, Some(passwordHash))
    r.setId(ctx(conn).nextval(Sequences.USER_ID_S))
    r.setCreated(Timestamp.from(Instant.now()))

    Converters.userFromRecord(ctx(conn).insertInto(USER).set(r).returning().fetchOne())
  }

  override def update(user: User, hash: Option[PasswordHash]): DbEffect[Option[User]] = DB.cacheUpdate("user", user.id) { conn =>
    val r = Converters.userToRecord(user, hash)
    r.changed(true)
    r.changed(USER.CREATED, false)
    if (hash.isEmpty) {
      r.changed(USER.PASSWORD, false)
    }
    r.setUpdated(Timestamp.from(Instant.now()))
    Option(Converters.userFromRecord(ctx(conn).update(USER).set(r)
        .where(USER.ID equal user.id.id)
        .returning().fetchOne()))
  }

  override def delete(userId: User.Id): DbEffect[Boolean] = DB.cacheDelete("user", userId) { conn =>
    ctx(conn).deleteFrom(USER).where(USER.ID equal userId.id).execute() > 0
  }
}