mongoose 6.1.8 → 6.2.1

package/lib/helpers/common.js

@@ -88,7 +88,7 @@ function modifiedPaths(update, path, result) {
         cur += '.' + sp[i];
       }
     }
-    if (isMongooseObject(val) && !Buffer.isBuffer(val)) {
+    if (!Buffer.isBuffer(val) && isMongooseObject(val)) {
       val = val.toObject({ transform: false, virtuals: false });
     }
     if (shouldFlatten(val)) {
@@ -108,7 +108,7 @@ function shouldFlatten(val) {
     typeof val === 'object' &&
     !(val instanceof Date) &&
     !(val instanceof ObjectId) &&
-    (!Array.isArray(val) || val.length > 0) &&
+    (!Array.isArray(val) || val.length !== 0) &&
     !(val instanceof Buffer) &&
     !(val instanceof Decimal128) &&
     !(val instanceof Binary);

package/lib/helpers/getFunctionName.js

@@ -1,8 +1,10 @@
 'use strict';
 
+const functionNameRE = /^function\s*([^\s(]+)/;
+
 module.exports = function(fn) {
-  if (fn.name) {
-    return fn.name;
-  }
-  return (fn.toString().trim().match(/^function\s*([^\s(]+)/) || [])[1];
+  return (
+    fn.name ||
+    (fn.toString().trim().match(functionNameRE) || [])[1]
+  );
 };

package/lib/helpers/isMongooseObject.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const isMongooseArray = require('../types/array/isMongooseArray').isMongooseArray;
 /*!
  * Returns if `v` is a mongoose object that has a `toObject()` method we can use.
  *
@@ -10,12 +11,12 @@
  */
 
 module.exports = function(v) {
-  if (v == null) {
-    return false;
-  }
-
-  return v.$__ != null || // Document
-    v.isMongooseArray || // Array or Document Array
-    v.isMongooseBuffer || // Buffer
-    v.$isMongooseMap; // Map
+  return (
+    v != null && (
+      isMongooseArray(v) || // Array or Document Array
+      v.$__ != null || // Document
+      v.isMongooseBuffer || // Buffer
+      v.$isMongooseMap // Map
+    )
+  );
 };

package/lib/helpers/isObject.js

@@ -9,8 +9,8 @@
  */
 
 module.exports = function(arg) {
-  if (Buffer.isBuffer(arg)) {
-    return true;
-  }
-  return Object.prototype.toString.call(arg) === '[object Object]';
+  return (
+    Buffer.isBuffer(arg) ||
+    Object.prototype.toString.call(arg) === '[object Object]'
+  );
 };

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/parentPaths.js

@@ -1,12 +1,17 @@
 'use strict';
 
+const dotRE = /\./g;
 module.exports = function parentPaths(path) {
-  const pieces = path.split('.');
+  if (path.indexOf('.') === -1) {
+    return [path];
+  }
+  const pieces = path.split(dotRE);
+  const len = pieces.length;
+  const ret = new Array(len);
   let cur = '';
-  const ret = [];
-  for (let i = 0; i < pieces.length; ++i) {
-    cur += (cur.length > 0 ? '.' : '') + pieces[i];
-    ret.push(cur);
+  for (let i = 0; i < len; ++i) {
+    cur += (cur.length !== 0) ? '.' + pieces[i] : pieces[i];
+    ret[i] = cur;
   }
 
   return ret;

package/lib/helpers/populate/assignRawDocsToIdStructure.js

@@ -35,11 +35,13 @@ function assignRawDocsToIdStructure(rawIds, resultDocs, resultOrder, options, re
   let sid;
   let id;
 
-  if (rawIds.isMongooseArrayProxy) {
+  if (utils.isMongooseArray(rawIds)) {
     rawIds = rawIds.__array;
   }
 
-  for (let i = 0; i < rawIds.length; ++i) {
+  let i = 0;
+  const len = rawIds.length;
+  for (i = 0; i < len; ++i) {
     id = rawIds[i];
 
     if (Array.isArray(id)) {

package/lib/helpers/populate/assignVals.js

@@ -241,15 +241,19 @@ function valueFilter(val, assignmentOpts, populateOptions, allIds) {
       }
     }
 
+    const rLen = ret.length;
     // Since we don't want to have to create a new mongoosearray, make sure to
     // modify the array in place
-    while (val.length > ret.length) {
+    while (val.length > rLen) {
       Array.prototype.pop.apply(val, []);
     }
-    for (let i = 0; i < ret.length; ++i) {
-      if (val.isMongooseArrayProxy) {
+    let i = 0;
+    if (utils.isMongooseArray(val)) {
+      for (i = 0; i < rLen; ++i) {
         val.set(i, ret[i], true);
-      } else {
+      }
+    } else {
+      for (i = 0; i < rLen; ++i) {
         val[i] = ret[i];
       }
     }

package/lib/helpers/populate/getModelsMapForPopulate.js

@@ -43,7 +43,7 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
   let allSchemaTypes = getSchemaTypes(model, modelSchema, null, options.path);
   allSchemaTypes = Array.isArray(allSchemaTypes) ? allSchemaTypes : [allSchemaTypes].filter(v => v != null);
 
-  if (allSchemaTypes.length <= 0 && options.strictPopulate !== false && options._localModel != null) {
+  if (allSchemaTypes.length === 0 && options.strictPopulate !== false && options._localModel != null) {
     return new MongooseError('Cannot populate path `' + (options._fullPath || options.path) +
       '` because it is not in your schema. Set the `strictPopulate` option ' +
       'to false to override.');
@@ -607,7 +607,7 @@ function _getLocalFieldValues(doc, localField, model, options, virtual, schema)
   const getters = 'getters' in _populateOptions ?
     _populateOptions.getters :
     get(virtual, 'options.getters', false);
-  if (localFieldGetters.length > 0 && getters) {
+  if (localFieldGetters.length !== 0 && getters) {
     const hydratedDoc = (doc.$__ != null) ? doc : model.hydrate(doc);
     const localFieldValue = utils.getValue(localField, doc);
     if (Array.isArray(localFieldValue)) {
@@ -644,7 +644,7 @@ function convertTo_id(val, schema) {
         rawVal[i] = rawVal[i]._id;
       }
     }
-    if (val.isMongooseArray && val.$schema()) {
+    if (utils.isMongooseArray(val) && val.$schema()) {
       return val.$schema()._castForPopulate(val, val.$parent());
     }
 
@@ -694,9 +694,9 @@ function _findRefPathForDiscriminators(doc, modelSchema, data, options, normaliz
     if (schematype != null &&
         schematype.$isMongooseArray &&
         schematype.caster.discriminators != null &&
-        Object.keys(schematype.caster.discriminators).length > 0) {
+        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/markArraySubdocsPopulated.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const utils = require('../../utils');
+
 /*!
  * If populating a path within a document array, make sure each
  * subdoc within the array knows its subpaths are populated.
@@ -29,7 +31,7 @@ module.exports = function markArraySubdocsPopulated(doc, populated) {
         continue;
       }
 
-      if (val.isMongooseDocumentArray) {
+      if (utils.isMongooseDocumentArray(val)) {
         for (let j = 0; j < val.length; ++j) {
           val[j].populated(rest, item._docs[id] == null ? void 0 : item._docs[id][j], item);
         }

package/lib/helpers/populate/modelNamesFromRefPath.js

@@ -7,6 +7,8 @@ const mpath = require('mpath');
 const util = require('util');
 const utils = require('../../utils');
 
+const hasNumericPropRE = /(\.\d+$|\.\d+\.)/g;
+
 module.exports = function modelNamesFromRefPath(refPath, doc, populatedPath, modelSchema, queryProjection) {
   if (refPath == null) {
     return [];
@@ -20,10 +22,9 @@ module.exports = function modelNamesFromRefPath(refPath, doc, populatedPath, mod
   // If populated path has numerics, the end `refPath` should too. For example,
   // if populating `a.0.b` instead of `a.b` and `b` has `refPath = a.c`, we
   // should return `a.0.c` for the refPath.
-  const hasNumericProp = /(\.\d+$|\.\d+\.)/g;
 
-  if (hasNumericProp.test(populatedPath)) {
-    const chunks = populatedPath.split(hasNumericProp);
+  if (hasNumericPropRE.test(populatedPath)) {
+    const chunks = populatedPath.split(hasNumericPropRE);
 
     if (chunks[chunks.length - 1] === '') {
       throw new Error('Can\'t populate individual element in an array');
@@ -35,8 +36,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/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/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/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/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);
     }