The asynchronous driver (see MongoConnection).

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

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

A MongoDB Collection, resolved from a reactivemongo.api.DefaultDB.

You should consider the generic API (reactivemongo.api.collections.GenericCollection).

A Producer of Collection implementation.

This is used to get an implementation implicitly when getting a reference of a Collection.

Cursor over results from MongoDB.

import scala.concurrent.{ ExecutionContext, Future }

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

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

implicit val handler = 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]]())

Cursor over results from MongoDB.

Flattening strategy for cursor.

import scala.concurrent.Future

import reactivemongo.api.{ Cursor, CursorFlattener, FlattenedCursor }

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

implicit def fooFlattener = new CursorFlattener[FooCursor] {
  def flatten[T](future: Future[FooCursor[T]]): FooCursor[T] =
    new FlattenedCursor[T](future) with FooCursor[T] {
      def foo = "Flattened"
    }
}

The reference to a MongoDB database, obtained from a reactivemongo.api.MongoConnection.

You should consider the provided reactivemongo.api.DefaultDB implementation.

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

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

The default DB implementation, that mixes in the database traits.

A failover strategy for sending requests. The default uses 10 retries: 125ms, 250ms, 375ms, 500ms, 625ms, 750ms, 875ms, 1s, 1125ms, 1250ms

import scala.concurrent.duration._

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

A pool of MongoDB connections, obtained from a reactivemongo.api.MongoDriver.

Connection here does not mean that there is one open channel to the server: behind the scene, many connections (channels) are open on all the available servers in the replica set.

Example:

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

def foo(driver: MongoDriver)(implicit ec: ExecutionContext) = {
  val con = driver.connection(List("localhost"))
  val db = con.database("plugin")
  val collection = db.map(_("acoll"))
}

A helper to make the query options. You may use the methods to set the fields of this class, or set them directly.

Cursor wrapper, to help to define custom cursor classes.

A helper that sends the given message to the given actor, following a failover strategy. This helper holds a future reference that is completed with a response, after 1 or more attempts (specified in the given strategy). If the all the tryouts configured by the given strategy were unsuccessful, the future reference is completed with a Throwable.

Should not be used directly for most use cases.