mongodb 3.3.0-beta1 → 3.3.0-beta2

package/lib/core/utils.js

@@ -116,6 +116,41 @@ function isPromiseLike(maybePromise) {
   return maybePromise && typeof maybePromise.then === 'function';
 }
 
+/**
+ * Applies the function `eachFn` to each item in `arr`, in parallel.
+ *
+ * @param {array} arr an array of items to asynchronusly iterate over
+ * @param {function} eachFn A function to call on each item of the array. The callback signature is `(item, callback)`, where the callback indicates iteration is complete.
+ * @param {function} callback The callback called after every item has been iterated
+ */
+function eachAsync(arr, eachFn, callback) {
+  if (arr.length === 0) {
+    callback(null);
+    return;
+  }
+
+  const length = arr.length;
+  let completed = 0;
+  function eachCallback(err) {
+    if (err) {
+      callback(err, null);
+      return;
+    }
+
+    if (++completed === length) {
+      callback(null);
+    }
+  }
+
+  for (let idx = 0; idx < length; ++idx) {
+    eachFn(arr[idx], eachCallback);
+  }
+}
+
+function isUnifiedTopology(topology) {
+  return topology.description != null;
+}
+
 module.exports = {
   uuidV4,
   calculateDurationInMs,
@@ -124,5 +159,7 @@ module.exports = {
   retrieveEJSON,
   retrieveKerberos,
   maxWireVersion,
-  isPromiseLike
+  isPromiseLike,
+  eachAsync,
+  isUnifiedTopology
 };

package/lib/core/wireprotocol/command.js

@@ -10,7 +10,7 @@ const isTransactionCommand = require('../transactions').isTransactionCommand;
 const applySession = require('../sessions').applySession;
 
 function isClientEncryptionEnabled(server) {
-  return server && server.s && server.s.options && server.s.options.autoEncrypter;
+  return server.autoEncrypter;
 }
 
 function command(server, ns, cmd, options, callback) {
@@ -133,7 +133,7 @@ function supportsOpMsg(topologyOrServer) {
 
 function _cryptCommand(server, ns, cmd, options, callback) {
   const shouldBypassAutoEncryption = !!server.s.options.bypassAutoEncryption;
-  const autoEncrypter = server.s.options.autoEncrypter;
+  const autoEncrypter = server.autoEncrypter;
   function commandResponseHandler(err, response) {
     if (err || response == null) {
       callback(err, response);

package/lib/cursor.js

@@ -106,10 +106,12 @@ const fields = ['numberOfRetries', 'tailableRetryInterval'];
  *
  * collection.find({}).maxTimeMS(1000).maxScan(100).skip(1).toArray(..)
  */
-function Cursor(bson, ns, cmd, options, topology, topologyOptions) {
+function Cursor(topology, ns, cmd, options) {
   CoreCursor.apply(this, Array.prototype.slice.call(arguments, 0));
   const state = Cursor.INIT;
   const streamOptions = {};
+  const bson = topology.s.bson;
+  const topologyOptions = topology.s.options;
 
   // Tailable cursor options
   const numberOfRetries = options.numberOfRetries || 5;
@@ -214,9 +216,6 @@ if (SUPPORTS.ASYNC_ITERATOR) {
 
 // Map core cursor _next method so we can apply mapping
 Cursor.prototype._next = function() {
-  if (this._initImplicitSession) {
-    this._initImplicitSession();
-  }
   return CoreCursor.prototype.next.apply(this, arguments);
 };
 
@@ -224,11 +223,14 @@ for (let name in CoreCursor.prototype) {
   Cursor.prototype[name] = CoreCursor.prototype[name];
 }
 
-Cursor.prototype._initImplicitSession = function() {
+Cursor.prototype._initializeCursor = function(callback) {
+  // implicitly create a session if one has not been provided
   if (!this.s.explicitlyIgnoreSession && !this.s.session && this.s.topology.hasSessionSupport()) {
     this.s.session = this.s.topology.startSession({ owner: this });
     this.cursorState.session = this.s.session;
   }
+
+  CoreCursor.prototype._initializeCursor.apply(this, [callback]);
 };
 
 Cursor.prototype._endSession = function() {

package/lib/db.js

@@ -505,7 +505,9 @@ Db.prototype.createCollection = deprecateOptions(
     if (typeof options === 'function') (callback = options), (options = {});
     options = options || {};
     options.promiseLibrary = options.promiseLibrary || this.s.promiseLibrary;
-
+    options.readConcern = options.readConcern
+      ? new ReadConcern(options.readConcern.level)
+      : this.readConcern;
     const createCollectionOperation = new CreateCollectionOperation(this, name, options);
 
     return executeOperation(this.s.topology, createCollectionOperation, callback);
@@ -687,6 +689,10 @@ Db.prototype.renameCollection = function(fromCollection, toCollection, options,
  * @method
  * @param {string} name Name of collection to drop
  * @param {Object} [options] Optional settings
+ * @param {WriteConcern} [options.writeConcern] A full WriteConcern object
+ * @param {(number|string)} [options.w] The write concern
+ * @param {number} [options.wtimeout] The write concern timeout
+ * @param {boolean} [options.j] The journal write concern
  * @param {ClientSession} [options.session] optional session to use for this operation
  * @param {Db~resultCallback} [callback] The results callback
  * @return {Promise} returns Promise if no callback passed

package/lib/error.js

@@ -9,15 +9,15 @@ const GET_MORE_NON_RESUMABLE_CODES = new Set([
   11601 // Interrupted
 ]);
 
-// From spec@https://github.com/mongodb/specifications/blob/35e466ddf25059cb30e4113de71cdebd3754657f/source/change-streams.rst#resumable-error:
+// From spec@https://github.com/mongodb/specifications/blob/7a2e93d85935ee4b1046a8d2ad3514c657dc74fa/source/change-streams/change-streams.rst#resumable-error:
 //
 // An error is considered resumable if it meets any of the following criteria:
 // - any error encountered which is not a server error (e.g. a timeout error or network error)
-// - any server error response from a getMore command excluding those containing the following error codes
+// - any server error response from a getMore command excluding those containing the error label
+//   NonRetryableChangeStreamError and those containing the following error codes:
 //   - Interrupted: 11601
 //   - CappedPositionLost: 136
 //   - CursorKilled: 237
-// - a server error response with an error message containing the substring "not master" or "node is recovering"
 //
 // An error on an aggregate command is not a resumable error. Only errors on a getMore command may be considered resumable errors.
 
@@ -32,11 +32,13 @@ function isResumableError(error) {
     return false;
   }
 
-  return !!(
-    error instanceof MongoNetworkError ||
-    !GET_MORE_NON_RESUMABLE_CODES.has(error.code) ||
-    error.message.match(/not master/) ||
-    error.message.match(/node is recovering/)
+  if (error instanceof MongoNetworkError) {
+    return true;
+  }
+
+  return !(
+    GET_MORE_NON_RESUMABLE_CODES.has(error.code) ||
+    error.hasErrorLabel('NonRetryableChangeStreamError')
   );
 }
 

package/lib/mongo_client.js

@@ -3,16 +3,15 @@
 const ChangeStream = require('./change_stream');
 const Db = require('./db');
 const EventEmitter = require('events').EventEmitter;
-const executeLegacyOperation = require('./utils').executeLegacyOperation;
+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');
 
 // Operations
-const connectOp = require('./operations/mongo_client_ops').connectOp;
-const validOptions = require('./operations/mongo_client_ops').validOptions;
-const closeOperation = require('./operations/mongo_client_ops').closeOperation;
+const ConnectOperation = require('./operations/connect');
+const CloseOperation = require('./operations/close');
 
 /**
  * @fileOverview The **MongoClient** class is a class that allows for making Connections to MongoDB.
@@ -67,6 +66,7 @@ const closeOperation = require('./operations/mongo_client_ops').closeOperation;
  * @property {string} [kmsProviders.local.key] The master key used to encrypt/decrypt data keys
  * @property {object} [schemaMap] A map of namespaces to a local JSON schema for encryption
  * @property {boolean} [bypassAutoEncryption] Allows the user to bypass auto encryption, maintaining implicit decryption
+ * @param {string} [extraOptions.mongocryptURI] A local process the driver communicates with to determine how to encrypt values in a command. Defaults to "mongodb://%2Fvar%2Fmongocryptd.sock" if domain sockets are available or "mongodb://localhost:27020" otherwise.
  */
 
 /**
@@ -191,16 +191,13 @@ Object.defineProperty(MongoClient.prototype, 'writeConcern', {
  * @return {Promise<MongoClient>} returns Promise if no callback passed
  */
 MongoClient.prototype.connect = function(callback) {
-  // Validate options object
-  const err = validOptions(this.s.options);
-
   if (typeof callback === 'string') {
     throw new TypeError('`connect` only accepts a callback');
   }
 
-  return executeLegacyOperation(this, connectOp, [this, err, callback], {
-    skipSessions: true
-  });
+  const operation = new ConnectOperation(this);
+
+  return executeOperation(this, operation, callback);
 };
 
 MongoClient.prototype.logout = deprecate(function(options, callback) {
@@ -217,9 +214,8 @@ MongoClient.prototype.logout = deprecate(function(options, callback) {
  */
 MongoClient.prototype.close = function(force, callback) {
   if (typeof force === 'function') (callback = force), (force = false);
-  return executeLegacyOperation(this, closeOperation, [this, force, callback], {
-    skipSessions: true
-  });
+  const operation = new CloseOperation(this, force);
+  return executeOperation(this, operation, callback);
 };
 
 /**

package/lib/operations/aggregate.js

@@ -8,9 +8,9 @@ const handleCallback = require('../utils').handleCallback;
 const MongoError = require('../core').MongoError;
 const resolveReadPreference = require('../utils').resolveReadPreference;
 const toError = require('../utils').toError;
+const ReadPreference = require('../core').ReadPreference;
 
 const DB_AGGREGATE_COLLECTION = 1;
-
 const MIN_WIRE_VERSION_$OUT_READ_CONCERN_SUPPORT = 8;
 
 /**
@@ -27,13 +27,16 @@ function aggregate(db, coll, pipeline, options, callback) {
   const isDbAggregate = typeof coll === 'string';
   const target = isDbAggregate ? db : coll;
   const topology = target.s.topology;
-  let hasOutStage = false;
+  let hasWriteStage = false;
 
   if (typeof options.out === 'string') {
     pipeline = pipeline.concat({ $out: options.out });
-    hasOutStage = true;
-  } else if (pipeline.length > 0 && pipeline[pipeline.length - 1]['$out']) {
-    hasOutStage = true;
+    hasWriteStage = true;
+  } else if (pipeline.length > 0) {
+    const finalStage = pipeline[pipeline.length - 1];
+    if (finalStage.$out || finalStage.$merge) {
+      hasWriteStage = true;
+    }
   }
 
   let command;
@@ -55,11 +58,11 @@ function aggregate(db, coll, pipeline, options, callback) {
   const takesWriteConcern = topology.capabilities().commandsTakeWriteConcern;
   const ismaster = topology.lastIsMaster() || {};
 
-  if (!hasOutStage || ismaster.maxWireVersion >= MIN_WIRE_VERSION_$OUT_READ_CONCERN_SUPPORT) {
+  if (!hasWriteStage || ismaster.maxWireVersion >= MIN_WIRE_VERSION_$OUT_READ_CONCERN_SUPPORT) {
     decorateWithReadConcern(command, target, options);
   }
 
-  if (pipeline.length > 0 && pipeline[pipeline.length - 1]['$out'] && takesWriteConcern) {
+  if (hasWriteStage && takesWriteConcern) {
     applyWriteConcern(command, optionSources, options);
   }
 
@@ -82,7 +85,9 @@ function aggregate(db, coll, pipeline, options, callback) {
   options = Object.assign({}, options);
 
   // Ensure we have the right read preference inheritance
-  options.readPreference = resolveReadPreference(isDbAggregate ? db : coll, options);
+  options.readPreference = hasWriteStage
+    ? ReadPreference.primary
+    : resolveReadPreference(isDbAggregate ? db : coll, options);
 
   if (options.explain) {
     if (command.readConcern || command.writeConcern) {
@@ -99,7 +104,10 @@ function aggregate(db, coll, pipeline, options, callback) {
   }
 
   options.cursor = options.cursor || {};
-  if (options.batchSize && !hasOutStage) options.cursor.batchSize = options.batchSize;
+  if (options.batchSize && !hasWriteStage) {
+    options.cursor.batchSize = options.batchSize;
+  }
+
   command.cursor = options.cursor;
 
   // promiseLibrary

package/lib/operations/close.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const Aspect = require('./operation').Aspect;
+const defineAspects = require('./operation').defineAspects;
+const OperationBase = require('./operation').OperationBase;
+
+class CloseOperation extends OperationBase {
+  constructor(client, force) {
+    super();
+    this.client = client;
+    this.force = force;
+  }
+
+  execute(callback) {
+    const client = this.client;
+    const force = this.force;
+    const completeClose = err => {
+      client.emit('close', client);
+      for (const name in client.s.dbCache) {
+        client.s.dbCache[name].emit('close', client);
+      }
+
+      client.removeAllListeners('close');
+      callback(err, null);
+    };
+    const mongocryptdClientClose = err => {
+      const mongocryptdClient = client.s.mongocryptdClient;
+      if (!mongocryptdClient) {
+        completeClose(err);
+        return;
+      }
+
+      mongocryptdClient.close(force, err2 => completeClose(err || err2));
+    };
+
+    if (client.topology == null) {
+      mongocryptdClientClose();
+      return;
+    }
+
+    client.topology.close(force, mongocryptdClientClose);
+  }
+}
+
+defineAspects(CloseOperation, [Aspect.SKIP_SESSION]);
+
+module.exports = CloseOperation;

package/lib/operations/collection_ops.js

@@ -156,6 +156,10 @@ function bulkWrite(coll, operations, options, callback) {
 
 // Check the update operation to ensure it has atomic operators.
 function checkForAtomicOperators(update) {
+  if (Array.isArray(update)) {
+    return update.reduce((err, u) => err || checkForAtomicOperators(u), null);
+  }
+
   const keys = Object.keys(update);
 
   // same errors as the server would give for update doc lacking atomic operators

package/lib/operations/command.js

@@ -105,7 +105,8 @@ class CommandOperation extends OperationBase {
       );
     }
 
-    const namespace = new MongoDBNamespace(dbName, '$cmd');
+    const namespace =
+      this.namespace != null ? this.namespace : new MongoDBNamespace(dbName, '$cmd');
 
     // Execute command
     db.s.topology.command(namespace, command, options, (err, result) => {

package/lib/operations/command_v2.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const OperationBase = require('./operation').OperationBase;
+const resolveReadPreference = require('../utils').resolveReadPreference;
+
+class CommandOperationV2 extends OperationBase {
+  constructor(parent, options) {
+    super(options);
+
+    this.ns = parent.s.namespace.withCollection('$cmd');
+    this.readPreference = resolveReadPreference(parent, options);
+
+    // TODO(NODE-2056): make logger another "inheritable" property
+    if (parent.s.logger) {
+      this.logger = parent.s.logger;
+    } else if (parent.s.db && parent.s.db.logger) {
+      this.logger = parent.s.db.logger;
+    }
+  }
+
+  executeCommand(server, cmd, callback) {
+    if (this.logger && this.logger.isDebug()) {
+      this.logger.debug(`executing command ${JSON.stringify(cmd)} against ${this.ns}`);
+    }
+
+    server.command(this.ns.toString(), cmd, this.options, (err, result) => {
+      if (err) {
+        callback(err, null);
+        return;
+      }
+
+      // full response was requested
+      if (this.options.full) {
+        callback(null, result);
+        return;
+      }
+
+      callback(null, result.result);
+    });
+  }
+}
+
+module.exports = CommandOperationV2;

package/lib/operations/connect.js

@@ -1,6 +1,8 @@
 'use strict';
 
+const os = require('os');
 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;
@@ -131,31 +133,58 @@ const validOptionNames = [
   'minSize',
   'monitorCommands',
   'retryWrites',
+  'retryReads',
   'useNewUrlParser',
   'useUnifiedTopology',
-  'serverSelectionTimeoutMS'
+  'serverSelectionTimeoutMS',
+  'useRecoveryToken',
+  'autoEncryption'
 ];
 
+const ignoreOptionNames = ['native_parser'];
+const legacyOptionNames = ['server', 'replset', 'replSet', 'mongos', 'db'];
+
+// Validate options object
+function validOptions(options) {
+  const _validOptions = validOptionNames.concat(legacyOptionNames);
+
+  for (const name in options) {
+    if (ignoreOptionNames.indexOf(name) !== -1) {
+      continue;
+    }
+
+    if (_validOptions.indexOf(name) === -1) {
+      if (options.validateOptions) {
+        return new MongoError(`option ${name} is not supported`);
+      } else {
+        console.warn(`the options [${name}] is not supported`);
+      }
+    }
+
+    if (legacyOptionNames.indexOf(name) !== -1) {
+      console.warn(
+        `the server/replset/mongos/db options are deprecated, ` +
+          `all their options are supported at the top level of the options object [${validOptionNames}]`
+      );
+    }
+  }
+}
+
 const LEGACY_OPTIONS_MAP = validOptionNames.reduce((obj, name) => {
   obj[name.toLowerCase()] = name;
   return obj;
 }, {});
 
 class ConnectOperation extends OperationBase {
-  constructor(mongoClient, err) {
+  constructor(mongoClient) {
     super();
 
     this.mongoClient = mongoClient;
-    this.err = err;
-  }
-
-  static get aspects() {
-    return new Set([Aspect.SKIP_SESSIONS]);
   }
 
   execute(callback) {
     const mongoClient = this.mongoClient;
-    const err = this.err;
+    const err = validOptions(mongoClient.s.options);
 
     // Did we have a validation error
     if (err) return callback(err);
@@ -166,6 +195,7 @@ class ConnectOperation extends OperationBase {
     });
   }
 }
+defineAspects(ConnectOperation, [Aspect.SKIP_SESSION]);
 
 function addListeners(mongoClient, topology) {
   topology.on('authenticated', createListener(mongoClient, 'authenticated'));
@@ -245,6 +275,7 @@ function connect(mongoClient, url, options, callback) {
     if (_finalOptions.socketTimeoutMS == null) _finalOptions.socketTimeoutMS = 360000;
     if (_finalOptions.connectTimeoutMS == null) _finalOptions.connectTimeoutMS = 30000;
     if (_finalOptions.retryWrites == null) _finalOptions.retryWrites = true;
+    if (_finalOptions.useRecoveryToken == null) _finalOptions.useRecoveryToken = true;
 
     if (_finalOptions.db_options && _finalOptions.db_options.auth) {
       delete _finalOptions.db_options.auth;
@@ -433,7 +464,50 @@ function createTopology(mongoClient, topologyType, options, callback) {
     }
 
     assignTopology(mongoClient, newTopology);
-    callback(null, newTopology);
+    if (options.autoEncryption == null) {
+      callback(null, newTopology);
+      return;
+    }
+
+    // setup for client side encryption
+    let AutoEncrypter;
+    try {
+      AutoEncrypter = require('mongodb-client-encryption').AutoEncrypter;
+    } catch (err) {
+      callback(
+        new MongoError(
+          'Auto-encryption requested, but the module is not installed. Please add `mongodb-client-encryption` as a dependency of your project'
+        )
+      );
+
+      return;
+    }
+
+    const MongoClient = loadClient();
+    let connectionString;
+    if (options.autoEncryption.extraOptions && options.autoEncryption.extraOptions.mongocryptURI) {
+      connectionString = options.autoEncryption.extraOptions.mongocryptURI;
+    } else if (os.platform() === 'win32') {
+      connectionString = 'mongodb://localhost:27020/?serverSelectionTimeoutMS=1000';
+    } else {
+      connectionString = 'mongodb://%2Ftmp%2Fmongocryptd.sock/?serverSelectionTimeoutMS=1000';
+    }
+
+    const mongocryptdClient = new MongoClient(connectionString, {
+      useNewUrlParser: true,
+      useUnifiedTopology: true
+    });
+    mongoClient.s.mongocryptdClient = mongocryptdClient;
+    mongocryptdClient.connect(err => {
+      if (err) return callback(err, null);
+
+      const mongoCryptOptions = Object.assign({}, options.autoEncryption, {
+        mongocryptdClient
+      });
+
+      topology.s.options.autoEncrypter = new AutoEncrypter(mongoClient, mongoCryptOptions);
+      callback(null, newTopology);
+    });
   });
 }
 

package/lib/operations/create_collection.js

@@ -22,6 +22,7 @@ const illegalCommandFields = [
   'raw',
   'readPreference',
   'session',
+  'readConcern',
   'writeConcern'
 ];
 

package/lib/operations/distinct.js

@@ -2,12 +2,9 @@
 
 const Aspect = require('./operation').Aspect;
 const defineAspects = require('./operation').defineAspects;
-const OperationBase = require('./operation').OperationBase;
+const CommandOperationV2 = require('./command_v2');
 const decorateWithCollation = require('../utils').decorateWithCollation;
 const decorateWithReadConcern = require('../utils').decorateWithReadConcern;
-const executeCommand = require('./db_ops').executeCommand;
-const handleCallback = require('../utils').handleCallback;
-const resolveReadPreference = require('../utils').resolveReadPreference;
 
 /**
  * Return a list of distinct values for the given key across a collection.
@@ -18,7 +15,7 @@ const resolveReadPreference = require('../utils').resolveReadPreference;
  * @property {object} query The query for filtering the set of documents to which we apply the distinct filter.
  * @property {object} [options] Optional settings. See Collection.prototype.distinct for a list of options.
  */
-class DistinctOperation extends OperationBase {
+class DistinctOperation extends CommandOperationV2 {
   /**
    * Construct a Distinct operation.
    *
@@ -28,7 +25,7 @@ class DistinctOperation extends OperationBase {
    * @param {object} [options] Optional settings. See Collection.prototype.distinct for a list of options.
    */
   constructor(collection, key, query, options) {
-    super(options);
+    super(collection, options);
 
     this.collection = collection;
     this.key = key;
@@ -40,14 +37,11 @@ class DistinctOperation extends OperationBase {
    *
    * @param {Collection~resultCallback} [callback] The command result callback
    */
-  execute(callback) {
+  execute(server, callback) {
     const coll = this.collection;
     const key = this.key;
     const query = this.query;
-    let options = this.options;
-
-    // maxTimeMS option
-    const maxTimeMS = options.maxTimeMS;
+    const options = this.options;
 
     // Distinct command
     const cmd = {
@@ -56,12 +50,10 @@ class DistinctOperation extends OperationBase {
       query: query
     };
 
-    options = Object.assign({}, options);
-    // Ensure we have the right read preference inheritance
-    options.readPreference = resolveReadPreference(coll, options);
-
     // Add maxTimeMS if defined
-    if (typeof maxTimeMS === 'number') cmd.maxTimeMS = maxTimeMS;
+    if (typeof options.maxTimeMS === 'number') {
+      cmd.maxTimeMS = options.maxTimeMS;
+    }
 
     // Do we have a readConcern specified
     decorateWithReadConcern(cmd, coll, options);
@@ -73,14 +65,21 @@ class DistinctOperation extends OperationBase {
       return callback(err, null);
     }
 
-    // Execute the command
-    executeCommand(coll.s.db, cmd, options, (err, result) => {
-      if (err) return handleCallback(callback, err);
-      handleCallback(callback, null, result.values);
+    super.executeCommand(server, cmd, (err, result) => {
+      if (err) {
+        callback(err);
+        return;
+      }
+
+      callback(null, this.options.full ? result : result.values);
     });
   }
 }
 
-defineAspects(DistinctOperation, Aspect.READ_OPERATION);
+defineAspects(DistinctOperation, [
+  Aspect.READ_OPERATION,
+  Aspect.RETRYABLE,
+  Aspect.EXECUTE_WITH_SELECTION
+]);
 
 module.exports = DistinctOperation;

package/lib/operations/drop.js

@@ -32,6 +32,7 @@ class DropCollectionOperation extends DropOperation {
     super(db, options);
 
     this.name = name;
+    this.namespace = `${db.namespace}.${name}`;
   }
 
   _buildCommand() {