mongoose 9.2.1 → 9.2.2

package/lib/document.js

@@ -22,6 +22,7 @@ const $__hasIncludedChildren = require('./helpers/projection/hasIncludedChildren
 const applyDefaults = require('./helpers/document/applyDefaults');
 const cleanModifiedSubpaths = require('./helpers/document/cleanModifiedSubpaths');
 const clone = require('./helpers/clone');
+const isInPathsToSave = require('./helpers/document/isInPathsToSave');
 const compile = require('./helpers/document/compile').compile;
 const defineKey = require('./helpers/document/compile').defineKey;
 const firstKey = require('./helpers/firstKey');
@@ -1428,11 +1429,25 @@ Document.prototype.$set = function $set(path, val, type, options) {
       }
 
       // Check refPath
-      const refPath = schema.options.refPath;
+      let refPath = schema.options.refPath;
       if (refPath == null) {
         return false;
       }
-      const modelName = val.get(refPath);
+
+      if (typeof refPath === 'function' && !refPath[modelSymbol]) {
+        let fullPath = path;
+        const fullPathWithIndexes = this.$__fullPathWithIndexes?.();
+        if (fullPathWithIndexes?.length) {
+          fullPath = fullPathWithIndexes + '.' + path;
+        }
+        refPath = refPath.call(this, this, fullPath);
+      }
+
+      if (typeof refPath !== 'string') {
+        throw new MongooseError('`refPath` must be a string or a function that returns a string, got ' + inspect(refPath));
+      }
+
+      const modelName = this.ownerDocument().get(refPath);
       return modelName === model.modelName || modelName === model.baseModelName;
     })();
 
@@ -4998,26 +5013,47 @@ Document.prototype.getChanges = function() {
 /**
  * Produces a special query document of the modified properties used in updates.
  *
+ * @param {string[]|null} [pathsToSave] paths to include in delta generation
+ * @param {Set<string>|null} [pathsToSaveSet] pre-built Set of pathsToSave for O(1) exact lookup
  * @api private
  * @method $__delta
  * @memberOf Document
  * @instance
  */
 
-Document.prototype.$__delta = function $__delta() {
-  const dirty = this.$__dirty();
+Document.prototype.$__delta = function $__delta(pathsToSave, pathsToSaveSet) {
+  const allDirty = this.$__dirty();
+  let dirty = allDirty;
+  let unsavedDirty = null;
+  if (pathsToSave != null) {
+    dirty = [];
+    unsavedDirty = [];
+    for (const data of allDirty) {
+      if (isInPathsToSave(data.path, pathsToSaveSet, pathsToSave)) {
+        dirty.push(data);
+      } else {
+        unsavedDirty.push(data);
+      }
+    }
+  }
   const optimisticConcurrency = this.$__schema.options.optimisticConcurrency;
   if (optimisticConcurrency) {
     if (Array.isArray(optimisticConcurrency)) {
       const optCon = new Set(optimisticConcurrency);
       const modPaths = this.modifiedPaths();
-      if (modPaths.some(path => optCon.has(path))) {
+      const hasRelevantModPaths = pathsToSave == null ?
+        modPaths.find(path => optCon.has(path)) :
+        modPaths.find(path => optCon.has(path) && isInPathsToSave(path, pathsToSaveSet, pathsToSave));
+      if (hasRelevantModPaths) {
         this.$__.version = dirty.length ? VERSION_ALL : VERSION_WHERE;
       }
     } else if (Array.isArray(optimisticConcurrency?.exclude)) {
       const excluded = new Set(optimisticConcurrency.exclude);
       const modPaths = this.modifiedPaths();
-      if (modPaths.some(path => !excluded.has(path))) {
+      const hasRelevantModPaths = pathsToSave == null ?
+        modPaths.find(path => !excluded.has(path)) :
+        modPaths.find(path => !excluded.has(path) && isInPathsToSave(path, pathsToSaveSet, pathsToSave));
+      if (hasRelevantModPaths) {
         this.$__.version = dirty.length ? VERSION_ALL : VERSION_WHERE;
       }
     } else {
@@ -5123,10 +5159,10 @@ Document.prototype.$__delta = function $__delta() {
   }
 
   if (utils.hasOwnKeys(delta) === false) {
-    return [where, null];
+    return [where, null, unsavedDirty];
   }
 
-  return [where, delta];
+  return [where, delta, unsavedDirty];
 };
 
 /**

package/lib/helpers/document/isInPathsToSave.js

@@ -0,0 +1,24 @@
+'use strict';
+
+/**
+ * Returns true if `path` is included by the `pathsToSave` filter.
+ * Matches exact paths and child paths (e.g. 'metadata.views' is included by 'metadata').
+ *
+ * @param {string} path
+ * @param {Set<string>} pathsToSaveSet - pre-built Set of pathsToSave for O(1) exact lookup
+ * @param {string[]} pathsToSave - original array, used for prefix matching
+ * @returns {boolean}
+ */
+module.exports = function isInPathsToSave(path, pathsToSaveSet, pathsToSave) {
+  if (pathsToSaveSet.has(path)) {
+    return true;
+  }
+
+  for (const pathToSave of pathsToSave) {
+    if (path.slice(0, pathToSave.length) === pathToSave && path.charAt(pathToSave.length) === '.') {
+      return true;
+    }
+  }
+
+  return false;
+};

package/lib/helpers/populate/getModelsMapForPopulate.js

@@ -17,6 +17,9 @@ const modelSymbol = require('../symbols').modelSymbol;
 const populateModelSymbol = require('../symbols').populateModelSymbol;
 const schemaMixedSymbol = require('../../schema/symbols').schemaMixedSymbol;
 const StrictPopulate = require('../../error/strictPopulate');
+const numericPathSegmentPattern = '\\.\\d+(?=\\.|$)';
+const hasNumericPathSegmentRE = new RegExp(numericPathSegmentPattern);
+const numericPathSegmentRE = new RegExp(numericPathSegmentPattern, 'g');
 
 module.exports = function getModelsMapForPopulate(model, docs, options) {
   let doc;
@@ -43,7 +46,8 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
     return _virtualPopulate(model, docs, options, _virtualRes);
   }
 
-  let allSchemaTypes = getSchemaTypes(model, modelSchema, null, options.path);
+  const parts = modelSchema.paths[options.path]?.splitPath() ?? options.path.split('.');
+  let allSchemaTypes = getSchemaTypes(model, modelSchema, null, options.path, parts);
   allSchemaTypes = Array.isArray(allSchemaTypes) ? allSchemaTypes : [allSchemaTypes].filter(v => v != null);
 
   const isStrictPopulateDisabled = options.strictPopulate === false || options.options?.strictPopulate === false;
@@ -63,7 +67,7 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
     }
 
     const docSchema = doc?.$__ != null ? doc.$__schema : modelSchema;
-    schema = getSchemaTypes(model, docSchema, doc, options.path);
+    schema = getSchemaTypes(model, docSchema, doc, options.path, parts);
 
     // Special case: populating a path that's a DocumentArray unless
     // there's an explicit `ref` or `refPath` re: gh-8946
@@ -201,8 +205,11 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
     data.modelNamesInOrder = modelNamesInOrder;
 
     if (isRefPath) {
+      const normalizedRefPathForDiscriminators = typeof normalizedRefPath === 'string' ?
+        normalizedRefPath.replace(numericPathSegmentRE, '') :
+        normalizedRefPath;
       const embeddedDiscriminatorModelNames = _findRefPathForDiscriminators(doc,
-        modelSchema, data, options, normalizedRefPath, ret);
+        modelSchema, data, options, normalizedRefPathForDiscriminators, ret);
 
       modelNames = embeddedDiscriminatorModelNames || modelNames;
     }
@@ -215,23 +222,23 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
   }
   return map;
 
-  function _getModelNames(doc, schema, modelNameFromQuery, model) {
+  function _getModelNames(doc, schemaType, modelNameFromQuery, model) {
     let modelNames;
     let isRefPath = false;
     let justOne = null;
 
-    const originalSchema = schema;
-    if (schema?.instance === 'Array') {
-      schema = schema.embeddedSchemaType;
+    const originalSchema = schemaType;
+    if (schemaType?.instance === 'Array') {
+      schemaType = schemaType.embeddedSchemaType;
     }
-    if (schema?.$isSchemaMap) {
-      schema = schema.$__schemaType;
+    if (schemaType?.$isSchemaMap) {
+      schemaType = schemaType.$__schemaType;
     }
 
-    const ref = schema?.options?.ref;
-    refPath = schema?.options?.refPath;
-    if (schema != null &&
-        schema[schemaMixedSymbol] &&
+    const ref = schemaType?.options?.ref;
+    refPath = schemaType?.options?.refPath;
+    if (schemaType != null &&
+        schemaType[schemaMixedSymbol] &&
         !ref &&
         !refPath &&
         !modelNameFromQuery) {
@@ -242,19 +249,9 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
       modelNames = [modelNameFromQuery]; // query options
     } else if (refPath != null) {
       if (typeof refPath === 'function') {
-        const subdocPath = options.path.slice(0, options.path.length - schema.path.length - 1);
-        const vals = mpath.get(subdocPath, doc, lookupLocalFields);
-        const subdocsBeingPopulated = Array.isArray(vals) ?
-          utils.array.flatten(vals) :
-          (vals ? [vals] : []);
-
-        modelNames = new Set();
-        for (const subdoc of subdocsBeingPopulated) {
-          refPath = refPath.call(subdoc, subdoc, options.path);
-          modelNamesFromRefPath(refPath, doc, options.path, modelSchema, options._queryProjection).
-            forEach(name => modelNames.add(name));
-        }
-        modelNames = Array.from(modelNames);
+        const res = _getModelNamesFromFunctionRefPath(refPath, doc, schemaType, options.path, modelSchema, options._queryProjection);
+        modelNames = res.modelNames;
+        refPath = res.refPath;
       } else {
         modelNames = modelNamesFromRefPath(refPath, doc, options.path, modelSchema, options._queryProjection);
       }
@@ -268,7 +265,7 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
       let modelForCurrentDoc = model;
       const discriminatorKey = model.schema.options.discriminatorKey;
 
-      if (!schema && discriminatorKey && (discriminatorValue = utils.getValue(discriminatorKey, doc))) {
+      if (!schemaType && discriminatorKey && (discriminatorValue = utils.getValue(discriminatorKey, doc))) {
         // `modelNameForFind` is the discriminator value, so we might need
         // find the discriminated model name
         const discriminatorModel = getDiscriminatorByValue(model.discriminators, discriminatorValue) || model;
@@ -288,7 +285,7 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
           schemaForCurrentDoc = schemaForCurrentDoc.embeddedSchemaType;
         }
       } else {
-        schemaForCurrentDoc = schema;
+        schemaForCurrentDoc = schemaType;
       }
 
       if (originalSchema && originalSchema.path.endsWith('.$*')) {
@@ -322,22 +319,12 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
           ref = handleRefFunction(ref, doc);
           modelNames = [ref];
         }
-      } else if ((schemaForCurrentDoc = get(schema, 'options.refPath')) != null) {
+      } else if ((refPath = get(schemaForCurrentDoc, 'options.refPath')) != null) {
         isRefPath = true;
         if (typeof refPath === 'function') {
-          const subdocPath = options.path.slice(0, options.path.length - schemaForCurrentDoc.path.length - 1);
-          const vals = mpath.get(subdocPath, doc, lookupLocalFields);
-          const subdocsBeingPopulated = Array.isArray(vals) ?
-            utils.array.flatten(vals) :
-            (vals ? [vals] : []);
-
-          modelNames = new Set();
-          for (const subdoc of subdocsBeingPopulated) {
-            refPath = refPath.call(subdoc, subdoc, options.path);
-            modelNamesFromRefPath(refPath, doc, options.path, modelSchema, options._queryProjection).
-              forEach(name => modelNames.add(name));
-          }
-          modelNames = Array.from(modelNames);
+          const res = _getModelNamesFromFunctionRefPath(refPath, doc, schemaForCurrentDoc, options.path, modelSchema, options._queryProjection);
+          modelNames = res.modelNames;
+          refPath = res.refPath;
         } else {
           modelNames = modelNamesFromRefPath(refPath, doc, options.path, modelSchema, options._queryProjection);
         }
@@ -361,6 +348,137 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
   }
 };
 
+/**
+ * Resolve model names for function-style `refPath` and return the first
+ * resolved refPath value so discriminator handling can inspect it later.
+ *
+ * @param {Function} refPath
+ * @param {Document|Object} doc
+ * @param {SchemaType} schema
+ * @param {String} populatePath
+ * @param {Schema} modelSchema
+ * @param {Object} queryProjection
+ * @returns {{modelNames: String[], refPath: String|null}}
+ * @private
+ */
+function _getModelNamesFromFunctionRefPath(refPath, doc, schemaType, populatePath, modelSchema, queryProjection) {
+  const modelNames = [];
+  let normalizedRefPath = null;
+  const schemaPath = schemaType?.path;
+
+  if (schemaPath != null &&
+      populatePath.length > schemaPath.length + 1 &&
+      populatePath.charAt(populatePath.length - schemaPath.length - 1) === '.' &&
+      populatePath.slice(populatePath.length - schemaPath.length) === schemaPath
+  ) {
+    const subdocPath = populatePath.slice(0, populatePath.length - schemaPath.length - 1);
+    const segments = subdocPath.indexOf('.') === -1 ? [subdocPath] : subdocPath.split('.');
+    let hasSubdoc = false;
+
+    walkSubdocs(doc, '', 0);
+    if (hasSubdoc) {
+      return { modelNames, refPath: normalizedRefPath };
+    }
+
+    function walkSubdocs(currentSubdoc, indexedPathPrefix, segmentIndex) {
+      if (currentSubdoc == null) {
+        return;
+      }
+
+      if (segmentIndex >= segments.length) {
+        hasSubdoc = true;
+        const indexedPath = indexedPathPrefix + '.' + schemaPath;
+        const subdocRefPath = refPath.call(currentSubdoc, currentSubdoc, indexedPath);
+        normalizedRefPath = normalizedRefPath || subdocRefPath;
+        modelNames.push(..._getModelNamesFromRefPath(subdocRefPath, doc, populatePath, indexedPath, modelSchema, queryProjection));
+        return;
+      }
+
+      const segment = segments[segmentIndex];
+      const source = currentSubdoc?._doc ?? currentSubdoc;
+
+      if (segment === '$*') {
+        if (source instanceof Map) {
+          for (const [key, value] of source.entries()) {
+            if (value != null) {
+              const valuePath = indexedPathPrefix.length === 0 ?
+                key :
+                indexedPathPrefix + '.' + key;
+              walkSubdocs(value, valuePath, segmentIndex + 1);
+            }
+          }
+          return;
+        }
+
+        if (source != null && typeof source === 'object') {
+          for (const key of Object.keys(source)) {
+            const value = source[key];
+            if (value != null) {
+              const valuePath = indexedPathPrefix.length === 0 ?
+                key :
+                indexedPathPrefix + '.' + key;
+              walkSubdocs(value, valuePath, segmentIndex + 1);
+            }
+          }
+        }
+        return;
+      }
+
+      const child = source[segment];
+      const childPath = indexedPathPrefix.length === 0 ?
+        segment :
+        indexedPathPrefix + '.' + segment;
+
+      if (Array.isArray(child)) {
+        for (let i = 0; i < child.length; ++i) {
+          if (child[i] != null) {
+            walkSubdocs(child[i], childPath + '.' + i, segmentIndex + 1);
+          }
+        }
+      } else if (child != null) {
+        walkSubdocs(child, childPath, segmentIndex + 1);
+      }
+    }
+  }
+
+  const topLevelRefPath = refPath.call(doc, doc, populatePath);
+  normalizedRefPath = normalizedRefPath || topLevelRefPath;
+  modelNames.push(...modelNamesFromRefPath(topLevelRefPath, doc, populatePath, modelSchema, queryProjection));
+
+  return { modelNames, refPath: normalizedRefPath };
+}
+
+/**
+ * Resolve model names from a refPath, preferring the indexed populated path
+ * for array subdocuments and falling back to the original populate path if
+ * normalization fails.
+ *
+ * @param {String|Function} refPath
+ * @param {Document|Object} doc
+ * @param {String} populatePath
+ * @param {String} indexedPath
+ * @param {Schema} modelSchema
+ * @param {Object} queryProjection
+ * @returns {String[]}
+ * @private
+ */
+function _getModelNamesFromRefPath(refPath, doc, populatePath, indexedPath, modelSchema, queryProjection) {
+  const populatedPath = typeof refPath === 'string' && hasNumericPathSegmentRE.test(refPath) ?
+    populatePath :
+    indexedPath;
+
+  try {
+    return modelNamesFromRefPath(refPath, doc, populatedPath, modelSchema, queryProjection);
+  } catch (error) {
+    if (populatedPath === indexedPath &&
+        typeof error?.message === 'string' &&
+        error.message.startsWith('Could not normalize ref path')) {
+      return modelNamesFromRefPath(refPath, doc, populatePath, modelSchema, queryProjection);
+    }
+    throw error;
+  }
+}
+
 /*!
  * ignore
  */

package/lib/helpers/populate/getSchemaTypes.js

@@ -22,10 +22,11 @@ const populateModelSymbol = require('../symbols').populateModelSymbol;
  * @param {Schema} schema
  * @param {Object} doc POJO
  * @param {string} path
+ * @param {string[]} [parts] pass in pre-split `path` to avoid extra splitting
  * @api private
  */
 
-module.exports = function getSchemaTypes(model, schema, doc, path) {
+module.exports = function getSchemaTypes(model, schema, doc, path, parts) {
   const pathschema = schema.path(path);
   const topLevelDoc = doc;
   if (pathschema) {
@@ -217,7 +218,7 @@ module.exports = function getSchemaTypes(model, schema, doc, path) {
     }
   }
   // look for arrays
-  const parts = path.split('.');
+  parts = parts || path.split('.');
   for (let i = 0; i < parts.length; ++i) {
     if (parts[i] === '$') {
       // Re: gh-5628, because `schema.path()` doesn't take $ into account.

package/lib/helpers/populate/modelNamesFromRefPath.js

@@ -14,7 +14,11 @@ module.exports = function modelNamesFromRefPath(refPath, doc, populatedPath, mod
     return [];
   }
 
-  if (typeof refPath === 'string' && queryProjection != null && isPathExcluded(queryProjection, refPath)) {
+  if (typeof refPath !== 'string') {
+    throw new MongooseError('`refPath` must be a string or a function that returns a string, got ' + util.inspect(refPath));
+  }
+
+  if (queryProjection != null && isPathExcluded(queryProjection, refPath)) {
     throw new MongooseError('refPath `' + refPath + '` must not be excluded in projection, got ' +
       util.inspect(queryProjection));
   }
@@ -35,7 +39,11 @@ module.exports = function modelNamesFromRefPath(refPath, doc, populatedPath, mod
     // 2nd, 4th, etc. will be numeric props. For example: `[ 'a', '.0.', 'b' ]`
     for (let i = 0; i < chunks.length; i += 2) {
       const chunk = chunks[i];
-      if (_remaining.startsWith(chunk + '.')) {
+      if (
+        _remaining.length >= chunk.length + 1 &&
+        _remaining.charAt(chunk.length) === '.' &&
+        _remaining.slice(0, chunk.length) === chunk
+      ) {
         _refPath += _remaining.substring(0, chunk.length) + chunks[i + 1];
         _remaining = _remaining.substring(chunk.length + 1);
       } else if (i === chunks.length - 1) {

package/lib/helpers/setDefaultsOnInsert.js

@@ -22,7 +22,7 @@ module.exports = function(filter, schema, castedDoc, options) {
   }
 
   const keys = Object.keys(castedDoc || {});
-  const updatedKeys = {};
+  const updatedKeys = Object.create(null);
   const updatedValues = {};
   const numKeys = keys.length;
 
@@ -55,6 +55,20 @@ module.exports = function(filter, schema, castedDoc, options) {
       }
     }
     updatedKeys[path] = true;
+    if (path.indexOf('.') === -1) {
+      continue;
+    }
+    // Also mark all parent prefixes so child-path lookups are O(1).
+    // e.g. 'extraProps.location' also marks 'extraProps'
+    const pieces = schema.paths[path] ?
+      // If the SchemaType already split for us, use that to avoid the extra overhead
+      schema.paths[path].splitPath() :
+      path.split('.');
+    let cur = pieces[0];
+    for (let j = 1; j < pieces.length; ++j) {
+      updatedKeys[cur] = true;
+      cur += '.' + pieces[j];
+    }
   }
 
   if (options?.overwrite && !hasDollarUpdate) {

package/lib/model.js

@@ -21,6 +21,7 @@ const ValidationError = require('./error/validation');
 const VersionError = require('./error/version');
 const ParallelSaveError = require('./error/parallelSave');
 const applyDefaultsHelper = require('./helpers/document/applyDefaults');
+const isInPathsToSave = require('./helpers/document/isInPathsToSave');
 const applyDefaultsToPOJO = require('./helpers/model/applyDefaultsToPOJO');
 const applyEmbeddedDiscriminators = require('./helpers/discriminator/applyEmbeddedDiscriminators');
 const applyHooks = require('./helpers/model/applyHooks');
@@ -73,7 +74,11 @@ const ObjectExpectedError = require('./error/objectExpected');
 const decorateBulkWriteResult = require('./helpers/model/decorateBulkWriteResult');
 const modelCollectionSymbol = Symbol('mongoose#Model#collection');
 const modelDbSymbol = Symbol('mongoose#Model#db');
-const modelSymbol = require('./helpers/symbols').modelSymbol;
+const {
+  arrayAtomicsBackupSymbol,
+  arrayAtomicsSymbol,
+  modelSymbol
+} = require('./helpers/symbols');
 const subclassedSymbol = Symbol('mongoose#Model#subclassed');
 
 const { VERSION_INC, VERSION_WHERE, VERSION_ALL } = Document;
@@ -405,19 +410,14 @@ Model.prototype.$__save = async function $__save(options) {
       // Make sure we don't treat it as a new object on error,
       // since it already exists
       this.$__.inserting = false;
-      const delta = this.$__delta();
-
-      if (options.pathsToSave) {
-        for (const key in delta[1]['$set']) {
-          if (options.pathsToSave.includes(key)) {
-            continue;
-          } else if (options.pathsToSave.some(pathToSave => key.slice(0, pathToSave.length) === pathToSave && key.charAt(pathToSave.length) === '.')) {
-            continue;
-          } else {
-            delete delta[1]['$set'][key];
-          }
-        }
-      }
+      const pathsToSave = Array.isArray(options.pathsToSave) ? options.pathsToSave : null;
+      const pathsToSaveSet = pathsToSave != null ? new Set(pathsToSave) : null;
+      const delta = this.$__delta(pathsToSave, pathsToSaveSet);
+      const unsavedDirty = pathsToSave != null ? (delta != null ? delta[2] : this.$__dirty()) : null;
+      const unsavedDefaultPaths = pathsToSave != null
+        ? Object.keys(this.$__.activePaths.getStatePaths('default')).filter(path => !isInPathsToSave(path, pathsToSaveSet, pathsToSave))
+        : null;
+
       if (delta) {
         where = this.$__where(delta[0]);
         _applyCustomWhere(this, where);
@@ -448,6 +448,7 @@ Model.prototype.$__save = async function $__save(options) {
         // store the modified paths before the document is reset
         this.$__.modifiedPaths = this.modifiedPaths();
         this.$__reset();
+        restoreUnsavedState(this, unsavedDirty, unsavedDefaultPaths);
 
         _setIsNew(this, false);
         result = await this[modelCollectionSymbol].updateOne(where, update, saveOptions).catch(err => {
@@ -526,6 +527,33 @@ Model.prototype.$__save = async function $__save(options) {
   await this._execDocumentPostHooks('save', options);
 };
 
+/*!
+ * Restores $__.activePaths state and any atomics for paths that failed
+ * to save.
+ *
+ * @param {Document} doc
+ * @param {object[]} unsavedDirty
+ * @param {string[]} unsavedDefaultPaths
+ */
+
+function restoreUnsavedState(doc, unsavedDirty, unsavedDefaultPaths) {
+  if (unsavedDirty == null) {
+    return;
+  }
+
+  for (const dirty of unsavedDirty) {
+    doc.$__.activePaths.modify(dirty.path);
+    if (dirty.value?.[arrayAtomicsBackupSymbol]) {
+      dirty.value[arrayAtomicsSymbol] = dirty.value[arrayAtomicsBackupSymbol];
+      dirty.value[arrayAtomicsBackupSymbol] = null;
+    }
+  }
+
+  for (const path of unsavedDefaultPaths) {
+    doc.$__.activePaths.default(path);
+  }
+}
+
 /*!
  * ignore
  */

package/lib/schemaType.js

@@ -170,7 +170,6 @@ SchemaType.prototype.path;
  *     const schematype = schema.path('name');
  *     console.log(schematype.toJSON());
  *
- * @function toJSON
  * @memberOf SchemaType
  * @instance
  * @api public

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "9.2.1",
+  "version": "9.2.2",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -35,6 +35,7 @@
     "acquit-ignore": "0.2.2",
     "acquit-require": "0.1.1",
     "ajv": "8.17.1",
+    "c8": "10.1.3",
     "cheerio": "^1.2",
     "dox": "1.0.0",
     "eslint": "9.39.2",
@@ -54,9 +55,9 @@
     "mongodb-memory-server": "11.0.1",
     "mongodb-runner": "^6.0.0",
     "ncp": "^2.0.0",
-    "c8": "10.1.3",
     "pug": "3.0.3",
     "sinon": "21.0.1",
+    "tstyche": "^6.2.0",
     "typescript": "5.9.3",
     "typescript-eslint": "^8.31.1",
     "uuid": "11.1.0"
@@ -98,7 +99,7 @@
     "test-deno:ci": "npm run test-deno -- --reporter min",
     "test-rs": "START_REPLICA_SET=1 mocha --timeout 30000 --exit ./test/*.test.js",
     "test-rs:ci": "npm run test-rs -- --reporter min",
-    "test:types": "tsc --project test/types/tsconfig.json",
+    "test:types": "tstyche",
     "setup-test-encryption": "node scripts/setup-encryption-tests.js",
     "test-encryption": "mocha --exit ./test/encryption/*.test.js",
     "test-encryption:ci": "npm run test-encryption -- --reporter min",

package/tstyche.config.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://tstyche.org/schemas/config.json",
+  "testFileMatch": [
+    "test/types/*.test.*"
+  ]
+}