mongodb 3.5.3 → 3.5.7

package/lib/cursor.js

@@ -9,16 +9,12 @@ const MongoError = require('./core').MongoError;
 const CoreCursor = require('./core/cursor').CoreCursor;
 const CursorState = require('./core/cursor').CursorState;
 const Map = require('./core').BSON.Map;
+const maybePromise = require('./utils').maybePromise;
+const executeOperation = require('./operations/execute_operation');
+const formattedOrderClause = require('./utils').formattedOrderClause;
 
 const each = require('./operations/cursor_ops').each;
-
 const CountOperation = require('./operations/count');
-const ExplainOperation = require('./operations/explain');
-const HasNextOperation = require('./operations/has_next');
-const NextOperation = require('./operations/next');
-const ToArrayOperation = require('./operations/to_array');
-
-const executeOperation = require('./operations/execute_operation');
 
 /**
  * @fileOverview The **Cursor** class is an internal class that embodies a cursor on MongoDB
@@ -128,8 +124,6 @@ class Cursor extends CoreCursor {
       state: CursorState.INIT,
       // Promise library
       promiseLibrary,
-      // Current doc
-      currentDoc: null,
       // explicitlyIgnoreSession
       explicitlyIgnoreSession: !!options.explicitlyIgnoreSession
     };
@@ -199,9 +193,33 @@ class Cursor extends CoreCursor {
    * @return {Promise} returns Promise if no callback passed
    */
   hasNext(callback) {
-    const hasNextOperation = new HasNextOperation(this);
+    if (this.s.state === CursorState.CLOSED || (this.isDead && this.isDead())) {
+      throw MongoError.create({ message: 'Cursor is closed', driver: true });
+    }
+
+    return maybePromise(this, callback, cb => {
+      const cursor = this;
+      if (cursor.isNotified()) {
+        return cb(null, false);
+      }
 
-    return executeOperation(this.topology, hasNextOperation, callback);
+      cursor._next((err, doc) => {
+        if (err) return cb(err);
+        if (doc == null || cursor.s.state === Cursor.CLOSED || cursor.isDead()) {
+          return cb(null, false);
+        }
+
+        cursor.s.state = CursorState.OPEN;
+
+        // NODE-2482: merge this into the core cursor implementation
+        cursor.cursorState.cursorIndex--;
+        if (cursor.cursorState.limit > 0) {
+          cursor.cursorState.currentLimit--;
+        }
+
+        cb(null, true);
+      });
+    });
   }
 
   /**
@@ -212,9 +230,27 @@ class Cursor extends CoreCursor {
    * @return {Promise} returns Promise if no callback passed
    */
   next(callback) {
-    const nextOperation = new NextOperation(this);
+    return maybePromise(this, callback, cb => {
+      const cursor = this;
+      if (cursor.s.state === CursorState.CLOSED || (cursor.isDead && cursor.isDead())) {
+        cb(MongoError.create({ message: 'Cursor is closed', driver: true }));
+        return;
+      }
 
-    return executeOperation(this.topology, nextOperation, callback);
+      if (cursor.s.state === CursorState.INIT && cursor.cmd.sort) {
+        try {
+          cursor.cmd.sort = formattedOrderClause(cursor.cmd.sort);
+        } catch (err) {
+          return cb(err);
+        }
+      }
+
+      cursor._next((err, doc) => {
+        if (err) return cb(err);
+        cursor.s.state = CursorState.OPEN;
+        cb(null, doc);
+      });
+    });
   }
 
   /**
@@ -784,9 +820,43 @@ class Cursor extends CoreCursor {
       });
     }
 
-    const toArrayOperation = new ToArrayOperation(this);
+    return maybePromise(this, callback, cb => {
+      const cursor = this;
+      const items = [];
+
+      // Reset cursor
+      cursor.rewind();
+      cursor.s.state = CursorState.INIT;
+
+      // Fetch all the documents
+      const fetchDocs = () => {
+        cursor._next((err, doc) => {
+          if (err) {
+            return cursor._endSession
+              ? cursor._endSession(() => handleCallback(cb, err))
+              : handleCallback(cb, err);
+          }
+
+          if (doc == null) {
+            return cursor.close({ skipKillCursors: true }, () => handleCallback(cb, null, items));
+          }
+
+          // Add doc to items
+          items.push(doc);
+
+          // Get all buffered objects
+          if (cursor.bufferedCount() > 0) {
+            let docs = cursor.readBufferedDocuments(cursor.bufferedCount());
+            Array.prototype.push.apply(items, docs);
+          }
+
+          // Attempt a fetch
+          fetchDocs();
+        });
+      };
 
-    return executeOperation(this.topology, toArrayOperation, callback);
+      fetchDocs();
+    });
   }
 
   /**
@@ -971,10 +1041,9 @@ class Cursor extends CoreCursor {
     if (this.cmd.readConcern) {
       delete this.cmd['readConcern'];
     }
-
-    const explainOperation = new ExplainOperation(this);
-
-    return executeOperation(this.topology, explainOperation, callback);
+    return maybePromise(this, callback, cb => {
+      CoreCursor.prototype._next.apply(this, [cb]);
+    });
   }
 
   /**

package/lib/mongo_client.js

@@ -3,17 +3,16 @@
 const ChangeStream = require('./change_stream');
 const Db = require('./db');
 const EventEmitter = require('events').EventEmitter;
-const executeOperation = require('./operations/execute_operation');
 const inherits = require('util').inherits;
 const MongoError = require('./core').MongoError;
 const deprecate = require('util').deprecate;
 const WriteConcern = require('./write_concern');
 const MongoDBNamespace = require('./utils').MongoDBNamespace;
 const ReadPreference = require('./core/topologies/read_preference');
-
-// Operations
-const ConnectOperation = require('./operations/connect');
-const CloseOperation = require('./operations/close');
+const maybePromise = require('./utils').maybePromise;
+const NativeTopology = require('./topologies/native_topology');
+const connect = require('./operations/connect').connect;
+const validOptions = require('./operations/connect').validOptions;
 
 /**
  * @fileOverview The **MongoClient** class is a class that allows for making Connections to MongoDB.
@@ -144,6 +143,9 @@ const CloseOperation = require('./operations/close');
  * @param {number} [options.minSize] If present, the connection pool will be initialized with minSize connections, and will never dip below minSize connections
  * @param {boolean} [options.useNewUrlParser=true] Determines whether or not to use the new url parser. Enables the new, spec-compliant, url parser shipped in the core driver. This url parser fixes a number of problems with the original parser, and aims to outright replace that parser in the near future. Defaults to true, and must be explicitly set to false to use the legacy url parser.
  * @param {boolean} [options.useUnifiedTopology] Enables the new unified topology layer
+ * @param {Number} [options.localThresholdMS=15] **Only applies to the unified topology** The size of the latency window for selecting among multiple suitable servers
+ * @param {Number} [options.serverSelectionTimeoutMS=30000] **Only applies to the unified topology** How long to block for server selection before throwing an error
+ * @param {Number} [options.heartbeatFrequencyMS=10000] **Only applies to the unified topology** The frequency with which topology updates are scheduled
  * @param {AutoEncrypter~AutoEncryptionOptions} [options.autoEncryption] Optionally enable client side auto encryption
  * @param {DriverInfoOptions} [options.driverInfo] Allows a wrapping driver to amend the client metadata generated by the driver to include information about the wrapping driver
  * @param {MongoClient~connectCallback} [callback] The command result callback
@@ -158,18 +160,12 @@ function MongoClient(url, options) {
   this.s = {
     url: url,
     options: options || {},
-    promiseLibrary: null,
+    promiseLibrary: (options && options.promiseLibrary) || Promise,
     dbCache: new Map(),
     sessions: new Set(),
     writeConcern: WriteConcern.fromOptions(options),
     namespace: new MongoDBNamespace('admin')
   };
-
-  // Get the promiseLibrary
-  const promiseLibrary = this.s.options.promiseLibrary || Promise;
-
-  // Add the promise to the internal state
-  this.s.promiseLibrary = promiseLibrary;
 }
 
 /**
@@ -214,9 +210,16 @@ MongoClient.prototype.connect = function(callback) {
     throw new TypeError('`connect` only accepts a callback');
   }
 
-  const operation = new ConnectOperation(this);
+  const client = this;
+  return maybePromise(this, callback, cb => {
+    const err = validOptions(client.s.options);
+    if (err) return cb(err);
 
-  return executeOperation(this, operation, callback);
+    connect(client, client.s.url, client.s.options, err => {
+      if (err) return cb(err);
+      cb(null, client);
+    });
+  });
 };
 
 MongoClient.prototype.logout = deprecate(function(options, callback) {
@@ -232,9 +235,41 @@ MongoClient.prototype.logout = deprecate(function(options, callback) {
  * @return {Promise} returns Promise if no callback passed
  */
 MongoClient.prototype.close = function(force, callback) {
-  if (typeof force === 'function') (callback = force), (force = false);
-  const operation = new CloseOperation(this, force);
-  return executeOperation(this, operation, callback);
+  if (typeof force === 'function') {
+    callback = force;
+    force = false;
+  }
+
+  const client = this;
+  return maybePromise(this, callback, cb => {
+    const completeClose = err => {
+      client.emit('close', client);
+
+      if (!(client.topology instanceof NativeTopology)) {
+        for (const item of client.s.dbCache) {
+          item[1].emit('close', client);
+        }
+      }
+
+      client.removeAllListeners('close');
+      cb(err);
+    };
+
+    if (client.topology == null) {
+      completeClose();
+      return;
+    }
+
+    client.topology.close(force, err => {
+      const autoEncrypter = client.topology.s.options.autoEncrypter;
+      if (!autoEncrypter) {
+        completeClose(err);
+        return;
+      }
+
+      autoEncrypter.teardown(force, err2 => completeClose(err || err2));
+    });
+  });
 };
 
 /**
@@ -312,7 +347,7 @@ MongoClient.prototype.isConnected = function(options) {
  * @param {object} [options] Optional settings
  * @param {number} [options.poolSize=5] The maximum size of the individual server pool
  * @param {boolean} [options.ssl=false] Enable SSL connection. *deprecated* use `tls` variants
- * @param {boolean} [options.sslValidate=false] Validate mongod server certificate against Certificate Authority *deprecated* use `tls` variants
+ * @param {boolean} [options.sslValidate=false] Validate mongod server certificate against Certificate Authority
  * @param {buffer} [options.sslCA=undefined] SSL Certificate store binary buffer *deprecated* use `tls` variants
  * @param {buffer} [options.sslCert=undefined] SSL Certificate binary buffer *deprecated* use `tls` variants
  * @param {buffer} [options.sslKey=undefined] SSL Key file binary buffer *deprecated* use `tls` variants
@@ -329,7 +364,7 @@ MongoClient.prototype.isConnected = function(options) {
  * @param {boolean} [options.autoReconnect=true] Enable autoReconnect for single server instances
  * @param {boolean} [options.noDelay=true] TCP Connection no delay
  * @param {boolean} [options.keepAlive=true] TCP Connection keep alive enabled
- * @param {boolean} [options.keepAliveInitialDelay=30000] The number of milliseconds to wait before initiating keepAlive on the TCP socket
+ * @param {number} [options.keepAliveInitialDelay=30000] The number of milliseconds to wait before initiating keepAlive on the TCP socket
  * @param {number} [options.connectTimeoutMS=10000] How long to wait for a connection to be established before timing out
  * @param {number} [options.socketTimeoutMS=360000] How long a send or receive on a socket can take before timing out
  * @param {number} [options.family] Version of IP stack. Can be 4, 6 or null (default).
@@ -373,7 +408,15 @@ MongoClient.prototype.isConnected = function(options) {
  * @param {array} [options.readPreferenceTags] Read preference tags
  * @param {number} [options.numberOfRetries=5] The number of retries for a tailable cursor
  * @param {boolean} [options.auto_reconnect=true] Enable auto reconnecting for single server instances
+ * @param {boolean} [options.monitorCommands=false] Enable command monitoring for this client
  * @param {number} [options.minSize] If present, the connection pool will be initialized with minSize connections, and will never dip below minSize connections
+ * @param {boolean} [options.useNewUrlParser=true] Determines whether or not to use the new url parser. Enables the new, spec-compliant, url parser shipped in the core driver. This url parser fixes a number of problems with the original parser, and aims to outright replace that parser in the near future. Defaults to true, and must be explicitly set to false to use the legacy url parser.
+ * @param {boolean} [options.useUnifiedTopology] Enables the new unified topology layer
+ * @param {Number} [options.localThresholdMS=15] **Only applies to the unified topology** The size of the latency window for selecting among multiple suitable servers
+ * @param {Number} [options.serverSelectionTimeoutMS=30000] **Only applies to the unified topology** How long to block for server selection before throwing an error
+ * @param {Number} [options.heartbeatFrequencyMS=10000] **Only applies to the unified topology** The frequency with which topology updates are scheduled
+ * @param {AutoEncrypter~AutoEncryptionOptions} [options.autoEncryption] Optionally enable client side auto encryption
+ * @param {DriverInfoOptions} [options.driverInfo] Allows a wrapping driver to amend the client metadata generated by the driver to include information about the wrapping driver
  * @param {MongoClient~connectCallback} [callback] The command result callback
  * @return {Promise<MongoClient>} returns Promise if no callback passed
  */

package/lib/operations/connect.js

@@ -1,8 +1,5 @@
 'use strict';
 
-const OperationBase = require('./operation').OperationBase;
-const defineAspects = require('./operation').defineAspects;
-const Aspect = require('./operation').Aspect;
 const deprecate = require('util').deprecate;
 const Logger = require('../core').Logger;
 const MongoCredentials = require('../core').MongoCredentials;
@@ -191,28 +188,6 @@ const LEGACY_OPTIONS_MAP = validOptionNames.reduce((obj, name) => {
   return obj;
 }, {});
 
-class ConnectOperation extends OperationBase {
-  constructor(mongoClient) {
-    super();
-
-    this.mongoClient = mongoClient;
-  }
-
-  execute(callback) {
-    const mongoClient = this.mongoClient;
-    const err = validOptions(mongoClient.s.options);
-
-    // Did we have a validation error
-    if (err) return callback(err);
-    // Fallback to callback based connect
-    connect(mongoClient, mongoClient.s.url, mongoClient.s.options, err => {
-      if (err) return callback(err);
-      callback(null, mongoClient);
-    });
-  }
-}
-defineAspects(ConnectOperation, [Aspect.SKIP_SESSION]);
-
 function addListeners(mongoClient, topology) {
   topology.on('authenticated', createListener(mongoClient, 'authenticated'));
   topology.on('error', createListener(mongoClient, 'error'));
@@ -820,4 +795,4 @@ function translateOptions(options, translationOptions) {
   });
 }
 
-module.exports = ConnectOperation;
+module.exports = { validOptions, connect };

package/lib/operations/count.js

@@ -1,8 +1,6 @@
 'use strict';
 
-const Aspect = require('./operation').Aspect;
 const buildCountCommand = require('./common_functions').buildCountCommand;
-const defineAspects = require('./operation').defineAspects;
 const OperationBase = require('./operation').OperationBase;
 
 class CountOperation extends OperationBase {
@@ -67,6 +65,4 @@ class CountOperation extends OperationBase {
   }
 }
 
-defineAspects(CountOperation, Aspect.SKIP_SESSION);
-
 module.exports = CountOperation;

package/lib/operations/cursor_ops.js

@@ -1,7 +1,6 @@
 'use strict';
 
 const buildCountCommand = require('./collection_ops').buildCountCommand;
-const formattedOrderClause = require('../utils').formattedOrderClause;
 const handleCallback = require('../utils').handleCallback;
 const MongoError = require('../core').MongoError;
 const push = Array.prototype.push;
@@ -106,34 +105,6 @@ function each(cursor, callback) {
   }
 }
 
-/**
- * Check if there is any document still available in the cursor.
- *
- * @method
- * @param {Cursor} cursor The Cursor instance on which to run.
- * @param {Cursor~resultCallback} [callback] The result callback.
- */
-function hasNext(cursor, callback) {
-  if (cursor.s.currentDoc) {
-    return callback(null, true);
-  }
-
-  if (cursor.isNotified()) {
-    return callback(null, false);
-  }
-
-  nextObject(cursor, (err, doc) => {
-    if (err) return callback(err, null);
-    if (cursor.s.state === CursorState.CLOSED || cursor.isDead()) {
-      return callback(null, false);
-    }
-
-    if (!doc) return callback(null, false);
-    cursor.s.currentDoc = doc;
-    callback(null, true);
-  });
-}
-
 // Trampoline emptying the number of retrieved items
 // without incurring a nextTick operation
 function loop(cursor, callback) {
@@ -145,48 +116,6 @@ function loop(cursor, callback) {
   return loop;
 }
 
-/**
- * Get the next available document from the cursor. Returns null if no more documents are available.
- *
- * @method
- * @param {Cursor} cursor The Cursor instance from which to get the next document.
- * @param {Cursor~resultCallback} [callback] The result callback.
- */
-function next(cursor, callback) {
-  // Return the currentDoc if someone called hasNext first
-  if (cursor.s.currentDoc) {
-    const doc = cursor.s.currentDoc;
-    cursor.s.currentDoc = null;
-    return callback(null, doc);
-  }
-
-  // Return the next object
-  nextObject(cursor, callback);
-}
-
-// Get the next available document from the cursor, returns null if no more documents are available.
-function nextObject(cursor, callback) {
-  if (cursor.s.state === CursorState.CLOSED || (cursor.isDead && cursor.isDead()))
-    return handleCallback(
-      callback,
-      MongoError.create({ message: 'Cursor is closed', driver: true })
-    );
-  if (cursor.s.state === CursorState.INIT && cursor.cmd.sort) {
-    try {
-      cursor.cmd.sort = formattedOrderClause(cursor.cmd.sort);
-    } catch (err) {
-      return handleCallback(callback, err);
-    }
-  }
-
-  // Get the next object
-  cursor._next((err, doc) => {
-    cursor.s.state = CursorState.OPEN;
-    if (err) return handleCallback(callback, err);
-    handleCallback(callback, null, doc);
-  });
-}
-
 /**
  * Returns an array of documents. See Cursor.prototype.toArray for more information.
  *
@@ -236,4 +165,4 @@ function toArray(cursor, callback) {
   fetchDocs();
 }
 
-module.exports = { count, each, hasNext, next, toArray };
+module.exports = { count, each, toArray };