mongoose 6.1.8 → 6.2.1

package/lib/schematype.js

@@ -128,6 +128,51 @@ function SchemaType(path, options, instance) {
 
 SchemaType.prototype.OptionsConstructor = SchemaTypeOptions;
 
+/**
+ * The path to this SchemaType in a Schema.
+ *
+ * ####Example:
+ *     const schema = new Schema({ name: String });
+ *     schema.path('name').path; // 'name'
+ *
+ * @property path
+ * @api public
+ * @memberOf SchemaType
+ */
+
+SchemaType.prototype.path;
+
+/**
+ * The validators that Mongoose should run to validate properties at this SchemaType's path.
+ *
+ * ####Example:
+ *     const schema = new Schema({ name: { type: String, required: true } });
+ *     schema.path('name').validators.length; // 1, the `required` validator
+ *
+ * @property validators
+ * @api public
+ * @memberOf SchemaType
+ */
+
+SchemaType.prototype.validators;
+
+/**
+ * True if this SchemaType has a required validator. False otherwise.
+ *
+ * ####Example:
+ *     const schema = new Schema({ name: { type: String, required: true } });
+ *     schema.path('name').isRequired; // true
+ *
+ *     schema.path('name').required(false);
+ *     schema.path('name').isRequired; // false
+ *
+ * @property isRequired
+ * @api public
+ * @memberOf SchemaType
+ */
+
+SchemaType.prototype.validators;
+
 /*!
  * ignore
  */
@@ -1080,7 +1125,7 @@ SchemaType.prototype.getDefault = function(scope, init) {
     }
 
     const casted = this.applySetters(ret, scope, init);
-    if (casted && casted.$isSingleNested) {
+    if (casted && !Array.isArray(casted) && casted.$isSingleNested) {
       casted.$__parent = scope;
     }
     return casted;
@@ -1283,6 +1328,16 @@ SchemaType.prototype.doValidate = function(value, fn, scope, options) {
   }
 };
 
+
+function _validate(ok, validatorProperties) {
+  if (ok !== undefined && !ok) {
+    const ErrorConstructor = validatorProperties.ErrorConstructor || ValidatorError;
+    const err = new ErrorConstructor(validatorProperties);
+    err[validatorErrorSymbol] = true;
+    return err;
+  }
+}
+
 /**
  * Performs a validation of `value` using the validators declared for this SchemaType.
  *
@@ -1306,7 +1361,7 @@ SchemaType.prototype.doValidateSync = function(value, scope, options) {
 
   let validators = this.validators;
   if (value === void 0) {
-    if (this.validators.length > 0 && this.validators[0].type === 'required') {
+    if (this.validators.length !== 0 && this.validators[0].type === 'required') {
       validators = [this.validators[0]];
     } else {
       return null;
@@ -1314,34 +1369,35 @@ SchemaType.prototype.doValidateSync = function(value, scope, options) {
   }
 
   let err = null;
-  validators.forEach(function(v) {
-    if (err) {
-      return;
-    }
+  let i = 0;
+  const len = validators.length;
+  for (i = 0; i < len; ++i) {
+
+    const v = validators[i];
 
     if (v == null || typeof v !== 'object') {
-      return;
+      continue;
     }
 
     const validator = v.validator;
     const validatorProperties = utils.clone(v);
     validatorProperties.path = options && options.path ? options.path : path;
     validatorProperties.value = value;
-    let ok;
+    let ok = false;
 
     // Skip any explicit async validators. Validators that return a promise
     // will still run, but won't trigger any errors.
     if (isAsyncFunction(validator)) {
-      return;
+      continue;
     }
 
     if (validator instanceof RegExp) {
-      validate(validator.test(value), validatorProperties);
-      return;
+      err = _validate(validator.test(value), validatorProperties);
+      continue;
     }
 
     if (typeof validator !== 'function') {
-      return;
+      continue;
     }
 
     try {
@@ -1358,23 +1414,15 @@ SchemaType.prototype.doValidateSync = function(value, scope, options) {
     // Skip any validators that return a promise, we can't handle those
     // synchronously
     if (ok != null && typeof ok.then === 'function') {
-      return;
+      continue;
     }
-    validate(ok, validatorProperties);
-  });
-
-  return err;
-
-  function validate(ok, validatorProperties) {
+    err = _validate(ok, validatorProperties);
     if (err) {
-      return;
-    }
-    if (ok !== undefined && !ok) {
-      const ErrorConstructor = validatorProperties.ErrorConstructor || ValidatorError;
-      err = new ErrorConstructor(validatorProperties);
-      err[validatorErrorSymbol] = true;
+      break;
     }
   }
+
+  return err;
 };
 
 /**
@@ -1585,7 +1633,7 @@ SchemaType.prototype._castForQuery = function(val) {
  */
 
 SchemaType.checkRequired = function(fn) {
-  if (arguments.length > 0) {
+  if (arguments.length !== 0) {
     this._checkRequired = fn;
   }
 

package/lib/types/ArraySubdocument.js

@@ -6,6 +6,7 @@
 
 const EventEmitter = require('events').EventEmitter;
 const Subdocument = require('./subdocument');
+const utils = require('../utils');
 
 const documentArrayParent = require('../helpers/symbols').documentArrayParent;
 
@@ -20,7 +21,7 @@ const documentArrayParent = require('../helpers/symbols').documentArrayParent;
  */
 
 function ArraySubdocument(obj, parentArr, skipId, fields, index) {
-  if (parentArr != null && parentArr.isMongooseDocumentArray) {
+  if (utils.isMongooseDocumentArray(parentArr)) {
     this.__parentArray = parentArr;
     this[documentArrayParent] = parentArr.$parent();
   } else {

package/lib/types/DocumentArray/index.js

@@ -15,7 +15,7 @@ const arrayPathSymbol = require('../../helpers/symbols').arrayPathSymbol;
 const arraySchemaSymbol = require('../../helpers/symbols').arraySchemaSymbol;
 
 const _basePush = Array.prototype.push;
-
+const numberRE = /^\d+$/;
 /**
  * DocumentArray constructor
  *
@@ -29,7 +29,7 @@ const _basePush = Array.prototype.push;
  */
 
 function MongooseDocumentArray(values, path, doc) {
-  const arr = [];
+  const __array = [];
 
   const internals = {
     [arrayAtomicsSymbol]: {},
@@ -45,10 +45,11 @@ function MongooseDocumentArray(values, path, doc) {
       internals[arrayAtomicsSymbol] = Object.assign({}, values[arrayAtomicsSymbol]);
     }
     values.forEach(v => {
-      _basePush.call(arr, v);
+      _basePush.call(__array, v);
     });
   }
   internals[arrayPathSymbol] = path;
+  internals.__array = __array;
 
   // Because doc comes from the context of another function, doc === global
   // can happen if there was a null somewhere up the chain (see #3020 && #3034)
@@ -69,7 +70,7 @@ function MongooseDocumentArray(values, path, doc) {
     }
   }
 
-  const proxy = new Proxy(arr, {
+  const proxy = new Proxy(__array, {
     get: function(target, prop) {
       if (prop === 'isMongooseArray' ||
           prop === 'isMongooseArrayProxy' ||
@@ -77,12 +78,6 @@ function MongooseDocumentArray(values, path, doc) {
           prop === 'isMongooseDocumentArrayProxy') {
         return true;
       }
-      if (prop === '__array') {
-        return arr;
-      }
-      if (prop === 'set') {
-        return set;
-      }
       if (internals.hasOwnProperty(prop)) {
         return internals[prop];
       }
@@ -93,15 +88,15 @@ function MongooseDocumentArray(values, path, doc) {
         return ArrayMethods[prop];
       }
 
-      return arr[prop];
+      return __array[prop];
     },
     set: function(target, prop, value) {
-      if (typeof prop === 'string' && /^\d+$/.test(prop)) {
-        set.call(proxy, prop, value);
+      if (typeof prop === 'string' && numberRE.test(prop)) {
+        DocumentArrayMethods.set.call(proxy, prop, value, false);
       } else if (internals.hasOwnProperty(prop)) {
         internals[prop] = value;
       } else {
-        arr[prop] = value;
+        __array[prop] = value;
       }
 
       return true;
@@ -111,18 +106,6 @@ function MongooseDocumentArray(values, path, doc) {
   return proxy;
 }
 
-function set(i, val, skipModified) {
-  const arr = this.__array;
-  if (skipModified) {
-    arr[i] = val;
-    return arr;
-  }
-  const value = DocumentArrayMethods._cast.call(this, val, i);
-  arr[i] = value;
-  DocumentArrayMethods._markModified.call(this, i);
-  return arr;
-}
-
 /*!
  * Module exports.
  */

package/lib/types/DocumentArray/isMongooseDocumentArray.js

@@ -0,0 +1,5 @@
+'use strict';
+
+exports.isMongooseDocumentArray = function(mongooseDocumentArray) {
+  return Array.isArray(mongooseDocumentArray) && mongooseDocumentArray.isMongooseDocumentArray;
+};

package/lib/types/DocumentArray/methods/index.js

@@ -36,7 +36,7 @@ const methods = {
     }
     let Constructor = this[arraySchemaSymbol].casterConstructor;
     const isInstance = Constructor.$isMongooseDocumentArray ?
-      value && value.isMongooseDocumentArray :
+      utils.isMongooseDocumentArray(value) :
       value instanceof Constructor;
     if (isInstance ||
         // Hack re: #5001, see #5005
@@ -295,7 +295,7 @@ const methods = {
             break;
         }
 
-        if (_arr[i].isMongooseArray) {
+        if (utils.isMongooseArray(_arr[i])) {
           notify(val, _arr[i]);
         } else if (_arr[i]) {
           _arr[i].emit(event, val);
@@ -304,6 +304,18 @@ const methods = {
     };
   },
 
+  set(i, val, skipModified) {
+    const arr = this.__array;
+    if (skipModified) {
+      arr[i] = val;
+      return this;
+    }
+    const value = methods._cast.call(this, val, i);
+    arr[i] = value;
+    methods._markModified.call(this, i);
+    return this;
+  },
+
   _markModified(elem, embeddedPath) {
     const parent = this[arrayParentSymbol];
     let dirtyPath;
@@ -326,7 +338,7 @@ const methods = {
         return this;
       }
 
-      parent.markModified(dirtyPath, arguments.length > 0 ? elem : parent);
+      parent.markModified(dirtyPath, arguments.length !== 0 ? elem : parent);
     }
 
     return this;

package/lib/types/array/index.js

@@ -27,9 +27,12 @@ const arraySchemaSymbol = require('../../helpers/symbols').arraySchemaSymbol;
  * @inherits Array
  * @see http://bit.ly/f6CnZU
  */
+const _basePush = Array.prototype.push;
+const numberRE = /^\d+$/;
 
 function MongooseArray(values, path, doc, schematype) {
-  let arr;
+  let __array;
+
   if (Array.isArray(values)) {
     const len = values.length;
 
@@ -38,21 +41,21 @@ function MongooseArray(values, path, doc, schematype) {
     // modifying the array is faster. Seems small, but adds up when you have a document
     // with thousands of nested arrays.
     if (len === 0) {
-      arr = new Array();
+      __array = new Array();
     } else if (len === 1) {
-      arr = new Array(1);
-      arr[0] = values[0];
+      __array = new Array(1);
+      __array[0] = values[0];
     } else if (len < 10000) {
-      arr = new Array();
-      arr.push.apply(arr, values);
+      __array = new Array();
+      _basePush.apply(__array, values);
     } else {
-      arr = new Array();
+      __array = new Array();
       for (let i = 0; i < len; ++i) {
-        arr.push(values[i]);
+        _basePush.apply(__array, values[i]);
       }
     }
   } else {
-    arr = [];
+    __array = [];
   }
 
   const internals = {
@@ -63,10 +66,10 @@ function MongooseArray(values, path, doc, schematype) {
     [arrayParentSymbol]: void 0,
     isMongooseArray: true,
     isMongooseArrayProxy: true,
-    __array: arr
+    __array: __array
   };
 
-  if (values[arrayAtomicsSymbol] != null) {
+  if (values && values[arrayAtomicsSymbol] != null) {
     internals[arrayAtomicsSymbol] = values[arrayAtomicsSymbol];
   }
 
@@ -79,7 +82,7 @@ function MongooseArray(values, path, doc, schematype) {
     internals[arraySchemaSymbol] = schematype || doc.schema.path(path);
   }
 
-  const proxy = new Proxy(arr, {
+  const proxy = new Proxy(__array, {
     get: function(target, prop) {
       if (internals.hasOwnProperty(prop)) {
         return internals[prop];
@@ -88,17 +91,15 @@ function MongooseArray(values, path, doc, schematype) {
         return mongooseArrayMethods[prop];
       }
 
-      return arr[prop];
+      return __array[prop];
     },
-    set: function(target, prop, val) {
-      if (typeof prop === 'string' && /^\d+$/.test(prop)) {
-        const value = mongooseArrayMethods._cast.call(proxy, val, prop);
-        arr[prop] = value;
-        mongooseArrayMethods._markModified.call(proxy, prop);
+    set: function(target, prop, value) {
+      if (typeof prop === 'string' && numberRE.test(prop)) {
+        mongooseArrayMethods.set.call(proxy, prop, value, false);
       } else if (internals.hasOwnProperty(prop)) {
-        internals[prop] = val;
+        internals[prop] = value;
       } else {
-        arr[prop] = val;
+        __array[prop] = value;
       }
 
       return true;

package/lib/types/array/isMongooseArray.js

@@ -0,0 +1,5 @@
+'use strict';
+
+exports.isMongooseArray = function(mongooseArray) {
+  return Array.isArray(mongooseArray) && mongooseArray.isMongooseArray;
+};

package/lib/types/array/methods/index.js

@@ -285,7 +285,7 @@ const methods = {
         return this;
       }
 
-      parent.markModified(dirtyPath, arguments.length > 0 ? elem : parent);
+      parent.markModified(dirtyPath, arguments.length !== 0 ? elem : parent);
     }
 
     return this;
@@ -393,8 +393,8 @@ const methods = {
       type = 'date';
     }
 
-    const rawValues = values.isMongooseArrayProxy ? values.__array : this;
-    const rawArray = this.isMongooseArrayProxy ? this.__array : this;
+    const rawValues = utils.isMongooseArray(values) ? values.__array : this;
+    const rawArray = utils.isMongooseArray(this) ? this.__array : this;
 
     rawValues.forEach(function(v) {
       let found;
@@ -520,7 +520,7 @@ const methods = {
    *
    * ####Note:
    *
-   * _marks the entire array as modified which will pass the entire thing to $set potentially overwritting any changes that happen between when you retrieved the object and when you save it._
+   * _marks the entire array as modified which will pass the entire thing to $set potentially overwriting any changes that happen between when you retrieved the object and when you save it._
    *
    * @see MongooseArray#$pop #types_array_MongooseArray-%24pop
    * @api public
@@ -638,7 +638,7 @@ const methods = {
     let atomic = values;
     const isOverwrite = values[0] != null &&
       utils.hasUserDefinedProperty(values[0], '$each');
-    const arr = this.isMongooseArrayProxy ? this.__array : this;
+    const arr = utils.isMongooseArray(this) ? this.__array : this;
     if (isOverwrite) {
       atomic = values[0];
       values = values[0].$each;
@@ -761,7 +761,7 @@ const methods = {
    */
 
   shift() {
-    const arr = this.isMongooseArrayProxy ? this.__array : this;
+    const arr = utils.isMongooseArray(this) ? this.__array : this;
     const ret = [].shift.call(arr);
     this._registerAtomic('$set', this);
     this._markModified();
@@ -782,7 +782,7 @@ const methods = {
    */
 
   sort() {
-    const arr = this.isMongooseArrayProxy ? this.__array : this;
+    const arr = utils.isMongooseArray(this) ? this.__array : this;
     const ret = [].sort.apply(arr, arguments);
     this._registerAtomic('$set', this);
     return ret;
@@ -803,7 +803,7 @@ const methods = {
 
   splice() {
     let ret;
-    const arr = this.isMongooseArrayProxy ? this.__array : this;
+    const arr = utils.isMongooseArray(this) ? this.__array : this;
 
     _checkManualPopulation(this, Array.prototype.slice.call(arguments, 2));
 
@@ -846,7 +846,7 @@ const methods = {
    */
 
   toObject(options) {
-    const arr = this.isMongooseArrayProxy ? this.__array : this;
+    const arr = utils.isMongooseArray(this) ? this.__array : this;
     if (options && options.depopulate) {
       options = utils.clone(options);
       options._isNested = true;
@@ -888,7 +888,7 @@ const methods = {
       values = this[arraySchemaSymbol].applySetters(values, this[arrayParentSymbol]);
     }
 
-    const arr = this.isMongooseArrayProxy ? this.__array : this;
+    const arr = utils.isMongooseArray(this) ? this.__array : this;
     [].unshift.apply(arr, values);
     this._registerAtomic('$set', this);
     this._markModified();
@@ -928,7 +928,7 @@ function _checkManualPopulation(arr, docs) {
     null :
     get(arr[arraySchemaSymbol], 'caster.options.ref', null);
   if (arr.length === 0 &&
-      docs.length > 0) {
+      docs.length !== 0) {
     if (_isAllSubdocs(docs, ref)) {
       arr[arrayParentSymbol].$populated(arr[arrayPathSymbol], [], {
         [populateModelSymbol]: docs[0].constructor
@@ -950,7 +950,7 @@ for (const method of returnVanillaArrayMethods) {
   }
 
   methods[method] = function() {
-    const _arr = this.isMongooseArrayProxy ? this.__array : this;
+    const _arr = utils.isMongooseArray(this) ? this.__array : this;
     const arr = [].concat(_arr);
 
     return arr[method].apply(arr, arguments);

package/lib/utils.js

@@ -12,6 +12,8 @@ const PopulateOptions = require('./options/PopulateOptions');
 const clone = require('./helpers/clone');
 const immediate = require('./helpers/immediate');
 const isObject = require('./helpers/isObject');
+const isMongooseArray = require('./types/array/isMongooseArray');
+const isMongooseDocumentArray = require('./types/DocumentArray/isMongooseDocumentArray');
 const isBsonType = require('./helpers/isBsonType');
 const getFunctionName = require('./helpers/getFunctionName');
 const isMongooseObject = require('./helpers/isMongooseObject');
@@ -24,6 +26,11 @@ let Document;
 
 exports.specialProperties = specialProperties;
 
+exports.isMongooseArray = isMongooseArray.isMongooseArray;
+exports.isMongooseDocumentArray = isMongooseDocumentArray.isMongooseDocumentArray;
+exports.registerMongooseArray = isMongooseArray.registerMongooseArray;
+exports.registerMongooseDocumentArray = isMongooseDocumentArray.registerMongooseDocumentArray;
+
 /*!
  * Produces a collection name from model `name`. By default, just returns
  * the model name
@@ -80,7 +87,11 @@ exports.deepEqual = function deepEqual(a, b) {
     return a.source === b.source &&
         a.ignoreCase === b.ignoreCase &&
         a.multiline === b.multiline &&
-        a.global === b.global;
+        a.global === b.global &&
+        a.dotAll === b.dotAll &&
+        a.unicode === b.unicode &&
+        a.sticky === b.sticky &&
+        a.hasIndices === b.hasIndices;
   }
 
   if (a == null || b == null) {
@@ -484,13 +495,9 @@ exports.expires = function expires(object) {
     return;
   }
 
-  let when;
-  if (typeof object.expires !== 'string') {
-    when = object.expires;
-  } else {
-    when = Math.round(ms(object.expires) / 1000);
-  }
-  object.expireAfterSeconds = when;
+  object.expireAfterSeconds = (typeof object.expires !== 'string')
+    ? object.expires
+    : Math.round(ms(object.expires) / 1000);
   delete object.expires;
 };