mongoose 8.19.0 → 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/query/castUpdate.js

@@ -379,8 +379,13 @@ function walkUpdatePath(schema, obj, op, options, context, filter, prefix) {
           (utils.isObject(val) && Object.keys(val).length === 0);
       }
     } else {
-      const checkPath = (key === '$each' || key === '$or' || key === '$and' || key === '$in') ?
-        prefix : prefix + key;
+      const isModifier = (key === '$each' || key === '$or' || key === '$and' || key === '$in');
+      if (isModifier && !prefix) {
+        throw new MongooseError('Invalid update: Unexpected modifier "' + key + '" as a key in operator. '
+          + 'Did you mean something like { $addToSet: { fieldName: { $each: [...] } } }? '
+          + 'Modifiers such as "$each", "$or", "$and", "$in" must appear under a valid field path.');
+      }
+      const checkPath = isModifier ? prefix : prefix + key;
       schematype = schema._getSchema(checkPath);
 
       // You can use `$setOnInsert` with immutable keys

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/update/castArrayFilters.js

@@ -7,6 +7,9 @@ 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 updatedPathsByFilter = updatedPathsByArrayFilter(update);
@@ -29,10 +32,6 @@ module.exports = function castArrayFilters(query) {
 };
 
 function _castArrayFilters(arrayFilters, schema, strictQuery, updatedPathsByFilter, query) {
-  if (!Array.isArray(arrayFilters)) {
-    return;
-  }
-
   // Map to store discriminator values for embedded documents in the array filters.
   // This is used to handle cases where array filters target specific embedded document types.
   const discriminatorValueMap = {};

package/lib/helpers/update/decorateUpdateWithVersionKey.js

@@ -1,7 +1,5 @@
 'use strict';
 
-const modifiedPaths = require('./modifiedPaths');
-
 /**
  * Decorate the update with a version key, if necessary
  * @api private
@@ -12,15 +10,26 @@ module.exports = function decorateUpdateWithVersionKey(update, options, versionK
     return;
   }
 
-  const updatedPaths = modifiedPaths(update);
-  if (!updatedPaths[versionKey]) {
-    if (options.overwrite) {
+  if (options.overwrite) {
+    if (!hasKey(update, versionKey)) {
       update[versionKey] = 0;
-    } else {
-      if (!update.$setOnInsert) {
-        update.$setOnInsert = {};
-      }
-      update.$setOnInsert[versionKey] = 0;
     }
+  } else if (
+    !hasKey(update, versionKey) &&
+    !hasKey(update?.$set, versionKey) &&
+    !hasKey(update?.$inc, versionKey) &&
+    !hasKey(update?.$setOnInsert, versionKey)
+  ) {
+    if (!update.$setOnInsert) {
+      update.$setOnInsert = {};
+    }
+    update.$setOnInsert[versionKey] = 0;
   }
 };
+
+function hasKey(obj, key) {
+  if (obj == null || typeof obj !== 'object') {
+    return false;
+  }
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}

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.0",
+  "version": "8.19.2",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -30,7 +30,7 @@
   },
   "devDependencies": {
     "@ark/attest": "0.48.2",
-    "@babel/core": "7.28.3",
+    "@babel/core": "7.28.4",
     "@babel/preset-env": "7.28.3",
     "@mongodb-js/mongodb-downloader": "^0.4.2",
     "@typescript-eslint/eslint-plugin": "^8.19.1",
@@ -57,9 +57,9 @@
     "markdownlint-cli2": "^0.18.1",
     "marked": "15.0.12",
     "mkdirp": "^3.0.1",
-    "mocha": "11.7.2",
+    "mocha": "11.7.4",
     "moment": "2.30.1",
-    "mongodb-memory-server": "10.2.0",
+    "mongodb-memory-server": "10.2.1",
     "mongodb-runner": "^5.8.2",
     "ncp": "^2.0.0",
     "nyc": "15.1.0",
@@ -68,9 +68,9 @@
     "sinon": "21.0.0",
     "stream-browserify": "3.0.0",
     "tsd": "0.33.0",
-    "typescript": "5.9.2",
+    "typescript": "5.9.3",
     "uuid": "11.1.0",
-    "webpack": "5.101.3"
+    "webpack": "5.102.0"
   },
   "directories": {
     "lib": "./lib/mongoose"

package/types/query.d.ts

@@ -10,11 +10,9 @@ declare module 'mongoose' {
    * { age: { $gte: 30 } }
    * ```
    */
-  type RootFilterQuery<T> = FilterQuery<T> | Query<any, any> | Types.ObjectId;
+  type RootFilterQuery<T> = IsItRecordAndNotAny<T> extends true ? FilterQuery<T> | Query<any, any> | Types.ObjectId : FilterQuery<Record<string, any>> | Query<any, any> | Types.ObjectId;
 
-  type FilterQuery<T> = IsItRecordAndNotAny<T> extends true ?
-    ({ [P in keyof T]?: Condition<T[P]>; } & RootQuerySelector<T> & { _id?: Condition<string>; }) :
-    FilterQuery<Record<string, any>>;
+  type FilterQuery<T> = ({ [P in keyof T]?: Condition<T[P]>; } & RootQuerySelector<T> & { _id?: Condition<string>; });
 
   type MongooseBaseQueryOptionKeys =
     | 'context'
@@ -424,18 +422,10 @@ declare module 'mongoose' {
 
     /** Creates a `find` query: gets a list of documents that match `filter`. */
     find(
-      filter: RootFilterQuery<RawDocType>,
+      filter?: RootFilterQuery<RawDocType>,
       projection?: ProjectionType<RawDocType> | null,
       options?: QueryOptions<RawDocType> | null
     ): QueryWithHelpers<Array<DocType>, DocType, THelpers, RawDocType, 'find', TDocOverrides>;
-    find(
-      filter: RootFilterQuery<RawDocType>,
-      projection?: ProjectionType<RawDocType> | null
-    ): QueryWithHelpers<Array<DocType>, DocType, THelpers, RawDocType, 'find', TDocOverrides>;
-    find(
-      filter: RootFilterQuery<RawDocType>
-    ): QueryWithHelpers<Array<DocType>, DocType, THelpers, RawDocType, 'find', TDocOverrides>;
-    find(): QueryWithHelpers<Array<DocType>, DocType, THelpers, RawDocType, 'find', TDocOverrides>;
 
     /** Declares the query a findOne operation. When executed, returns the first found document. */
     findOne(
@@ -443,13 +433,6 @@ declare module 'mongoose' {
       projection?: ProjectionType<RawDocType> | null,
       options?: QueryOptions<RawDocType> | null
     ): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType, 'findOne', TDocOverrides>;
-    findOne(
-      filter?: RootFilterQuery<RawDocType>,
-      projection?: ProjectionType<RawDocType> | null
-    ): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType, 'findOne', TDocOverrides>;
-    findOne(
-      filter?: RootFilterQuery<RawDocType>
-    ): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType, 'findOne', TDocOverrides>;
 
     /** Creates a `findOneAndDelete` query: atomically finds the given document, deletes it, and returns the document as it was before deletion. */
     findOneAndDelete(
@@ -484,13 +467,6 @@ declare module 'mongoose' {
       projection?: ProjectionType<RawDocType> | null,
       options?: QueryOptions<RawDocType> | null
     ): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType, 'findOne', TDocOverrides>;
-    findById(
-      id: mongodb.ObjectId | any,
-      projection?: ProjectionType<RawDocType> | null
-    ): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType, 'findOne', TDocOverrides>;
-    findById(
-      id: mongodb.ObjectId | any
-    ): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType, 'findOne', TDocOverrides>;
 
     /** Creates a `findByIdAndDelete` query, filtering by the given `_id`. */
     findByIdAndDelete(