reactivemongo.api

import scala.concurrent.Future
import reactivemongo.api.{ AsyncDriver, MongoConnection }

val driver = AsyncDriver()
val connection: Future[MongoConnection] =
 driver.connect("mongodb://node:27017")

import scala.concurrent.{ ExecutionContext, Future }

import reactivemongo.api.ChangeStreams.FullDocumentStrategy

import reactivemongo.api.bson.BSONDocument
import reactivemongo.api.bson.collection.BSONCollection

def peekNext(
 coll: BSONCollection,
 strategy: FullDocumentStrategy)(
 implicit ec: ExecutionContext): Future[Option[BSONDocument]] =
 coll.watch[BSONDocument](fullDocumentStrategy = Some(strategy)).
   cursor.headOption

def doIt(coll: BSONCollection)(
 implicit ec: ExecutionContext): Future[Unit] = for {
   _ <- peekNext(coll, FullDocumentStrategy.Default)
   _ <- peekNext(coll, FullDocumentStrategy.UpdateLookup)
 } yield ()

import reactivemongo.api.Collation

val collation = Collation(
 locale = "en-US",
 caseLevel = None,
 caseFirst = None,
 strength = Some(Collation.PrimaryStrength),
 numericOrdering = None,
 alternate = None,
 maxVariable = None,
 backwards = None)

import scala.concurrent.{ ExecutionContext, Future }

import reactivemongo.api.Cursor
import reactivemongo.api.bson.{ BSONDocument, BSONDocumentReader, Macros }
import reactivemongo.api.bson.collection.BSONCollection

case class User(name: String, pass: String)

implicit val reader: BSONDocumentReader[User] = Macros.reader[User]

def findUsers(coll: BSONCollection)(
 implicit ec: ExecutionContext): Future[List[User]] =
 coll.find(BSONDocument("enabled" -> true)).
   cursor[User](). // obtain cursor for User results
   collect[List](
     maxDocs = 10,
     err = Cursor.FailOnError[List[User]]())

import scala.concurrent.Future

import reactivemongo.api.{ Cursor, CursorFlattener }

trait FooCursor[T] extends Cursor[T] { def foo: String }

def flatFoo[T](future: Future[FooCursor[T]])(implicit cf: CursorFlattener[FooCursor]): FooCursor[T] = Cursor.flatten(future)

import scala.concurrent.ExecutionContext
import reactivemongo.api.MongoConnection

def foo(connection: MongoConnection)(implicit ec: ExecutionContext) = {
 val db = connection.database("plugin")
 val _ = db.map(_("acoll")) // Collection reference
}

import scala.concurrent.duration._

reactivemongo.api.FailoverStrategy(
 initialDelay = 150.milliseconds,
 retries = 20,
 delayFactor = { `try` => `try` * 1.5D })

import scala.concurrent.ExecutionContext
import reactivemongo.api._

def foo(driver: AsyncDriver)(implicit ec: ExecutionContext) = {
 val con = driver.connect(List("localhost"))
 val db = con.flatMap(_.database("plugin"))
 val _ = db.map(_("acoll")) // Collection reference
}

reactivemongo.api.MongoConnectionOptions(nbChannelsPerNode = 10)

import reactivemongo.api.ReadConcern
import reactivemongo.api.bson.BSONDocument
import reactivemongo.api.bson.collection.BSONCollection

def queryBuilderWithReadConcern(coll: BSONCollection) =
 coll.find(BSONDocument.empty).
 readConcern(ReadConcern.Available)

import reactivemongo.api.ReadPreference

val pref: ReadPreference = ReadPreference.primary

import scala.concurrent.ExecutionContext
import reactivemongo.api.{ DB, WriteConcern }
import reactivemongo.api.bson.BSONDocument

def foo(db: DB)(implicit ec: ExecutionContext) =
 db.collection("myColl").
   insert(ordered = false, WriteConcern.Acknowledged).
   one(BSONDocument("foo" -> "bar"))