mongodb 3.3.0-beta1 → 3.3.2

package/lib/operations/db_ops.js

@@ -55,21 +55,6 @@ const debugFields = [
   'noListener'
 ];
 
-// Filter out any write concern options
-const illegalCommandFields = [
-  'w',
-  'wtimeout',
-  'j',
-  'fsync',
-  'autoIndexId',
-  'strict',
-  'serializeFunctions',
-  'pkFactory',
-  'raw',
-  'readPreference',
-  'session'
-];
-
 /**
  * Add a user to the database.
  * @method
@@ -177,92 +162,6 @@ function collections(db, options, callback) {
   });
 }
 
-/**
- * Create a new collection on a server with the specified options. Use this to create capped collections.
- * More information about command options available at https://docs.mongodb.com/manual/reference/command/create/
- *
- * @method
- * @param {Db} db The Db instance on which to create the collection.
- * @param {string} name The collection name to create.
- * @param {object} [options] Optional settings. See Db.prototype.createCollection for a list of options.
- * @param {Db~collectionResultCallback} [callback] The results callback
- */
-function createCollection(db, name, options, callback) {
-  let Collection = loadCollection();
-
-  // Get the write concern options
-  const finalOptions = applyWriteConcern(Object.assign({}, options), { db }, options);
-
-  // Did the user destroy the topology
-  if (db.serverConfig && db.serverConfig.isDestroyed()) {
-    return callback(new MongoError('topology was destroyed'));
-  }
-
-  const listCollectionOptions = Object.assign({}, finalOptions, { nameOnly: true });
-
-  // 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 && finalOptions.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);
-        }
-      }
-
-      // Create collection command
-      const cmd = { create: name };
-
-      // Decorate command with writeConcern if supported
-      applyWriteConcern(cmd, { db }, options);
-
-      // 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];
-        }
-      }
-
-      // Force a primary read Preference
-      finalOptions.readPreference = ReadPreference.PRIMARY;
-      // Execute command
-      executeCommand(db, cmd, finalOptions, 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);
-        }
-      });
-    });
-}
-
 /**
  * Creates an index on the db and collection.
  * @method
@@ -586,23 +485,6 @@ function indexInformation(db, name, options, callback) {
     });
 }
 
-// Transformation methods for cursor results
-function listCollectionsTransforms(databaseName) {
-  const matching = `${databaseName}.`;
-
-  return {
-    doc: doc => {
-      const index = doc.name.indexOf(matching);
-      // Remove database name if available
-      if (doc.name && index === 0) {
-        doc.name = doc.name.substr(index + matching.length);
-      }
-
-      return doc;
-    }
-  };
-}
-
 /**
  * Retrieve the current profiling information for MongoDB
  *
@@ -623,28 +505,6 @@ function profilingInfo(db, options, callback) {
   }
 }
 
-/**
- * Retrieve the current profiling level for MongoDB
- *
- * @method
- * @param {Db} db The Db instance on which to retrieve the profiling level.
- * @param {Object} [options] Optional settings. See Db.prototype.profilingLevel for a list of options.
- * @param {Db~resultCallback} [callback] The command result callback
- */
-function profilingLevel(db, options, callback) {
-  executeCommand(db, { profile: -1 }, options, (err, doc) => {
-    if (err == null && doc.ok === 1) {
-      const was = doc.was;
-      if (was === 0) return callback(null, 'off');
-      if (was === 1) return callback(null, 'slow_only');
-      if (was === 2) return callback(null, 'all');
-      return callback(new Error('Error: illegal profiling level value ' + was), null);
-    } else {
-      err != null ? callback(err, null) : callback(new Error('Error with profile command'), null);
-    }
-  });
-}
-
 /**
  * Remove a user from a database
  *
@@ -683,40 +543,6 @@ function removeUser(db, username, options, callback) {
   });
 }
 
-/**
- * Set the current profiling level of MongoDB
- *
- * @method
- * @param {Db} db The Db instance on which to execute the command.
- * @param {string} level The new profiling level (off, slow_only, all).
- * @param {Object} [options] Optional settings. See Db.prototype.setProfilingLevel for a list of options.
- * @param {Db~resultCallback} [callback] The command result callback.
- */
-function setProfilingLevel(db, level, options, callback) {
-  const command = {};
-  let profile = 0;
-
-  if (level === 'off') {
-    profile = 0;
-  } else if (level === 'slow_only') {
-    profile = 1;
-  } else if (level === 'all') {
-    profile = 2;
-  } else {
-    return callback(new Error('Error: illegal profiling level value ' + level));
-  }
-
-  // Set up the profile number
-  command['profile'] = profile;
-
-  executeCommand(db, command, options, (err, doc) => {
-    if (err == null && doc.ok === 1) return callback(null, level);
-    return err != null
-      ? callback(err, null)
-      : callback(new Error('Error with profile command'), null);
-  });
-}
-
 // Validate the database name
 function validateDatabaseName(databaseName) {
   if (typeof databaseName !== 'string')
@@ -990,7 +816,6 @@ function executeAuthRemoveUserCommand(db, username, options, callback) {
 module.exports = {
   addUser,
   collections,
-  createCollection,
   createListener,
   createIndex,
   dropCollection,
@@ -999,11 +824,8 @@ module.exports = {
   evaluate,
   executeCommand,
   executeDbAdminCommand,
-  listCollectionsTransforms,
   indexInformation,
   profilingInfo,
-  profilingLevel,
   removeUser,
-  setProfilingLevel,
   validateDatabaseName
 };

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() {

package/lib/operations/estimated_document_count.js

@@ -2,32 +2,57 @@
 
 const Aspect = require('./operation').Aspect;
 const defineAspects = require('./operation').defineAspects;
-const CommandOperation = require('./command');
-const buildCountCommand = require('./common_functions').buildCountCommand;
-const handleCallback = require('../utils').handleCallback;
-
-class EstimatedDocumentCountOperation extends CommandOperation {
-  constructor(collection, options) {
-    super(collection.s.db, options, collection);
+const CommandOperationV2 = require('./command_v2');
+
+class EstimatedDocumentCountOperation extends CommandOperationV2 {
+  constructor(collection, query, options) {
+    if (typeof options === 'undefined') {
+      options = query;
+      query = undefined;
+    }
+
+    super(collection, options);
+    this.collectionName = collection.s.namespace.collection;
+    if (query) {
+      this.query = query;
+    }
   }
 
-  _buildCommand() {
-    const coll = this.collection;
-    let options = this.options;
+  execute(server, callback) {
+    const options = this.options;
+    const cmd = { count: this.collectionName };
 
-    options.collectionName = coll.collectionName;
+    if (this.query) {
+      cmd.query = this.query;
+    }
 
-    return buildCountCommand(coll, null, options);
-  }
+    if (typeof options.skip === 'number') {
+      cmd.skip = options.skip;
+    }
+
+    if (typeof options.limit === 'number') {
+      cmd.limit = options.limit;
+    }
+
+    if (options.hint) {
+      cmd.hint = options.hint;
+    }
+
+    super.executeCommand(server, cmd, (err, response) => {
+      if (err) {
+        callback(err);
+        return;
+      }
 
-  execute(callback) {
-    super.execute((err, result) => {
-      if (err) return handleCallback(callback, err);
-      handleCallback(callback, null, result.n);
+      callback(null, response.n);
     });
   }
 }
 
-defineAspects(EstimatedDocumentCountOperation, Aspect.READ_OPERATION);
+defineAspects(EstimatedDocumentCountOperation, [
+  Aspect.READ_OPERATION,
+  Aspect.RETRYABLE,
+  Aspect.EXECUTE_WITH_SELECTION
+]);
 
 module.exports = EstimatedDocumentCountOperation;

package/lib/operations/execute_operation.js

@@ -1,8 +1,12 @@
 'use strict';
 
-const MongoError = require('../core').MongoError;
+const MongoError = require('../core/error').MongoError;
 const Aspect = require('./operation').Aspect;
 const OperationBase = require('./operation').OperationBase;
+const ReadPreference = require('../core/topologies/read_preference');
+const isRetryableError = require('../core/error').isRetryableError;
+const maxWireVersion = require('../core/utils').maxWireVersion;
+const isUnifiedTopology = require('../core/utils').isUnifiedTopology;
 
 /**
  * Executes the given operation with provided arguments.
@@ -26,6 +30,14 @@ function executeOperation(topology, operation, callback) {
     throw new TypeError('This method requires a valid operation instance');
   }
 
+  if (
+    isUnifiedTopology(topology) &&
+    !operation.hasAspect(Aspect.SKIP_SESSION) &&
+    topology.shouldCheckForSessionSupport()
+  ) {
+    return selectServerForSessionSupport(topology, operation, callback);
+  }
+
   const Promise = topology.s.promiseLibrary;
 
   // The driver sessions spec mandates that we implicitly create sessions for operations
@@ -65,7 +77,11 @@ function executeOperation(topology, operation, callback) {
     );
 
     try {
-      return operation.execute(handler);
+      if (operation.hasAspect(Aspect.EXECUTE_WITH_SELECTION)) {
+        return executeWithServerSelection(topology, operation, handler);
+      } else {
+        return operation.execute(handler);
+      }
     } catch (e) {
       handler(e);
       throw e;
@@ -76,11 +92,107 @@ function executeOperation(topology, operation, callback) {
     const handler = makeExecuteCallback(resolve, reject);
 
     try {
-      return operation.execute(handler);
+      if (operation.hasAspect(Aspect.EXECUTE_WITH_SELECTION)) {
+        return executeWithServerSelection(topology, operation, handler);
+      } else {
+        return operation.execute(handler);
+      }
     } catch (e) {
       handler(e);
     }
   });
 }
 
+function supportsRetryableReads(server) {
+  return maxWireVersion(server) >= 6;
+}
+
+function executeWithServerSelection(topology, operation, callback) {
+  const readPreference = operation.readPreference || ReadPreference.primary;
+  const inTransaction = operation.session && operation.session.inTransaction();
+
+  if (inTransaction && !readPreference.equals(ReadPreference.primary)) {
+    callback(
+      new MongoError(
+        `Read preference in a transaction must be primary, not: ${readPreference.mode}`
+      )
+    );
+
+    return;
+  }
+
+  const serverSelectionOptions = {
+    readPreference,
+    session: operation.session
+  };
+
+  function callbackWithRetry(err, result) {
+    if (err == null) {
+      return callback(null, result);
+    }
+
+    if (!isRetryableError(err)) {
+      return callback(err);
+    }
+
+    // select a new server, and attempt to retry the operation
+    topology.selectServer(serverSelectionOptions, (err, server) => {
+      if (err || !supportsRetryableReads(server)) {
+        callback(err, null);
+        return;
+      }
+
+      operation.execute(server, callback);
+    });
+  }
+
+  // select a server, and execute the operation against it
+  topology.selectServer(serverSelectionOptions, (err, server) => {
+    if (err) {
+      callback(err, null);
+      return;
+    }
+
+    const shouldRetryReads =
+      topology.s.options.retryReads !== false &&
+      (operation.session && !inTransaction) &&
+      supportsRetryableReads(server) &&
+      operation.canRetryRead;
+
+    if (operation.hasAspect(Aspect.RETRYABLE) && shouldRetryReads) {
+      operation.execute(server, callbackWithRetry);
+      return;
+    }
+
+    operation.execute(server, callback);
+  });
+}
+
+// TODO: This is only supported for unified topology, it should go away once
+//       we remove support for legacy topology types.
+function selectServerForSessionSupport(topology, operation, callback) {
+  const Promise = topology.s.promiseLibrary;
+
+  let result;
+  if (typeof callback !== 'function') {
+    result = new Promise((resolve, reject) => {
+      callback = (err, result) => {
+        if (err) return reject(err);
+        resolve(result);
+      };
+    });
+  }
+
+  topology.selectServer(ReadPreference.primaryPreferred, err => {
+    if (err) {
+      callback(err);
+      return;
+    }
+
+    executeOperation(topology, operation, callback);
+  });
+
+  return result;
+}
+
 module.exports = executeOperation;

package/lib/operations/explain.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const Aspect = require('./operation').Aspect;
-const CoreCursor = require('../core').Cursor;
+const CoreCursor = require('../core/cursor').CoreCursor;
 const defineAspects = require('./operation').defineAspects;
 const OperationBase = require('./operation').OperationBase;
 
@@ -14,11 +14,7 @@ class ExplainOperation extends OperationBase {
 
   execute() {
     const cursor = this.cursor;
-
-    if (cursor._initImplicitSession) {
-      cursor._initImplicitSession();
-    }
-    return CoreCursor.prototype.next.apply(cursor, arguments);
+    return CoreCursor.prototype._next.apply(cursor, arguments);
   }
 }
 

package/lib/operations/find.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const OperationBase = require('./operation').OperationBase;
+const Aspect = require('./operation').Aspect;
+const defineAspects = require('./operation').defineAspects;
+const resolveReadPreference = require('../utils').resolveReadPreference;
+
+class FindOperation extends OperationBase {
+  constructor(collection, ns, command, options) {
+    super(options);
+
+    this.ns = ns;
+    this.cmd = command;
+    this.readPreference = resolveReadPreference(collection, this.options);
+  }
+
+  execute(server, callback) {
+    // copied from `CommandOperationV2`, to be subclassed in the future
+    this.server = server;
+
+    const cursorState = this.cursorState || {};
+
+    // TOOD: use `MongoDBNamespace` through and through
+    server.query(this.ns.toString(), this.cmd, cursorState, this.options, callback);
+  }
+}
+
+defineAspects(FindOperation, [
+  Aspect.READ_OPERATION,
+  Aspect.RETRYABLE,
+  Aspect.EXECUTE_WITH_SELECTION,
+  Aspect.SKIP_SESSION
+]);
+
+module.exports = FindOperation;

package/lib/operations/insert_one.js

@@ -1,12 +1,8 @@
 'use strict';
 
-const applyRetryableWrites = require('../utils').applyRetryableWrites;
-const applyWriteConcern = require('../utils').applyWriteConcern;
-const handleCallback = require('../utils').handleCallback;
 const MongoError = require('../core').MongoError;
 const OperationBase = require('./operation').OperationBase;
-const prepareDocs = require('./common_functions').prepareDocs;
-const toError = require('../utils').toError;
+const insertDocuments = require('./common_functions').insertDocuments;
 
 class InsertOneOperation extends OperationBase {
   constructor(collection, doc, options) {
@@ -40,36 +36,4 @@ class InsertOneOperation extends OperationBase {
   }
 }
 
-function insertDocuments(coll, docs, options, callback) {
-  if (typeof options === 'function') (callback = options), (options = {});
-  options = options || {};
-  // Ensure we are operating on an array op docs
-  docs = Array.isArray(docs) ? docs : [docs];
-
-  // Final options for retryable writes and write concern
-  let finalOptions = Object.assign({}, options);
-  finalOptions = applyRetryableWrites(finalOptions, coll.s.db);
-  finalOptions = applyWriteConcern(finalOptions, { db: coll.s.db, collection: coll }, options);
-
-  // If keep going set unordered
-  if (finalOptions.keepGoing === true) finalOptions.ordered = false;
-  finalOptions.serializeFunctions = options.serializeFunctions || coll.s.serializeFunctions;
-
-  docs = prepareDocs(coll, docs, options);
-
-  // File inserts
-  coll.s.topology.insert(coll.s.namespace, docs, finalOptions, (err, result) => {
-    if (callback == null) return;
-    if (err) return handleCallback(callback, err);
-    if (result == null) return handleCallback(callback, null, null);
-    if (result.result.code) return handleCallback(callback, toError(result.result));
-    if (result.result.writeErrors)
-      return handleCallback(callback, toError(result.result.writeErrors[0]));
-    // Add docs to the list
-    result.ops = docs;
-    // Return the results
-    handleCallback(callback, null, result);
-  });
-}
-
 module.exports = InsertOneOperation;