mongoose 6.1.7 → 6.2.0

package/lib/helpers/document/compile.js

@@ -9,6 +9,8 @@ let Document;
 const getSymbol = require('../../helpers/symbols').getSymbol;
 const scopeSymbol = require('../../helpers/symbols').scopeSymbol;
 
+const isPOJO = utils.isPOJO;
+
 /*!
  * exports
  */
@@ -22,12 +24,14 @@ exports.defineKey = defineKey;
 
 function compile(tree, proto, prefix, options) {
   Document = Document || require('../../document');
+  const typeKey = options.typeKey;
 
   for (const key of Object.keys(tree)) {
     const limb = tree[key];
 
-    const hasSubprops = utils.isPOJO(limb) && Object.keys(limb).length &&
-      (!limb[options.typeKey] || (options.typeKey === 'type' && limb.type.type));
+    const hasSubprops = isPOJO(limb) &&
+      Object.keys(limb).length > 0 &&
+      (!limb[typeKey] || (typeKey === 'type' && isPOJO(limb.type) && limb.type.type));
     const subprops = hasSubprops ? limb : null;
 
     defineKey({ prop: key, subprops: subprops, prototype: proto, prefix: prefix, options: options });

package/lib/helpers/model/discriminator.js

@@ -17,6 +17,7 @@ const CUSTOMIZABLE_DISCRIMINATOR_OPTIONS = {
  */
 
 module.exports = function discriminator(model, name, schema, tiedValue, applyPlugins) {
+
   if (!(schema && schema.instanceOfSchema)) {
     throw new Error('You must pass a valid discriminator Schema');
   }
@@ -201,7 +202,7 @@ module.exports = function discriminator(model, name, schema, tiedValue, applyPlu
 
   model.schema.discriminators[name] = schema;
 
-  if (model.discriminators[name]) {
+  if (model.discriminators[name] && !schema.options.overwriteModels) {
     throw new Error('Discriminator with name "' + name + '" already exists');
   }
 

package/lib/helpers/path/setDottedPath.js

@@ -1,9 +1,14 @@
 'use strict';
 
 module.exports = function setDottedPath(obj, path, val) {
-  const parts = path.indexOf('.') === -1 ? [path] : path.split('.');
+  if (path.indexOf('.') === -1) {
+    obj[path] = val;
+    return;
+  }
+  const parts = path.split('.');
+  const last = parts.pop();
   let cur = obj;
-  for (const part of parts.slice(0, -1)) {
+  for (const part of parts) {
     if (cur[part] == null) {
       cur[part] = {};
     }
@@ -11,6 +16,5 @@ module.exports = function setDottedPath(obj, path, val) {
     cur = cur[part];
   }
 
-  const last = parts[parts.length - 1];
   cur[last] = val;
 };

package/lib/helpers/populate/getModelsMapForPopulate.js

@@ -696,7 +696,7 @@ function _findRefPathForDiscriminators(doc, modelSchema, data, options, normaliz
         schematype.caster.discriminators != null &&
         Object.keys(schematype.caster.discriminators).length > 0) {
       const subdocs = utils.getValue(cur, doc);
-      const remnant = options.path.substr(cur.length + 1);
+      const remnant = options.path.substring(cur.length + 1);
       const discriminatorKey = schematype.caster.schema.options.discriminatorKey;
       modelNames = [];
       for (const subdoc of subdocs) {
@@ -708,7 +708,7 @@ function _findRefPathForDiscriminators(doc, modelSchema, data, options, normaliz
         }
         const _path = discriminatorSchema.path(remnant);
         if (_path == null || _path.options.refPath == null) {
-          const docValue = utils.getValue(data.localField.substr(cur.length + 1), subdoc);
+          const docValue = utils.getValue(data.localField.substring(cur.length + 1), subdoc);
           ret.forEach((v, i) => {
             if (v === docValue) {
               ret[i] = SkipPopulateValue(v);

package/lib/helpers/populate/modelNamesFromRefPath.js

@@ -35,8 +35,8 @@ module.exports = function modelNamesFromRefPath(refPath, doc, populatedPath, mod
     for (let i = 0; i < chunks.length; i += 2) {
       const chunk = chunks[i];
       if (_remaining.startsWith(chunk + '.')) {
-        _refPath += _remaining.substr(0, chunk.length) + chunks[i + 1];
-        _remaining = _remaining.substr(chunk.length + 1);
+        _refPath += _remaining.substring(0, chunk.length) + chunks[i + 1];
+        _remaining = _remaining.substring(chunk.length + 1);
       } else if (i === chunks.length - 1) {
         _refPath += _remaining;
         _remaining = '';

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

@@ -0,0 +1,284 @@
+'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 (const key of keys) {
+    if (val[key] === void 0) {
+      delete val[key];
+    }
+  }
+}
+
+// { $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) {
+  let search = val[0];
+  let path = val[1];
+  if (!isPath(path)) {
+    return val;
+  }
+
+  path = path.slice(1);
+  const schematype = schema.path(path);
+  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');
+  }
+
+  if (schematype.$isMongooseDocumentArray) {
+    search = schematype.$embeddedSchemaType.cast(search);
+  } else {
+    search = schematype.caster.cast(search);
+  }
+  return [search, val[1]];
+}
+
+// { $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.startsWith('$');
+}
+
+function isLiteral(val) {
+  if (typeof val === 'string' && val.startsWith('$')) {
+    return false;
+  }
+  if (typeof val === 'object' && val != null && Object.keys(val).find(key => key.startsWith('$'))) {
+    // 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/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/setDefaultsOnInsert.js

@@ -79,14 +79,23 @@ module.exports = function(filter, schema, castedDoc, options) {
       return;
     }
     const def = schemaType.getDefault(null, true);
-    if (!isModified(modified, path) && typeof def !== 'undefined') {
-      castedDoc = castedDoc || {};
-      castedDoc.$setOnInsert = castedDoc.$setOnInsert || {};
-      if (get(castedDoc, path) == null) {
-        castedDoc.$setOnInsert[path] = def;
-      }
-      updatedValues[path] = def;
+    if (isModified(modified, path)) {
+      return;
+    }
+    if (typeof def === 'undefined') {
+      return;
+    }
+    if (schemaType.splitPath().includes('$*')) {
+      // Skip defaults underneath maps. We should never do `$setOnInsert` on a path with `$*`
+      return;
+    }
+
+    castedDoc = castedDoc || {};
+    castedDoc.$setOnInsert = castedDoc.$setOnInsert || {};
+    if (get(castedDoc, path) == null) {
+      castedDoc.$setOnInsert[path] = def;
     }
+    updatedValues[path] = def;
   });
 
   return castedDoc;

package/lib/helpers/update/applyTimestampsToChildren.js

@@ -153,7 +153,7 @@ function applyTimestampsToUpdateKey(schema, key, update, now) {
         // Single nested is easy
         update[parentPath + '.' + updatedAt] = now;
       } else if (parentSchemaType.$isMongooseDocumentArray) {
-        let childPath = key.substr(parentPath.length + 1);
+        let childPath = key.substring(parentPath.length + 1);
 
         if (/^\d+$/.test(childPath)) {
           update[parentPath + '.' + childPath][updatedAt] = now;
@@ -161,7 +161,7 @@ function applyTimestampsToUpdateKey(schema, key, update, now) {
         }
 
         const firstDot = childPath.indexOf('.');
-        childPath = firstDot !== -1 ? childPath.substr(0, firstDot) : childPath;
+        childPath = firstDot !== -1 ? childPath.substring(0, firstDot) : childPath;
 
         update[parentPath + '.' + childPath + '.' + updatedAt] = now;
       }

package/lib/helpers/update/castArrayFilters.js

@@ -51,7 +51,7 @@ function _castArrayFilters(arrayFilters, schema, strictQuery, updatedPathsByFilt
       const dot = key.indexOf('.');
       let filterPath = dot === -1 ?
         updatedPathsByFilter[key] + '.0' :
-        updatedPathsByFilter[key.substr(0, dot)] + '.0' + key.substr(dot);
+        updatedPathsByFilter[key.substring(0, dot)] + '.0' + key.substring(dot);
       if (filterPath == null) {
         throw new Error(`Filter path not found for ${key}`);
       }

package/lib/helpers/update/updatedPathsByArrayFilter.js

@@ -19,7 +19,7 @@ module.exports = function updatedPathsByArrayFilter(update) {
         throw new Error(`Path '${path}' contains the same array filter multiple times`);
       }
       cur[match.substring(2, match.length - 1)] = path.
-        substr(0, firstMatch - 1).
+        substring(0, firstMatch - 1).
         replace(/\$\[[^\]]+\]/g, '0');
     }
     return cur;

package/lib/index.js

@@ -947,55 +947,29 @@ Mongoose.prototype.ObjectId = SchemaTypes.ObjectId;
  *
  *     mongoose.isValidObjectId(new mongoose.Types.ObjectId()); // true
  *     mongoose.isValidObjectId('0123456789ab'); // true
- *     mongoose.isValidObjectId(6); // false
+ *     mongoose.isValidObjectId(6); // true
+ *     mongoose.isValidObjectId({ test: 42 }); // false
  *
  * @method isValidObjectId
  * @api public
  */
 
 Mongoose.prototype.isValidObjectId = function(v) {
-  if (v == null) {
-    return true;
-  }
-  const base = this || mongoose;
-  const ObjectId = base.driver.get().ObjectId;
-  if (v instanceof ObjectId) {
-    return true;
-  }
-
-  if (v._id != null) {
-    if (v._id instanceof ObjectId) {
-      return true;
-    }
-    if (v._id.toString instanceof Function) {
-      v = v._id.toString();
-      if (typeof v === 'string' && v.length === 12) {
-        return true;
-      }
-      if (typeof v === 'string' && /^[0-9A-Fa-f]{24}$/.test(v)) {
-        return true;
-      }
-      return false;
-    }
-  }
-
-  if (v.toString instanceof Function) {
-    v = v.toString();
-  }
-
-  if (typeof v === 'string' && v.length === 12) {
-    return true;
-  }
-  if (typeof v === 'string' && /^[0-9A-Fa-f]{24}$/.test(v)) {
-    return true;
-  }
-
-  return false;
+  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);
 };
 
 /**

package/lib/model.js

@@ -48,6 +48,7 @@ const modifiedPaths = require('./helpers/update/modifiedPaths');
 const parallelLimit = require('./helpers/parallelLimit');
 const prepareDiscriminatorPipeline = require('./helpers/aggregate/prepareDiscriminatorPipeline');
 const removeDeselectedForeignField = require('./helpers/populate/removeDeselectedForeignField');
+const setDottedPath = require('./helpers/path/setDottedPath');
 const util = require('util');
 const utils = require('./utils');
 
@@ -832,7 +833,8 @@ Model.prototype.$__version = function(where, delta) {
   if (where === true) {
     // this is an insert
     if (key) {
-      this.$__setValue(key, delta[key] = 0);
+      setDottedPath(delta, key, 0);
+      this.$__setValue(key, 0);
     }
     return;
   }
@@ -1059,8 +1061,8 @@ Model.prototype.model = function model(name) {
 };
 
 /**
- * Returns true if at least one document exists in the database that matches
- * the given `filter`, and false otherwise.
+ * Returns a document with `_id` only if at least one document exists in the database that matches
+ * the given `filter`, and `null` otherwise.
  *
  * Under the hood, `MyModel.exists({ answer: 42 })` is equivalent to
  * `MyModel.findOne({ answer: 42 }).select({ _id: 1 }).lean()`
@@ -1097,10 +1099,6 @@ Model.exists = function exists(filter, options, callback) {
   if (typeof callback === 'function') {
     return query.exec(callback);
   }
-  options = options || {};
-  if (!options.explain) {
-    return query.then(doc => !!doc);
-  }
 
   return query;
 };
@@ -1136,11 +1134,13 @@ Model.exists = function exists(filter, options, callback) {
  * @param {Object|String} [options] If string, same as `options.value`.
  * @param {String} [options.value] the string stored in the `discriminatorKey` property. If not specified, Mongoose uses the `name` parameter.
  * @param {Boolean} [options.clone=true] By default, `discriminator()` clones the given `schema`. Set to `false` to skip cloning.
+ * @param {Boolean} [options.overwriteModels=false] by default, Mongoose does not allow you to define a discriminator with the same name as another discriminator. Set this to allow overwriting discriminators with the same name.
  * @return {Model} The newly created discriminator model
  * @api public
  */
 
 Model.discriminator = function(name, schema, options) {
+
   let model;
   if (typeof name === 'function') {
     model = name;
@@ -1164,7 +1164,7 @@ Model.discriminator = function(name, schema, options) {
   }
 
   schema = discriminator(this, name, schema, value, true);
-  if (this.db.models[name]) {
+  if (this.db.models[name] && !schema.options.overwriteModels) {
     throw new OverwriteModelError(name);
   }
 
@@ -3069,10 +3069,10 @@ Model.create = function create(doc, options, callback) {
     options = {};
     // Handle falsy callbacks re: #5061
     if (typeof last === 'function' || (arguments.length > 1 && !last)) {
-      cb = last;
-      args = utils.args(arguments, 0, arguments.length - 1);
+      args = [...arguments];
+      cb = args.pop();
     } else {
-      args = utils.args(arguments);
+      args = [...arguments];
     }
 
     if (args.length === 2 &&
@@ -3609,16 +3609,21 @@ Model.bulkWrite = function(ops, options, callback) {
  * `bulkSave` uses `bulkWrite` under the hood, so it's mostly useful when dealing with many documents (10K+)
  *
  * @param {[Document]} documents
+ * @param {Object} [options] options passed to the underlying `bulkWrite()`
+ * @param {ClientSession} [options.session=null] The session associated with this bulk write. See [transactions docs](/docs/transactions.html).
+ * @param {String|number} [options.w=1] The [write concern](https://docs.mongodb.com/manual/reference/write-concern/). See [`Query#w()`](/docs/api.html#query_Query-w) for more information.
+ * @param {number} [options.wtimeout=null] The [write concern timeout](https://docs.mongodb.com/manual/reference/write-concern/#wtimeout).
+ * @param {Boolean} [options.j=true] If false, disable [journal acknowledgement](https://docs.mongodb.com/manual/reference/write-concern/#j-option)
  *
  */
-Model.bulkSave = function(documents) {
+Model.bulkSave = function(documents, options) {
   const preSavePromises = documents.map(buildPreSavePromise);
 
   const writeOperations = this.buildBulkWriteOperations(documents, { skipValidation: true });
 
   let bulkWriteResultPromise;
   return Promise.all(preSavePromises)
-    .then(() => bulkWriteResultPromise = this.bulkWrite(writeOperations))
+    .then(() => bulkWriteResultPromise = this.bulkWrite(writeOperations, options))
     .then(() => documents.map(buildSuccessfulWriteHandlerPromise))
     .then(() => bulkWriteResultPromise)
     .catch((err) => {