mongodb 3.2.5 → 3.3.0-beta2

package/lib/operations/execute_operation.js

@@ -0,0 +1,165 @@
+'use strict';
+
+const MongoError = require('../core').MongoError;
+const Aspect = require('./operation').Aspect;
+const OperationBase = require('./operation').OperationBase;
+const ReadPreference = require('../core').ReadPreference;
+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.
+ *
+ * This method reduces large amounts of duplication in the entire codebase by providing
+ * a single point for determining whether callbacks or promises should be used. Additionally
+ * it allows for a single point of entry to provide features such as implicit sessions, which
+ * are required by the Driver Sessions specification in the event that a ClientSession is
+ * not provided
+ *
+ * @param {object} topology The topology to execute this operation on
+ * @param {Operation} operation The operation to execute
+ * @param {function} callback The command result callback
+ */
+function executeOperation(topology, operation, callback) {
+  if (topology == null) {
+    throw new TypeError('This method requires a valid topology instance');
+  }
+
+  if (!(operation instanceof OperationBase)) {
+    throw new TypeError('This method requires a valid operation instance');
+  }
+
+  if (
+    isUnifiedTopology(topology) &&
+    !operation.hasAspect(Aspect.SKIP_SESSION) &&
+    topology.shouldCheckForSessionSupport()
+  ) {
+    // TODO: this is only supported for unified topology, the first part of this check
+    //       should go away when we drop legacy topology types.
+    topology.selectServer(ReadPreference.primaryPreferred, err => {
+      if (err) {
+        callback(err);
+        return;
+      }
+
+      executeOperation(topology, operation, callback);
+    });
+
+    return;
+  }
+
+  const Promise = topology.s.promiseLibrary;
+
+  // The driver sessions spec mandates that we implicitly create sessions for operations
+  // that are not explicitly provided with a session.
+  let session, owner;
+  if (!operation.hasAspect(Aspect.SKIP_SESSION) && topology.hasSessionSupport()) {
+    if (operation.session == null) {
+      owner = Symbol();
+      session = topology.startSession({ owner });
+      operation.session = session;
+    } else if (operation.session.hasEnded) {
+      throw new MongoError('Use of expired sessions is not permitted');
+    }
+  }
+
+  const makeExecuteCallback = (resolve, reject) =>
+    function executeCallback(err, result) {
+      if (session && session.owner === owner) {
+        session.endSession(() => {
+          if (operation.session === session) {
+            operation.clearSession();
+          }
+          if (err) return reject(err);
+          resolve(result);
+        });
+      } else {
+        if (err) return reject(err);
+        resolve(result);
+      }
+    };
+
+  // Execute using callback
+  if (typeof callback === 'function') {
+    const handler = makeExecuteCallback(
+      result => callback(null, result),
+      err => callback(err, null)
+    );
+
+    try {
+      if (operation.hasAspect(Aspect.EXECUTE_WITH_SELECTION)) {
+        return executeWithServerSelection(topology, operation, handler);
+      } else {
+        return operation.execute(handler);
+      }
+    } catch (e) {
+      handler(e);
+      throw e;
+    }
+  }
+
+  return new Promise(function(resolve, reject) {
+    const handler = makeExecuteCallback(resolve, reject);
+
+    try {
+      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;
+
+  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(readPreference, (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(readPreference, (err, server) => {
+    if (err) {
+      callback(err, null);
+      return;
+    }
+
+    const shouldRetryReads =
+      topology.s.options.retryReads !== false &&
+      (operation.session && !operation.session.inTransaction()) &&
+      supportsRetryableReads(server);
+
+    if (operation.hasAspect(Aspect.RETRYABLE) && shouldRetryReads) {
+      operation.execute(server, callbackWithRetry);
+      return;
+    }
+
+    operation.execute(server, callback);
+  });
+}
+
+module.exports = executeOperation;

package/lib/operations/explain.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const Aspect = require('./operation').Aspect;
+const CoreCursor = require('../core').Cursor;
+const defineAspects = require('./operation').defineAspects;
+const OperationBase = require('./operation').OperationBase;
+
+class ExplainOperation extends OperationBase {
+  constructor(cursor) {
+    super();
+
+    this.cursor = cursor;
+  }
+
+  execute() {
+    const cursor = this.cursor;
+    return CoreCursor.prototype.next.apply(cursor, arguments);
+  }
+}
+
+defineAspects(ExplainOperation, Aspect.SKIP_SESSION);
+
+module.exports = ExplainOperation;

package/lib/operations/find_and_modify.js

@@ -0,0 +1,98 @@
+'use strict';
+
+const OperationBase = require('./operation').OperationBase;
+const applyRetryableWrites = require('../utils').applyRetryableWrites;
+const applyWriteConcern = require('../utils').applyWriteConcern;
+const decorateWithCollation = require('../utils').decorateWithCollation;
+const executeCommand = require('./db_ops').executeCommand;
+const formattedOrderClause = require('../utils').formattedOrderClause;
+const handleCallback = require('../utils').handleCallback;
+const ReadPreference = require('../core').ReadPreference;
+
+class FindAndModifyOperation extends OperationBase {
+  constructor(collection, query, sort, doc, options) {
+    super(options);
+
+    this.collection = collection;
+    this.query = query;
+    this.sort = sort;
+    this.doc = doc;
+  }
+
+  execute(callback) {
+    const coll = this.collection;
+    const query = this.query;
+    const sort = formattedOrderClause(this.sort);
+    const doc = this.doc;
+    let options = this.options;
+
+    // Create findAndModify command object
+    const queryObject = {
+      findAndModify: coll.collectionName,
+      query: query
+    };
+
+    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;
+    }
+
+    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
+    options = applyRetryableWrites(options, coll.s.db);
+    options = applyWriteConcern(options, { db: coll.s.db, collection: coll }, options);
+
+    // Decorate the findAndModify command with the write Concern
+    if (options.writeConcern) {
+      queryObject.writeConcern = options.writeConcern;
+    }
+
+    // Have we specified bypassDocumentValidation
+    if (options.bypassDocumentValidation === true) {
+      queryObject.bypassDocumentValidation = options.bypassDocumentValidation;
+    }
+
+    options.readPreference = ReadPreference.primary;
+
+    // Have we specified collation
+    try {
+      decorateWithCollation(queryObject, coll, options);
+    } catch (err) {
+      return callback(err, null);
+    }
+
+    // Execute the command
+    executeCommand(coll.s.db, queryObject, options, (err, result) => {
+      if (err) return handleCallback(callback, err, null);
+
+      return handleCallback(callback, null, result);
+    });
+  }
+}
+
+module.exports = FindAndModifyOperation;

package/lib/operations/find_one.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const handleCallback = require('../utils').handleCallback;
+const OperationBase = require('./operation').OperationBase;
+const toError = require('../utils').toError;
+
+class FindOneOperation extends OperationBase {
+  constructor(collection, query, options) {
+    super(options);
+
+    this.collection = collection;
+    this.query = query;
+  }
+
+  execute(callback) {
+    const coll = this.collection;
+    const query = this.query;
+    const options = this.options;
+
+    const cursor = coll
+      .find(query, options)
+      .limit(-1)
+      .batchSize(1);
+
+    // Return the item
+    cursor.next((err, item) => {
+      if (err != null) return handleCallback(callback, toError(err), null);
+      handleCallback(callback, null, item);
+    });
+  }
+}
+
+module.exports = FindOneOperation;

package/lib/operations/find_one_and_delete.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const FindAndModifyOperation = require('./find_and_modify');
+
+class FindOneAndDeleteOperation extends FindAndModifyOperation {
+  constructor(collection, filter, options) {
+    // Final options
+    const finalOptions = Object.assign({}, options);
+    finalOptions.fields = options.projection;
+    finalOptions.remove = true;
+
+    super(collection, filter, finalOptions.sort, null, finalOptions);
+  }
+}
+
+module.exports = FindOneAndDeleteOperation;

package/lib/operations/find_one_and_replace.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const FindAndModifyOperation = require('./find_and_modify');
+
+class FindOneAndReplaceOperation extends FindAndModifyOperation {
+  constructor(collection, filter, replacement, options) {
+    // Final options
+    const finalOptions = Object.assign({}, options);
+    finalOptions.fields = options.projection;
+    finalOptions.update = true;
+    finalOptions.new = options.returnOriginal !== void 0 ? !options.returnOriginal : false;
+    finalOptions.upsert = options.upsert !== void 0 ? !!options.upsert : false;
+
+    super(collection, filter, finalOptions.sort, replacement, finalOptions);
+  }
+}
+
+module.exports = FindOneAndReplaceOperation;

package/lib/operations/find_one_and_update.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const FindAndModifyOperation = require('./find_and_modify');
+
+class FindOneAndUpdateOperation extends FindAndModifyOperation {
+  constructor(collection, filter, update, options) {
+    // Final options
+    const finalOptions = Object.assign({}, options);
+    finalOptions.fields = options.projection;
+    finalOptions.update = true;
+    finalOptions.new =
+      typeof options.returnOriginal === 'boolean' ? !options.returnOriginal : false;
+    finalOptions.upsert = typeof options.upsert === 'boolean' ? options.upsert : false;
+
+    super(collection, filter, finalOptions.sort, update, finalOptions);
+  }
+}
+
+module.exports = FindOneAndUpdateOperation;

package/lib/operations/geo_haystack_search.js

@@ -0,0 +1,79 @@
+'use strict';
+
+const Aspect = require('./operation').Aspect;
+const defineAspects = require('./operation').defineAspects;
+const OperationBase = require('./operation').OperationBase;
+const decorateCommand = require('../utils').decorateCommand;
+const decorateWithReadConcern = require('../utils').decorateWithReadConcern;
+const executeCommand = require('./db_ops').executeCommand;
+const handleCallback = require('../utils').handleCallback;
+const resolveReadPreference = require('../utils').resolveReadPreference;
+const toError = require('../utils').toError;
+
+/**
+ * Execute a geo search using a geo haystack index on a collection.
+ *
+ * @class
+ * @property {Collection} a Collection instance.
+ * @property {number} x Point to search on the x axis, ensure the indexes are ordered in the same order.
+ * @property {number} y Point to search on the y axis, ensure the indexes are ordered in the same order.
+ * @property {object} [options] Optional settings. See Collection.prototype.geoHaystackSearch for a list of options.
+ */
+class GeoHaystackSearchOperation extends OperationBase {
+  /**
+   * Construct a GeoHaystackSearch operation.
+   *
+   * @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.
+   */
+  constructor(collection, x, y, options) {
+    super(options);
+
+    this.collection = collection;
+    this.x = x;
+    this.y = y;
+  }
+
+  /**
+   * Execute the operation.
+   *
+   * @param {Collection~resultCallback} [callback] The command result callback
+   */
+  execute(callback) {
+    const coll = this.collection;
+    const x = this.x;
+    const y = this.y;
+    let options = this.options;
+
+    // Build command object
+    let commandObject = {
+      geoSearch: coll.collectionName,
+      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(coll, options);
+
+    // 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);
+    });
+  }
+}
+
+defineAspects(GeoHaystackSearchOperation, Aspect.READ_OPERATION);
+
+module.exports = GeoHaystackSearchOperation;

package/lib/operations/has_next.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const Aspect = require('./operation').Aspect;
+const defineAspects = require('./operation').defineAspects;
+const loadCursor = require('../dynamic_loaders').loadCursor;
+const OperationBase = require('./operation').OperationBase;
+const nextObject = require('./common_functions').nextObject;
+
+class HasNextOperation extends OperationBase {
+  constructor(cursor) {
+    super();
+
+    this.cursor = cursor;
+  }
+
+  execute(callback) {
+    const cursor = this.cursor;
+    let Cursor = loadCursor();
+
+    if (cursor.s.currentDoc) {
+      return callback(null, true);
+    }
+
+    if (cursor.isNotified()) {
+      return callback(null, false);
+    }
+
+    nextObject(cursor, (err, doc) => {
+      if (err) return callback(err, null);
+      if (cursor.s.state === Cursor.CLOSED || cursor.isDead()) return callback(null, false);
+      if (!doc) return callback(null, false);
+      cursor.s.currentDoc = doc;
+      callback(null, true);
+    });
+  }
+}
+
+defineAspects(HasNextOperation, Aspect.SKIP_SESSION);
+
+module.exports = HasNextOperation;

package/lib/operations/index_exists.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const OperationBase = require('./operation').OperationBase;
+const handleCallback = require('../utils').handleCallback;
+const indexInformationDb = require('./db_ops').indexInformation;
+
+class IndexExistsOperation extends OperationBase {
+  constructor(collection, indexes, options) {
+    super(options);
+
+    this.collection = collection;
+    this.indexes = indexes;
+  }
+
+  execute(callback) {
+    const coll = this.collection;
+    const indexes = this.indexes;
+    const options = this.options;
+
+    indexInformationDb(coll.s.db, coll.collectionName, options, (err, indexInformation) => {
+      // If we have an error return
+      if (err != null) return handleCallback(callback, err, null);
+      // Let's check for the index names
+      if (!Array.isArray(indexes))
+        return handleCallback(callback, null, indexInformation[indexes] != null);
+      // Check in list of indexes
+      for (let i = 0; i < indexes.length; i++) {
+        if (indexInformation[indexes[i]] == null) {
+          return handleCallback(callback, null, false);
+        }
+      }
+
+      // All keys found return true
+      return handleCallback(callback, null, true);
+    });
+  }
+}
+
+module.exports = IndexExistsOperation;

package/lib/operations/index_information.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const OperationBase = require('./operation').OperationBase;
+const indexInformation = require('./common_functions').indexInformation;
+
+class IndexInformationOperation extends OperationBase {
+  constructor(db, name, options) {
+    super(options);
+
+    this.db = db;
+    this.name = name;
+  }
+
+  execute(callback) {
+    const db = this.db;
+    const name = this.name;
+    const options = this.options;
+
+    indexInformation(db, name, options, callback);
+  }
+}
+
+module.exports = IndexInformationOperation;

package/lib/operations/indexes.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const OperationBase = require('./operation').OperationBase;
+const indexInformation = require('./common_functions').indexInformation;
+
+class IndexesOperation extends OperationBase {
+  constructor(collection, options) {
+    super(options);
+
+    this.collection = collection;
+  }
+
+  execute(callback) {
+    const coll = this.collection;
+    let options = this.options;
+
+    options = Object.assign({}, { full: true }, options);
+    indexInformation(coll.s.db, coll.collectionName, options, callback);
+  }
+}
+
+module.exports = IndexesOperation;

package/lib/operations/insert_many.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const OperationBase = require('./operation').OperationBase;
+const BulkWriteOperation = require('./bulk_write');
+const MongoError = require('../core').MongoError;
+const prepareDocs = require('./common_functions').prepareDocs;
+
+class InsertManyOperation extends OperationBase {
+  constructor(collection, docs, options) {
+    super(options);
+
+    this.collection = collection;
+    this.docs = docs;
+  }
+
+  execute(callback) {
+    const coll = this.collection;
+    let docs = this.docs;
+    const options = this.options;
+
+    if (!Array.isArray(docs)) {
+      return callback(
+        MongoError.create({ message: 'docs parameter must be an array of documents', driver: true })
+      );
+    }
+
+    // If keep going set unordered
+    options['serializeFunctions'] = options['serializeFunctions'] || coll.s.serializeFunctions;
+
+    docs = prepareDocs(coll, docs, options);
+
+    // Generate the bulk write operations
+    const operations = [
+      {
+        insertMany: docs
+      }
+    ];
+
+    const bulkWriteOperation = new BulkWriteOperation(coll, operations, options);
+
+    bulkWriteOperation.execute((err, result) => {
+      if (err) return callback(err, null);
+      callback(null, mapInsertManyResults(docs, result));
+    });
+  }
+}
+
+function mapInsertManyResults(docs, r) {
+  const finalResult = {
+    result: { ok: 1, n: r.insertedCount },
+    ops: docs,
+    insertedCount: r.insertedCount,
+    insertedIds: r.insertedIds
+  };
+
+  if (r.getLastOp()) {
+    finalResult.result.opTime = r.getLastOp();
+  }
+
+  return finalResult;
+}
+
+module.exports = InsertManyOperation;