Add docs, operators, improve semantics

build.sbt

@@ -1,6 +1,7 @@
 ThisBuild / scalaVersion               := "2.13.12"
 ThisBuild / organization               := "com.github.dapperware"
 ThisBuild / organizationName           := "Dapperware"
+ThisBuild / organizationHomepage       := Some(url("https://dappermongo.github.io"))
 ThisBuild / name                       := "dappermongo"
 ThisBuild / semanticdbEnabled          := true
 ThisBuild / semanticdbVersion          := scalafixSemanticdb.revision
@@ -42,14 +43,15 @@ lazy val core = (project in file("modules/core"))
   .settings(
     name := "dappermongo-core",
     libraryDependencies ++= Seq(
-      "dev.zio"           %% "zio"                            % "2.0.21",
-      "dev.zio"           %% "zio-streams"                    % "2.0.21",
-      "dev.zio"           %% "zio-interop-reactivestreams"    % "2.0.2",
-      "org.mongodb"        % "mongodb-driver-reactivestreams" % "4.11.0",
-      "org.reactivemongo" %% "reactivemongo-bson-msb-compat"  % "1.1.0-RC12",
-      "dev.zio"           %% "zio-test"                       % "2.0.21"  % Test,
-      "dev.zio"           %% "zio-test-sbt"                   % "2.0.21"  % Test,
-      "com.dimafeng"      %% "testcontainers-scala-mongodb"   % "0.40.12" % Test
+      "dev.zio"                %% "zio"                            % "2.0.21",
+      "dev.zio"                %% "zio-streams"                    % "2.0.21",
+      "dev.zio"                %% "zio-interop-reactivestreams"    % "2.0.2",
+      "org.mongodb"             % "mongodb-driver-reactivestreams" % "4.11.0",
+      "org.reactivemongo"      %% "reactivemongo-bson-msb-compat"  % "1.1.0-RC12",
+      "org.scala-lang.modules" %% "scala-collection-compat"        % "2.11.0",
+      "dev.zio"                %% "zio-test"                       % "2.0.21"  % Test,
+      "dev.zio"                %% "zio-test-sbt"                   % "2.0.21"  % Test,
+      "com.dimafeng"           %% "testcontainers-scala-mongodb"   % "0.40.12" % Test
     ),
     testFrameworks += new TestFramework("zio.test.sbt.ZTestFramework"),
     Test / fork   := true,
@@ -65,24 +67,26 @@ lazy val core = (project in file("modules/core"))
     }
   )
 
-//lazy val docs = project
-//  .in(file("zio-mongo-docs"))
-//  .settings(
-//    scalacOptions --= List("-Yno-imports", "-Xfatal-warnings"),
-//    publish / skip := true
-//  )
-//  .settings(
-//    moduleName                                 := "zio-mongo-docs",
-//    projectName                                := (ThisBuild / name).value,
-//    mainModuleName                             := (core / moduleName).value,
-//    projectStage                               := ProjectStage.Development,
-//    ScalaUnidoc / unidoc / unidocProjectFilter := inProjects(core)
-//  )
-//  .dependsOn(core)
-//  .enablePlugins(WebsitePlugin)
+lazy val microsite = project
+  .enablePlugins(MicrositesPlugin, MdocPlugin)
+  .settings(
+    publish / skip            := true,
+    name                      := "dappermongo-microsite",
+    micrositeName             := "DapperMongo",
+    micrositeDescription      := "A ZIO-friendly MongoDB client",
+    micrositeFooterText       := Some("DapperMongo is maintained by the Dapperware team."),
+    micrositeDocumentationUrl := "docs"
+  )
+
+lazy val examples = project
+  .dependsOn(core)
+  .settings(
+    publish / skip := true,
+    scalacOptions  := scalacOptionsVersion(scalaVersion.value)
+  )
 
 lazy val root = (project in file("."))
-  .aggregate(core)
+  .aggregate(core, microsite, examples)
   .settings(
     publish / skip := true
   )

examples/docker-compose.yml

@@ -0,0 +1,6 @@
+services:
+  mongo:
+    image: mongo:latest
+    container_name: mongo
+    ports:
+      - "27017:27017"

examples/src/main/scala/dapperware/examples/InsertAndQuery.scala

@@ -0,0 +1,32 @@
+package dapperware.examples
+
+import dappermongo.{Collection, Database, MongoClient}
+import reactivemongo.api.bson.{BSONDocumentHandler, Macros, document}
+import zio.{ZIO, ZIOAppDefault}
+
+object InsertAndQuery extends ZIOAppDefault {
+  case class Cookie(name: String, price: Double, quantity: Int)
+
+  object Cookie {
+    implicit val handler: BSONDocumentHandler[Cookie] = Macros.handler[Cookie]
+  }
+
+  val program = for {
+    db <- ZIO.service[Database]
+    _ <- db.insert.many(
+           List(
+             Cookie("oreo", 1.5, 10),
+             Cookie("chips ahoy", 2.0, 5),
+             Cookie("nutter butter", 1.75, 7)
+           )
+         )
+    _ <- db.find(document("price" -> document("$lt" -> 2.0))).stream[Cookie]().runCollect.debug
+  } yield ()
+
+  val run = program.provide(
+    MongoClient.local,
+    Collection.named("cookies"),
+    Database.named("example")
+  )
+
+}

microsite/docs/docs/getting-started.md

@@ -0,0 +1,60 @@
+---
+layout: docs
+title: Getting Started
+permalink: docs/getting-started/
+---
+
+# Getting started
+
+You'll need to first make sure that you have access to a mongo instance or cluster. 
+
+There are a few ways to do this:
+- Install mongo on your local machine or get a hosted version of mongo through Atlas.
+  - You can find more information on that [here](https://www.mongodb.com/docs/manual/installation/).
+
+- Alternatively, if you want to develop locally you can also use docker to run a mongo instance. See the examples project for reference.
+
+- Finally, you can use the mongodb-atlas CLI tool to create a cluster either locally or on atlas.
+
+## Installation
+
+```scala
+libraryDependencies += "com.github.dapperware" %% "dappermongo-core" % "0.0.1"
+```
+
+## Setting up the client
+
+After adding the above dependency you can start a `MongoClient`
+
+```scala
+import dappermongo._
+
+// ZLayer
+MongoClient.local // Uses the default local settings
+MongoClient.configured // By default, it looks for a config key of "mongodb"
+MongoClient.configured(NonEmptyChunk("mongo", "database")) // You can also specify the config key
+MongoClient.live // Accepts `MongoSettings` as an environmental parameter
+
+// ZIO
+MongoClient.scoped // Returns a ZIO that can be configured
+MongoClient.fromSettings(settings) // Accepts settings passed as an argument
+```
+
+### Example
+
+```scala
+import dappermongo._
+import zio._
+
+object Example1 extends ZIOAppDefault {
+
+  val program = for {
+    db <- MongoClient.database("test")
+    _  <- db.diagnostics.ping
+  } yield ()
+
+  val run = program.provide(
+    MongoClient.local
+  )
+}
+```

microsite/docs/docs/intro.md

@@ -0,0 +1,25 @@
+---
+layout: docs
+title: Intro
+permalink: docs/
+---
+
+# Introduction
+
+Welcome to DapperMongo, a ZIO-friendly MongoDB client. This project is designed to provide an easy-to-use, efficient, and reliable interface for interacting with MongoDB databases in Scala.
+
+## Why DapperMongo?
+
+You might be wondering, why another wrapper library for MongoDB in Scala? The answer is simple: DapperMongo takes the best from each library and combines them into a single "dapper" library.
+
+Here are some of the reasons why you should consider using DapperMongo:
+
+- **Ease of Use**: DapperMongo is designed with simplicity in mind. It provides a straightforward and intuitive API that makes it easy to perform common database operations.
+
+- **Efficiency**: By leveraging the power of ZIO and other high-performance libraries, DapperMongo ensures that your database operations are as efficient as possible.
+
+- **Reliability**: DapperMongo is built on top of reliable libraries and uses ZIO's powerful error handling capabilities to ensure that your database operations are safe and reliable.
+
+- **Best of All Worlds**: DapperMongo takes the best features from various MongoDB libraries and combines them into a single, easy-to-use package. This means you get the benefits of all these libraries without having to deal with their individual quirks and complexities.
+
+So, if you're looking for a MongoDB library that's easy to use, efficient, reliable, and takes the best from each library, look no further than DapperMongo. We hope you'll find it to be a valuable tool in your Scala development toolkit.

microsite/docs/index.md

@@ -0,0 +1,9 @@
+---
+layout: home
+title: "Home"
+section: "home"
+technologies:
+  - first: ["ZIO", ""]
+  - second: ["Reactivemongo-BSON", ""]
+  - third: ["mongodb-java-sdk", ""]
+---

microsite/src/main/resources/microsite/data/menu.yml

@@ -0,0 +1,7 @@
+options:
+  - title: Intro
+    url: docs/
+
+  - title: Getting Started
+    url: docs/getting-started/
+    section: intro

modules/core/src/main/scala/dappermongo/AggregateOps.scala

@@ -1,7 +1,9 @@
 package dappermongo
+import scala.jdk.CollectionConverters._
+
 import com.mongodb.reactivestreams.client.{ClientSession, MongoDatabase}
 import dappermongo.aggregate.Pipeline
-import dappermongo.internal.{CollectionConversionsVersionSpecific, _}
+import dappermongo.internal._
 import org.bson.RawBsonDocument
 import reactivemongo.api.bson.msb._
 import reactivemongo.api.bson.{BSON, BSONDocumentReader, BSONDocumentWriter}
@@ -57,8 +59,7 @@ object AggregateBuilder {
     pipeline: Pipeline,
     options: AggregateBuilderOptions,
     sessionStorage: SessionStorage[ClientSession]
-  ) extends AggregateBuilder[Collection]
-      with CollectionConversionsVersionSpecific {
+  ) extends AggregateBuilder[Collection] {
 
     override def allowDiskUse(allowDiskUse: Boolean): AggregateBuilder[Collection] =
       copy(options = options.copy(allowDiskUse = Some(allowDiskUse)))
@@ -115,11 +116,7 @@ object AggregateBuilder {
       session: Option[ClientSession]
     ) = ZIO.attempt {
       val underlying = database.getCollection(collection.name, classOf[RawBsonDocument])
-      val encoded = listAsJava(
-        pipeline.stages.reduceMapLeft(stage => List(fromDocument(BSON.writeDocument(stage).get))) { (acc, stage) =>
-          acc ++ List(fromDocument(BSON.writeDocument(stage).get))
-        }
-      )
+      val encoded    = pipeline.toList.map(_.map(fromDocument).asJava).get
 
       val hint    = options.hint.map(_.apply()).map(_.map(fromDocument).get)
       val comment = options.comment.map(_.apply()).map(_.map(fromDocument).get)

modules/core/src/main/scala/dappermongo/BuildInfo.scala

@@ -0,0 +1,24 @@
+package dappermongo
+
+import reactivemongo.api.bson.{BSONDocument, BSONDocumentHandler, Macros}
+
+case class BuildInfo(
+  version: String,
+  gitVersion: String,
+  sysInfo: String,
+  loaderFlags: String,
+  compilerFlags: String,
+  allocator: String,
+  versionArray: List[Int],
+  openssl: BSONDocument,
+  javascriptEngine: String,
+  bits: Int,
+  debug: Boolean,
+  maxBsonObjectSize: Int,
+  storageEngines: List[String],
+  ok: Int
+)
+
+object BuildInfo {
+  implicit val bsonHandler: BSONDocumentHandler[BuildInfo] = Macros.handler[BuildInfo]
+}

modules/core/src/main/scala/dappermongo/ChangeStreamPreAndPostImagesOptions.scala

@@ -0,0 +1,8 @@
+package dappermongo
+
+case class ChangeStreamPreAndPostImagesOptions(
+  enabled: Boolean = false
+) {
+  def toJava: com.mongodb.client.model.ChangeStreamPreAndPostImagesOptions =
+    new com.mongodb.client.model.ChangeStreamPreAndPostImagesOptions(enabled)
+}

modules/core/src/main/scala/dappermongo/ClusteredIndexOptions.scala

@@ -0,0 +1,16 @@
+package dappermongo
+
+import reactivemongo.api.bson.BSONDocument
+import reactivemongo.api.bson.msb._
+
+case class ClusteredIndexOptions(
+  key: BSONDocument,
+  unique: Boolean,
+  name: Option[String] = None
+) {
+  def toJava: com.mongodb.client.model.ClusteredIndexOptions = {
+    val builder = new com.mongodb.client.model.ClusteredIndexOptions(key, unique)
+    name.foreach(builder.name)
+    builder
+  }
+}

modules/core/src/main/scala/dappermongo/Collection.scala

@@ -1,7 +1,7 @@
 package dappermongo
 
-import zio.ZIO
 import zio.stream.ZStream
+import zio.{Trace, ZIO, ZLayer}
 
 trait Collection { self =>
   def name: String
@@ -30,6 +30,14 @@ trait Collection { self =>
 
 object Collection {
 
+  def named(
+    name: String,
+    readPreference: Option[ReadPreference] = None,
+    writeConcern: Option[WriteConcern] = None,
+    readConcern: Option[ReadConcern] = None
+  )(implicit trace: Trace): ZLayer[Any, Nothing, Collection] =
+    ZLayer.succeed(Impl(name, readPreference, writeConcern, readConcern))
+
   def apply(
     name: String,
     readPreference: Option[ReadPreference] = None,