refactor: improve JsonConverter and CirceSchema methods

- Renamed variables in `toJson` and `toObject` methods for clarity in `JsonConverter`.
- Enhanced `encodeAnyToJson` in `CirceSchema` to handle `Option` types directly.

Author: QuadStingray

build.sbt

@@ -20,7 +20,7 @@ developers := List(
 
 licenses += ("Apache-2.0", url("https://www.apache.org/licenses/LICENSE-2.0.html"))
 
-crossScalaVersions := Seq("3.7.0", "2.13.16")
+crossScalaVersions := Seq("3.7.2", "2.13.16")
 
 scalaVersion := crossScalaVersions.value.last
 

package.json

@@ -1,7 +1,7 @@
 {
   "name" : "mongodb-driver",
   "organization" : "dev.mongocamp",
-  "version" : "3.0.8.snapshot",
+  "version" : "3.0.8",
   "author" : "[email protected]",
   "license" : "Apache-2.0",
   "type" : "module",

project/build.properties

@@ -1 +1 @@
-sbt.version=1.11.2
+sbt.version=1.11.5

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

@@ -127,7 +127,10 @@ trait CirceSchema extends CirceProductSchema {
   }
 
   implicit val AnyFormat: Encoder[Any] with io.circe.Decoder[Any] = new io.circe.Encoder[Any] with io.circe.Decoder[Any] {
-    override def apply(a: Any): Json = encodeAnyToJson(a)
+
+    override def apply(a: Any): Json = {
+      encodeAnyToJson(a)
+    }
 
     override def apply(c: HCursor): Result[Any] = {
       Decoder.decodeJson
@@ -136,6 +139,7 @@ trait CirceSchema extends CirceProductSchema {
         )
         .apply(c)
     }
+
   }
 
   def encodeMapStringAny(a: Map[String, Any]): Json = {
@@ -189,14 +193,20 @@ trait CirceSchema extends CirceProductSchema {
 
   def encodeAnyToJson(a: Any, deepth: Int = 0): Json = {
     a match {
-      case s: String         => Json.fromString(s)
-      case b: Boolean        => Json.fromBoolean(b)
-      case l: Long           => Json.fromLong(l)
-      case i: Int            => Json.fromInt(i)
-      case bi: BigInt        => Json.fromBigInt(bi)
-      case bd: BigDecimal    => Json.fromBigDecimal(bd)
-      case d: Double         => Json.fromDoubleOrNull(d)
-      case f: Float          => Json.fromFloatOrNull(f)
+      case s: String      => Json.fromString(s)
+      case b: Boolean     => Json.fromBoolean(b)
+      case l: Long        => Json.fromLong(l)
+      case i: Int         => Json.fromInt(i)
+      case bi: BigInt     => Json.fromBigInt(bi)
+      case bd: BigDecimal => Json.fromBigDecimal(bd)
+      case d: Double      => Json.fromDoubleOrNull(d)
+      case f: Float       => Json.fromFloatOrNull(f)
+      case option: Option[_] =>
+        option
+          .map(
+            e => encodeAnyToJson(e, deepth)
+          )
+          .getOrElse(Json.Null)
       case d: Date           => Encoder.encodeString.apply(d.toInstant.toString)
       case d: DateTime       => Encoder.encodeString.apply(d.toInstant.toString)
       case o: ObjectId       => Encoder.encodeString.apply(o.toHexString)

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

@@ -3,18 +3,18 @@ package dev.mongocamp.driver.mongodb.json
 import better.files.Resource
 import com.typesafe.scalalogging.LazyLogging
 import io.circe.jawn.decode
-import io.circe.syntax._
 import io.circe.Decoder
 import io.circe.Encoder
 
 class JsonConverter(dropNullValues: Boolean = false, defaultShouldLogAsError: Boolean = false) extends CirceSchema with LazyLogging {
 
-  def toJson[A <: Any](s: A)(implicit encoder: Encoder[A]): String = {
+  def toJson[A <: Any](a: A)(implicit encoder: Encoder[A]): String = {
+    import io.circe.syntax._
     if (dropNullValues) {
-      s.asJson.deepDropNullValues.noSpaces
+      a.asJson.deepDropNullValues.noSpaces
     }
     else {
-      s.asJson.noSpaces
+      a.asJson.noSpaces
     }
   }
 
@@ -37,14 +37,14 @@ class JsonConverter(dropNullValues: Boolean = false, defaultShouldLogAsError: Bo
     toObjectOption[A](jsonString, defaultShouldLogAsError).getOrElse(null.asInstanceOf[A])
   }
 
-  def toObject[A](jsonString: String, shouldLogError: Boolean = defaultShouldLogAsError)(implicit decoder: Decoder[A]): A = {
-    toObjectOption[A](jsonString, shouldLogError).getOrElse(null.asInstanceOf[A])
+  def toObject[A](jsonString: String, shouldLogAsError: Boolean = defaultShouldLogAsError)(implicit decoder: Decoder[A]): A = {
+    toObjectOption[A](jsonString, shouldLogAsError).getOrElse(null.asInstanceOf[A])
   }
 
-  def toObjectOption[A](jsonString: String, shouldLogError: Boolean = defaultShouldLogAsError)(implicit decoder: Decoder[A]): Option[A] = {
+  def toObjectOption[A](jsonString: String, shouldLogAsError: Boolean = defaultShouldLogAsError)(implicit decoder: Decoder[A]): Option[A] = {
     val decodeResponse = toObjectRaw[A](jsonString)
     if (decodeResponse.isLeft) {
-      if (shouldLogError) {
+      if (shouldLogAsError) {
         logger.error(s"Error while decoding json: ${decodeResponse.left}")
       }
       else {

src/test/scala/dev/mongocamp/driver/mongodb/json/JsonConversionSuite.scala

@@ -1,14 +1,14 @@
 package dev.mongocamp.driver.mongodb.json
-import io.circe.ACursor
-import io.circe.DecodingFailure
+import dev.mongocamp.driver.mongodb.json.model.FooBar
+import dev.mongocamp.driver.mongodb.json.model.HelloWorld
+import dev.mongocamp.driver.mongodb.json.model.HelloWorld2
+import dev.mongocamp.driver.mongodb.json.model.HelloWorld3
 import io.circe.ParsingFailure
 import org.typelevel.jawn.IncompleteParseException
 
-case class HelloWorld(greetings: String, name: String)
-case class HelloWorld2(greetings: String, name: String, option: Option[HelloWorld], subClass: List[Long])
-
 class JsonConversionSuite extends munit.FunSuite {
-  protected lazy val jsonConverter = new JsonConverter()
+  protected lazy val jsonConverter     = new JsonConverter()
+  protected lazy val dropNullConverter = new JsonConverter(dropNullValues = true)
 
   test("Convert to List to Json") {
     assertEquals(jsonConverter.toJson(Array(1, 2)), "[1,2]")
@@ -19,6 +19,22 @@ class JsonConversionSuite extends munit.FunSuite {
     assertEquals(jsonConverter.toJson(Array("hallo", "Welt")), "[\"hallo\",\"Welt\"]")
   }
 
+  test("Convert Case Class with Any to Json") {
+    val isScala3 = scala.util.Properties.versionNumberString.startsWith("3.")
+    val jString3: String = if (isScala3) {
+      jsonConverter.toJson(HelloWorld3("servus", "welt"))
+    }
+    else {
+      jsonConverter.toJson(HelloWorld3("servus", "welt").asInstanceOf[Any])
+    }
+    assertEquals(jString3, "{\"greetings\":\"servus\",\"name\":\"welt\"}")
+  }
+
+  test("Convert Json to Case Class with Option using anyFormat") {
+    assertEquals(jsonConverter.toJson(FooBar()), "{\"foo\":null,\"bar\":null}")
+    assertEquals(dropNullConverter.toJson(FooBar()), "{}")
+  }
+
   test("Convert Case Class to Json") {
     assertEquals(jsonConverter.toJson(HelloWorld("hello", "world")), "{\"greetings\":\"hello\",\"name\":\"world\"}")
     assertEquals(jsonConverter.toJson(HelloWorld("servus", "welt")), "{\"greetings\":\"servus\",\"name\":\"welt\"}")

src/test/scala/dev/mongocamp/driver/mongodb/json/model/FooBar.scala

@@ -0,0 +1,3 @@
+package dev.mongocamp.driver.mongodb.json.model
+
+case class FooBar(foo: Option[String] = None, bar: Option[Long] = None)

src/test/scala/dev/mongocamp/driver/mongodb/json/model/HelloWorld.scala

@@ -0,0 +1,3 @@
+package dev.mongocamp.driver.mongodb.json.model
+
+case class HelloWorld(greetings: String, name: String)

src/test/scala/dev/mongocamp/driver/mongodb/json/model/HelloWorld2.scala

@@ -0,0 +1,3 @@
+package dev.mongocamp.driver.mongodb.json.model
+
+case class HelloWorld2(greetings: String, name: String, option: Option[HelloWorld], subClass: List[Long])

src/test/scala/dev/mongocamp/driver/mongodb/json/model/HelloWorld3.scala

@@ -0,0 +1,3 @@
+package dev.mongocamp.driver.mongodb.json.model
+
+case class HelloWorld3(greetings: String, name: Any)