mongodb 3.5.11 → 3.6.2

package/lib/operations/create_indexes.js

@@ -2,60 +2,136 @@
 
 const Aspect = require('./operation').Aspect;
 const defineAspects = require('./operation').defineAspects;
-const OperationBase = require('./operation').OperationBase;
-const executeCommand = require('./db_ops').executeCommand;
+const CommandOperationV2 = require('./command_v2');
 const MongoError = require('../core').MongoError;
-const ReadPreference = require('../core').ReadPreference;
+const parseIndexOptions = require('../utils').parseIndexOptions;
+const maxWireVersion = require('../core/utils').maxWireVersion;
 
-class CreateIndexesOperation extends OperationBase {
-  constructor(collection, indexSpecs, options) {
-    super(options);
+const VALID_INDEX_OPTIONS = new Set([
+  'background',
+  'unique',
+  'name',
+  'partialFilterExpression',
+  'sparse',
+  'expireAfterSeconds',
+  'storageEngine',
+  'collation',
 
+  // text indexes
+  'weights',
+  'default_language',
+  'language_override',
+  'textIndexVersion',
+
+  // 2d-sphere indexes
+  '2dsphereIndexVersion',
+
+  // 2d indexes
+  'bits',
+  'min',
+  'max',
+
+  // geoHaystack Indexes
+  'bucketSize',
+
+  // wildcard indexes
+  'wildcardProjection'
+]);
+
+class CreateIndexesOperation extends CommandOperationV2 {
+  /**
+   * @ignore
+   */
+  constructor(parent, collection, indexes, options) {
+    super(parent, options);
     this.collection = collection;
-    this.indexSpecs = indexSpecs;
+
+    // createIndex can be called with a variety of styles:
+    //   coll.createIndex('a');
+    //   coll.createIndex({ a: 1 });
+    //   coll.createIndex([['a', 1]]);
+    // createIndexes is always called with an array of index spec objects
+    if (!Array.isArray(indexes) || Array.isArray(indexes[0])) {
+      this.onlyReturnNameOfCreatedIndex = true;
+      // TODO: remove in v4 (breaking change); make createIndex return full response as createIndexes does
+
+      const indexParameters = parseIndexOptions(indexes);
+      // Generate the index name
+      const name = typeof options.name === 'string' ? options.name : indexParameters.name;
+      // Set up the index
+      const indexSpec = { name, key: indexParameters.fieldHash };
+      // merge valid index options into the index spec
+      for (let optionName in options) {
+        if (VALID_INDEX_OPTIONS.has(optionName)) {
+          indexSpec[optionName] = options[optionName];
+        }
+      }
+      this.indexes = [indexSpec];
+      return;
+    }
+
+    this.indexes = indexes;
   }
 
-  execute(callback) {
-    const coll = this.collection;
-    const indexSpecs = this.indexSpecs;
-    let options = this.options;
+  /**
+   * @ignore
+   */
+  execute(server, callback) {
+    const options = this.options;
+    const indexes = this.indexes;
 
-    const capabilities = coll.s.topology.capabilities();
+    const serverWireVersion = maxWireVersion(server);
 
     // 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 = [];
+    for (let i = 0; i < indexes.length; i++) {
+      // Did the user pass in a collation, check if our write server supports it
+      if (indexes[i].collation && serverWireVersion < 5) {
+        callback(
+          new MongoError(
+            `Server ${server.name}, which reports wire version ${serverWireVersion}, does not support collation`
+          )
+        );
+        return;
+      }
 
-        // 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'));
-        }
+      if (indexes[i].name == null) {
+        const keys = [];
 
-        for (let name in indexSpecs[i].key) {
-          keys.push(`${name}_${indexSpecs[i].key[name]}`);
+        for (let name in indexes[i].key) {
+          keys.push(`${name}_${indexes[i].key[name]}`);
         }
 
         // Set the name
-        indexSpecs[i].name = keys.join('_');
+        indexes[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
-    );
+    const cmd = { createIndexes: this.collection, indexes };
+
+    if (options.commitQuorum != null) {
+      if (serverWireVersion < 9) {
+        callback(
+          new MongoError('`commitQuorum` option for `createIndexes` not supported on servers < 4.4')
+        );
+        return;
+      }
+      cmd.commitQuorum = options.commitQuorum;
+    }
+
+    // collation is set on each index, it should not be defined at the root
+    this.options.collation = undefined;
+
+    super.executeCommand(server, cmd, (err, result) => {
+      if (err) {
+        callback(err);
+        return;
+      }
+
+      callback(null, this.onlyReturnNameOfCreatedIndex ? indexes[0].name : result);
+    });
   }
 }
 
-defineAspects(CreateIndexesOperation, Aspect.WRITE_OPERATION);
+defineAspects(CreateIndexesOperation, [Aspect.WRITE_OPERATION, Aspect.EXECUTE_WITH_SELECTION]);
 
 module.exports = CreateIndexesOperation;

package/lib/operations/find.js

@@ -4,6 +4,8 @@ const OperationBase = require('./operation').OperationBase;
 const Aspect = require('./operation').Aspect;
 const defineAspects = require('./operation').defineAspects;
 const ReadPreference = require('../core').ReadPreference;
+const maxWireVersion = require('../core/utils').maxWireVersion;
+const MongoError = require('../core/error').MongoError;
 
 class FindOperation extends OperationBase {
   constructor(collection, ns, command, options) {
@@ -18,9 +20,13 @@ class FindOperation extends OperationBase {
     // copied from `CommandOperationV2`, to be subclassed in the future
     this.server = server;
 
-    const cursorState = this.cursorState || {};
+    if (typeof this.cmd.allowDiskUse !== 'undefined' && maxWireVersion(server) < 4) {
+      callback(new MongoError('The `allowDiskUse` option is not supported on MongoDB < 3.2'));
+      return;
+    }
 
     // TOOD: use `MongoDBNamespace` through and through
+    const cursorState = this.cursorState || {};
     server.query(this.ns.toString(), this.cmd, cursorState, this.options, callback);
   }
 }

package/lib/operations/find_and_modify.js

@@ -8,6 +8,8 @@ const executeCommand = require('./db_ops').executeCommand;
 const formattedOrderClause = require('../utils').formattedOrderClause;
 const handleCallback = require('../utils').handleCallback;
 const ReadPreference = require('../core').ReadPreference;
+const maxWireVersion = require('../core/utils').maxWireVersion;
+const MongoError = require('../error').MongoError;
 
 class FindAndModifyOperation extends OperationBase {
   constructor(collection, query, sort, doc, options) {
@@ -86,6 +88,21 @@ class FindAndModifyOperation extends OperationBase {
       return callback(err, null);
     }
 
+    if (options.hint) {
+      // TODO: once this method becomes a CommandOperationV2 we will have the server
+      // in place to check.
+      const unacknowledgedWrite = options.writeConcern && options.writeConcern.w === 0;
+      if (unacknowledgedWrite || maxWireVersion(coll.s.topology) < 8) {
+        callback(
+          new MongoError('The current topology does not support a hint on findAndModify commands')
+        );
+
+        return;
+      }
+
+      queryObject.hint = options.hint;
+    }
+
     // Execute the command
     executeCommand(coll.s.db, queryObject, options, (err, result) => {
       if (err) return handleCallback(callback, err, null);

package/lib/operations/find_one_and_delete.js

@@ -9,6 +9,11 @@ class FindOneAndDeleteOperation extends FindAndModifyOperation {
     finalOptions.fields = options.projection;
     finalOptions.remove = true;
 
+    // Basic validation
+    if (filter == null || typeof filter !== 'object') {
+      throw new TypeError('Filter parameter must be an object');
+    }
+
     super(collection, filter, finalOptions.sort, null, finalOptions);
   }
 }

package/lib/operations/find_one_and_replace.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const FindAndModifyOperation = require('./find_and_modify');
+const hasAtomicOperators = require('../utils').hasAtomicOperators;
 
 class FindOneAndReplaceOperation extends FindAndModifyOperation {
   constructor(collection, filter, replacement, options) {
@@ -11,6 +12,18 @@ class FindOneAndReplaceOperation extends FindAndModifyOperation {
     finalOptions.new = options.returnOriginal !== void 0 ? !options.returnOriginal : false;
     finalOptions.upsert = options.upsert !== void 0 ? !!options.upsert : false;
 
+    if (filter == null || typeof filter !== 'object') {
+      throw new TypeError('Filter parameter must be an object');
+    }
+
+    if (replacement == null || typeof replacement !== 'object') {
+      throw new TypeError('Replacement parameter must be an object');
+    }
+
+    if (hasAtomicOperators(replacement)) {
+      throw new TypeError('Replacement document must not contain atomic operators');
+    }
+
     super(collection, filter, finalOptions.sort, replacement, finalOptions);
   }
 }

package/lib/operations/find_one_and_update.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const FindAndModifyOperation = require('./find_and_modify');
+const hasAtomicOperators = require('../utils').hasAtomicOperators;
 
 class FindOneAndUpdateOperation extends FindAndModifyOperation {
   constructor(collection, filter, update, options) {
@@ -12,6 +13,18 @@ class FindOneAndUpdateOperation extends FindAndModifyOperation {
       typeof options.returnOriginal === 'boolean' ? !options.returnOriginal : false;
     finalOptions.upsert = typeof options.upsert === 'boolean' ? options.upsert : false;
 
+    if (filter == null || typeof filter !== 'object') {
+      throw new TypeError('Filter parameter must be an object');
+    }
+
+    if (update == null || typeof update !== 'object') {
+      throw new TypeError('Update parameter must be an object');
+    }
+
+    if (!hasAtomicOperators(update)) {
+      throw new TypeError('Update document requires atomic operators');
+    }
+
     super(collection, filter, finalOptions.sort, update, finalOptions);
   }
 }

package/lib/operations/map_reduce.js

@@ -60,7 +60,7 @@ class MapReduceOperation extends OperationBase {
     let options = this.options;
 
     const mapCommandHash = {
-      mapreduce: coll.collectionName,
+      mapReduce: coll.collectionName,
       map: map,
       reduce: reduce
     };

package/lib/operations/re_index.js

@@ -1,28 +1,33 @@
 'use strict';
 
-const CommandOperation = require('./command');
-const handleCallback = require('../utils').handleCallback;
+const Aspect = require('./operation').Aspect;
+const defineAspects = require('./operation').defineAspects;
+const CommandOperationV2 = require('./command_v2');
+const serverType = require('../core/sdam/common').serverType;
+const ServerType = require('../core/sdam/common').ServerType;
+const MongoError = require('../core').MongoError;
 
-class ReIndexOperation extends CommandOperation {
+class ReIndexOperation extends CommandOperationV2 {
   constructor(collection, options) {
-    super(collection.s.db, options, collection);
+    super(collection, options);
+    this.collectionName = collection.collectionName;
   }
 
-  _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);
+  execute(server, callback) {
+    if (serverType(server) !== ServerType.Standalone) {
+      callback(new MongoError(`reIndex can only be executed on standalone servers.`));
+      return;
+    }
+    super.executeCommand(server, { reIndex: this.collectionName }, (err, result) => {
+      if (err) {
+        callback(err);
+        return;
+      }
+      callback(null, !!result.ok);
     });
   }
 }
 
+defineAspects(ReIndexOperation, [Aspect.EXECUTE_WITH_SELECTION]);
+
 module.exports = ReIndexOperation;

package/lib/operations/replace_one.js

@@ -2,27 +2,34 @@
 
 const OperationBase = require('./operation').OperationBase;
 const updateDocuments = require('./common_functions').updateDocuments;
+const hasAtomicOperators = require('../utils').hasAtomicOperators;
 
 class ReplaceOneOperation extends OperationBase {
-  constructor(collection, filter, doc, options) {
+  constructor(collection, filter, replacement, options) {
     super(options);
 
+    if (hasAtomicOperators(replacement)) {
+      throw new TypeError('Replacement document must not contain atomic operators');
+    }
+
     this.collection = collection;
     this.filter = filter;
-    this.doc = doc;
+    this.replacement = replacement;
   }
 
   execute(callback) {
     const coll = this.collection;
     const filter = this.filter;
-    const doc = this.doc;
+    const replacement = this.replacement;
     const options = this.options;
 
     // Set single document update
     options.multi = false;
 
     // Execute update
-    updateDocuments(coll, filter, doc, options, (err, r) => replaceCallback(err, r, doc, callback));
+    updateDocuments(coll, filter, replacement, options, (err, r) =>
+      replaceCallback(err, r, replacement, callback)
+    );
   }
 }
 

package/lib/operations/update_many.js

@@ -3,11 +3,16 @@
 const OperationBase = require('./operation').OperationBase;
 const updateCallback = require('./common_functions').updateCallback;
 const updateDocuments = require('./common_functions').updateDocuments;
+const hasAtomicOperators = require('../utils').hasAtomicOperators;
 
 class UpdateManyOperation extends OperationBase {
   constructor(collection, filter, update, options) {
     super(options);
 
+    if (!hasAtomicOperators(update)) {
+      throw new TypeError('Update document requires atomic operators');
+    }
+
     this.collection = collection;
     this.filter = filter;
     this.update = update;

package/lib/operations/update_one.js

@@ -2,11 +2,16 @@
 
 const OperationBase = require('./operation').OperationBase;
 const updateDocuments = require('./common_functions').updateDocuments;
+const hasAtomicOperators = require('../utils').hasAtomicOperators;
 
 class UpdateOneOperation extends OperationBase {
   constructor(collection, filter, update, options) {
     super(options);
 
+    if (!hasAtomicOperators(update)) {
+      throw new TypeError('Update document requires atomic operators');
+    }
+
     this.collection = collection;
     this.filter = filter;
     this.update = update;

package/lib/operations/validate_collection.js

@@ -14,8 +14,7 @@ class ValidateCollectionOperation extends CommandOperation {
     }
 
     super(admin.s.db, options, null, command);
-
-    this.collectionName;
+    this.collectionName = collectionName;
   }
 
   execute(callback) {

package/lib/topologies/mongos.js

@@ -82,7 +82,7 @@ var legalOptionNames = [
  * @param {object} [options.socketOptions] Socket options
  * @param {boolean} [options.socketOptions.noDelay=true] TCP Socket NoDelay option.
  * @param {boolean} [options.socketOptions.keepAlive=true] TCP Connection keep alive enabled
- * @param {number} [options.socketOptions.keepAliveInitialDelay=30000] The number of milliseconds to wait before initiating keepAlive on the TCP socket
+ * @param {number} [options.socketOptions.keepAliveInitialDelay=120000] The number of milliseconds to wait before initiating keepAlive on the TCP socket
  * @param {number} [options.socketOptions.connectTimeoutMS=10000] How long to wait for a connection to be established before timing out
  * @param {number} [options.socketOptions.socketTimeoutMS=360000] How long a send or receive on a socket can take before timing out
  * @param {boolean} [options.domainsEnabled=false] Enable the wrapping of the callback in the current domain, disabled by default to avoid perf hit.

package/lib/topologies/replset.js

@@ -92,7 +92,7 @@ var legalOptionNames = [
  * @param {object} [options.socketOptions] Socket options
  * @param {boolean} [options.socketOptions.noDelay=true] TCP Socket NoDelay option.
  * @param {boolean} [options.socketOptions.keepAlive=true] TCP Connection keep alive enabled
- * @param {number} [options.socketOptions.keepAliveInitialDelay=30000] The number of milliseconds to wait before initiating keepAlive on the TCP socket
+ * @param {number} [options.socketOptions.keepAliveInitialDelay=120000] The number of milliseconds to wait before initiating keepAlive on the TCP socket
  * @param {number} [options.socketOptions.connectTimeoutMS=10000] How long to wait for a connection to be established before timing out
  * @param {number} [options.socketOptions.socketTimeoutMS=360000] How long a send or receive on a socket can take before timing out
  * @param {boolean} [options.domainsEnabled=false] Enable the wrapping of the callback in the current domain, disabled by default to avoid perf hit.

package/lib/topologies/server.js

@@ -84,7 +84,7 @@ var legalOptionNames = [
  * @param {boolean} [options.socketOptions.autoReconnect=true] Reconnect on error.
  * @param {boolean} [options.socketOptions.noDelay=true] TCP Socket NoDelay option.
  * @param {boolean} [options.socketOptions.keepAlive=true] TCP Connection keep alive enabled
- * @param {number} [options.socketOptions.keepAliveInitialDelay=30000] The number of milliseconds to wait before initiating keepAlive on the TCP socket
+ * @param {number} [options.socketOptions.keepAliveInitialDelay=120000] The number of milliseconds to wait before initiating keepAlive on the TCP socket
  * @param {number} [options.socketOptions.connectTimeoutMS=10000] How long to wait for a connection to be established before timing out
  * @param {number} [options.socketOptions.socketTimeoutMS=360000] How long a send or receive on a socket can take before timing out
  * @param {number} [options.reconnectTries=30] Server attempt to reconnect #times

package/lib/utils.js

@@ -721,6 +721,12 @@ function makeInterruptableAsyncInterval(fn, options) {
     const timeUntilNextCall = Math.max(interval - timeSinceLastCall, 0);
     lastWakeTime = currentTime;
 
+    // For the streaming protocol: there is nothing obviously stopping this
+    // interval from being woken up again while we are waiting "infinitely"
+    // for `fn` to be called again`. Since the function effectively
+    // never completes, the `timeUntilNextCall` will continue to grow
+    // negatively unbounded, so it will never trigger a reschedule here.
+
     // debounce multiple calls to wake within the `minInterval`
     if (timeSinceLastWake < minInterval) {
       return;
@@ -753,6 +759,7 @@ function makeInterruptableAsyncInterval(fn, options) {
   function executeAndReschedule() {
     lastWakeTime = 0;
     lastCallTime = now();
+
     fn(err => {
       if (err) throw err;
       reschedule(interval);
@@ -769,6 +776,15 @@ function makeInterruptableAsyncInterval(fn, options) {
   return { wake, stop };
 }
 
+function hasAtomicOperators(doc) {
+  if (Array.isArray(doc)) {
+    return doc.reduce((err, u) => err || hasAtomicOperators(u), null);
+  }
+
+  const keys = Object.keys(doc);
+  return keys.length > 0 && keys[0][0] === '$';
+}
+
 module.exports = {
   filterOptions,
   mergeOptions,
@@ -800,5 +816,6 @@ module.exports = {
   maybePromise,
   now,
   calculateDurationInMs,
-  makeInterruptableAsyncInterval
+  makeInterruptableAsyncInterval,
+  hasAtomicOperators
 };

package/lib/write_concern.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const kWriteConcernKeys = new Set(['w', 'wtimeout', 'j', 'fsync']);
+
 /**
  * The **WriteConcern** class is a class that represents a MongoDB WriteConcern.
  * @class
@@ -51,6 +53,14 @@ class WriteConcern {
     }
 
     if (options.writeConcern) {
+      if (typeof options.writeConcern === 'string') {
+        return new WriteConcern(options.writeConcern);
+      }
+
+      if (!Object.keys(options.writeConcern).some(key => kWriteConcernKeys.has(key))) {
+        return;
+      }
+
       return new WriteConcern(
         options.writeConcern.w,
         options.writeConcern.wtimeout,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mongodb",
-  "version": "3.5.11",
+  "version": "3.6.2",
   "description": "The official MongoDB driver for Node.js",
   "main": "index.js",
   "files": [