refined support module

build.sbt

@@ -57,6 +57,16 @@ val `oolong-bson` = (project in file("oolong-bson"))
     Test / fork := true,
   )
 
+val `oolong-bson-refined` = (project in file("oolong-bson-refined"))
+  .settings(Settings.common)
+  .dependsOn(`oolong-bson`)
+  .settings(
+    libraryDependencies ++= Seq(
+      "eu.timepit" %% "refined" % "0.11.0"
+    ),
+    Test / fork := true,
+  )
+
 val `oolong-core` = (project in file("oolong-core"))
   .settings(Settings.common)
   .dependsOn(`oolong-bson`)
@@ -95,7 +105,7 @@ val `oolong-mongo-it` = (project in file("oolong-mongo-it"))
 
 val root = (project in file("."))
   .settings(Settings.common)
-  .aggregate(`oolong-bson`, `oolong-core`, `oolong-mongo`, `oolong-mongo-it`)
+  .aggregate(`oolong-bson`, `oolong-bson-refined`, `oolong-core`, `oolong-mongo`, `oolong-mongo-it`)
   .settings(
     pullRemoteCache := {},
     pushRemoteCache := {},

oolong-bson-refined/src/main/scala/oolong/bson/refined/refined.scala

@@ -0,0 +1,42 @@
+package oolong.bson.refined
+
+import scala.util.Failure
+import scala.util.Success
+import scala.util.Try
+
+import eu.timepit.refined.api.RefType
+import eu.timepit.refined.api.Validate
+import oolong.bson.BsonDecoder
+import oolong.bson.BsonEncoder
+import oolong.bson.BsonKeyDecoder
+import oolong.bson.BsonKeyEncoder
+import oolong.bson.DeserializationError
+import org.mongodb.scala.bson.BsonValue
+
+given [T, P, F[_, _]](using BsonDecoder[T], Validate[T, P], RefType[F]): BsonDecoder[F[T, P]] with
+  def fromBson(value: BsonValue): Try[F[T, P]] =
+    BsonDecoder[T].fromBson(value) match {
+      case Success(t0) =>
+        RefType[F].refine(t0) match {
+          case Left(err) => Failure(DeserializationError(err))
+          case Right(t)  => Success(t)
+        }
+      case Failure(exc) => Failure(exc)
+    }
+
+given [T, P, F[_, _]](using BsonEncoder[T], Validate[T, P], RefType[F]): BsonEncoder[F[T, P]] with
+  extension (value: F[T, P]) def bson: BsonValue = RefType[F].unwrap(value).bson
+
+given [T, P, F[_, _]](using BsonKeyDecoder[T], Validate[T, P], RefType[F]): BsonKeyDecoder[F[T, P]] with
+  def decode(value: String): Try[F[T, P]] =
+    BsonKeyDecoder[T].decode(value) match {
+      case Success(t0) =>
+        RefType[F].refine(t0) match {
+          case Left(err) => Failure(DeserializationError(err))
+          case Right(t)  => Success(t)
+        }
+      case Failure(exc) => Failure(exc)
+    }
+
+given [T, P, F[_, _]](using BsonKeyEncoder[T], Validate[T, P], RefType[F]): BsonKeyEncoder[F[T, P]] with
+  def encode(t: F[T, P]): String = BsonKeyEncoder[T].encode(RefType[F].unwrap(t))