mongoose 6.1.9 → 6.2.2

package/lib/queryhelpers.js

@@ -26,9 +26,9 @@ exports.preparePopulationOptions = function preparePopulationOptions(query, opti
 
   // lean options should trickle through all queries
   if (options.lean != null) {
-    pop.
-      filter(p => get(p, 'options.lean') == null).
-      forEach(makeLean(options.lean));
+    pop
+      .filter(p => (p && p.options && p.options.lean) == null)
+      .forEach(makeLean(options.lean));
   }
 
   pop.forEach(opts => {
@@ -53,12 +53,12 @@ exports.preparePopulationOptionsMQ = function preparePopulationOptionsMQ(query,
 
   // lean options should trickle through all queries
   if (options.lean != null) {
-    pop.
-      filter(p => get(p, 'options.lean') == null).
-      forEach(makeLean(options.lean));
+    pop
+      .filter(p => (p && p.options && p.options.lean) == null)
+      .forEach(makeLean(options.lean));
   }
 
-  const session = get(query, 'options.session', null);
+  const session = query && query.options && query.options.session || null;
   if (session != null) {
     pop.forEach(path => {
       if (path.options == null) {
@@ -212,7 +212,7 @@ exports.applyPaths = function applyPaths(fields, schema) {
 
       let addedPath = analyzePath(path, type);
       // arrays
-      if (addedPath == null && type.$isMongooseArray && !type.$isMongooseDocumentArray) {
+      if (addedPath == null && !Array.isArray(type) && type.$isMongooseArray && !type.$isMongooseDocumentArray) {
         addedPath = analyzePath(path, type.caster);
       }
       if (addedPath != null) {
@@ -272,7 +272,7 @@ exports.applyPaths = function applyPaths(fields, schema) {
     // Special case: if user has included a parent path of a discriminator key,
     // don't explicitly project in the discriminator key because that will
     // project out everything else under the parent path
-    if (!exclude && get(type, 'options.$skipDiscriminatorCheck', false)) {
+    if (!exclude && (type && type.options && type.options.$skipDiscriminatorCheck || false)) {
       let cur = '';
       for (let i = 0; i < pieces.length; ++i) {
         cur += (cur.length === 0 ? '' : '.') + pieces[i];
@@ -319,7 +319,7 @@ exports.handleDeleteWriteOpResult = function handleDeleteWriteOpResult(callback)
       return callback(error);
     }
     const mongooseResult = Object.assign({}, res.result);
-    if (get(res, 'result.n', null) != null) {
+    if ((res && res.result && res.result.n || null) != null) {
       mongooseResult.deletedCount = res.result.n;
     }
     if (res.deletedCount != null) {

package/lib/schema/SubdocumentPath.js

@@ -13,7 +13,6 @@ const $exists = require('./operators/exists');
 const castToNumber = require('./operators/helpers').castToNumber;
 const discriminator = require('../helpers/model/discriminator');
 const geospatial = require('./operators/geospatial');
-const get = require('../helpers/get');
 const getConstructor = require('../helpers/discriminator/getConstructor');
 const handleIdOption = require('../helpers/schema/handleIdOption');
 const internalToObjectOptions = require('../options').internalToObjectOptions;
@@ -164,7 +163,7 @@ SubdocumentPath.prototype.cast = function(val, doc, init, priorVal, options) {
   let subdoc;
 
   // Only pull relevant selected paths and pull out the base path
-  const parentSelected = get(doc, '$__.selected', {});
+  const parentSelected = doc && doc.$__ && doc.$__.selected || {};
   const path = this.path;
   const selected = Object.keys(parentSelected).reduce((obj, key) => {
     if (key.startsWith(path + '.')) {
@@ -301,7 +300,9 @@ SubdocumentPath.prototype.doValidateSync = function(value, scope, options) {
 SubdocumentPath.prototype.discriminator = function(name, schema, options) {
   options = options || {};
   const value = utils.isPOJO(options) ? options.value : options;
-  const clone = get(options, 'clone', true);
+  const clone = typeof options.clone === 'boolean'
+    ? options.clone
+    : true;
 
   if (schema.instanceOfSchema && clone) {
     schema = schema.clone();

package/lib/schema/array.js

@@ -13,7 +13,6 @@ const CastError = SchemaType.CastError;
 const Mixed = require('./mixed');
 const arrayDepth = require('../helpers/arrayDepth');
 const cast = require('../cast');
-const get = require('../helpers/get');
 const isOperator = require('../helpers/query/isOperator');
 const util = require('util');
 const utils = require('../utils');
@@ -112,14 +111,12 @@ function SchemaArray(key, cast, options, schemaOptions) {
 
   if (!('defaultValue' in this) || this.defaultValue !== void 0) {
     const defaultFn = function() {
-      let arr = [];
-      if (fn) {
-        arr = defaultArr.call(this);
-      } else if (defaultArr != null) {
-        arr = arr.concat(defaultArr);
-      }
       // Leave it up to `cast()` to convert the array
-      return arr;
+      return fn
+        ? defaultArr.call(this)
+        : defaultArr != null
+          ? [].concat(defaultArr)
+          : [];
     };
     defaultFn.$runBeforeSetters = !fn;
     this.default(defaultFn);
@@ -220,7 +217,7 @@ SchemaArray.prototype.checkRequired = function checkRequired(value, doc) {
 
   // `require('util').inherits()` does **not** copy static properties, and
   // plugins like mongoose-float use `inherits()` for pre-ES6.
-  const _checkRequired = typeof this.constructor.checkRequired == 'function' ?
+  const _checkRequired = typeof this.constructor.checkRequired === 'function' ?
     this.constructor.checkRequired() :
     SchemaArray.checkRequired();
 
@@ -238,7 +235,9 @@ SchemaArray.prototype.checkRequired = function checkRequired(value, doc) {
 SchemaArray.prototype.enum = function() {
   let arr = this;
   while (true) {
-    const instance = get(arr, 'caster.instance');
+    const instance = arr &&
+    arr.caster &&
+    arr.caster.instance;
     if (instance === 'Array') {
       arr = arr.caster;
       continue;
@@ -275,7 +274,7 @@ SchemaArray.prototype.applyGetters = function(value, scope) {
 
   const ret = SchemaType.prototype.applyGetters.call(this, value, scope);
   if (Array.isArray(ret)) {
-    const rawValue = ret.isMongooseArrayProxy ? ret.__array : ret;
+    const rawValue = utils.isMongooseArray(ret) ? ret.__array : ret;
     const len = rawValue.length;
     for (let i = 0; i < len; ++i) {
       rawValue[i] = this.caster.applyGetters(rawValue[i], scope);
@@ -299,7 +298,7 @@ SchemaArray.prototype._applySetters = function(value, scope, init, priorVal) {
     }
 
     // No need to wrap empty arrays
-    if (value != null && value.length > 0) {
+    if (value != null && value.length !== 0) {
       const valueDepth = arrayDepth(value);
       if (valueDepth.min === valueDepth.max && valueDepth.max < depth && valueDepth.containsNonArrayItem) {
         for (let i = valueDepth.max; i < depth; ++i) {
@@ -357,7 +356,7 @@ SchemaArray.prototype.cast = function(value, doc, init, prev, options) {
 
     options = options || emptyOpts;
 
-    let rawValue = value.isMongooseArrayProxy ? value.__array : value;
+    let rawValue = utils.isMongooseArray(value) ? value.__array : value;
     value = MongooseArray(rawValue, options.path || this._arrayPath || this.path, doc, this);
     rawValue = value.__array;
 
@@ -557,12 +556,16 @@ function cast$all(val) {
   }
 
   val = val.map(function(v) {
-    if (utils.isObject(v)) {
-      const o = {};
-      o[this.path] = v;
-      return cast(this.casterConstructor.schema, o)[this.path];
+    if (!utils.isObject(v)) {
+      return v;
+    }
+    if (v.$elemMatch != null) {
+      return { $elemMatch: cast(this.casterConstructor.schema, v.$elemMatch) };
     }
-    return v;
+
+    const o = {};
+    o[this.path] = v;
+    return cast(this.casterConstructor.schema, o)[this.path];
   }, this);
 
   return this.castForQuery(val);
@@ -581,9 +584,15 @@ function cast$elemMatch(val) {
 
   // Is this an embedded discriminator and is the discriminator key set?
   // If so, use the discriminator schema. See gh-7449
-  const discriminatorKey = get(this,
-    'casterConstructor.schema.options.discriminatorKey');
-  const discriminators = get(this, 'casterConstructor.schema.discriminators', {});
+  const discriminatorKey = this &&
+    this.casterConstructor &&
+    this.casterConstructor.schema &&
+    this.casterConstructor.schema.options &&
+    this.casterConstructor.schema.options.discriminatorKey;
+  const discriminators = this &&
+  this.casterConstructor &&
+  this.casterConstructor.schema &&
+  this.casterConstructor.schema.discriminators || {};
   if (discriminatorKey != null &&
       val[discriminatorKey] != null &&
       discriminators[val[discriminatorKey]] != null) {

package/lib/schema/buffer.js

@@ -202,7 +202,7 @@ SchemaBuffer.prototype.cast = function(value, doc, init) {
 
 /**
  * Sets the default [subtype](https://studio3t.com/whats-new/best-practices-uuid-mongodb/)
- * for this buffer. You can find a [list of allowed subtypes here](http://api.mongodb.com/python/current/api/bson/binary.html).
+ * for this buffer. You can find a [list of allowed subtypes here](https://api.mongodb.com/python/current/api/bson/binary.html).
  *
  * ####Example:
  *

package/lib/schema/date.js

@@ -201,7 +201,7 @@ SchemaDate.prototype.checkRequired = function(value, doc) {
 
   // `require('util').inherits()` does **not** copy static properties, and
   // plugins like mongoose-float use `inherits()` for pre-ES6.
-  const _checkRequired = typeof this.constructor.checkRequired == 'function' ?
+  const _checkRequired = typeof this.constructor.checkRequired === 'function' ?
     this.constructor.checkRequired() :
     SchemaDate.checkRequired();
   return _checkRequired(value);

package/lib/schema/decimal128.js

@@ -146,7 +146,7 @@ Decimal128.prototype.checkRequired = function checkRequired(value, doc) {
 
   // `require('util').inherits()` does **not** copy static properties, and
   // plugins like mongoose-float use `inherits()` for pre-ES6.
-  const _checkRequired = typeof this.constructor.checkRequired == 'function' ?
+  const _checkRequired = typeof this.constructor.checkRequired === 'function' ?
     this.constructor.checkRequired() :
     Decimal128.checkRequired();
 

package/lib/schema/documentarray.js

@@ -11,7 +11,6 @@ const SchemaDocumentArrayOptions =
   require('../options/SchemaDocumentArrayOptions');
 const SchemaType = require('../schematype');
 const discriminator = require('../helpers/model/discriminator');
-const get = require('../helpers/get');
 const handleIdOption = require('../helpers/schema/handleIdOption');
 const util = require('util');
 const utils = require('../utils');
@@ -68,7 +67,9 @@ function DocumentArrayPath(key, schema, options, schemaOptions) {
 
   const parentSchemaType = this;
   this.$embeddedSchemaType = new SchemaType(key + '.$', {
-    required: get(this, 'schemaOptions.required', false)
+    required: this &&
+      this.schemaOptions &&
+      this.schemaOptions.required || false
   });
   this.$embeddedSchemaType.cast = function(value, doc, init) {
     return parentSchemaType.cast(value, doc, init)[0];
@@ -173,7 +174,7 @@ DocumentArrayPath.prototype.discriminator = function(name, schema, options) {
 
   options = options || {};
   const tiedValue = utils.isPOJO(options) ? options.value : options;
-  const clone = get(options, 'clone', true);
+  const clone = typeof options.clone === 'boolean' ? options.clone : true;
 
   if (schema.instanceOfSchema && clone) {
     schema = schema.clone();
@@ -228,7 +229,7 @@ DocumentArrayPath.prototype.doValidate = function(array, fn, scope, options) {
     if (options && options.updateValidator) {
       return fn();
     }
-    if (!array.isMongooseDocumentArray) {
+    if (!utils.isMongooseDocumentArray(array)) {
       array = new MongooseDocumentArray(array, _this.path, scope);
     }
 
@@ -398,12 +399,9 @@ DocumentArrayPath.prototype.cast = function(value, doc, init, prev, options) {
     return this.cast([value], doc, init, prev, options);
   }
 
-  if (!(value && value.isMongooseDocumentArray) &&
-      !options.skipDocumentArrayCast) {
-    value = new MongooseDocumentArray(value, this.path, doc);
-  } else if (value && value.isMongooseDocumentArray) {
-    // We need to create a new array, otherwise change tracking will
-    // update the old doc (gh-4449)
+  // We need to create a new array, otherwise change tracking will
+  // update the old doc (gh-4449)
+  if (!options.skipDocumentArrayCast || utils.isMongooseDocumentArray(value)) {
     value = new MongooseDocumentArray(value, this.path, doc);
   }
 
@@ -415,7 +413,7 @@ DocumentArrayPath.prototype.cast = function(value, doc, init, prev, options) {
     value[arrayPathSymbol] = this.path + '.' + options.arrayPathIndex;
   }
 
-  const rawArray = value.isMongooseDocumentArrayProxy ? value.__array : value;
+  const rawArray = utils.isMongooseDocumentArray(value) ? value.__array : value;
 
   const len = rawArray.length;
   const initDocumentOptions = { skipId: true, willInit: true };

package/lib/schema/number.js

@@ -170,7 +170,7 @@ SchemaNumber.prototype.checkRequired = function checkRequired(value, doc) {
 
   // `require('util').inherits()` does **not** copy static properties, and
   // plugins like mongoose-float use `inherits()` for pre-ES6.
-  const _checkRequired = typeof this.constructor.checkRequired == 'function' ?
+  const _checkRequired = typeof this.constructor.checkRequired === 'function' ?
     this.constructor.checkRequired() :
     SchemaNumber.checkRequired();
 

package/lib/schema/objectid.js

@@ -204,7 +204,7 @@ ObjectId.prototype.checkRequired = function checkRequired(value, doc) {
 
   // `require('util').inherits()` does **not** copy static properties, and
   // plugins like mongoose-float use `inherits()` for pre-ES6.
-  const _checkRequired = typeof this.constructor.checkRequired == 'function' ?
+  const _checkRequired = typeof this.constructor.checkRequired === 'function' ?
     this.constructor.checkRequired() :
     ObjectId.checkRequired();
 
@@ -281,7 +281,7 @@ function resetId(v) {
 
   if (this instanceof Document) {
     if (v === void 0) {
-      const _v = new oid;
+      const _v = new oid();
       this.$__._id = _v;
       return _v;
     }

package/lib/schema/string.js

@@ -253,7 +253,7 @@ SchemaString.prototype.enum = function() {
 };
 
 /**
- * Adds a lowercase [setter](http://mongoosejs.com/docs/api.html#schematype_SchemaType-set).
+ * Adds a lowercase [setter](https://mongoosejs.com/docs/api.html#schematype_SchemaType-set).
  *
  * ####Example:
  *
@@ -291,7 +291,7 @@ SchemaString.prototype.lowercase = function(shouldApply) {
 };
 
 /**
- * Adds an uppercase [setter](http://mongoosejs.com/docs/api.html#schematype_SchemaType-set).
+ * Adds an uppercase [setter](https://mongoosejs.com/docs/api.html#schematype_SchemaType-set).
  *
  * ####Example:
  *
@@ -327,7 +327,7 @@ SchemaString.prototype.uppercase = function(shouldApply) {
 };
 
 /**
- * Adds a trim [setter](http://mongoosejs.com/docs/api.html#schematype_SchemaType-set).
+ * Adds a trim [setter](https://mongoosejs.com/docs/api.html#schematype_SchemaType-set).
  *
  * The string value will be [trimmed](https://masteringjs.io/tutorials/fundamentals/trim-string) when set.
  *
@@ -566,7 +566,7 @@ SchemaString.prototype.checkRequired = function checkRequired(value, doc) {
 
   // `require('util').inherits()` does **not** copy static properties, and
   // plugins like mongoose-float use `inherits()` for pre-ES6.
-  const _checkRequired = typeof this.constructor.checkRequired == 'function' ?
+  const _checkRequired = typeof this.constructor.checkRequired === 'function' ?
     this.constructor.checkRequired() :
     SchemaString.checkRequired();
 

package/lib/schema.js

@@ -75,6 +75,7 @@ let id = 0;
  * - [selectPopulatedPaths](/docs/guide.html#selectPopulatedPaths): boolean - defaults to `true`
  * - [skipVersioning](/docs/guide.html#skipVersioning): object - paths to exclude from versioning
  * - [timestamps](/docs/guide.html#timestamps): object or boolean - defaults to `false`. If true, Mongoose adds `createdAt` and `updatedAt` properties to your schema and manages those properties for you.
+ * - [pluginTags](/docs/guide.html#pluginTags): array of strings - defaults to `undefined`. If set and plugin called with `tags` option, will only apply that plugin to schemas with a matching tag.
  *
  * ####Options for Nested Schemas:
  * - `excludeIndexes`: bool - defaults to `false`. If `true`, skip building indexes on this schema's paths.
@@ -85,7 +86,7 @@ let id = 0;
  *
  * @param {Object|Schema|Array} [definition] Can be one of: object describing schema paths, or schema to copy, or array of objects and schemas
  * @param {Object} [options]
- * @inherits NodeJS EventEmitter http://nodejs.org/api/events.html#events_class_events_eventemitter
+ * @inherits NodeJS EventEmitter https://nodejs.org/api/events.html#events_class_events_eventemitter
  * @event `init`: Emitted after the schema is compiled into a `Model`.
  * @api public
  */
@@ -424,7 +425,7 @@ Schema.prototype.pick = function(paths, options) {
 
 Schema.prototype.defaultOptions = function(options) {
   this._userProvidedOptions = options == null ? {} : utils.clone(options);
-  const baseOptions = get(this, 'base.options', {});
+  const baseOptions = this.base && this.base.options || {};
 
   const strict = 'strict' in baseOptions ? baseOptions.strict : true;
   options = utils.options({
@@ -518,7 +519,7 @@ Schema.prototype.add = function add(obj, prefix) {
     if (key === '_id' && val === false) {
       continue;
     }
-    if (val instanceof VirtualType || get(val, 'constructor.name', null) === 'VirtualType') {
+    if (val instanceof VirtualType || (val.constructor && val.constructor.name || null) === 'VirtualType') {
       this.virtual(val);
       continue;
     }
@@ -1035,7 +1036,7 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
       if (!MongooseTypes.hasOwnProperty(name)) {
         throw new TypeError('Invalid schema configuration: ' +
           `\`${name}\` is not a valid type within the array \`${path}\`.` +
-          'See http://bit.ly/mongoose-schematypes for a list of valid schema types.');
+          'See https://bit.ly/mongoose-schematypes for a list of valid schema types.');
       }
     }
 
@@ -1075,7 +1076,7 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
   if (MongooseTypes[name] == null) {
     throw new TypeError(`Invalid schema configuration: \`${name}\` is not ` +
       `a valid type at path \`${path}\`. See ` +
-      'http://bit.ly/mongoose-schematypes for a list of valid schema types.');
+      'https://bit.ly/mongoose-schematypes for a list of valid schema types.');
   }
 
   const schemaType = new MongooseTypes[name](path, obj);
@@ -1470,8 +1471,8 @@ Schema.prototype.pre = function(name) {
  * @param {Boolean} [options.document] If `name` is a hook for both document and query middleware, set to `true` to run on document middleware.
  * @param {Boolean} [options.query] If `name` is a hook for both document and query middleware, set to `true` to run on query middleware.
  * @param {Function} fn callback
- * @see middleware http://mongoosejs.com/docs/middleware.html
- * @see kareem http://npmjs.org/package/kareem
+ * @see middleware https://mongoosejs.com/docs/middleware.html
+ * @see kareem https://npmjs.org/package/kareem
  * @api public
  */
 
@@ -1618,7 +1619,7 @@ Schema.prototype.static = function(name, fn) {
  *     schema.index({ first: 1, last: -1 })
  *
  * @param {Object} fields
- * @param {Object} [options] Options to pass to [MongoDB driver's `createIndex()` function](http://mongodb.github.io/node-mongodb-native/2.0/api/Collection.html#createIndex)
+ * @param {Object} [options] Options to pass to [MongoDB driver's `createIndex()` function](https://mongodb.github.io/node-mongodb-native/2.0/api/Collection.html#createIndex)
  * @param {String | number} [options.expires=null] Mongoose-specific syntactic sugar, uses [ms](https://www.npmjs.com/package/ms) to convert `expires` option into seconds for the `expireAfterSeconds` in the above link.
  * @api public
  */

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;
@@ -1283,6 +1327,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 +1360,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 +1368,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 +1413,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 +1632,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 {