mongodb 3.2.5 → 3.3.0-beta2

package/lib/operations/insert_one.js

@@ -0,0 +1,75 @@
+'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;
+
+class InsertOneOperation extends OperationBase {
+  constructor(collection, doc, options) {
+    super(options);
+
+    this.collection = collection;
+    this.doc = doc;
+  }
+
+  execute(callback) {
+    const coll = this.collection;
+    const doc = this.doc;
+    const options = this.options;
+
+    if (Array.isArray(doc)) {
+      return callback(
+        MongoError.create({ message: 'doc parameter must be an object', driver: true })
+      );
+    }
+
+    insertDocuments(coll, [doc], options, (err, r) => {
+      if (callback == null) return;
+      if (err && callback) return callback(err);
+      // Workaround for pre 2.6 servers
+      if (r == null) return callback(null, { result: { ok: 1 } });
+      // Add values to top level to ensure crud spec compatibility
+      r.insertedCount = r.result.n;
+      r.insertedId = doc._id;
+      if (callback) callback(null, r);
+    });
+  }
+}
+
+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;

package/lib/operations/is_capped.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const OptionsOperation = require('./options_operation');
+const handleCallback = require('../utils').handleCallback;
+
+class IsCappedOperation extends OptionsOperation {
+  constructor(collection, options) {
+    super(collection, options);
+  }
+
+  execute(callback) {
+    super.execute((err, document) => {
+      if (err) return handleCallback(callback, err);
+      handleCallback(callback, null, !!(document && document.capped));
+    });
+  }
+}
+
+module.exports = IsCappedOperation;

package/lib/operations/list_indexes.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const OperationBase = require('./operation').OperationBase;
+const CommandCursor = require('../command_cursor');
+const MongoError = require('../core').MongoError;
+const resolveReadPreference = require('../utils').resolveReadPreference;
+
+class ListIndexesOperation extends OperationBase {
+  constructor(collection, options) {
+    super(options);
+
+    this.collection = collection;
+  }
+
+  execute() {
+    const coll = this.collection;
+    let options = this.options;
+
+    options = options || {};
+    // Clone the options
+    options = Object.assign({}, options);
+    // Determine the read preference in the options.
+    options.readPreference = resolveReadPreference(coll, options);
+    // Set the CommandCursor constructor
+    options.cursorFactory = CommandCursor;
+    // Set the promiseLibrary
+    options.promiseLibrary = coll.s.promiseLibrary;
+
+    if (!coll.s.topology.capabilities()) {
+      throw new MongoError('cannot connect to server');
+    }
+
+    // Cursor options
+    let cursor = options.batchSize ? { batchSize: options.batchSize } : {};
+
+    // We have a list collections command
+    if (coll.s.topology.capabilities().hasListIndexesCommand) {
+      // Build the command
+      const command = { listIndexes: coll.collectionName, cursor: cursor };
+      // Execute the cursor
+      cursor = coll.s.topology.cursor(
+        coll.s.namespace.withCollection('$cmd').toString(),
+        command,
+        options
+      );
+      // Do we have a readPreference, apply it
+      if (options.readPreference) cursor.setReadPreference(options.readPreference);
+      // Return the cursor
+      return cursor;
+    }
+
+    // Get the namespace
+    const namespace = coll.s.namespace.withCollection('system.indexes');
+    const ns = namespace.toString();
+    // Get the query
+    cursor = coll.s.topology.cursor(ns, { find: ns, query: { ns: coll.namespace } }, options);
+    // Do we have a readPreference, apply it
+    if (options.readPreference) cursor.setReadPreference(options.readPreference);
+    // Set the passed in batch size if one was provided
+    if (options.batchSize) cursor = cursor.batchSize(options.batchSize);
+    // Return the cursor
+    return cursor;
+  }
+}
+
+module.exports = ListIndexesOperation;

package/lib/operations/map_reduce.js

@@ -0,0 +1,189 @@
+'use strict';
+
+const applyWriteConcern = require('../utils').applyWriteConcern;
+const Code = require('../core').BSON.Code;
+const decorateWithCollation = require('../utils').decorateWithCollation;
+const decorateWithReadConcern = require('../utils').decorateWithReadConcern;
+const executeCommand = require('./db_ops').executeCommand;
+const handleCallback = require('../utils').handleCallback;
+const isObject = require('../utils').isObject;
+const loadDb = require('../dynamic_loaders').loadDb;
+const OperationBase = require('./operation').OperationBase;
+const resolveReadPreference = require('../utils').resolveReadPreference;
+const toError = require('../utils').toError;
+
+const exclusionList = [
+  'readPreference',
+  'session',
+  'bypassDocumentValidation',
+  'w',
+  'wtimeout',
+  'j',
+  'writeConcern'
+];
+
+/**
+ * Run Map Reduce across a collection. Be aware that the inline option for out will return an array of results not a collection.
+ *
+ * @class
+ * @property {Collection} a Collection instance.
+ * @property {(function|string)} map The mapping function.
+ * @property {(function|string)} reduce The reduce function.
+ * @property {object} [options] Optional settings. See Collection.prototype.mapReduce for a list of options.
+ */
+class MapReduceOperation extends OperationBase {
+  /**
+   * Constructs a MapReduce operation.
+   *
+   * @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.
+   */
+  constructor(collection, map, reduce, options) {
+    super(options);
+
+    this.collection = collection;
+    this.map = map;
+    this.reduce = reduce;
+  }
+
+  /**
+   * Execute the operation.
+   *
+   * @param {Collection~resultCallback} [callback] The command result callback
+   */
+  execute(callback) {
+    const coll = this.collection;
+    const map = this.map;
+    const reduce = this.reduce;
+    let options = this.options;
+
+    const mapCommandHash = {
+      mapreduce: coll.collectionName,
+      map: map,
+      reduce: reduce
+    };
+
+    // 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(coll, options);
+
+    // 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 });
+    });
+  }
+}
+
+/**
+ * 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;
+}
+
+module.exports = MapReduceOperation;

package/lib/operations/next.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const Aspect = require('./operation').Aspect;
+const defineAspects = require('./operation').defineAspects;
+const OperationBase = require('./operation').OperationBase;
+const nextObject = require('./common_functions').nextObject;
+
+class NextOperation extends OperationBase {
+  constructor(cursor) {
+    super();
+
+    this.cursor = cursor;
+  }
+
+  execute(callback) {
+    const cursor = this.cursor;
+
+    // Return the currentDoc if someone called hasNext first
+    if (cursor.s.currentDoc) {
+      const doc = cursor.s.currentDoc;
+      cursor.s.currentDoc = null;
+      return callback(null, doc);
+    }
+
+    // Return the next object
+    nextObject(cursor, callback);
+  }
+}
+
+defineAspects(NextOperation, Aspect.SKIP_SESSION);
+
+module.exports = NextOperation;

package/lib/operations/operation.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const Aspect = {
+  READ_OPERATION: Symbol('READ_OPERATION'),
+  SKIP_SESSION: Symbol('SKIP_SESSION'),
+  WRITE_OPERATION: Symbol('WRITE_OPERATION'),
+  RETRYABLE: Symbol('RETRYABLE'),
+  EXECUTE_WITH_SELECTION: Symbol('EXECUTE_WITH_SELECTION')
+};
+
+/**
+ * This class acts as a parent class for any operation and is responsible for setting this.options,
+ * as well as setting and getting a session.
+ * Additionally, this class implements `hasAspect`, which determines whether an operation has
+ * a specific aspect, including `SKIP_SESSION` and other aspects to encode retryability
+ * and other functionality.
+ */
+class OperationBase {
+  constructor(options) {
+    this.options = Object.assign({}, options);
+  }
+
+  hasAspect(aspect) {
+    if (this.constructor.aspects == null) {
+      return false;
+    }
+    return this.constructor.aspects.has(aspect);
+  }
+
+  set session(session) {
+    Object.assign(this.options, { session });
+  }
+
+  get session() {
+    return this.options.session;
+  }
+
+  clearSession() {
+    delete this.options.session;
+  }
+
+  execute() {
+    throw new TypeError('`execute` must be implemented for OperationBase subclasses');
+  }
+}
+
+function defineAspects(operation, aspects) {
+  if (!Array.isArray(aspects) && !(aspects instanceof Set)) {
+    aspects = [aspects];
+  }
+  aspects = new Set(aspects);
+  Object.defineProperty(operation, 'aspects', {
+    value: aspects,
+    writable: false
+  });
+  return aspects;
+}
+
+module.exports = {
+  Aspect,
+  defineAspects,
+  OperationBase
+};

package/lib/operations/options_operation.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const OperationBase = require('./operation').OperationBase;
+const handleCallback = require('../utils').handleCallback;
+const MongoError = require('../core').MongoError;
+
+class OptionsOperation extends OperationBase {
+  constructor(collection, options) {
+    super(options);
+
+    this.collection = collection;
+  }
+
+  execute(callback) {
+    const coll = this.collection;
+    const opts = this.options;
+
+    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.namespace} not found`, driver: true })
+        );
+      }
+
+      handleCallback(callback, err, collections[0].options || null);
+    });
+  }
+}
+
+module.exports = OptionsOperation;

package/lib/operations/profiling_level.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const CommandOperation = require('./command');
+
+class ProfilingLevelOperation extends CommandOperation {
+  constructor(db, command, options) {
+    super(db, options);
+  }
+
+  _buildCommand() {
+    const command = { profile: -1 };
+
+    return command;
+  }
+
+  execute(callback) {
+    super.execute((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);
+      }
+    });
+  }
+}
+
+module.exports = ProfilingLevelOperation;

package/lib/operations/re_index.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const CommandOperation = require('./command');
+const handleCallback = require('../utils').handleCallback;
+
+class ReIndexOperation extends CommandOperation {
+  constructor(collection, options) {
+    super(collection.s.db, options, collection);
+  }
+
+  _buildCommand() {
+    const collection = this.collection;
+
+    const cmd = { reIndex: collection.collectionName };
+
+    return cmd;
+  }
+
+  execute(callback) {
+    super.execute((err, result) => {
+      if (callback == null) return;
+      if (err) return handleCallback(callback, err, null);
+      handleCallback(callback, null, result.ok ? true : false);
+    });
+  }
+}
+
+module.exports = ReIndexOperation;

package/lib/operations/remove_user.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const Aspect = require('./operation').Aspect;
+const CommandOperation = require('./command');
+const defineAspects = require('./operation').defineAspects;
+const handleCallback = require('../utils').handleCallback;
+const WriteConcern = require('../write_concern');
+
+class RemoveUserOperation extends CommandOperation {
+  constructor(db, username, options) {
+    const commandOptions = {};
+
+    const writeConcern = WriteConcern.fromOptions(options);
+    if (writeConcern != null) {
+      commandOptions.writeConcern = writeConcern;
+    }
+
+    if (options.dbName) {
+      commandOptions.dbName = options.dbName;
+    }
+
+    // Add maxTimeMS to options if set
+    if (typeof options.maxTimeMS === 'number') {
+      commandOptions.maxTimeMS = options.maxTimeMS;
+    }
+
+    super(db, commandOptions);
+
+    this.username = username;
+  }
+
+  _buildCommand() {
+    const username = this.username;
+
+    // Build the command to execute
+    const command = { dropUser: username };
+
+    return command;
+  }
+
+  execute(callback) {
+    // Attempt to execute command
+    super.execute((err, result) => {
+      if (err) return handleCallback(callback, err, null);
+      handleCallback(callback, err, result.ok ? true : false);
+    });
+  }
+}
+
+defineAspects(RemoveUserOperation, [Aspect.WRITE_OPERATION, Aspect.SKIP_SESSIONS]);
+
+module.exports = RemoveUserOperation;

package/lib/operations/rename.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const OperationBase = require('./operation').OperationBase;
+const applyWriteConcern = require('../utils').applyWriteConcern;
+const checkCollectionName = require('../utils').checkCollectionName;
+const executeDbAdminCommand = require('./db_ops').executeDbAdminCommand;
+const handleCallback = require('../utils').handleCallback;
+const loadCollection = require('../dynamic_loaders').loadCollection;
+const toError = require('../utils').toError;
+
+class RenameOperation extends OperationBase {
+  constructor(collection, newName, options) {
+    super(options);
+
+    this.collection = collection;
+    this.newName = newName;
+  }
+
+  execute(callback) {
+    const coll = this.collection;
+    const newName = this.newName;
+    const options = this.options;
+
+    let Collection = loadCollection();
+    // Check the collection name
+    checkCollectionName(newName);
+    // Build the command
+    const renameCollection = coll.namespace;
+    const toCollection = coll.s.namespace.withCollection(newName).toString();
+    const dropTarget = typeof options.dropTarget === 'boolean' ? options.dropTarget : false;
+    const cmd = { renameCollection: renameCollection, to: toCollection, dropTarget: dropTarget };
+
+    // Decorate command with writeConcern if supported
+    applyWriteConcern(cmd, { db: coll.s.db, collection: coll }, options);
+
+    // Execute against admin
+    executeDbAdminCommand(coll.s.db.admin().s.db, cmd, options, (err, doc) => {
+      if (err) return handleCallback(callback, err, null);
+      // We have an error
+      if (doc.errmsg) return handleCallback(callback, toError(doc), null);
+      try {
+        return handleCallback(
+          callback,
+          null,
+          new Collection(
+            coll.s.db,
+            coll.s.topology,
+            coll.databaseName,
+            newName,
+            coll.s.pkFactory,
+            coll.s.options
+          )
+        );
+      } catch (err) {
+        return handleCallback(callback, toError(err), null);
+      }
+    });
+  }
+}
+
+module.exports = RenameOperation;