mongoose 7.4.1 → 7.4.3

package/lib/document.js

@@ -2216,7 +2216,7 @@ Document.prototype.isModified = function(paths, modifiedPaths) {
     }
 
     if (typeof paths === 'string') {
-      paths = [paths];
+      paths = paths.indexOf(' ') === -1 ? [paths] : paths.split(' ');
     }
 
     for (const path of paths) {
@@ -2619,7 +2619,7 @@ function _evaluateRequiredFunctions(doc) {
  */
 
 function _getPathsToValidate(doc, pathsToValidate, pathsToSkip) {
-  const skipSchemaValidators = {};
+  const doValidateOptions = {};
 
   _evaluateRequiredFunctions(doc);
   // only validate required fields when necessary
@@ -2656,8 +2656,17 @@ function _getPathsToValidate(doc, pathsToValidate, pathsToSkip) {
             !doc.isDirectModified(fullPathToSubdoc) &&
             !doc.$isDefault(fullPathToSubdoc)) {
         paths.add(fullPathToSubdoc);
+        if (doc.$__.pathsToScopes == null) {
+          doc.$__.pathsToScopes = {};
+        }
+        doc.$__.pathsToScopes[fullPathToSubdoc] = subdoc.$isDocumentArrayElement ?
+          subdoc.__parentArray :
+          subdoc.$parent();
 
-        skipSchemaValidators[fullPathToSubdoc] = true;
+        doValidateOptions[fullPathToSubdoc] = { skipSchemaValidators: true };
+        if (subdoc.$isDocumentArrayElement && subdoc.__index != null) {
+          doValidateOptions[fullPathToSubdoc].index = subdoc.__index;
+        }
       }
     }
   }
@@ -2791,7 +2800,7 @@ function _getPathsToValidate(doc, pathsToValidate, pathsToSkip) {
   }
 
   paths = Array.from(paths);
-  return [paths, skipSchemaValidators];
+  return [paths, doValidateOptions];
 }
 
 /*!
@@ -2862,7 +2871,7 @@ Document.prototype.$__validate = function(pathsToValidate, options, callback) {
   const paths = shouldValidateModifiedOnly ?
     pathDetails[0].filter((path) => this.$isModified(path)) :
     pathDetails[0];
-  const skipSchemaValidators = pathDetails[1];
+  const doValidateOptionsByPath = pathDetails[1];
   if (typeof pathsToValidate === 'string') {
     pathsToValidate = pathsToValidate.split(' ');
   }
@@ -2930,7 +2939,7 @@ Document.prototype.$__validate = function(pathsToValidate, options, callback) {
         _this;
 
       const doValidateOptions = {
-        skipSchemaValidators: skipSchemaValidators[path],
+        ...doValidateOptionsByPath[path],
         path: path,
         validateModifiedOnly: shouldValidateModifiedOnly
       };
@@ -2938,8 +2947,8 @@ Document.prototype.$__validate = function(pathsToValidate, options, callback) {
       schemaType.doValidate(val, function(err) {
         if (err) {
           const isSubdoc = schemaType.$isSingleNested ||
-            schemaType.$isArraySubdocument ||
-            schemaType.$isMongooseDocumentArray;
+              schemaType.$isArraySubdocument ||
+              schemaType.$isMongooseDocumentArray;
           if (isSubdoc && err instanceof ValidationError) {
             return --total || complete();
           }

package/lib/helpers/model/castBulkWrite.js

@@ -20,7 +20,6 @@ const setDefaultsOnInsert = require('../setDefaultsOnInsert');
 
 module.exports = function castBulkWrite(originalModel, op, options) {
   const now = originalModel.base.now();
-
   if (op['insertOne']) {
     return (callback) => {
       const model = decideModelByObject(originalModel, op['insertOne']['document']);
@@ -66,7 +65,9 @@ module.exports = function castBulkWrite(originalModel, op, options) {
           applyTimestampsToUpdate(now, createdAt, updatedAt, op['updateOne']['update'], {});
         }
 
-        applyTimestampsToChildren(now, op['updateOne']['update'], model.schema);
+        if (op['updateOne'].timestamps !== false) {
+          applyTimestampsToChildren(now, op['updateOne']['update'], model.schema);
+        }
 
         if (op['updateOne'].setDefaultsOnInsert !== false) {
           setDefaultsOnInsert(op['updateOne']['filter'], model.schema, op['updateOne']['update'], {
@@ -117,8 +118,9 @@ module.exports = function castBulkWrite(originalModel, op, options) {
           const updatedAt = model.schema.$timestamps.updatedAt;
           applyTimestampsToUpdate(now, createdAt, updatedAt, op['updateMany']['update'], {});
         }
-
-        applyTimestampsToChildren(now, op['updateMany']['update'], model.schema);
+        if (op['updateMany'].timestamps !== false) {
+          applyTimestampsToChildren(now, op['updateMany']['update'], model.schema);
+        }
 
         _addDiscriminatorToObject(schema, op['updateMany']['filter']);
 

package/lib/helpers/schema/idGetter.js

@@ -12,6 +12,9 @@ module.exports = function addIdGetter(schema) {
   if (!autoIdGetter) {
     return schema;
   }
+  if (schema.aliases && schema.aliases.id) {
+    return schema;
+  }
   schema.virtual('id').get(idGetter);
   schema.virtual('id').set(idSetter);
 

package/lib/model.js

@@ -77,7 +77,8 @@ const modelSymbol = require('./helpers/symbols').modelSymbol;
 const subclassedSymbol = Symbol('mongoose#Model#subclassed');
 
 const saveToObjectOptions = Object.assign({}, internalToObjectOptions, {
-  bson: true
+  bson: true,
+  flattenObjectIds: false
 });
 
 /**
@@ -3471,18 +3472,22 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
     let validOps = [];
     let validationErrors = [];
     const results = [];
-    for (let i = 0; i < validations.length; ++i) {
-      validations[i]((err) => {
-        if (err == null) {
-          validOps.push(i);
-        } else {
-          validationErrors.push({ index: i, error: err });
-          results[i] = err;
-        }
-        if (--remaining <= 0) {
-          completeUnorderedValidation.call(this);
-        }
-      });
+    if (remaining === 0) {
+      completeUnorderedValidation.call(this);
+    } else {
+      for (let i = 0; i < validations.length; ++i) {
+        validations[i]((err) => {
+          if (err == null) {
+            validOps.push(i);
+          } else {
+            validationErrors.push({ index: i, error: err });
+            results[i] = err;
+          }
+          if (--remaining <= 0) {
+            completeUnorderedValidation.call(this);
+          }
+        });
+      }
     }
 
     validationErrors = validationErrors.

package/lib/queryhelpers.js

@@ -325,7 +325,7 @@ exports.applyPaths = function applyPaths(fields, schema) {
     // If set to 0, we're explicitly excluding the discriminator key. Can't do this for all fields,
     // because we have tests that assert that using `-path` to exclude schema-level `select: true`
     // fields counts as an exclusive projection. See gh-11546
-    if (exclude && type.selected && path === schema.options.discriminatorKey && fields[path] != null && !fields[path]) {
+    if (!exclude && type.selected && path === schema.options.discriminatorKey && fields[path] != null && !fields[path]) {
       delete fields[path];
       return;
     }

package/lib/schema.js

@@ -413,7 +413,25 @@ Schema.prototype._clone = function _clone(Constructor) {
   s.paths = clone(this.paths);
   s.nested = clone(this.nested);
   s.subpaths = clone(this.subpaths);
-  s.singleNestedPaths = clone(this.singleNestedPaths);
+  for (const schemaType of Object.values(s.paths)) {
+    if (schemaType.$isSingleNested) {
+      const path = schemaType.path;
+      for (const key of Object.keys(schemaType.schema.paths)) {
+        s.singleNestedPaths[path + '.' + key] = schemaType.schema.paths[key];
+      }
+      for (const key of Object.keys(schemaType.schema.singleNestedPaths)) {
+        s.singleNestedPaths[path + '.' + key] =
+          schemaType.schema.singleNestedPaths[key];
+      }
+      for (const key of Object.keys(schemaType.schema.subpaths)) {
+        s.singleNestedPaths[path + '.' + key] =
+          schemaType.schema.subpaths[key];
+      }
+      for (const key of Object.keys(schemaType.schema.nested)) {
+        s.singleNestedPaths[path + '.' + key] = 'nested';
+      }
+    }
+  }
   s.childSchemas = gatherChildSchemas(s);
 
   s.virtuals = clone(this.virtuals);

package/lib/utils.js

@@ -630,9 +630,22 @@ function _populateObj(obj) {
  */
 
 exports.getValue = function(path, obj, map) {
-  return mpath.get(path, obj, '_doc', map);
+  return mpath.get(path, obj, getValueLookup, map);
 };
 
+/*!
+ * ignore
+ */
+
+const mapGetterOptions = Object.freeze({ getters: false });
+
+function getValueLookup(obj, part) {
+  const _from = obj?._doc || obj;
+  return _from instanceof Map ?
+    _from.get(part, mapGetterOptions) :
+    _from[part];
+}
+
 /**
  * Sets the value of `obj` at the given `path`.
  *

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "7.4.1",
+  "version": "7.4.3",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -28,10 +28,10 @@
     "sift": "16.0.1"
   },
   "devDependencies": {
-    "@babel/core": "7.22.5",
-    "@babel/preset-env": "7.22.5",
+    "@babel/core": "7.22.9",
+    "@babel/preset-env": "7.22.9",
     "@typescript-eslint/eslint-plugin": "5.61.0",
-    "@typescript-eslint/parser": "5.61.0",
+    "@typescript-eslint/parser": "5.62.0",
     "acquit": "1.3.0",
     "acquit-ignore": "0.2.1",
     "acquit-require": "0.1.1",
@@ -46,7 +46,7 @@
     "crypto-browserify": "3.12.0",
     "dotenv": "16.3.1",
     "dox": "1.0.0",
-    "eslint": "8.44.0",
+    "eslint": "8.46.0",
     "eslint-plugin-markdown": "^3.0.0",
     "eslint-plugin-mocha-no-only": "1.1.1",
     "express": "^4.18.1",
@@ -69,7 +69,7 @@
     "tsd": "0.28.1",
     "typescript": "5.1.6",
     "uuid": "9.0.0",
-    "webpack": "5.88.1"
+    "webpack": "5.88.2"
   },
   "directories": {
     "lib": "./lib/mongoose"

package/types/index.d.ts

@@ -278,7 +278,7 @@ declare module 'mongoose' {
      * Returns a list of indexes that this schema declares, via `schema.index()`
      * or by `index: true` in a path's options.
      */
-    indexes(): Array<IndexDefinition>;
+    indexes(): Array<[IndexDefinition, IndexOptions]>;
 
     /** Gets a schema option. */
     get<K extends keyof SchemaOptions>(key: K): SchemaOptions[K];
@@ -406,8 +406,25 @@ declare module 'mongoose' {
     pre<T extends Aggregate<any>>(method: 'aggregate' | RegExp, fn: PreMiddlewareFunction<T>): this;
     pre<T extends Aggregate<any>>(method: 'aggregate' | RegExp, options: SchemaPreOptions, fn: PreMiddlewareFunction<T>): this;
     /* method insertMany */
-    pre<T = TModelType>(method: 'insertMany' | RegExp, fn: (this: T, next: (err?: CallbackError) => void, docs: any | Array<any>) => void | Promise<void>): this;
-    pre<T = TModelType>(method: 'insertMany' | RegExp, options: SchemaPreOptions, fn: (this: T, next: (err?: CallbackError) => void, docs: any | Array<any>) => void | Promise<void>): this;
+    pre<T = TModelType>(
+      method: 'insertMany' | RegExp,
+      fn: (
+        this: T,
+        next: (err?: CallbackError) => void,
+        docs: any | Array<any>,
+        options?: InsertManyOptions & { lean?: boolean }
+      ) => void | Promise<void>
+    ): this;
+    pre<T = TModelType>(
+      method: 'insertMany' | RegExp,
+      options: SchemaPreOptions,
+      fn: (
+        this: T,
+        next: (err?: CallbackError) => void,
+        docs: any | Array<any>,
+        options?: InsertManyOptions & { lean?: boolean }
+      ) => void | Promise<void>
+    ): this;
 
     /** Object of currently defined query helpers on this schema. */
     query: TQueryHelpers;
@@ -578,24 +595,24 @@ declare module 'mongoose' {
 
   export type SortOrder = -1 | 1 | 'asc' | 'ascending' | 'desc' | 'descending';
 
-  type _UpdateQuery<TSchema> = {
+  type _UpdateQuery<TSchema, AdditionalProperties = AnyObject> = {
     /** @see https://www.mongodb.com/docs/manual/reference/operator/update-field/ */
-    $currentDate?: AnyKeys<TSchema> & AnyObject;
-    $inc?: AnyKeys<TSchema> & AnyObject;
-    $min?: AnyKeys<TSchema> & AnyObject;
-    $max?: AnyKeys<TSchema> & AnyObject;
-    $mul?: AnyKeys<TSchema> & AnyObject;
+    $currentDate?: AnyKeys<TSchema> & AdditionalProperties;
+    $inc?: AnyKeys<TSchema> & AdditionalProperties;
+    $min?: AnyKeys<TSchema> & AdditionalProperties;
+    $max?: AnyKeys<TSchema> & AdditionalProperties;
+    $mul?: AnyKeys<TSchema> & AdditionalProperties;
     $rename?: Record<string, string>;
-    $set?: AnyKeys<TSchema> & AnyObject;
-    $setOnInsert?: AnyKeys<TSchema> & AnyObject;
-    $unset?: AnyKeys<TSchema> & AnyObject;
+    $set?: AnyKeys<TSchema> & AdditionalProperties;
+    $setOnInsert?: AnyKeys<TSchema> & AdditionalProperties;
+    $unset?: AnyKeys<TSchema> & AdditionalProperties;
 
     /** @see https://www.mongodb.com/docs/manual/reference/operator/update-array/ */
-    $addToSet?: AnyKeys<TSchema> & AnyObject;
-    $pop?: AnyKeys<TSchema> & AnyObject;
-    $pull?: AnyKeys<TSchema> & AnyObject;
-    $push?: AnyKeys<TSchema> & AnyObject;
-    $pullAll?: AnyKeys<TSchema> & AnyObject;
+    $addToSet?: AnyKeys<TSchema> & AdditionalProperties;
+    $pop?: AnyKeys<TSchema> & AdditionalProperties;
+    $pull?: AnyKeys<TSchema> & AdditionalProperties;
+    $push?: AnyKeys<TSchema> & AdditionalProperties;
+    $pullAll?: AnyKeys<TSchema> & AdditionalProperties;
 
     /** @see https://www.mongodb.com/docs/manual/reference/operator/update-bitwise/ */
     $bit?: AnyKeys<TSchema>;
@@ -618,6 +635,18 @@ declare module 'mongoose' {
    */
   export type UpdateQuery<T> = _UpdateQuery<T> & AnyObject;
 
+  /**
+   * A more strict form of UpdateQuery that enforces updating only
+   * known top-level properties.
+   * @example
+   * ```ts
+   * function updateUser(_id: mongoose.Types.ObjectId, update: UpdateQueryKnownOnly<IUser>) {
+   *   return User.updateOne({ _id }, update);
+   * }
+   * ```
+   */
+  export type UpdateQueryKnownOnly<T> = _UpdateQuery<T, {}>;
+
   export type FlattenMaps<T> = {
     [K in keyof T]: FlattenProperty<T[K]>;
   };

package/types/inferschematype.d.ts

@@ -86,7 +86,7 @@ type IsPathDefaultUndefined<PathType> = PathType extends { default: undefined }
  * @param {TypeKey} TypeKey A generic of literal string type."Refers to the property used for path type definition".
  */
 type IsPathRequired<P, TypeKey extends string = DefaultTypeKey> =
-  P extends { required: true | [true, string | undefined] } | ArrayConstructor | any[]
+  P extends { required: true | [true, string | undefined] | { isRequired: true } } | ArrayConstructor | any[]
     ? true
     : P extends { required: boolean }
       ? P extends { required: false }

package/types/middlewares.d.ts

@@ -31,8 +31,16 @@ declare module 'mongoose' {
   type SchemaPreOptions = MiddlewareOptions;
   type SchemaPostOptions = MiddlewareOptions;
 
-  type PreMiddlewareFunction<ThisType = any> = (this: ThisType, next: CallbackWithoutResultAndOptionalError) => void | Promise<void>;
-  type PreSaveMiddlewareFunction<ThisType = any> = (this: ThisType, next: CallbackWithoutResultAndOptionalError, opts: SaveOptions) => void | Promise<void>;
+  type PreMiddlewareFunction<ThisType = any> = (
+    this: ThisType,
+    next: CallbackWithoutResultAndOptionalError,
+    opts?: Record<string, any>
+  ) => void | Promise<void>;
+  type PreSaveMiddlewareFunction<ThisType = any> = (
+    this: ThisType,
+    next: CallbackWithoutResultAndOptionalError,
+    opts: SaveOptions
+  ) => void | Promise<void>;
   type PostMiddlewareFunction<ThisType = any, ResType = any> = (this: ThisType, res: ResType, next: CallbackWithoutResultAndOptionalError) => void | Promise<void>;
   type ErrorHandlingMiddlewareFunction<ThisType = any, ResType = any> = (this: ThisType, err: NativeError, res: ResType, next: CallbackWithoutResultAndOptionalError) => void;
   type ErrorHandlingMiddlewareWithOption<ThisType = any, ResType = any> = (this: ThisType, err: NativeError, res: ResType | null, next: CallbackWithoutResultAndOptionalError) => void | Promise<void>;

package/types/models.d.ts

@@ -297,6 +297,17 @@ declare module 'mongoose' {
      * equivalent to `findOne({ _id: id })`. If you want to query by a document's
      * `_id`, use `findById()` instead of `findOne()`.
      */
+    findById<ResultDoc = THydratedDocumentType>(
+      id: any,
+      projection: ProjectionType<TRawDocType> | null | undefined,
+      options: QueryOptions<TRawDocType> & { lean: true }
+    ): QueryWithHelpers<
+      GetLeanResultType<TRawDocType, TRawDocType, 'findOne'> | null,
+      ResultDoc,
+      TQueryHelpers,
+      TRawDocType,
+      'findOne'
+    >;
     findById<ResultDoc = THydratedDocumentType>(
       id: any,
       projection?: ProjectionType<TRawDocType> | null,
@@ -308,6 +319,17 @@ declare module 'mongoose' {
     ): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, TRawDocType, 'findOne'>;
 
     /** Finds one document. */
+    findOne<ResultDoc = THydratedDocumentType>(
+      filter: FilterQuery<TRawDocType>,
+      projection: ProjectionType<TRawDocType> | null | undefined,
+      options: QueryOptions<TRawDocType> & { lean: true }
+    ): QueryWithHelpers<
+      GetLeanResultType<TRawDocType, TRawDocType, 'findOne'> | null,
+      ResultDoc,
+      TQueryHelpers,
+      TRawDocType,
+      'findOne'
+    >;
     findOne<ResultDoc = THydratedDocumentType>(
       filter?: FilterQuery<TRawDocType>,
       projection?: ProjectionType<TRawDocType> | null,
@@ -460,6 +482,17 @@ declare module 'mongoose' {
     >;
 
     /** Creates a `find` query: gets a list of documents that match `filter`. */
+    find<ResultDoc = THydratedDocumentType>(
+      filter: FilterQuery<TRawDocType>,
+      projection: ProjectionType<TRawDocType> | null | undefined,
+      options: QueryOptions<TRawDocType> & { lean: true }
+    ): QueryWithHelpers<
+      GetLeanResultType<TRawDocType, TRawDocType[], 'find'>,
+      ResultDoc,
+      TQueryHelpers,
+      TRawDocType,
+      'find'
+    >;
     find<ResultDoc = THydratedDocumentType>(
       filter: FilterQuery<TRawDocType>,
       projection?: ProjectionType<TRawDocType> | null | undefined,
@@ -476,18 +509,49 @@ declare module 'mongoose' {
     ): QueryWithHelpers<Array<ResultDoc>, ResultDoc, TQueryHelpers, TRawDocType, 'find'>;
 
     /** Creates a `findByIdAndDelete` query, filtering by the given `_id`. */
+    findByIdAndDelete<ResultDoc = THydratedDocumentType>(
+      id: mongodb.ObjectId | any,
+      options: QueryOptions<TRawDocType> & { lean: true }
+    ): QueryWithHelpers<
+      GetLeanResultType<TRawDocType, TRawDocType, 'findOneAndDelete'> | null,
+      ResultDoc,
+      TQueryHelpers,
+      TRawDocType,
+      'findOneAndDelete'
+    >;
     findByIdAndDelete<ResultDoc = THydratedDocumentType>(
       id?: mongodb.ObjectId | any,
       options?: QueryOptions<TRawDocType> | null
     ): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndDelete'>;
 
     /** Creates a `findByIdAndRemove` query, filtering by the given `_id`. */
+    findByIdAndRemove<ResultDoc = THydratedDocumentType>(
+      id: mongodb.ObjectId | any,
+      options: QueryOptions<TRawDocType> & { lean: true }
+    ): QueryWithHelpers<
+      GetLeanResultType<TRawDocType, TRawDocType, 'findOneAndDelete'> | null,
+      ResultDoc,
+      TQueryHelpers,
+      TRawDocType,
+      'findOneAndDelete'
+    >;
     findByIdAndRemove<ResultDoc = THydratedDocumentType>(
       id?: mongodb.ObjectId | any,
       options?: QueryOptions<TRawDocType> | null
     ): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndDelete'>;
 
     /** Creates a `findOneAndUpdate` query, filtering by the given `_id`. */
+    findByIdAndUpdate<ResultDoc = THydratedDocumentType>(
+      id: mongodb.ObjectId | any,
+      update: UpdateQuery<TRawDocType>,
+      options: QueryOptions<TRawDocType> & { lean: true }
+    ): QueryWithHelpers<
+      GetLeanResultType<TRawDocType, TRawDocType, 'findOneAndUpdate'> | null,
+      ResultDoc,
+      TQueryHelpers,
+      TRawDocType,
+      'findOneAndUpdate'
+    >;
     findByIdAndUpdate<ResultDoc = THydratedDocumentType>(
       id: mongodb.ObjectId | any,
       update: UpdateQuery<TRawDocType>,
@@ -509,6 +573,16 @@ declare module 'mongoose' {
     ): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndUpdate'>;
 
     /** Creates a `findOneAndDelete` query: atomically finds the given document, deletes it, and returns the document as it was before deletion. */
+    findOneAndDelete<ResultDoc = THydratedDocumentType>(
+      filter: FilterQuery<TRawDocType>,
+      options: QueryOptions<TRawDocType> & { lean: true }
+    ): QueryWithHelpers<
+      GetLeanResultType<TRawDocType, TRawDocType, 'findOneAndDelete'> | null,
+      ResultDoc,
+      TQueryHelpers,
+      TRawDocType,
+      'findOneAndDelete'
+    >;
     findOneAndDelete<ResultDoc = THydratedDocumentType>(
       filter?: FilterQuery<TRawDocType>,
       options?: QueryOptions<TRawDocType> | null
@@ -521,6 +595,17 @@ declare module 'mongoose' {
     ): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndRemove'>;
 
     /** Creates a `findOneAndReplace` query: atomically finds the given document and replaces it with `replacement`. */
+    findOneAndReplace<ResultDoc = THydratedDocumentType>(
+      filter: FilterQuery<TRawDocType>,
+      replacement: TRawDocType | AnyObject,
+      options: QueryOptions<TRawDocType> & { lean: true }
+    ): QueryWithHelpers<
+      GetLeanResultType<TRawDocType, TRawDocType, 'findOneAndReplace'> | null,
+      ResultDoc,
+      TQueryHelpers,
+      TRawDocType,
+      'findOneAndReplace'
+    >;
     findOneAndReplace<ResultDoc = THydratedDocumentType>(
       filter: FilterQuery<TRawDocType>,
       replacement: TRawDocType | AnyObject,
@@ -538,6 +623,17 @@ declare module 'mongoose' {
     ): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndReplace'>;
 
     /** Creates a `findOneAndUpdate` query: atomically find the first document that matches `filter` and apply `update`. */
+    findOneAndUpdate<ResultDoc = THydratedDocumentType>(
+      filter: FilterQuery<TRawDocType>,
+      update: UpdateQuery<TRawDocType>,
+      options: QueryOptions<TRawDocType> & { lean: true }
+    ): QueryWithHelpers<
+      GetLeanResultType<TRawDocType, TRawDocType, 'findOneAndUpdate'> | null,
+      ResultDoc,
+      TQueryHelpers,
+      TRawDocType,
+      'findOneAndUpdate'
+    >;
     findOneAndUpdate<ResultDoc = THydratedDocumentType>(
       filter: FilterQuery<TRawDocType>,
       update: UpdateQuery<TRawDocType>,

package/types/query.d.ts

@@ -179,6 +179,10 @@ declare module 'mongoose' {
 
   type QueryOpThatReturnsDocument = 'find' | 'findOne' | 'findOneAndUpdate' | 'findOneAndReplace' | 'findOneAndDelete';
 
+  type GetLeanResultType<RawDocType, ResultType, QueryOp> = QueryOp extends QueryOpThatReturnsDocument
+    ? (ResultType extends any[] ? Require_id<FlattenMaps<RawDocType>>[] : Require_id<FlattenMaps<RawDocType>>)
+    : ResultType;
+
   class Query<ResultType, DocType, THelpers = {}, RawDocType = DocType, QueryOp = 'find'> implements SessionOperation {
     _mongooseOptions: MongooseQueryOptions<DocType>;
 
@@ -499,9 +503,19 @@ declare module 'mongoose' {
     j(val: boolean | null): this;
 
     /** Sets the lean option. */
-    lean<LeanResultType = QueryOp extends QueryOpThatReturnsDocument ? (ResultType extends any[] ? Require_id<FlattenMaps<RawDocType>>[] : Require_id<FlattenMaps<RawDocType>>) : ResultType>(
+    lean<
+      LeanResultType = GetLeanResultType<RawDocType, ResultType, QueryOp>
+    >(
       val?: boolean | any
-    ): QueryWithHelpers<ResultType extends null ? LeanResultType | null : LeanResultType, DocType, THelpers, RawDocType, QueryOp>;
+    ): QueryWithHelpers<
+      ResultType extends null
+        ? LeanResultType | null
+        : LeanResultType,
+      DocType,
+      THelpers,
+      RawDocType,
+      QueryOp
+      >;
 
     /** Specifies the maximum number of documents the query will return. */
     limit(val: number): this;