mongodb 2.2.36 → 3.0.2

package/lib/cursor.js

@@ -1,44 +1,45 @@
-"use strict";
-
-var inherits = require('util').inherits
-  , f = require('util').format
-  , formattedOrderClause = require('./utils').formattedOrderClause
-  , handleCallback = require('./utils').handleCallback
-  , ReadPreference = require('./read_preference')
-  , MongoError = require('mongodb-core').MongoError
-  , Readable = require('stream').Readable || require('readable-stream').Readable
-  , Define = require('./metadata')
-  , CoreCursor = require('mongodb-core').Cursor
-  , Map = require('mongodb-core').BSON.Map
-  , CoreReadPreference = require('mongodb-core').ReadPreference;
+'use strict';
+
+var inherits = require('util').inherits,
+  f = require('util').format,
+  formattedOrderClause = require('./utils').formattedOrderClause,
+  handleCallback = require('./utils').handleCallback,
+  ReadPreference = require('mongodb-core').ReadPreference,
+  MongoError = require('mongodb-core').MongoError,
+  Readable = require('stream').Readable,
+  Define = require('./metadata'),
+  CoreCursor = require('mongodb-core').Cursor,
+  Map = require('mongodb-core').BSON.Map,
+  executeOperation = require('./utils').executeOperation;
 
 /**
  * @fileOverview The **Cursor** class is an internal class that embodies a cursor on MongoDB
  * allowing for iteration over the results returned from the underlying query. It supports
- * one by one document iteration, conversion to an array or can be iterated as a Node 0.10.X
+ * one by one document iteration, conversion to an array or can be iterated as a Node 4.X
  * or higher stream
  *
  * **CURSORS Cannot directly be instantiated**
  * @example
- * var MongoClient = require('mongodb').MongoClient,
- *   test = require('assert');
+ * const MongoClient = require('mongodb').MongoClient;
+ * const test = require('assert');
  * // Connection url
- * var url = 'mongodb://localhost:27017/test';
+ * const url = 'mongodb://localhost:27017';
+ * // Database Name
+ * const dbName = 'test';
  * // Connect using MongoClient
- * MongoClient.connect(url, function(err, db) {
+ * MongoClient.connect(url, function(err, client) {
  *   // Create a collection we want to drop later
- *   var col = db.collection('createIndexExample1');
+ *   const col = client.db(dbName).collection('createIndexExample1');
  *   // Insert a bunch of documents
  *   col.insert([{a:1, b:1}
  *     , {a:2, b:2}, {a:3, b:3}
  *     , {a:4, b:4}], {w:1}, function(err, result) {
  *     test.equal(null, err);
- *
  *     // Show that duplicate records got dropped
  *     col.find({}).toArray(function(err, items) {
  *       test.equal(null, err);
  *       test.equal(4, items.length);
- *       db.close();
+ *       client.close();
  *     });
  *   });
  * });
@@ -99,7 +100,6 @@ var push = Array.prototype.push;
  */
 var Cursor = function(bson, ns, cmd, options, topology, topologyOptions) {
   CoreCursor.apply(this, Array.prototype.slice.call(arguments, 0));
-  var self = this;
   var state = Cursor.INIT;
   var streamOptions = {};
 
@@ -109,61 +109,58 @@ var Cursor = function(bson, ns, cmd, options, topology, topologyOptions) {
   var currentNumberOfRetries = numberOfRetries;
 
   // Get the promiseLibrary
-  var promiseLibrary = options.promiseLibrary;
-
-  // No promise library selected fall back
-  if(!promiseLibrary) {
-    promiseLibrary = typeof global.Promise == 'function' ?
-      global.Promise : require('es6-promise').Promise;
-  }
+  var promiseLibrary = options.promiseLibrary || Promise;
 
   // Set up
-  Readable.call(this, {objectMode: true});
+  Readable.call(this, { objectMode: true });
 
   // Internal cursor state
   this.s = {
     // Tailable cursor options
-      numberOfRetries: numberOfRetries
-    , tailableRetryInterval: tailableRetryInterval
-    , currentNumberOfRetries: currentNumberOfRetries
+    numberOfRetries: numberOfRetries,
+    tailableRetryInterval: tailableRetryInterval,
+    currentNumberOfRetries: currentNumberOfRetries,
     // State
-    , state: state
+    state: state,
     // Stream options
-    , streamOptions: streamOptions
+    streamOptions: streamOptions,
     // BSON
-    , bson: bson
+    bson: bson,
     // Namespace
-    , ns: ns
+    ns: ns,
     // Command
-    , cmd: cmd
+    cmd: cmd,
     // Options
-    , options: options
+    options: options,
     // Topology
-    , topology: topology
+    topology: topology,
     // Topology options
-    , topologyOptions: topologyOptions
+    topologyOptions: topologyOptions,
     // Promise library
-    , promiseLibrary: promiseLibrary
+    promiseLibrary: promiseLibrary,
     // Current doc
-    , currentDoc: null
-  }
+    currentDoc: null,
+    // Optional ClientSession
+    session: options.session
+  };
 
   // Translate correctly
-  if(self.s.options.noCursorTimeout == true) {
-    self.addCursorFlag('noCursorTimeout', true);
+  if (this.s.options.noCursorTimeout === true) {
+    this.addCursorFlag('noCursorTimeout', true);
   }
 
   // Set the sort value
-  this.sortValue = self.s.cmd.sort;
+  this.sortValue = this.s.cmd.sort;
 
   // Get the batchSize
-  var batchSize = cmd.cursor && cmd.cursor.batchSize
-    ? cmd.cursor && cmd.cursor.batchSize
-    : (options.cursor && options.cursor.batchSize ? options.cursor.batchSize : 1000);
+  var batchSize =
+    cmd.cursor && cmd.cursor.batchSize
+      ? cmd.cursor && cmd.cursor.batchSize
+      : options.cursor && options.cursor.batchSize ? options.cursor.batchSize : 1000;
 
   // Set the batchSize
   this.setCursorBatchSize(batchSize);
-}
+};
 
 /**
  * Cursor stream data event, fired for each document in the cursor.
@@ -199,11 +196,11 @@ inherits(Cursor, Readable);
 // Map core cursor _next method so we can apply mapping
 CoreCursor.prototype._next = CoreCursor.prototype.next;
 
-for(var name in CoreCursor.prototype) {
+for (var name in CoreCursor.prototype) {
   Cursor.prototype[name] = CoreCursor.prototype[name];
 }
 
-var define = Cursor.define = new Define('Cursor', Cursor, true);
+var define = (Cursor.define = new Define('Cursor', Cursor, true));
 
 /**
  * Check if there is any document still available in the cursor
@@ -213,39 +210,26 @@ var define = Cursor.define = new Define('Cursor', Cursor, true);
  * @return {Promise} returns Promise if no callback passed
  */
 Cursor.prototype.hasNext = function(callback) {
-  var self = this;
+  return executeOperation(this.s.topology, hasNext, [this, callback], {
+    skipSessions: true
+  });
+};
 
-  // Execute using callback
-  if(typeof callback == 'function') {
-    if(self.s.currentDoc){
-      return callback(null, true);
-    } else {
-      return nextObject(self, function(err, doc) {
-        if (err) return callback(err, null);
-        if (!doc) return callback(null, false);
-        self.s.currentDoc = doc;
-        callback(null, true);
-      });
-    }
+const hasNext = (self, callback) => {
+  if (self.s.currentDoc) {
+    return callback(null, true);
   }
 
-  // Return a Promise
-  return new this.s.promiseLibrary(function(resolve, reject) {
-    if(self.s.currentDoc){
-      resolve(true);
-    } else {
-      nextObject(self, function(err, doc) {
-        if(self.s.state == Cursor.CLOSED || self.isDead()) return resolve(false);
-        if(err) return reject(err);
-        if(!doc) return resolve(false);
-        self.s.currentDoc = doc;
-        resolve(true);
-      });
-    }
+  nextObject(self, function(err, doc) {
+    if (err) return callback(err, null);
+    if (self.s.state === Cursor.CLOSED || self.isDead()) return callback(null, false);
+    if (!doc) return callback(null, false);
+    self.s.currentDoc = doc;
+    callback(null, true);
   });
-}
+};
 
-define.classMethod('hasNext', {callback: true, promise:true});
+define.classMethod('hasNext', { callback: true, promise: true });
 
 /**
  * Get the next available document from the cursor, returns null if no more documents are available.
@@ -255,38 +239,24 @@ define.classMethod('hasNext', {callback: true, promise:true});
  * @return {Promise} returns Promise if no callback passed
  */
 Cursor.prototype.next = function(callback) {
-  var self = this;
-
-  // Execute using callback
-  if(typeof callback == 'function') {
-    // Return the currentDoc if someone called hasNext first
-    if(self.s.currentDoc) {
-      var doc = self.s.currentDoc;
-      self.s.currentDoc = null;
-      return callback(null, doc);
-    }
+  return executeOperation(this.s.topology, next, [this, callback], {
+    skipSessions: true
+  });
+};
 
-    // Return the next object
-    return nextObject(self, callback)
+const next = (self, callback) => {
+  // Return the currentDoc if someone called hasNext first
+  if (self.s.currentDoc) {
+    var doc = self.s.currentDoc;
+    self.s.currentDoc = null;
+    return callback(null, doc);
   }
 
-  // Return a Promise
-  return new this.s.promiseLibrary(function(resolve, reject) {
-    // Return the currentDoc if someone called hasNext first
-    if(self.s.currentDoc) {
-      var doc = self.s.currentDoc;
-      self.s.currentDoc = null;
-      return resolve(doc);
-    }
-
-    nextObject(self, function(err, r) {
-      if(err) return reject(err);
-      resolve(r);
-    });
-  });
-}
+  // Return the next object
+  nextObject(self, callback);
+};
 
-define.classMethod('next', {callback: true, promise:true});
+define.classMethod('next', { callback: true, promise: true });
 
 /**
  * Set the cursor query
@@ -295,12 +265,15 @@ define.classMethod('next', {callback: true, promise:true});
  * @return {Cursor}
  */
 Cursor.prototype.filter = function(filter) {
-  if(this.s.state == Cursor.CLOSED || this.s.state == Cursor.OPEN || this.isDead()) throw MongoError.create({message: "Cursor is closed", driver:true});
+  if (this.s.state === Cursor.CLOSED || this.s.state === Cursor.OPEN || this.isDead()) {
+    throw MongoError.create({ message: 'Cursor is closed', driver: true });
+  }
+
   this.s.cmd.query = filter;
   return this;
-}
+};
 
-define.classMethod('filter', {callback: false, promise:false, returns: [Cursor]});
+define.classMethod('filter', { callback: false, promise: false, returns: [Cursor] });
 
 /**
  * Set the cursor maxScan
@@ -309,12 +282,15 @@ define.classMethod('filter', {callback: false, promise:false, returns: [Cursor]}
  * @return {Cursor}
  */
 Cursor.prototype.maxScan = function(maxScan) {
-  if(this.s.state == Cursor.CLOSED || this.s.state == Cursor.OPEN || this.isDead()) throw MongoError.create({message: "Cursor is closed", driver:true});
+  if (this.s.state === Cursor.CLOSED || this.s.state === Cursor.OPEN || this.isDead()) {
+    throw MongoError.create({ message: 'Cursor is closed', driver: true });
+  }
+
   this.s.cmd.maxScan = maxScan;
   return this;
-}
+};
 
-define.classMethod('maxScan', {callback: false, promise:false, returns: [Cursor]});
+define.classMethod('maxScan', { callback: false, promise: false, returns: [Cursor] });
 
 /**
  * Set the cursor hint
@@ -323,12 +299,15 @@ define.classMethod('maxScan', {callback: false, promise:false, returns: [Cursor]
  * @return {Cursor}
  */
 Cursor.prototype.hint = function(hint) {
-  if(this.s.state == Cursor.CLOSED || this.s.state == Cursor.OPEN || this.isDead()) throw MongoError.create({message: "Cursor is closed", driver:true});
+  if (this.s.state === Cursor.CLOSED || this.s.state === Cursor.OPEN || this.isDead()) {
+    throw MongoError.create({ message: 'Cursor is closed', driver: true });
+  }
+
   this.s.cmd.hint = hint;
   return this;
-}
+};
 
-define.classMethod('hint', {callback: false, promise:false, returns: [Cursor]});
+define.classMethod('hint', { callback: false, promise: false, returns: [Cursor] });
 
 /**
  * Set the cursor min
@@ -337,12 +316,13 @@ define.classMethod('hint', {callback: false, promise:false, returns: [Cursor]});
  * @return {Cursor}
  */
 Cursor.prototype.min = function(min) {
-  if(this.s.state == Cursor.CLOSED || this.s.state == Cursor.OPEN || this.isDead()) throw MongoError.create({message: "Cursor is closed", driver:true});
+  if (this.s.state === Cursor.CLOSED || this.s.state === Cursor.OPEN || this.isDead())
+    throw MongoError.create({ message: 'Cursor is closed', driver: true });
   this.s.cmd.min = min;
   return this;
-}
+};
 
-define.classMethod('min', {callback: false, promise:false, returns: [Cursor]});
+define.classMethod('min', { callback: false, promise: false, returns: [Cursor] });
 
 /**
  * Set the cursor max
@@ -351,12 +331,15 @@ define.classMethod('min', {callback: false, promise:false, returns: [Cursor]});
  * @return {Cursor}
  */
 Cursor.prototype.max = function(max) {
-  if(this.s.state == Cursor.CLOSED || this.s.state == Cursor.OPEN || this.isDead()) throw MongoError.create({message: "Cursor is closed", driver:true});
+  if (this.s.state === Cursor.CLOSED || this.s.state === Cursor.OPEN || this.isDead()) {
+    throw MongoError.create({ message: 'Cursor is closed', driver: true });
+  }
+
   this.s.cmd.max = max;
   return this;
-}
+};
 
-define.classMethod('max', {callback: false, promise:false, returns: [Cursor]});
+define.classMethod('max', { callback: false, promise: false, returns: [Cursor] });
 
 /**
  * Set the cursor returnKey
@@ -365,12 +348,15 @@ define.classMethod('max', {callback: false, promise:false, returns: [Cursor]});
  * @return {Cursor}
  */
 Cursor.prototype.returnKey = function(value) {
-  if(this.s.state == Cursor.CLOSED || this.s.state == Cursor.OPEN || this.isDead()) throw MongoError.create({message: "Cursor is closed", driver:true});
+  if (this.s.state === Cursor.CLOSED || this.s.state === Cursor.OPEN || this.isDead()) {
+    throw MongoError.create({ message: 'Cursor is closed', driver: true });
+  }
+
   this.s.cmd.returnKey = value;
   return this;
-}
+};
 
-define.classMethod('returnKey', {callback: false, promise:false, returns: [Cursor]});
+define.classMethod('returnKey', { callback: false, promise: false, returns: [Cursor] });
 
 /**
  * Set the cursor showRecordId
@@ -379,12 +365,15 @@ define.classMethod('returnKey', {callback: false, promise:false, returns: [Curso
  * @return {Cursor}
  */
 Cursor.prototype.showRecordId = function(value) {
-  if(this.s.state == Cursor.CLOSED || this.s.state == Cursor.OPEN || this.isDead()) throw MongoError.create({message: "Cursor is closed", driver:true});
+  if (this.s.state === Cursor.CLOSED || this.s.state === Cursor.OPEN || this.isDead()) {
+    throw MongoError.create({ message: 'Cursor is closed', driver: true });
+  }
+
   this.s.cmd.showDiskLoc = value;
   return this;
-}
+};
 
-define.classMethod('showRecordId', {callback: false, promise:false, returns: [Cursor]});
+define.classMethod('showRecordId', { callback: false, promise: false, returns: [Cursor] });
 
 /**
  * Set the cursor snapshot
@@ -393,12 +382,15 @@ define.classMethod('showRecordId', {callback: false, promise:false, returns: [Cu
  * @return {Cursor}
  */
 Cursor.prototype.snapshot = function(value) {
-  if(this.s.state == Cursor.CLOSED || this.s.state == Cursor.OPEN || this.isDead()) throw MongoError.create({message: "Cursor is closed", driver:true});
+  if (this.s.state === Cursor.CLOSED || this.s.state === Cursor.OPEN || this.isDead()) {
+    throw MongoError.create({ message: 'Cursor is closed', driver: true });
+  }
+
   this.s.cmd.snapshot = value;
   return this;
-}
+};
 
-define.classMethod('snapshot', {callback: false, promise:false, returns: [Cursor]});
+define.classMethod('snapshot', { callback: false, promise: false, returns: [Cursor] });
 
 /**
  * Set a node.js specific cursor option
@@ -409,15 +401,23 @@ define.classMethod('snapshot', {callback: false, promise:false, returns: [Cursor
  * @return {Cursor}
  */
 Cursor.prototype.setCursorOption = function(field, value) {
-  if(this.s.state == Cursor.CLOSED || this.s.state == Cursor.OPEN || this.isDead()) throw MongoError.create({message: "Cursor is closed", driver:true});
-  if(fields.indexOf(field) == -1) throw MongoError.create({message: f("option %s not a supported option %s", field, fields), driver:true });
+  if (this.s.state === Cursor.CLOSED || this.s.state === Cursor.OPEN || this.isDead()) {
+    throw MongoError.create({ message: 'Cursor is closed', driver: true });
+  }
+
+  if (fields.indexOf(field) === -1) {
+    throw MongoError.create({
+      message: f('option %s not a supported option %s', field, fields),
+      driver: true
+    });
+  }
+
   this.s[field] = value;
-  if(field == 'numberOfRetries')
-    this.s.currentNumberOfRetries = value;
+  if (field === 'numberOfRetries') this.s.currentNumberOfRetries = value;
   return this;
-}
+};
 
-define.classMethod('setCursorOption', {callback: false, promise:false, returns: [Cursor]});
+define.classMethod('setCursorOption', { callback: false, promise: false, returns: [Cursor] });
 
 /**
  * Add a cursor flag to the cursor
@@ -428,14 +428,26 @@ define.classMethod('setCursorOption', {callback: false, promise:false, returns:
  * @return {Cursor}
  */
 Cursor.prototype.addCursorFlag = function(flag, value) {
-  if(this.s.state == Cursor.CLOSED || this.s.state == Cursor.OPEN || this.isDead()) throw MongoError.create({message: "Cursor is closed", driver:true});
-  if(flags.indexOf(flag) == -1) throw MongoError.create({message: f("flag %s not a supported flag %s", flag, flags), driver:true });
-  if(typeof value != 'boolean') throw MongoError.create({message: f("flag %s must be a boolean value", flag), driver:true});
+  if (this.s.state === Cursor.CLOSED || this.s.state === Cursor.OPEN || this.isDead()) {
+    throw MongoError.create({ message: 'Cursor is closed', driver: true });
+  }
+
+  if (flags.indexOf(flag) === -1) {
+    throw MongoError.create({
+      message: f('flag %s not a supported flag %s', flag, flags),
+      driver: true
+    });
+  }
+
+  if (typeof value !== 'boolean') {
+    throw MongoError.create({ message: f('flag %s must be a boolean value', flag), driver: true });
+  }
+
   this.s.cmd[flag] = value;
   return this;
-}
+};
 
-define.classMethod('addCursorFlag', {callback: false, promise:false, returns: [Cursor]});
+define.classMethod('addCursorFlag', { callback: false, promise: false, returns: [Cursor] });
 
 /**
  * Add a query modifier to the cursor query
@@ -446,18 +458,24 @@ define.classMethod('addCursorFlag', {callback: false, promise:false, returns: [C
  * @return {Cursor}
  */
 Cursor.prototype.addQueryModifier = function(name, value) {
-  if(this.s.state == Cursor.CLOSED || this.s.state == Cursor.OPEN || this.isDead()) throw MongoError.create({message: "Cursor is closed", driver:true});
-  if(name[0] != '$') throw MongoError.create({message: f("%s is not a valid query modifier"), driver:true});
+  if (this.s.state === Cursor.CLOSED || this.s.state === Cursor.OPEN || this.isDead()) {
+    throw MongoError.create({ message: 'Cursor is closed', driver: true });
+  }
+
+  if (name[0] !== '$') {
+    throw MongoError.create({ message: f('%s is not a valid query modifier'), driver: true });
+  }
+
   // Strip of the $
   var field = name.substr(1);
   // Set on the command
   this.s.cmd[field] = value;
   // Deal with the special case for sort
-  if(field == 'orderby') this.s.cmd.sort = this.s.cmd[field];
+  if (field === 'orderby') this.s.cmd.sort = this.s.cmd[field];
   return this;
-}
+};
 
-define.classMethod('addQueryModifier', {callback: false, promise:false, returns: [Cursor]});
+define.classMethod('addQueryModifier', { callback: false, promise: false, returns: [Cursor] });
 
 /**
  * Add a comment to the cursor query allowing for tracking the comment in the log.
@@ -467,12 +485,15 @@ define.classMethod('addQueryModifier', {callback: false, promise:false, returns:
  * @return {Cursor}
  */
 Cursor.prototype.comment = function(value) {
-  if(this.s.state == Cursor.CLOSED || this.s.state == Cursor.OPEN || this.isDead()) throw MongoError.create({message: "Cursor is closed", driver:true});
+  if (this.s.state === Cursor.CLOSED || this.s.state === Cursor.OPEN || this.isDead()) {
+    throw MongoError.create({ message: 'Cursor is closed', driver: true });
+  }
+
   this.s.cmd.comment = value;
   return this;
-}
+};
 
-define.classMethod('comment', {callback: false, promise:false, returns: [Cursor]});
+define.classMethod('comment', { callback: false, promise: false, returns: [Cursor] });
 
 /**
  * Set a maxAwaitTimeMS on a tailing cursor query to allow to customize the timeout value for the option awaitData (Only supported on MongoDB 3.2 or higher, ignored otherwise)
@@ -482,13 +503,19 @@ define.classMethod('comment', {callback: false, promise:false, returns: [Cursor]
  * @return {Cursor}
  */
 Cursor.prototype.maxAwaitTimeMS = function(value) {
-  if(typeof value != 'number') throw MongoError.create({message: "maxAwaitTimeMS must be a number", driver:true});
-  if(this.s.state == Cursor.CLOSED || this.s.state == Cursor.OPEN || this.isDead()) throw MongoError.create({message: "Cursor is closed", driver:true});
+  if (typeof value !== 'number') {
+    throw MongoError.create({ message: 'maxAwaitTimeMS must be a number', driver: true });
+  }
+
+  if (this.s.state === Cursor.CLOSED || this.s.state === Cursor.OPEN || this.isDead()) {
+    throw MongoError.create({ message: 'Cursor is closed', driver: true });
+  }
+
   this.s.cmd.maxAwaitTimeMS = value;
   return this;
-}
+};
 
-define.classMethod('maxAwaitTimeMS', {callback: false, promise:false, returns: [Cursor]});
+define.classMethod('maxAwaitTimeMS', { callback: false, promise: false, returns: [Cursor] });
 
 /**
  * Set a maxTimeMS on the cursor query, allowing for hard timeout limits on queries (Only supported on MongoDB 2.6 or higher)
@@ -498,17 +525,23 @@ define.classMethod('maxAwaitTimeMS', {callback: false, promise:false, returns: [
  * @return {Cursor}
  */
 Cursor.prototype.maxTimeMS = function(value) {
-  if(typeof value != 'number') throw MongoError.create({message: "maxTimeMS must be a number", driver:true});
-  if(this.s.state == Cursor.CLOSED || this.s.state == Cursor.OPEN || this.isDead()) throw MongoError.create({message: "Cursor is closed", driver:true});
+  if (typeof value !== 'number') {
+    throw MongoError.create({ message: 'maxTimeMS must be a number', driver: true });
+  }
+
+  if (this.s.state === Cursor.CLOSED || this.s.state === Cursor.OPEN || this.isDead()) {
+    throw MongoError.create({ message: 'Cursor is closed', driver: true });
+  }
+
   this.s.cmd.maxTimeMS = value;
   return this;
-}
+};
 
-define.classMethod('maxTimeMS', {callback: false, promise:false, returns: [Cursor]});
+define.classMethod('maxTimeMS', { callback: false, promise: false, returns: [Cursor] });
 
 Cursor.prototype.maxTimeMs = Cursor.prototype.maxTimeMS;
 
-define.classMethod('maxTimeMs', {callback: false, promise:false, returns: [Cursor]});
+define.classMethod('maxTimeMs', { callback: false, promise: false, returns: [Cursor] });
 
 /**
  * Sets a field projection for the query.
@@ -518,12 +551,15 @@ define.classMethod('maxTimeMs', {callback: false, promise:false, returns: [Curso
  * @return {Cursor}
  */
 Cursor.prototype.project = function(value) {
-  if(this.s.state == Cursor.CLOSED || this.s.state == Cursor.OPEN || this.isDead()) throw MongoError.create({message: "Cursor is closed", driver:true});
+  if (this.s.state === Cursor.CLOSED || this.s.state === Cursor.OPEN || this.isDead()) {
+    throw MongoError.create({ message: 'Cursor is closed', driver: true });
+  }
+
   this.s.cmd.fields = value;
   return this;
-}
+};
 
-define.classMethod('project', {callback: false, promise:false, returns: [Cursor]});
+define.classMethod('project', { callback: false, promise: false, returns: [Cursor] });
 
 /**
  * Sets the sort order of the cursor query.
@@ -534,39 +570,49 @@ define.classMethod('project', {callback: false, promise:false, returns: [Cursor]
  * @return {Cursor}
  */
 Cursor.prototype.sort = function(keyOrList, direction) {
-  if(this.s.options.tailable) throw MongoError.create({message: "Tailable cursor doesn't support sorting", driver:true});
-  if(this.s.state == Cursor.CLOSED || this.s.state == Cursor.OPEN || this.isDead()) throw MongoError.create({message: "Cursor is closed", driver:true});
+  if (this.s.options.tailable) {
+    throw MongoError.create({ message: "Tailable cursor doesn't support sorting", driver: true });
+  }
+
+  if (this.s.state === Cursor.CLOSED || this.s.state === Cursor.OPEN || this.isDead()) {
+    throw MongoError.create({ message: 'Cursor is closed', driver: true });
+  }
+
   var order = keyOrList;
 
   // We have an array of arrays, we need to preserve the order of the sort
   // so we will us a Map
-  if(Array.isArray(order) && Array.isArray(order[0])) {
-    order = new Map(order.map(function(x) {
-      var value = [x[0], null];
-      if(x[1] == 'asc') {
-        value[1] = 1;
-      } else if(x[1] == 'desc') {
-        value[1] = -1;
-      } else if(x[1] == 1 || x[1] == -1) {
-        value[1] = x[1];
-      } else {
-        throw new MongoError("Illegal sort clause, must be of the form [['field1', '(ascending|descending)'], ['field2', '(ascending|descending)']]");
-      }
+  if (Array.isArray(order) && Array.isArray(order[0])) {
+    order = new Map(
+      order.map(function(x) {
+        var value = [x[0], null];
+        if (x[1] === 'asc') {
+          value[1] = 1;
+        } else if (x[1] === 'desc') {
+          value[1] = -1;
+        } else if (x[1] === 1 || x[1] === -1) {
+          value[1] = x[1];
+        } else {
+          throw new MongoError(
+            "Illegal sort clause, must be of the form [['field1', '(ascending|descending)'], ['field2', '(ascending|descending)']]"
+          );
+        }
 
-      return value;
-    }));
+        return value;
+      })
+    );
   }
 
-  if(direction != null) {
+  if (direction != null) {
     order = [[keyOrList, direction]];
   }
 
   this.s.cmd.sort = order;
   this.sortValue = order;
   return this;
-}
+};
 
-define.classMethod('sort', {callback: false, promise:false, returns: [Cursor]});
+define.classMethod('sort', { callback: false, promise: false, returns: [Cursor] });
 
 /**
  * Set the batch size for the cursor.
@@ -576,15 +622,24 @@ define.classMethod('sort', {callback: false, promise:false, returns: [Cursor]});
  * @return {Cursor}
  */
 Cursor.prototype.batchSize = function(value) {
-  if(this.s.options.tailable) throw MongoError.create({message: "Tailable cursor doesn't support batchSize", driver:true});
-  if(this.s.state == Cursor.CLOSED || this.isDead()) throw MongoError.create({message: "Cursor is closed", driver:true});
-  if(typeof value != 'number') throw MongoError.create({message: "batchSize requires an integer", driver:true});
+  if (this.s.options.tailable) {
+    throw MongoError.create({ message: "Tailable cursor doesn't support batchSize", driver: true });
+  }
+
+  if (this.s.state === Cursor.CLOSED || this.isDead()) {
+    throw MongoError.create({ message: 'Cursor is closed', driver: true });
+  }
+
+  if (typeof value !== 'number') {
+    throw MongoError.create({ message: 'batchSize requires an integer', driver: true });
+  }
+
   this.s.cmd.batchSize = value;
   this.setCursorBatchSize(value);
   return this;
-}
+};
 
-define.classMethod('batchSize', {callback: false, promise:false, returns: [Cursor]});
+define.classMethod('batchSize', { callback: false, promise: false, returns: [Cursor] });
 
 /**
  * Set the collation options for the cursor.
@@ -596,9 +651,9 @@ define.classMethod('batchSize', {callback: false, promise:false, returns: [Curso
 Cursor.prototype.collation = function(value) {
   this.s.cmd.collation = value;
   return this;
-}
+};
 
-define.classMethod('collation', {callback: false, promise:false, returns: [Cursor]});
+define.classMethod('collation', { callback: false, promise: false, returns: [Cursor] });
 
 /**
  * Set the limit for the cursor.
@@ -608,16 +663,25 @@ define.classMethod('collation', {callback: false, promise:false, returns: [Curso
  * @return {Cursor}
  */
 Cursor.prototype.limit = function(value) {
-  if(this.s.options.tailable) throw MongoError.create({message: "Tailable cursor doesn't support limit", driver:true});
-  if(this.s.state == Cursor.OPEN || this.s.state == Cursor.CLOSED || this.isDead()) throw MongoError.create({message: "Cursor is closed", driver:true});
-  if(typeof value != 'number') throw MongoError.create({message: "limit requires an integer", driver:true});
+  if (this.s.options.tailable) {
+    throw MongoError.create({ message: "Tailable cursor doesn't support limit", driver: true });
+  }
+
+  if (this.s.state === Cursor.OPEN || this.s.state === Cursor.CLOSED || this.isDead()) {
+    throw MongoError.create({ message: 'Cursor is closed', driver: true });
+  }
+
+  if (typeof value !== 'number') {
+    throw MongoError.create({ message: 'limit requires an integer', driver: true });
+  }
+
   this.s.cmd.limit = value;
   // this.cursorLimit = value;
   this.setCursorLimit(value);
   return this;
-}
+};
 
-define.classMethod('limit', {callback: false, promise:false, returns: [Cursor]});
+define.classMethod('limit', { callback: false, promise: false, returns: [Cursor] });
 
 /**
  * Set the skip for the cursor.
@@ -627,15 +691,24 @@ define.classMethod('limit', {callback: false, promise:false, returns: [Cursor]})
  * @return {Cursor}
  */
 Cursor.prototype.skip = function(value) {
-  if(this.s.options.tailable) throw MongoError.create({message: "Tailable cursor doesn't support skip", driver:true});
-  if(this.s.state == Cursor.OPEN || this.s.state == Cursor.CLOSED || this.isDead()) throw MongoError.create({message: "Cursor is closed", driver:true});
-  if(typeof value != 'number') throw MongoError.create({message: "skip requires an integer", driver:true});
+  if (this.s.options.tailable) {
+    throw MongoError.create({ message: "Tailable cursor doesn't support skip", driver: true });
+  }
+
+  if (this.s.state === Cursor.OPEN || this.s.state === Cursor.CLOSED || this.isDead()) {
+    throw MongoError.create({ message: 'Cursor is closed', driver: true });
+  }
+
+  if (typeof value !== 'number') {
+    throw MongoError.create({ message: 'skip requires an integer', driver: true });
+  }
+
   this.s.cmd.skip = value;
   this.setCursorSkip(value);
   return this;
-}
+};
 
-define.classMethod('skip', {callback: false, promise:false, returns: [Cursor]});
+define.classMethod('skip', { callback: false, promise: false, returns: [Cursor] });
 
 /**
  * The callback format for results
@@ -656,22 +729,17 @@ define.classMethod('skip', {callback: false, promise:false, returns: [Cursor]});
  * @return {null}
  */
 
-/**
- * Get the next available document from the cursor, returns null if no more documents are available.
- * @method
- * @param {Cursor~resultCallback} [callback] The result callback.
- * @throws {MongoError}
- * @deprecated
- * @return {Promise} returns Promise if no callback passed
- */
-Cursor.prototype.nextObject = Cursor.prototype.next;
-
+// Get the next available document from the cursor, returns null if no more documents are available.
 var nextObject = function(self, callback) {
-  if(self.s.state == Cursor.CLOSED || self.isDead && self.isDead()) return handleCallback(callback, MongoError.create({message: "Cursor is closed", driver:true}));
-  if(self.s.state == Cursor.INIT && self.s.cmd.sort) {
+  if (self.s.state === Cursor.CLOSED || (self.isDead && self.isDead()))
+    return handleCallback(
+      callback,
+      MongoError.create({ message: 'Cursor is closed', driver: true })
+    );
+  if (self.s.state === Cursor.INIT && self.s.cmd.sort) {
     try {
       self.s.cmd.sort = formattedOrderClause(self.s.cmd.sort);
-    } catch(err) {
+    } catch (err) {
       return handleCallback(callback, err);
     }
   }
@@ -679,31 +747,25 @@ var nextObject = function(self, callback) {
   // Get the next object
   self._next(function(err, doc) {
     self.s.state = Cursor.OPEN;
-    if(err) return handleCallback(callback, err);
+    if (err) return handleCallback(callback, err);
     handleCallback(callback, null, doc);
   });
-}
-
-define.classMethod('nextObject', {callback: true, promise:true});
+};
 
 // Trampoline emptying the number of retrieved items
 // without incurring a nextTick operation
 var loop = function(self, callback) {
   // No more items we are done
-  if(self.bufferedCount() == 0) return;
+  if (self.bufferedCount() === 0) return;
   // Get the next document
   self._next(callback);
   // Loop
   return loop;
-}
-
-Cursor.prototype.next = Cursor.prototype.nextObject;
-
-define.classMethod('next', {callback: true, promise:true});
+};
 
 /**
  * Iterates over all the documents for this cursor. As with **{cursor.toArray}**,
- * not all of the elements will be iterated if this cursor had been previously accessed.
+ * not all of the elements will be iterated if this cursor had been previouly accessed.
  * In that case, **{cursor.rewind}** can be used to reset the cursor. However, unlike
  * **{cursor.toArray}**, the cursor will only hold a maximum of batch size elements
  * at any given time if batch size is specified. Otherwise, the caller is responsible
@@ -723,37 +785,39 @@ Cursor.prototype.each = function(callback) {
   _each(this, callback);
 };
 
-define.classMethod('each', {callback: true, promise:false});
+define.classMethod('each', { callback: true, promise: false });
 
 // Run the each loop
 var _each = function(self, callback) {
-  if(!callback) throw MongoError.create({message: 'callback is mandatory', driver:true});
-  if(self.isNotified()) return;
-  if(self.s.state == Cursor.CLOSED || self.isDead()) {
-    return handleCallback(callback, MongoError.create({message: "Cursor is closed", driver:true}));
+  if (!callback) throw MongoError.create({ message: 'callback is mandatory', driver: true });
+  if (self.isNotified()) return;
+  if (self.s.state === Cursor.CLOSED || self.isDead()) {
+    return handleCallback(
+      callback,
+      MongoError.create({ message: 'Cursor is closed', driver: true })
+    );
   }
 
-  if(self.s.state == Cursor.INIT) self.s.state = Cursor.OPEN;
+  if (self.s.state === Cursor.INIT) self.s.state = Cursor.OPEN;
 
   // Define function to avoid global scope escape
   var fn = null;
   // Trampoline all the entries
-  if(self.bufferedCount() > 0) {
-    while(fn = loop(self, callback)) fn(self, callback);
+  if (self.bufferedCount() > 0) {
+    while ((fn = loop(self, callback))) fn(self, callback);
     _each(self, callback);
   } else {
     self.next(function(err, item) {
-      if(err) return handleCallback(callback, err);
-      if(item == null) {
-        self.s.state = Cursor.CLOSED;
-        return handleCallback(callback, null, null);
+      if (err) return handleCallback(callback, err);
+      if (item == null) {
+        return self.close({ skipKillCursors: true }, () => handleCallback(callback, null, null));
       }
 
-      if(handleCallback(callback, null, item) == false) return;
+      if (handleCallback(callback, null, item) === false) return;
       _each(self, callback);
-    })
+    });
   }
-}
+};
 
 /**
  * The callback format for the forEach iterator method
@@ -776,19 +840,25 @@ var _each = function(self, callback) {
  * @return {null}
  */
 Cursor.prototype.forEach = function(iterator, callback) {
-  this.each(function(err, doc){
-    if(err) { callback(err); return false; }
-    if(doc != null) { iterator(doc); return true; }
-    if(doc == null && callback) {
+  this.each(function(err, doc) {
+    if (err) {
+      callback(err);
+      return false;
+    }
+    if (doc != null) {
+      iterator(doc);
+      return true;
+    }
+    if (doc == null && callback) {
       var internalCallback = callback;
       callback = null;
       internalCallback(null);
       return false;
     }
   });
-}
+};
 
-define.classMethod('forEach', {callback: true, promise:false});
+define.classMethod('forEach', { callback: true, promise: false });
 
 /**
  * Set the ReadPreference for the cursor.
@@ -797,20 +867,26 @@ define.classMethod('forEach', {callback: true, promise:false});
  * @throws {MongoError}
  * @return {Cursor}
  */
-Cursor.prototype.setReadPreference = function(r) {
-  if(this.s.state != Cursor.INIT) throw MongoError.create({message: 'cannot change cursor readPreference after cursor has been accessed', driver:true});
-  if(r instanceof ReadPreference) {
-    this.s.options.readPreference = new CoreReadPreference(r.mode, r.tags, {maxStalenessSeconds: r.maxStalenessSeconds});
-  } else if(typeof r == 'string'){
-    this.s.options.readPreference = new CoreReadPreference(r);
-  } else if(r instanceof CoreReadPreference) {
-    this.s.options.readPreference = r;
+Cursor.prototype.setReadPreference = function(readPreference) {
+  if (this.s.state !== Cursor.INIT) {
+    throw MongoError.create({
+      message: 'cannot change cursor readPreference after cursor has been accessed',
+      driver: true
+    });
+  }
+
+  if (readPreference instanceof ReadPreference) {
+    this.s.options.readPreference = readPreference;
+  } else if (typeof readPreference === 'string') {
+    this.s.options.readPreference = new ReadPreference(readPreference);
+  } else {
+    throw new TypeError('Invalid read preference: ' + readPreference);
   }
 
   return this;
-}
+};
 
-define.classMethod('setReadPreference', {callback: false, promise:false, returns: [Cursor]});
+define.classMethod('setReadPreference', { callback: false, promise: false, returns: [Cursor] });
 
 /**
  * The callback format for results
@@ -822,7 +898,7 @@ define.classMethod('setReadPreference', {callback: false, promise:false, returns
 /**
  * Returns an array of documents. The caller is responsible for making sure that there
  * is enough memory to store the results. Note that the array only contain partial
- * results when this cursor had been previously accessed. In that case,
+ * results when this cursor had been previouly accessed. In that case,
  * cursor.rewind() can be used to reset the cursor.
  * @method
  * @param {Cursor~toArrayResultCallback} [callback] The result callback.
@@ -831,19 +907,17 @@ define.classMethod('setReadPreference', {callback: false, promise:false, returns
  */
 Cursor.prototype.toArray = function(callback) {
   var self = this;
-  if(self.s.options.tailable) throw MongoError.create({message: 'Tailable cursor cannot be converted to array', driver:true});
-
-  // Execute using callback
-  if(typeof callback == 'function') return toArray(self, callback);
-
-  // Return a Promise
-  return new this.s.promiseLibrary(function(resolve, reject) {
-    toArray(self, function(err, r) {
-      if(err) return reject(err);
-      resolve(r);
+  if (self.s.options.tailable) {
+    throw MongoError.create({
+      message: 'Tailable cursor cannot be converted to array',
+      driver: true
     });
+  }
+
+  return executeOperation(this.s.topology, toArray, [this, callback], {
+    skipSessions: true
   });
-}
+};
 
 var toArray = function(self, callback) {
   var items = [];
@@ -855,21 +929,20 @@ var toArray = function(self, callback) {
   // Fetch all the documents
   var fetchDocs = function() {
     self._next(function(err, doc) {
-      if(err) return handleCallback(callback, err);
-      if(doc == null) {
-        self.s.state = Cursor.CLOSED;
-        return handleCallback(callback, null, items);
+      if (err) return handleCallback(callback, err);
+      if (doc == null) {
+        return self.close({ skipKillCursors: true }, () => handleCallback(callback, null, items));
       }
 
       // Add doc to items
-      items.push(doc)
+      items.push(doc);
 
       // Get all buffered objects
-      if(self.bufferedCount() > 0) {
-        var docs = self.readBufferedDocuments(self.bufferedCount())
+      if (self.bufferedCount() > 0) {
+        var docs = self.readBufferedDocuments(self.bufferedCount());
 
         // Transform the doc if transform method added
-        if(self.s.transforms && typeof self.s.transforms.doc == 'function') {
+        if (self.s.transforms && typeof self.s.transforms.doc === 'function') {
           docs = docs.map(self.s.transforms.doc);
         }
 
@@ -878,13 +951,13 @@ var toArray = function(self, callback) {
 
       // Attempt a fetch
       fetchDocs();
-    })
-  }
+    });
+  };
 
   fetchDocs();
-}
+};
 
-define.classMethod('toArray', {callback: true, promise:true});
+define.classMethod('toArray', { callback: true, promise: true });
 
 /**
  * The callback format for results
@@ -900,102 +973,120 @@ define.classMethod('toArray', {callback: true, promise:true});
  * @param {object} [options=null] Optional settings.
  * @param {number} [options.skip=null] The number of documents to skip.
  * @param {number} [options.limit=null] The maximum amounts to count before aborting.
- * @param {number} [options.maxTimeMS=null] Number of milliseconds to wait before aborting the query.
+ * @param {number} [options.maxTimeMS=null] Number of miliseconds to wait before aborting the query.
  * @param {string} [options.hint=null] An index name hint for the query.
  * @param {(ReadPreference|string)} [options.readPreference=null] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
  * @param {Cursor~countResultCallback} [callback] The result callback.
  * @return {Promise} returns Promise if no callback passed
  */
 Cursor.prototype.count = function(applySkipLimit, opts, callback) {
-  var self = this;
-  if(self.s.cmd.query == null) throw MongoError.create({message: "count can only be used with find command", driver:true});
-  if(typeof opts == 'function') callback = opts, opts = {};
+  if (this.s.cmd.query == null)
+    throw MongoError.create({ message: 'count can only be used with find command', driver: true });
+  if (typeof opts === 'function') (callback = opts), (opts = {});
   opts = opts || {};
 
-  // Execute using callback
-  if(typeof callback == 'function') return count(self, applySkipLimit, opts, callback);
-
-  // Return a Promise
-  return new this.s.promiseLibrary(function(resolve, reject) {
-    count(self, applySkipLimit, opts, function(err, r) {
-      if(err) return reject(err);
-      resolve(r);
-    });
+  return executeOperation(this.s.topology, count, [this, applySkipLimit, opts, callback], {
+    skipSessions: true
   });
 };
 
 var count = function(self, applySkipLimit, opts, callback) {
-  if(typeof applySkipLimit == 'function') {
+  if (typeof applySkipLimit === 'function') {
     callback = applySkipLimit;
     applySkipLimit = true;
   }
 
-  if(applySkipLimit) {
-    if(typeof self.cursorSkip() == 'number') opts.skip = self.cursorSkip();
-    if(typeof self.cursorLimit() == 'number') opts.limit = self.cursorLimit();
+  if (applySkipLimit) {
+    if (typeof self.cursorSkip() === 'number') opts.skip = self.cursorSkip();
+    if (typeof self.cursorLimit() === 'number') opts.limit = self.cursorLimit();
   }
 
   // Command
   var delimiter = self.s.ns.indexOf('.');
 
   var command = {
-    'count': self.s.ns.substr(delimiter+1), 'query': self.s.cmd.query
-  }
+    count: self.s.ns.substr(delimiter + 1),
+    query: self.s.cmd.query
+  };
 
   // Apply a readConcern if set
-  if(self.s.cmd.readConcern) {
+  if (self.s.cmd.readConcern) {
     command.readConcern = self.s.cmd.readConcern;
   }
 
   // Apply a hint if set
-  if(self.s.cmd.hint) {
+  if (self.s.cmd.hint) {
     command.hint = self.s.cmd.hint;
   }
 
-  if(typeof opts.maxTimeMS == 'number') {
+  if (typeof opts.maxTimeMS === 'number') {
     command.maxTimeMS = opts.maxTimeMS;
-  } else if(self.s.cmd && typeof self.s.cmd.maxTimeMS == 'number') {
+  } else if (self.s.cmd && typeof self.s.cmd.maxTimeMS === 'number') {
     command.maxTimeMS = self.s.cmd.maxTimeMS;
   }
 
   // Merge in any options
-  if(opts.skip) command.skip = opts.skip;
-  if(opts.limit) command.limit = opts.limit;
-  if(self.s.options.hint) command.hint = self.s.options.hint;
+  if (opts.skip) command.skip = opts.skip;
+  if (opts.limit) command.limit = opts.limit;
+  if (self.s.options.hint) command.hint = self.s.options.hint;
 
   // Set cursor server to the same as the topology
-  self.server = self.topology;
+  self.server = self.topology.s.coreTopology;
 
   // Execute the command
-  self.topology.command(f("%s.$cmd", self.s.ns.substr(0, delimiter))
-    , command, function(err, result) {
-      callback(err, result ? result.result.n : null)
-    }, self.options);
-}
+  self.s.topology.command(
+    f('%s.$cmd', self.s.ns.substr(0, delimiter)),
+    command,
+    function(err, result) {
+      callback(err, result ? result.result.n : null);
+    },
+    self.options
+  );
+};
 
-define.classMethod('count', {callback: true, promise:true});
+define.classMethod('count', { callback: true, promise: true });
 
 /**
  * Close the cursor, sending a KillCursor command and emitting close.
  * @method
+ * @param {object} [options] Optional settings.
+ * @param {boolean} [options.skipKillCursors] Bypass calling killCursors when closing the cursor.
  * @param {Cursor~resultCallback} [callback] The result callback.
  * @return {Promise} returns Promise if no callback passed
  */
-Cursor.prototype.close = function(callback) {
+Cursor.prototype.close = function(options, callback) {
+  if (typeof options === 'function') (callback = options), (options = {});
+  options = Object.assign({}, { skipKillCursors: false }, options);
+
   this.s.state = Cursor.CLOSED;
-  // Kill the cursor
-  this.kill();
-  // Emit the close event for the cursor
-  this.emit('close');
-  // Callback if provided
-  if(typeof callback == 'function') return handleCallback(callback, null, this);
-  // Return a Promise
-  return new this.s.promiseLibrary(function(resolve) {
-    resolve();
-  });
-}
+  if (!options.skipKillCursors) {
+    // Kill the cursor
+    this.kill();
+  }
 
-define.classMethod('close', {callback: true, promise:true});
+  const completeClose = () => {
+    // Emit the close event for the cursor
+    this.emit('close');
+
+    // Callback if provided
+    if (typeof callback === 'function') {
+      return handleCallback(callback, null, this);
+    }
+
+    // Return a Promise
+    return new this.s.promiseLibrary(function(resolve) {
+      resolve();
+    });
+  };
+
+  if (this.s.session) {
+    return this.s.session.endSession(() => completeClose());
+  }
+
+  return completeClose();
+};
+
+define.classMethod('close', { callback: true, promise: true });
 
 /**
  * Map all documents using the provided function
@@ -1004,16 +1095,18 @@ define.classMethod('close', {callback: true, promise:true});
  * @return {Cursor}
  */
 Cursor.prototype.map = function(transform) {
-  if(this.cursorState.transforms && this.cursorState.transforms.doc) {
+  if (this.cursorState.transforms && this.cursorState.transforms.doc) {
     var oldTransform = this.cursorState.transforms.doc;
-    this.cursorState.transforms.doc = function (doc) { return transform(oldTransform(doc)); };
+    this.cursorState.transforms.doc = function(doc) {
+      return transform(oldTransform(doc));
+    };
   } else {
     this.cursorState.transforms = { doc: transform };
   }
   return this;
-}
+};
 
-define.classMethod('map', {callback: false, promise:false, returns: [Cursor]});
+define.classMethod('map', { callback: false, promise: false, returns: [Cursor] });
 
 /**
  * Is the cursor closed
@@ -1022,17 +1115,17 @@ define.classMethod('map', {callback: false, promise:false, returns: [Cursor]});
  */
 Cursor.prototype.isClosed = function() {
   return this.isDead();
-}
+};
 
-define.classMethod('isClosed', {callback: false, promise:false, returns: [Boolean]});
+define.classMethod('isClosed', { callback: false, promise: false, returns: [Boolean] });
 
 Cursor.prototype.destroy = function(err) {
-  if(err) this.emit('error', err);
+  if (err) this.emit('error', err);
   this.pause();
   this.close();
-}
+};
 
-define.classMethod('destroy', {callback: false, promise:false});
+define.classMethod('destroy', { callback: false, promise: false });
 
 /**
  * Return a modified Readable stream including a possible transform method.
@@ -1044,9 +1137,9 @@ define.classMethod('destroy', {callback: false, promise:false});
 Cursor.prototype.stream = function(options) {
   this.s.streamOptions = options || {};
   return this;
-}
+};
 
-define.classMethod('stream', {callback: false, promise:false, returns: [Cursor]});
+define.classMethod('stream', { callback: false, promise: false, returns: [Cursor] });
 
 /**
  * Execute the explain for the cursor
@@ -1055,41 +1148,33 @@ define.classMethod('stream', {callback: false, promise:false, returns: [Cursor]}
  * @return {Promise} returns Promise if no callback passed
  */
 Cursor.prototype.explain = function(callback) {
-  var self = this;
   this.s.cmd.explain = true;
 
   // Do we have a readConcern
-  if(this.s.cmd.readConcern) {
+  if (this.s.cmd.readConcern) {
     delete this.s.cmd['readConcern'];
   }
 
-  // Execute using callback
-  if(typeof callback == 'function') return this._next(callback);
-
-  // Return a Promise
-  return new this.s.promiseLibrary(function(resolve, reject) {
-    self._next(function(err, r) {
-      if(err) return reject(err);
-      resolve(r);
-    });
+  return executeOperation(this.s.topology, this._next.bind(this), [callback], {
+    skipSessions: true
   });
-}
+};
 
-define.classMethod('explain', {callback: true, promise:true});
+define.classMethod('explain', { callback: true, promise: true });
 
 Cursor.prototype._read = function() {
   var self = this;
-  if(self.s.state == Cursor.CLOSED || self.isDead()) {
+  if (self.s.state === Cursor.CLOSED || self.isDead()) {
     return self.push(null);
   }
 
   // Get the next item
-  self.nextObject(function(err, result) {
-    if(err) {
-      if(self.listeners('error') && self.listeners('error').length > 0) {
+  self.next(function(err, result) {
+    if (err) {
+      if (self.listeners('error') && self.listeners('error').length > 0) {
         self.emit('error', err);
       }
-      if(!self.isDead()) self.close();
+      if (!self.isDead()) self.close();
 
       // Emit end event
       self.emit('end');
@@ -1097,22 +1182,33 @@ Cursor.prototype._read = function() {
     }
 
     // If we provided a transformation method
-    if(typeof self.s.streamOptions.transform == 'function' && result != null) {
+    if (typeof self.s.streamOptions.transform === 'function' && result != null) {
       return self.push(self.s.streamOptions.transform(result));
     }
 
     // If we provided a map function
-    if(self.cursorState.transforms && typeof self.cursorState.transforms.doc == 'function' && result != null) {
+    if (
+      self.cursorState.transforms &&
+      typeof self.cursorState.transforms.doc === 'function' &&
+      result != null
+    ) {
       return self.push(self.cursorState.transforms.doc(result));
     }
 
     // Return the result
     self.push(result);
+
+    if (result === null && self.isDead()) {
+      self.once('end', () => {
+        self.close();
+        self.emit('finish');
+      });
+    }
   });
-}
+};
 
 Object.defineProperty(Cursor.prototype, 'readPreference', {
-  enumerable:true,
+  enumerable: true,
   get: function() {
     if (!this || !this.s) {
       return null;