feat: use circe scheme to convert documents to objects

Author: QuadStingray

src/main/scala/dev/mongocamp/driver/mongodb/MongoDAO.scala

@@ -18,7 +18,7 @@ import java.nio.charset.Charset
 import java.util.Date
 import scala.collection.mutable.ArrayBuffer
 import scala.reflect.ClassTag
-
+import dev.mongocamp.driver.mongodb.schema.JsonConverter._
 /** Created by tom on 20.01.17.
   */
 abstract class MongoDAO[A](provider: DatabaseProvider, collectionName: String)(implicit ct: ClassTag[A], decoder: Decoder[A]) extends Crud[A] {

src/main/scala/dev/mongocamp/driver/mongodb/bson/AbstractConverterPlugin.scala

@@ -0,0 +1,26 @@
+package dev.mongocamp.driver.mongodb.bson
+
+import org.bson.BsonValue
+import org.mongodb.scala.bson.BsonNull
+
+abstract class AbstractConverterPlugin {
+
+  def customClassList: List[Class[_]] = {
+    List()
+  }
+
+  def hasCustomClass(v: Any): Boolean = {
+    customClassList.exists(c => c.isAssignableFrom(v.getClass))
+  }
+
+  def objectToBson(value: AnyRef): BsonValue = {
+    val map: Map[String, Any] = ClassUtil.membersToMap(value)
+    BsonConverter.toBson(map)
+  }
+
+  def toBson(value: Any): BsonValue =
+    value match {
+      case _ =>
+        BsonNull()
+    }
+}

src/main/scala/dev/mongocamp/driver/mongodb/bson/BaseConverterPlugin.scala

@@ -0,0 +1,3 @@
+package dev.mongocamp.driver.mongodb.bson
+
+class BaseConverterPlugin extends AbstractConverterPlugin

…river/mongodb/bson/ConverterPlugin.scala …camp/driver/mongodb/bson/ClassUtil.scalasrc/main/scala/dev/mongocamp/driver/mongodb/bson/ConverterPlugin.scala renamed to src/main/scala/dev/mongocamp/driver/mongodb/bson/ClassUtil.scala src/main/scala/dev/mongocamp/driver/mongodb/bson/ConverterPlugin.scala renamed to src/main/scala/dev/mongocamp/driver/mongodb/bson/ClassUtil.scala

@@ -1,33 +1,8 @@
 package dev.mongocamp.driver.mongodb.bson
 
 import java.lang.reflect.Field
-
-import org.bson.BsonValue
-import org.mongodb.scala.bson.BsonNull
-
 import scala.collection.mutable
 
-class BaseConverterPlugin extends AbstractConverterPlugin
-
-abstract class AbstractConverterPlugin {
-
-  def customClassList: List[Class[_]] = List()
-
-  def hasCustomClass(v: Any): Boolean =
-    customClassList.exists(c => c.isAssignableFrom(v.getClass))
-
-  def objectToBson(value: AnyRef): BsonValue = {
-    val map: Map[String, Any] = ClassUtil.membersToMap(value)
-    BsonConverter.toBson(map)
-  }
-
-  def toBson(value: Any): BsonValue =
-    value match {
-      case _ =>
-        BsonNull()
-    }
-}
-
 object ClassUtil {
   private val classRegistry =
     new mutable.HashMap[Class[_], Map[String, Field]]()

src/main/scala/dev/mongocamp/driver/mongodb/database/ChangeObserver.scala

@@ -8,11 +8,13 @@ case class ChangeObserver[A](onChangeCallback: ChangeStreamDocument[A] => Unit)
 
   override def onSubscribe(subscription: Subscription): Unit = subscription.request(Long.MaxValue) // Request data
 
-  override def onNext(changeDocument: ChangeStreamDocument[A]): Unit =
+  override def onNext(changeDocument: ChangeStreamDocument[A]): Unit = {
     onChangeCallback(changeDocument)
+  }
 
-  override def onError(throwable: Throwable): Unit =
+  override def onError(throwable: Throwable): Unit = {
     logger.error(throwable.getMessage, throwable)
+  }
 
   override def onComplete(): Unit = {}
 

src/main/scala/dev/mongocamp/driver/mongodb/database/DatabaseProvider.scala

@@ -1,10 +1,7 @@
 package dev.mongocamp.driver.mongodb.database
 
 import dev.mongocamp.driver.mongodb._
-import dev.mongocamp.driver.mongodb.bson.codecs.CustomCodecProvider
-import org.bson.codecs.configuration.CodecRegistries.{ fromProviders, fromRegistries }
-import org.bson.codecs.configuration.CodecRegistry
-import org.mongodb.scala.MongoClient.DEFAULT_CODEC_REGISTRY
+import dev.mongocamp.driver.mongodb.schema.JsonConverter._
 import org.mongodb.scala._
 import org.mongodb.scala.gridfs.GridFSBucket
 

src/main/scala/dev/mongocamp/driver/mongodb/gridfs/Metadata.scala

@@ -10,6 +10,7 @@ import org.mongodb.scala.model.Filters.equal
 import org.mongodb.scala.model.Updates._
 import org.mongodb.scala.result.UpdateResult
 import org.mongodb.scala.{ Document, Observable }
+import dev.mongocamp.driver.mongodb.schema.JsonConverter._
 
 abstract class Metadata(provider: DatabaseProvider, bucketName: String) extends Crud {
 

src/main/scala/dev/mongocamp/driver/mongodb/operation/Base.scala

@@ -3,37 +3,32 @@ package dev.mongocamp.driver.mongodb.operation
 import com.typesafe.scalalogging.LazyLogging
 import dev.mongocamp.driver.mongodb.bson.BsonConverter
 import dev.mongocamp.driver.mongodb.database.MongoIndex
-import dev.mongocamp.driver.mongodb.schema.{ CirceSchema, JsonConverter }
+import dev.mongocamp.driver.mongodb.schema.CirceSchema
+import io.circe.Decoder
+import io.circe.jawn.decode
+import io.circe.syntax._
 import org.mongodb.scala.bson.conversions.Bson
 import org.mongodb.scala.model.Sorts._
 import org.mongodb.scala.model.{ CountOptions, DropIndexOptions, IndexOptions, Indexes }
 import org.mongodb.scala.{ Document, ListIndexesObservable, MongoCollection, Observable, SingleObservable }
 
 import scala.collection.mutable
-import scala.concurrent.duration.Duration
-import scala.concurrent.duration.durationToPair
+import scala.concurrent.duration.{ durationToPair, Duration }
 import scala.reflect.ClassTag
-import io.circe.generic.auto._
-import io.circe.syntax._
-import better.files.Resource
-import io.circe.{ Decoder, HCursor }
-import io.circe.jawn.decode
-import io.circe.syntax._
-import io.circe.generic.auto._
 
-abstract class Base[A](implicit classTag: ClassTag[A]) extends LazyLogging {
-  def jsonConverter = new JsonConverter()
-  def documentToObject[A](document: Document)(implicit decoder: Decoder[A]): A = {
+abstract class Base[A](implicit classTag: ClassTag[A]) extends LazyLogging with CirceSchema {
+  def documentToObject[A](document: Document, decoder: Decoder[A]): A = {
     if (classTag.runtimeClass == classOf[Document]) {
       document.asInstanceOf[A]
     }
     else {
-      val helperMap = mutable.Map[String, Any]()
-      document.keys.foreach(k => helperMap.put(k, BsonConverter.fromBson(document(k))))
-      val jsonString = jsonConverter.toJson(helperMap)
-      val response   = jsonConverter.toObject(jsonString)
-//      val decoder         = converter.decodeString[A](jsonString)
-      response
+      val helperMap = BsonConverter.asMap(document)
+      val jsonString = helperMap.asJson.noSpaces
+      val response   = decode[A](jsonString)(decoder)
+      if (response.isLeft) {
+        logger.error(s"Error decoding document to object: ${response.swap.getOrElse("")}")
+      }
+      response.getOrElse(null.asInstanceOf[A])
     }
   }
 

src/main/scala/dev/mongocamp/driver/mongodb/operation/Crud.scala

@@ -3,6 +3,7 @@ package dev.mongocamp.driver.mongodb.operation
 import dev.mongocamp.driver.mongodb.database.DatabaseProvider
 import dev.mongocamp.driver.mongodb.sync.MongoSyncOperation
 import dev.mongocamp.driver.mongodb.{ Converter, _ }
+import io.circe.Decoder
 import org.mongodb.scala.bson.conversions.Bson
 import org.mongodb.scala.model.Filters._
 import org.mongodb.scala.model.Updates._
@@ -14,7 +15,7 @@ import java.util.Date
 import scala.collection.mutable.ArrayBuffer
 import scala.reflect.ClassTag
 
-abstract class Crud[A]()(implicit ct: ClassTag[A]) extends Search[A] {
+abstract class Crud[A]()(implicit ct: ClassTag[A], decoder: Decoder[A]) extends Search[A] {
 
   // create
   def insertOne(value: A): Observable[InsertOneResult] = {

src/main/scala/dev/mongocamp/driver/mongodb/operation/Search.scala

@@ -1,20 +1,18 @@
 package dev.mongocamp.driver.mongodb.operation
 
 import dev.mongocamp.driver.mongodb._
-import dev.mongocamp.driver.mongodb.bson.BsonConverter
 import dev.mongocamp.driver.mongodb.bson.BsonConverter._
 import dev.mongocamp.driver.mongodb.database.DatabaseProvider
-import io.circe.Decoder.Result
-import io.circe.{ Decoder, HCursor }
+import io.circe.Decoder
 import org.bson.BsonValue
 import org.mongodb.scala.bson.ObjectId
 import org.mongodb.scala.bson.conversions.Bson
 import org.mongodb.scala.model.Filters._
-import org.mongodb.scala.{ AggregateObservable, DistinctObservable, Document, FindObservable, MongoCollection, Observable }
+import org.mongodb.scala.{ DistinctObservable, Document, MongoCollection, Observable }
 
 import scala.reflect.ClassTag
 
-abstract class Search[A]()(implicit ct: ClassTag[A]) extends Base[A] {
+abstract class Search[A]()(implicit ct: ClassTag[A], decoder: Decoder[A]) extends Base[A] {
 
   protected def coll: MongoCollection[Document]
 
@@ -23,7 +21,7 @@ abstract class Search[A]()(implicit ct: ClassTag[A]) extends Base[A] {
       sort: Bson = Document(),
       projection: Bson = Document(),
       limit: Int = 0
-  )(implicit decoder: Decoder[A]): Observable[A] = {
+  ): Observable[A] = {
     val findObservable = {
       if (limit > 0) {
         coll.find(filter).sort(sort).projection(projection).limit(limit)
@@ -32,14 +30,14 @@ abstract class Search[A]()(implicit ct: ClassTag[A]) extends Base[A] {
         coll.find(filter).sort(sort).projection(projection)
       }
     }
-    findObservable.map(doc => documentToObject[A](doc))
+    findObservable.map(doc => documentToObject[A](doc, decoder))
   }
 
-  def findById(oid: ObjectId)(implicit decoder: Decoder[A]): Observable[A] = {
+  def findById(oid: ObjectId): Observable[A] = {
     find(equal(DatabaseProvider.ObjectIdKey, oid))
   }
 
-  def find(name: String, value: Any)(implicit decoder: Decoder[A]): Observable[A] = {
+  def find(name: String, value: Any): Observable[A] = {
     find(equal(name, value))
   }
 
@@ -51,13 +49,13 @@ abstract class Search[A]()(implicit ct: ClassTag[A]) extends Base[A] {
     distinct(fieldName, filter).resultList().map(v => fromBson(v).asInstanceOf[S])
   }
 
-  def findAggregated(pipeline: Seq[Bson], allowDiskUse: Boolean = false)(implicit decoder: Decoder[A]): Observable[A] = {
+  def findAggregated(pipeline: Seq[Bson], allowDiskUse: Boolean = false): Observable[A] = {
     val aggregateObservable = coll.aggregate(pipeline).allowDiskUse(allowDiskUse)
     aggregateObservable.map {
       case a: A =>
         a
       case doc =>
-        documentToObject[A](doc)
+        documentToObject[A](doc, decoder)
     }
   }