mongoose 8.19.1 → 8.19.2

package/lib/connection.js

@@ -28,6 +28,10 @@ const decorateBulkWriteResult = require('./helpers/model/decorateBulkWriteResult
 const arrayAtomicsSymbol = require('./helpers/symbols').arrayAtomicsSymbol;
 const sessionNewDocuments = require('./helpers/symbols').sessionNewDocuments;
 
+// Snapshot the native Date constructor to ensure both Date.now() and new Date() (and other Date methods)
+// bypass timer mocks such as those set up by useFakeTimers().
+const Date = globalThis.Date;
+
 /**
  * A list of authentication mechanisms that don't require a password for authentication.
  * This is used by the authMechanismDoesNotRequirePassword method.

package/lib/helpers/setDefaultsOnInsert.js

@@ -1,5 +1,4 @@
 'use strict';
-const modifiedPaths = require('./common').modifiedPaths;
 const get = require('./get');
 
 /**
@@ -29,21 +28,16 @@ module.exports = function(filter, schema, castedDoc, options) {
   const updatedKeys = {};
   const updatedValues = {};
   const numKeys = keys.length;
-  const modified = {};
 
   let hasDollarUpdate = false;
 
   for (let i = 0; i < numKeys; ++i) {
-    if (keys[i].startsWith('$')) {
-      modifiedPaths(castedDoc[keys[i]], '', modified);
+    if (keys[i].charAt(0) === '$') {
       hasDollarUpdate = true;
+      break;
     }
   }
 
-  if (!hasDollarUpdate) {
-    modifiedPaths(castedDoc, '', modified);
-  }
-
   const paths = Object.keys(filter);
   const numPaths = paths.length;
   for (let i = 0; i < numPaths; ++i) {
@@ -54,7 +48,7 @@ module.exports = function(filter, schema, castedDoc, options) {
       const numConditionKeys = conditionKeys.length;
       let hasDollarKey = false;
       for (let j = 0; j < numConditionKeys; ++j) {
-        if (conditionKeys[j].startsWith('$')) {
+        if (conditionKeys[j].charAt(0) === '$') {
           hasDollarKey = true;
           break;
         }
@@ -64,7 +58,6 @@ module.exports = function(filter, schema, castedDoc, options) {
       }
     }
     updatedKeys[path] = true;
-    modified[path] = true;
   }
 
   if (options && options.overwrite && !hasDollarUpdate) {
@@ -79,16 +72,17 @@ module.exports = function(filter, schema, castedDoc, options) {
       return;
     }
     const def = schemaType.getDefault(null, true);
-    if (isModified(modified, path)) {
-      return;
-    }
     if (typeof def === 'undefined') {
       return;
     }
-    if (schemaType.splitPath().includes('$*')) {
+    const pathPieces = schemaType.splitPath();
+    if (pathPieces.includes('$*')) {
       // Skip defaults underneath maps. We should never do `$setOnInsert` on a path with `$*`
       return;
     }
+    if (isModified(castedDoc, updatedKeys, path, pathPieces, hasDollarUpdate)) {
+      return;
+    }
 
     castedDoc = castedDoc || {};
     castedDoc.$setOnInsert = castedDoc.$setOnInsert || {};
@@ -101,31 +95,66 @@ module.exports = function(filter, schema, castedDoc, options) {
   return castedDoc;
 };
 
-function isModified(modified, path) {
-  if (modified[path]) {
+function isModified(castedDoc, updatedKeys, path, pathPieces, hasDollarUpdate) {
+  // Check if path is in filter (updatedKeys)
+  if (updatedKeys[path]) {
     return true;
   }
 
-  // Is any parent path of `path` modified?
-  const sp = path.split('.');
-  let cur = sp[0];
-  for (let i = 1; i < sp.length; ++i) {
-    if (modified[cur]) {
+  // Check if any parent path is in filter
+  let cur = pathPieces[0];
+  for (let i = 1; i < pathPieces.length; ++i) {
+    if (updatedKeys[cur]) {
       return true;
     }
-    cur += '.' + sp[i];
+    cur += '.' + pathPieces[i];
   }
 
-  // Is any child of `path` modified?
-  const modifiedKeys = Object.keys(modified);
-  if (modifiedKeys.length) {
-    const parentPath = path + '.';
-
-    for (const modifiedPath of modifiedKeys) {
-      if (modifiedPath.slice(0, path.length + 1) === parentPath) {
-        return true;
+  // Check if path is modified in the update
+  if (hasDollarUpdate) {
+    // Check each update operator
+    for (const key in castedDoc) {
+      if (key.charAt(0) === '$') {
+        if (pathExistsInUpdate(castedDoc[key], path, pathPieces)) {
+          return true;
+        }
       }
     }
+  } else {
+    // No dollar operators, check the castedDoc directly
+    if (pathExistsInUpdate(castedDoc, path, pathPieces)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function pathExistsInUpdate(update, targetPath, pathPieces) {
+  if (update == null || typeof update !== 'object') {
+    return false;
+  }
+
+  // Check exact match
+  if (update.hasOwnProperty(targetPath)) {
+    return true;
+  }
+
+  // Check if any parent path exists
+  let cur = pathPieces[0];
+  for (let i = 1; i < pathPieces.length; ++i) {
+    if (update.hasOwnProperty(cur)) {
+      return true;
+    }
+    cur += '.' + pathPieces[i];
+  }
+
+  // Check if any child path exists (e.g., path is "a" and update has "a.b")
+  const prefix = targetPath + '.';
+  for (const key in update) {
+    if (key.startsWith(prefix)) {
+      return true;
+    }
   }
 
   return false;

package/lib/helpers/updateValidators.js

@@ -7,7 +7,6 @@
 const ValidationError = require('../error/validation');
 const cleanPositionalOperators = require('./schema/cleanPositionalOperators');
 const flatten = require('./common').flatten;
-const modifiedPaths = require('./common').modifiedPaths;
 
 /**
  * Applies validators and defaults to update and findOneAndUpdate operations,
@@ -29,7 +28,6 @@ module.exports = function(query, schema, castedDoc, options, callback) {
   const arrayAtomicUpdates = {};
   const numKeys = keys.length;
   let hasDollarUpdate = false;
-  const modified = {};
   let currentUpdate;
   let key;
   let i;
@@ -51,7 +49,6 @@ module.exports = function(query, schema, castedDoc, options, callback) {
         }
         continue;
       }
-      modifiedPaths(castedDoc[keys[i]], '', modified);
       const flat = flatten(castedDoc[keys[i]], null, null, schema);
       const paths = Object.keys(flat);
       const numPaths = paths.length;
@@ -76,7 +73,6 @@ module.exports = function(query, schema, castedDoc, options, callback) {
   }
 
   if (!hasDollarUpdate) {
-    modifiedPaths(castedDoc, '', modified);
     updatedValues = flatten(castedDoc, null, null, schema);
     updatedKeys = Object.keys(updatedValues);
   }

package/lib/schema/map.js

@@ -28,10 +28,14 @@ class SchemaMap extends SchemaType {
       return val;
     }
 
-    const path = options?.path ?? this.path;
+    const path = this.path;
 
     if (init) {
-      const map = new MongooseMap({}, path, doc, this.$__schemaType);
+      const map = new MongooseMap({}, path, doc, this.$__schemaType, options);
+
+      // Use the map's path for passing to nested casts.
+      // If map's parent is a subdocument, use the relative path so nested casts get relative paths.
+      const mapPath = map.$__pathRelativeToParent != null ? map.$__pathRelativeToParent : map.$__path;
 
       if (val instanceof global.Map) {
         for (const key of val.keys()) {
@@ -39,7 +43,7 @@ class SchemaMap extends SchemaType {
           if (_val == null) {
             _val = map.$__schemaType._castNullish(_val);
           } else {
-            _val = map.$__schemaType.cast(_val, doc, true, null, { ...options, path: path + '.' + key });
+            _val = map.$__schemaType.cast(_val, doc, true, null, { ...options, path: mapPath + '.' + key });
           }
           map.$init(key, _val);
         }
@@ -49,7 +53,7 @@ class SchemaMap extends SchemaType {
           if (_val == null) {
             _val = map.$__schemaType._castNullish(_val);
           } else {
-            _val = map.$__schemaType.cast(_val, doc, true, null, { ...options, path: path + '.' + key });
+            _val = map.$__schemaType.cast(_val, doc, true, null, { ...options, path: mapPath + '.' + key });
           }
           map.$init(key, _val);
         }
@@ -58,7 +62,7 @@ class SchemaMap extends SchemaType {
       return map;
     }
 
-    return new MongooseMap(val, path, doc, this.$__schemaType);
+    return new MongooseMap(val, path, doc, this.$__schemaType, options);
   }
 
   clone() {

package/lib/schema/subdocument.js

@@ -203,6 +203,13 @@ SchemaSubdocument.prototype.cast = function(val, doc, init, priorVal, options) {
   if (init) {
     subdoc = new Constructor(void 0, selected, doc, false, { defaults: false });
     delete subdoc.$__.defaults;
+    // Don't pass `path` to $init - it's only for the subdocument itself, not its fields.
+    // For change tracking, subdocuments use relative paths internally.
+    // Here, `options.path` contains the absolute path and is only used by the subdocument constructor, not by $init.
+    if (options.path != null) {
+      options = { ...options };
+      delete options.path;
+    }
     subdoc.$init(val, options);
     const exclude = isExclusive(selected);
     applyDefaults(subdoc, selected, exclude);

package/lib/schemaType.js

@@ -1174,6 +1174,9 @@ SchemaType.prototype.ref = function(ref) {
 
 SchemaType.prototype.getDefault = function(scope, init, options) {
   let ret;
+  if (this.defaultValue == null) {
+    return this.defaultValue;
+  }
   if (typeof this.defaultValue === 'function') {
     if (
       this.defaultValue === Date.now ||

package/lib/types/array/methods/index.js

@@ -611,7 +611,7 @@ const methods = {
 
   pull() {
     const values = [].map.call(arguments, (v, i) => this._cast(v, i, { defaults: false }), this);
-    let cur = this[arrayParentSymbol].get(this[arrayPathSymbol]);
+    let cur = this;
     if (utils.isMongooseArray(cur)) {
       cur = cur.__array;
     }

package/lib/types/map.js

@@ -18,13 +18,29 @@ const populateModelSymbol = require('../helpers/symbols').populateModelSymbol;
  */
 
 class MongooseMap extends Map {
-  constructor(v, path, doc, schemaType) {
+  constructor(v, path, doc, schemaType, options) {
     if (getConstructorName(v) === 'Object') {
       v = Object.keys(v).reduce((arr, key) => arr.concat([[key, v[key]]]), []);
     }
     super(v);
     this.$__parent = doc != null && doc.$__ != null ? doc : null;
-    this.$__path = path;
+
+    // Calculate the full path from the root document
+    // Priority: parent.$basePath (from subdoc) > options.path (from parent map/structure) > path (schema path)
+    // Subdocuments have the most up-to-date path info, so prefer that over options.path
+    if (this.$__parent?.$isSingleNested && this.$__parent.$basePath) {
+      this.$__path = this.$__parent.$basePath + '.' + path;
+      // Performance optimization: store path relative to parent subdocument
+      // to avoid string operations in set() hot path
+      this.$__pathRelativeToParent = path;
+    } else if (options?.path) {
+      this.$__path = options.path;
+      this.$__pathRelativeToParent = null;
+    } else {
+      this.$__path = path;
+      this.$__pathRelativeToParent = null;
+    }
+
     this.$__schemaType = schemaType == null ? new Mixed(path) : schemaType;
 
     this.$__runDeferred();
@@ -37,6 +53,14 @@ class MongooseMap extends Map {
 
     if (value != null && value.$isSingleNested) {
       value.$basePath = this.$__path + '.' + key;
+      // Store the path relative to parent subdoc for efficient markModified()
+      if (this.$__pathRelativeToParent != null) {
+        // Map's parent is a subdocument, store path relative to that subdoc
+        value.$pathRelativeToParent = this.$__pathRelativeToParent + '.' + key;
+      } else {
+        // Map's parent is root document, store the full path
+        value.$pathRelativeToParent = this.$__path + '.' + key;
+      }
     }
   }
 
@@ -136,9 +160,16 @@ class MongooseMap extends Map {
       }
     } else {
       try {
-        const options = this.$__schemaType.$isMongooseDocumentArray || this.$__schemaType.$isSingleNested || this.$__schemaType.$isMongooseArray || this.$__schemaType.$isSchemaMap ?
-          { path: fullPath.call(this) } :
-          null;
+        let options = null;
+        if (this.$__schemaType.$isMongooseDocumentArray || this.$__schemaType.$isSingleNested || this.$__schemaType.$isMongooseArray || this.$__schemaType.$isSchemaMap) {
+          options = { path: fullPath.call(this) };
+          // For subdocuments, also pass the relative path to avoid string operations
+          if (this.$__schemaType.$isSingleNested) {
+            options.pathRelativeToParent = this.$__pathRelativeToParent != null ?
+              this.$__pathRelativeToParent + '.' + key :
+              this.$__path + '.' + key;
+          }
+        }
         value = this.$__schemaType.applySetters(
           value,
           this.$__parent,
@@ -157,13 +188,34 @@ class MongooseMap extends Map {
 
     super.set(key, value);
 
+    // Set relative path on subdocuments to avoid string operations in markModified()
+    // The path should be relative to the parent subdocument (if any), not just the key
+    if (value != null && value.$isSingleNested) {
+      if (this.$__pathRelativeToParent != null) {
+        // Map's parent is a subdocument, store path relative to that subdoc (e.g., 'items.i2')
+        value.$pathRelativeToParent = this.$__pathRelativeToParent + '.' + key;
+      } else {
+        // Map's parent is root document, store just the full path
+        value.$pathRelativeToParent = this.$__path + '.' + key;
+      }
+    }
+
     if (parent != null && parent.$__ != null && !deepEqual(value, priorVal)) {
-      const path = fullPath.call(this);
-      parent.markModified(path);
+      // Optimization: if parent is a subdocument, use precalculated relative path
+      // to avoid building a full path just to strip the parent's prefix
+      let pathToMark;
+      if (this.$__pathRelativeToParent != null) {
+        // Parent is a subdocument - use precalculated relative path (e.g., 'items.i1')
+        pathToMark = this.$__pathRelativeToParent + '.' + key;
+      } else {
+        // Parent is root document or map - use full path
+        pathToMark = fullPath.call(this);
+      }
+      parent.markModified(pathToMark);
       // If overwriting the full document array or subdoc, make sure to clean up any paths that were modified
       // before re: #15108
       if (this.$__schemaType.$isMongooseDocumentArray || this.$__schemaType.$isSingleNested) {
-        cleanModifiedSubpaths(parent, path);
+        cleanModifiedSubpaths(parent, pathToMark);
       }
     }
 

package/lib/types/subdocument.js

@@ -31,7 +31,21 @@ function Subdocument(value, fields, parent, skipId, options) {
   if (options != null && options.path != null) {
     this.$basePath = options.path;
   }
-  Document.call(this, value, fields, skipId, options);
+  if (options != null && options.pathRelativeToParent != null) {
+    this.$pathRelativeToParent = options.pathRelativeToParent;
+  }
+
+  // Don't pass `path` to Document constructor: path is used for storing the
+  // absolute path to this schematype relative to the top-level document, but
+  // subdocuments use relative paths (relative to the parent document) to track changes.
+  // This avoids the subdocument's fields receiving the subdocument's path as options.path.
+  let documentOptions = options;
+  if (options != null && options.path != null) {
+    documentOptions = Object.assign({}, options);
+    delete documentOptions.path;
+  }
+
+  Document.call(this, value, fields, skipId, documentOptions);
 
   delete this.$__.priorDoc;
 }
@@ -123,9 +137,18 @@ Subdocument.prototype.$__fullPath = function(path) {
  */
 
 Subdocument.prototype.$__pathRelativeToParent = function(p) {
+  // If this subdocument has a stored relative path (set by map when subdoc is created),
+  // use it directly to avoid string operations
+  if (this.$pathRelativeToParent != null) {
+    return p == null ? this.$pathRelativeToParent : this.$pathRelativeToParent + '.' + p;
+  }
+
   if (p == null) {
     return this.$basePath;
   }
+  if (!this.$basePath) {
+    return p;
+  }
   return [this.$basePath, p].join('.');
 };
 
@@ -165,9 +188,13 @@ Subdocument.prototype.$isValid = function(path) {
 Subdocument.prototype.markModified = function(path) {
   Document.prototype.markModified.call(this, path);
   const parent = this.$parent();
-  const fullPath = this.$__pathRelativeToParent(path);
 
-  if (parent == null || fullPath == null) {
+  if (parent == null) {
+    return;
+  }
+
+  const pathToMark = this.$__pathRelativeToParent(path);
+  if (pathToMark == null) {
     return;
   }
 
@@ -175,7 +202,8 @@ Subdocument.prototype.markModified = function(path) {
   if (parent.isDirectModified(myPath) || this.isNew) {
     return;
   }
-  this.$__parent.markModified(fullPath, this);
+
+  this.$__parent.markModified(pathToMark, this);
 };
 
 /*!

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "8.19.1",
+  "version": "8.19.2",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",

package/deno.lock

@@ -1,53 +0,0 @@
-{
-  "version": "4",
-  "redirects": {
-    "https://deno.land/std/flags/mod.ts": "https://deno.land/std@0.224.0/flags/mod.ts"
-  },
-  "remote": {
-    "https://deno.land/std@0.224.0/assert/assert_exists.ts": "43420cf7f956748ae6ed1230646567b3593cb7a36c5a5327269279c870c5ddfd",
-    "https://deno.land/std@0.224.0/assert/assertion_error.ts": "ba8752bd27ebc51f723702fac2f54d3e94447598f54264a6653d6413738a8917",
-    "https://deno.land/std@0.224.0/flags/mod.ts": "88553267f34519c8982212185339efdb2d2e62c159ec558f47eb50c8952a6be3"
-  },
-  "workspace": {
-    "packageJson": {
-      "dependencies": [
-        "npm:@mongodb-js/mongodb-downloader@~0.4.2",
-        "npm:acquit-ignore@0.2.1",
-        "npm:acquit-require@0.1.1",
-        "npm:acquit@1.4.0",
-        "npm:ajv@8.17.1",
-        "npm:broken-link-checker@~0.7.8",
-        "npm:cheerio@1.1.2",
-        "npm:dox@1.0.0",
-        "npm:eslint-plugin-markdown@^5.1.0",
-        "npm:eslint-plugin-mocha-no-only@1.2.0",
-        "npm:eslint@9.25.1",
-        "npm:express@^4.19.2",
-        "npm:fs-extra@11.3",
-        "npm:highlight.js@11.11.1",
-        "npm:lodash.isequal@4.5.0",
-        "npm:lodash.isequalwith@4.4.0",
-        "npm:markdownlint-cli2@~0.18.1",
-        "npm:marked@15.0.12",
-        "npm:mkdirp@^3.0.1",
-        "npm:mocha@11.7.1",
-        "npm:moment@2.30.1",
-        "npm:mongodb-memory-server@10.1.4",
-        "npm:mongodb-runner@^5.8.2",
-        "npm:mongodb@6.18",
-        "npm:mpath@0.9.0",
-        "npm:mquery@5.0.0",
-        "npm:ms@2.1.3",
-        "npm:ncp@2",
-        "npm:nyc@15.1.0",
-        "npm:pug@3.0.3",
-        "npm:sift@17.1.3",
-        "npm:sinon@21.0.0",
-        "npm:tsd@0.32.0",
-        "npm:typescript-eslint@^8.31.1",
-        "npm:typescript@5.8.3",
-        "npm:uuid@11.1.0"
-      ]
-    }
-  }
-}