How to properly use IO and OptionT in service layer in for-comprehension?

Question

I have a simple repository interface with CRUD operations (probably, it is a bad idea to pass implicit session as parameter in general trait):

trait Repository[Entity, PK] {
  def find(pk: PK)(implicit session: DBSession): OptionT[IO, Entity]

  def insert(e: Entity)(implicit session: DBSession): IO[Entity]

  def update(e: Entity)(implicit session: DBSession): IO[Entity]

  def delete(pk: PK)(implicit session: DBSession): IO[Int]

  def findAll()(implicit session: DBSession): IO[List[Entity]]
}

And i want to use it like this:

for {
  _ <- repository.insert(???)
  _ <- repository.delete(???)
  v <- repository.find(???).value
  _ <- someFunctionReliesOnReturnedValue(v)
} yield (???)

Also, i want to stop execution if v is None and rollback transaction if there is any error (i use scalikejdbc). So, as i think, i have to do it in my service layer like this (+ wrap it into Try or something like this to cacth business exception):

def logic(???) = {
  DB localTx {
    implicit session => {
      (for {
        _ <- repository.insert(???)
        _ <- repository.delete(???)
        v <- repository.find(???).value
        _ <- someFunctionReliesOnReturnedValue(v)
      } yield (???)).unsafeRunSync() // to rollback transaction if there is any error
    }
  }
}

The problem is here: someFunctionReliesOnReturnedValue(v). It can be an arbitrary function which accepts Entity not Option[Entity]. How can i convert result of OptionT[IO, Entity] to IO[Entity] and save semantic of Option[]? Is it correct approach or i've mistaken somewhere?

---

import java.nio.file.{Files, Paths}

import cats.data.OptionT
import cats.effect.IO
import scalikejdbc._

import scala.util.Try

case class Entity(id: Long, value: String)

object Entity extends SQLSyntaxSupport[Entity] {
  override def tableName: String = "entity"

  override def columnNames: Seq[String] = Seq("id", "value")

  def apply(g: SyntaxProvider[Entity])(rs: WrappedResultSet): Entity = apply(g.resultName)(rs)

  def apply(r: ResultName[Entity])(rs: WrappedResultSet): Entity =
    Entity(rs.long(r.id), rs.string(r.value))
}

trait Repository[Entity, PK] {
  def find(pk: PK)(implicit session: DBSession): OptionT[IO, Entity]

  def insert(e: Entity)(implicit session: DBSession): IO[Entity]
}

class EntityRepository extends Repository[Entity, Long] {
  private val alias = Entity.syntax("entity")

  override def find(pk: Long)(implicit session: DBSession): OptionT[IO, Entity] = OptionT{
    IO{
      withSQL {
        select(alias.resultAll).from(Entity as alias).where.eq(Entity.column.id, pk)
      }.map(Entity(alias.resultName)(_)).single().apply()
    }
  }

  override def insert(e: Entity)(implicit session: DBSession): IO[Entity] = IO{
    withSQL {
      insertInto(Entity).namedValues(
        Entity.column.id -> e.id,
        Entity.column.value -> e.value,
      )
    }.update().apply()
    e
  }
}

object EntityRepository {
  def apply(): EntityRepository = new EntityRepository()
}

object Util {
  def createFile(value: String): IO[Unit] = IO(Files.createDirectory(Paths.get("path", value)))
}

class Service {
  val repository = EntityRepository()

  def logic(): Either[Throwable, Unit] = Try {
    DB localTx {
      implicit session => {
        val result: IO[Unit] = for {
          _ <- repository.insert(Entity(1, "1"))
          _ <- repository.insert(Entity(2, "2"))
          e <- repository.find(3)
          _ <- Util.createFile(e.value) // error
          //after this step there is possible more steps (another insert or find)
        } yield ()
        result.unsafeRunSync()
      }
    }
  }.toEither
}

object Test extends App {
  ConnectionPool.singleton("jdbc:postgresql://localhost:5433/postgres", "postgres", "")
  val service = new Service()
  service.logic()
}

Table:

create table entity (id numeric(38), value varchar(255));

And i got compile error:

Error:(69, 13) type mismatch; found : cats.effect.IO[Unit] required: cats.data.OptionT[cats.effect.IO,?] _ <- Util.createFile(e.value)

Answer 1

In general, you should convert all of your different results to your "most general" type that has a monad. In this case, that means you should use OptionT[IO, A] throughout your for-comprehension by converting all of those IO[Entity] to OptionT[IO, Entity] with OptionT.liftF:

for {
  _ <- OptionT.liftF(repository.insert(???))
  _ <- OptionT.liftF(repository.delete(???))
  v <- repository.find(???)
  _ <- someFunctionReliesOnReturnedValue(v)
} yield (???)

If you had an Option[A] you could use OptionT.fromOption[IO]. The issues come from trying to mix monads within the same for-comprehension.

This will already stop execution if any of these result in a None. As for rolling back the transaction, that depends on how your DB interaction library works, but if it handles exceptions by rolling back, then yes, unsafeRunSync will work. If you also want it to roll back by throwing an exception when the result is None, you could do something like:

val result: OptionT[IO, ...] = ...
result.value.unsafeRunSync().getOrElse(throw new FooException(...))