mongoose 6.1.9 → 6.2.2

package/lib/helpers/projection/isInclusive.js

@@ -26,7 +26,11 @@ module.exports = function isInclusive(projection) {
     // If field is truthy (1, true, etc.) and not an object, then this
     // projection must be inclusive. If object, assume its $meta, $slice, etc.
     if (isDefiningProjection(projection[prop]) && !!projection[prop]) {
-      return true;
+      if (projection[prop] != null && typeof projection[prop] === 'object') {
+        return isInclusive(projection[prop]);
+      } else {
+        return !!projection[prop];
+      }
     }
   }
 

package/lib/helpers/query/cast$expr.js

@@ -0,0 +1,279 @@
+'use strict';
+
+const CastError = require('../../error/cast');
+const StrictModeError = require('../../error/strict');
+const castNumber = require('../../cast/number');
+
+const booleanComparison = new Set(['$and', '$or', '$not']);
+const comparisonOperator = new Set(['$cmp', '$eq', '$lt', '$lte', '$gt', '$gte']);
+const arithmeticOperatorArray = new Set([
+  // avoid casting '$add' or '$subtract', because expressions can be either number or date,
+  // and we don't have a good way of inferring which arguments should be numbers and which should
+  // be dates.
+  '$multiply',
+  '$divide',
+  '$log',
+  '$mod',
+  '$trunc',
+  '$avg',
+  '$max',
+  '$min',
+  '$stdDevPop',
+  '$stdDevSamp',
+  '$sum'
+]);
+const arithmeticOperatorNumber = new Set([
+  '$abs',
+  '$exp',
+  '$ceil',
+  '$floor',
+  '$ln',
+  '$log10',
+  '$round',
+  '$sqrt',
+  '$sin',
+  '$cos',
+  '$tan',
+  '$asin',
+  '$acos',
+  '$atan',
+  '$atan2',
+  '$asinh',
+  '$acosh',
+  '$atanh',
+  '$sinh',
+  '$cosh',
+  '$tanh',
+  '$degreesToRadians',
+  '$radiansToDegrees'
+]);
+const arrayElementOperators = new Set([
+  '$arrayElemAt',
+  '$first',
+  '$last'
+]);
+const dateOperators = new Set([
+  '$year',
+  '$month',
+  '$week',
+  '$dayOfMonth',
+  '$dayOfYear',
+  '$hour',
+  '$minute',
+  '$second',
+  '$isoDayOfWeek',
+  '$isoWeekYear',
+  '$isoWeek',
+  '$millisecond'
+]);
+
+module.exports = function cast$expr(val, schema, strictQuery) {
+  if (typeof val !== 'object' || val === null) {
+    throw new Error('`$expr` must be an object');
+  }
+
+  return _castExpression(val, schema, strictQuery);
+};
+
+function _castExpression(val, schema, strictQuery) {
+  if (isPath(val)) {
+    // Assume path
+    return val;
+  }
+
+  if (val.$cond != null) {
+    if (Array.isArray(val.$cond)) {
+      val.$cond = val.$cond.map(expr => _castExpression(expr, schema, strictQuery));
+    } else {
+      val.$cond.if = _castExpression(val.$cond.if, schema, strictQuery);
+      val.$cond.then = _castExpression(val.$cond.then, schema, strictQuery);
+      val.$cond.else = _castExpression(val.$cond.else, schema, strictQuery);
+    }
+  } else if (val.$ifNull != null) {
+    val.$ifNull.map(v => _castExpression(v, schema, strictQuery));
+  } else if (val.$switch != null) {
+    val.branches.map(v => _castExpression(v, schema, strictQuery));
+    val.default = _castExpression(val.default, schema, strictQuery);
+  }
+
+  const keys = Object.keys(val);
+  for (const key of keys) {
+    if (booleanComparison.has(key)) {
+      val[key] = val[key].map(v => _castExpression(v, schema, strictQuery));
+    } else if (comparisonOperator.has(key)) {
+      val[key] = castComparison(val[key], schema, strictQuery);
+    } else if (arithmeticOperatorArray.has(key)) {
+      val[key] = castArithmetic(val[key], schema, strictQuery);
+    } else if (arithmeticOperatorNumber.has(key)) {
+      val[key] = castNumberOperator(val[key], schema, strictQuery);
+    }
+  }
+
+  if (val.$in) {
+    val.$in = castIn(val.$in, schema, strictQuery);
+  }
+  if (val.$size) {
+    val.$size = castNumberOperator(val.$size, schema, strictQuery);
+  }
+
+  _omitUndefined(val);
+
+  return val;
+}
+
+function _omitUndefined(val) {
+  const keys = Object.keys(val);
+  for (let i = 0, len = keys.length; i < len; ++i) {
+    (val[keys[i]] === void 0) && delete val[keys[i]];
+  }
+}
+
+// { $op: <number> }
+function castNumberOperator(val) {
+  if (!isLiteral(val)) {
+    return val;
+  }
+
+  try {
+    return castNumber(val);
+  } catch (err) {
+    throw new CastError('Number', val);
+  }
+}
+
+function castIn(val, schema, strictQuery) {
+  const path = val[1];
+  if (!isPath(path)) {
+    return val;
+  }
+  const search = val[0];
+
+  const schematype = schema.path(path.slice(1));
+  if (schematype === null) {
+    if (strictQuery === false) {
+      return val;
+    } else if (strictQuery === 'throw') {
+      throw new StrictModeError('$in');
+    }
+
+    return void 0;
+  }
+
+  if (!schematype.$isMongooseArray) {
+    throw new Error('Path must be an array for $in');
+  }
+
+  return [
+    schematype.$isMongooseDocumentArray ? schematype.$embeddedSchemaType.cast(search) : schematype.caster.cast(search),
+    path
+  ];
+}
+
+// { $op: [<number>, <number>] }
+function castArithmetic(val) {
+  if (!Array.isArray(val)) {
+    if (!isLiteral(val)) {
+      return val;
+    }
+    try {
+      return castNumber(val);
+    } catch (err) {
+      throw new CastError('Number', val);
+    }
+  }
+
+  return val.map(v => {
+    if (!isLiteral(v)) {
+      return v;
+    }
+    try {
+      return castNumber(v);
+    } catch (err) {
+      throw new CastError('Number', v);
+    }
+  });
+}
+
+// { $op: [expression, expression] }
+function castComparison(val, schema, strictQuery) {
+  if (!Array.isArray(val) || val.length !== 2) {
+    throw new Error('Comparison operator must be an array of length 2');
+  }
+
+  val[0] = _castExpression(val[0], schema, strictQuery);
+  const lhs = val[0];
+
+  if (isLiteral(val[1])) {
+    let path = null;
+    let schematype = null;
+    let caster = null;
+    if (isPath(lhs)) {
+      path = lhs.slice(1);
+      schematype = schema.path(path);
+    } else if (typeof lhs === 'object' && lhs != null) {
+      for (const key of Object.keys(lhs)) {
+        if (dateOperators.has(key) && isPath(lhs[key])) {
+          path = lhs[key].slice(1) + '.' + key;
+          caster = castNumber;
+        } else if (arrayElementOperators.has(key) && isPath(lhs[key])) {
+          path = lhs[key].slice(1) + '.' + key;
+          schematype = schema.path(lhs[key].slice(1));
+          if (schematype != null) {
+            if (schematype.$isMongooseDocumentArray) {
+              schematype = schematype.$embeddedSchemaType;
+            } else if (schematype.$isMongooseArray) {
+              schematype = schematype.caster;
+            }
+          }
+        }
+      }
+    }
+
+    const is$literal = typeof val[1] === 'object' && val[1] != null && val[1].$literal != null;
+    if (schematype != null) {
+      if (is$literal) {
+        val[1] = { $literal: schematype.cast(val[1].$literal) };
+      } else {
+        val[1] = schematype.cast(val[1]);
+      }
+    } else if (caster != null) {
+      if (is$literal) {
+        try {
+          val[1] = { $literal: caster(val[1].$literal) };
+        } catch (err) {
+          throw new CastError(caster.name.replace(/^cast/, ''), val[1], path + '.$literal');
+        }
+      } else {
+        try {
+          val[1] = caster(val[1]);
+        } catch (err) {
+          throw new CastError(caster.name.replace(/^cast/, ''), val[1], path);
+        }
+      }
+    } else if (path != null && strictQuery === true) {
+      return void 0;
+    } else if (path != null && strictQuery === 'throw') {
+      throw new StrictModeError(path);
+    }
+  } else {
+    val[1] = _castExpression(val[1]);
+  }
+
+  return val;
+}
+
+function isPath(val) {
+  return typeof val === 'string' && val[0] === '$';
+}
+
+function isLiteral(val) {
+  if (typeof val === 'string' && val[0] === '$') {
+    return false;
+  }
+  if (typeof val === 'object' && val !== null && Object.keys(val).find(key => key[0] === '$')) {
+    // The `$literal` expression can make an object a literal
+    // https://docs.mongodb.com/manual/reference/operator/aggregation/literal/#mongodb-expression-exp.-literal
+    return val.$literal != null;
+  }
+  return true;
+}

package/lib/helpers/query/castUpdate.js

@@ -41,9 +41,10 @@ module.exports = function castUpdate(schema, obj, options, context, filter) {
     }
     return obj;
   }
+
   if (schema.options.strict === 'throw' && obj.hasOwnProperty(schema.options.discriminatorKey)) {
     throw new StrictModeError(schema.options.discriminatorKey);
-  } else if (context._mongooseOptions != null && !context._mongooseOptions.overwriteDiscriminatorKey) {
+  } else if (!options.overwriteDiscriminatorKey) {
     delete obj[schema.options.discriminatorKey];
   }
   if (options.upsert) {
@@ -353,7 +354,10 @@ function walkUpdatePath(schema, obj, op, options, context, filter, pref) {
         }
 
         if (Array.isArray(obj[key]) && (op === '$addToSet' || op === '$push') && key !== '$each') {
-          if (schematype && schematype.caster && !schematype.caster.$isMongooseArray) {
+          if (schematype &&
+              schematype.caster &&
+              !schematype.caster.$isMongooseArray &&
+              !schematype.caster[schemaMixedSymbol]) {
             obj[key] = { $each: obj[key] };
           }
         }

package/lib/helpers/query/isOperator.js

@@ -7,5 +7,8 @@ const specialKeys = new Set([
 ]);
 
 module.exports = function isOperator(path) {
-  return path.startsWith('$') && !specialKeys.has(path);
-};
+  return (
+    path[0] === '$' &&
+    !specialKeys.has(path)
+  );
+};

package/lib/helpers/schema/applyPlugins.js

@@ -7,7 +7,18 @@ module.exports = function applyPlugins(schema, plugins, options, cacheKey) {
   schema[cacheKey] = true;
 
   if (!options || !options.skipTopLevel) {
+    let pluginTags = null;
     for (const plugin of plugins) {
+      const tags = plugin[1] == null ? null : plugin[1].tags;
+      if (!Array.isArray(tags)) {
+        schema.plugin(plugin[0], plugin[1]);
+        continue;
+      }
+
+      pluginTags = pluginTags || new Set(schema.options.pluginTags || []);
+      if (!tags.find(tag => pluginTags.has(tag))) {
+        continue;
+      }
       schema.plugin(plugin[0], plugin[1]);
     }
   }

package/lib/helpers/schema/getPath.js

@@ -5,6 +5,8 @@
  * needing to put `.0.`, so `getPath(schema, 'docArr.elProp')` works.
  */
 
+const numberRE = /^\d+$/;
+
 module.exports = function getPath(schema, path) {
   let schematype = schema.path(path);
   if (schematype != null) {
@@ -16,7 +18,7 @@ module.exports = function getPath(schema, path) {
   let isArray = false;
 
   for (const piece of pieces) {
-    if (/^\d+$/.test(piece) && isArray) {
+    if (isArray && numberRE.test(piece)) {
       continue;
     }
     cur = cur.length === 0 ? piece : cur + '.' + piece;
@@ -25,7 +27,7 @@ module.exports = function getPath(schema, path) {
     if (schematype != null && schematype.schema) {
       schema = schematype.schema;
       cur = '';
-      if (schematype.$isMongooseDocumentArray) {
+      if (!isArray && schematype.$isMongooseDocumentArray) {
         isArray = true;
       }
     }

package/lib/helpers/timestamps/setupTimestamps.js

@@ -47,20 +47,15 @@ module.exports = function setupTimestamps(schema, timestamps) {
     const defaultTimestamp = currentTime != null ?
       currentTime() :
       this.ownerDocument().constructor.base.now();
-    const auto_id = this._id && this._id.auto;
 
     if (!skipCreatedAt && this.isNew && createdAt && !this.$__getValue(createdAt) && this.$__isSelected(createdAt)) {
-      this.$set(createdAt, auto_id ? this._id.getTimestamp() : defaultTimestamp);
+      this.$set(createdAt, defaultTimestamp);
     }
 
     if (!skipUpdatedAt && updatedAt && (this.isNew || this.$isModified())) {
       let ts = defaultTimestamp;
-      if (this.isNew) {
-        if (createdAt != null) {
-          ts = this.$__getValue(createdAt);
-        } else if (auto_id) {
-          ts = this._id.getTimestamp();
-        }
+      if (this.isNew && createdAt != null) {
+        ts = this.$__getValue(createdAt);
       }
       this.$set(updatedAt, ts);
     }

package/lib/index.js

@@ -19,7 +19,6 @@ const Query = require('./query');
 const Model = require('./model');
 const applyPlugins = require('./helpers/schema/applyPlugins');
 const driver = require('./driver');
-const get = require('./helpers/get');
 const promiseOrCallback = require('./helpers/promiseOrCallback');
 const legacyPluralize = require('./helpers/pluralize');
 const utils = require('./utils');
@@ -252,17 +251,17 @@ Mongoose.prototype.get = Mongoose.prototype.set;
  *     db.openUri('localhost', 'database', port, [opts]);
  *
  * @param {String} [uri] a mongodb:// URI
- * @param {Object} [options] passed down to the [MongoDB driver's `connect()` function](http://mongodb.github.io/node-mongodb-native/3.0/api/MongoClient.html), except for 4 mongoose-specific options explained below.
- * @param {Boolean} [options.bufferCommands=true] Mongoose specific option. Set to false to [disable buffering](http://mongoosejs.com/docs/faq.html#callback_never_executes) on all models associated with this connection.
+ * @param {Object} [options] passed down to the [MongoDB driver's `connect()` function](https://mongodb.github.io/node-mongodb-native/3.0/api/MongoClient.html), except for 4 mongoose-specific options explained below.
+ * @param {Boolean} [options.bufferCommands=true] Mongoose specific option. Set to false to [disable buffering](https://mongoosejs.com/docs/faq.html#callback_never_executes) on all models associated with this connection.
  * @param {String} [options.dbName] The name of the database you want to use. If not provided, Mongoose uses the database name from connection string.
  * @param {String} [options.user] username for authentication, equivalent to `options.auth.user`. Maintained for backwards compatibility.
  * @param {String} [options.pass] password for authentication, equivalent to `options.auth.password`. Maintained for backwards compatibility.
  * @param {Boolean} [options.autoIndex=true] Mongoose-specific option. Set to false to disable automatic index creation for all models associated with this connection.
  * @param {Number} [options.reconnectTries=30] If you're connected to a single server or mongos proxy (as opposed to a replica set), the MongoDB driver will try to reconnect every `reconnectInterval` milliseconds for `reconnectTries` times, and give up afterward. When the driver gives up, the mongoose connection emits a `reconnectFailed` event. This option does nothing for replica set connections.
  * @param {Number} [options.reconnectInterval=1000] See `reconnectTries` option above.
- * @param {Class} [options.promiseLibrary] Sets the [underlying driver's promise library](http://mongodb.github.io/node-mongodb-native/3.1/api/MongoClient.html).
- * @param {Number} [options.maxPoolSize=5] The maximum number of sockets the MongoDB driver will keep open for this connection. Keep in mind that MongoDB only allows one operation per socket at a time, so you may want to increase this if you find you have a few slow queries that are blocking faster queries from proceeding. See [Slow Trains in MongoDB and Node.js](http://thecodebarbarian.com/slow-trains-in-mongodb-and-nodejs).
- * @param {Number} [options.minPoolSize=1] The minimum number of sockets the MongoDB driver will keep open for this connection. Keep in mind that MongoDB only allows one operation per socket at a time, so you may want to increase this if you find you have a few slow queries that are blocking faster queries from proceeding. See [Slow Trains in MongoDB and Node.js](http://thecodebarbarian.com/slow-trains-in-mongodb-and-nodejs).
+ * @param {Class} [options.promiseLibrary] Sets the [underlying driver's promise library](https://mongodb.github.io/node-mongodb-native/3.1/api/MongoClient.html).
+ * @param {Number} [options.maxPoolSize=5] The maximum number of sockets the MongoDB driver will keep open for this connection. Keep in mind that MongoDB only allows one operation per socket at a time, so you may want to increase this if you find you have a few slow queries that are blocking faster queries from proceeding. See [Slow Trains in MongoDB and Node.js](https://thecodebarbarian.com/slow-trains-in-mongodb-and-nodejs).
+ * @param {Number} [options.minPoolSize=1] The minimum number of sockets the MongoDB driver will keep open for this connection. Keep in mind that MongoDB only allows one operation per socket at a time, so you may want to increase this if you find you have a few slow queries that are blocking faster queries from proceeding. See [Slow Trains in MongoDB and Node.js](https://thecodebarbarian.com/slow-trains-in-mongodb-and-nodejs).
  * @param {Number} [options.connectTimeoutMS=30000] How long the MongoDB driver will wait before killing a socket due to inactivity _during initial connection_. Defaults to 30000. This option is passed transparently to [Node.js' `socket#setTimeout()` function](https://nodejs.org/api/net.html#net_socket_settimeout_timeout_callback).
  * @param {Number} [options.socketTimeoutMS=30000] How long the MongoDB driver will wait before killing a socket due to inactivity _after initial connection_. A socket may be inactive because of either no activity or a long-running operation. This is set to `30000` by default, you should set this to 2-3x your longest running operation if you expect some of your database operations to run longer than 20 seconds. This option is passed to [Node.js `socket#setTimeout()` function](https://nodejs.org/api/net.html#net_socket_settimeout_timeout_callback) after the MongoDB driver successfully completes.
  * @param {Number} [options.family=0] Passed transparently to [Node.js' `dns.lookup()`](https://nodejs.org/api/dns.html#dns_dns_lookup_hostname_options_callback) function. May be either `0`, `4`, or `6`. `4` means use IPv4 only, `6` means use IPv6 only, `0` means try both.
@@ -309,20 +308,20 @@ Mongoose.prototype.createConnection = function(uri, options, callback) {
  *     })
  *
  * @param {String} uri(s)
- * @param {Object} [options] passed down to the [MongoDB driver's `connect()` function](http://mongodb.github.io/node-mongodb-native/3.0/api/MongoClient.html), except for 4 mongoose-specific options explained below.
- * @param {Boolean} [options.bufferCommands=true] Mongoose specific option. Set to false to [disable buffering](http://mongoosejs.com/docs/faq.html#callback_never_executes) on all models associated with this connection.
+ * @param {Object} [options] passed down to the [MongoDB driver's `connect()` function](https://mongodb.github.io/node-mongodb-native/3.0/api/MongoClient.html), except for 4 mongoose-specific options explained below.
+ * @param {Boolean} [options.bufferCommands=true] Mongoose specific option. Set to false to [disable buffering](https://mongoosejs.com/docs/faq.html#callback_never_executes) on all models associated with this connection.
  * @param {Number} [options.bufferTimeoutMS=10000] Mongoose specific option. If `bufferCommands` is true, Mongoose will throw an error after `bufferTimeoutMS` if the operation is still buffered.
  * @param {String} [options.dbName] The name of the database we want to use. If not provided, use database name from connection string.
  * @param {String} [options.user] username for authentication, equivalent to `options.auth.user`. Maintained for backwards compatibility.
  * @param {String} [options.pass] password for authentication, equivalent to `options.auth.password`. Maintained for backwards compatibility.
- * @param {Number} [options.maxPoolSize=100] The maximum number of sockets the MongoDB driver will keep open for this connection. Keep in mind that MongoDB only allows one operation per socket at a time, so you may want to increase this if you find you have a few slow queries that are blocking faster queries from proceeding. See [Slow Trains in MongoDB and Node.js](http://thecodebarbarian.com/slow-trains-in-mongodb-and-nodejs).
+ * @param {Number} [options.maxPoolSize=100] The maximum number of sockets the MongoDB driver will keep open for this connection. Keep in mind that MongoDB only allows one operation per socket at a time, so you may want to increase this if you find you have a few slow queries that are blocking faster queries from proceeding. See [Slow Trains in MongoDB and Node.js](https://thecodebarbarian.com/slow-trains-in-mongodb-and-nodejs).
  * @param {Number} [options.minPoolSize=0] The minimum number of sockets the MongoDB driver will keep open for this connection.
  * @param {Number} [options.serverSelectionTimeoutMS] If `useUnifiedTopology = true`, the MongoDB driver will try to find a server to send any given operation to, and keep retrying for `serverSelectionTimeoutMS` milliseconds before erroring out. If not set, the MongoDB driver defaults to using `30000` (30 seconds).
  * @param {Number} [options.heartbeatFrequencyMS] If `useUnifiedTopology = true`, the MongoDB driver sends a heartbeat every `heartbeatFrequencyMS` to check on the status of the connection. A heartbeat is subject to `serverSelectionTimeoutMS`, so the MongoDB driver will retry failed heartbeats for up to 30 seconds by default. Mongoose only emits a `'disconnected'` event after a heartbeat has failed, so you may want to decrease this setting to reduce the time between when your server goes down and when Mongoose emits `'disconnected'`. We recommend you do **not** set this setting below 1000, too many heartbeats can lead to performance degradation.
  * @param {Boolean} [options.autoIndex=true] Mongoose-specific option. Set to false to disable automatic index creation for all models associated with this connection.
  * @param {Number} [options.reconnectTries=30] If you're connected to a single server or mongos proxy (as opposed to a replica set), the MongoDB driver will try to reconnect every `reconnectInterval` milliseconds for `reconnectTries` times, and give up afterward. When the driver gives up, the mongoose connection emits a `reconnectFailed` event. This option does nothing for replica set connections.
  * @param {Number} [options.reconnectInterval=1000] See `reconnectTries` option above.
- * @param {Class} [options.promiseLibrary] Sets the [underlying driver's promise library](http://mongodb.github.io/node-mongodb-native/3.1/api/MongoClient.html).
+ * @param {Class} [options.promiseLibrary] Sets the [underlying driver's promise library](https://mongodb.github.io/node-mongodb-native/3.1/api/MongoClient.html).
  * @param {Number} [options.connectTimeoutMS=30000] How long the MongoDB driver will wait before killing a socket due to inactivity _during initial connection_. Defaults to 30000. This option is passed transparently to [Node.js' `socket#setTimeout()` function](https://nodejs.org/api/net.html#net_socket_settimeout_timeout_callback).
  * @param {Number} [options.socketTimeoutMS=30000] How long the MongoDB driver will wait before killing a socket due to inactivity _after initial connection_. A socket may be inactive because of either no activity or a long-running operation. This is set to `30000` by default, you should set this to 2-3x your longest running operation if you expect some of your database operations to run longer than 20 seconds. This option is passed to [Node.js `socket#setTimeout()` function](https://nodejs.org/api/net.html#net_socket_settimeout_timeout_callback) after the MongoDB driver successfully completes.
  * @param {Number} [options.family=0] Passed transparently to [Node.js' `dns.lookup()`](https://nodejs.org/api/dns.html#dns_dns_lookup_hostname_options_callback) function. May be either `0`, `4`, or `6`. `4` means use IPv4 only, `6` means use IPv6 only, `0` means try both.
@@ -379,13 +378,13 @@ Mongoose.prototype.disconnect = function(callback) {
 /**
  * _Requires MongoDB >= 3.6.0._ Starts a [MongoDB session](https://docs.mongodb.com/manual/release-notes/3.6/#client-sessions)
  * for benefits like causal consistency, [retryable writes](https://docs.mongodb.com/manual/core/retryable-writes/),
- * and [transactions](http://thecodebarbarian.com/a-node-js-perspective-on-mongodb-4-transactions.html).
+ * and [transactions](https://thecodebarbarian.com/a-node-js-perspective-on-mongodb-4-transactions.html).
  *
  * Calling `mongoose.startSession()` is equivalent to calling `mongoose.connection.startSession()`.
  * Sessions are scoped to a connection, so calling `mongoose.startSession()`
  * starts a session on the [default mongoose connection](/docs/api.html#mongoose_Mongoose-connection).
  *
- * @param {Object} [options] see the [mongodb driver options](http://mongodb.github.io/node-mongodb-native/3.0/api/MongoClient.html#startSession)
+ * @param {Object} [options] see the [mongodb driver options](https://mongodb.github.io/node-mongodb-native/3.0/api/MongoClient.html#startSession)
  * @param {Boolean} [options.causalConsistency=true] set to false to disable causal consistency
  * @param {Function} [callback]
  * @return {Promise<ClientSession>} promise that resolves to a MongoDB driver `ClientSession`
@@ -632,10 +631,8 @@ Mongoose.prototype._applyPlugins = function(schema, options) {
   const _mongoose = this instanceof Mongoose ? this : mongoose;
 
   options = options || {};
-  options.applyPluginsToDiscriminators = get(_mongoose,
-    'options.applyPluginsToDiscriminators', false);
-  options.applyPluginsToChildSchemas = get(_mongoose,
-    'options.applyPluginsToChildSchemas', true);
+  options.applyPluginsToDiscriminators = _mongoose.options && _mongoose.options.applyPluginsToDiscriminators || false;
+  options.applyPluginsToChildSchemas = typeof (_mongoose.options && _mongoose.options.applyPluginsToDiscriminators) === 'boolean' ? _mongoose.options.applyPluginsToDiscriminators : true;
   applyPlugins(schema, _mongoose.plugins, options, '$globalPluginsApplied');
 };
 
@@ -951,28 +948,33 @@ Mongoose.prototype.ObjectId = SchemaTypes.ObjectId;
  *     mongoose.isValidObjectId({ test: 42 }); // false
  *
  * @method isValidObjectId
+ * @param {Any} value
+ * @returns {boolean} true if it is a valid ObjectId
  * @api public
  */
 
 Mongoose.prototype.isValidObjectId = function(v) {
-  try {
-    new this.Types.ObjectId(v);
-  } catch (err) {
-    return false;
-  }
-
-  return true;
+  const _mongoose = this instanceof Mongoose ? this : mongoose;
+  return _mongoose.Types.ObjectId.isValid(v);
 };
 
-Mongoose.prototype.syncIndexes = function() {
+/**
+ *
+ * Syncs all the indexes for the models registered with this connection.
+ *
+ * @param {Object} options
+ * @param {Boolean} options.continueOnError `false` by default. If set to `true`, mongoose will not throw an error if one model syncing failed, and will return an object where the keys are the names of the models, and the values are the results/errors for each model.
+ * @returns
+ */
+Mongoose.prototype.syncIndexes = function(options) {
   const _mongoose = this instanceof Mongoose ? this : mongoose;
-  return _mongoose.connection.syncIndexes();
+  return _mongoose.connection.syncIndexes(options);
 };
 
 /**
  * The Mongoose Decimal128 [SchemaType](/docs/schematypes.html). Used for
  * declaring paths in your schema that should be
- * [128-bit decimal floating points](http://thecodebarbarian.com/a-nodejs-perspective-on-mongodb-34-decimal.html).
+ * [128-bit decimal floating points](https://thecodebarbarian.com/a-nodejs-perspective-on-mongodb-34-decimal.html).
  * Do not use this to create a new Decimal128 instance, use `mongoose.Types.Decimal128`
  * instead.
  *

package/lib/internal.js

@@ -10,7 +10,7 @@ const ActiveRoster = StateMachine.ctor('require', 'modify', 'init', 'default', '
 module.exports = exports = InternalCache;
 
 function InternalCache() {
-  this.activePaths = new ActiveRoster;
+  this.activePaths = new ActiveRoster();
   this.strictMode = undefined;
 }