Question: mongodb-scala-driver example?

[vilinski]

I'm not familiar with shapeless. What you mean if you say you library is usable with scala driver?
Could you provide an example how to use it?
And whether the ADTs, traits or enumerations are supported? Sorry if asked too much

[a14e]

@vilinski Good day! This library is useful if you don't like default serialization in mongo scala driver =)

• Yes, you can use ADTs via BsonEncoder.switch, but you should manually specify decoding/encoding key

trait Shape
case class Circle(r: Double) extends Shape
case class Rectangle(a: Double) extends Shape

implicit val decoder: BsonDecoder[Shape] = {
    BsonDecoder.switch[String, Shape]("type")(
      "circle" -> BsonDecoder.derived[Circle](),
      "rectangle" -> BsonDecoder.derived[Rectangle]()
    )
  }

implicit val encoder: BsonEncoder[Shape] = {
    import a14e.bson.auto._
    BsonEncoder.switch[String, Shape]("type")(
      "circle" -> BsonEncoder.derived[Circle](),
      "rectangle" -> BsonEncoder.derived[Rectangle]()
    )
  }

• Yes, enums are supported via reflection (in similar way with Ficus but with caching):

object SizeType extends Enumeration {
    type SizeType = Value
    val Big = Value("BIG")
    val Small = Value("SMALL")
}

import a14e.bson._
import a14e.bson.auto.enumUnsafe._
// Encoding
SizeType.Big.asBson // == "BIG"
// Decoding
SizeType.Big.asBson.as[SizeType.SizeType] // == "BIG"

• And finally full example with ADTs, enums and Mongo Scala Driver is listed below:

in build.sbt

libraryDependencies ++= Seq(
  "com.github.a14e" %% "mongoless" % "0.3.00",
  "org.mongodb.scala" %% "mongo-scala-driver" % "2.4.0"
)

Example.scala

import scala.concurrent.Await
import scala.concurrent.duration.Duration
import scala.concurrent.ExecutionContext.Implicits.global

import org.bson.BsonValue
import org.mongodb.scala._

import a14e.bson._
import a14e.bson.auto._
import a14e.bson.auto.enumUnsafe._
import a14e.bson.decoder.BsonDecoder
import a14e.bson.encoder.BsonEncoder

import Gender.Gender

case class Director(id: ID[String],
                    name: String,
                    gender: Gender,
                    subordinates: Seq[Subordinate])

trait Subordinate

case class Manager(name: String,
                   gender: Gender,
                   salary: BigDecimal) extends Subordinate

case class Clerk(name: String,
                 gender: Gender,
                 salary: BigDecimal) extends Subordinate


object Gender extends Enumeration {
  type Gender = Value
  val Male = Value("Male")
  val Female = Value("Female")
}


object Application extends App {

  implicit val subordinateEncoder: BsonEncoder[Subordinate] = BsonEncoder.switch[String, Subordinate]("type")(
    "Manager" -> BsonEncoder.derived[Manager](),
    "Clerk" -> BsonEncoder.derived[Clerk]()
  )

  implicit val subordinateDecoder: BsonDecoder[Subordinate] = BsonDecoder.switch[String, Subordinate]("type")(
    "Manager" -> BsonDecoder.derived[Manager](),
    "Clerk" -> BsonDecoder.derived[Clerk]()
  )

  val mongoClient: MongoClient = MongoClient()
  val database: MongoDatabase = mongoClient.getDatabase("test")
  val collection = database.getCollection[BsonValue]("directors")


  val director = Director(
    id = "123",
    name = "Director Name",
    gender = Gender.Male,
    subordinates = Seq(
      Manager(
        name = "Manager name",
        gender = Gender.Female,
        salary = 123
      ),
      Clerk(
        name = "Clerk name",
        gender = Gender.Male,
        salary = 456
      )
    )
  )


  val insertRes = collection.insertOne(director.asBson).toFuture()
  Await.result(insertRes, Duration.Inf)

  val findFuture = collection.find(Bson.obj("_id" -> "123"))
    .toFuture()
    .map(_.flatMap(_.asOpt[Director]))
  val res = Await.result(findFuture, Duration.Inf)
  println(res)
}