mongoose 6.2.0 → 6.2.1

package/lib/aggregate.js

@@ -39,7 +39,7 @@ const readConcern = Query.prototype.readConcern;
  * ```javascript
  *   new Aggregate([{ $match: { _id: '00000000000000000000000a' } }]);
  *   // Do this instead to cast to an ObjectId
- *   new Aggregate([{ $match: { _id: mongoose.Types.ObjectId('00000000000000000000000a') } }]);
+ *   new Aggregate([{ $match: { _id: new mongoose.Types.ObjectId('00000000000000000000000a') } }]);
  * ```
  *
  * @see MongoDB http://docs.mongodb.org/manual/applications/aggregation/

package/lib/document.js

@@ -90,7 +90,7 @@ function Document(obj, fields, skipId, options) {
     options = arguments[4] || {};
   }
 
-  this.$__ = new InternalCache;
+  this.$__ = new InternalCache();
   this.$isNew = 'isNew' in options ? options.isNew : true;
 
   if ('priorDoc' in options) {
@@ -479,7 +479,7 @@ function $__applyDefaults(doc, fields, exclude, hasIncludedChildren, isBeforeSet
           break;
         }
       } else if (exclude === false && fields && !included) {
-        if (curPath in fields) {
+        if (curPath in fields || type.$isSingleNested && hasIncludedChildren[curPath]) {
           included = true;
         } else if (!hasIncludedChildren[curPath]) {
           break;
@@ -795,11 +795,12 @@ function init(self, obj, doc, opts, prefix) {
 
   const keys = Object.keys(obj);
   const len = keys.length;
-  let schema;
+  let schemaType;
   let path;
   let i;
   let index = 0;
   const strict = self.$__.strictMode;
+  const docSchema = self.$__schema;
 
   while (index < len) {
     _init(index++);
@@ -808,25 +809,27 @@ function init(self, obj, doc, opts, prefix) {
   function _init(index) {
     i = keys[index];
     path = prefix + i;
-    schema = self.$__schema.path(path);
+    schemaType = docSchema.path(path);
 
     // Should still work if not a model-level discriminator, but should not be
     // necessary. This is *only* to catch the case where we queried using the
     // base model and the discriminated model has a projection
-    if (self.$__schema.$isRootDiscriminator && !self.$__isSelected(path)) {
+    if (docSchema.$isRootDiscriminator && !self.$__isSelected(path)) {
       return;
     }
 
-    if (!schema && utils.isPOJO(obj[i])) {
+    if (!schemaType && utils.isPOJO(obj[i])) {
       // assume nested object
       if (!doc[i]) {
         doc[i] = {};
+        if (!strict && !(i in docSchema.tree) && !(i in docSchema.methods) && !(i in docSchema.virtuals)) {
+          self[i] = doc[i];
+        }
       }
       init(self, obj[i], doc[i], opts, path + '.');
-    } else if (!schema) {
+    } else if (!schemaType) {
       doc[i] = obj[i];
-      if (!strict && !prefix) {
-        // Set top-level properties that aren't in the schema if strict is false
+      if (!strict) {
         self[i] = obj[i];
       }
     } else {
@@ -835,13 +838,13 @@ function init(self, obj, doc, opts, prefix) {
         delete doc[i];
       }
       if (obj[i] === null) {
-        doc[i] = schema._castNullish(null);
+        doc[i] = schemaType._castNullish(null);
       } else if (obj[i] !== undefined) {
         const wasPopulated = obj[i].$__ == null ? null : obj[i].$__.wasPopulated;
 
-        if (schema && !wasPopulated) {
+        if (schemaType && !wasPopulated) {
           try {
-            doc[i] = schema.cast(obj[i], self, true);
+            doc[i] = schemaType.cast(obj[i], self, true);
           } catch (e) {
             self.invalidate(e.path, new ValidatorError({
               path: e.path,
@@ -1135,7 +1138,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
       // them to ensure we keep the user's key order.
       if (type === true &&
           !prefix &&
-          path[key] != null &&
+          valForKey != null &&
           pathtype === 'nested' &&
           this._doc[key] != null) {
         delete this._doc[key];
@@ -1313,7 +1316,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
   let curPath = '';
   for (i = 0; i < parts.length - 1; ++i) {
     cur = cur[parts[i]];
-    curPath += (curPath.length > 0 ? '.' : '') + parts[i];
+    curPath += (curPath.length !== 0 ? '.' : '') + parts[i];
     if (!cur) {
       this.$set(curPath, {});
       // Hack re: gh-5800. If nested field is not selected, it probably exists
@@ -1336,7 +1339,8 @@ Document.prototype.$set = function $set(path, val, type, options) {
   if (parts.length <= 1) {
     pathToMark = path;
   } else {
-    for (i = 0; i < parts.length; ++i) {
+    const len = parts.length;
+    for (i = 0; i < len; ++i) {
       const subpath = parts.slice(0, i + 1).join('.');
       if (this.$get(subpath, null, { getters: false }) === null) {
         pathToMark = subpath;
@@ -1361,7 +1365,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
     _markValidSubpaths(this, path);
   }
 
-  if (schema.$isSingleNested && val != null && merge) {
+  if (val != null && merge && schema.$isSingleNested) {
     if (val instanceof Document) {
       val = val.toObject({ virtuals: false, transform: false });
     }
@@ -1431,9 +1435,10 @@ Document.prototype.$set = function $set(path, val, type, options) {
       val = schema.applySetters(val, this, false, priorVal);
     }
 
-    if (schema.$isMongooseDocumentArray &&
-        Array.isArray(val) &&
-        val.length > 0 &&
+    if (Array.isArray(val) &&
+        !Array.isArray(schema) &&
+        schema.$isMongooseDocumentArray &&
+        val.length !== 0 &&
         val[0] != null &&
         val[0].$__ != null &&
         val[0].$__.populated != null) {
@@ -1459,7 +1464,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
       delete this.$__.populated[path];
     }
 
-    if (schema.$isSingleNested && val != null) {
+    if (val != null && schema.$isSingleNested) {
       _checkImmutableSubpaths(val, schema, priorVal);
     }
 
@@ -1652,11 +1657,11 @@ Document.prototype.$__set = function(pathToMark, path, options, constructing, pa
 
     // handle directly setting arrays (gh-1126)
     MongooseArray || (MongooseArray = require('./types/array'));
-    if (val && val.isMongooseArray) {
+    if (val && utils.isMongooseArray(val)) {
       val._registerAtomic('$set', val);
 
       // Update embedded document parent references (gh-5189)
-      if (val.isMongooseDocumentArray) {
+      if (utils.isMongooseDocumentArray(val)) {
         val.forEach(function(item) {
           item && item.__parentArray && (item.__parentArray = val);
         });
@@ -1670,10 +1675,10 @@ Document.prototype.$__set = function(pathToMark, path, options, constructing, pa
         }
       });
     }
-  } else if (Array.isArray(val) && val.isMongooseArray && Array.isArray(priorVal) && priorVal.isMongooseArray) {
+  } else if (Array.isArray(val) && Array.isArray(priorVal) && utils.isMongooseArray(val) && utils.isMongooseArray(priorVal)) {
     val[arrayAtomicsSymbol] = priorVal[arrayAtomicsSymbol];
     val[arrayAtomicsBackupSymbol] = priorVal[arrayAtomicsBackupSymbol];
-    if (val.isMongooseDocumentArray) {
+    if (utils.isMongooseDocumentArray(val)) {
       val.forEach(doc => { doc.isNew = false; });
     }
   }
@@ -1702,7 +1707,7 @@ Document.prototype.$__set = function(pathToMark, path, options, constructing, pa
         obj = obj[parts[i]];
       } else if (obj[parts[i]] && obj[parts[i]] instanceof Embedded) {
         obj = obj[parts[i]];
-      } else if (obj[parts[i]] && obj[parts[i]].$isSingleNested) {
+      } else if (obj[parts[i]] && !Array.isArray(obj[parts[i]]) && obj[parts[i]].$isSingleNested) {
         obj = obj[parts[i]];
       } else if (obj[parts[i]] && Array.isArray(obj[parts[i]])) {
         obj = obj[parts[i]];
@@ -1963,7 +1968,7 @@ Document.prototype.$isEmpty = function(path) {
     transform: false
   };
 
-  if (arguments.length > 0) {
+  if (arguments.length !== 0) {
     const v = this.$get(path);
     if (v == null) {
       return true;
@@ -2006,51 +2011,60 @@ function _isEmpty(v) {
 
 Document.prototype.modifiedPaths = function(options) {
   options = options || {};
+
   const directModifiedPaths = Object.keys(this.$__.activePaths.states.modify);
-  const _this = this;
-  return directModifiedPaths.reduce(function(list, path) {
-    const parts = path.split('.');
-    list = list.concat(parts.reduce(function(chains, part, i) {
-      return chains.concat(parts.slice(0, i).concat(part).join('.'));
-    }, []).filter(function(chain) {
-      return (list.indexOf(chain) === -1);
-    }));
+  const result = new Set();
+
+  let i = 0;
+  let j = 0;
+  const len = directModifiedPaths.length;
+
+  for (i = 0; i < len; ++i) {
+    const path = directModifiedPaths[i];
+    const parts = parentPaths(path);
+    const pLen = parts.length;
+
+    for (j = 0; j < pLen; ++j) {
+      result.add(parts[j]);
+    }
 
     if (!options.includeChildren) {
-      return list;
+      continue;
     }
 
-    let cur = _this.$get(path);
-    if (cur != null && typeof cur === 'object') {
+    let ii = 0;
+    let cur = this.$get(path);
+    if (typeof cur === 'object' && cur !== null) {
       if (cur._doc) {
         cur = cur._doc;
       }
+      const len = cur.length;
       if (Array.isArray(cur)) {
-        const len = cur.length;
-        for (let i = 0; i < len; ++i) {
-          if (list.indexOf(path + '.' + i) === -1) {
-            list.push(path + '.' + i);
-            if (cur[i] != null && cur[i].$__) {
-              const modified = cur[i].modifiedPaths();
-              for (const childPath of modified) {
-                list.push(path + '.' + i + '.' + childPath);
+        for (ii = 0; ii < len; ++ii) {
+          const subPath = path + '.' + ii;
+          if (!result.has(subPath)) {
+            result.add(subPath);
+            if (cur[ii] != null && cur[ii].$__) {
+              const modified = cur[ii].modifiedPaths();
+              let iii = 0;
+              const iiiLen = modified.length;
+              for (iii = 0; iii < iiiLen; ++iii) {
+                result.add(subPath + '.' + modified[iii]);
               }
             }
           }
         }
       } else {
-        Object.keys(cur).
-          filter(function(key) {
-            return list.indexOf(path + '.' + key) === -1;
-          }).
-          forEach(function(key) {
-            list.push(path + '.' + key);
-          });
+        const keys = Object.keys(cur);
+        let ii = 0;
+        const len = keys.length;
+        for (ii = 0; ii < len; ++ii) {
+          result.add(path + '.' + keys[ii]);
+        }
       }
     }
-
-    return list;
-  }, []);
+  }
+  return Array.from(result);
 };
 
 Document.prototype[documentModifiedPaths] = Document.prototype.modifiedPaths;
@@ -2448,7 +2462,12 @@ Document.prototype.$validate = Document.prototype.validate;
  */
 
 function _evaluateRequiredFunctions(doc) {
-  Object.keys(doc.$__.activePaths.states.require).forEach(path => {
+  const requiredFields = Object.keys(doc.$__.activePaths.states.require);
+  let i = 0;
+  const len = requiredFields.length;
+  for (i = 0; i < len; ++i) {
+    const path = requiredFields[i];
+
     const p = doc.$__schema.path(path);
 
     if (p != null && typeof p.originalRequiredValue === 'function') {
@@ -2459,7 +2478,7 @@ function _evaluateRequiredFunctions(doc) {
         doc.invalidate(path, err);
       }
     }
-  });
+  }
 }
 
 /*!
@@ -2520,7 +2539,7 @@ function _getPathsToValidate(doc) {
         // To avoid potential performance issues, skip doc arrays whose children
         // are not required. `getPositionalPathType()` may be slow, so avoid
         // it unless we have a case of #6364
-        (_pathType.$isMongooseDocumentArray && !get(_pathType, 'schemaOptions.required'))) {
+        (!Array.isArray(_pathType) && _pathType.$isMongooseDocumentArray && !get(_pathType, 'schemaOptions.required'))) {
       continue;
     }
 
@@ -3112,7 +3131,7 @@ Document.prototype.$__reset = function reset() {
       return _this.$__getValue(i);
     })
     .filter(function(val) {
-      return val && val instanceof Array && val.isMongooseDocumentArray && val.length;
+      return val && val instanceof Array && utils.isMongooseDocumentArray(val) && val.length;
     })
     .forEach(function(array) {
       let i = array.length;
@@ -3135,7 +3154,7 @@ Document.prototype.$__reset = function reset() {
       return _this.$__getValue(i);
     }).
     filter(function(val) {
-      return val && val.$isSingleNested;
+      return val && !Array.isArray(val) && val.$isSingleNested;
     }).
     forEach(function(doc) {
       doc.$__reset();
@@ -3315,7 +3334,7 @@ Document.prototype.$__getArrayPathsToValidate = function() {
       return this.$__getValue(i);
     }.bind(this))
     .filter(function(val) {
-      return val && val instanceof Array && val.isMongooseDocumentArray && val.length;
+      return val && val instanceof Array && utils.isMongooseDocumentArray(val) && val.length;
     }).reduce(function(seed, array) {
       return seed.concat(array);
     }, [])
@@ -3357,12 +3376,12 @@ Document.prototype.$getAllSubdocs = function() {
       seed = Array.from(val.keys()).reduce(function(seed, path) {
         return docReducer(val.get(path), seed, null);
       }, seed);
-    } else if (val && val.$isSingleNested) {
+    } else if (val && !Array.isArray(val) && val.$isSingleNested) {
       seed = Object.keys(val._doc).reduce(function(seed, path) {
         return docReducer(val._doc, seed, path);
       }, seed);
       seed.push(val);
-    } else if (val && val.isMongooseDocumentArray) {
+    } else if (val && utils.isMongooseDocumentArray(val)) {
       val.forEach(function _docReduce(doc) {
         if (!doc || !doc._doc) {
           return;
@@ -4139,7 +4158,7 @@ Document.prototype.populate = function populate() {
   const args = [...arguments];
   let fn;
 
-  if (args.length > 0) {
+  if (args.length !== 0) {
     if (typeof args[args.length - 1] === 'function') {
       fn = args.pop();
     }

package/lib/helpers/clone.js

@@ -1,7 +1,5 @@
 'use strict';
 
-
-const cloneRegExp = require('regexp-clone');
 const Decimal = require('../types/decimal128');
 const ObjectId = require('../types/objectid');
 const specialProperties = require('./specialProperties');
@@ -34,7 +32,7 @@ function clone(obj, options, isArrayChild) {
   }
 
   if (Array.isArray(obj)) {
-    return cloneArray(obj, options);
+    return cloneArray(utils.isMongooseArray(obj) ? obj.__array : obj, options);
   }
 
   if (isMongooseObject(obj)) {
@@ -54,12 +52,14 @@ function clone(obj, options, isArrayChild) {
     return obj.toObject(options);
   }
 
-  if (obj.constructor) {
-    switch (getFunctionName(obj.constructor)) {
+  const objConstructor = obj.constructor;
+
+  if (objConstructor) {
+    switch (getFunctionName(objConstructor)) {
       case 'Object':
         return cloneObject(obj, options, isArrayChild);
       case 'Date':
-        return new obj.constructor(+obj);
+        return new objConstructor(+obj);
       case 'RegExp':
         return cloneRegExp(obj);
       default:
@@ -79,12 +79,12 @@ function clone(obj, options, isArrayChild) {
     return Decimal.fromString(obj.toString());
   }
 
-  if (!obj.constructor && isObject(obj)) {
-    // object created with Object.create(null)
+  // object created with Object.create(null)
+  if (!objConstructor && isObject(obj)) {
     return cloneObject(obj, options, isArrayChild);
   }
 
-  if (obj[symbols.schemaTypeSymbol]) {
+  if (typeof obj === 'object' && obj[symbols.schemaTypeSymbol]) {
     return obj.clone();
   }
 
@@ -95,7 +95,7 @@ function clone(obj, options, isArrayChild) {
     return obj;
   }
 
-  if (obj.valueOf != null) {
+  if (typeof obj.valueOf === 'function') {
     return obj.valueOf();
   }
 
@@ -112,25 +112,28 @@ function cloneObject(obj, options, isArrayChild) {
   const ret = {};
   let hasKeys;
 
-  if (obj[trustedSymbol]) {
+  if (trustedSymbol in obj) {
     ret[trustedSymbol] = obj[trustedSymbol];
   }
 
-  for (const k of Object.keys(obj)) {
-    if (specialProperties.has(k)) {
+  let i = 0;
+  let key = '';
+  const keys = Object.keys(obj);
+  const len = keys.length;
+
+  for (i = 0; i < len; ++i) {
+    if (specialProperties.has(key = keys[i])) {
       continue;
     }
 
     // Don't pass `isArrayChild` down
-    const val = clone(obj[k], options);
-
-    if (!minimize || (typeof val !== 'undefined')) {
-      if (minimize === false && typeof val === 'undefined') {
-        delete ret[k];
-      } else {
-        hasKeys || (hasKeys = true);
-        ret[k] = val;
-      }
+    const val = clone(obj[key], options, false);
+
+    if (minimize === false && typeof val === 'undefined') {
+      delete ret[key];
+    } else if (minimize !== true || (typeof val !== 'undefined')) {
+      hasKeys || (hasKeys = true);
+      ret[key] = val;
     }
   }
 
@@ -138,11 +141,21 @@ function cloneObject(obj, options, isArrayChild) {
 }
 
 function cloneArray(arr, options) {
-  const ret = [];
-
-  for (const item of arr) {
-    ret.push(clone(item, options, true));
+  let i = 0;
+  const len = arr.length;
+  const ret = new Array(len);
+  for (i = 0; i < len; ++i) {
+    ret[i] = clone(arr[i], options, true);
   }
 
   return ret;
-}
+}
+
+function cloneRegExp(regexp) {
+  const ret = new RegExp(regexp.source, regexp.flags);
+
+  if (ret.lastIndex !== regexp.lastIndex) {
+    ret.lastIndex = regexp.lastIndex;
+  }
+  return ret;
+}

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/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,7 +694,7 @@ 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.substring(cur.length + 1);
       const discriminatorKey = schematype.caster.schema.options.discriminatorKey;