cross compilation of @mongoid & MongoEntity(Companion) to JS

Author: ghik

.gitignore

@@ -9,6 +9,7 @@
 target
 out
 .bloop
+.bsp
 
 *.sjsir
 *.class

build.sbt

@@ -226,6 +226,7 @@ lazy val `commons-jvm` = project.in(file(".jvm"))
 lazy val `commons-js` = project.in(file(".js"))
   .aggregate(
     `commons-core-js`,
+    `commons-mongo-js`,
     `commons-benchmark-js`,
   )
   .settings(aggregateProjectSettings)
@@ -288,6 +289,63 @@ lazy val `commons-core-js` = project.in(`commons-core`.base / "js")
     )
   )
 
+lazy val `commons-mongo` = project
+  .dependsOn(`commons-core` % CompileAndTest)
+  .settings(
+    jvmCommonSettings,
+    sourceDirsSettings(_ / "jvm"),
+    libraryDependencies ++= Seq(
+      "com.google.guava" % "guava" % guavaVersion,
+      "io.monix" %% "monix" % monixVersion,
+      "org.mongodb" % "mongodb-driver-core" % mongoVersion,
+      "org.mongodb" % "mongodb-driver-sync" % mongoVersion % Optional,
+      "org.mongodb" % "mongodb-driver-reactivestreams" % mongoVersion % Optional,
+      "org.mongodb.scala" %% "mongo-scala-driver" % mongoVersion % Optional,
+    ),
+  )
+
+// only to allow @mongoId & MongoEntity to be used in JS/JVM cross-compiled code
+lazy val `commons-mongo-js` = project.in(`commons-mongo`.base / "js")
+  .enablePlugins(ScalaJSPlugin)
+  .configure(p => if (forIdeaImport) p.dependsOn(`commons-mongo`) else p)
+  .dependsOn(`commons-core-js`)
+  .settings(
+    jsCommonSettings,
+    sameNameAs(`commons-mongo`),
+    sourceDirsSettings(_.getParentFile),
+  )
+
+lazy val `commons-redis` = project
+  .dependsOn(`commons-core` % CompileAndTest)
+  .settings(
+    jvmCommonSettings,
+    libraryDependencies ++= Seq(
+      "com.google.guava" % "guava" % guavaVersion,
+      "com.typesafe.akka" %% "akka-actor" % akkaVersion,
+      "com.typesafe.akka" %% "akka-stream" % akkaVersion,
+      "com.typesafe.scala-logging" %% "scala-logging" % scalaLoggingVersion,
+    ),
+    parallelExecution in Test := false,
+  )
+
+lazy val `commons-hocon` = project
+  .dependsOn(`commons-core` % CompileAndTest)
+  .settings(
+    jvmCommonSettings,
+    libraryDependencies ++= Seq(
+      "com.typesafe" % "config" % typesafeConfigVersion,
+    ),
+  )
+
+lazy val `commons-spring` = project
+  .dependsOn(`commons-hocon` % CompileAndTest)
+  .settings(
+    jvmCommonSettings,
+    libraryDependencies ++= Seq(
+      "org.springframework" % "spring-context" % springVersion,
+    ),
+  )
+
 lazy val `commons-jetty` = project
   .dependsOn(`commons-core` % CompileAndTest)
   .settings(
@@ -338,51 +396,6 @@ lazy val `commons-benchmark-js` = project.in(`commons-benchmark`.base / "js")
     scalaJSUseMainModuleInitializer := true,
   )
 
-lazy val `commons-mongo` = project
-  .dependsOn(`commons-core` % CompileAndTest)
-  .settings(
-    jvmCommonSettings,
-    libraryDependencies ++= Seq(
-      "com.google.guava" % "guava" % guavaVersion,
-      "io.monix" %% "monix" % monixVersion,
-      "org.mongodb" % "mongodb-driver-core" % mongoVersion,
-      "org.mongodb" % "mongodb-driver-sync" % mongoVersion % Optional,
-      "org.mongodb" % "mongodb-driver-reactivestreams" % mongoVersion % Optional,
-      "org.mongodb.scala" %% "mongo-scala-driver" % mongoVersion % Optional,
-    ),
-  )
-
-lazy val `commons-redis` = project
-  .dependsOn(`commons-core` % CompileAndTest)
-  .settings(
-    jvmCommonSettings,
-    libraryDependencies ++= Seq(
-      "com.google.guava" % "guava" % guavaVersion,
-      "com.typesafe.akka" %% "akka-actor" % akkaVersion,
-      "com.typesafe.akka" %% "akka-stream" % akkaVersion,
-      "com.typesafe.scala-logging" %% "scala-logging" % scalaLoggingVersion,
-    ),
-    parallelExecution in Test := false,
-  )
-
-lazy val `commons-hocon` = project
-  .dependsOn(`commons-core` % CompileAndTest)
-  .settings(
-    jvmCommonSettings,
-    libraryDependencies ++= Seq(
-      "com.typesafe" % "config" % typesafeConfigVersion,
-    ),
-  )
-
-lazy val `commons-spring` = project
-  .dependsOn(`commons-hocon` % CompileAndTest)
-  .settings(
-    jvmCommonSettings,
-    libraryDependencies ++= Seq(
-      "org.springframework" % "spring-context" % springVersion,
-    ),
-  )
-
 lazy val `commons-comprof` = project
   .disablePlugins(GenerativePlugin)
   .dependsOn(`commons-core`)

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

@@ -0,0 +1,13 @@
+package com.avsystem.commons
+package mongo.typed
+
+import com.avsystem.commons.meta.MacroInstances
+import com.avsystem.commons.serialization.{GenObjectCodec, HasGenObjectCodec}
+
+abstract class MongoDataCompanion[T](
+  implicit instances: MacroInstances[Unit, () => GenObjectCodec[T]]
+) extends HasGenObjectCodec[T]
+
+abstract class MongoEntityCompanion[T <: BaseMongoEntity](
+  implicit instances: MacroInstances[Unit, () => GenObjectCodec[T]]
+) extends MongoDataCompanion[T]

commons-mongo/src/main/scala/com/avsystem/commons/mongo/BsonCodec.scala renamed to commons-mongo/jvm/src/main/scala/com/avsystem/commons/mongo/BsonCodec.scala

@@ -0,0 +1,69 @@
+package com.avsystem.commons
+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 scala.annotation.{compileTimeOnly, implicitNotFound}
+
+trait MongoAdtInstances[T] {
+  def codec: GenObjectCodec[T]
+  def format: MongoAdtFormat[T]
+}
+
+/**
+  * Provides additional static validation for `as`, `is` and `ref` macros from [[DataTypeDsl]].
+  * Catches mistakes when someone forgets to use [[MongoDataCompanion]] or [[MongoEntityCompanion]] for its
+  * case class or sealed hierarchy.
+  */
+@implicitNotFound("${T} is an opaque data type - does it have a companion that extends MongoDataCompanion?")
+sealed trait IsMongoAdtOrSubtype[T]
+
+abstract class AbstractMongoDataCompanion[Implicits, E](implicits: Implicits)(
+  implicit instances: MacroInstances[Implicits, MongoAdtInstances[E]]
+) extends DataTypeDsl[E] {
+  implicit val codec: GenObjectCodec[E] = instances(implicits, this).codec
+  implicit val format: MongoAdtFormat[E] = instances(implicits, this).format
+
+  implicit def isMongoAdtOrSubtype[C <: E]: IsMongoAdtOrSubtype[C] = null
+
+  implicit class macroDslExtensions(value: E) {
+    @explicitGenerics
+    @compileTimeOnly("the .as[Subtype] construct can only be used inside lambda passed to .ref(...) macro")
+    def as[T <: E]: T = sys.error("stub")
+  }
+
+  final val SelfRef: MongoRef[E, E] = MongoRef.RootRef(format)
+}
+
+abstract class AbstractMongoEntityCompanion[Implicits, E <: BaseMongoEntity](implicits: Implicits)(
+  implicit instances: MacroInstances[Implicits, MongoAdtInstances[E]]
+) extends AbstractMongoDataCompanion[Implicits, E](implicits) {
+
+  type ID = E#IDType
+
+  final val IdRef: Ref[ID] = format.fieldRefFor(SelfRef, MongoEntity.Id)
+}
+
+/**
+  * Base class for companion objects of types that represent inner documents of MongoDB entities.
+  * Just like entities, inner documents may be case classes or sealed hierarchies with `@flatten` annotation.
+  *
+  * NOTE: It is enough for a MongoDB field type to have just `GenCodec` defined (i.e. you can get away with
+  * using `HasGenCodec` instead of `MongoDataCompanion`). However, data type which only has codec will be considered
+  * opaque and you won't be able to reference its inner fields in filters, updates, indices, etc.
+  */
+abstract class MongoDataCompanion[E](
+  implicit instances: MacroInstances[BsonGenCodecs.type, MongoAdtInstances[E]]
+) extends AbstractMongoDataCompanion[BsonGenCodecs.type, E](BsonGenCodecs)
+
+/**
+  * Base class for companion objects of types representing MongoDB entities.
+  * Entities may be case classes or sealed hierarchies with `@flatten` annotation.
+  * They must extend [[MongoEntity]].
+  */
+abstract class MongoEntityCompanion[E <: BaseMongoEntity](
+  implicit instances: MacroInstances[BsonGenCodecs.type, MongoAdtInstances[E]]
+) extends AbstractMongoEntityCompanion[BsonGenCodecs.type, E](BsonGenCodecs)

commons-mongo/src/main/scala/com/avsystem/commons/mongo/BsonGenCodecs.scala renamed to commons-mongo/jvm/src/main/scala/com/avsystem/commons/mongo/BsonGenCodecs.scala

@@ -1,12 +1,7 @@
 package com.avsystem.commons
 package mongo.typed
 
-import com.avsystem.commons.annotation.explicitGenerics
-import com.avsystem.commons.meta.MacroInstances
-import com.avsystem.commons.mongo.{BsonGenCodecs, mongoId}
-import com.avsystem.commons.serialization.GenObjectCodec
-
-import scala.annotation.{compileTimeOnly, implicitNotFound}
+import com.avsystem.commons.mongo.mongoId
 
 /**
   * Type-member version of [[MongoEntity]]. Used in type bounds where wildcards would wreak havoc
@@ -34,63 +29,3 @@ trait MongoEntity[ID] extends BaseMongoEntity {
 object MongoEntity {
   final val Id = "id"
 }
-
-trait MongoAdtInstances[T] {
-  def codec: GenObjectCodec[T]
-  def format: MongoAdtFormat[T]
-}
-
-/**
-  * Provides additional static validation for `as`, `is` and `ref` macros from [[DataTypeDsl]].
-  * Catches mistakes when someone forgets to use [[MongoDataCompanion]] or [[MongoEntityCompanion]] for its
-  * case class or sealed hierarchy.
-  */
-@implicitNotFound("${T} is an opaque data type - does it have a companion that extends MongoDataCompanion?")
-sealed trait IsMongoAdtOrSubtype[T]
-
-abstract class AbstractMongoDataCompanion[Implicits, E](implicits: Implicits)(
-  implicit instances: MacroInstances[Implicits, MongoAdtInstances[E]]
-) extends DataTypeDsl[E] {
-  implicit val codec: GenObjectCodec[E] = instances(implicits, this).codec
-  implicit val format: MongoAdtFormat[E] = instances(implicits, this).format
-
-  implicit def isMongoAdtOrSubtype[C <: E]: IsMongoAdtOrSubtype[C] = null
-
-  implicit class macroDslExtensions(value: E) {
-    @explicitGenerics
-    @compileTimeOnly("the .as[Subtype] construct can only be used inside lambda passed to .ref(...) macro")
-    def as[T <: E]: T = sys.error("stub")
-  }
-
-  final val SelfRef: MongoRef[E, E] = MongoRef.RootRef(format)
-}
-
-abstract class AbstractMongoEntityCompanion[Implicits, E <: BaseMongoEntity](implicits: Implicits)(
-  implicit instances: MacroInstances[Implicits, MongoAdtInstances[E]]
-) extends AbstractMongoDataCompanion[Implicits, E](implicits) {
-
-  type ID = E#IDType
-
-  final val IdRef: Ref[ID] = format.fieldRefFor(SelfRef, MongoEntity.Id)
-}
-
-/**
-  * Base class for companion objects of types that represent inner documents of MongoDB entities.
-  * Just like entities, inner documents may be case classes or sealed hierarchies with `@flatten` annotation.
-  *
-  * NOTE: It is enough for a MongoDB field type to have just `GenCodec` defined (i.e. you can get away with
-  * using `HasGenCodec` instead of `MongoDataCompanion`). However, data type which only has codec will be considered
-  * opaque and you won't be able to reference its inner fields in filters, updates, indices, etc.
-  */
-abstract class MongoDataCompanion[E](
-  implicit instances: MacroInstances[BsonGenCodecs.type, MongoAdtInstances[E]]
-) extends AbstractMongoDataCompanion[BsonGenCodecs.type, E](BsonGenCodecs)
-
-/**
-  * Base class for companion objects of types representing MongoDB entities.
-  * Entities may be case classes or sealed hierarchies with `@flatten` annotation.
-  * They must extend [[MongoEntity]].
-  */
-abstract class MongoEntityCompanion[E <: BaseMongoEntity](
-  implicit instances: MacroInstances[BsonGenCodecs.type, MongoAdtInstances[E]]
-) extends AbstractMongoEntityCompanion[BsonGenCodecs.type, E](BsonGenCodecs)