mongoose 9.11.0 → 9.11.2

package/lib/aggregate.js

@@ -1174,7 +1174,7 @@ Aggregate.prototype.then = function(resolve, reject) {
 /**
  * Executes the aggregation returning a `Promise` which will be
  * resolved with either the doc(s) or rejected with the error.
- * Like [`.then()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.then), but only takes a rejection handler.
+ * Like [`.then()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.then()), but only takes a rejection handler.
  * Compatible with `await`.
  *
  * @param {Function} [reject]

package/lib/cast.js

@@ -11,6 +11,7 @@ const cast$expr = require('./helpers/query/cast$expr');
 const castString = require('./cast/string');
 const castTextSearch = require('./schema/operators/text');
 const get = require('./helpers/get');
+const getDiscriminatorValueFromFilter = require('./helpers/discriminator/getDiscriminatorValueFromFilter');
 const getSchemaDiscriminatorByValue = require('./helpers/discriminator/getSchemaDiscriminatorByValue');
 const isOperator = require('./helpers/query/isOperator');
 const util = require('util');
@@ -43,7 +44,8 @@ module.exports = function cast(schema, obj, options, context) {
   }
 
   if (schema?.discriminators != null && obj[schema.options.discriminatorKey] != null) {
-    schema = getSchemaDiscriminatorByValue(schema, obj[schema.options.discriminatorKey]) || schema;
+    const discriminatorValue = getDiscriminatorValueFromFilter(obj[schema.options.discriminatorKey]);
+    schema = getSchemaDiscriminatorByValue(schema, discriminatorValue) || schema;
   }
 
   const paths = Object.keys(obj);
@@ -134,18 +136,10 @@ module.exports = function cast(schema, obj, options, context) {
           if (_schematype?.schema?.discriminators != null &&
             discriminatorKey != null &&
             pathLastHalf !== discriminatorKey) {
-            const discriminatorVal = get(obj, pathFirstHalf + '.' + discriminatorKey);
+            const discriminatorVal = getDiscriminatorValueFromFilter(get(obj, pathFirstHalf + '.' + discriminatorKey));
             const discriminators = _schematype.schema.discriminators;
             if (typeof discriminatorVal === 'string' && discriminators[discriminatorVal] != null) {
-
               schematype = discriminators[discriminatorVal].path(pathLastHalf);
-            } else if (discriminatorVal != null &&
-              Object.keys(discriminatorVal).length === 1 &&
-              Array.isArray(discriminatorVal.$in) &&
-              discriminatorVal.$in.length === 1 &&
-              typeof discriminatorVal.$in[0] === 'string' &&
-              discriminators[discriminatorVal.$in[0]] != null) {
-              schematype = discriminators[discriminatorVal.$in[0]].path(pathLastHalf);
             }
           }
         }
@@ -329,15 +323,11 @@ module.exports = function cast(schema, obj, options, context) {
               if (nested && schematype?.schema != null) {
                 cast(schematype.schema, nested, options, context);
               } else if (nested && schematype?.$isMongooseArray) {
-                if (utils.isPOJO(nested) && nested.$not != null) {
-                  cast(schema, nested, options, context);
-                } else {
-                  val[$cond] = schematype.castForQuery(
-                    $cond,
-                    nested,
-                    context
-                  );
-                }
+                val[$cond] = schematype.castForQuery(
+                  $cond,
+                  nested,
+                  context
+                );
               }
             } else if ($cond === '$not') {
               if (nested && schematype) {

package/lib/cursor/queryCursor.js

@@ -170,6 +170,9 @@ QueryCursor.prototype.getDriverCursor = async function getDriverCursor() {
   if (this.cursor) {
     return this.cursor;
   }
+  if (this._error) {
+    throw this._error;
+  }
 
   await once(this, 'cursor');
   return this.cursor;
@@ -278,7 +281,7 @@ QueryCursor.prototype._destroy = function _destroy(_err, callback) {
 
   waitForCursor
     .then(() => {
-      this.cursor.close();
+      return this.cursor.close();
     })
     .then(() => {
       this._closed = true;

package/lib/document.js

@@ -63,6 +63,7 @@ const scopeSymbol = require('./helpers/symbols').scopeSymbol;
 const schemaMixedSymbol = require('./schema/symbols').schemaMixedSymbol;
 const getDeepestSubdocumentForPath = require('./helpers/document/getDeepestSubdocumentForPath');
 const sessionNewDocuments = require('./helpers/symbols').sessionNewDocuments;
+const toObjectRecursive = require('./helpers/document/toObjectRecursive');
 
 let DocumentArray;
 let Embedded;
@@ -75,7 +76,7 @@ const VERSION_ALL = VERSION_WHERE | VERSION_INC;
 
 /**
  * The core Mongoose document constructor. You should not call this directly,
- * the Mongoose [Model constructor](./api/model.html#Model) calls this for you.
+ * the Mongoose [Model constructor](./api/model.html#Model()) calls this for you.
  *
  * @param {object} obj the values to set
  * @param {object} [fields] optional object containing the fields which were selected in the query returning this document and any populated paths data
@@ -878,9 +879,9 @@ function init(self, obj, doc, opts, prefix) {
  *
  * #### Valid options:
  *
- *  - same as in [Model.updateOne](https://mongoosejs.com/docs/api/model.html#Model.updateOne)
+ *  - same as in [Model.updateOne](https://mongoosejs.com/docs/api/model.html#Model.updateOne())
  *
- * @see Model.updateOne https://mongoosejs.com/docs/api/model.html#Model.updateOne
+ * @see Model.updateOne https://mongoosejs.com/docs/api/model.html#Model.updateOne()
  * @param {object} update
  * @param {object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
  * @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).
@@ -1253,9 +1254,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
 
   if (pathType === 'nested' && val) {
     if (typeof val === 'object' && val != null) {
-      if (val.$__ != null) {
-        val = val.toObject(internalToObjectOptions);
-      }
+      val = toObjectRecursive(val, internalToObjectOptions);
       if (val == null) {
         this.invalidate(path, new MongooseError.CastError('Object', val, path));
         return this;
@@ -3792,7 +3791,7 @@ function _checkImmutableSubpaths(subdoc, schematype, priorVal) {
 }
 
 /**
- * Saves this document by inserting a new document into the database if [document.isNew](https://mongoosejs.com/docs/api/document.html#Document.prototype.isNew()) is `true`,
+ * Saves this document by inserting a new document into the database if [document.isNew](https://mongoosejs.com/docs/api/document.html#Document.prototype.isNew) is `true`,
  * or sends an [updateOne](https://mongoosejs.com/docs/api/document.html#Document.prototype.updateOne()) operation **only** with the modifications to the database, it does not replace the whole document in the latter case.
  *
  * #### Example:
@@ -3825,7 +3824,7 @@ function _checkImmutableSubpaths(subdoc, schematype, priorVal) {
  * @method save
  * @memberOf Document
  * @instance
- * @throws {DocumentNotFoundError} if this [save updates an existing document](https://mongoosejs.com/docs/api/document.html#Document.prototype.isNew()) but the document doesn't exist in the database. For example, you will get this error if the document is [deleted between when you retrieved the document and when you saved it](documents.html#updating).
+ * @throws {DocumentNotFoundError} if this [save updates an existing document](https://mongoosejs.com/docs/api/document.html#Document.prototype.isNew) but the document doesn't exist in the database. For example, you will get this error if the document is [deleted between when you retrieved the document and when you saved it](documents.html#updating).
  * @return {Promise}
  * @api public
  * @see middleware https://mongoosejs.com/docs/middleware.html
@@ -4072,7 +4071,7 @@ Document.prototype.$__setSchema = function(schema) {
     this.schema = schema;
   }
   this.$__schema = schema;
-  this.$__middleware = schema._getDocumentMiddleware();
+  this.$__middleware = schema._getDocumentMiddleware(this.$isSubdocument);
   this[documentSchemaSymbol] = schema;
 };
 
@@ -4265,9 +4264,11 @@ Document.prototype.$toObject = function(options, json) {
     ?? false;
 
   let ret;
-  if (hasOnlyPrimitiveValues && !options.flattenObjectIds) {
+  if (hasOnlyPrimitiveValues && !options.flattenObjectIds && !options.flattenDecimals) {
     // Fast path: if we don't have any nested objects or arrays, we only need a
-    // shallow clone.
+    // shallow clone. Skipped for `flattenObjectIds` and `flattenDecimals`, because
+    // `$__hasOnlyPrimitiveValues()` counts ObjectIds and Decimal128s as primitives
+    // and only the full `clone()` path converts them.
     ret = this.$__toObjectShallow(schemaFieldsOnly);
   } else if (schemaFieldsOnly) {
     ret = {};

package/lib/error/index.js

@@ -26,14 +26,14 @@ const MongooseError = require('./mongooseError');
  * - `MongooseError`: general Mongoose error
  * - `CastError`: Mongoose could not convert a value to the type defined in the schema path. May be in a `ValidationError` class' `errors` property.
  * - `DivergentArrayError`: You attempted to `save()` an array that was modified after you loaded it with a `$elemMatch` or similar projection
- * - `MissingSchemaError`: You tried to access a model with [`mongoose.model()`](https://mongoosejs.com/docs/api/mongoose.html#Mongoose.model()) that was not defined
+ * - `MissingSchemaError`: You tried to access a model with [`mongoose.model()`](https://mongoosejs.com/docs/api/mongoose.html#Mongoose.prototype.model()) that was not defined
  * - `DocumentNotFoundError`: The document you tried to [`save()`](https://mongoosejs.com/docs/api/document.html#Document.prototype.save()) was not found
  * - `ValidatorError`: error from an individual schema path's validator
  * - `ValidationError`: error returned from [`validate()`](https://mongoosejs.com/docs/api/document.html#Document.prototype.validate()) or [`validateSync()`](https://mongoosejs.com/docs/api/document.html#Document.prototype.validateSync()). Contains zero or more `ValidatorError` instances in `.errors` property.
  * - `MissingSchemaError`: You called `mongoose.Document()` without a schema
  * - `ObjectExpectedError`: Thrown when you set a nested path to a non-object value with [strict mode set](https://mongoosejs.com/docs/guide.html#strict).
  * - `ObjectParameterError`: Thrown when you pass a non-object value to a function which expects an object as a parameter
- * - `OverwriteModelError`: Thrown when you call [`mongoose.model()`](https://mongoosejs.com/docs/api/mongoose.html#Mongoose.model()) to re-define a model that was already defined.
+ * - `OverwriteModelError`: Thrown when you call [`mongoose.model()`](https://mongoosejs.com/docs/api/mongoose.html#Mongoose.prototype.model()) to re-define a model that was already defined.
  * - `ParallelSaveError`: Thrown when you call [`save()`](https://mongoosejs.com/docs/api/model.html#Model.prototype.save()) on a document when the same document instance is already saving.
  * - `StrictModeError`: Thrown when you set a path that isn't the schema and [strict mode](https://mongoosejs.com/docs/guide.html#strict) is set to `throw`.
  * - `VersionError`: Thrown when the [document is out of sync](https://mongoosejs.com/docs/guide.html#versionKey)

package/lib/helpers/discriminator/getDiscriminatorValueFromFilter.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const isPOJO = require('../isPOJO');
+
+/**
+ * Returns the single discriminator value that a query filter condition selects,
+ * like `'Clicked'` for `'Clicked'`, `{ $eq: 'Clicked' }`, or `{ $in: ['Clicked'] }`.
+ * Returns the condition unchanged if it does not select exactly one value.
+ *
+ * @param {any} value the filter condition on the discriminator key
+ * @return {any}
+ * @api private
+ */
+
+module.exports = function getDiscriminatorValueFromFilter(value) {
+  if (!isPOJO(value)) {
+    return value;
+  }
+  const keys = Object.keys(value);
+  if (keys.length !== 1) {
+    return value;
+  }
+  if (keys[0] === '$eq') {
+    return value.$eq;
+  }
+  if (keys[0] === '$in' && Array.isArray(value.$in) && value.$in.length === 1) {
+    return value.$in[0];
+  }
+  return value;
+};

package/lib/helpers/document/toObjectRecursive.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const isPOJO = require('../isPOJO');
+
+/**
+ * Convert nested path documents underneath POJOs and arrays to POJOs without
+ * modifying the original value. Only clone containers that contain a nested
+ * path document. Preserve regular document children so casting can handle
+ * populated documents and subdocuments.
+ */
+
+module.exports = function toObjectRecursive(value, options) {
+  return _toObjectRecursive(value, options, true, new Set());
+};
+
+function _toObjectRecursive(value, options, isRoot, seen) {
+  if (value == null) {
+    return value;
+  }
+
+  if (value.$__ != null && typeof value.toObject === 'function') {
+    return isRoot || value.$__isNested ? value.toObject(options) : value;
+  }
+
+  if (!Array.isArray(value) && !isPOJO(value)) {
+    return value;
+  }
+
+  if (seen.has(value)) {
+    return value;
+  }
+  seen.add(value);
+
+  let ret = value;
+  for (const key of Object.keys(value)) {
+    const converted = _toObjectRecursive(value[key], options, false, seen);
+    if (converted === value[key]) {
+      continue;
+    }
+
+    if (ret === value) {
+      ret = Array.isArray(value) ? Object.assign([], value) : { ...value };
+    }
+    ret[key] = converted;
+  }
+
+  seen.delete(value);
+  return ret;
+}

package/lib/helpers/model/applyHooks.js

@@ -81,21 +81,30 @@ function applyHooks(model, schema, options) {
   // promises and make it so that `doc.save.toString()` provides meaningful
   // information.
 
-  const middleware = schema._getDocumentMiddleware();
+  const middleware = schema._getDocumentMiddleware(model.prototype.$isSubdocument);
 
   model._middleware = middleware;
 
-  objToDecorate.$__init = middleware.
-    createWrapperSync('init', objToDecorate.$__init, null, {
-      ...kareemOptions,
-      getOptions: (args) => {
-        const opts = args[1];
-        return {
-          pre: { filter: buildMiddlewareFilter(opts, 'pre') },
-          post: { filter: buildMiddlewareFilter(opts, 'post') }
-        };
-      }
-    });
+  // Most subdocuments have no init hooks. Avoid wrapping every hydration in
+  // Kareem when there is no middleware to run.
+  const $__init = objToDecorate.$__init;
+  if (middleware.hasHooks('init')) {
+    objToDecorate.$__init = middleware.
+      createWrapperSync('init', $__init, null, {
+        ...kareemOptions,
+        getOptions: (args) => {
+          const opts = args[1];
+          return {
+            pre: { filter: buildMiddlewareFilter(opts, 'pre') },
+            post: { filter: buildMiddlewareFilter(opts, 'post') }
+          };
+        }
+      });
+  } else {
+    // Still define an own `$__init` so top-level discriminators, whose prototype is later set to
+    // the base model's prototype, don't inherit the base model's wrapped `$__init`.
+    objToDecorate.$__init = $__init;
+  }
 
   // Support hooks for custom methods
   const customMethods = Object.keys(schema.methods);

package/lib/helpers/model/castBulkWrite.js

@@ -6,6 +6,7 @@ const applyTimestampsToChildren = require('../update/applyTimestampsToChildren')
 const applyTimestampsToUpdate = require('../update/applyTimestampsToUpdate');
 const cast = require('../../cast');
 const castUpdate = require('../query/castUpdate');
+const { castArrayFiltersForUpdate } = require('../update/castArrayFilters');
 const clone = require('../clone');
 const decorateUpdateWithVersionKey = require('../update/decorateUpdateWithVersionKey');
 const { inspect } = require('util');
@@ -153,6 +154,10 @@ module.exports.castUpdateOne = function castUpdateOne(originalModel, updateOne,
     strict: strict,
     upsert: updateOne.upsert
   });
+  if (Array.isArray(updateOne.arrayFilters)) {
+    updateOne.arrayFilters = clone(updateOne.arrayFilters);
+    castArrayFiltersForUpdate(updateOne.arrayFilters, update, schema, model, options);
+  }
   updateOne['update'] = castUpdate(model.schema, update, {
     strict: strict,
     upsert: updateOne.upsert,
@@ -214,6 +219,10 @@ module.exports.castUpdateMany = function castUpdateMany(originalModel, updateMan
     strict: strict,
     upsert: updateMany.upsert
   });
+  if (Array.isArray(updateMany.arrayFilters)) {
+    updateMany.arrayFilters = clone(updateMany.arrayFilters);
+    castArrayFiltersForUpdate(updateMany.arrayFilters, update, schema, model, options);
+  }
 
   updateMany['update'] = castUpdate(model.schema, update, {
     strict: strict,

package/lib/helpers/query/getEmbeddedDiscriminatorPath.js

@@ -3,6 +3,7 @@
 const cleanPositionalOperators = require('../schema/cleanPositionalOperators');
 const get = require('../get');
 const getDiscriminatorByValue = require('../discriminator/getDiscriminatorByValue');
+const getDiscriminatorValueFromFilter = require('../discriminator/getDiscriminatorValueFromFilter');
 const updatedPathsByArrayFilter = require('../update/updatedPathsByArrayFilter');
 
 /**
@@ -46,16 +47,16 @@ module.exports = function getEmbeddedDiscriminatorPath(schema, update, filter, p
       let discriminatorKey = null;
 
       if (discriminatorValuePath in filter) {
-        discriminatorKey = filter[discriminatorValuePath];
+        discriminatorKey = getDiscriminatorValueFromFilter(filter[discriminatorValuePath]);
       }
       if (discriminatorFilterPath in filter) {
-        discriminatorKey = filter[discriminatorFilterPath];
+        discriminatorKey = getDiscriminatorValueFromFilter(filter[discriminatorFilterPath]);
       }
 
       const wrapperPath = subpath.replace(/\.\d+$/, '');
       if (schematype.$isMongooseDocumentArrayElement &&
           get(filter[wrapperPath], '$elemMatch.' + key) != null) {
-        discriminatorKey = filter[wrapperPath].$elemMatch[key];
+        discriminatorKey = getDiscriminatorValueFromFilter(filter[wrapperPath].$elemMatch[key]);
       }
 
       const discriminatorKeyUpdatePath = originalSubpath + '.' + key;

package/lib/helpers/update/castArrayFilters.js

@@ -7,30 +7,53 @@ const updatedPathsByArrayFilter = require('./updatedPathsByArrayFilter');
 const utils = require('../../utils');
 
 module.exports = function castArrayFilters(query) {
-  const arrayFilters = query.options.arrayFilters;
+  castArrayFiltersForUpdate(
+    query.options.arrayFilters,
+    query.getUpdate(),
+    query.schema,
+    query.model,
+    query._mongooseOptions,
+    query
+  );
+};
+
+/**
+ * Casts `arrayFilters` in place against the schema paths that `update` modifies.
+ * Shared by queries and `bulkWrite()`.
+ *
+ * @param {Array} arrayFilters
+ * @param {object} update the update that the array filters apply to, before casting
+ * @param {Schema} schema
+ * @param {Model} [model]
+ * @param {object} options the `strict` and `strictQuery` options of the query or bulk write
+ * @param {object} [context] passed to `castForQuery()`
+ * @api private
+ */
+
+function castArrayFiltersForUpdate(arrayFilters, update, schema, model, options, context) {
   if (!Array.isArray(arrayFilters)) {
     return;
   }
-  const update = query.getUpdate();
-  const schema = query.schema;
   const updatedPathsByFilter = updatedPathsByArrayFilter(update);
 
   let strictQuery = schema.options.strict;
-  if (query._mongooseOptions.strict != null) {
-    strictQuery = query._mongooseOptions.strict;
+  if (options.strict != null) {
+    strictQuery = options.strict;
   }
-  if (query.model?.base.options.strictQuery != null) {
-    strictQuery = query.model.base.options.strictQuery;
+  if (model?.base.options.strictQuery != null) {
+    strictQuery = model.base.options.strictQuery;
   }
   if (schema._userProvidedOptions.strictQuery != null) {
     strictQuery = schema._userProvidedOptions.strictQuery;
   }
-  if (query._mongooseOptions.strictQuery != null) {
-    strictQuery = query._mongooseOptions.strictQuery;
+  if (options.strictQuery != null) {
+    strictQuery = options.strictQuery;
   }
 
-  _castArrayFilters(arrayFilters, schema, strictQuery, updatedPathsByFilter, query);
-};
+  _castArrayFilters(arrayFilters, schema, strictQuery, updatedPathsByFilter, context);
+}
+
+module.exports.castArrayFiltersForUpdate = castArrayFiltersForUpdate;
 
 function _castArrayFilters(arrayFilters, schema, strictQuery, updatedPathsByFilter, query) {
   // Map to store discriminator values for embedded documents in the array filters.
@@ -92,7 +115,7 @@ function _castArrayFilters(arrayFilters, schema, strictQuery, updatedPathsByFilt
 
       if (schematype == null) {
         if (!strictQuery) {
-          return;
+          continue;
         }
         const filterPath = filterPathRelativeToBase == null ?
           baseFilterPath + '.0' :

package/lib/model.js

@@ -615,7 +615,7 @@ function generateVersionError(doc, modifiedPaths, defaultPaths) {
  *     newProduct === product; // true
  *
  * @param {object} [options] options optional options
- * @param {Session} [options.session=null] the [session](https://www.mongodb.com/docs/manual/reference/server-sessions/) associated with this save operation. If not specified, defaults to the [document's associated session](https://mongoosejs.com/docs/api/document.html#Document.prototype.session()).
+ * @param {Session} [options.session=null] the [session](https://www.mongodb.com/docs/manual/reference/server-sessions/) associated with this save operation. If not specified, defaults to the [document's associated session](https://mongoosejs.com/docs/api/document.html#Document.prototype.$session()).
  * @param {object} [options.safe] (DEPRECATED) overrides [schema's safe option](https://mongoosejs.com/docs/guide.html#safe). Use the `w` option instead.
  * @param {boolean} [options.validateBeforeSave] set to false to save without validating.
  * @param {boolean} [options.validateModifiedOnly=false] if `true`, Mongoose will only validate modified paths, as opposed to modified paths and `required` paths.
@@ -2391,7 +2391,7 @@ Model.where = function where(path, val) {
  * @method $where
  * @memberOf Model
  * @return {Query}
- * @see Query.$where https://mongoosejs.com/docs/api/query.html#Query.prototype.$where
+ * @see Query.$where https://mongoosejs.com/docs/api/query.html#Query.prototype.$where()
  * @api public
  */
 

package/lib/mongoose.js

@@ -240,7 +240,7 @@ Mongoose.prototype.setDriver = function setDriver(driver) {
  * - `selectPopulatedPaths`: `true` by default. Set to false to opt out of Mongoose adding all fields that you `populate()` to your `select()`. The schema-level option `selectPopulatedPaths` overwrites this one.
  * - `strictQuery`: `false` by default. May be `false`, `true`, or `'throw'`. Sets the default [strictQuery](https://mongoosejs.com/docs/guide.html#strictQuery) mode for schemas.
  * - `strict`: `true` by default, may be `false`, `true`, or `'throw'`. Sets the default strict mode for schemas.
- * - `timestamps.createdAt.immutable`: `true` by default. If `false`, it will change the `createdAt` field to be [`immutable: false`](https://mongoosejs.com/docs/api/schematype.html#SchemaType.prototype.immutable) which means you can update the `createdAt`
+ * - `timestamps.createdAt.immutable`: `true` by default. If `false`, it will change the `createdAt` field to be [`immutable: false`](https://mongoosejs.com/docs/api/schematype.html#SchemaType.prototype.immutable()) which means you can update the `createdAt`
  * - `toJSON`: `{ transform: true, flattenDecimals: true }` by default. Overwrites default objects to [`toJSON()`](https://mongoosejs.com/docs/api/document.html#Document.prototype.toJSON()), for determining how Mongoose documents get serialized by `JSON.stringify()`
  * - `toObject`: `{ transform: true, flattenDecimals: true }` by default. Overwrites default objects to [`toObject()`](https://mongoosejs.com/docs/api/document.html#Document.prototype.toObject())
  * - `transactionAsyncLocalStorage`: `false` by default. If `true`, Mongoose will automatically pass the `session` to any operation executing within a transaction executor function. See [transaction AsyncLocalStorage documentation](https://mongoosejs.com/docs/transactions.html#asynclocalstorage)
@@ -1067,7 +1067,7 @@ Mongoose.prototype.Query = Query;
 Mongoose.prototype.Model = Model;
 
 /**
- * The Mongoose [Document](https://mongoosejs.com/docs/api/document.html#Document()) constructor.
+ * The Mongoose [Document](https://mongoosejs.com/docs/api/document.html) constructor.
  *
  * @method Document
  * @api public

package/lib/plugins/saveSubdocs.js

@@ -92,6 +92,10 @@ function saveSubdocsPostDeleteOne() {
 
 
 saveSubdocsPreSave[symbols.builtInMiddleware] = true;
+saveSubdocsPreSave[symbols.skipOnSubdocuments] = true;
 saveSubdocsPostSave[symbols.builtInMiddleware] = true;
+saveSubdocsPostSave[symbols.skipOnSubdocuments] = true;
 saveSubdocsPreDeleteOne[symbols.builtInMiddleware] = true;
+saveSubdocsPreDeleteOne[symbols.skipOnSubdocuments] = true;
 saveSubdocsPostDeleteOne[symbols.builtInMiddleware] = true;
+saveSubdocsPostDeleteOne[symbols.skipOnSubdocuments] = true;

package/lib/plugins/sharding.js

@@ -95,7 +95,17 @@ function storeShard() {
 }
 
 shardingPluginPostInit[symbols.builtInMiddleware] = true;
+shardingPluginPostInit[symbols.skipOnSubdocuments] = true;
+shardingPluginPostInit[symbols.requiresShardKey] = true;
 shardingPluginPreSave[symbols.builtInMiddleware] = true;
+shardingPluginPreSave[symbols.skipOnSubdocuments] = true;
+shardingPluginPreSave[symbols.requiresShardKey] = true;
 shardingPluginPostSave[symbols.builtInMiddleware] = true;
+shardingPluginPostSave[symbols.skipOnSubdocuments] = true;
+shardingPluginPostSave[symbols.requiresShardKey] = true;
 shardingPluginPreDeleteOne[symbols.builtInMiddleware] = true;
+shardingPluginPreDeleteOne[symbols.skipOnSubdocuments] = true;
+shardingPluginPreDeleteOne[symbols.requiresShardKey] = true;
 shardingPluginPreUpdateOne[symbols.builtInMiddleware] = true;
+shardingPluginPreUpdateOne[symbols.skipOnSubdocuments] = true;
+shardingPluginPreUpdateOne[symbols.requiresShardKey] = true;

package/lib/query.js

@@ -893,7 +893,7 @@ Query.prototype.mod = function() {
  *
  * #### Note:
  *
- * As of Mongoose 3.7, `$geoWithin` is always used for queries. To change this behavior, see [Query.use$geoWithin](https://mongoosejs.com/docs/api/query.html#Query.prototype.use$geoWithin).
+ * As of Mongoose 3.7, `$geoWithin` is always used for queries. To change this behavior, see [Query.use$geoWithin](https://mongoosejs.com/docs/api/query.html#Query.use$geoWithin).
  *
  * #### Note:
  *
@@ -4232,7 +4232,7 @@ Query.prototype.validate = async function validate(castedDoc, options, isOverwri
 /**
  * Execute an updateMany query
  *
- * @see Model.update https://mongoosejs.com/docs/api/model.html#Model.update()
+ * @see Model.updateMany https://mongoosejs.com/docs/api/model.html#Model.updateMany()
  * @method _updateMany
  * @memberOf Query
  * @instance
@@ -4278,7 +4278,7 @@ Query.prototype._updateMany = async function _updateMany() {
 /**
  * Execute an updateOne query
  *
- * @see Model.update https://mongoosejs.com/docs/api/model.html#Model.update()
+ * @see Model.updateOne https://mongoosejs.com/docs/api/model.html#Model.updateOne()
  * @method _updateOne
  * @memberOf Query
  * @instance
@@ -4389,7 +4389,7 @@ Query.prototype._replaceOne = async function _replaceOne() {
  * @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.
  * @param {boolean} [options.requireFilter=false] If true, throws an error if the filter is empty (`{}`)
  * @return {Query} this
- * @see Model.update https://mongoosejs.com/docs/api/model.html#Model.update()
+ * @see Model.updateMany https://mongoosejs.com/docs/api/model.html#Model.updateMany()
  * @see Query docs https://mongoosejs.com/docs/queries.html
  * @see update https://www.mongodb.com/docs/manual/reference/method/db.collection.update/
  * @see UpdateResult https://mongodb.github.io/node-mongodb-native/7.0/interfaces/UpdateResult.html
@@ -4465,7 +4465,7 @@ Query.prototype.updateMany = function(conditions, doc, options, callback) {
  * @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.
  * @param {boolean} [options.requireFilter=false] If true, throws an error if the filter is empty (`{}`)
  * @return {Query} this
- * @see Model.update https://mongoosejs.com/docs/api/model.html#Model.update()
+ * @see Model.updateOne https://mongoosejs.com/docs/api/model.html#Model.updateOne()
  * @see Query docs https://mongoosejs.com/docs/queries.html
  * @see update https://www.mongodb.com/docs/manual/reference/method/db.collection.update/
  * @see UpdateResult https://mongodb.github.io/node-mongodb-native/7.0/interfaces/UpdateResult.html
@@ -4533,7 +4533,7 @@ Query.prototype.updateOne = function(conditions, doc, options, callback) {
  * @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.
  * @param {boolean} [options.requireFilter=false] If true, throws an error if the filter is empty (`{}`)
  * @return {Query} this
- * @see Model.update https://mongoosejs.com/docs/api/model.html#Model.update()
+ * @see Model.replaceOne https://mongoosejs.com/docs/api/model.html#Model.replaceOne()
  * @see Query docs https://mongoosejs.com/docs/queries.html
  * @see update https://www.mongodb.com/docs/manual/reference/method/db.collection.update/
  * @see UpdateResult https://mongodb.github.io/node-mongodb-native/7.0/interfaces/UpdateResult.html

package/lib/schema/array.js

@@ -611,6 +611,19 @@ function cast$elemMatch(val, context) {
   for (let i = 0; i < numKeys; ++i) {
     const key = keys[i];
     const value = val[key];
+    if (key === '$not') {
+      // `$not` wraps other operators, like `{ $not: { $gt: 5 } }` or
+      // `{ $not: { $elemMatch: ... } }`, so cast each wrapped operator.
+      // A RegExp is left as-is.
+      if (utils.isPOJO(value)) {
+        for (const notKey of Object.keys(value)) {
+          if (isOperator(notKey) && value[notKey] != null) {
+            value[notKey] = this.castForQuery(notKey, value[notKey], context);
+          }
+        }
+      }
+      continue;
+    }
     if (isOperator(key) && value != null) {
       val[key] = this.castForQuery(key, value, context);
     }

package/lib/schema/documentArray.js

@@ -484,10 +484,10 @@ SchemaDocumentArray.prototype.cast = function(value, doc, init, prev, options) {
         }
 
         subdoc = new Constructor(null, value, initDocumentOptions, selected, i);
-        // Don't pass `path` to $init - it's only for this DocumentArray itself, not its element fields.
-        // Element subdocuments use relative paths internally for change tracking.
-        if (options.path != null) {
-          const { path, ...initOptions } = options;
+        // Don't pass `path` or `arrayPathIndex` to $init - they're only for this DocumentArray itself,
+        // not its element fields. Element subdocuments use relative paths internally for change tracking.
+        if (options.path != null || options.arrayPathIndex != null) {
+          const { path, arrayPathIndex, ...initOptions } = options;
           options = initOptions;
         }
         rawArray[i] = subdoc.$init(rawArray[i], options);

package/lib/schema/number.js

@@ -222,7 +222,9 @@ SchemaNumber.prototype.min = function(value, message) {
 
   if (value != null) {
     let msg = message || MongooseError.messages.Number.min;
-    msg = msg.replace(/{MIN}/, value);
+    if (typeof msg === 'string') {
+      msg = msg.replace(/{MIN}/, value);
+    }
     this.validators.push({
       validator: this.minValidator = function(v) {
         return v == null || v >= value;
@@ -276,7 +278,9 @@ SchemaNumber.prototype.max = function(value, message) {
 
   if (value != null) {
     let msg = message || MongooseError.messages.Number.max;
-    msg = msg.replace(/{MAX}/, value);
+    if (typeof msg === 'string') {
+      msg = msg.replace(/{MAX}/, value);
+    }
     this.validators.push({
       validator: this.maxValidator = function(v) {
         return v == null || v <= value;

package/lib/schema/string.js

@@ -417,7 +417,9 @@ SchemaString.prototype.minlength = function(value, message) {
 
   if (value != null) {
     let msg = message || MongooseError.messages.String.minlength;
-    msg = msg.replace(/{MINLENGTH}/, value);
+    if (typeof msg === 'string') {
+      msg = msg.replace(/{MINLENGTH}/, value);
+    }
     this.validators.push({
       validator: this.minlengthValidator = function(v) {
         return v === null || v.length >= value;

package/lib/schema/symbols.js

@@ -3,3 +3,5 @@
 exports.schemaMixedSymbol = Symbol.for('mongoose:schema_mixed');
 
 exports.builtInMiddleware = Symbol.for('mongoose:built-in-middleware');
+exports.skipOnSubdocuments = Symbol('mongoose:skip-on-subdocuments');
+exports.requiresShardKey = Symbol.for('mongoose:requires-shard-key');

package/lib/schema.js

@@ -700,9 +700,18 @@ Schema.prototype.discriminator = function(name, schema, options) {
 /*!
  * Get the document middleware for this schema, filtering out any hooks that are specific to queries.
  */
-Schema.prototype._getDocumentMiddleware = function _getDocumentMiddleware() {
+Schema.prototype._getDocumentMiddleware = function _getDocumentMiddleware(isSubdocument) {
+  // Check `shardKey` at compile time rather than when the sharding plugin is applied, because
+  // discriminators apply plugins before inheriting the base schema's options.
+  const hasShardKey = !!(this.options.shardKey || this.options.shardkey);
   return this.s.hooks.
     filter(hook => {
+      if (isSubdocument && hook.fn[symbols.skipOnSubdocuments]) {
+        return false;
+      }
+      if (!hasShardKey && hook.fn[symbols.requiresShardKey]) {
+        return false;
+      }
       if (hook.name === 'updateOne' || hook.name === 'deleteOne') {
         return !!hook['document'];
       }

package/lib/schemaType.js

@@ -645,7 +645,7 @@ SchemaType.prototype.sparse = function(bool) {
 
 /**
  * Defines this path as immutable. Mongoose prevents you from changing
- * immutable paths unless the parent document has [`isNew: true`](https://mongoosejs.com/docs/api/document.html#Document.prototype.isNew()).
+ * immutable paths unless the parent document has [`isNew: true`](https://mongoosejs.com/docs/api/document.html#Document.prototype.isNew).
  *
  * #### Example:
  *
@@ -682,7 +682,7 @@ SchemaType.prototype.sparse = function(bool) {
  *
  * @param {boolean} bool
  * @return {SchemaType} this
- * @see isNew https://mongoosejs.com/docs/api/document.html#Document.prototype.isNew()
+ * @see isNew https://mongoosejs.com/docs/api/document.html#Document.prototype.isNew
  * @api public
  */
 
@@ -1131,7 +1131,7 @@ SchemaType.prototype.validate = function(obj, message, type) {
  * @see SchemaBoolean#checkRequired https://mongoosejs.com/docs/api/schemaboolean.html#SchemaBoolean.prototype.checkRequired()
  * @see SchemaBuffer#checkRequired https://mongoosejs.com/docs/api/schemabuffer.html#SchemaBuffer.prototype.checkRequired()
  * @see SchemaNumber#checkRequired https://mongoosejs.com/docs/api/schemanumber.html#SchemaNumber.prototype.checkRequired()
- * @see SchemaObjectId#checkRequired https://mongoosejs.com/docs/api/schemaobjectid.html#ObjectId.prototype.checkRequired()
+ * @see SchemaObjectId#checkRequired https://mongoosejs.com/docs/api/schemaobjectid.html#SchemaObjectId.prototype.checkRequired()
  * @see SchemaString#checkRequired https://mongoosejs.com/docs/api/schemastring.html#SchemaString.prototype.checkRequired()
  * @api public
  */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "9.11.0",
+  "version": "9.11.2",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -21,7 +21,7 @@
   "license": "MIT",
   "dependencies": {
     "@standard-schema/spec": "^1.1.0",
-    "kareem": "3.4.0",
+    "kareem": "3.4.1",
     "mongodb": "~7.7",
     "mpath": "0.9.0",
     "mquery": "6.0.0",

package/types/index.d.ts

@@ -738,7 +738,7 @@ declare module 'mongoose' {
     static ObjectId: typeof Schema.Types.ObjectId;
   }
 
-  export type NumberSchemaDefinition = typeof Number | 'number' | 'Number' | typeof Schema.Types.Number | Schema.Types.Number;
+  export type NumberSchemaDefinition = typeof Number | 'number' | 'Number' | typeof Schema.Types.Number | Schema.Types.Number | 'int32' | 'Int32' | typeof Schema.Types.Int32 | Schema.Types.Int32;
   export type StringSchemaDefinition = typeof String | 'string' | 'String' | typeof Schema.Types.String | Schema.Types.String;
   export type BooleanSchemaDefinition = typeof Boolean | 'boolean' | 'Boolean' | typeof Schema.Types.Boolean | Schema.Types.Boolean;
   export type DateSchemaDefinition = DateConstructor | 'date' | 'Date' | typeof Schema.Types.Date | Schema.Types.Date;

package/types/models.d.ts

@@ -158,13 +158,19 @@ declare module 'mongoose' {
     MongooseBulkUpdatePerOperationOptions;
 
   export type UpdateOneModel<TSchema extends mongodb.Document = mongodb.Document> =
-    Omit<mongodb.UpdateOneModel<TSchema>, 'filter'> &
-    { filter: QueryFilter<TSchema> } &
+    Omit<mongodb.UpdateOneModel<TSchema>, 'filter' | 'update'> &
+    {
+      filter: QueryFilter<TSchema>;
+      update: UpdateQuery<TSchema> | UpdateWithAggregationPipeline;
+    } &
     MongooseBulkUpdatePerOperationOptions;
 
   export type UpdateManyModel<TSchema extends mongodb.Document = mongodb.Document> =
-    Omit<mongodb.UpdateManyModel<TSchema>, 'filter'> &
-    { filter: QueryFilter<TSchema> } &
+    Omit<mongodb.UpdateManyModel<TSchema>, 'filter' | 'update'> &
+    {
+      filter: QueryFilter<TSchema>;
+      update: UpdateQuery<TSchema> | UpdateWithAggregationPipeline;
+    } &
     MongooseBulkUpdatePerOperationOptions;
 
   export type DeleteOneModel<TSchema extends mongodb.Document = mongodb.Document> =

package/types/populate.d.ts

@@ -23,7 +23,9 @@ declare module 'mongoose' {
             ? { [K in keyof T]: PopulatePathToRawDocType<T[K]> }
             : T;
 
-  type PopulatedPathsDocumentType<RawDocType, Paths> = UnpackedIntersection<RawDocType, PopulatePathToRawDocType<Paths>>;
+  type PopulatedPathsDocumentType<RawDocType, Paths> = Paths extends Record<string, never>
+    ? RawDocType
+    : UnpackedIntersection<RawDocType, PopulatePathToRawDocType<Paths>>;
 
   type PopulatedDocumentMarker<
     PopulatedRawDocType,

package/types/schematypes.d.ts

@@ -193,18 +193,18 @@ declare module 'mongoose' {
     min?:
       | number
       | NativeDate
-      | [number, string]
+      | [number, string | ValidatorMessageFn]
       | [NativeDate, string]
-      | readonly [number, string]
+      | readonly [number, string | ValidatorMessageFn]
       | readonly [NativeDate, string];
 
     /** The maximum value allowed for this path. Only allowed for numbers and dates. */
     max?:
       | number
       | NativeDate
-      | [number, string]
+      | [number, string | ValidatorMessageFn]
       | [NativeDate, string]
-      | readonly [number, string]
+      | readonly [number, string | ValidatorMessageFn]
       | readonly [NativeDate, string];
 
     /** Set to false to disable minimizing empty single nested subdocuments by default */
@@ -241,12 +241,12 @@ declare module 'mongoose' {
     uppercase?: boolean;
 
     /** If set, Mongoose will add a custom validator that ensures the given string's `length` is at least the given number. */
-    minlength?: number | [number, string] | readonly [number, string];
-    minLength?: number | [number, string] | readonly [number, string];
+    minlength?: number | [number, string | ValidatorMessageFn] | readonly [number, string | ValidatorMessageFn];
+    minLength?: number | [number, string | ValidatorMessageFn] | readonly [number, string | ValidatorMessageFn];
 
     /** If set, Mongoose will add a custom validator that ensures the given string's `length` is at most the given number. */
-    maxlength?: number | [number, string] | readonly [number, string];
-    maxLength?: number | [number, string] | readonly [number, string];
+    maxlength?: number | [number, string | ValidatorMessageFn] | readonly [number, string | ValidatorMessageFn];
+    maxLength?: number | [number, string | ValidatorMessageFn] | readonly [number, string | ValidatorMessageFn];
 
     [other: string]: any;
 
@@ -562,10 +562,10 @@ declare module 'mongoose' {
         enum(vals: number[]): this;
 
         /** Sets a maximum number validator. */
-        max(value: number, message?: string): this;
+        max(value: number, message?: string | ValidatorMessageFn): this;
 
         /** Sets a minimum number validator. */
-        min(value: number, message?: string): this;
+        min(value: number, message?: string | ValidatorMessageFn): this;
 
         /** Default options for this SchemaType */
         static defaultOptions: Record<string, any>;
@@ -632,10 +632,10 @@ declare module 'mongoose' {
         match(value: RegExp, message: string): this;
 
         /** Sets a maximum length validator. */
-        maxlength(value: number, message: string): this;
+        maxlength(value: number, message: string | ValidatorMessageFn): this;
 
         /** Sets a minimum length validator. */
-        minlength(value: number, message: string): this;
+        minlength(value: number, message: string | ValidatorMessageFn): this;
 
         /** Adds a trim [setter](http://mongoosejs.com/docs/api/schematype.html#schematype_SchemaType-set). */
         trim(shouldTrim?: boolean): this;

package/types/utility.d.ts

@@ -143,7 +143,13 @@ declare module 'mongoose' {
     ? T
     : T extends any ? (Omit<T, keyof U> & U) : never;
 
-  type MergeType<A, B> = A extends unknown ? Omit<A, keyof B> & B : never;
+  type MergeTypeKeys<T> = T extends unknown ? keyof T : never;
+
+  type MergeType<A, B> = [B] extends [object]
+    ? [MergeTypeKeys<B>] extends [never]
+      ? A
+      : A extends unknown ? Omit<A, keyof B> & B : never
+    : A extends unknown ? Omit<A, keyof B> & B : never;
 
   /**
    * @summary Converts Unions to one record "object".