MongoPolyDataCompanion

Author: Roman Janusz

commons-macros/src/main/scala/com/avsystem/commons/macros/serialization/MongoMacros.scala

@@ -14,6 +14,7 @@ class MongoMacros(ctx: blackbox.Context) extends CodecMacroCommons(ctx) {
   lazy val MapApplySym: Symbol = typeOf[scala.collection.Map[Any, Any]].member(TermName("apply"))
   lazy val TypedMapApplySym: Symbol = getType(tq"$MiscPkg.TypedMap[$ScalaPkg.Any]").member(TermName("apply"))
   lazy val AdtAsSym: Symbol = getType(tq"$MongoTypedPkg.AbstractMongoDataCompanion[Any, Any]#macroDslExtensions").member(TermName("as"))
+  lazy val PolyAdtAsSym: Symbol = getType(tq"$MongoTypedPkg.AbstractMongoPolyDataCompanion[Any, Any]#macroDslExtensions").member(TermName("as"))
 
   // check if some symbol is an abstract method of a sealed trait/class implemented in every case class
   // by a field with exactly the same type
@@ -52,7 +53,8 @@ class MongoMacros(ctx: blackbox.Context) extends CodecMacroCommons(ctx) {
         case body: Ident if body.symbol == param.symbol =>
           c.prefix.tree
 
-        case TypeApply(Select(Apply(_, List(prefix)), TermName("as")), List(subtpe)) if body.symbol == AdtAsSym =>
+        case TypeApply(Select(Apply(_, List(prefix)), TermName("as")), List(subtpe))
+          if body.symbol == AdtAsSym || body.symbol == PolyAdtAsSym =>
           q"${extractRefStep(prefix)}.as[$subtpe]"
 
         case Select(prefix, name: TermName) =>

commons-mongo/jvm/src/main/scala/com/avsystem/commons/mongo/typed/MongoEntityCompanion.scala

@@ -4,7 +4,7 @@ package mongo.typed
 import com.avsystem.commons.annotation.explicitGenerics
 import com.avsystem.commons.meta.MacroInstances
 import com.avsystem.commons.mongo.BsonGenCodecs
-import com.avsystem.commons.serialization.GenObjectCodec
+import com.avsystem.commons.serialization.{GenCodec, GenObjectCodec}
 
 import scala.annotation.{compileTimeOnly, implicitNotFound}
 
@@ -13,6 +13,14 @@ trait MongoAdtInstances[T] {
   def format: MongoAdtFormat[T]
 }
 
+trait MongoPolyAdtInstances[D[_]] {
+  // needed by MongoAdtFormat.materialize for generic type
+  protected final implicit def codecFromFormat[T: MongoFormat]: GenCodec[T] = MongoFormat[T].codec
+
+  def codec[T: GenCodec]: GenObjectCodec[D[T]]
+  def format[T: MongoFormat]: MongoAdtFormat[D[T]]
+}
+
 trait MongoEntityInstances[E <: BaseMongoEntity] extends MongoAdtInstances[E] {
   def meta: MongoEntityMeta[E]
 }
@@ -47,6 +55,25 @@ abstract class AbstractMongoDataCompanion[Implicits, E](implicits: Implicits)(
   implicit val format: MongoAdtFormat[E] = instances(implicits, this).format
 }
 
+abstract class AbstractMongoPolyDataCompanion[Implicits, D[_]](implicits: Implicits)(
+  implicit instances: MacroInstances[Implicits, MongoPolyAdtInstances[D]]
+) {
+  implicit def codec[T: GenCodec]: GenObjectCodec[D[T]] = instances(implicits, this).codec[T]
+  implicit def format[T: MongoFormat]: MongoAdtFormat[D[T]] = instances(implicits, this).format[T]
+
+  implicit def isMongoAdtOrSubtype[C <: D[_]]: IsMongoAdtOrSubtype[C] = null
+
+  implicit class macroDslExtensions[T](value: D[T]) {
+    @explicitGenerics
+    @compileTimeOnly("the .as[Subtype] construct can only be used inside lambda passed to .ref(...) macro")
+    def as[C <: D[T]]: C = sys.error("stub")
+  }
+
+  def apply[T: MongoFormat]: DataTypeDsl[D[T]] = new DataTypeDsl[D[T]] {
+    def SelfRef: MongoRef[D[T], D[T]] = MongoRef.RootRef(format[T])
+  }
+}
+
 abstract class AbstractMongoEntityCompanion[Implicits, E <: BaseMongoEntity](implicits: Implicits)(
   implicit instances: MacroInstances[Implicits, MongoEntityInstances[E]]
 ) extends BaseMongoCompanion[E] {
@@ -79,3 +106,19 @@ abstract class MongoDataCompanion[E](
 abstract class MongoEntityCompanion[E <: BaseMongoEntity](
   implicit instances: MacroInstances[BsonGenCodecs.type, MongoEntityInstances[E]]
 ) extends AbstractMongoEntityCompanion[BsonGenCodecs.type, E](BsonGenCodecs)
+
+/**
+  * Like [[MongoDataCompanion]] buf for generic types (with exactly one unbounded type parameter).
+  *
+  * @example
+  * {{{
+  *   case class Point[+T](x: T, y: T)
+  *   object Point extends MongoPolyDataCompanion[Point] {
+  *     def XRef[T: MongoFormat]: MongoPropertyRef[Point[T], T] =
+  *       Point[T].ref(_.x)
+  *   }
+  * }}}
+  */
+abstract class MongoPolyDataCompanion[D[_]](
+  implicit instances: MacroInstances[BsonGenCodecs.type, MongoPolyAdtInstances[D]]
+) extends AbstractMongoPolyDataCompanion[BsonGenCodecs.type, D](BsonGenCodecs)

commons-mongo/jvm/src/test/scala/com/avsystem/commons/mongo/typed/MongoRefTest.scala

@@ -7,6 +7,8 @@ class MongoRefTest extends AnyFunSuite {
   final val Rte = RecordTestEntity
   final val Ute = UnionTestEntity
   final val Ir = InnerRecord
+  final val Pmr = PolyMongoRecord
+  final val Pmu = PolyMongoUnion
 
   test("filterPath") {
     assert(Rte.IdRef.rawPath == "_id")
@@ -30,11 +32,19 @@ class MongoRefTest extends AnyFunSuite {
     assert(Rte.ref(_.union.as[CaseOne].data).rawPath == "union.data")
     assert(Rte.ref(_.union.as[HasInner].inner).rawPath == "union.inner")
     assert(Rte.ref(_.union).as[HasInner].ref(_.inner).rawPath == "union.inner")
+    assert(Pmr[Int].ref(_.value).rawPath == "value")
     assert(Ute.ref(_.as[HasInner].inner).rawPath == "inner")
     assert(Ute.as[HasInner].ref(_.inner).rawPath == "inner")
     assert(Ute.ref(_.as[HasInner].inner.union.as[HasInner].inner).rawPath == "inner.union.inner")
     assert((Ute.ref(_.as[HasInner].inner) andThen Rte.ref(_.union.as[HasInner].inner)).rawPath == "inner.union.inner")
     assert((Rte.ref(_.union.as[HasInner].inner) compose Ute.ref(_.as[HasInner].inner)).rawPath == "inner.union.inner")
+    assert(Pmu[Int].ref(_.as[PolyMongoUnion.CaseOne[Int]].value).rawPath == "value")
+    assert(Pmu[Int].as[PolyMongoUnion.CaseOne[Int]].ref(_.value).rawPath == "value")
+    assert(Pmu[Int].ref(_.as[PolyMongoUnion.CaseOne[Int]].str).rawPath == "str")
+    assert(Pmu[PolyMongoUnion[Int]].ref(x =>
+      x.as[PolyMongoUnion.CaseOne[PolyMongoUnion[Int]]].value
+        .as[PolyMongoUnion.CaseOne[Int]].str
+    ).rawPath == "value.str")
   }
 
   test("projectionPath") {

commons-mongo/jvm/src/test/scala/com/avsystem/commons/mongo/typed/testEntities.scala

@@ -70,6 +70,16 @@ case class CaseTwo(id: String, str: String, data: Int, inner: RecordTestEntity)
 case class CaseThree(id: String, str: String, data: String, inner: RecordTestEntity) extends HasInner
 object UnionTestEntity extends MongoEntityCompanion[UnionTestEntity]
 
+@flatten sealed trait PolyMongoUnion[+T]
+object PolyMongoUnion extends MongoPolyDataCompanion[PolyMongoUnion] {
+  case class CaseOne[+T](value: T, str: String) extends PolyMongoUnion[T]
+  case class CaseTwo[+T](foo: T, int: Int) extends PolyMongoUnion[T]
+  case object CaseThree extends PolyMongoUnion[Nothing]
+}
+
+case class PolyMongoRecord[+T](value: T, meta: String)
+object PolyMongoRecord extends MongoPolyDataCompanion[PolyMongoRecord]
+
 case class TestAutoId(id: ObjectId) extends AnyVal
 object TestAutoId extends ObjectIdWrapperCompanion[TestAutoId]