Http4s middleware - example with a resource being used by routes

[adamjuhasz]

Hey all!

I'm trying to understand how to use natchez and natchez-http4s when the route requires a resource (such as database calls). Is there an example of this?

When trying to send the database object to the routes I get the following type error around the resource I'm trying to use in the http routes.

[error] -- [E007] Type Mismatch Error: Application.scala:54:56 
[error] 54 |      ap = ep.liftT(NatchezMiddleware.server(rootRoutes(db))).orNotFound
[error]    |                                                        ^^
[error]    |Found:    (db : modules.Database[cats.effect.IO])
[error]    |Required: modules.Database[
[error]    |  [_] =>> cats.data.Kleisli[cats.effect.IO, natchez.Span[cats.effect.IO], _]]
[error]    |
[error]    | longer explanation available when compiling with `-explain`
[error] one error found

object Application extends IOApp.Simple {
  given logger: Logger[IO] = Slf4jLogger.getLogger[IO]

  val epInIO: EntryPoint[IO] = Log.entryPoint[IO]("app")

  def server(
      xa: HikariTransactor[IO],
      httpConf: HttpConfig
  ): Resource[IO, Server] =
    for
      ep: EntryPoint[IO] <- Resource.pure(epInIO)

      db: Database[IO] = Database(xa)

      ap = ep.liftT(NatchezMiddleware.server(rootRoutes(db))).orNotFound

      server: Server <- EmberServerBuilder
        .default[IO]
        .withHost(httpConf.host)
        .withPort(httpConf.port)
        .withHttpApp(ap)
        .build
    yield server

  override def run: IO[Unit] =
    for
      dbConf: DatabaseConfig <- DatabaseConfig.getConfig[IO]
      httpConf <- HttpConfig.getConfig[IO]

      program: Resource[IO, Unit] = for
        xa: HikariTransactor[IO] <- Database.makePostgresResource[IO](dbConf)
        _x: Server  <- server(xa, httpConf)
      yield ()

      _ <- program.use(_ => IO.never)
    yield ExitCode.Success
}

def rootRoutes[F[_]: Trace: Concurrent: Logger](database: Database[F])(implicit
    ev: MonadError[F, Throwable]
): HttpRoutes[F] = Router(
  "/"            -> (HealthRoutes[F].routes),
  "/v1/security" -> (SecuritiesRoutes[F](database).routes)
)

object Database:
  def apply[F[_]: Async: Logger](
      xa: Transactor[F]
  ): Database[F] = new Database[F](
    securities = SecuritiesRepository[F](xa),
    identifiers = IdentifierRepository[F](xa),
    securityTree = SecurityTreeRepository[F](xa),
    events = EventRepository[F](xa)
  )

  def makePostgresResource[F[_]: Async: Logger](
      config: DatabaseConfig
  ): Resource[F, HikariTransactor[F]] = for
    ec <- ExecutionContexts.fixedThreadPool(config.nThreads)
    xa <- HikariTransactor.newHikariTransactor[F](
      driverClassName = "org.postgresql.Driver",
      url = s"jdbc:${config.url}",
      user = config.user,
      pass = config.pass,
      connectEC = ec,
      logHandler = Some(mkLogger[F])
    )
  yield xa

[armanbilge]

The problem is that you have a Database[IO] but you need to have a Database[Kleisli[IO, Span[IO], *]].

If your Database[IO] has a mapK method, you can use that with Kleisli.liftK.

Otherwise, you can manually implement a Database[Kleisli[IO, Span[IO], *]] that delegates to a Database[IO] using Kleisli.liftF.

[adamjuhasz]

First, sorry for putting the question in the wrong spot and thanks for the help. I am struggling with understand the delegation, the Database[IO does not have a mapK so I'm attempting to use liftF.

Apologies again for the simpleton questions but I'm unsure how to do the lift. I tried the code below but I'm getting a Not found: type * error now on the asterisks. Am I using the liftF incorrectly?

      ep <- Resource.pure(epInIO)

      db: Database[IO] = Database(xa)
      dbInKleisli: Database[Kleisli[IO, Span[IO], *]] = Kleisli
        .liftF[Database, IO, Kleisli[IO, Span[IO], *]](db)

      ap = ep
        .liftT(NatchezMiddleware.server(rootRoutes(dbInKleisli)))
        .orNotFound

[armanbilge]

First, sorry for putting the question in the wrong spot

You didn't! First I had to enable the "discussions" feature for this repository :)

Not found: type * error now on the asterisks.

It looks like you are using Scala 3. Have you added the -Ykind-projector flag to your compiler options? That will enable the * syntax to work.

Once you have that setup, then you should do something like this:

val dbInKleisli = new Database[Kleisli[IO, Span[IO], *]]:
  def method1(...) = Kleisli.liftF(db.method1(...))
  // etc.

[adamjuhasz]

Yep, the Kind Projector flag worked! Awesome thanks!!

Ugh sorry still struggling with the types

I tried the following but getting the error on db.securities

[error] 71 |        def securities   = Kleisli.liftF(db.securities)
[error]    |                                         ^^^^^^^^^^^^^
[error]    |Found:    com.farther.secmaster.database.SecuritiesRepository[cats.effect.IO]
[error]    |Required: F[B]
[error]    |
[error]    |where:    B is a type variable with constraint 
[error]    |          F is a type variable with constraint <: [_] =>> Any
[error]    |
[error]    |Note that implicit conversions were not tried because the result of an implicit conversion
[error]    |must be more specific than F[B]

      db: Database[IO] = Database(xa)
      dbInKleisli      = new Database[Kleisli[IO, Span[IO], *]]:
        def securities   = Kleisli.liftF(db.securities)
        def identifiers  = Kleisli.liftF(db.identifiers)
        def securityTree = Kleisli.liftF(db.securityTree)
        def events       = Kleisli.liftF(db.events)

This made me think that liftF needs type arguments to help the compiler but looking at its signature def liftF[F[_], A, B](x: F[B]): Kleisli[F, A, B] I'm confused as it seems like it expects its argument x F[B] to already be in the Trace context(the B type variable as I believe F is Database)

---

This is what the database class/object pair look like

class Database[F[_]: Logger]:
  def securities: SecuritiesRepository[F]
  def identifiers: IdentifierRepository[F]
  def securityTree: SecurityTreeRepository[F]
  def events: EventRepository[F]

object Database:
  def apply[F[_]: Async: Logger](
      xa: Transactor[F]
  ): Database[F] = new Database[F]:
    def securities   = SecuritiesRepository[F](xa)
    def identifiers  = IdentifierRepository[F](xa)
    def securityTree = SecurityTreeRepository[F](xa)
    def events       = EventRepository[F](xa)

SecuritiesRepository looks like the following an the other ones are the same idea

class SecuritiesRepository[F[_]: MonadCancelThrow] private (xa: Transactor[F])
    extends SecuritiesRepositoryTrait[F]:
  override def create(
      security: CreateSecurity,
      event: EventInfo
  ): F[UUID] = createSecurity(security, (event)).transact(xa) // createSecurity is a doobie `ConnectionIO[UUID]`


object SecuritiesRepository:
  def apply[F[_]: MonadCancelThrow](
      xa: Transactor[F]
  ): SecuritiesRepository[F] =
    new SecuritiesRepository[F](xa)

[armanbilge]

Hmm, ok, let's try something different. Try initializing your database like this:

db = Database[Kleisli[IO, Span[IO], *]](xa)

Then you will need to change xa to be a HikariTransactor[Kleisli[IO, Span[IO], *]].

[adamjuhasz]

Thank you!!!

Added a .mapK(Kleisli.liftK[IO, Span[IO]]) to make db: Database[Kleisli[IO, Span[IO], *]] = Database(xa.mapK(Kleisli.liftK[IO, Span[IO]])) and all the lego blocks connected.

Thank you so so much!

---

For anyone searching here's the final bit that connected the types.

  
object Application extends IOApp.Simple {
  given logger: Logger[IO] = Slf4jLogger.getLogger[IO]

  val epInIO: EntryPoint[IO] = Log.entryPoint[IO]("sec-master")

  def server(
      xa: HikariTransactor[IO],
      httpConf: HttpConfig
  ): Resource[IO, Server] =
    for
      // from https://github.com/typelevel/natchez-http4s/blob/main/modules/examples/src/main/scala/Example1.scala
      ep <- Resource.pure(epInIO)

      db: Database[Kleisli[IO, Span[IO], *]] = Database(
        xa.mapK(Kleisli.liftK[IO, Span[IO]])
      )

      ap = ep
        .liftT(NatchezMiddleware.server(rootRoutes(db)))
        .orNotFound

      server <- EmberServerBuilder
        .default[IO]
        .withHost(httpConf.host)
        .withPort(httpConf.port)
        .withHttpApp(ap)
        .build
    yield server

  override def run =
    for
      dbConf   <- DatabaseConfig.getConfig[IO]
      httpConf <- HttpConfig.getConfig[IO]

      program = for
        xa <- Database.makePostgresResource[IO](dbConf)
        _  <- server(xa, httpConf)
      yield ()

      _ <- program.use(_ => IO.never)
    yield ExitCode.Success
}

object HttpApi:
  def rootRoutes[F[_]: Trace: Concurrent: Logger](database: Database[F])(implicit
      ev: MonadError[F, Throwable]
  ): HttpRoutes[F] = Router(
    "/"            -> (HealthRoutes[F].routes),
    "/v1/security" -> (SecuritiesRoutes[F](database).routes)
  )

final class Database[F[_]: Logger] private (
    val securities: SecuritiesRepository[F]
)

object Database:
  def apply[F[_]: Async: Logger](
      xa: Transactor[F]
  ): Database[F] = new Database[F](
    securities = SecuritiesRepository[F](xa),
    identifiers = IdentifierRepository[F](xa),
    securityTree = SecurityTreeRepository[F](xa),
    events = EventRepository[F](xa)
  )

  def makePostgresResource[F[_]: Async: Logger](
      config: DatabaseConfig
  ): Resource[F, HikariTransactor[F]] = for
    ec <- ExecutionContexts.fixedThreadPool(config.nThreads)
    xa <- HikariTransactor.newHikariTransactor[F](
      driverClassName = "org.postgresql.Driver",
      url = s"jdbc:${config.url}",
      user = config.user,
      pass = config.pass,
      connectEC = ec,
      logHandler = Some(mkLogger[F])
    )
  yield xa

trait SecuritiesRepositoryTrait[F[_]]:
  /** Create a new security, will place it at the root of the tree
    */
  def create(
      security: CreateSecurity,
      event: EventInfo
  ): F[SecurityId]

class SecuritiesRepository[F[_]: MonadCancelThrow] private (xa: Transactor[F])
    extends SecuritiesRepositoryTrait[F]:
  override def create(
      security: CreateSecurity,
      event: EventInfo
  ): F[SecurityId] = createSecurity(security, (event)).transact(xa)

object SecuritiesRepository:
  def apply[F[_]: MonadCancelThrow](
      xa: Transactor[F]
  ): SecuritiesRepository[F] =
    new SecuritiesRepository[F](xa)