mongodb 3.2.5 → 3.3.0-beta2

package/lib/operations/collections.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const OperationBase = require('./operation').OperationBase;
+const handleCallback = require('../utils').handleCallback;
+
+let collection;
+function loadCollection() {
+  if (!collection) {
+    collection = require('../collection');
+  }
+  return collection;
+}
+
+class CollectionsOperation extends OperationBase {
+  constructor(db, options) {
+    super(options);
+
+    this.db = db;
+  }
+
+  execute(callback) {
+    const db = this.db;
+    let options = this.options;
+
+    let Collection = loadCollection();
+
+    options = Object.assign({}, options, { nameOnly: true });
+    // Let's get the collection names
+    db.listCollections({}, options).toArray((err, documents) => {
+      if (err != null) return handleCallback(callback, err, null);
+      // Filter collections removing any illegal ones
+      documents = documents.filter(doc => {
+        return doc.name.indexOf('$') === -1;
+      });
+
+      // Return the collection objects
+      handleCallback(
+        callback,
+        null,
+        documents.map(d => {
+          return new Collection(
+            db,
+            db.s.topology,
+            db.databaseName,
+            d.name,
+            db.s.pkFactory,
+            db.s.options
+          );
+        })
+      );
+    });
+  }
+}
+
+module.exports = CollectionsOperation;

package/lib/operations/command.js

@@ -0,0 +1,120 @@
+'use strict';
+
+const Aspect = require('./operation').Aspect;
+const OperationBase = require('./operation').OperationBase;
+const applyWriteConcern = require('../utils').applyWriteConcern;
+const debugOptions = require('../utils').debugOptions;
+const handleCallback = require('../utils').handleCallback;
+const MongoError = require('../core').MongoError;
+const ReadPreference = require('../core').ReadPreference;
+const resolveReadPreference = require('../utils').resolveReadPreference;
+const MongoDBNamespace = require('../utils').MongoDBNamespace;
+
+const debugFields = [
+  'authSource',
+  'w',
+  'wtimeout',
+  'j',
+  'native_parser',
+  'forceServerObjectId',
+  'serializeFunctions',
+  'raw',
+  'promoteLongs',
+  'promoteValues',
+  'promoteBuffers',
+  'bufferMaxEntries',
+  'numberOfRetries',
+  'retryMiliSeconds',
+  'readPreference',
+  'pkFactory',
+  'parentDb',
+  'promiseLibrary',
+  'noListener'
+];
+
+class CommandOperation extends OperationBase {
+  constructor(db, options, collection, command) {
+    super(options);
+
+    if (!this.hasAspect(Aspect.WRITE_OPERATION)) {
+      if (collection != null) {
+        this.options.readPreference = resolveReadPreference(collection, options);
+      } else {
+        this.options.readPreference = resolveReadPreference(db, options);
+      }
+    } else {
+      if (collection != null) {
+        applyWriteConcern(this.options, { db, coll: collection }, this.options);
+      } else {
+        applyWriteConcern(this.options, { db }, this.options);
+      }
+      this.options.readPreference = ReadPreference.primary;
+    }
+
+    this.db = db;
+
+    if (command != null) {
+      this.command = command;
+    }
+
+    if (collection != null) {
+      this.collection = collection;
+    }
+  }
+
+  _buildCommand() {
+    if (this.command != null) {
+      return this.command;
+    }
+  }
+
+  execute(callback) {
+    const db = this.db;
+    const options = Object.assign({}, this.options);
+
+    // Did the user destroy the topology
+    if (db.serverConfig && db.serverConfig.isDestroyed()) {
+      return callback(new MongoError('topology was destroyed'));
+    }
+
+    let command;
+    try {
+      command = this._buildCommand();
+    } catch (e) {
+      return callback(e);
+    }
+
+    // Get the db name we are executing against
+    const dbName = options.dbName || options.authdb || db.databaseName;
+
+    // Convert the readPreference if its not a write
+    if (this.hasAspect(Aspect.WRITE_OPERATION)) {
+      if (options.writeConcern && (!options.session || !options.session.inTransaction())) {
+        command.writeConcern = options.writeConcern;
+      }
+    }
+
+    // Debug information
+    if (db.s.logger.isDebug()) {
+      db.s.logger.debug(
+        `executing command ${JSON.stringify(
+          command
+        )} against ${dbName}.$cmd with options [${JSON.stringify(
+          debugOptions(debugFields, options)
+        )}]`
+      );
+    }
+
+    const namespace =
+      this.namespace != null ? this.namespace : new MongoDBNamespace(dbName, '$cmd');
+
+    // Execute command
+    db.s.topology.command(namespace, command, options, (err, result) => {
+      if (err) return handleCallback(callback, err);
+      if (options.full) return handleCallback(callback, null, result);
+      handleCallback(callback, null, result.result);
+    });
+  }
+}
+
+module.exports = CommandOperation;

package/lib/operations/command_v2.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const OperationBase = require('./operation').OperationBase;
+const resolveReadPreference = require('../utils').resolveReadPreference;
+
+class CommandOperationV2 extends OperationBase {
+  constructor(parent, options) {
+    super(options);
+
+    this.ns = parent.s.namespace.withCollection('$cmd');
+    this.readPreference = resolveReadPreference(parent, options);
+
+    // TODO(NODE-2056): make logger another "inheritable" property
+    if (parent.s.logger) {
+      this.logger = parent.s.logger;
+    } else if (parent.s.db && parent.s.db.logger) {
+      this.logger = parent.s.db.logger;
+    }
+  }
+
+  executeCommand(server, cmd, callback) {
+    if (this.logger && this.logger.isDebug()) {
+      this.logger.debug(`executing command ${JSON.stringify(cmd)} against ${this.ns}`);
+    }
+
+    server.command(this.ns.toString(), cmd, this.options, (err, result) => {
+      if (err) {
+        callback(err, null);
+        return;
+      }
+
+      // full response was requested
+      if (this.options.full) {
+        callback(null, result);
+        return;
+      }
+
+      callback(null, result.result);
+    });
+  }
+}
+
+module.exports = CommandOperationV2;

package/lib/operations/common_functions.js

@@ -0,0 +1,372 @@
+'use strict';
+
+const applyRetryableWrites = require('../utils').applyRetryableWrites;
+const applyWriteConcern = require('../utils').applyWriteConcern;
+const decorateWithCollation = require('../utils').decorateWithCollation;
+const decorateWithReadConcern = require('../utils').decorateWithReadConcern;
+const executeCommand = require('./db_ops').executeCommand;
+const formattedOrderClause = require('../utils').formattedOrderClause;
+const handleCallback = require('../utils').handleCallback;
+const loadCursor = require('../dynamic_loaders').loadCursor;
+const MongoError = require('../core').MongoError;
+const ReadPreference = require('../core').ReadPreference;
+const toError = require('../utils').toError;
+
+/**
+ * Build the count command.
+ *
+ * @method
+ * @param {collectionOrCursor} an instance of a collection or cursor
+ * @param {object} query The query for the count.
+ * @param {object} [options] Optional settings. See Collection.prototype.count and Cursor.prototype.count for a list of options.
+ */
+function buildCountCommand(collectionOrCursor, query, options) {
+  const skip = options.skip;
+  const limit = options.limit;
+  let hint = options.hint;
+  const maxTimeMS = options.maxTimeMS;
+  query = query || {};
+
+  // Final query
+  const cmd = {
+    count: options.collectionName,
+    query: query
+  };
+
+  // check if collectionOrCursor is a cursor by using cursor.s.numberOfRetries
+  if (collectionOrCursor.s.numberOfRetries) {
+    if (collectionOrCursor.s.options.hint) {
+      hint = collectionOrCursor.s.options.hint;
+    } else if (collectionOrCursor.s.cmd.hint) {
+      hint = collectionOrCursor.s.cmd.hint;
+    }
+    decorateWithCollation(cmd, collectionOrCursor, collectionOrCursor.s.cmd);
+  } else {
+    decorateWithCollation(cmd, collectionOrCursor, options);
+  }
+
+  // Add limit, skip and maxTimeMS if defined
+  if (typeof skip === 'number') cmd.skip = skip;
+  if (typeof limit === 'number') cmd.limit = limit;
+  if (typeof maxTimeMS === 'number') cmd.maxTimeMS = maxTimeMS;
+  if (hint) cmd.hint = hint;
+
+  // Do we have a readConcern specified
+  decorateWithReadConcern(cmd, collectionOrCursor);
+
+  return cmd;
+}
+
+function deleteCallback(err, r, callback) {
+  if (callback == null) return;
+  if (err && callback) return callback(err);
+  if (r == null) return callback(null, { result: { ok: 1 } });
+  r.deletedCount = r.result.n;
+  if (callback) callback(null, r);
+}
+
+/**
+ * Find and update a document.
+ *
+ * @method
+ * @param {Collection} a Collection instance.
+ * @param {object} query Query object to locate the object to modify.
+ * @param {array} sort If multiple docs match, choose the first one in the specified sort order as the object to manipulate.
+ * @param {object} doc The fields/vals to be updated.
+ * @param {object} [options] Optional settings. See Collection.prototype.findAndModify for a list of options.
+ * @param {Collection~findAndModifyCallback} [callback] The command result callback
+ * @deprecated use findOneAndUpdate, findOneAndReplace or findOneAndDelete instead
+ */
+function findAndModify(coll, query, sort, doc, options, callback) {
+  // Create findAndModify command object
+  const queryObject = {
+    findAndModify: coll.collectionName,
+    query: query
+  };
+
+  sort = formattedOrderClause(sort);
+  if (sort) {
+    queryObject.sort = sort;
+  }
+
+  queryObject.new = options.new ? true : false;
+  queryObject.remove = options.remove ? true : false;
+  queryObject.upsert = options.upsert ? true : false;
+
+  const projection = options.projection || options.fields;
+
+  if (projection) {
+    queryObject.fields = projection;
+  }
+
+  if (options.arrayFilters) {
+    queryObject.arrayFilters = options.arrayFilters;
+    delete options.arrayFilters;
+  }
+
+  if (doc && !options.remove) {
+    queryObject.update = doc;
+  }
+
+  if (options.maxTimeMS) queryObject.maxTimeMS = options.maxTimeMS;
+
+  // Either use override on the function, or go back to default on either the collection
+  // level or db
+  options.serializeFunctions = options.serializeFunctions || coll.s.serializeFunctions;
+
+  // No check on the documents
+  options.checkKeys = false;
+
+  // 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);
+
+  // Decorate the findAndModify command with the write Concern
+  if (finalOptions.writeConcern) {
+    queryObject.writeConcern = finalOptions.writeConcern;
+  }
+
+  // Have we specified bypassDocumentValidation
+  if (finalOptions.bypassDocumentValidation === true) {
+    queryObject.bypassDocumentValidation = finalOptions.bypassDocumentValidation;
+  }
+
+  finalOptions.readPreference = ReadPreference.primary;
+
+  // Have we specified collation
+  try {
+    decorateWithCollation(queryObject, coll, finalOptions);
+  } catch (err) {
+    return callback(err, null);
+  }
+
+  // Execute the command
+  executeCommand(coll.s.db, queryObject, finalOptions, (err, result) => {
+    if (err) return handleCallback(callback, err, null);
+
+    return handleCallback(callback, null, result);
+  });
+}
+
+/**
+ * Retrieves this collections index info.
+ *
+ * @method
+ * @param {Db} db The Db instance on which to retrieve the index info.
+ * @param {string} name The name of the collection.
+ * @param {object} [options] Optional settings. See Db.prototype.indexInformation for a list of options.
+ * @param {Db~resultCallback} [callback] The command result callback
+ */
+function indexInformation(db, name, options, callback) {
+  // If we specified full information
+  const full = options['full'] == null ? false : options['full'];
+
+  // Did the user destroy the topology
+  if (db.serverConfig && db.serverConfig.isDestroyed())
+    return callback(new MongoError('topology was destroyed'));
+  // Process all the results from the index command and collection
+  function processResults(indexes) {
+    // Contains all the information
+    let info = {};
+    // Process all the indexes
+    for (let i = 0; i < indexes.length; i++) {
+      const index = indexes[i];
+      // Let's unpack the object
+      info[index.name] = [];
+      for (let name in index.key) {
+        info[index.name].push([name, index.key[name]]);
+      }
+    }
+
+    return info;
+  }
+
+  // Get the list of indexes of the specified collection
+  db
+    .collection(name)
+    .listIndexes(options)
+    .toArray((err, indexes) => {
+      if (err) return callback(toError(err));
+      if (!Array.isArray(indexes)) return handleCallback(callback, null, []);
+      if (full) return handleCallback(callback, null, indexes);
+      handleCallback(callback, null, processResults(indexes));
+    });
+}
+
+function prepareDocs(coll, docs, options) {
+  const forceServerObjectId =
+    typeof options.forceServerObjectId === 'boolean'
+      ? options.forceServerObjectId
+      : coll.s.db.options.forceServerObjectId;
+
+  // no need to modify the docs if server sets the ObjectId
+  if (forceServerObjectId === true) {
+    return docs;
+  }
+
+  return docs.map(doc => {
+    if (forceServerObjectId !== true && doc._id == null) {
+      doc._id = coll.s.pkFactory.createPk();
+    }
+
+    return doc;
+  });
+}
+
+// Get the next available document from the cursor, returns null if no more documents are available.
+function nextObject(cursor, callback) {
+  let Cursor = loadCursor();
+
+  if (cursor.s.state === Cursor.CLOSED || (cursor.isDead && cursor.isDead())) {
+    return handleCallback(
+      callback,
+      MongoError.create({ message: 'Cursor is closed', driver: true })
+    );
+  }
+  if (cursor.s.state === Cursor.INIT && cursor.s.cmd.sort) {
+    try {
+      cursor.s.cmd.sort = formattedOrderClause(cursor.s.cmd.sort);
+    } catch (err) {
+      return handleCallback(callback, err);
+    }
+  }
+
+  // Get the next object
+  cursor._next((err, doc) => {
+    cursor.s.state = Cursor.OPEN;
+    if (err) return handleCallback(callback, err);
+    handleCallback(callback, null, doc);
+  });
+}
+
+function removeDocuments(coll, selector, options, callback) {
+  if (typeof options === 'function') {
+    (callback = options), (options = {});
+  } else if (typeof selector === 'function') {
+    callback = selector;
+    options = {};
+    selector = {};
+  }
+
+  // Create an empty options object if the provided one is null
+  options = options || {};
+
+  // 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 selector is null set empty
+  if (selector == null) selector = {};
+
+  // Build the op
+  const op = { q: selector, limit: 0 };
+  if (options.single) {
+    op.limit = 1;
+  } else if (finalOptions.retryWrites) {
+    finalOptions.retryWrites = false;
+  }
+
+  // Have we specified collation
+  try {
+    decorateWithCollation(finalOptions, coll, options);
+  } catch (err) {
+    return callback(err, null);
+  }
+
+  // Execute the remove
+  coll.s.topology.remove(coll.s.namespace, [op], finalOptions, (err, result) => {
+    if (callback == null) return;
+    if (err) return handleCallback(callback, err, null);
+    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]));
+    // Return the results
+    handleCallback(callback, null, result);
+  });
+}
+
+function updateDocuments(coll, selector, document, options, callback) {
+  if ('function' === typeof options) (callback = options), (options = null);
+  if (options == null) options = {};
+  if (!('function' === typeof callback)) callback = null;
+
+  // If we are not providing a selector or document throw
+  if (selector == null || typeof selector !== 'object')
+    return callback(toError('selector must be a valid JavaScript object'));
+  if (document == null || typeof document !== 'object')
+    return callback(toError('document must be a valid JavaScript object'));
+
+  // 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);
+
+  // Do we return the actual result document
+  // Either use override on the function, or go back to default on either the collection
+  // level or db
+  finalOptions.serializeFunctions = options.serializeFunctions || coll.s.serializeFunctions;
+
+  // Execute the operation
+  const op = { q: selector, u: document };
+  op.upsert = options.upsert !== void 0 ? !!options.upsert : false;
+  op.multi = options.multi !== void 0 ? !!options.multi : false;
+
+  if (finalOptions.arrayFilters) {
+    op.arrayFilters = finalOptions.arrayFilters;
+    delete finalOptions.arrayFilters;
+  }
+
+  if (finalOptions.retryWrites && op.multi) {
+    finalOptions.retryWrites = false;
+  }
+
+  // Have we specified collation
+  try {
+    decorateWithCollation(finalOptions, coll, options);
+  } catch (err) {
+    return callback(err, null);
+  }
+
+  // Update options
+  coll.s.topology.update(coll.s.namespace, [op], finalOptions, (err, result) => {
+    if (callback == null) return;
+    if (err) return handleCallback(callback, err, null);
+    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]));
+    // Return the results
+    handleCallback(callback, null, result);
+  });
+}
+
+function updateCallback(err, r, callback) {
+  if (callback == null) return;
+  if (err) return callback(err);
+  if (r == null) return callback(null, { result: { ok: 1 } });
+  r.modifiedCount = r.result.nModified != null ? r.result.nModified : r.result.n;
+  r.upsertedId =
+    Array.isArray(r.result.upserted) && r.result.upserted.length > 0
+      ? r.result.upserted[0] // FIXME(major): should be `r.result.upserted[0]._id`
+      : null;
+  r.upsertedCount =
+    Array.isArray(r.result.upserted) && r.result.upserted.length ? r.result.upserted.length : 0;
+  r.matchedCount =
+    Array.isArray(r.result.upserted) && r.result.upserted.length > 0 ? 0 : r.result.n;
+  callback(null, r);
+}
+
+module.exports = {
+  buildCountCommand,
+  deleteCallback,
+  findAndModify,
+  indexInformation,
+  nextObject,
+  prepareDocs,
+  removeDocuments,
+  updateDocuments,
+  updateCallback
+};