mongodb 3.2.5 → 3.3.0-beta2

package/lib/operations/bulk_write.js

@@ -0,0 +1,104 @@
+'use strict';
+
+const applyRetryableWrites = require('../utils').applyRetryableWrites;
+const applyWriteConcern = require('../utils').applyWriteConcern;
+const MongoError = require('../core').MongoError;
+const OperationBase = require('./operation').OperationBase;
+
+class BulkWriteOperation extends OperationBase {
+  constructor(collection, operations, options) {
+    super(options);
+
+    this.collection = collection;
+    this.operations = operations;
+  }
+
+  execute(callback) {
+    const coll = this.collection;
+    const operations = this.operations;
+    let options = this.options;
+
+    // Add ignoreUndfined
+    if (coll.s.options.ignoreUndefined) {
+      options = Object.assign({}, options);
+      options.ignoreUndefined = coll.s.options.ignoreUndefined;
+    }
+
+    // Create the bulk operation
+    const bulk =
+      options.ordered === true || options.ordered == null
+        ? coll.initializeOrderedBulkOp(options)
+        : coll.initializeUnorderedBulkOp(options);
+
+    // Do we have a collation
+    let collation = false;
+
+    // for each op go through and add to the bulk
+    try {
+      for (let i = 0; i < operations.length; i++) {
+        // Get the operation type
+        const key = Object.keys(operations[i])[0];
+        // Check if we have a collation
+        if (operations[i][key].collation) {
+          collation = true;
+        }
+
+        // Pass to the raw bulk
+        bulk.raw(operations[i]);
+      }
+    } catch (err) {
+      return callback(err, null);
+    }
+
+    // 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);
+
+    const writeCon = finalOptions.writeConcern ? finalOptions.writeConcern : {};
+    const capabilities = coll.s.topology.capabilities();
+
+    // Did the user pass in a collation, check if our write server supports it
+    if (collation && capabilities && !capabilities.commandsTakeCollation) {
+      return callback(new MongoError('server/primary/mongos does not support collation'));
+    }
+
+    // Execute the bulk
+    bulk.execute(writeCon, finalOptions, (err, r) => {
+      // We have connection level error
+      if (!r && err) {
+        return callback(err, null);
+      }
+
+      r.insertedCount = r.nInserted;
+      r.matchedCount = r.nMatched;
+      r.modifiedCount = r.nModified || 0;
+      r.deletedCount = r.nRemoved;
+      r.upsertedCount = r.getUpsertedIds().length;
+      r.upsertedIds = {};
+      r.insertedIds = {};
+
+      // Update the n
+      r.n = r.insertedCount;
+
+      // Inserted documents
+      const inserted = r.getInsertedIds();
+      // Map inserted ids
+      for (let i = 0; i < inserted.length; i++) {
+        r.insertedIds[inserted[i].index] = inserted[i]._id;
+      }
+
+      // Upserted documents
+      const upserted = r.getUpsertedIds();
+      // Map upserted ids
+      for (let i = 0; i < upserted.length; i++) {
+        r.upsertedIds[upserted[i].index] = upserted[i]._id;
+      }
+
+      // Return the results
+      callback(null, r);
+    });
+  }
+}
+
+module.exports = BulkWriteOperation;

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

@@ -3,9 +3,8 @@
 const applyWriteConcern = require('../utils').applyWriteConcern;
 const applyRetryableWrites = require('../utils').applyRetryableWrites;
 const checkCollectionName = require('../utils').checkCollectionName;
-const Code = require('mongodb-core').BSON.Code;
+const Code = require('../core').BSON.Code;
 const createIndexDb = require('./db_ops').createIndex;
-const decorateCommand = require('../utils').decorateCommand;
 const decorateWithCollation = require('../utils').decorateWithCollation;
 const decorateWithReadConcern = require('../utils').decorateWithReadConcern;
 const ensureIndexDb = require('./db_ops').ensureIndex;
@@ -16,10 +15,9 @@ const formattedOrderClause = require('../utils').formattedOrderClause;
 const resolveReadPreference = require('../utils').resolveReadPreference;
 const handleCallback = require('../utils').handleCallback;
 const indexInformationDb = require('./db_ops').indexInformation;
-const isObject = require('../utils').isObject;
-const Long = require('mongodb-core').BSON.Long;
-const MongoError = require('mongodb-core').MongoError;
-const ReadPreference = require('mongodb-core').ReadPreference;
+const Long = require('../core').BSON.Long;
+const MongoError = require('../core').MongoError;
+const ReadPreference = require('../core').ReadPreference;
 const toError = require('../utils').toError;
 
 let collection;
@@ -29,13 +27,6 @@ function loadCollection() {
   }
   return collection;
 }
-let db;
-function loadDb() {
-  if (!db) {
-    db = require('../db');
-  }
-  return db;
-}
 
 /**
  * Group function helper
@@ -165,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
@@ -189,12 +184,9 @@ function checkForAtomicOperators(update) {
 function count(coll, query, options, callback) {
   if (typeof options === 'function') (callback = options), (options = {});
   options = Object.assign({}, options);
-  options.collectionName = coll.s.name;
+  options.collectionName = coll.collectionName;
 
-  options.readPreference = resolveReadPreference(options, {
-    db: coll.s.db,
-    collection: coll
-  });
+  options.readPreference = resolveReadPreference(coll, options);
 
   let cmd;
   try {
@@ -291,7 +283,7 @@ function buildCountCommand(collectionOrCursor, query, options) {
  * @param {Collection~resultCallback} [callback] The command result callback
  */
 function createIndex(coll, fieldOrSpec, options, callback) {
-  createIndexDb(coll.s.db, coll.s.name, fieldOrSpec, options, callback);
+  createIndexDb(coll.s.db, coll.collectionName, fieldOrSpec, options, callback);
 }
 
 /**
@@ -333,7 +325,7 @@ function createIndexes(coll, indexSpecs, options, callback) {
   executeCommand(
     coll.s.db,
     {
-      createIndexes: coll.s.name,
+      createIndexes: coll.collectionName,
       indexes: indexSpecs
     },
     options,
@@ -378,51 +370,6 @@ function deleteOne(coll, filter, options, callback) {
   removeDocuments(coll, filter, options, (err, r) => deleteCallback(err, r, callback));
 }
 
-/**
- * Return a list of distinct values for the given key across a collection.
- *
- * @method
- * @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.
- * @param {Collection~resultCallback} [callback] The command result callback
- */
-function distinct(coll, key, query, options, callback) {
-  // maxTimeMS option
-  const maxTimeMS = options.maxTimeMS;
-
-  // Distinct command
-  const cmd = {
-    distinct: coll.s.name,
-    key: key,
-    query: query
-  };
-
-  options = Object.assign({}, options);
-  // Ensure we have the right read preference inheritance
-  options.readPreference = resolveReadPreference(options, { db: coll.s.db, collection: coll });
-
-  // Add maxTimeMS if defined
-  if (typeof maxTimeMS === 'number') cmd.maxTimeMS = 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);
-  }
-
-  // Execute the command
-  executeCommand(coll.s.db, cmd, options, (err, result) => {
-    if (err) return handleCallback(callback, err);
-    handleCallback(callback, null, result.values);
-  });
-}
-
 /**
  * Drop an index from this collection.
  *
@@ -434,7 +381,7 @@ function distinct(coll, key, query, options, callback) {
  */
 function dropIndex(coll, indexName, options, callback) {
   // Delete index command
-  const cmd = { dropIndexes: coll.s.name, index: indexName };
+  const cmd = { dropIndexes: coll.collectionName, index: indexName };
 
   // Decorate command with writeConcern if supported
   applyWriteConcern(cmd, { db: coll.s.db, collection: coll }, options);
@@ -472,7 +419,7 @@ function dropIndexes(coll, options, callback) {
  * @param {Collection~resultCallback} [callback] The command result callback
  */
 function ensureIndex(coll, fieldOrSpec, options, callback) {
-  ensureIndexDb(coll.s.db, coll.s.name, fieldOrSpec, options, callback);
+  ensureIndexDb(coll.s.db, coll.collectionName, fieldOrSpec, options, callback);
 }
 
 /**
@@ -490,7 +437,7 @@ function ensureIndex(coll, fieldOrSpec, options, callback) {
 function findAndModify(coll, query, sort, doc, options, callback) {
   // Create findAndModify command object
   const queryObject = {
-    findAndModify: coll.s.name,
+    findAndModify: coll.collectionName,
     query: query
   };
 
@@ -661,43 +608,6 @@ function findOneAndUpdate(coll, filter, update, options, callback) {
   findAndModify(coll, filter, options.sort, update, finalOptions, callback);
 }
 
-/**
- * Execute a geo search using a geo haystack index on a collection.
- *
- * @method
- * @param {Collection} a Collection instance.
- * @param {number} x Point to search on the x axis, ensure the indexes are ordered in the same order.
- * @param {number} y Point to search on the y axis, ensure the indexes are ordered in the same order.
- * @param {object} [options] Optional settings. See Collection.prototype.geoHaystackSearch for a list of options.
- * @param {Collection~resultCallback} [callback] The command result callback
- */
-function geoHaystackSearch(coll, x, y, options, callback) {
-  // Build command object
-  let commandObject = {
-    geoSearch: coll.s.name,
-    near: [x, y]
-  };
-
-  // Remove read preference from hash if it exists
-  commandObject = decorateCommand(commandObject, options, ['readPreference', 'session']);
-
-  options = Object.assign({}, options);
-  // Ensure we have the right read preference inheritance
-  options.readPreference = resolveReadPreference(options, { db: coll.s.db, collection: coll });
-
-  // Do we have a readConcern specified
-  decorateWithReadConcern(commandObject, coll, options);
-
-  // Execute the command
-  executeCommand(coll.s.db, commandObject, options, (err, res) => {
-    if (err) return handleCallback(callback, err);
-    if (res.err || res.errmsg) handleCallback(callback, toError(res));
-    // should we only be returning res.results here? Not sure if the user
-    // should see the other return information
-    handleCallback(callback, null, res);
-  });
-}
-
 /**
  * Run a group command across a collection.
  *
@@ -720,7 +630,7 @@ function group(coll, keys, condition, initial, reduce, finalize, command, option
 
     const selector = {
       group: {
-        ns: coll.s.name,
+        ns: coll.collectionName,
         $reduce: reduceFunction,
         cond: condition,
         initial: initial,
@@ -743,7 +653,7 @@ function group(coll, keys, condition, initial, reduce, finalize, command, option
 
     options = Object.assign({}, options);
     // Ensure we have the right read preference inheritance
-    options.readPreference = resolveReadPreference(options, { db: coll.s.db, collection: coll });
+    options.readPreference = resolveReadPreference(coll, options);
 
     // Do we have a readConcern specified
     decorateWithReadConcern(selector, coll, options);
@@ -764,7 +674,7 @@ function group(coll, keys, condition, initial, reduce, finalize, command, option
     // Create execution scope
     const scope = reduce != null && reduce._bsontype === 'Code' ? reduce.scope : {};
 
-    scope.ns = coll.s.name;
+    scope.ns = coll.collectionName;
     scope.keys = keys;
     scope.condition = condition;
     scope.initial = initial;
@@ -789,7 +699,7 @@ function group(coll, keys, condition, initial, reduce, finalize, command, option
  */
 function indexes(coll, options, callback) {
   options = Object.assign({}, { full: true }, options);
-  indexInformationDb(coll.s.db, coll.s.name, options, callback);
+  indexInformationDb(coll.s.db, coll.collectionName, options, callback);
 }
 
 /**
@@ -829,7 +739,7 @@ function indexExists(coll, indexes, options, callback) {
  * @param {Collection~resultCallback} [callback] The command result callback
  */
 function indexInformation(coll, options, callback) {
-  indexInformationDb(coll.s.db, coll.s.name, options, callback);
+  indexInformationDb(coll.s.db, coll.collectionName, options, callback);
 }
 
 function insertDocuments(coll, docs, options, callback) {
@@ -958,120 +868,6 @@ function isCapped(coll, options, callback) {
   });
 }
 
-/**
- * Run Map Reduce across a collection. Be aware that the inline option for out will return an array of results not a collection.
- *
- * @method
- * @param {Collection} a Collection instance.
- * @param {(function|string)} map The mapping function.
- * @param {(function|string)} reduce The reduce function.
- * @param {object} [options] Optional settings. See Collection.prototype.mapReduce for a list of options.
- * @param {Collection~resultCallback} [callback] The command result callback
- */
-function mapReduce(coll, map, reduce, options, callback) {
-  const mapCommandHash = {
-    mapreduce: coll.s.name,
-    map: map,
-    reduce: reduce
-  };
-
-  // Exclusion list
-  const exclusionList = ['readPreference', 'session', 'bypassDocumentValidation'];
-
-  // Add any other options passed in
-  for (let n in options) {
-    if ('scope' === n) {
-      mapCommandHash[n] = processScope(options[n]);
-    } else {
-      // Only include if not in exclusion list
-      if (exclusionList.indexOf(n) === -1) {
-        mapCommandHash[n] = options[n];
-      }
-    }
-  }
-
-  options = Object.assign({}, options);
-
-  // Ensure we have the right read preference inheritance
-  options.readPreference = resolveReadPreference(options, { db: coll.s.db, collection: coll });
-
-  // If we have a read preference and inline is not set as output fail hard
-  if (
-    options.readPreference !== false &&
-    options.readPreference !== 'primary' &&
-    options['out'] &&
-    (options['out'].inline !== 1 && options['out'] !== 'inline')
-  ) {
-    // Force readPreference to primary
-    options.readPreference = 'primary';
-    // Decorate command with writeConcern if supported
-    applyWriteConcern(mapCommandHash, { db: coll.s.db, collection: coll }, options);
-  } else {
-    decorateWithReadConcern(mapCommandHash, coll, options);
-  }
-
-  // Is bypassDocumentValidation specified
-  if (options.bypassDocumentValidation === true) {
-    mapCommandHash.bypassDocumentValidation = options.bypassDocumentValidation;
-  }
-
-  // Have we specified collation
-  try {
-    decorateWithCollation(mapCommandHash, coll, options);
-  } catch (err) {
-    return callback(err, null);
-  }
-
-  // Execute command
-  executeCommand(coll.s.db, mapCommandHash, options, (err, result) => {
-    if (err) return handleCallback(callback, err);
-    // Check if we have an error
-    if (1 !== result.ok || result.err || result.errmsg) {
-      return handleCallback(callback, toError(result));
-    }
-
-    // Create statistics value
-    const stats = {};
-    if (result.timeMillis) stats['processtime'] = result.timeMillis;
-    if (result.counts) stats['counts'] = result.counts;
-    if (result.timing) stats['timing'] = result.timing;
-
-    // invoked with inline?
-    if (result.results) {
-      // If we wish for no verbosity
-      if (options['verbose'] == null || !options['verbose']) {
-        return handleCallback(callback, null, result.results);
-      }
-
-      return handleCallback(callback, null, { results: result.results, stats: stats });
-    }
-
-    // The returned collection
-    let collection = null;
-
-    // If we have an object it's a different db
-    if (result.result != null && typeof result.result === 'object') {
-      const doc = result.result;
-      // Return a collection from another db
-      let Db = loadDb();
-      collection = new Db(doc.db, coll.s.db.s.topology, coll.s.db.s.options).collection(
-        doc.collection
-      );
-    } else {
-      // Create a collection object that wraps the result collection
-      collection = coll.s.db.collection(result.result);
-    }
-
-    // If we wish for no verbosity
-    if (options['verbose'] == null || !options['verbose']) {
-      return handleCallback(callback, err, collection);
-    }
-
-    // Return stats as third set of values
-    handleCallback(callback, err, { collection: collection, stats: stats });
-  });
-}
-
 /**
  * Return the options of the collection.
  *
@@ -1081,12 +877,12 @@ function mapReduce(coll, map, reduce, options, callback) {
  * @param {Collection~resultCallback} [callback] The results callback
  */
 function optionsOp(coll, opts, callback) {
-  coll.s.db.listCollections({ name: coll.s.name }, opts).toArray((err, collections) => {
+  coll.s.db.listCollections({ name: coll.collectionName }, opts).toArray((err, collections) => {
     if (err) return handleCallback(callback, err);
     if (collections.length === 0) {
       return handleCallback(
         callback,
-        MongoError.create({ message: `collection ${coll.s.namespace} not found`, driver: true })
+        MongoError.create({ message: `collection ${coll.namespace} not found`, driver: true })
       );
     }
 
@@ -1106,7 +902,7 @@ function optionsOp(coll, opts, callback) {
 function parallelCollectionScan(coll, options, callback) {
   // Create command object
   const commandObject = {
-    parallelCollectionScan: coll.s.name,
+    parallelCollectionScan: coll.collectionName,
     numCursors: options.numCursors
   };
 
@@ -1138,7 +934,7 @@ function parallelCollectionScan(coll, options, callback) {
       // Convert cursorId to Long if needed
       const cursorId = typeof rawId === 'number' ? Long.fromNumber(rawId) : rawId;
       // Add a command cursor
-      cursors.push(coll.s.topology.cursor(coll.s.namespace, cursorId, options));
+      cursors.push(coll.s.topology.cursor(coll.namespace, cursorId, options));
     }
 
     handleCallback(callback, null, cursors);
@@ -1166,32 +962,6 @@ function prepareDocs(coll, docs, options) {
   });
 }
 
-/**
- * Functions that are passed as scope args must
- * be converted to Code instances.
- * @ignore
- */
-function processScope(scope) {
-  if (!isObject(scope) || scope._bsontype === 'ObjectID') {
-    return scope;
-  }
-
-  const keys = Object.keys(scope);
-  let key;
-  const new_scope = {};
-
-  for (let i = keys.length - 1; i >= 0; i--) {
-    key = keys[i];
-    if ('function' === typeof scope[key]) {
-      new_scope[key] = new Code(String(scope[key]));
-    } else {
-      new_scope[key] = processScope(scope[key]);
-    }
-  }
-
-  return new_scope;
-}
-
 /**
  * Reindex all indexes on the collection.
  *
@@ -1202,7 +972,7 @@ function processScope(scope) {
  */
 function reIndex(coll, options, callback) {
   // Reindex
-  const cmd = { reIndex: coll.s.name };
+  const cmd = { reIndex: coll.collectionName };
 
   // Execute the command
   executeCommand(coll.s.db, cmd, options, (err, result) => {
@@ -1274,8 +1044,8 @@ function rename(coll, newName, options, callback) {
   // Check the collection name
   checkCollectionName(newName);
   // Build the command
-  const renameCollection = `${coll.s.dbName}.${coll.s.name}`;
-  const toCollection = `${coll.s.dbName}.${newName}`;
+  const renameCollection = coll.s.namespace.toString();
+  const toCollection = coll.s.namespace.withCollection(newName);
   const dropTarget = typeof options.dropTarget === 'boolean' ? options.dropTarget : false;
   const cmd = { renameCollection: renameCollection, to: toCollection, dropTarget: dropTarget };
 
@@ -1294,7 +1064,7 @@ function rename(coll, newName, options, callback) {
         new Collection(
           coll.s.db,
           coll.s.topology,
-          coll.s.dbName,
+          coll.databaseName,
           newName,
           coll.s.pkFactory,
           coll.s.options
@@ -1372,31 +1142,6 @@ function save(coll, doc, options, callback) {
   });
 }
 
-/**
- * Get all the collection statistics.
- *
- * @method
- * @param {Collection} a Collection instance.
- * @param {object} [options] Optional settings. See Collection.prototype.stats for a list of options.
- * @param {Collection~resultCallback} [callback] The collection result callback
- */
-function stats(coll, options, callback) {
-  // Build command object
-  const commandObject = {
-    collStats: coll.s.name
-  };
-
-  // Check if we have the scale value
-  if (options['scale'] != null) commandObject['scale'] = options['scale'];
-
-  options = Object.assign({}, options);
-  // Ensure we have the right read preference inheritance
-  options.readPreference = resolveReadPreference(options, { db: coll.s.db, collection: coll });
-
-  // Execute the command
-  executeCommand(coll.s.db, commandObject, options, callback);
-}
-
 function updateCallback(err, r, callback) {
   if (callback == null) return;
   if (err) return callback(err);
@@ -1512,7 +1257,6 @@ module.exports = {
   createIndexes,
   deleteMany,
   deleteOne,
-  distinct,
   dropIndex,
   dropIndexes,
   ensureIndex,
@@ -1522,7 +1266,6 @@ module.exports = {
   findOneAndDelete,
   findOneAndReplace,
   findOneAndUpdate,
-  geoHaystackSearch,
   group,
   indexes,
   indexExists,
@@ -1530,7 +1273,6 @@ module.exports = {
   insertMany,
   insertOne,
   isCapped,
-  mapReduce,
   optionsOp,
   parallelCollectionScan,
   prepareDocs,
@@ -1539,7 +1281,6 @@ module.exports = {
   rename,
   replaceOne,
   save,
-  stats,
   updateDocuments,
   updateMany,
   updateOne