mongoose 6.0.4 → 6.0.8

package/lib/cast.js

@@ -85,6 +85,11 @@ module.exports = function cast(schema, obj, options, context) {
         obj[path] = val.toString();
       }
 
+      continue;
+    } else if (path === '$expr') {
+      if (typeof val !== 'object' || val == null) {
+        throw new Error('`$expr` must be an object');
+      }
       continue;
     } else if (path === '$elemMatch') {
       val = cast(schema, val, options, context);
@@ -288,7 +293,7 @@ module.exports = function cast(schema, obj, options, context) {
             nested = val[$cond];
 
             if ($cond === '$not') {
-              if (nested && schematype && !schematype.caster) {
+              if (nested && schematype) {
                 _keys = Object.keys(nested);
                 if (_keys.length && isOperator(_keys[0])) {
                   for (const key in nested) {
@@ -307,7 +312,6 @@ module.exports = function cast(schema, obj, options, context) {
                 }
                 continue;
               }
-              cast(schematype.caster ? schematype.caster.schema : schema, nested, options, context);
             } else {
               val[$cond] = schematype.castForQueryWrapper({
                 $conditional: $cond,

package/lib/connection.js

@@ -562,12 +562,10 @@ function _wrapConnHelper(fn) {
       Array.prototype.slice.call(arguments);
     const disconnectedError = new MongooseError('Connection ' + this.id +
       ' was disconnected when calling `' + fn.name + '`');
+
     return promiseOrCallback(cb, cb => {
-      // Make it ok to call collection helpers before `mongoose.connect()`
-      // as long as `mongoose.connect()` is called on the same tick.
-      // Re: gh-8534
       immediate(() => {
-        if (this.readyState === STATES.connecting && this._shouldBufferCommands()) {
+        if ((this.readyState === STATES.connecting || this.readyState === STATES.disconnected) && this._shouldBufferCommands()) {
           this._queue.push({ fn: fn, ctx: this, args: argsWithoutCb.concat([cb]) });
         } else if (this.readyState === STATES.disconnected && this.db == null) {
           cb(disconnectedError);
@@ -744,7 +742,7 @@ Connection.prototype.openUri = function(uri, options, callback) {
     // Backwards compat
     if (options.user || options.pass) {
       options.auth = options.auth || {};
-      options.auth.user = options.user;
+      options.auth.username = options.user;
       options.auth.password = options.pass;
 
       this.user = options.user;

package/lib/document.js

@@ -51,7 +51,7 @@ const getSymbol = require('./helpers/symbols').getSymbol;
 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;
@@ -94,9 +94,7 @@ function Document(obj, fields, skipId, options) {
   this.$__ = new InternalCache;
   this.$__.emitter = new EventEmitter();
   this.$isNew = 'isNew' in options ? options.isNew : true;
-  this.$errors = undefined;
   this.$__.$options = options || {};
-  this.$locals = {};
   this.$op = null;
   if (obj != null && typeof obj !== 'object') {
     throw new ObjectParameterError(obj, 'obj', 'Document');
@@ -271,7 +269,15 @@ Document.prototype.schema;
 Object.defineProperty(Document.prototype, '$locals', {
   configurable: false,
   enumerable: false,
-  writable: true
+  get: function() {
+    if (this.$__.locals == null) {
+      this.$__.locals = {};
+    }
+    return this.$__.locals;
+  },
+  set: function(v) {
+    this.$__.locals = v;
+  }
 });
 
 
@@ -1800,6 +1806,7 @@ Document.prototype.$__path = function(path) {
 Document.prototype.markModified = function(path, scope) {
   this.$__.activePaths.modify(path);
   if (scope != null && !this.ownerDocument) {
+    this.$__.pathsToScopes = this.$__pathsToScopes || {};
     this.$__.pathsToScopes[path] = scope;
   }
 };
@@ -1819,7 +1826,9 @@ Document.prototype.markModified = function(path, scope) {
 
 Document.prototype.unmarkModified = function(path) {
   this.$__.activePaths.init(path);
-  delete this.$__.pathsToScopes[path];
+  if (this.$__.pathsToScopes != null) {
+    delete this.$__.pathsToScopes[path];
+  }
 };
 
 /**
@@ -2382,6 +2391,7 @@ function _evaluateRequiredFunctions(doc) {
     const p = doc.$__schema.path(path);
 
     if (p != null && typeof p.originalRequiredValue === 'function') {
+      doc.$__.cachedRequired = doc.$__.cachedRequired || {};
       doc.$__.cachedRequired[path] = p.originalRequiredValue.call(doc, doc);
     }
   });
@@ -2400,7 +2410,7 @@ function _getPathsToValidate(doc) {
     if (!doc.$__isSelected(path) && !doc.$isModified(path)) {
       return false;
     }
-    if (path in doc.$__.cachedRequired) {
+    if (doc.$__.cachedRequired != null && path in doc.$__.cachedRequired) {
       return doc.$__.cachedRequired[path];
     }
     return true;
@@ -2639,7 +2649,7 @@ Document.prototype.$__validate = function(pathsToValidate, options, callback) {
         // so in that case pull out the document's id
         val = val._id;
       }
-      const scope = path in _this.$__.pathsToScopes ?
+      const scope = _this.$__.pathsToScopes != null && path in _this.$__.pathsToScopes ?
         _this.$__.pathsToScopes[path] :
         _this;
 
@@ -3164,37 +3174,37 @@ Document.prototype.$__dirty = function() {
     };
   }));
 
-  // Sort dirty paths in a flat hierarchy.
-  all.sort(function(a, b) {
-    return (a.path < b.path ? -1 : (a.path > b.path ? 1 : 0));
-  });
-
+  const allPaths = new Map(all.filter((el) => el != null).map((el) => [el.path, el.value]));
   // Ignore "foo.a" if "foo" is dirty already.
   const minimal = [];
-  let lastPath;
-  let top;
 
   all.forEach(function(item) {
     if (!item) {
       return;
     }
-    if (lastPath == null || item.path.indexOf(lastPath) !== 0) {
-      lastPath = item.path + '.';
+
+    let top = null;
+
+    const array = parentPaths(item.path);
+    for (let i = 0; i < array.length - 1; i++) {
+      if (allPaths.has(array[i])) {
+        top = allPaths.get(array[i]);
+        break;
+      }
+    }
+    if (top == null) {
       minimal.push(item);
-      top = item;
     } else if (top != null &&
-        top.value != null &&
-        top.value[arrayAtomicsSymbol] != null &&
-        top.value.hasAtomics()) {
+        top[arrayAtomicsSymbol] != null &&
+        top.hasAtomics()) {
       // special case for top level MongooseArrays
       // the `top` array itself and a sub path of `top` are being set.
       // the only way to honor all of both modifications is through a $set
       // of entire array.
-      top.value[arrayAtomicsSymbol] = {};
-      top.value[arrayAtomicsSymbol].$set = top.value;
+      top[arrayAtomicsSymbol] = {};
+      top[arrayAtomicsSymbol].$set = top;
     }
   });
-  top = lastPath = null;
   return minimal;
 };
 
@@ -4022,13 +4032,33 @@ Document.prototype.equals = function(doc) {
  *     doc.stories[0].title; // 'Casino Royale'
  *     doc.populated('fans'); // Array of ObjectIds
  *
+ *     await doc.populate('fans', '-email');
+ *     doc.fans[0].email // not populated
+ *
+ *     await doc.populate('author fans', '-email');
+ *     doc.author.email // not populated
+ *     doc.fans[0].email // not populated
+ *
+ * @param {String|Object|Array} path either the path to populate or an object specifying all parameters, or either an array of those
+ * @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
+ * @param {Object} [options] Options for the population query (sort, etc)
+ * @param {String} [options.path=null] The path to populate.
+ * @param {boolean} [options.retainNullValues=false] by default, Mongoose removes null and undefined values from populated arrays. Use this option to make `populate()` retain `null` and `undefined` array entries.
+ * @param {boolean} [options.getters=false] if true, Mongoose will call any getters defined on the `localField`. By default, Mongoose gets the raw value of `localField`. For example, you would need to set this option to `true` if you wanted to [add a `lowercase` getter to your `localField`](/docs/schematypes.html#schematype-options).
+ * @param {boolean} [options.clone=false] When you do `BlogPost.find().populate('author')`, blog posts with the same author will share 1 copy of an `author` doc. Enable this option to make Mongoose clone populated docs before assigning them.
+ * @param {Object|Function} [options.match=null] Add an additional filter to the populate query. Can be a filter object containing [MongoDB query syntax](https://docs.mongodb.com/manual/tutorial/query-documents/), or a function that returns a filter object.
+ * @param {Function} [options.transform=null] Function that Mongoose will call on every populated document that allows you to transform the populated document.
+ * @param {Object} [options.options=null] Additional options like `limit` and `lean`.
+ * @param {Function} [callback] Callback
+ * @see population ./populate.html
+ * @see Query#select #query_Query-select
  * @see Model.populate #model_Model.populate
- * @param {String|Object|Array} [path] The path to populate or an options object or array of paths and/or options objects.
- * @param {Function} [callback] When passed, population is invoked
- * @api public
- * @return {Promise|null} this
  * @memberOf Document
  * @instance
+ * @return {Promise|null}
+ * @api public
  */
 
 Document.prototype.populate = function populate() {
@@ -4130,6 +4160,9 @@ Document.prototype.populated = function(path, val, options) {
     if (!this.$__.populated) {
       return undefined;
     }
+    if (typeof path !== 'string') {
+      return undefined;
+    }
 
     // Map paths can be populated with either `path.$*` or just `path`
     const _path = path.endsWith('.$*') ? path.replace(/\.\$\*$/, '') : path;
@@ -4210,7 +4243,7 @@ Document.prototype.depopulate = function(path) {
         continue;
       }
       delete populated[key];
-      this.$set(key, populatedIds);
+      utils.setValue(key, populatedIds, this._doc);
     }
     return this;
   }
@@ -4223,7 +4256,7 @@ Document.prototype.depopulate = function(path) {
       delete this.$$populatedVirtuals[singlePath];
       delete this._doc[singlePath];
     } else if (populatedIds) {
-      this.$set(singlePath, populatedIds);
+      utils.setValue(singlePath, populatedIds, this._doc);
     }
   }
   return this;

package/lib/drivers/node-mongodb-native/collection.js

@@ -66,7 +66,7 @@ NativeCollection.prototype.onClose = function(force) {
  * ignore
  */
 
-const syncCollectionMethods = { watch: true, find: true };
+const syncCollectionMethods = { watch: true, find: true, aggregate: true };
 
 /*!
  * Copy the collection methods and make them subject to queues

package/lib/error/objectExpected.js

@@ -18,7 +18,7 @@ class ObjectExpectedError extends MongooseError {
   constructor(path, val) {
     const typeDescription = Array.isArray(val) ? 'array' : 'primitive value';
     super('Tried to set nested object field `' + path +
-      `\` to ${typeDescription} \`` + val + '` and strict mode is set to throw.');
+      `\` to ${typeDescription} \`` + val + '`');
     this.path = path;
   }
 }

package/lib/helpers/document/getEmbeddedDiscriminatorPath.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const get = require('../get');
+const getSchemaDiscriminatorByValue = require('../discriminator/getSchemaDiscriminatorByValue');
 
 /*!
  * Like `schema.path()`, except with a document, because impossible to
@@ -10,26 +11,28 @@ const get = require('../get');
 module.exports = function getEmbeddedDiscriminatorPath(doc, path, options) {
   options = options || {};
   const typeOnly = options.typeOnly;
-  const parts = path.split('.');
-  let schema = null;
+  const parts = path.indexOf('.') === -1 ? [path] : path.split('.');
+  let schemaType = null;
   let type = 'adhocOrUndefined';
 
+  const schema = getSchemaDiscriminatorByValue(doc.schema, doc.get(doc.schema.options.discriminatorKey)) || doc.schema;
+
   for (let i = 0; i < parts.length; ++i) {
     const subpath = parts.slice(0, i + 1).join('.');
-    schema = doc.schema.path(subpath);
-    if (schema == null) {
+    schemaType = schema.path(subpath);
+    if (schemaType == null) {
       type = 'adhocOrUndefined';
       continue;
     }
-    if (schema.instance === 'Mixed') {
-      return typeOnly ? 'real' : schema;
+    if (schemaType.instance === 'Mixed') {
+      return typeOnly ? 'real' : schemaType;
     }
-    type = doc.schema.pathType(subpath);
-    if ((schema.$isSingleNested || schema.$isMongooseDocumentArrayElement) &&
-        schema.schema.discriminators != null) {
-      const discriminators = schema.schema.discriminators;
+    type = schema.pathType(subpath);
+    if ((schemaType.$isSingleNested || schemaType.$isMongooseDocumentArrayElement) &&
+    schemaType.schema.discriminators != null) {
+      const discriminators = schemaType.schema.discriminators;
       const discriminatorKey = doc.get(subpath + '.' +
-        get(schema, 'schema.options.discriminatorKey'));
+        get(schemaType, 'schema.options.discriminatorKey'));
       if (discriminatorKey == null || discriminators[discriminatorKey] == null) {
         continue;
       }
@@ -39,5 +42,5 @@ module.exports = function getEmbeddedDiscriminatorPath(doc, path, options) {
   }
 
   // Are we getting the whole schema or just the type, 'real', 'nested', etc.
-  return typeOnly ? type : schema;
+  return typeOnly ? type : schemaType;
 };

package/lib/helpers/model/applyMethods.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const get = require('../get');
+const utils = require('../../utils');
 
 /*!
  * Register methods for this model
@@ -30,7 +31,7 @@ module.exports = function applyMethods(model, schema) {
     }
     if (schema.reserved[method] &&
         !get(schema, `methodOptions.${method}.suppressWarning`, false)) {
-      console.warn(`mongoose: the method name "${method}" is used by mongoose ` +
+      utils.warn(`mongoose: the method name "${method}" is used by mongoose ` +
         'internally, overwriting it may cause bugs. If you\'re sure you know ' +
         'what you\'re doing, you can suppress this error by using ' +
         `\`schema.method('${method}', fn, { suppressWarning: true })\`.`);

package/lib/helpers/populate/assignVals.js

@@ -46,6 +46,9 @@ module.exports = function assignVals(o) {
     if (val instanceof SkipPopulateValue) {
       return val.val;
     }
+    if (val === void 0) {
+      return val;
+    }
 
     const _allIds = o.allIds[i];
 

package/lib/helpers/populate/createPopulateQueryFilter.js

@@ -2,6 +2,7 @@
 
 const SkipPopulateValue = require('./SkipPopulateValue');
 const parentPaths = require('../path/parentPaths');
+const { trusted } = require('../query/trusted');
 
 module.exports = function createPopulateQueryFilter(ids, _match, _foreignField, model, skipInvalidIds) {
   const match = _formatMatch(_match);
@@ -11,14 +12,14 @@ module.exports = function createPopulateQueryFilter(ids, _match, _foreignField,
     const foreignSchemaType = model.schema.path(foreignField);
     if (foreignField !== '_id' || !match['_id']) {
       ids = _filterInvalidIds(ids, foreignSchemaType, skipInvalidIds);
-      match[foreignField] = { $in: ids };
+      match[foreignField] = trusted({ $in: ids });
     }
 
     const _parentPaths = parentPaths(foreignField);
     for (let i = 0; i < _parentPaths.length - 1; ++i) {
       const cur = _parentPaths[i];
       if (match[cur] != null && match[cur].$elemMatch != null) {
-        match[cur].$elemMatch[foreignField.slice(cur.length + 1)] = { $in: ids };
+        match[cur].$elemMatch[foreignField.slice(cur.length + 1)] = trusted({ $in: ids });
         delete match[foreignField];
         break;
       }

package/lib/helpers/populate/lookupLocalFields.js

@@ -13,6 +13,9 @@ module.exports = function lookupLocalFields(cur, path, val) {
     if (typeof cur !== 'object') {
       return void 0;
     }
+    if (val === void 0) {
+      return void 0;
+    }
     if (cur instanceof Map) {
       cur.set(path, val);
     } else {

package/lib/helpers/printJestWarning.js

@@ -1,14 +1,16 @@
 'use strict';
 
+const utils = require('../utils');
+
 if (typeof jest !== 'undefined' && typeof window !== 'undefined') {
-  console.warn('Mongoose: looks like you\'re trying to test a Mongoose app ' +
+  utils.warn('Mongoose: looks like you\'re trying to test a Mongoose app ' +
     'with Jest\'s default jsdom test environment. Please make sure you read ' +
     'Mongoose\'s docs on configuring Jest to test Node.js apps: ' +
     'http://mongoosejs.com/docs/jest.html');
 }
 
 if (typeof jest !== 'undefined' && process.nextTick.toString().indexOf('nextTick') === -1) {
-  console.warn('Mongoose: looks like you\'re trying to test a Mongoose app ' +
+  utils.warn('Mongoose: looks like you\'re trying to test a Mongoose app ' +
     'with Jest\'s mock timers enabled. Please make sure you read ' +
     'Mongoose\'s docs on configuring Jest to test Node.js apps: ' +
     'http://mongoosejs.com/docs/jest.html');

package/lib/helpers/setDefaultsOnInsert.js

@@ -75,36 +75,17 @@ module.exports = function(filter, schema, castedDoc, options) {
 
   schema.eachPath(function(path, schemaType) {
     // Skip single nested paths if underneath a map
-    const isUnderneathMap = schemaType.path.endsWith('.$*') ||
-      schemaType.path.indexOf('.$*.') !== -1;
-    if (schemaType.$isSingleNested && !isUnderneathMap) {
-      // Only handle nested schemas 1-level deep to avoid infinite
-      // recursion re: https://github.com/mongodb-js/mongoose-autopopulate/issues/11
-      schemaType.schema.eachPath(function(_path, _schemaType) {
-        if (_path === '_id' && _schemaType.auto) {
-          // Ignore _id if auto id so we don't create subdocs
-          return;
-        }
-
-        const def = _schemaType.getDefault(null, true);
-        if (!isModified(modified, path + '.' + _path) &&
-            typeof def !== 'undefined') {
-          castedDoc = castedDoc || {};
-          castedDoc.$setOnInsert = castedDoc.$setOnInsert || {};
-          castedDoc.$setOnInsert[path + '.' + _path] = def;
-          updatedValues[path + '.' + _path] = def;
-        }
-      });
-    } else {
-      const def = schemaType.getDefault(null, true);
-      if (!isModified(modified, path) && typeof def !== 'undefined') {
-        castedDoc = castedDoc || {};
-        castedDoc.$setOnInsert = castedDoc.$setOnInsert || {};
-        if (get(castedDoc, path) == null) {
-          castedDoc.$setOnInsert[path] = def;
-        }
-        updatedValues[path] = def;
+    if (schemaType.path === '_id' && schemaType.options.auto) {
+      return;
+    }
+    const def = schemaType.getDefault(null, true);
+    if (!isModified(modified, path) && typeof def !== 'undefined') {
+      castedDoc = castedDoc || {};
+      castedDoc.$setOnInsert = castedDoc.$setOnInsert || {};
+      if (get(castedDoc, path) == null) {
+        castedDoc.$setOnInsert[path] = def;
       }
+      updatedValues[path] = def;
     }
   });
 

package/lib/helpers/timestamps/setupTimestamps.js

@@ -31,7 +31,7 @@ module.exports = function setupTimestamps(schema, timestamps) {
   }
 
   if (createdAt && !schema.paths[createdAt]) {
-    schemaAdditions[createdAt] = { type: Date, immutable: true };
+    schemaAdditions[createdAt] = { [schema.options.typeKey || 'type']: Date, immutable: true };
   }
   schema.add(schemaAdditions);
 
@@ -49,7 +49,7 @@ module.exports = function setupTimestamps(schema, timestamps) {
       (this.ownerDocument ? this.ownerDocument() : this).constructor.base.now();
     const auto_id = this._id && this._id.auto;
 
-    if (!skipCreatedAt && createdAt && !this.get(createdAt) && this.$__isSelected(createdAt)) {
+    if (!skipCreatedAt && createdAt && !this.$__getValue(createdAt) && this.$__isSelected(createdAt)) {
       this.$set(createdAt, auto_id ? this._id.getTimestamp() : defaultTimestamp);
     }
 

package/lib/helpers/update/castArrayFilters.js

@@ -7,25 +7,37 @@ const updatedPathsByArrayFilter = require('./updatedPathsByArrayFilter');
 
 module.exports = function castArrayFilters(query) {
   const arrayFilters = query.options.arrayFilters;
-  if (!Array.isArray(arrayFilters)) {
-    return;
-  }
   const update = query.getUpdate();
   const schema = query.schema;
   const strict = schema.options.strict;
   const updatedPathsByFilter = updatedPathsByArrayFilter(update);
+
+  _castArrayFilters(arrayFilters, schema, strict, updatedPathsByFilter, query);
+};
+
+function _castArrayFilters(arrayFilters, schema, strict, updatedPathsByFilter, query) {
+  if (!Array.isArray(arrayFilters)) {
+    return;
+  }
+
   for (const filter of arrayFilters) {
     if (filter == null) {
       throw new Error(`Got null array filter in ${arrayFilters}`);
     }
     for (const key of Object.keys(filter)) {
+      if (key === '$and' || key === '$or') {
+        _castArrayFilters(filter[key], schema, strict, updatedPathsByFilter, query);
+        continue;
+      }
       if (filter[key] == null) {
         continue;
       }
       if (updatedPathsByFilter[key] === null) {
         continue;
       }
-      if (Object.keys(updatedPathsByFilter).length === 0) continue;
+      if (Object.keys(updatedPathsByFilter).length === 0) {
+        continue;
+      }
       const dot = key.indexOf('.');
       let filterPath = dot === -1 ?
         updatedPathsByFilter[key] + '.0' :
@@ -55,4 +67,4 @@ module.exports = function castArrayFilters(query) {
       }
     }
   }
-};
+}

package/lib/helpers/update/removeUnusedArrayFilters.js

@@ -7,12 +7,26 @@
  */
 
 module.exports = function removeUnusedArrayFilters(update, arrayFilters) {
-  const updateKeys = Object.keys(update).map(key => Object.keys(update[key])).reduce((cur, arr) => cur.concat(arr), []);
+  const updateKeys = Object.keys(update).
+    map(key => Object.keys(update[key])).
+    reduce((cur, arr) => cur.concat(arr), []);
   return arrayFilters.filter(obj => {
-    const firstKey = Object.keys(obj)[0];
-    const firstDot = firstKey.indexOf('.');
-    const arrayFilterKey = firstDot === -1 ? firstKey : firstKey.slice(0, firstDot);
-
-    return updateKeys.find(key => key.includes('$[' + arrayFilterKey + ']')) != null;
+    return _checkSingleFilterKey(obj, updateKeys);
   });
-};
+};
+
+function _checkSingleFilterKey(arrayFilter, updateKeys) {
+  const firstKey = Object.keys(arrayFilter)[0];
+
+  if (firstKey === '$and' || firstKey === '$or') {
+    if (!Array.isArray(arrayFilter[firstKey])) {
+      return false;
+    }
+    return arrayFilter[firstKey].find(filter => _checkSingleFilterKey(filter, updateKeys)) != null;
+  }
+
+  const firstDot = firstKey.indexOf('.');
+  const arrayFilterKey = firstDot === -1 ? firstKey : firstKey.slice(0, firstDot);
+
+  return updateKeys.find(key => key.includes('$[' + arrayFilterKey + ']')) != null;
+}

package/lib/helpers/update/updatedPathsByArrayFilter.js

@@ -3,6 +3,9 @@
 const modifiedPaths = require('./modifiedPaths');
 
 module.exports = function updatedPathsByArrayFilter(update) {
+  if (update == null) {
+    return {};
+  }
   const updatedPaths = modifiedPaths(update);
 
   return Object.keys(updatedPaths).reduce((cur, path) => {

package/lib/index.js

@@ -25,7 +25,6 @@ const legacyPluralize = require('./helpers/pluralize');
 const utils = require('./utils');
 const pkg = require('../package.json');
 const cast = require('./cast');
-const idGetter = require('./plugins/idGetter');
 const removeSubdocs = require('./plugins/removeSubdocs');
 const saveSubdocs = require('./plugins/saveSubdocs');
 const trackTransaction = require('./plugins/trackTransaction');
@@ -102,7 +101,6 @@ function Mongoose(options) {
     enumerable: true,
     writable: false,
     value: [
-      [idGetter, { deduplicate: true }],
       [saveSubdocs, { deduplicate: true }],
       [validateBeforeSave, { deduplicate: true }],
       [shardingPlugin, { deduplicate: true }],

package/lib/internal.js

@@ -10,28 +10,30 @@ const ActiveRoster = StateMachine.ctor('require', 'modify', 'init', 'default', '
 module.exports = exports = InternalCache;
 
 function InternalCache() {
-  this.strictMode = undefined;
-  this.selected = undefined;
-  this.shardval = undefined;
-  this.saveError = undefined;
-  this.validationError = undefined;
-  this.adhocPaths = undefined;
-  this.removing = undefined;
-  this.inserting = undefined;
-  this.saving = undefined;
-  this.version = undefined;
-  this.getters = {};
-  this._id = undefined;
-  this.populate = undefined; // what we want to populate in this doc
-  this.populated = undefined;// the _ids that have been populated
-  this.wasPopulated = false; // if this doc was the result of a population
-  this.scope = undefined;
+
   this.activePaths = new ActiveRoster;
-  this.pathsToScopes = {};
-  this.cachedRequired = {};
-  this.session = null;
 
   // embedded docs
   this.ownerDocument = undefined;
   this.fullPath = undefined;
 }
+
+InternalCache.prototype.strictMode = undefined;
+InternalCache.prototype.selected = undefined;
+InternalCache.prototype.shardval = undefined;
+InternalCache.prototype.saveError = undefined;
+InternalCache.prototype.validationError = undefined;
+InternalCache.prototype.adhocPaths = undefined;
+InternalCache.prototype.removing = undefined;
+InternalCache.prototype.inserting = undefined;
+InternalCache.prototype.saving = undefined;
+InternalCache.prototype.version = undefined;
+InternalCache.prototype._id = undefined;
+InternalCache.prototype.populate = undefined; // what we want to populate in this doc
+InternalCache.prototype.populated = undefined;// the _ids that have been populated
+InternalCache.prototype.wasPopulated = false; // if this doc was the result of a population
+InternalCache.prototype.scope = undefined;
+
+InternalCache.prototype.session = null;
+InternalCache.prototype.pathsToScopes = null;
+InternalCache.prototype.cachedRequired = null;