Skip to main content

doobie module

Import

import refined4s.modules.doobie.derivation.types.all.given
import refined4s.modules.doobie.derivation.*

Use Drived Instances for Pre-defined Types

To use Newtype, Refined and InlinedRefined with Doobie by having Get and Put (or Read and Write from Get and Put) type-class instances derived from the actual values, you can simply use

import refined4s.modules.doobie.derivation.types.all.given
NOTE

This works only when the actual type already has Get and Put.

info

Using refined4s.modules.doobie.derivation.types.all.given is required only when Get and/or Put is required for the pre-defined types.
So if you want your Newtype or Refined or InlinedRefined to have Get and Put instances,
you can use pre-defined traits for doobie or the deriving method instead.

import cats.effect.*

import refined4s.*
import refined4s.types.all.*

import doobie.*
import doobie.syntax.all.*

def insertOrUpdate[F[*]](fragment: Fragment)(transactor: Transactor[F])(
using bracket: Bracket[F, Throwable]
): F[Int] =
fragment
.update
.run
.transact(transactor)

With derivation.types.all,

import refined4s.modules.doobie.derivation.types.all.given

final case class Person(name: NonEmptyString)

val name = NonEmptyString("Tony Stark")

insertOrUpdate[F](
sql"""
INSERT INTO db_tools_test.example (value) VALUES ($name)
"""
)(transactor)

// You don't have to do use .value like
// insertOrUpdate[F](
// sql"""
// INSERT INTO db_tools_test.example (value) VALUES ($name.value)
// """
// )(transactor)

With Explicit Pre-defined Doobie Support

There are the following pre-defined traits to support doobie's Get and Put (or Codec).

  • refined4s.modules.doobie.derivation.DoobiePut
  • refined4s.modules.doobie.derivation.DoobieNewtypeGet
  • refined4s.modules.doobie.derivation.DoobieRefinedGet
NOTE

This works only when the actual type already has Get and/or Put.

e.g.)

import cats.effect.*

import refined4s.*
import refined4s.types.all.*
import refined4s.modules.doobie.derivation.*

type NotEmptyStr = NotEmptyStr.Type
object NotEmptyStr extends Refined[String], DoobieRefinedGetPut[String] {
inline def invalidReason(a: String): String = "non-empty String"

inline def predicate(a: String): Boolean = a != ""
}

type Name = Name.Type
object Name extends Newtype[NotEmptyStr], DoobieNewtypeGetPut[NotEmptyStr]

type Id = Id.Type
object Id extends Newtype[Long], DoobieNewtypeGetPut[Long]

final case class Person(id: Id, name: Name)

import doobie.*
import doobie.syntax.all.*

def insertOrUpdate[F[*]](fragment: Fragment)(transactor: Transactor[F])(
using bracket: Bracket[F, Throwable]
): F[Int] =
fragment
.update
.run
.transact(transactor)
val person = Person(Id(1), Name(NotEmptyStr("Kevin")))

insertOrUpdate[F](
sql"""
INSERT INTO db_tools_test.example (id, name) VALUES (${person.id}, ${person.name})
"""
)(transactor)

// You don't have to use .value or .value.value like
// insertOrUpdate[F](
// sql"""
// INSERT INTO db_tools_test.example (id, name) VALUES (${person.id.value}, ${person.name.value.value})
// """
// )(transactor)

With deriving Method

If you want to have explicit Get and Put type-class instances in your Newtype or Refined or InlinedRefined, you can use the deriving method.

NOTE

This works only when the actual type already has Get and Put.

import cats.effect.*

import refined4s.*

import doobie.*

type Name = Name.Type
object Name extends Newtype[NotEmptyStr] {
given getName: Get[Name] = deriving[Get]
given putName: Put[Name] = deriving[Put]
}

type NotEmptyStr = NotEmptyStr.Type
object NotEmptyStr extends Refined[String] {
inline def invalidReason(a: String): String = "non-empty String"

inline def predicate(a: String): Boolean = a != ""

given getNotEmptyStr: Get[NotEmptyStr] = Get[String].temap(NotEmptyStr.from)
given putNotEmptyStr: Put[NotEmptyStr] = deriving[Put]
}

type Id = Id.Type
object Id extends Newtype[Long] {
given getId: Get[Id] = deriving[Get]
given putId: Put[Id] = deriving[Put]
}

final case class Person(id: Id, name: Name)

import doobie.syntax.all.*

def insertOrUpdate[F[*]](fragment: Fragment)(transactor: Transactor[F])(
using bracket: Bracket[F, Throwable]
): F[Int] =
fragment
.update
.run
.transact(transactor)
val person = Person(Id(1), Name(NotEmptyStr("Kevin")))

insertOrUpdate[F](
sql"""
INSERT INTO db_tools_test.example (id, name) VALUES (${person.id}, ${person.name})
"""
)(transactor)

// You don't have to use .value or .value.value like
// insertOrUpdate[F](
// sql"""
// INSERT INTO db_tools_test.example (id, name) VALUES (${person.id.value}, ${person.name.value.value})
// """
// )(transactor)