@depup/mongoose 9.8.1-depup.0 → 9.9.0-depup.0

package/README.md

@@ -13,8 +13,8 @@ npm install @depup/mongoose
 
 | Field | Value |
 |-------|-------|
-| Original | [mongoose](https://www.npmjs.com/package/mongoose) @ 9.8.1 |
-| Processed | 2026-07-28 |
+| Original | [mongoose](https://www.npmjs.com/package/mongoose) @ 9.9.0 |
+| Processed | 2026-07-30 |
 | Smoke test | passed |
 | Deps updated | 0 |
 

package/changes.json

@@ -1,5 +1,5 @@
 {
   "bumped": {},
-  "timestamp": "2026-07-28T00:38:49.300Z",
+  "timestamp": "2026-07-30T16:33:49.673Z",
   "totalUpdated": 0
 }

package/lib/connection.js

@@ -779,16 +779,8 @@ function _resetSessionDocuments(session) {
       doc.set(doc.schema.options.versionKey, state.versionKey);
     }
 
-    if (state.modifiedPaths.length > 0 && doc.$__.activePaths.states.modify == null) {
-      doc.$__.activePaths.states.modify = {};
-    }
     for (const path of state.modifiedPaths) {
-      const currentState = doc.$__.activePaths.paths[path];
-      if (currentState != null) {
-        delete doc.$__.activePaths[currentState][path];
-      }
-      doc.$__.activePaths.paths[path] = 'modify';
-      doc.$__.activePaths.states.modify[path] = true;
+      doc.$__.activePaths.modify(path);
     }
 
     for (const path of state.atomics.keys()) {

package/lib/document.js

@@ -49,6 +49,8 @@ const isPromise = require('./helpers/isPromise');
 const deepEqual = utils.deepEqual;
 const isMongooseObject = utils.isMongooseObject;
 
+const applyDefaultsBeforeSettersOptions = Object.freeze({ skipParentChangeTracking: true });
+
 const arrayAtomicsBackupSymbol = require('./helpers/symbols').arrayAtomicsBackupSymbol;
 const arrayAtomicsSymbol = require('./helpers/symbols').arrayAtomicsSymbol;
 const documentArrayParent = require('./helpers/symbols').documentArrayParent;
@@ -91,7 +93,7 @@ function Document(obj, fields, options) {
   if (typeof options === 'boolean') {
     throw new Error('The skipId parameter has been removed. Use { skipId: true } in the options parameter instead.');
   }
-  options = Object.assign({}, options);
+  options = options == null ? {} : Object.assign({}, options);
   let skipId = options.skipId;
 
   this.$__ = new InternalCache();
@@ -162,15 +164,14 @@ function Document(obj, fields, options) {
     $__hasIncludedChildren(fields) :
     null;
 
+  let hasPostSetterDefaults = true;
   if (this._doc == null) {
     this.$__buildDoc(obj, fields, skipId, exclude, hasIncludedChildren, false);
 
     // By default, defaults get applied **before** setting initial values
     // Re: gh-6155
     if (defaults) {
-      applyDefaults(this, fields, exclude, hasIncludedChildren, true, null, {
-        skipParentChangeTracking: true
-      });
+      hasPostSetterDefaults = applyDefaults(this, fields, exclude, hasIncludedChildren, true, null, applyDefaultsBeforeSettersOptions);
     }
   }
   if (obj) {
@@ -181,7 +182,7 @@ function Document(obj, fields, options) {
       this.$set(obj, undefined, true, options);
     }
 
-    if (obj instanceof Document) {
+    if (obj.$__ != null && obj instanceof Document) {
       this.$isNew = obj.$isNew;
     }
   }
@@ -193,7 +194,7 @@ function Document(obj, fields, options) {
     if (options.skipDefaults) {
       this.$__.skipDefaults = options.skipDefaults;
     }
-  } else if (defaults) {
+  } else if (defaults && hasPostSetterDefaults) {
     applyDefaults(this, fields, exclude, hasIncludedChildren, false, options.skipDefaults);
   }
 
@@ -560,6 +561,14 @@ function $applyDefaultsToNested(val, path, doc) {
  */
 
 Document.prototype.$__buildDoc = function(obj, fields, skipId, exclude, hasIncludedChildren) {
+  // This function only creates intermediate objects for nested paths (e.g.
+  // `{ nested: {} }` for path `nested.name`), so if the schema has no nested
+  // paths then `_doc` starts out empty.
+  if (!utils.hasOwnKeys(this.$__schema.nested)) {
+    this._doc = {};
+    return;
+  }
+
   const doc = {};
 
   const paths = Object.keys(this.$__schema.paths);
@@ -1927,7 +1936,13 @@ Document.prototype.$inc = function $inc(path, val) {
  * @api private
  */
 
-Document.prototype.$__setValue = function(path, val) {
+Document.prototype.$__setValue = function $__setValue(path, val) {
+  if (Array.isArray(path) && path.length === 1) {
+    // Fast path: if pre-split paths array of length 1, avoid all
+    // setValue overhead and just set the value directly.
+    this._doc[path[0]] = val;
+    return this;
+  }
   utils.setValue(path, val, this._doc);
   return this;
 };
@@ -2007,7 +2022,7 @@ Document.prototype.get = function(path, type, options) {
       return undefined;
     }
 
-    if (obj?._doc) {
+    if (obj && obj._doc) {
       obj = obj._doc;
     }
 
@@ -2582,18 +2597,18 @@ Document.prototype.isSelected = function isSelected(path) {
     return inclusive;
   }
 
-  const pathDot = path + '.';
+  const pathHasDot = path.indexOf('.') !== -1;
 
   for (const cur of paths) {
     if (cur === '_id') {
       continue;
     }
 
-    if (cur.startsWith(pathDot)) {
-      return inclusive || cur !== pathDot;
+    if (cur.charAt(path.length) === '.' && cur.slice(0, path.length) === path) {
+      return inclusive || cur !== path + '.';
     }
 
-    if (pathDot.startsWith(cur + '.')) {
+    if (pathHasDot && path.charAt(cur.length) === '.' && path.slice(0, cur.length) === cur) {
       return inclusive;
     }
   }
@@ -2713,11 +2728,22 @@ Document.prototype.validate = async function validate(pathsToValidate, options)
     this.$__.validating = true;
   }
 
+  const hasValidateHooks = this.$__middleware.hasHooks('validate');
   try {
     try {
-      [options] = await this._execDocumentPreHooks('validate', options, [options]);
+      if (hasValidateHooks) {
+        [options] = await this._execDocumentPreHooks('validate', options, [options]);
+      } else if (!_skipParallelValidateCheck) {
+        // Even with no validate hooks, preserve the async boundary that the pre
+        // hook `await` used to provide so that the parallel validate check still
+        // observes `$__.validating` across a tick (gh-8468). insertMany's per-doc
+        // validate passes `_skipParallelValidateCheck` and stays fully synchronous.
+        await Promise.resolve();
+      }
     } catch (error) {
-      await this._execDocumentPostHooks('validate', options, error);
+      if (hasValidateHooks) {
+        await this._execDocumentPostHooks('validate', options, error);
+      }
       return;
     }
 
@@ -2789,7 +2815,11 @@ Document.prototype.validate = async function validate(pathsToValidate, options)
     if (paths.length === 0) {
       const error = _completeValidate(this);
 
-      await this._execDocumentPostHooks('validate', options, error);
+      if (hasValidateHooks) {
+        await this._execDocumentPostHooks('validate', options, error);
+      } else if (error != null) {
+        throw error;
+      }
       return;
     }
 
@@ -2884,7 +2914,11 @@ Document.prototype.validate = async function validate(pathsToValidate, options)
 
     const error = _completeValidate(this);
 
-    await this._execDocumentPostHooks('validate', options, error);
+    if (hasValidateHooks) {
+      await this._execDocumentPostHooks('validate', options, error);
+    } else if (error != null) {
+      throw error;
+    }
   } finally {
     // Assign rather than `delete` to avoid putting `$__` in dictionary mode
     this.$__.validateModifiedOnly = undefined;
@@ -2947,25 +2981,8 @@ function _completeValidate(doc) {
   return error;
 }
 
-function _evaluateRequiredFunctions(doc) {
-  const requiredFields = Object.keys(doc.$__.activePaths.getStatePaths('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 (typeof p?.originalRequiredValue === 'function') {
-      doc.$__.cachedRequired = doc.$__.cachedRequired || {};
-      try {
-        doc.$__.cachedRequired[path] = p.originalRequiredValue.call(doc, doc);
-      } catch (err) {
-        doc.invalidate(path, err);
-      }
-    }
-  }
-}
+const STATES_TO_VALIDATE = Object.freeze(['init', 'default', 'modify']);
+const STAR_CHAR_CODE = '*'.charCodeAt(0);
 
 /*!
  * ignore
@@ -2973,69 +2990,103 @@ function _evaluateRequiredFunctions(doc) {
 
 function _getPathsToValidate(doc, pathsToValidate, pathsToSkip, isNestedValidate) {
   const doValidateOptions = {};
+  const schema = doc.$__schema;
+  const schemaPaths = schema.paths;
+  const activeStates = doc.$__.activePaths.states;
 
-  _evaluateRequiredFunctions(doc);
   // gh-16379: compute the modified-path set at most once and reuse it below, so
   // checking many required paths doesn't rebuild it per-path (O(required x modified)).
   let _modifiedPaths;
   const getModifiedPaths = () => (_modifiedPaths ??= doc.modifiedPaths());
+
   // only validate required fields when necessary
-  let paths = new Set(Object.keys(doc.$__.activePaths.getStatePaths('require')).filter(function(path) {
-    if (!doc.$__isSelected(path) && !doc.$isModified(path, null, getModifiedPaths())) {
-      return false;
-    }
-    if (path.endsWith('.$*')) {
-      // Skip $* paths - they represent map schemas, not actual document paths
-      return false;
-    }
-    if (doc.$__.cachedRequired != null && path in doc.$__.cachedRequired) {
-      return doc.$__.cachedRequired[path];
+  let paths = [];
+  const requireStates = activeStates.require;
+  if (requireStates != null) {
+    let modifiedPaths = null;
+    for (const path in requireStates) {
+      // Evaluate function-valued `required` for every required path, before any
+      // filtering, so `invalidate()` calls and `cachedRequired` entries stay
+      // consistent no matter which paths end up validated.
+      const type = Object.hasOwn(schemaPaths, path) ? schemaPaths[path] : schema.path(path);
+      if (typeof type?.originalRequiredValue === 'function') {
+        const cachedRequired = doc.$__.cachedRequired ?? (doc.$__.cachedRequired = {});
+        try {
+          cachedRequired[path] = type.originalRequiredValue.call(doc, doc);
+        } catch (err) {
+          doc.invalidate(path, err);
+        }
+      }
+
+      if (!doc.$__isSelected(path)) {
+        if (modifiedPaths === null) {
+          modifiedPaths = doc.modifiedPaths();
+        }
+        if (!doc.$isModified(path, null, modifiedPaths)) {
+          continue;
+        }
+      }
+      if (path.charCodeAt(path.length - 1) === STAR_CHAR_CODE && path.endsWith('.$*')) {
+        // Skip $* paths - they represent map schemas, not actual document paths
+        continue;
+      }
+      const cachedRequired = doc.$__.cachedRequired;
+      if (cachedRequired != null && path in cachedRequired) {
+        if (cachedRequired[path]) {
+          paths.push(path);
+        }
+      } else {
+        paths.push(path);
+      }
     }
-    return true;
-  }));
+  }
 
-  Object.keys(doc.$__.activePaths.getStatePaths('init')).forEach(addToPaths);
-  Object.keys(doc.$__.activePaths.getStatePaths('modify')).forEach(addToPaths);
-  Object.keys(doc.$__.activePaths.getStatePaths('default')).forEach(addToPaths);
-  function addToPaths(p) {
-    if (p.endsWith('.$*')) {
-      // Skip $* paths - they represent map schemas, not actual document paths
-      return;
+  for (let i = 0; i < STATES_TO_VALIDATE.length; ++i) {
+    const statePaths = activeStates[STATES_TO_VALIDATE[i]];
+    if (statePaths == null) {
+      continue;
     }
+    for (const p in statePaths) {
+      if (p.charCodeAt(p.length - 1) === STAR_CHAR_CODE && p.endsWith('.$*')) {
+        // Skip $* paths - they represent map schemas, not actual document paths
+        continue;
+      }
 
-    const _pathType = doc.$__schema.path(p);
-
-    // Optimization: if primitive path with no validators, or array of primitives
-    // with no validators, skip validating this path entirely.
-    // Note: paths with no _pathType (e.g. sub-paths under Mixed) must still be
-    // added, as they trigger validation of the parent Mixed path.
-    if (_pathType) {
-      if (!_pathType.schema &&
-        !_pathType.embeddedSchemaType &&
-        _pathType.validators.length === 0 &&
-        !_pathType.$parentSchemaDocArray &&
-        // gh-15957: skip this optimization for SchemaMap as maps can contain subdocuments
-        // that need validation even if the map itself has no validators
-        !_pathType.$isSchemaMap &&
-        !_pathType.$isSchemaUnion) {
-        return;
-      } else if (_pathType.$isMongooseArray &&
-        !_pathType.$isMongooseDocumentArray && // Skip document arrays...
-        !_pathType.embeddedSchemaType.$isMongooseArray && // and arrays of arrays
-        _pathType.validators.length === 0 && // and arrays with top-level validators
-        _pathType.embeddedSchemaType.validators.length === 0) {
-        return;
+      const _pathType = Object.hasOwn(schemaPaths, p) ? schemaPaths[p] : schema.path(p);
+
+      // Optimization: if primitive path with no validators, or array of primitives
+      // with no validators, skip validating this path entirely.
+      // Note: paths with no _pathType (e.g. sub-paths under Mixed) must still be
+      // added, as they trigger validation of the parent Mixed path.
+      if (_pathType) {
+        if (!_pathType.schema &&
+          !_pathType.embeddedSchemaType &&
+          _pathType.validators.length === 0 &&
+          !_pathType.$parentSchemaDocArray &&
+          // gh-15957: skip this optimization for SchemaMap as maps can contain subdocuments
+          // that need validation even if the map itself has no validators
+          !_pathType.$isSchemaMap &&
+          !_pathType.$isSchemaUnion) {
+          continue;
+        } else if (_pathType.$isMongooseArray &&
+          !_pathType.$isMongooseDocumentArray && // Skip document arrays...
+          !_pathType.embeddedSchemaType.$isMongooseArray && // and arrays of arrays
+          _pathType.validators.length === 0 && // and arrays with top-level validators
+          _pathType.embeddedSchemaType.validators.length === 0) {
+          continue;
+        }
       }
-    }
 
-    paths.add(p);
+      paths.push(p);
+    }
   }
 
-  const onlyPrimitiveValues = doc.$__hasOnlyPrimitiveValues();
-  if (onlyPrimitiveValues && paths.size === 0) {
-    return [[], doValidateOptions];
+  if (paths.length === 0 && doc.$__hasOnlyPrimitiveValues()) {
+    return [paths, doValidateOptions];
   }
 
+  paths = new Set(paths);
+
   if (!isNestedValidate) {
     // If we're validating a subdocument, all this logic will run anyway on the top-level document, so skip for subdocuments.
     // But only run for top-level subdocuments, because we're looking for subdocuments that are not modified at top-level but
@@ -3061,6 +3112,18 @@ function _getPathsToValidate(doc, pathsToValidate, pathsToSkip, isNestedValidate
       }
     }
     const modifiedPaths = getModifiedPaths();
+
+    // gh-6818: if a document array that has array-level validators has any
+    // modified element, validate the array itself so those validators run.
+    for (const modifiedPath of modifiedPaths) {
+      const modifiedPathType = doc.$__schema.path(modifiedPath);
+      if (modifiedPathType != null &&
+          modifiedPathType.$isMongooseDocumentArray &&
+          modifiedPathType.validators.length > 0) {
+        paths.add(modifiedPath);
+      }
+    }
+
     for (const subdoc of topLevelSubdocs) {
       if (subdoc.$basePath) {
         const fullPathToSubdoc = subdoc.$__pathRelativeToParent();
@@ -3100,7 +3163,7 @@ function _getPathsToValidate(doc, pathsToValidate, pathsToSkip, isNestedValidate
     }
   }
 
-  if (!onlyPrimitiveValues) {
+  if (!doc.$__hasOnlyPrimitiveValues()) {
     for (const path of paths) {
       const _pathType = doc.$__schema.path(path);
       if (_pathType && _pathType.$isMongooseDocumentArray) {
@@ -3139,8 +3202,8 @@ function _getPathsToValidate(doc, pathsToValidate, pathsToSkip, isNestedValidate
       // Re: gh-8468
       const singleNestedPaths = doc.$__schema.singleNestedPaths;
       for (const path of Object.keys(flat)) {
-        if (!Object.hasOwn(singleNestedPaths, path)) {
-          addToPaths(path);
+        if (!Object.hasOwn(singleNestedPaths, path) && !path.endsWith('.$*')) {
+          paths.add(path);
         }
       }
     }
@@ -3632,23 +3695,23 @@ Document.prototype.$isValid = function(path) {
  * Resets the internal modified state of this document.
  *
  * @api private
+ * @param {boolean} [skipBackup] If `true`, skips the backup of modified paths for performance
+ * @param {boolean} [hasOnlyPrimitiveValues] Precalculate `$__hasOnlyPrimitiveValues()` for performance
  * @return {Document} this
  * @method $__reset
  * @memberOf Document
  * @instance
  */
 
-Document.prototype.$__reset = function reset() {
-  let _this = this;
-
-  const onlyPrimitiveValues = this.$__hasOnlyPrimitiveValues();
+Document.prototype.$__reset = function reset(skipBackup, hasOnlyPrimitiveValues) {
+  hasOnlyPrimitiveValues = hasOnlyPrimitiveValues ?? this.$__hasOnlyPrimitiveValues();
 
   // Skip for subdocuments. Also skip if doc only has primitive values,
   // because primitives can't be subdocs.
-  const subdocs = !this.$isSubdocument && !onlyPrimitiveValues ? this.$getAllSubdocs({ useCache: true }) : null;
+  const subdocs = !this.$isSubdocument && !hasOnlyPrimitiveValues ? this.$getAllSubdocs({ useCache: true }) : null;
   if (subdocs?.length > 0) {
     for (const subdoc of subdocs) {
-      subdoc.$__reset();
+      subdoc.$__reset(skipBackup);
     }
   }
 
@@ -3657,27 +3720,32 @@ Document.prototype.$__reset = function reset() {
   // arrays, a Map, and does parent-path deduplication we don't need here.
   // Skip entirely if the doc only has primitive values, because only arrays
   // and maps have atomics.
-  if (!onlyPrimitiveValues) {
+  if (!hasOnlyPrimitiveValues) {
     this.$__resetAtomics();
   }
 
-  this.$__.backup = {};
-  this.$__.backup.activePaths = {
-    modify: Object.assign({}, this.$__.activePaths.getStatePaths('modify')),
-    default: Object.assign({}, this.$__.activePaths.getStatePaths('default'))
-  };
-  this.$__.backup.validationError = this.$__.validationError;
-  this.$__.backup.errors = this.$errors;
+  if (!skipBackup) {
+    this.$__.backup = {};
+    this.$__.backup.activePaths = {
+      modify: Object.assign({}, this.$__.activePaths.getStatePaths('modify')),
+      default: Object.assign({}, this.$__.activePaths.getStatePaths('default'))
+    };
+    this.$__.backup.validationError = this.$__.validationError;
+    this.$__.backup.errors = this.$errors;
+  }
 
   // Clear 'dirty' cache
-  this.$__.activePaths.clear('modify');
-  this.$__.activePaths.clear('default');
-  this.$__.validationError = undefined;
-  this.$errors = undefined;
-  _this = this;
-  this.$__schema.requiredPaths().forEach(function(path) {
-    _this.$__.activePaths.require(path);
-  });
+  this.$__.activePaths.clearAllExcept('init');
+  if (this.$__.validationError) {
+    this.$__.validationError = undefined;
+  }
+  if (this.$errors) {
+    this.$errors = undefined;
+  }
+
+  for (const path of this.$__schema.requiredPaths()) {
+    this.$__.activePaths.require(path);
+  }
 
   return this;
 };
@@ -4007,9 +4075,6 @@ Document.prototype.$toObject = function(options, json) {
   if (depopulate && options._isNested && this.$__.wasPopulated) {
     return clone(this.$__.wasPopulated.value || this._doc._id, options);
   }
-  if (depopulate) {
-    options.depopulate = true;
-  }
 
   // merge default options with input options.
   if (defaultOptions != null) {
@@ -4021,7 +4086,6 @@ Document.prototype.$toObject = function(options, json) {
   }
   options._isNested = true;
   options.json = json;
-  options.minimize = _minimize;
 
   const parentOptions = options._parentOptions;
   // Parent options should only bubble down for subdocuments, not populated docs
@@ -4029,7 +4093,7 @@ Document.prototype.$toObject = function(options, json) {
 
   const schemaFieldsOnly = options._calledWithOptions.schemaFieldsOnly
     ?? options.schemaFieldsOnly
-    ?? defaultOptions.schemaFieldsOnly
+    ?? defaultOptions?.schemaFieldsOnly
     ?? false;
 
   let ret;
@@ -4066,7 +4130,7 @@ Document.prototype.$toObject = function(options, json) {
 
   const getters = options._calledWithOptions.getters
     ?? options.getters
-    ?? defaultOptions.getters
+    ?? defaultOptions?.getters
     ?? false;
 
   if (getters) {
@@ -4078,7 +4142,7 @@ Document.prototype.$toObject = function(options, json) {
   }
 
   const virtuals = options._calledWithOptions.virtuals
-    ?? defaultOptions.virtuals
+    ?? defaultOptions?.virtuals
     ?? parentOptions?.virtuals
     ?? undefined;
 
@@ -4093,7 +4157,7 @@ Document.prototype.$toObject = function(options, json) {
   const transform = options._calledWithOptions.transform ?? true;
   let transformFunction = undefined;
   if (transform === true) {
-    transformFunction = defaultOptions.transform;
+    transformFunction = defaultOptions?.transform;
   } else if (typeof transform === 'function') {
     transformFunction = transform;
   }
@@ -4406,6 +4470,32 @@ function applyGetters(self, json) {
   while (i--) {
     path = paths[i];
 
+    const schemaType = schema.paths[path];
+    // Skip if no getters, including `$__isSelected()` because that can be expensive
+    if (!schemaType.getters?.length && !schemaType.embeddedSchemaType?.getters?.length) {
+      continue;
+    }
+
+    if (!self.$__isSelected(path)) {
+      continue;
+    }
+
+    if (path.indexOf('.') === -1) {
+      json[path] = schemaType.applyGetters(
+        json[path],
+        self
+      );
+      if (Array.isArray(json[path]) && schemaType.embeddedSchemaType) {
+        for (let i = 0; i < json[path].length; ++i) {
+          json[path][i] = schemaType.embeddedSchemaType.applyGetters(
+            json[path][i],
+            self
+          );
+        }
+      }
+      continue;
+    }
+
     const parts = path.split('.');
 
     const plen = parts.length;
@@ -4414,10 +4504,6 @@ function applyGetters(self, json) {
     let part;
     cur = self._doc;
 
-    if (!self.$__isSelected(path)) {
-      continue;
-    }
-
     for (let ii = 0; ii < plen; ++ii) {
       part = parts[ii];
       v = cur[part];
@@ -4427,13 +4513,13 @@ function applyGetters(self, json) {
       if (branch != null && typeof branch !== 'object') {
         break;
       } else if (ii === last) {
-        branch[part] = schema.paths[path].applyGetters(
+        branch[part] = schemaType.applyGetters(
           branch[part],
           self
         );
-        if (Array.isArray(branch[part]) && schema.paths[path].embeddedSchemaType) {
+        if (Array.isArray(branch[part]) && schemaType.embeddedSchemaType) {
           for (let i = 0; i < branch[part].length; ++i) {
-            branch[part][i] = schema.paths[path].embeddedSchemaType.applyGetters(
+            branch[part][i] = schemaType.embeddedSchemaType.applyGetters(
               branch[part][i],
               self
             );
@@ -4465,10 +4551,10 @@ function applyGetters(self, json) {
 
 function applySchemaTypeTransforms(self, json) {
   const schema = self.$__schema;
-  const paths = Object.keys(schema.paths || {});
+  const paths = schema.pathsWithTransforms();
   const cur = self._doc;
 
-  if (!cur) {
+  if (!cur || !paths) {
     return json;
   }
 
@@ -5663,13 +5749,22 @@ Document.prototype.$clearModifiedPaths = function $clearModifiedPaths() {
  */
 
 Document.prototype.$__hasOnlyPrimitiveValues = function $__hasOnlyPrimitiveValues() {
-  return !this.$__.populated && !this.$__.wasPopulated && (this._doc == null || Object.values(this._doc).every(v => {
-    return v == null
+  if (this.$__.populated) {
+    return false;
+  }
+  const doc = this._doc;
+  for (const key in doc) {
+    const v = doc[key];
+    if (v == null
       || typeof v !== 'object'
       || (utils.isNativeObject(v) && !Array.isArray(v))
       || isBsonType(v, 'ObjectId')
-      || isBsonType(v, 'Decimal128');
-  }));
+      || isBsonType(v, 'Decimal128')) {
+      continue;
+    }
+    return false;
+  }
+  return true;
 };
 
 /*!