skunk-core

Skunk is a functional data access layer for Postgres.

Design principles:

• Skunk doesn't use JDBC. It speaks the Postgres wire protocol. It will not work with any other database back end.

• Skunk is asynchronous all the way down, via cats-effect, fs2, and ultimately nio. The high-level network layers (Protocol and Session) are safe to use concurrently.

• Serialization to and from schema types is not typeclass-based, so there are no implicit derivations. Codecs are explicit, like parser combinators.

• I'm not sweating arity abstraction that much. Pass a ~ b ~ c for three args and Void if there are no args. This may change in the future but it's fine for now.

• Skunk uses Resource for lifetime-managed objects, which means it takes some discipline to avoid leaks, especially when working concurrently. May or may not end up being problematic.

• I'm trying to write good Scaladoc this time.

A minimal example follows. We construct a Resource that yields a Session, then use it.

package example

import cats.effect._
import skunk._
import skunk.implicits._
import skunk.codec.numeric._

object Minimal extends IOApp {

 val session: Resource[IO, Session[IO]] =
   Session.single(
     host     = "localhost",
     port     = 5432,
     user     = "postgres",
     database = "world",
   )

 def run(args: List[String]): IO[ExitCode] =
   session.use { s =>
     for {
       n <- s.unique(sql"select 42".query(int4))
       _ <- IO(println(s"The answer is $n."))
     } yield ExitCode.Success
   }

}

Continue reading for an overview of the library. It's pretty small.