mongodb 3.2.5 → 3.3.0-beta2

package/lib/operations/create_index.js

@@ -0,0 +1,92 @@
+'use strict';
+
+const Aspect = require('./operation').Aspect;
+const CommandOperation = require('./command');
+const defineAspects = require('./operation').defineAspects;
+const handleCallback = require('../utils').handleCallback;
+const MongoError = require('../core').MongoError;
+const parseIndexOptions = require('../utils').parseIndexOptions;
+
+const keysToOmit = new Set([
+  'name',
+  'key',
+  'writeConcern',
+  'w',
+  'wtimeout',
+  'j',
+  'fsync',
+  'readPreference',
+  'session'
+]);
+
+class CreateIndexOperation extends CommandOperation {
+  constructor(db, name, fieldOrSpec, options) {
+    super(db, options);
+
+    // Build the index
+    const indexParameters = parseIndexOptions(fieldOrSpec);
+    // Generate the index name
+    const indexName = typeof options.name === 'string' ? options.name : indexParameters.name;
+    // Set up the index
+    const indexesObject = { name: indexName, key: indexParameters.fieldHash };
+
+    this.name = name;
+    this.fieldOrSpec = fieldOrSpec;
+    this.indexes = indexesObject;
+  }
+
+  _buildCommand() {
+    const options = this.options;
+    const name = this.name;
+    const indexes = this.indexes;
+
+    // merge all the options
+    for (let optionName in options) {
+      if (!keysToOmit.has(optionName)) {
+        indexes[optionName] = options[optionName];
+      }
+    }
+
+    // Create command, apply write concern to command
+    const cmd = { createIndexes: name, indexes: [indexes] };
+
+    return cmd;
+  }
+
+  execute(callback) {
+    const db = this.db;
+    const options = this.options;
+    const indexes = this.indexes;
+
+    // Get capabilities
+    const capabilities = db.s.topology.capabilities();
+
+    // Did the user pass in a collation, check if our write server supports it
+    if (options.collation && capabilities && !capabilities.commandsTakeCollation) {
+      // Create a new error
+      const error = new MongoError('server/primary/mongos does not support collation');
+      error.code = 67;
+      // Return the error
+      return callback(error);
+    }
+
+    // Ensure we have a callback
+    if (options.writeConcern && typeof callback !== 'function') {
+      throw MongoError.create({
+        message: 'Cannot use a writeConcern without a provided callback',
+        driver: true
+      });
+    }
+
+    // Attempt to run using createIndexes command
+    super.execute((err, result) => {
+      if (err == null) return handleCallback(callback, err, indexes.name);
+
+      return handleCallback(callback, err, result);
+    });
+  }
+}
+
+defineAspects(CreateIndexOperation, Aspect.WRITE_OPERATION);
+
+module.exports = CreateIndexOperation;

package/lib/operations/create_indexes.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const Aspect = require('./operation').Aspect;
+const defineAspects = require('./operation').defineAspects;
+const OperationBase = require('./operation').OperationBase;
+const executeCommand = require('./db_ops').executeCommand;
+const MongoError = require('../core').MongoError;
+const ReadPreference = require('../core').ReadPreference;
+
+class CreateIndexesOperation extends OperationBase {
+  constructor(collection, indexSpecs, options) {
+    super(options);
+
+    this.collection = collection;
+    this.indexSpecs = indexSpecs;
+  }
+
+  execute(callback) {
+    const coll = this.collection;
+    const indexSpecs = this.indexSpecs;
+    let options = this.options;
+
+    const capabilities = coll.s.topology.capabilities();
+
+    // Ensure we generate the correct name if the parameter is not set
+    for (let i = 0; i < indexSpecs.length; i++) {
+      if (indexSpecs[i].name == null) {
+        const keys = [];
+
+        // Did the user pass in a collation, check if our write server supports it
+        if (indexSpecs[i].collation && capabilities && !capabilities.commandsTakeCollation) {
+          return callback(new MongoError('server/primary/mongos does not support collation'));
+        }
+
+        for (let name in indexSpecs[i].key) {
+          keys.push(`${name}_${indexSpecs[i].key[name]}`);
+        }
+
+        // Set the name
+        indexSpecs[i].name = keys.join('_');
+      }
+    }
+
+    options = Object.assign({}, options, { readPreference: ReadPreference.PRIMARY });
+
+    // Execute the index
+    executeCommand(
+      coll.s.db,
+      {
+        createIndexes: coll.collectionName,
+        indexes: indexSpecs
+      },
+      options,
+      callback
+    );
+  }
+}
+
+defineAspects(CreateIndexesOperation, Aspect.WRITE_OPERATION);
+
+module.exports = CreateIndexesOperation;

package/lib/operations/cursor_ops.js

@@ -3,7 +3,7 @@
 const buildCountCommand = require('./collection_ops').buildCountCommand;
 const formattedOrderClause = require('../utils').formattedOrderClause;
 const handleCallback = require('../utils').handleCallback;
-const MongoError = require('mongodb-core').MongoError;
+const MongoError = require('../core').MongoError;
 const push = Array.prototype.push;
 
 let cursor;
@@ -49,8 +49,7 @@ function count(cursor, applySkipLimit, opts, callback) {
   options.maxTimeMS = opts.maxTimeMS;
 
   // Command
-  const delimiter = cursor.s.ns.indexOf('.');
-  options.collectionName = cursor.s.ns.substr(delimiter + 1);
+  options.collectionName = cursor.s.namespace.collection;
 
   let command;
   try {
@@ -64,7 +63,7 @@ function count(cursor, applySkipLimit, opts, callback) {
 
   // Execute the command
   cursor.s.topology.command(
-    `${cursor.s.ns.substr(0, delimiter)}.$cmd`,
+    cursor.s.namespace.withCollection('$cmd'),
     command,
     cursor.s.options,
     (err, result) => {

package/lib/operations/db_ops.js

@@ -1,16 +1,17 @@
 'use strict';
 
 const applyWriteConcern = require('../utils').applyWriteConcern;
-const Code = require('mongodb-core').BSON.Code;
+const Code = require('../core').BSON.Code;
 const resolveReadPreference = require('../utils').resolveReadPreference;
 const crypto = require('crypto');
 const debugOptions = require('../utils').debugOptions;
 const handleCallback = require('../utils').handleCallback;
-const MongoError = require('mongodb-core').MongoError;
+const MongoError = require('../core').MongoError;
 const parseIndexOptions = require('../utils').parseIndexOptions;
-const ReadPreference = require('mongodb-core').ReadPreference;
+const ReadPreference = require('../core').ReadPreference;
 const toError = require('../utils').toError;
 const CONSTANTS = require('../constants');
+const MongoDBNamespace = require('../utils').MongoDBNamespace;
 
 const count = require('./collection_ops').count;
 const findOne = require('./collection_ops').findOne;
@@ -166,7 +167,7 @@ function collections(db, options, callback) {
         return new Collection(
           db,
           db.s.topology,
-          db.s.databaseName,
+          db.databaseName,
           d.name,
           db.s.pkFactory,
           db.s.options
@@ -219,7 +220,7 @@ function createCollection(db, name, options, callback) {
           return handleCallback(
             callback,
             null,
-            new Collection(db, db.s.topology, db.s.databaseName, name, db.s.pkFactory, options)
+            new Collection(db, db.s.topology, db.databaseName, name, db.s.pkFactory, options)
           );
         } catch (err) {
           return handleCallback(callback, err);
@@ -253,7 +254,7 @@ function createCollection(db, name, options, callback) {
           return handleCallback(
             callback,
             null,
-            new Collection(db, db.s.topology, db.s.databaseName, name, db.s.pkFactory, options)
+            new Collection(db, db.s.topology, db.databaseName, name, db.s.pkFactory, options)
           );
         } catch (err) {
           return handleCallback(callback, err);
@@ -318,7 +319,7 @@ function createIndex(db, name, fieldOrSpec, options, callback) {
     finalOptions.checkKeys = false;
     // Insert document
     db.s.topology.insert(
-      `${db.s.databaseName}.${CONSTANTS.SYSTEM_INDEX_COLLECTION}`,
+      db.s.namespace.withCollection(CONSTANTS.SYSTEM_INDEX_COLLECTION),
       doc,
       finalOptions,
       (err, result) => {
@@ -494,10 +495,10 @@ function executeCommand(db, command, options, callback) {
   if (db.serverConfig && db.serverConfig.isDestroyed())
     return callback(new MongoError('topology was destroyed'));
   // Get the db name we are executing against
-  const dbName = options.dbName || options.authdb || db.s.databaseName;
+  const dbName = options.dbName || options.authdb || db.databaseName;
 
   // Convert the readPreference if its not a write
-  options.readPreference = resolveReadPreference(options, { db, default: ReadPreference.primary });
+  options.readPreference = resolveReadPreference(db, options);
 
   // Debug information
   if (db.s.logger.isDebug())
@@ -510,7 +511,7 @@ function executeCommand(db, command, options, callback) {
     );
 
   // Execute command
-  db.s.topology.command(`${dbName}.$cmd`, command, options, (err, result) => {
+  db.s.topology.command(db.s.namespace.withCollection('$cmd'), command, options, (err, result) => {
     if (err) return handleCallback(callback, err);
     if (options.full) return handleCallback(callback, null, result);
     handleCallback(callback, null, result.result);
@@ -527,7 +528,9 @@ function executeCommand(db, command, options, callback) {
  * @param {Db~resultCallback} [callback] The command result callback
  */
 function executeDbAdminCommand(db, command, options, callback) {
-  db.s.topology.command('admin.$cmd', command, options, (err, result) => {
+  const namespace = new MongoDBNamespace('admin', '$cmd');
+
+  db.s.topology.command(namespace, command, options, (err, result) => {
     // Did the user destroy the topology
     if (db.serverConfig && db.serverConfig.isDestroyed()) {
       return callback(new MongoError('topology was destroyed'));
@@ -748,7 +751,7 @@ function createCreateIndexCommand(db, name, fieldOrSpec, options) {
   // Generate the index name
   const indexName = typeof options.name === 'string' ? options.name : indexParameters.name;
   const selector = {
-    ns: db.databaseName + '.' + name,
+    ns: db.s.namespace.withCollection(name).toString(),
     key: fieldHash,
     name: indexName
   };

package/lib/operations/delete_many.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const OperationBase = require('./operation').OperationBase;
+const deleteCallback = require('./common_functions').deleteCallback;
+const removeDocuments = require('./common_functions').removeDocuments;
+
+class DeleteManyOperation extends OperationBase {
+  constructor(collection, filter, options) {
+    super(options);
+
+    this.collection = collection;
+    this.filter = filter;
+  }
+
+  execute(callback) {
+    const coll = this.collection;
+    const filter = this.filter;
+    const options = this.options;
+
+    options.single = false;
+    removeDocuments(coll, filter, options, (err, r) => deleteCallback(err, r, callback));
+  }
+}
+
+module.exports = DeleteManyOperation;

package/lib/operations/delete_one.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const OperationBase = require('./operation').OperationBase;
+const deleteCallback = require('./common_functions').deleteCallback;
+const removeDocuments = require('./common_functions').removeDocuments;
+
+class DeleteOneOperation extends OperationBase {
+  constructor(collection, filter, options) {
+    super(options);
+
+    this.collection = collection;
+    this.filter = filter;
+  }
+
+  execute(callback) {
+    const coll = this.collection;
+    const filter = this.filter;
+    const options = this.options;
+
+    options.single = true;
+    removeDocuments(coll, filter, options, (err, r) => deleteCallback(err, r, callback));
+  }
+}
+
+module.exports = DeleteOneOperation;

package/lib/operations/distinct.js

@@ -0,0 +1,85 @@
+'use strict';
+
+const Aspect = require('./operation').Aspect;
+const defineAspects = require('./operation').defineAspects;
+const CommandOperationV2 = require('./command_v2');
+const decorateWithCollation = require('../utils').decorateWithCollation;
+const decorateWithReadConcern = require('../utils').decorateWithReadConcern;
+
+/**
+ * Return a list of distinct values for the given key across a collection.
+ *
+ * @class
+ * @property {Collection} a Collection instance.
+ * @property {string} key Field of the document to find distinct values for.
+ * @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 CommandOperationV2 {
+  /**
+   * Construct a Distinct operation.
+   *
+   * @param {Collection} a Collection instance.
+   * @param {string} key Field of the document to find distinct values for.
+   * @param {object} query The query for filtering the set of documents to which we apply the distinct filter.
+   * @param {object} [options] Optional settings. See Collection.prototype.distinct for a list of options.
+   */
+  constructor(collection, key, query, options) {
+    super(collection, options);
+
+    this.collection = collection;
+    this.key = key;
+    this.query = query;
+  }
+
+  /**
+   * Execute the operation.
+   *
+   * @param {Collection~resultCallback} [callback] The command result callback
+   */
+  execute(server, callback) {
+    const coll = this.collection;
+    const key = this.key;
+    const query = this.query;
+    const options = this.options;
+
+    // Distinct command
+    const cmd = {
+      distinct: coll.collectionName,
+      key: key,
+      query: query
+    };
+
+    // Add maxTimeMS if defined
+    if (typeof options.maxTimeMS === 'number') {
+      cmd.maxTimeMS = options.maxTimeMS;
+    }
+
+    // Do we have a readConcern specified
+    decorateWithReadConcern(cmd, coll, options);
+
+    // Have we specified collation
+    try {
+      decorateWithCollation(cmd, coll, options);
+    } catch (err) {
+      return callback(err, null);
+    }
+
+    super.executeCommand(server, cmd, (err, result) => {
+      if (err) {
+        callback(err);
+        return;
+      }
+
+      callback(null, this.options.full ? result : result.values);
+    });
+  }
+}
+
+defineAspects(DistinctOperation, [
+  Aspect.READ_OPERATION,
+  Aspect.RETRYABLE,
+  Aspect.EXECUTE_WITH_SELECTION
+]);
+
+module.exports = DistinctOperation;

package/lib/operations/drop.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const Aspect = require('./operation').Aspect;
+const CommandOperation = require('./command');
+const defineAspects = require('./operation').defineAspects;
+const handleCallback = require('../utils').handleCallback;
+
+class DropOperation extends CommandOperation {
+  constructor(db, options) {
+    const finalOptions = Object.assign({}, options, db.s.options);
+
+    if (options.session) {
+      finalOptions.session = options.session;
+    }
+
+    super(db, finalOptions);
+  }
+
+  execute(callback) {
+    super.execute((err, result) => {
+      if (err) return handleCallback(callback, err);
+      if (result.ok) return handleCallback(callback, null, true);
+      handleCallback(callback, null, false);
+    });
+  }
+}
+
+defineAspects(DropOperation, Aspect.WRITE_OPERATION);
+
+class DropCollectionOperation extends DropOperation {
+  constructor(db, name, options) {
+    super(db, options);
+
+    this.name = name;
+    this.namespace = `${db.namespace}.${name}`;
+  }
+
+  _buildCommand() {
+    return { drop: this.name };
+  }
+}
+
+class DropDatabaseOperation extends DropOperation {
+  _buildCommand() {
+    return { dropDatabase: 1 };
+  }
+}
+
+module.exports = {
+  DropOperation,
+  DropCollectionOperation,
+  DropDatabaseOperation
+};

package/lib/operations/drop_index.js

@@ -0,0 +1,42 @@
+'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;
+
+class DropIndexOperation extends CommandOperation {
+  constructor(collection, indexName, options) {
+    super(collection.s.db, options, collection);
+
+    this.collection = collection;
+    this.indexName = indexName;
+  }
+
+  _buildCommand() {
+    const collection = this.collection;
+    const indexName = this.indexName;
+    const options = this.options;
+
+    let cmd = { dropIndexes: collection.collectionName, index: indexName };
+
+    // Decorate command with writeConcern if supported
+    cmd = applyWriteConcern(cmd, { db: collection.s.db, collection }, options);
+
+    return cmd;
+  }
+
+  execute(callback) {
+    // Execute command
+    super.execute((err, result) => {
+      if (typeof callback !== 'function') return;
+      if (err) return handleCallback(callback, err, null);
+      handleCallback(callback, null, result);
+    });
+  }
+}
+
+defineAspects(DropIndexOperation, Aspect.WRITE_OPERATION);
+
+module.exports = DropIndexOperation;

package/lib/operations/drop_indexes.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const Aspect = require('./operation').Aspect;
+const defineAspects = require('./operation').defineAspects;
+const DropIndexOperation = require('./drop_index');
+const handleCallback = require('../utils').handleCallback;
+
+class DropIndexesOperation extends DropIndexOperation {
+  constructor(collection, options) {
+    super(collection, '*', options);
+  }
+
+  execute(callback) {
+    super.execute(err => {
+      if (err) return handleCallback(callback, err, false);
+      handleCallback(callback, null, true);
+    });
+  }
+}
+
+defineAspects(DropIndexesOperation, Aspect.WRITE_OPERATION);
+
+module.exports = DropIndexesOperation;

package/lib/operations/estimated_document_count.js

@@ -0,0 +1,33 @@
+'use strict';
+
+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);
+  }
+
+  _buildCommand() {
+    const coll = this.collection;
+    let options = this.options;
+
+    options.collectionName = coll.collectionName;
+
+    return buildCountCommand(coll, null, options);
+  }
+
+  execute(callback) {
+    super.execute((err, result) => {
+      if (err) return handleCallback(callback, err);
+      handleCallback(callback, null, result.n);
+    });
+  }
+}
+
+defineAspects(EstimatedDocumentCountOperation, Aspect.READ_OPERATION);
+
+module.exports = EstimatedDocumentCountOperation;

package/lib/operations/execute_db_admin_command.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const OperationBase = require('./operation').OperationBase;
+const handleCallback = require('../utils').handleCallback;
+const MongoError = require('../core').MongoError;
+const MongoDBNamespace = require('../utils').MongoDBNamespace;
+
+class ExecuteDbAdminCommandOperation extends OperationBase {
+  constructor(db, selector, options) {
+    super(options);
+
+    this.db = db;
+    this.selector = selector;
+  }
+
+  execute(callback) {
+    const db = this.db;
+    const selector = this.selector;
+    const options = this.options;
+
+    const namespace = new MongoDBNamespace('admin', '$cmd');
+    db.s.topology.command(namespace, selector, options, (err, result) => {
+      // Did the user destroy the topology
+      if (db.serverConfig && db.serverConfig.isDestroyed()) {
+        return callback(new MongoError('topology was destroyed'));
+      }
+
+      if (err) return handleCallback(callback, err);
+      handleCallback(callback, null, result.result);
+    });
+  }
+}
+
+module.exports = ExecuteDbAdminCommandOperation;