mongoose 6.3.2 → 6.3.5

package/lib/cast/objectid.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const isBsonType = require('../helpers/isBsonType');
 const ObjectId = require('../driver').get().ObjectId;
 
 module.exports = function castObjectId(value) {
@@ -7,12 +8,12 @@ module.exports = function castObjectId(value) {
     return value;
   }
 
-  if (value instanceof ObjectId) {
+  if (isBsonType(value, 'ObjectID')) {
     return value;
   }
 
   if (value._id) {
-    if (value._id instanceof ObjectId) {
+    if (isBsonType(value._id, 'ObjectID')) {
       return value._id;
     }
     if (value._id.toString instanceof Function) {

package/lib/connection.js

@@ -548,7 +548,7 @@ Connection.prototype.dropDatabase = _wrapConnHelper(function dropDatabase(cb) {
   // If `dropDatabase()` is called, this model's collection will not be
   // init-ed. It is sufficiently common to call `dropDatabase()` after
   // `mongoose.connect()` but before creating models that we want to
-  // support this. See gh-6967
+  // support this. See gh-6796
   for (const name of Object.keys(this.models)) {
     delete this.models[name].$init;
   }

package/lib/document.js

@@ -53,6 +53,7 @@ const populateModelSymbol = require('./helpers/symbols').populateModelSymbol;
 const scopeSymbol = require('./helpers/symbols').scopeSymbol;
 const schemaMixedSymbol = require('./schema/symbols').schemaMixedSymbol;
 const parentPaths = require('./helpers/path/parentPaths');
+
 let DocumentArray;
 let MongooseArray;
 let Embedded;
@@ -1322,6 +1323,10 @@ Document.prototype.$set = function $set(path, val, type, options) {
 
   if (!schema) {
     this.$__set(pathToMark, path, options, constructing, parts, schema, val, priorVal);
+
+    if (pathType === 'nested' && val == null) {
+      cleanModifiedSubpaths(this, path);
+    }
     return this;
   }
 
@@ -1373,7 +1378,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
     })();
 
     let didPopulate = false;
-    if (refMatches && val instanceof Document) {
+    if (refMatches && val instanceof Document && (!val.$__.wasPopulated || utils.deepEqual(val.$__.wasPopulated.value, val._id))) {
       const unpopulatedValue = (schema && schema.$isSingleNested) ? schema.cast(val, this) : val._id;
       this.$populated(path, unpopulatedValue, { [populateModelSymbol]: val.constructor });
       val.$__.wasPopulated = { value: unpopulatedValue };
@@ -1828,7 +1833,6 @@ Document.prototype.$__path = function(path) {
  */
 
 Document.prototype.markModified = function(path, scope) {
-  // console.log('MarkModified', path, new Error().stack);
   this.$__.activePaths.modify(path);
   if (scope != null && !this.$isSubdocument) {
     this.$__.pathsToScopes = this.$__pathsToScopes || {};
@@ -2520,9 +2524,11 @@ function _getPathsToValidate(doc) {
   // the children as well
   for (const path of paths) {
     const _pathType = doc.$__schema.path(path);
+    if (!_pathType) {
+      continue;
+    }
 
-    if (!_pathType ||
-        !_pathType.$isMongooseArray ||
+    if (!_pathType.$isMongooseArray ||
         // 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
@@ -2534,8 +2540,7 @@ function _getPathsToValidate(doc) {
 
     // gh-11380: optimization. If the array isn't a document array and there's no validators
     // on the array type, there's no need to run validation on the individual array elements.
-    if (_pathType &&
-        _pathType.$isMongooseArray &&
+    if (_pathType.$isMongooseArray &&
         !_pathType.$isMongooseDocumentArray && // Skip document arrays...
         !_pathType.$embeddedSchemaType.$isMongooseArray && // and arrays of arrays
         _pathType.$embeddedSchemaType.validators.length === 0) {
@@ -3127,48 +3132,48 @@ Document.prototype.$isValid = function(path) {
 
 Document.prototype.$__reset = function reset() {
   let _this = this;
-  DocumentArray || (DocumentArray = require('./types/DocumentArray'));
 
-  this.$__.activePaths
-    .map('init', 'modify', function(i) {
-      return _this.$__getValue(i);
-    })
-    .filter(function(val) {
-      return val && Array.isArray(val) && utils.isMongooseDocumentArray(val) && val.length;
-    })
-    .forEach(function(array) {
-      let i = array.length;
-      while (i--) {
-        const doc = array[i];
-        if (!doc) {
-          continue;
+  // Skip for subdocuments
+  const subdocs = this.$parent() === this ? this.$getAllSubdocs() : [];
+  const resetArrays = new Set();
+  for (const subdoc of subdocs) {
+    const fullPathWithIndexes = subdoc.$__fullPathWithIndexes();
+    if (this.isModified(fullPathWithIndexes) || isParentInit(fullPathWithIndexes)) {
+      subdoc.$__reset();
+      if (subdoc.$isDocumentArrayElement) {
+        if (!resetArrays.has(subdoc.parentArray())) {
+          const array = subdoc.parentArray();
+          // Mark path to array as init for gh-6818
+          this.$__.activePaths.init(fullPathWithIndexes.replace(/\.\d+$/, '').slice(-subdoc.$basePath - 1));
+          array[arrayAtomicsBackupSymbol] = array[arrayAtomicsSymbol];
+          array[arrayAtomicsSymbol] = {};
+
+          resetArrays.add(array);
+        }
+      } else {
+        if (subdoc.$parent() === this) {
+          this.$__.activePaths.init(subdoc.$basePath);
+        } else if (subdoc.$parent() != null && subdoc.$parent().$isSubdocument) {
+          // If map path underneath subdocument, may end up with a case where
+          // map path is modified but parent still needs to be reset. See gh-10295
+          subdoc.$parent().$__reset();
         }
-        doc.$__reset();
       }
+    }
+  }
 
-      _this.$__.activePaths.init(array.$path());
-
-      array[arrayAtomicsBackupSymbol] = array[arrayAtomicsSymbol];
-      array[arrayAtomicsSymbol] = {};
-    });
-
-  this.$__.activePaths.
-    map('init', 'modify', function(i) {
-      return _this.$__getValue(i);
-    }).
-    filter(function(val) {
-      return val && !Array.isArray(val) && val.$isSingleNested;
-    }).
-    forEach(function(doc) {
-      doc.$__reset();
-      if (doc.$parent() === _this) {
-        _this.$__.activePaths.init(doc.$basePath);
-      } else if (doc.$parent() != null && doc.$parent().$isSubdocument) {
-        // If map path underneath subdocument, may end up with a case where
-        // map path is modified but parent still needs to be reset. See gh-10295
-        doc.$parent().$__reset();
+  function isParentInit(path) {
+    path = path.indexOf('.') === -1 ? [path] : path.split('.');
+    let cur = '';
+    for (let i = 0; i < path.length; ++i) {
+      cur += (cur.length ? '.' : '') + path[i];
+      if (_this.$__.activePaths[cur] === 'init') {
+        return true;
       }
-    });
+    }
+
+    return false;
+  }
 
   // clear atomics
   this.$__dirty().forEach(function(dirt) {
@@ -3459,9 +3464,9 @@ Document.prototype.$toObject = function(options, json) {
 
   const path = json ? 'toJSON' : 'toObject';
   const baseOptions = this.constructor &&
-  this.constructor.base &&
-  this.constructor.base.options &&
-  get(this.constructor.base.options, path) || {};
+    this.constructor.base &&
+    this.constructor.base.options &&
+    get(this.constructor.base.options, path) || {};
   const schemaOptions = this.$__schema && this.$__schema.options || {};
   // merge base default options with Schema's set default options if available.
   // `clone` is necessary here because `utils.options` directly modifies the second input.
@@ -3498,7 +3503,8 @@ Document.prototype.$toObject = function(options, json) {
     _isNested: true,
     json: json,
     minimize: _minimize,
-    flattenMaps: flattenMaps
+    flattenMaps: flattenMaps,
+    _seen: (options && options._seen) || new Map()
   });
 
   if (utils.hasUserDefinedProperty(options, 'getters')) {

package/lib/error/index.js

@@ -5,11 +5,11 @@
  * Mongoose-specific errors.
  *
  * #### Example:
- *     const Model = mongoose.model('Test', new Schema({ answer: Number }));
+ *     const Model = mongoose.model('Test', new mongoose.Schema({ answer: Number }));
  *     const doc = new Model({ answer: 'not a number' });
  *     const err = doc.validateSync();
  *
- *     err instanceof mongoose.Error; // true
+ *     err instanceof mongoose.Error.ValidationError; // true
  *
  * @constructor Error
  * @param {String} msg Error message

package/lib/helpers/clone.js

@@ -77,7 +77,7 @@ function clone(obj, options, isArrayChild) {
     }
   }
 
-  if (obj instanceof ObjectId) {
+  if (isBsonType(obj, 'ObjectID')) {
     return new ObjectId(obj.id);
   }
 
@@ -118,9 +118,16 @@ module.exports = clone;
 
 function cloneObject(obj, options, isArrayChild) {
   const minimize = options && options.minimize;
+  const omitUndefined = options && options.omitUndefined;
+  const seen = options && options._seen;
   const ret = {};
   let hasKeys;
 
+  if (seen && seen.has(obj)) {
+    return seen.get(obj);
+  } else if (seen) {
+    seen.set(obj, ret);
+  }
   if (trustedSymbol in obj) {
     ret[trustedSymbol] = obj[trustedSymbol];
   }
@@ -138,7 +145,7 @@ function cloneObject(obj, options, isArrayChild) {
     // Don't pass `isArrayChild` down
     const val = clone(obj[key], options, false);
 
-    if (minimize === false && typeof val === 'undefined') {
+    if ((minimize === false || omitUndefined) && typeof val === 'undefined') {
       delete ret[key];
     } else if (minimize !== true || (typeof val !== 'undefined')) {
       hasKeys || (hasKeys = true);

package/lib/helpers/common.js

@@ -5,8 +5,7 @@
  */
 
 const Binary = require('../driver').get().Binary;
-const Decimal128 = require('../types/decimal128');
-const ObjectId = require('../types/objectid');
+const isBsonType = require('./isBsonType');
 const isMongooseObject = require('./isMongooseObject');
 
 exports.flatten = flatten;
@@ -99,9 +98,9 @@ function shouldFlatten(val) {
   return val &&
     typeof val === 'object' &&
     !(val instanceof Date) &&
-    !(val instanceof ObjectId) &&
+    !isBsonType(val, 'ObjectID') &&
     (!Array.isArray(val) || val.length !== 0) &&
     !(val instanceof Buffer) &&
-    !(val instanceof Decimal128) &&
+    !isBsonType(val, 'Decimal128') &&
     !(val instanceof Binary);
 }

package/lib/helpers/discriminator/areDiscriminatorValuesEqual.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const ObjectId = require('../../types/objectid');
+const isBsonType = require('../isBsonType');
 
 module.exports = function areDiscriminatorValuesEqual(a, b) {
   if (typeof a === 'string' && typeof b === 'string') {
@@ -9,7 +9,7 @@ module.exports = function areDiscriminatorValuesEqual(a, b) {
   if (typeof a === 'number' && typeof b === 'number') {
     return a === b;
   }
-  if (a instanceof ObjectId && b instanceof ObjectId) {
+  if (isBsonType(a, 'ObjectID') && isBsonType(b, 'ObjectID')) {
     return a.toString() === b.toString();
   }
   return false;

package/lib/helpers/isBsonType.js

@@ -1,13 +1,15 @@
 'use strict';
 
-const get = require('./get');
-
 /*!
  * Get the bson type, if it exists
  */
 
 function isBsonType(obj, typename) {
-  return get(obj, '_bsontype', void 0) === typename;
+  return (
+    typeof obj === 'object' &&
+    obj !== null &&
+    obj._bsontype === typename
+  );
 }
 
 module.exports = isBsonType;

package/lib/helpers/model/castBulkWrite.js

@@ -27,6 +27,12 @@ module.exports = function castBulkWrite(originalModel, op, options) {
         doc.$session(options.session);
       }
       op['insertOne']['document'] = doc;
+
+      if (options.skipValidation || op['insertOne'].skipValidation) {
+        callback(null);
+        return;
+      }
+
       op['insertOne']['document'].$validate({ __noPromise: true }, function(error) {
         if (error) {
           return callback(error, null);
@@ -154,6 +160,12 @@ module.exports = function castBulkWrite(originalModel, op, options) {
       }
       op['replaceOne']['replacement'] = doc;
 
+      if (options.skipValidation || op['replaceOne'].skipValidation) {
+        op['replaceOne']['replacement'] = op['replaceOne']['replacement'].toBSON();
+        callback(null);
+        return;
+      }
+
       op['replaceOne']['replacement'].$validate({ __noPromise: true }, function(error) {
         if (error) {
           return callback(error, null);

package/lib/helpers/path/setDottedPath.js

@@ -1,14 +1,25 @@
 'use strict';
 
+const specialProperties = require('../specialProperties');
+
+
 module.exports = function setDottedPath(obj, path, val) {
   if (path.indexOf('.') === -1) {
+    if (specialProperties.has(path)) {
+      return;
+    }
+
     obj[path] = val;
     return;
   }
   const parts = path.split('.');
+
   const last = parts.pop();
   let cur = obj;
   for (const part of parts) {
+    if (specialProperties.has(part)) {
+      continue;
+    }
     if (cur[part] == null) {
       cur[part] = {};
     }
@@ -16,5 +27,7 @@ module.exports = function setDottedPath(obj, path, val) {
     cur = cur[part];
   }
 
-  cur[last] = val;
+  if (!specialProperties.has(last)) {
+    cur[last] = val;
+  }
 };

package/lib/helpers/query/cast$expr.js

@@ -4,7 +4,7 @@ const CastError = require('../../error/cast');
 const StrictModeError = require('../../error/strict');
 const castNumber = require('../../cast/number');
 
-const booleanComparison = new Set(['$and', '$or', '$not']);
+const booleanComparison = new Set(['$and', '$or']);
 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,
@@ -66,6 +66,7 @@ const dateOperators = new Set([
   '$isoWeek',
   '$millisecond'
 ]);
+const expressionOperator = new Set(['$not']);
 
 module.exports = function cast$expr(val, schema, strictQuery) {
   if (typeof val !== 'object' || val === null) {
@@ -106,6 +107,8 @@ function _castExpression(val, schema, strictQuery) {
       val[key] = castArithmetic(val[key], schema, strictQuery);
     } else if (arithmeticOperatorNumber.has(key)) {
       val[key] = castNumberOperator(val[key], schema, strictQuery);
+    } else if (expressionOperator.has(key)) {
+      val[key] = _castExpression(val[key], schema, strictQuery);
     }
   }
 

package/lib/helpers/topology/isAtlas.js

@@ -8,6 +8,19 @@ module.exports = function isAtlas(topologyDescription) {
   }
 
   const hostnames = Array.from(topologyDescription.servers.keys());
-  return hostnames.length > 0 &&
-    hostnames.every(host => host.endsWith('.mongodb.net:27017'));
+
+  if (hostnames.length === 0) {
+    return false;
+  }
+
+  for (let i = 0, il = hostnames.length; i < il; ++i) {
+    const url = new URL(hostnames[i]);
+    if (
+      url.hostname.endsWith('.mongodb.net') === false ||
+      url.port !== '27017'
+    ) {
+      return false;
+    }
+  }
+  return true;
 };

package/lib/index.js

@@ -34,6 +34,7 @@ const PromiseProvider = require('./promise_provider');
 const shardingPlugin = require('./plugins/sharding');
 const trusted = require('./helpers/query/trusted').trusted;
 const sanitizeFilter = require('./helpers/query/sanitizeFilter');
+const isBsonType = require('./helpers/isBsonType');
 
 const defaultMongooseSymbol = Symbol.for('mongoose:default');
 
@@ -995,8 +996,7 @@ Mongoose.prototype.isValidObjectId = function(v) {
  */
 
 Mongoose.prototype.isObjectIdOrHexString = function(v) {
-  const _mongoose = this instanceof Mongoose ? this : mongoose;
-  return v instanceof _mongoose.Types.ObjectId || (typeof v === 'string' && objectIdHexRegexp.test(v));
+  return isBsonType(v, 'ObjectID') || (typeof v === 'string' && objectIdHexRegexp.test(v));
 };
 
 /**

package/lib/model.js

@@ -768,6 +768,7 @@ Model.prototype.$__delta = function() {
         transform: false,
         virtuals: false,
         getters: false,
+        omitUndefined: true,
         _isNested: true
       });
       operand(this, where, delta, data, value);
@@ -1488,61 +1489,68 @@ Model.syncIndexes = function syncIndexes(options, callback) {
  * the result of this function would be the result of
  * Model.syncIndexes().
  *
- * @param {Object} options not used at all.
+ * @param {Object} [options]
  * @param {Function} callback optional callback
- * @returns {Promise} which containts an object, {toDrop, toCreate}, which
- * are indexes that would be dropped in mongodb and indexes that would be created in mongodb.
+ * @returns {Promise} which contains an object, {toDrop, toCreate}, which
+ * are indexes that would be dropped in MongoDB and indexes that would be created in MongoDB.
  */
 
 Model.diffIndexes = function diffIndexes(options, callback) {
+  if (typeof options === 'function') {
+    callback = options;
+    options = null;
+  }
   const toDrop = [];
   const toCreate = [];
   callback = this.$handleCallbackError(callback);
   return this.db.base._promiseOrCallback(callback, cb => {
     cb = this.$wrapCallback(cb);
-    this.listIndexes((err, indexes) => {
-      if (indexes === undefined) {
-        indexes = [];
+    this.listIndexes((err, dbIndexes) => {
+      if (dbIndexes === undefined) {
+        dbIndexes = [];
       }
-      const schemaIndexes = this.schema.indexes();
-      // Iterate through the indexes created in mongodb and
-      // compare against the indexes in the schema.
-      for (const index of indexes) {
+      dbIndexes = getRelatedDBIndexes(this, dbIndexes);
+      const schemaIndexes = getRelatedSchemaIndexes(this, this.schema.indexes());
+
+      for (const dbIndex of dbIndexes) {
         let found = false;
         // Never try to drop `_id` index, MongoDB server doesn't allow it
-        if (isDefaultIdIndex(index)) {
+        if (isDefaultIdIndex(dbIndex)) {
           continue;
         }
 
-        for (const schemaIndex of schemaIndexes) {
-          const key = schemaIndex[0];
-          const options = decorateDiscriminatorIndexOptions(this.schema, utils.clone(schemaIndex[1]));
-          if (isIndexEqual(key, options, index)) {
+        for (const [schemaIndexKeysObject, schemaIndexOptions] of schemaIndexes) {
+          const options = decorateDiscriminatorIndexOptions(this.schema, utils.clone(schemaIndexOptions));
+          applySchemaCollation(schemaIndexKeysObject, options, this.schema.options);
+
+          if (isIndexEqual(schemaIndexKeysObject, options, dbIndex)) {
             found = true;
           }
         }
 
         if (!found) {
-          toDrop.push(index.name);
+          toDrop.push(dbIndex.name);
         }
       }
       // Iterate through the indexes created on the schema and
       // compare against the indexes in mongodb.
-      for (const schemaIndex of schemaIndexes) {
-        let found = false;
-        const key = schemaIndex[0];
-        const options = decorateDiscriminatorIndexOptions(this.schema, utils.clone(schemaIndex[1]));
-        for (const index of indexes) {
-          if (isDefaultIdIndex(index)) {
-            continue;
+      if (!options || options.toCreate !== false) {
+        for (const schemaIndex of schemaIndexes) {
+          let found = false;
+          const key = schemaIndex[0];
+          const options = decorateDiscriminatorIndexOptions(this.schema, utils.clone(schemaIndex[1]));
+          for (const index of dbIndexes) {
+            if (isDefaultIdIndex(index)) {
+              continue;
+            }
+            if (isIndexEqual(key, options, index)) {
+              found = true;
+            }
           }
-          if (isIndexEqual(key, options, index)) {
-            found = true;
+          if (!found) {
+            toCreate.push(key);
           }
         }
-        if (!found) {
-          toCreate.push(key);
-        }
       }
       cb(null, { toDrop, toCreate });
     });
@@ -1568,36 +1576,12 @@ Model.cleanIndexes = function cleanIndexes(callback) {
   return this.db.base._promiseOrCallback(callback, cb => {
     const collection = this.$__collection;
 
-    this.listIndexes((err, dbIndexes) => {
+    this.diffIndexes({ toCreate: false }, (err, res) => {
       if (err != null) {
         return cb(err);
       }
 
-      dbIndexes = getRelatedDBIndexes(this, dbIndexes);
-      const schemaIndexes = getRelatedSchemaIndexes(this, this.schema.indexes());
-
-      const toDrop = [];
-
-      for (const dbIndex of dbIndexes) {
-        let found = false;
-        // Never try to drop `_id` index, MongoDB server doesn't allow it
-        if (isDefaultIdIndex(dbIndex)) {
-          continue;
-        }
-
-        for (const [schemaIndexKeysObject, schemaIndexOptions] of schemaIndexes) {
-          const options = decorateDiscriminatorIndexOptions(this.schema, utils.clone(schemaIndexOptions));
-          applySchemaCollation(schemaIndexKeysObject, options, this.schema.options);
-
-          if (isIndexEqual(schemaIndexKeysObject, options, dbIndex)) {
-            found = true;
-          }
-        }
-
-        if (!found) {
-          toDrop.push(dbIndex.name);
-        }
-      }
+      const toDrop = res.toDrop;
 
       if (toDrop.length === 0) {
         return cb(null, []);
@@ -3581,6 +3565,7 @@ function _setIsNew(doc, val) {
  * @param {String|number} [options.w=1] The [write concern](https://docs.mongodb.com/manual/reference/write-concern/). See [`Query#w()`](/docs/api.html#query_Query-w) for more information.
  * @param {number} [options.wtimeout=null] The [write concern timeout](https://docs.mongodb.com/manual/reference/write-concern/#wtimeout).
  * @param {Boolean} [options.j=true] If false, disable [journal acknowledgement](https://docs.mongodb.com/manual/reference/write-concern/#j-option)
+ * @param {Boolean} [options.skipValidation=false] Set to true to skip Mongoose schema validation on bulk write operations. Mongoose currently runs validation on `insertOne` and `replaceOne` operations by default.
  * @param {Boolean} [options.bypassDocumentValidation=false] If true, disable [MongoDB server-side schema validation](https://docs.mongodb.com/manual/core/schema-validation/) for all writes in this bulk.
  * @param {Boolean} [options.strict=null] Overwrites the [`strict` option](/docs/guide.html#strict) on schema. If false, allows filtering and writing fields not defined in the schema for all writes in this bulk.
  * @param {Function} [callback] callback `function(error, bulkWriteOpResult) {}`
@@ -4574,9 +4559,9 @@ function populate(model, docs, options, callback) {
     }
     // If no models to populate but we have a nested populate,
     // keep trying, re: gh-8946
-    if (options.populate != null) {
-      const opts = utils.populate(options.populate).map(pop => Object.assign({}, pop, {
-        path: options.path + '.' + pop.path
+    if (populateOptions.populate != null) {
+      const opts = utils.populate(populateOptions.populate).map(pop => Object.assign({}, pop, {
+        path: populateOptions.path + '.' + pop.path
       }));
       return model.populate(docs, opts, callback);
     }

package/lib/query.js

@@ -4610,7 +4610,10 @@ Query.prototype.transform = function(fn) {
  *     // Throws if no doc returned
  *     await Model.findOne({ foo: 'bar' }).orFail();
  *
- *     // Throws if no document was updated
+ *     // Throws if no document was updated. Note that `orFail()` will still
+ *     // throw if the only document that matches is `{ foo: 'bar', name: 'test' }`,
+ *     // because `orFail()` will throw if no document was _updated_, not
+ *     // if no document was _found_.
  *     await Model.updateOne({ foo: 'bar' }, { name: 'test' }).orFail();
  *
  *     // Throws "No docs found!" error if no docs match `{ foo: 'bar' }`
@@ -4977,7 +4980,7 @@ function castQuery(query) {
  * a response for each query has also been returned, the results are passed to
  * the callback.
  *
- * @param {Object|String} path either the path to populate or an object specifying all parameters
+ * @param {Object|String|Array<String>} path either the path(s) to populate or an object specifying all parameters
  * @param {Object|String} [select] Field selection for the population query
  * @param {Model} [model] The model you wish to use for population. If not specified, populate will look up the model by the name in the Schema's `ref` field.
  * @param {Object} [match] Conditions for the population query

package/lib/queryhelpers.js

@@ -226,7 +226,9 @@ exports.applyPaths = function applyPaths(fields, schema) {
     const addedPaths = [];
     schema.eachPath(function(path, type) {
       if (prefix) path = prefix + '.' + path;
-
+      if (type.$isSchemaMap || path.endsWith('.$*')) {
+        return;
+      }
       let addedPath = analyzePath(path, type);
       // arrays
       if (addedPath == null && !Array.isArray(type) && type.$isMongooseArray && !type.$isMongooseDocumentArray) {
@@ -248,7 +250,6 @@ exports.applyPaths = function applyPaths(fields, schema) {
         }
       }
     });
-
     stack.pop();
     return addedPaths;
   }