mongodb 3.2.5 → 3.3.0-beta2

package/lib/operations/{mongo_client_ops.js → connect.js}

@@ -1,16 +1,21 @@
 '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('mongodb-core').Logger;
-const MongoError = require('mongodb-core').MongoError;
+const Logger = require('../core').Logger;
+const MongoCredentials = require('../core').MongoCredentials;
+const MongoError = require('../core').MongoError;
 const Mongos = require('../topologies/mongos');
-const parse = require('mongodb-core').parseConnectionString;
-const ReadPreference = require('mongodb-core').ReadPreference;
+const NativeTopology = require('../topologies/native_topology');
+const parse = require('../core').parseConnectionString;
+const ReadConcern = require('../read_concern');
+const ReadPreference = require('../core').ReadPreference;
 const ReplSet = require('../topologies/replset');
 const Server = require('../topologies/server');
-const ServerSessionPool = require('mongodb-core').Sessions.ServerSessionPool;
-const NativeTopology = require('../topologies/native_topology');
-const MongoCredentials = require('mongodb-core').MongoCredentials;
+const ServerSessionPool = require('../core').Sessions.ServerSessionPool;
 
 let client;
 function loadClient() {
@@ -20,6 +25,21 @@ function loadClient() {
   return client;
 }
 
+const legacyParse = deprecate(
+  require('../url_parser'),
+  'current URL string parser is deprecated, and will be removed in a future version. ' +
+    'To use the new parser, pass option { useNewUrlParser: true } to MongoClient.connect.'
+);
+
+const AUTH_MECHANISM_INTERNAL_MAP = {
+  DEFAULT: 'default',
+  'MONGODB-CR': 'mongocr',
+  PLAIN: 'plain',
+  'MONGODB-X509': 'x509',
+  'SCRAM-SHA-1': 'scram-sha-1',
+  'SCRAM-SHA-256': 'scram-sha-256'
+};
+
 const monitoringEvents = [
   'timeout',
   'close',
@@ -43,13 +63,17 @@ const monitoringEvents = [
   'fullsetup',
   'open'
 ];
-const ignoreOptionNames = ['native_parser'];
-const legacyOptionNames = ['server', 'replset', 'replSet', 'mongos', 'db'];
-const legacyParse = deprecate(
-  require('../url_parser'),
-  'current URL string parser is deprecated, and will be removed in a future version. ' +
-    'To use the new parser, pass option { useNewUrlParser: true } to MongoClient.connect.'
-);
+
+const VALID_AUTH_MECHANISMS = new Set([
+  'DEFAULT',
+  'MONGODB-CR',
+  'PLAIN',
+  'MONGODB-X509',
+  'SCRAM-SHA-1',
+  'SCRAM-SHA-256',
+  'GSSAPI'
+]);
+
 const validOptionNames = [
   'poolSize',
   'ssl',
@@ -109,12 +133,70 @@ const validOptionNames = [
   'minSize',
   'monitorCommands',
   'retryWrites',
+  'retryReads',
   'useNewUrlParser',
   'useUnifiedTopology',
   'serverSelectionTimeoutMS',
-  'useRecoveryToken'
+  '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) {
+    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'));
@@ -160,19 +242,6 @@ function collectEvents(mongoClient, topology) {
   return collectedEvents;
 }
 
-/**
- * Connect to MongoDB using a url as documented at
- *
- *  docs.mongodb.org/manual/reference/connection-string/
- *
- * Note that for replicasets the replicaSet query parameter is required in the 2.0 driver
- *
- * @method
- * @param {MongoClient} mongoClient The MongoClient instance with which to connect.
- * @param {string} url The connection URI string
- * @param {object} [options] Optional settings. See MongoClient.prototype.connect for a list of options.
- * @param {MongoClient~connectCallback} [callback] The command result callback
- */
 function connect(mongoClient, url, options, callback) {
   options = Object.assign({}, options);
 
@@ -205,6 +274,8 @@ function connect(mongoClient, url, options, callback) {
     // Check if we have connection and socket timeout set
     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;
@@ -266,27 +337,6 @@ function connect(mongoClient, url, options, callback) {
   }
 }
 
-/**
- * Connect to MongoDB using a url as documented at
- *
- *  docs.mongodb.org/manual/reference/connection-string/
- *
- * Note that for replicasets the replicaSet query parameter is required in the 2.0 driver
- *
- * @method
- * @param {MongoClient} mongoClient The MongoClient instance with which to connect.
- * @param {MongoClient~connectCallback} [callback] The command result callback
- */
-function connectOp(mongoClient, err, callback) {
-  // 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);
-  });
-}
-
 function connectWithUrl(mongoClient, url, options, connectCallback) {
   // Set the topology
   assignTopology(mongoClient, url);
@@ -414,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);
+    });
   });
 }
 
@@ -453,6 +546,42 @@ function createUnifiedOptions(finalOptions, options) {
   return finalOptions;
 }
 
+function generateCredentials(client, username, password, options) {
+  options = Object.assign({}, options);
+
+  // the default db to authenticate against is 'self'
+  // if authententicate is called from a retry context, it may be another one, like admin
+  const source = options.authSource || options.authdb || options.dbName;
+
+  // authMechanism
+  const authMechanismRaw = options.authMechanism || 'DEFAULT';
+  const authMechanism = authMechanismRaw.toUpperCase();
+
+  if (!VALID_AUTH_MECHANISMS.has(authMechanism)) {
+    throw MongoError.create({
+      message: `authentication mechanism ${authMechanismRaw} not supported', options.authMechanism`,
+      driver: true
+    });
+  }
+
+  if (authMechanism === 'GSSAPI') {
+    return new MongoCredentials({
+      mechanism: process.platform === 'win32' ? 'sspi' : 'gssapi',
+      mechanismProperties: options,
+      source,
+      username,
+      password
+    });
+  }
+
+  return new MongoCredentials({
+    mechanism: AUTH_MECHANISM_INTERNAL_MAP[authMechanism],
+    source,
+    username,
+    password
+  });
+}
+
 function legacyTransformUrlOptions(object) {
   return mergeOptions(createUnifiedOptions({}, object), object, false);
 }
@@ -505,11 +634,6 @@ function replayEvents(mongoClient, events) {
   }
 }
 
-const LEGACY_OPTIONS_MAP = validOptionNames.reduce((obj, name) => {
-  obj[name.toLowerCase()] = name;
-  return obj;
-}, {});
-
 function transformUrlOptions(_object) {
   let object = Object.assign({ servers: _object.hosts }, _object.options);
   for (let name in object) {
@@ -541,13 +665,17 @@ function transformUrlOptions(_object) {
   }
 
   if (object.readconcernlevel) {
-    object.readConcern = { level: object.readconcernlevel };
+    object.readConcern = new ReadConcern(object.readconcernlevel);
   }
 
   if (object.wtimeoutms) {
     object.wtimeout = object.wtimeoutms;
   }
 
+  if (_object.srvHost) {
+    object.srvHost = _object.srvHost;
+  }
+
   return object;
 }
 
@@ -585,104 +713,4 @@ function translateOptions(options, translationOptions) {
   });
 }
 
-// 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 VALID_AUTH_MECHANISMS = new Set([
-  'DEFAULT',
-  'MONGODB-CR',
-  'PLAIN',
-  'MONGODB-X509',
-  'SCRAM-SHA-1',
-  'SCRAM-SHA-256',
-  'GSSAPI'
-]);
-
-const AUTH_MECHANISM_INTERNAL_MAP = {
-  DEFAULT: 'default',
-  'MONGODB-CR': 'mongocr',
-  PLAIN: 'plain',
-  'MONGODB-X509': 'x509',
-  'SCRAM-SHA-1': 'scram-sha-1',
-  'SCRAM-SHA-256': 'scram-sha-256'
-};
-
-function generateCredentials(client, username, password, options) {
-  options = Object.assign({}, options);
-
-  // the default db to authenticate against is 'self'
-  // if authenticate is called from a retry context, it may be another one, like admin
-  const source = options.authSource || options.authdb || options.dbName;
-
-  // authMechanism
-  const authMechanismRaw = options.authMechanism || 'DEFAULT';
-  const authMechanism = authMechanismRaw.toUpperCase();
-
-  if (!VALID_AUTH_MECHANISMS.has(authMechanism)) {
-    throw MongoError.create({
-      message: `authentication mechanism ${authMechanismRaw} not supported', options.authMechanism`,
-      driver: true
-    });
-  }
-
-  if (authMechanism === 'GSSAPI') {
-    return new MongoCredentials({
-      mechanism: process.platform === 'win32' ? 'sspi' : 'gssapi',
-      mechanismProperties: options,
-      source,
-      username,
-      password
-    });
-  }
-
-  return new MongoCredentials({
-    mechanism: AUTH_MECHANISM_INTERNAL_MAP[authMechanism],
-    source,
-    username,
-    password
-  });
-}
-
-function closeOperation(client, force, callback) {
-  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);
-  };
-
-  if (client.topology == null) {
-    completeClose();
-    return;
-  }
-
-  client.topology.close(force, completeClose);
-}
-
-module.exports = { connectOp, validOptions, closeOperation };
+module.exports = ConnectOperation;

package/lib/operations/count.js

@@ -0,0 +1,72 @@
+'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 {
+  constructor(cursor, applySkipLimit, options) {
+    super(options);
+
+    this.cursor = cursor;
+    this.applySkipLimit = applySkipLimit;
+  }
+
+  execute(callback) {
+    const cursor = this.cursor;
+    const applySkipLimit = this.applySkipLimit;
+    const options = this.options;
+
+    if (applySkipLimit) {
+      if (typeof cursor.cursorSkip() === 'number') options.skip = cursor.cursorSkip();
+      if (typeof cursor.cursorLimit() === 'number') options.limit = cursor.cursorLimit();
+    }
+
+    // Ensure we have the right read preference inheritance
+    if (options.readPreference) {
+      cursor.setReadPreference(options.readPreference);
+    }
+
+    if (
+      typeof options.maxTimeMS !== 'number' &&
+      cursor.s.cmd &&
+      typeof cursor.s.cmd.maxTimeMS === 'number'
+    ) {
+      options.maxTimeMS = cursor.s.cmd.maxTimeMS;
+    }
+
+    let finalOptions = {};
+    finalOptions.skip = options.skip;
+    finalOptions.limit = options.limit;
+    finalOptions.hint = options.hint;
+    finalOptions.maxTimeMS = options.maxTimeMS;
+
+    // Command
+    finalOptions.collectionName = cursor.s.namespace.collection;
+
+    let command;
+    try {
+      command = buildCountCommand(cursor, cursor.s.cmd.query, finalOptions);
+    } catch (err) {
+      return callback(err);
+    }
+
+    // Set cursor server to the same as the topology
+    cursor.server = cursor.topology.s.coreTopology;
+
+    // Execute the command
+    cursor.s.topology.command(
+      cursor.s.namespace.withCollection('$cmd'),
+      command,
+      cursor.s.options,
+      (err, result) => {
+        callback(err, result ? result.result.n : null);
+      }
+    );
+  }
+}
+
+defineAspects(CountOperation, Aspect.SKIP_SESSION);
+
+module.exports = CountOperation;

package/lib/operations/count_documents.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const OperationBase = require('./operation').OperationBase;
+const handleCallback = require('../utils').handleCallback;
+
+class CountDocumentsOperation extends OperationBase {
+  constructor(collection, query, options) {
+    super(options);
+
+    this.collection = collection;
+    this.query = query;
+  }
+
+  execute(callback) {
+    const coll = this.collection;
+    const query = this.query;
+    let options = this.options;
+
+    const skip = options.skip;
+    const limit = options.limit;
+    options = Object.assign({}, options);
+
+    const pipeline = [{ $match: query }];
+
+    // Add skip and limit if defined
+    if (typeof skip === 'number') {
+      pipeline.push({ $skip: skip });
+    }
+
+    if (typeof limit === 'number') {
+      pipeline.push({ $limit: limit });
+    }
+
+    pipeline.push({ $group: { _id: 1, n: { $sum: 1 } } });
+
+    delete options.limit;
+    delete options.skip;
+
+    coll.aggregate(pipeline, options).toArray((err, docs) => {
+      if (err) return handleCallback(callback, err);
+      handleCallback(callback, null, docs.length ? docs[0].n : 0);
+    });
+  }
+}
+
+module.exports = CountDocumentsOperation;

package/lib/operations/create_collection.js

@@ -0,0 +1,118 @@
+'use strict';
+
+const Aspect = require('./operation').Aspect;
+const defineAspects = require('./operation').defineAspects;
+const CommandOperation = require('./command');
+const applyWriteConcern = require('../utils').applyWriteConcern;
+const handleCallback = require('../utils').handleCallback;
+const loadCollection = require('../dynamic_loaders').loadCollection;
+const MongoError = require('../core').MongoError;
+const ReadPreference = require('../core').ReadPreference;
+
+// Filter out any write concern options
+const illegalCommandFields = [
+  'w',
+  'wtimeout',
+  'j',
+  'fsync',
+  'autoIndexId',
+  'strict',
+  'serializeFunctions',
+  'pkFactory',
+  'raw',
+  'readPreference',
+  'session',
+  'readConcern',
+  'writeConcern'
+];
+
+class CreateCollectionOperation extends CommandOperation {
+  constructor(db, name, options) {
+    super(db, options);
+
+    this.name = name;
+  }
+
+  _buildCommand() {
+    const name = this.name;
+    const options = this.options;
+
+    // Create collection command
+    const cmd = { create: name };
+    // Add all optional parameters
+    for (let n in options) {
+      if (
+        options[n] != null &&
+        typeof options[n] !== 'function' &&
+        illegalCommandFields.indexOf(n) === -1
+      ) {
+        cmd[n] = options[n];
+      }
+    }
+
+    return cmd;
+  }
+
+  execute(callback) {
+    const db = this.db;
+    const name = this.name;
+    const options = this.options;
+
+    let Collection = loadCollection();
+
+    // Did the user destroy the topology
+    if (db.serverConfig && db.serverConfig.isDestroyed()) {
+      return callback(new MongoError('topology was destroyed'));
+    }
+
+    let listCollectionOptions = Object.assign({}, options, { nameOnly: true });
+    listCollectionOptions = applyWriteConcern(listCollectionOptions, { db }, listCollectionOptions);
+
+    // Check if we have the name
+    db
+      .listCollections({ name }, listCollectionOptions)
+      .setReadPreference(ReadPreference.PRIMARY)
+      .toArray((err, collections) => {
+        if (err != null) return handleCallback(callback, err, null);
+        if (collections.length > 0 && listCollectionOptions.strict) {
+          return handleCallback(
+            callback,
+            MongoError.create({
+              message: `Collection ${name} already exists. Currently in strict mode.`,
+              driver: true
+            }),
+            null
+          );
+        } else if (collections.length > 0) {
+          try {
+            return handleCallback(
+              callback,
+              null,
+              new Collection(db, db.s.topology, db.databaseName, name, db.s.pkFactory, options)
+            );
+          } catch (err) {
+            return handleCallback(callback, err);
+          }
+        }
+
+        // Execute command
+        super.execute(err => {
+          if (err) return handleCallback(callback, err);
+
+          try {
+            return handleCallback(
+              callback,
+              null,
+              new Collection(db, db.s.topology, db.databaseName, name, db.s.pkFactory, options)
+            );
+          } catch (err) {
+            return handleCallback(callback, err);
+          }
+        });
+      });
+  }
+}
+
+defineAspects(CreateCollectionOperation, Aspect.WRITE_OPERATION);
+
+module.exports = CreateCollectionOperation;