mongoose 6.1.10 → 6.2.3

package/lib/schematype.js

@@ -8,7 +8,6 @@ const MongooseError = require('./error/index');
 const SchemaTypeOptions = require('./options/SchemaTypeOptions');
 const $exists = require('./schema/operators/exists');
 const $type = require('./schema/operators/type');
-const get = require('./helpers/get');
 const handleImmutable = require('./helpers/schematype/handleImmutable');
 const isAsyncFunction = require('./helpers/isAsyncFunction');
 const immediate = require('./helpers/immediate');
@@ -128,6 +127,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
  */
@@ -743,7 +787,7 @@ SchemaType.prototype.get = function(fn) {
  *
  *     // make sure every value is equal to "something"
  *     function validator (val) {
- *       return val == 'something';
+ *       return val === 'something';
  *     }
  *     new Schema({ name: { type: String, validate: validator }});
  *
@@ -871,7 +915,7 @@ SchemaType.prototype.validate = function(obj, message, type) {
     if (!utils.isPOJO(arg)) {
       const msg = 'Invalid validator. Received (' + typeof arg + ') '
           + arg
-          + '. See http://mongoosejs.com/docs/api.html#schematype_SchemaType-validate';
+          + '. See https://mongoosejs.com/docs/api.html#schematype_SchemaType-validate';
 
       throw new Error(msg);
     }
@@ -981,7 +1025,7 @@ SchemaType.prototype.required = function(required, message) {
   this.isRequired = true;
 
   this.requiredValidator = function(v) {
-    const cachedRequired = get(this, '$__.cachedRequired');
+    const cachedRequired = this && this.$__ && this.$__.cachedRequired;
 
     // no validation when this path wasn't selected in the query.
     if (cachedRequired != null && !this.$__isSelected(_this.path) && !this[documentIsModified](_this.path)) {
@@ -1080,7 +1124,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;
@@ -1206,10 +1250,10 @@ SchemaType.prototype.doValidate = function(value, fn, scope, options) {
     return fn(null);
   }
 
-  const _this = this;
-  validators.forEach(function(v) {
+  for (let i = 0, len = validators.length; i < len; ++i) {
+    const v = validators[i];
     if (err) {
-      return;
+      break;
     }
 
     const validator = v.validator;
@@ -1221,16 +1265,16 @@ SchemaType.prototype.doValidate = function(value, fn, scope, options) {
 
     if (validator instanceof RegExp) {
       validate(validator.test(value), validatorProperties);
-      return;
+      continue;
     }
 
     if (typeof validator !== 'function') {
-      return;
+      continue;
     }
 
-    if (value === undefined && validator !== _this.requiredValidator) {
+    if (value === undefined && validator !== this.requiredValidator) {
       validate(true, validatorProperties);
-      return;
+      continue;
     }
 
     try {
@@ -1259,8 +1303,7 @@ SchemaType.prototype.doValidate = function(value, fn, scope, options) {
     } else {
       validate(ok, validatorProperties);
     }
-
-  });
+  }
 
   function validate(ok, validatorProperties) {
     if (err) {
@@ -1283,6 +1326,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 +1359,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 +1367,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 +1412,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;
 };
 
 /**
@@ -1429,7 +1475,7 @@ SchemaType.prototype._castRef = function _castRef(value, doc, init) {
   }
 
   if (value.$__ != null) {
-    value.$__.wasPopulated = true;
+    value.$__.wasPopulated = value.$__.wasPopulated || true;
     return value;
   }
 
@@ -1585,7 +1631,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
  *
@@ -25,11 +25,11 @@ const _basePush = Array.prototype.push;
  * @api private
  * @return {MongooseDocumentArray}
  * @inherits MongooseArray
- * @see http://bit.ly/f6CnZU
+ * @see https://bit.ly/f6CnZU
  */
 
 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

@@ -25,11 +25,14 @@ const arraySchemaSymbol = require('../../helpers/symbols').arraySchemaSymbol;
  * @param {Document} doc parent document
  * @api private
  * @inherits Array
- * @see http://bit.ly/f6CnZU
+ * @see https://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.call(__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;
+};