feat: add conversion for scala duration

Author: Simon Siedler

src/main/scala/dev/mongocamp/driver/mongodb/json/CirceSchema.scala

@@ -1,153 +1,141 @@
 package dev.mongocamp.driver.mongodb.json
 
 import dev.mongocamp.driver.mongodb.bson.BsonConverter
-import io.circe.Decoder
 import io.circe.Decoder.Result
-import io.circe.Encoder
-import io.circe.HCursor
-import io.circe.Json
+import io.circe._
 import java.util.Date
 import org.bson.types.ObjectId
 import org.joda.time.DateTime
 import org.mongodb.scala.Document
+import scala.concurrent.duration.Duration
 import scala.jdk.CollectionConverters._
 
 trait CirceSchema extends CirceProductSchema {
 
-  implicit lazy val DocumentOneFormat: Encoder[org.mongodb.scala.Document] with io.circe.Decoder[org.mongodb.scala.Document] =
-    new io.circe.Encoder[org.mongodb.scala.Document] with io.circe.Decoder[org.mongodb.scala.Document] {
+  implicit lazy val DocumentOneFormat: Encoder[org.mongodb.scala.Document] with Decoder[org.mongodb.scala.Document] =
+    new Encoder[org.mongodb.scala.Document] with Decoder[org.mongodb.scala.Document] {
       override def apply(a: org.mongodb.scala.Document): Json = {
         encodeMapStringAny(BsonConverter.asMap(a))
       }
 
       override def apply(c: HCursor): Result[org.mongodb.scala.Document] = {
         Decoder.decodeString
-          .map(
-            s => {
-              val document = new org.mongodb.scala.Document(org.mongodb.scala.bson.BsonDocument(s))
-              document
-            }
-          )
+          .map(s => {
+            val document = new org.mongodb.scala.Document(org.mongodb.scala.bson.BsonDocument(s))
+            document
+          })
           .apply(c)
       }
     }
 
-  implicit lazy val DocumentTowFormat: Encoder[org.bson.Document] with io.circe.Decoder[org.bson.Document] = new io.circe.Encoder[org.bson.Document]
-    with io.circe.Decoder[org.bson.Document] {
-    override def apply(a: org.bson.Document): Json = {
-      val map = a
-        .keySet()
-        .asScala
-        .map(
-          key => {
+  implicit lazy val DocumentTowFormat: Encoder[org.bson.Document] with Decoder[org.bson.Document] =
+    new Encoder[org.bson.Document] with Decoder[org.bson.Document] {
+      override def apply(a: org.bson.Document): Json = {
+        val map = a
+          .keySet()
+          .asScala
+          .map(key => {
             val value = a.get(key)
             (key, encodeAnyToJson(value))
-          }
-        )
-        .toMap
-      encodeMapStringAny(map)
-    }
+          })
+          .toMap
+        encodeMapStringAny(map)
+      }
 
-    override def apply(c: HCursor): Result[org.bson.Document] = {
-      Decoder
-        .decodeMap[String, Any]
-        .map(
-          m => {
+      override def apply(c: HCursor): Result[org.bson.Document] = {
+        Decoder
+          .decodeMap[String, Any]
+          .map(m => {
             val document = new org.bson.Document(m.asJava)
             document
-          }
-        )
-        .apply(c)
+          })
+          .apply(c)
+      }
     }
-  }
 
-  implicit val DateFormat: Encoder[Date] with io.circe.Decoder[Date] = new io.circe.Encoder[Date] with io.circe.Decoder[Date] {
+  implicit val DateFormat: Encoder[Date] with Decoder[Date] = new Encoder[Date] with Decoder[Date] {
     override def apply(d: Date): Json = {
       Option(d)
-        .map(
-          date => Encoder.encodeString.apply(date.toInstant.toString)
-        )
+        .map(date => Encoder.encodeString.apply(date.toInstant.toString))
         .getOrElse(Json.Null)
     }
 
     override def apply(c: HCursor): Result[Date] = {
       Decoder.decodeString
-        .map(
-          s => new DateTime(s).toDate
-        )
+        .map(s => new DateTime(s).toDate)
         .apply(c)
     }
   }
 
-  implicit val DateTimeFormat: Encoder[DateTime] with io.circe.Decoder[DateTime] = new io.circe.Encoder[DateTime] with io.circe.Decoder[DateTime] {
+  implicit val DateTimeFormat: Encoder[DateTime] with Decoder[DateTime] = new Encoder[DateTime] with Decoder[DateTime] {
     override def apply(d: DateTime): Json = {
       Option(d)
-        .map(
-          date => Encoder.encodeString.apply(date.toInstant.toString)
-        )
+        .map(date => Encoder.encodeString.apply(date.toInstant.toString))
         .getOrElse(Json.Null)
     }
 
     override def apply(c: HCursor): Result[DateTime] = {
       Decoder.decodeString
-        .map(
-          s => new DateTime(s)
-        )
+        .map(s => new DateTime(s))
         .apply(c)
     }
   }
 
-  implicit val ObjectIdFormat: Encoder[ObjectId] with io.circe.Decoder[ObjectId] = new io.circe.Encoder[ObjectId] with io.circe.Decoder[ObjectId] {
+  implicit val ObjectIdFormat: Encoder[ObjectId] with Decoder[ObjectId] = new Encoder[ObjectId] with Decoder[ObjectId] {
     override def apply(o: ObjectId): Json = {
       Option(o)
-        .map(
-          o => Encoder.encodeString.apply(o.toHexString)
-        )
+        .map(o => Encoder.encodeString.apply(o.toHexString))
         .getOrElse(Json.Null)
     }
 
     override def apply(c: HCursor): Result[ObjectId] = {
       Decoder.decodeString
-        .map(
-          s => new ObjectId(s)
-        )
+        .map(s => new ObjectId(s))
         .apply(c)
     }
   }
 
-  implicit val MapStringAnyFormat: Encoder[Map[String, Any]] with io.circe.Decoder[Map[String, Any]] = new io.circe.Encoder[Map[String, Any]]
-    with io.circe.Decoder[Map[String, Any]] {
-    override def apply(a: Map[String, Any]): Json = {
-      encodeMapStringAny(a)
+  implicit val DurationFormat: Encoder[Duration] with Decoder[Duration] = new Encoder[Duration] with Decoder[Duration] {
+    override def apply(d: Duration): Json = {
+      Option(d)
+        .map(duration => Json.fromString(duration.toString))
+        .getOrElse(Json.Null)
     }
 
-    override def apply(c: HCursor): Result[Map[String, Any]] = {
-      Decoder.decodeMap[String, Any].apply(c)
+    override def apply(c: HCursor): Result[Duration] = {
+      Decoder.decodeString.emap(s =>
+        scala.util.Try(Duration(s)).toEither.left.map(_.getMessage)
+      ).apply(c)
     }
   }
 
-  implicit val AnyFormat: Encoder[Any] with io.circe.Decoder[Any] = new io.circe.Encoder[Any] with io.circe.Decoder[Any] {
+  implicit val MapStringAnyFormat: Encoder[Map[String, Any]] with Decoder[Map[String, Any]] =
+    new Encoder[Map[String, Any]] with Decoder[Map[String, Any]] {
+      override def apply(a: Map[String, Any]): Json = {
+        encodeMapStringAny(a)
+      }
+
+      override def apply(c: HCursor): Result[Map[String, Any]] = {
+        Decoder.decodeMap[String, Any].apply(c)
+      }
+    }
 
+  implicit val AnyFormat: Encoder[Any] with Decoder[Any] = new Encoder[Any] with Decoder[Any] {
     override def apply(a: Any): Json = {
       encodeAnyToJson(a)
     }
 
     override def apply(c: HCursor): Result[Any] = {
       Decoder.decodeJson
-        .map(
-          a => decodeFromJson(a)
-        )
+        .map(a => decodeFromJson(a))
         .apply(c)
     }
-
   }
 
   def encodeMapStringAny(a: Map[String, Any]): Json = {
     Json.obj(
       a.keySet
-        .map(
-          key => (key, encodeAnyToJson(a(key)))
-        )
+        .map(key => (key, encodeAnyToJson(a(key))))
         .toList: _*
     )
   }
@@ -159,8 +147,7 @@ trait CirceSchema extends CirceProductSchema {
         val long  = value.toLong
         if (long.isDefined) {
           long.get
-        }
-        else {
+        } else {
           value.toDouble
         }
       case a if a.isString =>
@@ -169,29 +156,23 @@ trait CirceSchema extends CirceProductSchema {
           try {
             val date = new DateTime(string)
             date
-          }
-          catch {
+          } catch {
             case _: Exception => string
           }
-        }
-        else {
+        } else {
           string
         }
       case a if a.isBoolean => a.asBoolean.getOrElse(false)
       case a if a.isArray =>
-        a.asArray.get.toList.map(
-          e => decodeFromJson(e)
-        )
+        a.asArray.get.toList.map(e => decodeFromJson(e))
       case a if a.isObject =>
-        a.asObject.get.toMap.map(
-          e => (e._1, decodeFromJson(e._2))
-        )
+        a.asObject.get.toMap.map(e => (e._1, decodeFromJson(e._2)))
       case a if a.isNull => null
       case _             => null
     }
   }
 
-  def encodeAnyToJson(a: Any, deepth: Int = 0): Json = {
+  def encodeAnyToJson(a: Any, depth: Int = 0): Json = {
     a match {
       case s: String      => Json.fromString(s)
       case b: Boolean     => Json.fromBoolean(b)
@@ -203,50 +184,42 @@ trait CirceSchema extends CirceProductSchema {
       case f: Float       => Json.fromFloatOrNull(f)
       case option: Option[_] =>
         option
-          .map(
-            e => encodeAnyToJson(e, deepth)
-          )
+          .map(e => encodeAnyToJson(e, depth))
           .getOrElse(Json.Null)
       case d: Date           => Encoder.encodeString.apply(d.toInstant.toString)
       case d: DateTime       => Encoder.encodeString.apply(d.toInstant.toString)
+      case d: Duration       => Json.fromString(d.toString)
       case o: ObjectId       => Encoder.encodeString.apply(o.toHexString)
       case m: Map[String, _] => encodeMapStringAny(m)
       case seq: Seq[_] =>
         Json.arr(
-          seq.map(
-            e => encodeAnyToJson(e, deepth)
-          ): _*
+          seq.map(e => encodeAnyToJson(e, depth)): _*
         )
       case set: Set[_] =>
         Json.arr(
           set
-            .map(
-              e => encodeAnyToJson(e, deepth)
-            )
+            .map(e => encodeAnyToJson(e, depth))
             .toList: _*
         )
       case product: Product =>
         val productElementKeys = productElementNames(product).toList
         val fieldMap = productElementKeys
-          .map(
-            key => {
-              val index = productElementKeys.indexOf(key)
-              (key, product.productElement(index))
-            }
-          )
+          .map(key => {
+            val index = productElementKeys.indexOf(key)
+            (key, product.productElement(index))
+          })
           .toMap
         encodeAnyToJson(fieldMap)
       case r: Document => encodeAnyToJson(r.toMap)
       case any: Any =>
-        if (deepth < 256) {
-          encodeAnyToJson(any, deepth + 1)
-        }
-        else {
+        if (depth < 256) {
+          encodeAnyToJson(any, depth + 1)
+        } else {
           Json.Null
         }
       case _ =>
         Json.Null
     }
   }
 
-}
+}