mongoose 8.13.3 → 8.14.1

package/lib/document.js

@@ -2620,7 +2620,6 @@ Document.prototype.validate = async function validate(pathsToValidate, options)
   if (typeof pathsToValidate === 'function' || typeof options === 'function' || typeof arguments[2] === 'function') {
     throw new MongooseError('Document.prototype.validate() no longer accepts a callback');
   }
-  let parallelValidate;
   this.$op = 'validate';
 
   if (arguments.length === 1) {
@@ -2638,16 +2637,9 @@ Document.prototype.validate = async function validate(pathsToValidate, options)
   if (this.$isSubdocument != null) {
     // Skip parallel validate check for subdocuments
   } else if (this.$__.validating && !_skipParallelValidateCheck) {
-    parallelValidate = new ParallelValidateError(this, {
-      parentStack: options && options.parentStack,
-      conflictStack: this.$__.validating.stack
-    });
+    throw new ParallelValidateError(this);
   } else if (!_skipParallelValidateCheck) {
-    this.$__.validating = new ParallelValidateError(this, { parentStack: options && options.parentStack });
-  }
-
-  if (parallelValidate != null) {
-    throw parallelValidate;
+    this.$__.validating = true;
   }
 
   return new Promise((resolve, reject) => {
@@ -3818,6 +3810,8 @@ Document.prototype.$toObject = function(options, json) {
   let _minimize;
   if (options._calledWithOptions.minimize != null) {
     _minimize = options.minimize;
+  } else if (this.$__schemaTypeOptions?.minimize != null) {
+    _minimize = this.$__schemaTypeOptions.minimize;
   } else if (defaultOptions != null && defaultOptions.minimize != null) {
     _minimize = defaultOptions.minimize;
   } else {

package/lib/helpers/clone.js

@@ -57,7 +57,6 @@ function clone(obj, options, isArrayChild) {
         return clonedDoc;
       }
     }
-    const isSingleNested = obj.$isSingleNested;
 
     if (isPOJO(obj) && obj.$__ != null && obj._doc != null) {
       return obj._doc;
@@ -70,10 +69,6 @@ function clone(obj, options, isArrayChild) {
       ret = obj.toObject(options);
     }
 
-    if (options && options.minimize && !obj.constructor.$__required && isSingleNested && Object.keys(ret).length === 0) {
-      return undefined;
-    }
-
     return ret;
   }
 

package/lib/helpers/populate/assignRawDocsToIdStructure.js

@@ -81,6 +81,8 @@ function assignRawDocsToIdStructure(rawIds, resultDocs, resultOrder, options, re
     if (id?.constructor?.name === 'Binary' && id.sub_type === 4 && typeof id.toUUID === 'function') {
       // Workaround for gh-15315 because Mongoose UUIDs don't use BSON UUIDs yet.
       sid = String(id.toUUID());
+    } else if (id?.constructor?.name === 'Buffer' && id._subtype === 4 && typeof id.toUUID === 'function') {
+      sid = String(id.toUUID());
     } else {
       sid = String(id);
     }

package/lib/model.js

@@ -2307,9 +2307,14 @@ Model.$where = function $where() {
  *
  * #### Example:
  *
- *     A.findOneAndUpdate(conditions, update, options)  // returns Query
- *     A.findOneAndUpdate(conditions, update)           // returns Query
- *     A.findOneAndUpdate()                             // returns Query
+ *     A.findOneAndUpdate(filter, update, options);  // returns Query
+ *     A.findOneAndUpdate(filter, update);           // returns Query
+ *     A.findOneAndUpdate(filter);                   // returns Query
+ *     A.findOneAndUpdate();                         // returns Query
+ *
+ *     // Other supported syntaxes
+ *     // Note that calling `Query#findOneAndUpdate()` with 1 arg will treat the arg as `update`, NOT `filter`
+ *     A.find(filter).findOneAndUpdate(update);
  *
  * #### Note:
  *
@@ -2318,10 +2323,10 @@ Model.$where = function $where() {
  * #### Example:
  *
  *     const query = { name: 'borne' };
- *     Model.findOneAndUpdate(query, { name: 'jason bourne' }, options)
+ *     Model.findOneAndUpdate(query, { name: 'jason bourne' }, options);
  *
  *     // is sent as
- *     Model.findOneAndUpdate(query, { $set: { name: 'jason bourne' }}, options)
+ *     Model.findOneAndUpdate(query, { $set: { name: 'jason bourne' }}, options);
  *
  * #### Note:
  *
@@ -2366,12 +2371,6 @@ Model.findOneAndUpdate = function(conditions, update, options) {
     throw new MongooseError('Model.findOneAndUpdate() no longer accepts a callback');
   }
 
-  if (arguments.length === 1) {
-    update = conditions;
-    conditions = null;
-    options = null;
-  }
-
   let fields;
   if (options) {
     fields = options.fields || options.projection;
@@ -4689,7 +4688,14 @@ function _assign(model, vals, mod, assignmentOpts) {
           if (__val instanceof Document) {
             __val = __val._doc._id;
           }
-          key = String(__val);
+          if (__val?.constructor?.name === 'Binary' && __val.sub_type === 4 && typeof __val.toUUID === 'function') {
+            // Workaround for gh-15315 because Mongoose UUIDs don't use BSON UUIDs yet.
+            key = String(__val.toUUID());
+          } else if (__val?.constructor?.name === 'Buffer' && __val._subtype === 4 && typeof __val.toUUID === 'function') {
+            key = String(__val.toUUID());
+          } else {
+            key = String(__val);
+          }
           if (rawDocs[key]) {
             if (Array.isArray(rawDocs[key])) {
               rawDocs[key].push(val);
@@ -4712,7 +4718,14 @@ function _assign(model, vals, mod, assignmentOpts) {
         if (_val instanceof Document) {
           _val = _val._doc._id;
         }
-        key = String(_val);
+        if (_val?.constructor?.name === 'Binary' && _val.sub_type === 4 && typeof _val.toUUID === 'function') {
+          // Workaround for gh-15315 because Mongoose UUIDs don't use BSON UUIDs yet.
+          key = String(_val.toUUID());
+        } else if (_val?.constructor?.name === 'Buffer' && _val._subtype === 4 && typeof _val.toUUID === 'function') {
+          key = String(_val.toUUID());
+        } else {
+          key = String(_val);
+        }
         if (rawDocs[key]) {
           if (Array.isArray(rawDocs[key])) {
             rawDocs[key].push(val);

package/lib/options/schemaSubdocumentOptions.js

@@ -31,7 +31,7 @@ const opts = require('./propertyOptions');
  *     parentSchema.path('child').schema.options._id; // false
  *
  * @api public
- * @property of
+ * @property _id
  * @memberOf SchemaSubdocumentOptions
  * @type {Function|string}
  * @instance
@@ -39,4 +39,28 @@ const opts = require('./propertyOptions');
 
 Object.defineProperty(SchemaSubdocumentOptions.prototype, '_id', opts);
 
+/**
+ * If set, overwrites the child schema's `minimize` option. In addition, configures whether the entire
+ * subdocument can be minimized out.
+ *
+ * #### Example:
+ *
+ *     const childSchema = Schema({ name: String });
+ *     const parentSchema = Schema({
+ *       child: { type: childSchema, minimize: false }
+ *     });
+ *     const ParentModel = mongoose.model('Parent', parentSchema);
+ *     // Saves `{ child: {} }` to the db. Without `minimize: false`, Mongoose would remove the empty
+ *     // object and save `{}` to the db.
+ *     await ParentModel.create({ child: {} });
+ *
+ * @api public
+ * @property minimize
+ * @memberOf SchemaSubdocumentOptions
+ * @type {Function|string}
+ * @instance
+ */
+
+Object.defineProperty(SchemaSubdocumentOptions.prototype, 'minimize', opts);
+
 module.exports = SchemaSubdocumentOptions;

package/lib/query.js

@@ -3307,17 +3307,18 @@ function prepareDiscriminatorCriteria(query) {
  * - `new`: bool - if true, return the modified document rather than the original. defaults to false (changed in 4.0)
  * - `upsert`: bool - creates the object if it doesn't exist. defaults to false.
  * - `fields`: {Object|String} - Field selection. Equivalent to `.select(fields).findOneAndUpdate()`
- * - `sort`: if multiple docs are found by the conditions, sets the sort order to choose which doc to update
+ * - `sort`: if multiple docs are found by the filter, sets the sort order to choose which doc to update
  * - `maxTimeMS`: puts a time limit on the query - requires mongodb >= 2.6.0
  * - `runValidators`: if true, runs [update validators](https://mongoosejs.com/docs/validation.html#update-validators) on this command. Update validators validate the update operation against the model's schema.
  * - `setDefaultsOnInsert`: `true` by default. If `setDefaultsOnInsert` and `upsert` are true, mongoose will apply the [defaults](https://mongoosejs.com/docs/defaults.html) specified in the model's schema if a new document is created.
  *
  * #### Example:
  *
- *     query.findOneAndUpdate(conditions, update, options)  // returns Query
- *     query.findOneAndUpdate(conditions, update)           // returns Query
- *     query.findOneAndUpdate(update)                       // returns Query
- *     query.findOneAndUpdate()                             // returns Query
+ *     query.findOneAndUpdate(filter, update, options);  // returns Query
+ *     query.findOneAndUpdate(filter, update);           // returns Query
+ *     // Note that `Query#findOneAndUpdate()` with 1 arg treats the first arg as the `update`, NOT the `filter`.
+ *     query.findOneAndUpdate(update);                   // returns Query
+ *     query.findOneAndUpdate();                         // returns Query
  *
  * @method findOneAndUpdate
  * @memberOf Query
@@ -3331,8 +3332,6 @@ function prepareDiscriminatorCriteria(query) {
  * @param {Boolean} [options.multipleCastError] by default, mongoose only returns the first error that occurred in casting the query. Turn on this option to aggregate all the cast errors.
  * @param {Boolean} [options.new=false] By default, `findOneAndUpdate()` returns the document as it was **before** `update` was applied. If you set `new: true`, `findOneAndUpdate()` will instead give you the object after `update` was applied.
  * @param {Object} [options.lean] if truthy, mongoose will return the document as a plain JavaScript object rather than a mongoose document. See [`Query.lean()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.lean()) and [the Mongoose lean tutorial](https://mongoosejs.com/docs/tutorials/lean.html).
- * @param {ClientSession} [options.session=null] The session associated with this query. See [transactions docs](https://mongoosejs.com/docs/transactions.html).
- * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
  * @param {Boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](https://mongoosejs.com/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Note that this allows you to overwrite timestamps. Does nothing if schema-level timestamps are not set.
  * @param {Boolean} [options.returnOriginal=null] An alias for the `new` option. `returnOriginal: false` is equivalent to `new: true`.
  * @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
@@ -3724,6 +3723,99 @@ Query.prototype._findOneAndReplace = async function _findOneAndReplace() {
   });
 };
 
+/**
+ * Finds a single document by its _id field. `findById(id)` is equivalent to
+ * `findOne({ _id: id })`.
+ *
+ * The `id` is cast based on the Schema before sending the command.
+ *
+ * This function triggers the following middleware.
+ *
+ * - `findOne()`
+ *
+ * @method findById
+ * @memberOf Query
+ * @instance
+ * @param {Any} id value of `_id` to query by
+ * @param {Object} [projection] optional fields to return
+ * @param {Object} [options] see [`setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
+ * @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
+ * @return {Query} this
+ * @see findOne https://www.mongodb.com/docs/manual/reference/method/db.collection.findOne/
+ * @see Query.select https://mongoosejs.com/docs/api/query.html#Query.prototype.select()
+ * @api public
+ */
+
+Query.prototype.findById = function(id, projection, options) {
+  return this.findOne({ _id: id }, projection, options);
+};
+
+
+/**
+ * Issues a mongodb findOneAndUpdate command by a document's _id field.
+ * `findByIdAndUpdate(id, ...)` is equivalent to `findOneAndUpdate({ _id: id }, ...)`.
+ *
+ * Finds a matching document, updates it according to the `update` arg,
+ * passing any `options`, and returns the found document (if any).
+ *
+ * This function triggers the following middleware.
+ *
+ * - `findOneAndUpdate()`
+ *
+ * @method findByIdAndUpdate
+ * @memberOf Query
+ * @instance
+ * @param {Any} id value of `_id` to query by
+ * @param {Object} [doc]
+ * @param {Object} [options]
+ * @param {Boolean} [options.includeResultMetadata] if true, returns the full [ModifyResult from the MongoDB driver](https://mongodb.github.io/node-mongodb-native/4.9/interfaces/ModifyResult.html) rather than just the document
+ * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
+ * @param {ClientSession} [options.session=null] The session associated with this query. See [transactions docs](https://mongoosejs.com/docs/transactions.html).
+ * @param {Boolean} [options.multipleCastError] by default, mongoose only returns the first error that occurred in casting the query. Turn on this option to aggregate all the cast errors.
+ * @param {Boolean} [options.new=false] By default, `findOneAndUpdate()` returns the document as it was **before** `update` was applied. If you set `new: true`, `findOneAndUpdate()` will instead give you the object after `update` was applied.
+ * @param {Object} [options.lean] if truthy, mongoose will return the document as a plain JavaScript object rather than a mongoose document. See [`Query.lean()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.lean()) and [the Mongoose lean tutorial](https://mongoosejs.com/docs/tutorials/lean.html).
+ * @param {Boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](https://mongoosejs.com/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Note that this allows you to overwrite timestamps. Does nothing if schema-level timestamps are not set.
+ * @param {Boolean} [options.returnOriginal=null] An alias for the `new` option. `returnOriginal: false` is equivalent to `new: true`.
+ * @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
+ * @param {Boolean} [options.overwriteDiscriminatorKey=false] Mongoose removes discriminator key updates from `update` by default, set `overwriteDiscriminatorKey` to `true` to allow updating the discriminator key
+ * @param {Boolean} [options.overwriteImmutable=false] Mongoose removes updated immutable properties from `update` by default (excluding $setOnInsert). Set `overwriteImmutable` to `true` to allow updating immutable properties using other update operators.
+ * @see Tutorial https://mongoosejs.com/docs/tutorials/findoneandupdate.html
+ * @see findAndModify command https://www.mongodb.com/docs/manual/reference/command/findAndModify/
+ * @see ModifyResult https://mongodb.github.io/node-mongodb-native/4.9/interfaces/ModifyResult.html
+ * @see findOneAndUpdate https://mongodb.github.io/node-mongodb-native/4.9/classes/Collection.html#findOneAndUpdate
+ * @return {Query} this
+ * @api public
+ */
+
+Query.prototype.findByIdAndUpdate = function(id, update, options) {
+  return this.findOneAndUpdate({ _id: id }, update, options);
+};
+
+/**
+ * Issue a MongoDB `findOneAndDelete()` command by a document's _id field.
+ * In other words, `findByIdAndDelete(id)` is a shorthand for
+ * `findOneAndDelete({ _id: id })`.
+ *
+ * This function triggers the following middleware.
+ *
+ * - `findOneAndDelete()`
+ *
+ * @method findByIdAndDelete
+ * @memberOf Query
+ * @param {any} id value of `_id` to query by
+ * @param {Object} [options]
+ * @param {Boolean} [options.includeResultMetadata] if true, returns the full [ModifyResult from the MongoDB driver](https://mongodb.github.io/node-mongodb-native/4.9/interfaces/ModifyResult.html) rather than just the document
+ * @param {ClientSession} [options.session=null] The session associated with this query. See [transactions docs](https://mongoosejs.com/docs/transactions.html).
+ * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
+ * @return {Query} this
+ * @see findAndModify command https://www.mongodb.com/docs/manual/reference/command/findAndModify/
+ * @api public
+ */
+
+Query.prototype.findByIdAndDelete = function(id, options) {
+  return this.findOneAndDelete({ _id: id }, options);
+};
+
 /**
  * Support the `new` option as an alternative to `returnOriginal` for backwards
  * compat.
@@ -4429,10 +4521,12 @@ Query.prototype.exec = async function exec(op) {
       str = str.slice(0, 60) + '...';
     }
     const err = new MongooseError('Query was already executed: ' + str);
-    err.originalStack = this._executionStack;
+    if (!this.model.base.options.skipOriginalStackTraces) {
+      err.originalStack = this._executionStack;
+    }
     throw err;
   } else {
-    this._executionStack = new Error().stack;
+    this._executionStack = this.model.base.options.skipOriginalStackTraces ? true : new Error().stack;
   }
 
   let skipWrappedFunction = null;

package/lib/schema/map.js

@@ -23,12 +23,12 @@ class SchemaMap extends SchemaType {
     return SchemaType.set(option, value);
   }
 
-  cast(val, doc, init) {
+  cast(val, doc, init, prev, options) {
     if (val instanceof MongooseMap) {
       return val;
     }
 
-    const path = this.path;
+    const path = options?.path ?? this.path;
 
     if (init) {
       const map = new MongooseMap({}, path, doc, this.$__schemaType);

package/lib/schema/subdocument.js

@@ -90,6 +90,7 @@ function _createConstructor(schema, baseClass, options) {
   _embedded.prototype = Object.create(proto);
   _embedded.prototype.$__setSchema(schema);
   _embedded.prototype.constructor = _embedded;
+  _embedded.prototype.$__schemaTypeOptions = options;
   _embedded.$__required = options?.required;
   _embedded.base = schema.base;
   _embedded.schema = schema;

package/lib/types/buffer.js

@@ -5,6 +5,7 @@
 'use strict';
 
 const Binary = require('bson').Binary;
+const UUID = require('bson').UUID;
 const utils = require('../utils');
 
 /**
@@ -207,6 +208,22 @@ MongooseBuffer.mixin.toBSON = function() {
   return new Binary(this, this._subtype || 0);
 };
 
+/**
+ * Converts this buffer to a UUID. Throws an error if subtype is not 4.
+ *
+ * @return {UUID}
+ * @api public
+ * @method toUUID
+ * @memberOf MongooseBuffer
+ */
+
+MongooseBuffer.mixin.toUUID = function() {
+  if (this._subtype !== 4) {
+    throw new Error('Cannot convert a Buffer with subtype ' + this._subtype + ' to a UUID');
+  }
+  return new UUID(this);
+};
+
 /**
  * Determines if this buffer is equals to `other` buffer
  *

package/lib/types/map.js

@@ -136,7 +136,7 @@ class MongooseMap extends Map {
       }
     } else {
       try {
-        const options = this.$__schemaType.$isMongooseDocumentArray || this.$__schemaType.$isSingleNested ?
+        const options = this.$__schemaType.$isMongooseDocumentArray || this.$__schemaType.$isSingleNested || this.$__schemaType.$isMongooseArray || this.$__schemaType.$isSchemaMap ?
           { path: fullPath.call(this) } :
           null;
         value = this.$__schemaType.applySetters(

package/lib/types/subdocument.js

@@ -412,6 +412,25 @@ if (util.inspect.custom) {
   Subdocument.prototype[util.inspect.custom] = Subdocument.prototype.inspect;
 }
 
+/**
+ * Override `$toObject()` to handle minimizing the whole path. Should not minimize if schematype-level minimize
+ * is set to false re: gh-11247, gh-14058, gh-14151
+ */
+
+Subdocument.prototype.$toObject = function $toObject(options, json) {
+  const ret = Document.prototype.$toObject.call(this, options, json);
+
+  // If `$toObject()` was called recursively, respect the minimize option, including schematype level minimize.
+  // If minimize is set, then we can minimize out the whole object.
+  if (Object.keys(ret).length === 0 && options?._calledWithOptions != null) {
+    const minimize = options._calledWithOptions?.minimize ?? this?.$__schemaTypeOptions?.minimize ?? options.minimize;
+    if (minimize && !this.constructor.$__required) {
+      return undefined;
+    }
+  }
+  return ret;
+};
+
 /**
  * Registers remove event listeners for triggering
  * on subdocuments.

package/lib/validOptions.js

@@ -29,6 +29,7 @@ const VALID_OPTIONS = Object.freeze([
   'sanitizeProjection',
   'selectPopulatedPaths',
   'setDefaultsOnInsert',
+  'skipOriginalStackTraces',
   'strict',
   'strictPopulate',
   'strictQuery',

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "8.13.3",
+  "version": "8.14.1",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -22,7 +22,7 @@
   "dependencies": {
     "bson": "^6.10.3",
     "kareem": "2.6.3",
-    "mongodb": "~6.15.0",
+    "mongodb": "~6.16.0",
     "mpath": "0.9.0",
     "mquery": "5.0.0",
     "ms": "2.1.3",

package/types/document.d.ts

@@ -18,7 +18,7 @@ declare module 'mongoose' {
    * *  TQueryHelpers - Object with any helpers that should be mixed into the Query type
    * *  DocType - the type of the actual Document created
    */
-  class Document<T = unknown, TQueryHelpers = any, DocType = any> {
+  class Document<T = unknown, TQueryHelpers = any, DocType = any, TVirtuals = Record<string, any>> {
     constructor(doc?: any);
 
     /** This documents _id. */
@@ -256,6 +256,7 @@ declare module 'mongoose' {
     set(value: string | Record<string, any>): this;
 
     /** The return value of this method is used in calls to JSON.stringify(doc). */
+    toJSON(options: ToObjectOptions & { virtuals: true }): Default__v<Require_id<DocType & TVirtuals>>;
     toJSON(options?: ToObjectOptions & { flattenMaps?: true, flattenObjectIds?: false }): FlattenMaps<Default__v<Require_id<DocType>>>;
     toJSON(options: ToObjectOptions & { flattenObjectIds: false }): FlattenMaps<Default__v<Require_id<DocType>>>;
     toJSON(options: ToObjectOptions & { flattenObjectIds: true }): ObjectIdToString<FlattenMaps<Default__v<Require_id<DocType>>>>;
@@ -269,6 +270,7 @@ declare module 'mongoose' {
     toJSON<T = Default__v<Require_id<DocType>>>(options: ToObjectOptions & { flattenMaps: false; flattenObjectIds: true }): ObjectIdToString<T>;
 
     /** Converts this document into a plain-old JavaScript object ([POJO](https://masteringjs.io/tutorials/fundamentals/pojo)). */
+    toObject(options: ToObjectOptions & { virtuals: true }): Default__v<Require_id<DocType & TVirtuals>>;
     toObject(options?: ToObjectOptions): Default__v<Require_id<DocType>>;
     toObject<T>(options?: ToObjectOptions): Default__v<Require_id<T>>;
 

package/types/index.d.ts

@@ -90,7 +90,8 @@ declare module 'mongoose' {
   HydratedDocument<
   InferSchemaType<TSchema>,
   ObtainSchemaGeneric<TSchema, 'TVirtuals'> & ObtainSchemaGeneric<TSchema, 'TInstanceMethods'>,
-  ObtainSchemaGeneric<TSchema, 'TQueryHelpers'>
+  ObtainSchemaGeneric<TSchema, 'TQueryHelpers'>,
+  ObtainSchemaGeneric<TSchema, 'TVirtuals'>
   >,
   TSchema
   > & ObtainSchemaGeneric<TSchema, 'TStaticMethods'>;
@@ -146,16 +147,17 @@ declare module 'mongoose' {
   export type HydratedDocument<
     DocType,
     TOverrides = {},
-    TQueryHelpers = {}
+    TQueryHelpers = {},
+    TVirtuals = {}
   > = IfAny<
     DocType,
     any,
     TOverrides extends Record<string, never> ?
-      Document<unknown, TQueryHelpers, DocType> & Default__v<Require_id<DocType>> :
+      Document<unknown, TQueryHelpers, DocType, TVirtuals> & Default__v<Require_id<DocType>> :
       IfAny<
         TOverrides,
-        Document<unknown, TQueryHelpers, DocType> & Default__v<Require_id<DocType>>,
-        Document<unknown, TQueryHelpers, DocType> & MergeType<
+        Document<unknown, TQueryHelpers, DocType, TVirtuals> & Default__v<Require_id<DocType>>,
+        Document<unknown, TQueryHelpers, DocType, TVirtuals> & MergeType<
           Default__v<Require_id<DocType>>,
           TOverrides
         >
@@ -195,8 +197,9 @@ declare module 'mongoose' {
 
   export type HydratedDocumentFromSchema<TSchema extends Schema> = HydratedDocument<
   InferSchemaType<TSchema>,
-  ObtainSchemaGeneric<TSchema, 'TInstanceMethods'>,
-  ObtainSchemaGeneric<TSchema, 'TQueryHelpers'>
+  ObtainSchemaGeneric<TSchema, 'TInstanceMethods'> & ObtainSchemaGeneric<TSchema, 'TVirtuals'>,
+  ObtainSchemaGeneric<TSchema, 'TQueryHelpers'>,
+  ObtainSchemaGeneric<TSchema, 'TVirtuals'>
   >;
 
   export interface TagSet {
@@ -269,7 +272,7 @@ declare module 'mongoose' {
       ObtainDocumentType<any, RawDocType, ResolveSchemaOptions<TSchemaOptions>>,
       ResolveSchemaOptions<TSchemaOptions>
     >,
-    THydratedDocumentType = HydratedDocument<FlatRecord<DocType>, TVirtuals & TInstanceMethods>
+    THydratedDocumentType = HydratedDocument<FlatRecord<DocType>, TVirtuals & TInstanceMethods, {}, TVirtuals>
   >
     extends events.EventEmitter {
     /**
@@ -436,6 +439,7 @@ declare module 'mongoose' {
     ): this;
     // this = Document
     pre<T = THydratedDocumentType>(method: 'save', fn: PreSaveMiddlewareFunction<T>): this;
+    pre<T = THydratedDocumentType, U = RawDocType>(method: 'init', fn: (this: T, doc: U) => void): this;
     pre<T = THydratedDocumentType>(method: MongooseDistinctDocumentMiddleware|MongooseDistinctDocumentMiddleware[], fn: PreMiddlewareFunction<T>): this;
     pre<T = THydratedDocumentType>(method: MongooseDistinctDocumentMiddleware|MongooseDistinctDocumentMiddleware[], options: SchemaPreOptions, fn: PreMiddlewareFunction<T>): this;
     pre<T = THydratedDocumentType>(

package/types/inferrawdoctype.d.ts

@@ -22,7 +22,7 @@ declare module 'mongoose' {
 
   /**
    * @summary Obtains schema Path type.
-   * @description Obtains Path type by separating path type from other options and calling {@link ResolvePathType}
+   * @description Obtains Path type by separating path type from other options and calling {@link ResolveRawPathType}
    * @param {PathValueType} PathValueType Document definition path type.
    * @param {TypeKey} TypeKey A generic refers to document definition.
    */
@@ -61,14 +61,14 @@ declare module 'mongoose' {
             // so we can directly obtain its path type.
             ObtainRawDocumentPathType<Item, TypeKey>[] :
             // If the type key isn't callable, then this is an array of objects, in which case
-            // we need to call ObtainDocumentType to correctly infer its type.
-            Array<ObtainDocumentType<Item, any, { typeKey: TypeKey }>> :
+            // we need to call InferRawDocType to correctly infer its type.
+            Array<InferRawDocType<Item>> :
           IsSchemaTypeFromBuiltinClass<Item> extends true ?
             ObtainRawDocumentPathType<Item, TypeKey>[] :
             IsItRecordAndNotAny<Item> extends true ?
               Item extends Record<string, never> ?
                 ObtainRawDocumentPathType<Item, TypeKey>[] :
-                Array<ObtainDocumentType<Item, any, { typeKey: TypeKey }>> :
+                Array<InferRawDocType<Item>> :
               ObtainRawDocumentPathType<Item, TypeKey>[]
       >:
       PathValueType extends ReadonlyArray<infer Item> ?
@@ -77,13 +77,13 @@ declare module 'mongoose' {
           Item extends Record<TypeKey, any> ?
             Item[TypeKey] extends Function | String ?
               ObtainRawDocumentPathType<Item, TypeKey>[] :
-              ObtainDocumentType<Item, any, { typeKey: TypeKey }>[]:
+              InferRawDocType<Item>[]:
             IsSchemaTypeFromBuiltinClass<Item> extends true ?
               ObtainRawDocumentPathType<Item, TypeKey>[] :
               IsItRecordAndNotAny<Item> extends true ?
                 Item extends Record<string, never> ?
                   ObtainRawDocumentPathType<Item, TypeKey>[] :
-                  Array<ObtainDocumentType<Item, any, { typeKey: TypeKey }>> :
+                  Array<InferRawDocType<Item>> :
                 ObtainRawDocumentPathType<Item, TypeKey>[]
         >:
         PathValueType extends StringSchemaDefinition ? PathEnumOrString<Options['enum']> :
@@ -114,6 +114,6 @@ declare module 'mongoose' {
                                                           IfEquals<PathValueType, ObjectConstructor> extends true ? any:
                                                             IfEquals<PathValueType, {}> extends true ? any:
                                                               PathValueType extends typeof SchemaType ? PathValueType['prototype'] :
-                                                                PathValueType extends Record<string, any> ? ObtainDocumentType<PathValueType, any, { typeKey: TypeKey }> :
+                                                                PathValueType extends Record<string, any> ? InferRawDocType<PathValueType> :
                                                                   unknown;
 }

package/types/middlewares.d.ts

@@ -3,7 +3,7 @@ declare module 'mongoose' {
 
   type MongooseQueryAndDocumentMiddleware = 'updateOne' | 'deleteOne';
 
-  type MongooseDistinctDocumentMiddleware = 'save' | 'init' | 'validate';
+  type MongooseDistinctDocumentMiddleware = 'save' | 'validate';
   type MongooseDocumentMiddleware = MongooseDistinctDocumentMiddleware | MongooseQueryAndDocumentMiddleware;
 
   type MongooseRawResultQueryMiddleware = 'findOneAndUpdate' | 'findOneAndReplace' | 'findOneAndDelete';

package/types/models.d.ts

@@ -263,7 +263,7 @@ declare module 'mongoose' {
     TQueryHelpers = {},
     TInstanceMethods = {},
     TVirtuals = {},
-    THydratedDocumentType = HydratedDocument<TRawDocType, TVirtuals & TInstanceMethods, TQueryHelpers>,
+    THydratedDocumentType = HydratedDocument<TRawDocType, TVirtuals & TInstanceMethods, TQueryHelpers, TVirtuals>,
     TSchema = any> extends
     NodeJS.EventEmitter,
     AcceptsDiscriminator,

package/types/mongooseoptions.d.ts

@@ -215,5 +215,13 @@ declare module 'mongoose' {
      * to their database property names. Defaults to false.
      */
     translateAliases?: boolean;
+
+    /**
+     * Mongoose queries currently store an `_executionStack` property that stores the stack trace
+     * of where the query was originally executed for debugging `Query was already executed` errors.
+     * This behavior can cause performance issues with bundlers and source maps. Set this option to
+     * `true` to disable Mongoose query stack trace collection.
+     */
+    skipOriginalStackTraces?: boolean;
   }
 }

package/types/query.d.ts

@@ -466,10 +466,14 @@ declare module 'mongoose' {
       options: QueryOptions<DocType> & { upsert: true } & ReturnsNewDoc
     ): QueryWithHelpers<DocType, DocType, THelpers, RawDocType, 'findOneAndUpdate', TDocOverrides>;
     findOneAndUpdate(
-      filter?: RootFilterQuery<RawDocType>,
-      update?: UpdateQuery<RawDocType>,
+      filter: RootFilterQuery<RawDocType>,
+      update: UpdateQuery<RawDocType>,
       options?: QueryOptions<DocType> | null
     ): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType, 'findOneAndUpdate', TDocOverrides>;
+    findOneAndUpdate(
+      update: UpdateQuery<RawDocType>
+    ): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType, 'findOneAndUpdate', TDocOverrides>;
+    findOneAndUpdate(): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType, 'findOneAndUpdate', TDocOverrides>;
 
     /** Declares the query a findById operation. When executed, returns the document with the given `_id`. */
     findById(