feat: enhance JSON conversion with support for case classes, add new tests, and update dependencies

- Improved `JsonConverter` to handle case classes and drop null values.
- Added `JsonConversionSuite` for comprehensive JSON conversion tests.
- Updated to Scala 3.7.0 and refined `scalacOptions`.
- Introduced new imports and utilities for enhanced JSON handling.

Author: QuadStingray

build.sbt

@@ -20,11 +20,12 @@ developers := List(
 
 licenses += ("Apache-2.0", url("https://www.apache.org/licenses/LICENSE-2.0.html"))
 
-crossScalaVersions := Seq("3.6.4", "2.13.16")
+crossScalaVersions := Seq("3.7.0", "2.13.16")
 
 scalaVersion := crossScalaVersions.value.head
 
-scalacOptions += "-deprecation"
+scalacOptions ++= Seq("-deprecation")
+//scalacOptions ++= Seq("--Xmax-inlines", "128")
 
 Test / parallelExecution := false
 

src/main/scala/dev/mongocamp/driver/mongodb/jdbc/MongoJdbcConnection.scala

@@ -1,8 +1,16 @@
 package dev.mongocamp.driver.mongodb.jdbc
 
+import com.mongodb.event.CommandListener
+import com.mongodb.event.ConnectionPoolListener
 import dev.mongocamp.driver.mongodb.bson.BsonConverter
 import dev.mongocamp.driver.mongodb.database.DatabaseProvider
+import dev.mongocamp.driver.mongodb.database.MongoConfig.DefaultApplicationName
+import dev.mongocamp.driver.mongodb.database.MongoConfig.DefaultAuthenticationDatabaseName
+import dev.mongocamp.driver.mongodb.database.MongoConfig.DefaultHost
+import dev.mongocamp.driver.mongodb.database.MongoConfig.DefaultPort
+import dev.mongocamp.driver.mongodb.database.MongoPoolOptions
 import dev.mongocamp.driver.mongodb.jdbc.statement.MongoPreparedStatement
+import dev.mongocamp.driver.mongodb.json._
 import dev.mongocamp.driver.mongodb.json.JsonConverter
 import java.sql
 import java.sql.Blob
@@ -22,6 +30,8 @@ import java.util
 import java.util.concurrent.Executor
 import java.util.Properties
 import org.mongodb.scala.bson.collection.immutable.Document
+import org.mongodb.scala.MongoClientSettings
+import org.mongodb.scala.ServerAddress
 import scala.jdk.CollectionConverters._
 
 class MongoJdbcConnection(databaseProvider: DatabaseProvider) extends Connection with MongoJdbcCloseable {
@@ -234,11 +244,50 @@ class MongoJdbcConnection(databaseProvider: DatabaseProvider) extends Connection
   override def getClientInfo: Properties = {
     val properties = new Properties()
     properties.setProperty("ApplicationName", databaseProvider.config.applicationName)
-    val document = Document(new JsonConverter().toJson(databaseProvider.config))
+    case class MongoConfigHelper(
+      database: String,
+      host: String = DefaultHost,
+      port: Int = DefaultPort,
+      var applicationName: String = DefaultApplicationName,
+      userName: Option[String] = None,
+      password: Option[String] = None,
+      authDatabase: String = DefaultAuthenticationDatabaseName,
+      poolOptions: MongoPoolOptions = MongoPoolOptions(),
+      compressors: List[String] = List.empty,
+      connectionPoolListener: List[String] = List.empty,
+      commandListener: List[String] = List.empty,
+      customClientSettings: Option[String] = None,
+      serverAddressList: List[String] = List.empty
+    )
+    val logConfig = Option(databaseProvider.config)
+      .map(
+        c =>
+          MongoConfigHelper(
+            c.database,
+            c.host,
+            c.port,
+            c.applicationName,
+            c.userName,
+            c.password,
+            c.authDatabase,
+            c.poolOptions,
+            c.compressors,
+            c.connectionPoolListener.map(_.toString),
+            c.commandListener.map(_.toString),
+            c.customClientSettings.map(_.toString),
+            c.serverAddressList.map(_.toString)
+          )
+      )
+      .get
+    val document = Document(new JsonConverter().toJson(logConfig))
     BsonConverter
       .asMap(document)
       .foreach(
-        entry => properties.setProperty(entry._1, entry._2.toString)
+        entry => {
+          if (entry._2 != null) {
+            properties.setProperty(entry._1, entry._2.toString)
+          }
+        }
       )
     properties
   }

src/main/scala/dev/mongocamp/driver/mongodb/jdbc/statement/MongoPreparedStatement.scala

@@ -5,6 +5,7 @@ import dev.mongocamp.driver.mongodb.exception.SqlCommandNotSupportedException
 import dev.mongocamp.driver.mongodb.jdbc.resultSet.MongoDbResultSet
 import dev.mongocamp.driver.mongodb.jdbc.MongoJdbcCloseable
 import dev.mongocamp.driver.mongodb.jdbc.MongoJdbcConnection
+import dev.mongocamp.driver.mongodb.json._
 import dev.mongocamp.driver.mongodb.json.JsonConverter
 import dev.mongocamp.driver.mongodb.sql.MongoSqlQueryHolder
 import dev.mongocamp.driver.mongodb.Converter
@@ -249,7 +250,8 @@ case class MongoPreparedStatement(connection: MongoJdbcConnection) extends Calla
         parameters.put(parameterIndex, s"'${t.toInstant.toString}'")
       case a: Array[Byte] =>
         parameters.put(parameterIndex, new JsonConverter().toJson(a))
-      case a: Iterable[_] =>
+      case a: Iterable[Any] =>
+        import dev.mongocamp.driver.mongodb.json._
         parameters.put(parameterIndex, new JsonConverter().toJson(a))
       case _ =>
         parameters.put(parameterIndex, x.toString)

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

@@ -1,14 +1,21 @@
 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 extends CirceSchema {
+class JsonConverter(dropNullValues: Boolean = false) extends CirceSchema with LazyLogging {
 
-  def toJson(s: Any): String = {
-    s.asJson.noSpaces
+  def toJson[A <: Any](s: A)(implicit encoder: Encoder[A]): String = {
+    if (dropNullValues) {
+      s.asJson.deepDropNullValues.noSpaces
+    }
+    else {
+      s.asJson.noSpaces
+    }
   }
 
   def readJsonMap(fileContent: String): Map[String, Any] = {
@@ -22,7 +29,11 @@ class JsonConverter extends CirceSchema {
   }
 
   def toObject[A](jsonString: String)(implicit decoder: Decoder[A]): A = {
-    decode[A](jsonString).getOrElse(null.asInstanceOf[A])
+    val decodeResponse = decode[A](jsonString)
+    if (decodeResponse.isLeft) {
+      logger.warn(s"Error while decoding json: ${decodeResponse.left.get}")
+    }
+    decodeResponse.getOrElse(null.asInstanceOf[A])
   }
 
 }

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

@@ -0,0 +1,4 @@
+package dev.mongocamp.driver.mongodb
+import io.circe.generic.AutoDerivation
+
+package object json extends CirceSchema with AutoDerivation {}

src/main/scala/dev/mongocamp/driver/mongodb/schema/JsonSchema.scala

@@ -1,5 +1,6 @@
 package dev.mongocamp.driver.mongodb.schema
 
+import dev.mongocamp.driver.mongodb.json._
 import dev.mongocamp.driver.mongodb.json.JsonConverter
 
 case class JsonSchema(`$schema`: String, `$ref`: String, definitions: Map[String, JsonSchemaDefinition]) {

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

@@ -0,0 +1,38 @@
+package dev.mongocamp.driver.mongodb.json
+
+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()
+
+  test("Convert to List to Json") {
+    assertEquals(jsonConverter.toJson(Array(1, 2)), "[1,2]")
+    assertEquals(jsonConverter.toJson(List[Int]()), "[]")
+    assertEquals(jsonConverter.toJson(List("hallo", "Welt")), "[\"hallo\",\"Welt\"]")
+    assertEquals(jsonConverter.toJson(List(1, 2)), "[1,2]")
+    assertEquals(jsonConverter.toJson(Array.empty[String]), "[]")
+    assertEquals(jsonConverter.toJson(Array("hallo", "Welt")), "[\"hallo\",\"Welt\"]")
+  }
+
+  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\"}")
+    val jString: String = jsonConverter.toJson(HelloWorld2("servus", "welt", Option(HelloWorld("hello", "world")), List(1, 2, 3, 4, 5)))
+    assertEquals(jString, "{\"greetings\":\"servus\",\"name\":\"welt\",\"option\":{\"greetings\":\"hello\",\"name\":\"world\"},\"subClass\":[1,2,3,4,5]}")
+    val jString2: String = jsonConverter.toJson(HelloWorld2("servus", "welt", None, List.empty))
+    assertEquals(jString2, "{\"greetings\":\"servus\",\"name\":\"welt\",\"option\":null,\"subClass\":[]}")
+  }
+
+  test("Convert to Json to List") {
+    assertEquals(jsonConverter.toObject[List[String]]("[]"), List())
+    assertEquals(jsonConverter.toObject[List[String]]("[\"hallo\",\"Welt\"]"), List("hallo", "Welt"))
+    assertEquals(jsonConverter.toObject[List[Int]]("[1,2]"), List(1, 2))
+    assertEquals(jsonConverter.toObject[Array[String]]("[\"hallo\",\"Welt\"]").last, Array("hallo", "Welt").last)
+    assertEquals(jsonConverter.toObject[Array[Int]]("[1,2]").last, Array(1, 2).last)
+  }
+
+  test("Convert Json to Case Class") {
+    assertEquals(jsonConverter.toObject[HelloWorld]("{\"name\":\"world\", \"greetings\":\"hello\"}"), HelloWorld("hello", "world"))
+  }
+}