mongoose 7.4.2 → 7.4.4

package/lib/connection.js

@@ -517,49 +517,66 @@ Connection.prototype.startSession = async function startSession(options) {
 Connection.prototype.transaction = function transaction(fn, options) {
   return this.startSession().then(session => {
     session[sessionNewDocuments] = new Map();
-    return session.withTransaction(() => fn(session), options).
+    return session.withTransaction(() => _wrapUserTransaction(fn, session), options).
       then(res => {
         delete session[sessionNewDocuments];
         return res;
       }).
       catch(err => {
-        // If transaction was aborted, we need to reset newly
-        // inserted documents' `isNew`.
-        for (const doc of session[sessionNewDocuments].keys()) {
-          const state = session[sessionNewDocuments].get(doc);
-          if (state.hasOwnProperty('isNew')) {
-            doc.$isNew = state.$isNew;
-          }
-          if (state.hasOwnProperty('versionKey')) {
-            doc.set(doc.schema.options.versionKey, state.versionKey);
-          }
-
-          if (state.modifiedPaths.length > 0 && doc.$__.activePaths.states.modify == null) {
-            doc.$__.activePaths.states.modify = {};
-          }
-          for (const path of state.modifiedPaths) {
-            doc.$__.activePaths.paths[path] = 'modify';
-            doc.$__.activePaths.states.modify[path] = true;
-          }
-
-          for (const path of state.atomics.keys()) {
-            const val = doc.$__getValue(path);
-            if (val == null) {
-              continue;
-            }
-            val[arrayAtomicsSymbol] = state.atomics.get(path);
-          }
-        }
         delete session[sessionNewDocuments];
         throw err;
-      })
-      .finally(() => {
-        session.endSession()
-          .catch(() => {});
+      }).
+      finally(() => {
+        session.endSession().catch(() => {});
       });
   });
 };
 
+/*!
+ * Reset document state in between transaction retries re: gh-13698
+ */
+
+async function _wrapUserTransaction(fn, session) {
+  try {
+    const res = await fn(session);
+    return res;
+  } catch (err) {
+    _resetSessionDocuments(session);
+    throw err;
+  }
+}
+
+/*!
+ * If transaction was aborted, we need to reset newly inserted documents' `isNew`.
+ */
+function _resetSessionDocuments(session) {
+  for (const doc of session[sessionNewDocuments].keys()) {
+    const state = session[sessionNewDocuments].get(doc);
+    if (state.hasOwnProperty('isNew')) {
+      doc.$isNew = state.isNew;
+    }
+    if (state.hasOwnProperty('versionKey')) {
+      doc.set(doc.schema.options.versionKey, state.versionKey);
+    }
+
+    if (state.modifiedPaths.length > 0 && doc.$__.activePaths.states.modify == null) {
+      doc.$__.activePaths.states.modify = {};
+    }
+    for (const path of state.modifiedPaths) {
+      doc.$__.activePaths.paths[path] = 'modify';
+      doc.$__.activePaths.states.modify[path] = true;
+    }
+
+    for (const path of state.atomics.keys()) {
+      const val = doc.$__getValue(path);
+      if (val == null) {
+        continue;
+      }
+      val[arrayAtomicsSymbol] = state.atomics.get(path);
+    }
+  }
+}
+
 /**
  * Helper for `dropCollection()`. Will delete the given collection, including
  * all documents and indexes.

package/lib/cursor/ChangeStream.js

@@ -6,6 +6,12 @@
 
 const EventEmitter = require('events').EventEmitter;
 
+/*!
+ * ignore
+ */
+
+const driverChangeStreamEvents = ['close', 'change', 'end', 'error', 'resumeTokenChanged'];
+
 /*!
  * ignore
  */
@@ -52,7 +58,7 @@ class ChangeStream extends EventEmitter {
           this.closed = true;
         });
 
-        ['close', 'change', 'end', 'error'].forEach(ev => {
+        driverChangeStreamEvents.forEach(ev => {
           this.driverChangeStream.on(ev, data => {
             // Sometimes Node driver still polls after close, so
             // avoid any uncaught exceptions due to closed change streams
@@ -75,7 +81,7 @@ class ChangeStream extends EventEmitter {
       this.closed = true;
     });
 
-    ['close', 'change', 'end', 'error'].forEach(ev => {
+    driverChangeStreamEvents.forEach(ev => {
       this.driverChangeStream.on(ev, data => {
         // Sometimes Node driver still polls after close, so
         // avoid any uncaught exceptions due to closed change streams
@@ -122,6 +128,11 @@ class ChangeStream extends EventEmitter {
     return this.driverChangeStream.next(cb);
   }
 
+  addListener(event, handler) {
+    this._bindEvents();
+    return super.addListener(event, handler);
+  }
+
   on(event, handler) {
     this._bindEvents();
     return super.on(event, handler);

package/lib/helpers/query/selectPopulatedFields.js

@@ -21,12 +21,25 @@ module.exports = function selectPopulatedFields(fields, userProvidedFields, popu
       } else if (userProvidedFields[path] === 0) {
         delete fields[path];
       }
+
+      const refPath = populateOptions[path]?.refPath;
+      if (typeof refPath === 'string') {
+        if (!isPathInFields(userProvidedFields, refPath)) {
+          fields[refPath] = 1;
+        } else if (userProvidedFields[refPath] === 0) {
+          delete fields[refPath];
+        }
+      }
     }
   } else if (isExclusive(fields)) {
     for (const path of paths) {
       if (userProvidedFields[path] == null) {
         delete fields[path];
       }
+      const refPath = populateOptions[path]?.refPath;
+      if (typeof refPath === 'string' && userProvidedFields[refPath] == null) {
+        delete fields[refPath];
+      }
     }
   }
 };

package/lib/helpers/schema/getIndexes.js

@@ -78,7 +78,15 @@ module.exports = function getIndexes(schema) {
           field[prefix + key] = 'text';
           delete options.text;
         } else {
-          const isDescendingIndex = Number(index) === -1;
+          let isDescendingIndex = false;
+          if (index === 'descending' || index === 'desc') {
+            isDescendingIndex = true;
+          } else if (index === 'ascending' || index === 'asc') {
+            isDescendingIndex = false;
+          } else {
+            isDescendingIndex = Number(index) === -1;
+          }
+
           field[prefix + key] = isDescendingIndex ? -1 : 1;
         }
 

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

@@ -2046,6 +2046,14 @@ Schema.prototype.index = function(fields, options) {
     utils.expires(options);
   }
 
+  for (const field of Object.keys(fields)) {
+    if (fields[field] === 'ascending' || fields[field] === 'asc') {
+      fields[field] = 1;
+    } else if (fields[field] === 'descending' || fields[field] === 'desc') {
+      fields[field] = -1;
+    }
+  }
+
   this._indexes.push([fields, options]);
   return this;
 };

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.2",
+  "version": "7.4.4",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",

package/types/document.d.ts

@@ -135,6 +135,7 @@ declare module 'mongoose' {
     errors?: Error.ValidationError;
 
     /** Returns the value of a path. */
+    get<T extends keyof DocType>(path: T, type?: any, options?: any): DocType[T];
     get(path: string, type?: any, options?: any): any;
 
     /**
@@ -157,30 +158,37 @@ declare module 'mongoose' {
     init(obj: AnyObject, opts?: AnyObject): this;
 
     /** Marks a path as invalid, causing validation to fail. */
+    invalidate<T extends keyof DocType>(path: T, errorMsg: string | NativeError, value?: any, kind?: string): NativeError | null;
     invalidate(path: string, errorMsg: string | NativeError, value?: any, kind?: string): NativeError | null;
 
     /** Returns true if `path` was directly set and modified, else false. */
+    isDirectModified<T extends keyof DocType>(path: T | Array<T>): boolean;
     isDirectModified(path: string | Array<string>): boolean;
 
     /** Checks if `path` was explicitly selected. If no projection, always returns true. */
+    isDirectSelected<T extends keyof DocType>(path: T): boolean;
     isDirectSelected(path: string): boolean;
 
     /** Checks if `path` is in the `init` state, that is, it was set by `Document#init()` and not modified since. */
+    isInit<T extends keyof DocType>(path: T): boolean;
     isInit(path: string): boolean;
 
     /**
      * Returns true if any of the given paths are modified, else false. If no arguments, returns `true` if any path
      * in this document is modified.
      */
+    isModified<T extends keyof DocType>(path?: T | Array<T>): boolean;
     isModified(path?: string | Array<string>): boolean;
 
     /** Boolean flag specifying if the document is new. */
     isNew: boolean;
 
     /** Checks if `path` was selected in the source query which initialized this document. */
+    isSelected<T extends keyof DocType>(path: T): boolean;
     isSelected(path: string): boolean;
 
     /** Marks the path as having pending changes to write to the db. */
+    markModified<T extends keyof DocType>(path: T, scope?: any): void;
     markModified(path: string, scope?: any): void;
 
     /** Returns the list of paths that have been modified. */
@@ -216,6 +224,7 @@ declare module 'mongoose' {
     schema: Schema;
 
     /** Sets the value of a path, or many paths. */
+    set<T extends keyof DocType>(path: T, val: DocType[T], type: any, options?: DocumentSetOptions): this;
     set(path: string | Record<string, any>, val: any, type: any, options?: DocumentSetOptions): this;
     set(path: string | Record<string, any>, val: any, options?: DocumentSetOptions): this;
     set(value: string | Record<string, any>): this;
@@ -228,17 +237,20 @@ declare module 'mongoose' {
     toObject<T = Require_id<DocType>>(options?: ToObjectOptions): Require_id<T>;
 
     /** Clears the modified state on the specified path. */
+    unmarkModified<T extends keyof DocType>(path: T): void;
     unmarkModified(path: string): void;
 
     /** Sends an updateOne command with this document `_id` as the query selector. */
     updateOne(update?: UpdateQuery<this> | UpdateWithAggregationPipeline, options?: QueryOptions | null): Query<any, this>;
 
     /** Executes registered validation rules for this document. */
+    validate<T extends keyof DocType>(pathsToValidate?: T | T[], options?: AnyObject): Promise<void>;
     validate(pathsToValidate?: pathsToValidate, options?: AnyObject): Promise<void>;
     validate(options: { pathsToSkip?: pathsToSkip }): Promise<void>;
 
     /** Executes registered validation rules (skipping asynchronous validators) for this document. */
     validateSync(options: { pathsToSkip?: pathsToSkip, [k: string]: any }): Error.ValidationError | null;
+    validateSync<T extends keyof DocType>(pathsToValidate?: T | T[], options?: AnyObject): Error.ValidationError | null;
     validateSync(pathsToValidate?: pathsToValidate, options?: AnyObject): Error.ValidationError | null;
   }
 }

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

@@ -30,7 +30,7 @@ declare module 'mongoose' {
      OptionalPaths<DocDefinition, TSchemaOptions['typeKey']>)]: ObtainDocumentPathType<DocDefinition[K], TSchemaOptions['typeKey']>;
    };
 
-  /**
+   /**
    * @summary Obtains document schema type from Schema instance.
    * @param {Schema} TSchema `typeof` a schema instance.
    * @example
@@ -39,7 +39,7 @@ declare module 'mongoose' {
    * // result
    * type UserType = {userName?: string}
    */
-  type InferSchemaType<TSchema> = IfAny<TSchema, any, ObtainSchemaGeneric<TSchema, 'DocType'>>;
+   export type InferSchemaType<TSchema> = IfAny<TSchema, any, ObtainSchemaGeneric<TSchema, 'DocType'>>;
 
   /**
    * @summary Obtains schema Generic type by using generic alias.
@@ -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,23 +509,59 @@ 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>,
       options: QueryOptions<TRawDocType> & { rawResult: true }
     ): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndUpdate'>;
+    findByIdAndUpdate<ResultDoc = THydratedDocumentType>(
+      id: mongodb.ObjectId | any,
+      update: UpdateQuery<TRawDocType>,
+      options: QueryOptions<TRawDocType> & { includeResultMetadata: true }
+    ): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndUpdate'>;
     findByIdAndUpdate<ResultDoc = THydratedDocumentType>(
       id: mongodb.ObjectId | any,
       update: UpdateQuery<TRawDocType>,
@@ -509,6 +578,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,11 +600,27 @@ 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,
       options: QueryOptions<TRawDocType> & { rawResult: true }
     ): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndReplace'>;
+    findOneAndReplace<ResultDoc = THydratedDocumentType>(
+      filter: FilterQuery<TRawDocType>,
+      replacement: TRawDocType | AnyObject,
+      options: QueryOptions<TRawDocType> & { includeResultMetadata: true }
+    ): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndReplace'>;
     findOneAndReplace<ResultDoc = THydratedDocumentType>(
       filter: FilterQuery<TRawDocType>,
       replacement: TRawDocType | AnyObject,
@@ -538,11 +633,27 @@ 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>,
       options: QueryOptions<TRawDocType> & { rawResult: true }
     ): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndUpdate'>;
+    findOneAndUpdate<ResultDoc = THydratedDocumentType>(
+      filter: FilterQuery<TRawDocType>,
+      update: UpdateQuery<TRawDocType>,
+      options: QueryOptions<TRawDocType> & { includeResultMetadata: true }
+    ): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndUpdate'>;
     findOneAndUpdate<ResultDoc = THydratedDocumentType>(
       filter: FilterQuery<TRawDocType>,
       update: UpdateQuery<TRawDocType>,