mongoose 9.9.4 → 9.10.0

package/eslint.config.mjs

@@ -43,6 +43,7 @@ export default defineConfig([
       'no-constant-condition': 'off',
       'no-multi-spaces': 'error',
       'func-call-spacing': 'error',
+      'no-unused-vars': ['error', { ignoreRestSiblings: true }],
       'no-trailing-spaces': 'error',
       'no-undef': 'error',
       'no-unneeded-ternary': 'error',

package/lib/aggregate.js

@@ -810,8 +810,7 @@ Aggregate.prototype.explain = async function explain(verbosity) {
   const postFilter = buildMiddlewareFilter(this.options, 'post');
 
   // Remove middleware option before passing to MongoDB
-  const options = this.options != null ? { ...this.options } : {};
-  delete options.middleware;
+  const { middleware, ...options } = this.options ?? {};
 
   try {
     await model.hooks.execPre('aggregate', this, [], { filter: preFilter });
@@ -925,6 +924,8 @@ Aggregate.prototype.option = function(value) {
  * Sets the `cursor` option and executes this aggregation, returning an aggregation cursor.
  * Cursors are useful if you want to process the results of the aggregation one-at-a-time
  * because the aggregation result is too big to fit into memory.
+ * Creating an aggregation cursor runs pre aggregate hooks, but not post aggregate hooks.
+ * To skip pre aggregate hooks, pass `middleware: false` to `.cursor()`.
  *
  * #### Example:
  *
@@ -935,6 +936,8 @@ Aggregate.prototype.option = function(value) {
  *
  * @param {object} options
  * @param {number} [options.batchSize] set the cursor batch size
+ * @param {boolean|object} [options.middleware=true] set to `false` to skip user-defined pre aggregate middleware
+ * @param {boolean} [options.middleware.pre=true] set to `false` to skip pre aggregate middleware
  * @param {boolean} [options.useMongooseAggCursor] use experimental mongoose-specific aggregation cursor (for `eachAsync()` and other query cursor semantics)
  * @return {AggregationCursor} cursor representing this aggregation
  * @api public
@@ -943,6 +946,11 @@ Aggregate.prototype.option = function(value) {
 
 Aggregate.prototype.cursor = function(options) {
   this._optionsForExec();
+  if (utils.hasUserDefinedProperty(options, 'middleware')) {
+    const { middleware, ...cursorOptions } = options;
+    this.options.middleware = middleware;
+    options = cursorOptions;
+  }
   this.options.cursor = options || {};
   return new AggregationCursor(this); // return this;
 };
@@ -1122,8 +1130,7 @@ Aggregate.prototype.exec = async function exec() {
       throw new MongooseError('Aggregate has empty pipeline');
     }
 
-    const options = clone(_this.options || {});
-    delete options.middleware;
+    const { middleware, ...options } = clone(_this.options || {});
 
     let result;
     try {

package/lib/cursor/aggregationCursor.js

@@ -11,6 +11,7 @@ const immediate = require('../helpers/immediate');
 const kareem = require('kareem');
 const util = require('util');
 const { cursorNextChannel } = require('../tracing');
+const { buildMiddlewareFilter } = require('../helpers/buildMiddlewareFilter');
 
 /**
  * An AggregationCursor is a concurrency primitive for processing aggregation
@@ -49,7 +50,14 @@ function AggregationCursor(agg) {
   this._mongooseOptions = {};
 
   if (connection) {
-    this.cursor = connection.db.aggregate(agg._pipeline, agg.options || {});
+    let options = agg.options || {};
+    if (Object.hasOwn(options, 'middleware')) {
+      // `middleware` is a Mongoose-only option used to skip user hooks; strip
+      // it from the clone passed through to the MongoDB driver.
+      const { middleware, ...driverOptions } = options;
+      options = driverOptions;
+    }
+    this.cursor = connection.db.aggregate(agg._pipeline, options);
     setImmediate(() => this.emit('cursor', this.cursor));
   } else {
     _init(model, this, agg);
@@ -63,7 +71,8 @@ util.inherits(AggregationCursor, Readable);
  */
 
 function _init(model, c, agg) {
-  model.hooks.execPre('aggregate', agg).then(() => onPreComplete(null), err => onPreComplete(err));
+  const preFilter = buildMiddlewareFilter(agg.options, 'pre');
+  model.hooks.execPre('aggregate', agg, [], { filter: preFilter }).then(() => onPreComplete(null), err => onPreComplete(err));
 
   function onPreComplete(err) {
     if (err != null) {
@@ -90,7 +99,14 @@ function _init(model, c, agg) {
 
 function _getRawCursor(model, aggregationCursor, agg) {
   try {
-    const cursor = model.collection.aggregate(agg._pipeline, agg.options || {});
+    let options = agg.options;
+    if (Object.hasOwn(options, 'middleware')) {
+      // `middleware` is a Mongoose-only option used to skip user hooks; strip
+      // it from the clone passed through to the MongoDB driver.
+      const { middleware, ...driverOptions } = options;
+      options = driverOptions;
+    }
+    const cursor = model.collection.aggregate(agg._pipeline, options);
     aggregationCursor.cursor = cursor;
     aggregationCursor.emit('cursor', cursor);
   } catch (err) {

package/lib/cursor/queryCursor.js

@@ -13,6 +13,7 @@ const immediate = require('../helpers/immediate');
 const { once } = require('events');
 const util = require('util');
 const { cursorNextChannel } = require('../tracing');
+const { buildMiddlewareFilter } = require('../helpers/buildMiddlewareFilter');
 
 /**
  * A QueryCursor is a concurrency primitive for processing query results
@@ -21,7 +22,8 @@ const { cursorNextChannel } = require('../tracing');
  * one at a time.
  *
  * QueryCursors execute the model's pre `find` hooks before loading any documents
- * from MongoDB, and the model's post `find` hooks after loading each document.
+ * from MongoDB, and the model's post `find` hooks once per document,
+ * with an array containing that document.
  *
  * Unless you're an advanced user, do **not** instantiate this class directly.
  * Use [`Query#cursor()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.cursor()) instead.
@@ -50,6 +52,7 @@ function QueryCursor(query) {
   this._transforms = [];
   this.model = model;
   this.options = {};
+  this._postMiddlewareFilter = null;
 
   const onPreComplete = (err) => {
     if (err != null) {
@@ -74,7 +77,15 @@ function QueryCursor(query) {
       this.listeners('error').length > 0 && this.emit('error', err);
       return;
     }
-    Object.assign(this.options, query._optionsForExec());
+    const { middleware, ...options } = query._optionsForExec();
+    Object.assign(this.options, options);
+    // `middleware` is a Mongoose-only option used to skip user hooks; strip it
+    // so it isn't passed through to the MongoDB driver. `this.options` is public
+    // and may be modified while pre hooks run, so check the target after assign.
+    if (Object.hasOwn(this.options, 'middleware')) {
+      delete this.options.middleware;
+    }
+    this._postMiddlewareFilter = buildMiddlewareFilter(query.options, 'post');
     this._transforms = this._transforms.concat(query._transforms.slice());
     if (this.options.transform) {
       this._transforms.push(this.options.transform);
@@ -98,7 +109,8 @@ function QueryCursor(query) {
     }
   };
 
-  model.hooks.execPre('find', query).then(() => onPreComplete(null), err => onPreComplete(err));
+  const preFilter = buildMiddlewareFilter(query.options, 'pre');
+  model.hooks.execPre('find', query, [], { filter: preFilter }).then(() => onPreComplete(null), err => onPreComplete(err));
 }
 
 util.inherits(QueryCursor, Readable);
@@ -607,7 +619,7 @@ function _populateBatch() {
 
 function _nextDoc(ctx, doc, pop, callback) {
   if (ctx.query._mongooseOptions.lean) {
-    return ctx.model.hooks.execPost('find', ctx.query, [[doc]]).then(() => callback(null, doc), err => callback(err));
+    return ctx.model.hooks.execPost('find', ctx.query, [[doc]], { filter: ctx._postMiddlewareFilter }).then(() => callback(null, doc), err => callback(err));
   }
 
   const { model, _fields, _userProvidedFields, options } = ctx.query;
@@ -618,7 +630,7 @@ function _nextDoc(ctx, doc, pop, callback) {
     if (options.session != null) {
       doc.$session(options.session);
     }
-    ctx.model.hooks.execPost('find', ctx.query, [[doc]]).then(() => callback(null, doc), err => callback(err));
+    ctx.model.hooks.execPost('find', ctx.query, [[doc]], { filter: ctx._postMiddlewareFilter }).then(() => callback(null, doc), err => callback(err));
   });
 }
 

package/lib/document.js

@@ -28,6 +28,7 @@ const compile = require('./helpers/document/compile').compile;
 const defineKey = require('./helpers/document/compile').defineKey;
 const firstKey = require('./helpers/firstKey');
 const flatten = require('./helpers/common').flatten;
+const getConstructorName = require('./helpers/getConstructorName');
 const getEmbeddedDiscriminatorPath = require('./helpers/document/getEmbeddedDiscriminatorPath');
 const getKeysInSchemaOrder = require('./helpers/schema/getKeysInSchemaOrder');
 const getSubdocumentStrictValue = require('./helpers/schema/getSubdocumentStrictValue');
@@ -3589,6 +3590,15 @@ Document.prototype.invalidate = function(path, err, val, kind) {
     return this.$__.validationError;
   }
 
+  // Set the model on cast errors with a custom message so `{MODEL}` gets
+  // replaced for document validation, not just query casting (gh-8300)
+  if (typeof err.setModel === 'function') {
+    const owner = this.ownerDocument();
+    if (getConstructorName(owner) === 'model') {
+      err.setModel(owner.constructor);
+    }
+  }
+
   this.$__.validationError.addError(path, err);
   return this.$__.validationError;
 };

package/lib/helpers/buildMiddlewareFilter.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const isPOJO = require('./isPOJO');
 const symbols = require('../schema/symbols');
 
 /**
@@ -15,10 +16,27 @@ const isBuiltInMiddleware = hook => hook.fn[symbols.builtInMiddleware];
  * @returns {Function|null} - null runs all middleware, isBuiltInMiddleware skips user middleware
  */
 function buildMiddlewareFilter(options, phase) {
-  const shouldRun = options?.middleware?.[phase] ?? options?.middleware ?? true;
-  return shouldRun ? null : isBuiltInMiddleware;
+  const shouldSkip = options?.middleware === false || options?.middleware?.[phase] === false;
+  return shouldSkip ? isBuiltInMiddleware : null;
+}
+
+/**
+ * kareem `getOptions` implementation for custom statics and methods: reads the
+ * `middleware` option from the call's last argument if it is a plain object.
+ *
+ * @param {Array} args - Arguments the custom static or method was called with
+ * @returns {object} - Per-call kareem options with pre/post filters
+ */
+function middlewareFiltersFromLastArg(args) {
+  const lastArg = args[args.length - 1];
+  const options = isPOJO(lastArg) ? lastArg : null;
+  return {
+    pre: { filter: buildMiddlewareFilter(options, 'pre') },
+    post: { filter: buildMiddlewareFilter(options, 'post') }
+  };
 }
 
 module.exports = {
-  buildMiddlewareFilter
+  buildMiddlewareFilter,
+  middlewareFiltersFromLastArg
 };

package/lib/helpers/model/applyHooks.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { buildMiddlewareFilter } = require('../buildMiddlewareFilter');
+const { buildMiddlewareFilter, middlewareFiltersFromLastArg } = require('../buildMiddlewareFilter');
 
 /*!
  * ignore
@@ -118,8 +118,15 @@ function applyHooks(model, schema, options) {
     }
     const originalMethod = objToDecorate[method];
     objToDecorate[`$__${method}`] = objToDecorate[method];
+    // Only read the `middleware` option from the method's last argument if
+    // the method opts in via `supportsMiddlewareOption`. Custom methods have
+    // arbitrary signatures, so the last argument may be an object with an
+    // unrelated `middleware` property.
+    const methodOptions = originalMethod.supportsMiddlewareOption === true ?
+      { ...customMethodOptions, getOptions: middlewareFiltersFromLastArg } :
+      customMethodOptions;
     objToDecorate[method] = middleware.
-      createWrapper(method, originalMethod, null, customMethodOptions);
+      createWrapper(method, originalMethod, null, methodOptions);
   }
 }
 

package/lib/helpers/model/applyStaticHooks.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const { middlewareFiltersFromLastArg } = require('../buildMiddlewareFilter');
 const { queryMiddlewareFunctions, aggregateMiddlewareFunctions, modelMiddlewareFunctions, documentMiddlewareFunctions } = require('../../constants');
 
 const middlewareFunctions = Array.from(
@@ -27,7 +28,14 @@ module.exports = function applyStaticHooks(model, hooks, statics) {
     if (hooks.hasHooks(key)) {
       const original = model[key];
 
-      model[key] = hooks.createWrapper(key, original);
+      // Only read the `middleware` option from the static's last argument if
+      // the static opts in via `supportsMiddlewareOption`. Custom statics have
+      // arbitrary signatures, so the last argument may be an object with an
+      // unrelated `middleware` property.
+      const wrapperOptions = original.supportsMiddlewareOption === true ?
+        { getOptions: middlewareFiltersFromLastArg } :
+        undefined;
+      model[key] = hooks.createWrapper(key, original, null, wrapperOptions);
     }
   }
 };

package/lib/helpers/projection/isPathSelectedInclusive.js

@@ -7,19 +7,9 @@
 module.exports = function isPathSelectedInclusive(fields, path) {
   const chunks = path.split('.');
   let cur = '';
-  let j;
-  let keys;
-  let numKeys;
   for (let i = 0; i < chunks.length; ++i) {
-    cur += cur.length ? '.' : '' + chunks[i];
+    cur += cur.length ? '.' + chunks[i] : chunks[i];
     if (fields[cur]) {
-      keys = Object.keys(fields);
-      numKeys = keys.length;
-      for (j = 0; j < numKeys; ++j) {
-        if (keys[i].indexOf(cur + '.') === 0 && keys[i].indexOf(path) !== 0) {
-          continue;
-        }
-      }
       return true;
     }
   }

package/lib/helpers/query/cast$expr.js

@@ -264,7 +264,7 @@ function castComparison(val, schema, strictQuery) {
       throw new StrictModeError(path);
     }
   } else {
-    val[1] = _castExpression(val[1]);
+    val[1] = _castExpression(val[1], schema, strictQuery);
   }
 
   return val;

package/lib/model.js

@@ -1229,8 +1229,8 @@ Model.createCollection = async function createCollection(options) {
 
   // Remove middleware option before passing to MongoDB
   if (options?.middleware != null) {
-    options = { ...options };
-    delete options.middleware;
+    const { middleware, ...driverOptions } = options;
+    options = driverOptions;
   }
 
   [options] = await this.hooks.execPre('createCollection', this, [options], { filter: preFilter }).catch(err => {
@@ -1431,7 +1431,7 @@ Model.dropSearchIndex = async function dropSearchIndex(name) {
  *     const Customer = mongoose.model('Customer', schema);
  *
  *     await Customer.createSearchIndex({ name: 'test', definition: { mappings: { dynamic: true } } });
- *     const res = await Customer.listSearchIndexes(); // Includes `[{ name: 'test' }]`
+ *     const res = await Customer.listSearchIndexes(); // Includes `[{ id: '...', name: 'test', status: 'READY', queryable: true, latestDefinition: { ... } }]`
  *
  * @param {object} [options]
  * @return {Promise<Array>}
@@ -2134,6 +2134,48 @@ Model.find = function find(conditions, projection, options) {
   return mq.find(conditions);
 };
 
+/**
+ * Finds documents and counts the number of documents matching the filter.
+ *
+ * This function fires both `find` and `countDocuments` middleware.
+ *
+ * #### Example:
+ *
+ *     const [adventures, total] = await Adventure.findAndCount(
+ *       { type: 'jungle' },
+ *       null,
+ *       { sort: { name: 1 }, skip: 10, limit: 10 }
+ *     );
+ *
+ *     adventures; // Array of at most 10 documents matching type 'jungle'
+ *     total; // Number of documents matching type 'jungle'
+ *
+ * @param {object|ObjectId} filter
+ * @param {object|string|string[]} [projection] optional fields to return
+ * @param {object} [options] optional query options
+ * @return {Promise<Array>} a promise that resolves to `[documents, total]`
+ * @api public
+ */
+
+Model.findAndCount = async function findAndCount(conditions, projection, options) {
+  _checkContext(this, 'findAndCount');
+
+  if (options == null) {
+    throw new MongooseError('Model.findAndCount() requires an `options` argument with `sort` and `limit`');
+  }
+  if (options.sort == null) {
+    throw new MongooseError('Model.findAndCount() requires `options.sort`');
+  }
+  if (options.limit == null) {
+    throw new MongooseError('Model.findAndCount() requires `options.limit`');
+  }
+
+  const findQuery = this.find(conditions, projection, options);
+  const countQuery = findQuery.clone().countDocuments().skip(0).limit(null);
+
+  return Promise.all([findQuery.exec(), countQuery.exec()]);
+};
+
 /**
  * Finds a single document by its _id field. `findById(id)` is equivalent to `findOne({ _id: id })`.
  *
@@ -4597,8 +4639,8 @@ async function _populatePath(model, docs, populateOptions) {
         select = select.filter(field => field !== '-_id');
       } else {
         // preserve original select conditions by copying
-        select = { ...select };
-        delete select._id;
+        const { _id, ...selectWithoutId } = select;
+        select = selectWithoutId;
       }
     }
 

package/lib/query.js

@@ -5329,7 +5329,8 @@ Query.prototype._applyPaths = function applyPaths() {
  * Returns a wrapper around a [mongodb driver cursor](https://mongodb.github.io/node-mongodb-native/7.0/classes/FindCursor.html).
  * A QueryCursor exposes a Streams3 interface, as well as a `.next()` function.
  *
- * The `.cursor()` function triggers pre find hooks, but **not** post find hooks.
+ * The `.cursor()` function triggers pre find hooks before opening the cursor
+ * and post find hooks once per document, with an array containing that document.
  *
  * #### Example:
  *
@@ -5358,9 +5359,14 @@ Query.prototype._applyPaths = function applyPaths() {
  * #### Valid options
  *
  *   - `transform`: optional function which accepts a mongoose document. The return value of the function will be emitted on `data` and returned by `.next()`.
+ *   - [`middleware`](https://mongoosejs.com/docs/middleware.html#skipping): set to `false` to skip all user-defined middleware, or `{ pre: false }` / `{ post: false }` to skip only pre or post find hooks
  *
  * @return {QueryCursor}
  * @param {object} [options]
+ * @param {Function} [options.transform] optional function which accepts a mongoose document. The return value of the function will be emitted on `data` and returned by `.next()`.
+ * @param {boolean|object} [options.middleware=true] set to `false` to skip all user-defined middleware
+ * @param {boolean} [options.middleware.pre=true] set to `false` to skip only pre hooks
+ * @param {boolean} [options.middleware.post=true] set to `false` to skip only post hooks
  * @see QueryCursor https://mongoosejs.com/docs/api/querycursor.html
  * @api public
  */

package/lib/schema/array.js

@@ -400,7 +400,15 @@ SchemaArray.prototype.cast = function(value, doc, init, prev, options) {
           if (options.virtuals) {
             opts.virtuals = options.virtuals;
           }
-          rawValue[i] = caster.applySetters(rawValue[i], doc, init, void 0, opts);
+          if (rawValue[i] === undefined && caster.defaultValue !== undefined) {
+            // No need to add _skipMarkModified to opts here (fallback for `getDefault()` opts parameter)
+            // because array setters don't rely on Document.prototype.set() - subdocuments do rely on
+            // Document.prototype.set() when applying setters, which is why _skipMarkModified is necessary
+            // for subdocuments. But here we know that `caster` is an array not a subdocument.
+            rawValue[i] = caster.getDefault(doc, init, null, opts);
+          } else {
+            rawValue[i] = caster.applySetters(rawValue[i], doc, init, void 0, opts);
+          }
         }
       } catch (e) {
         // rethrow

package/lib/schema/documentArray.js

@@ -466,8 +466,8 @@ SchemaDocumentArray.prototype.cast = function(value, doc, init, prev, options) {
         // 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) {
-          options = { ...options };
-          delete options.path;
+          const { path, ...initOptions } = options;
+          options = initOptions;
         }
         rawArray[i] = subdoc.$init(rawArray[i], options);
       } else {

package/lib/schema/subdocument.js

@@ -206,8 +206,8 @@ SchemaSubdocument.prototype.cast = function(val, doc, init, priorVal, options) {
     // For change tracking, subdocuments use relative paths internally.
     // Here, `options.path` contains the absolute path and is only used by the subdocument constructor, not by $init.
     if (options.path != null) {
-      options = { ...options };
-      delete options.path;
+      const { path, ...initOptions } = options;
+      options = initOptions;
     }
     subdoc.$init(val, options);
     const exclude = isExclusive(selected);

package/lib/schema.js

@@ -2280,6 +2280,37 @@ Schema.prototype.plugin = function(fn, opts) {
   return this;
 };
 
+/**
+ * Adds a query helper to this schema. Equivalent to `schema.query[name] = fn`.
+ *
+ * #### Example:
+ *
+ *     schema.queryHelper('byName', function(name) {
+ *       return this.where({ name });
+ *     });
+ *     const Test = mongoose.model('Test', schema);
+ *     await Test.find().byName('John'); // Equivalent to `Test.find({ name: 'John' })`
+ *
+ * @param {string} name The query helper name.
+ * @param {Function} fn The query helper function.
+ * @return {Schema} this
+ * @api public
+ */
+
+Schema.prototype.queryHelper = function queryHelper(name, fn) {
+  if (typeof name !== 'string') {
+    throw new MongooseError('First param to `schema.queryHelper()` must be a string, ' +
+      'got "' + (typeof name) + '"');
+  }
+  if (typeof fn !== 'function') {
+    throw new MongooseError('Second param to `schema.queryHelper()` must be a function, ' +
+      'got "' + (typeof fn) + '"');
+  }
+
+  this.query[name] = fn;
+  return this;
+};
+
 /**
  * Adds an instance method to documents constructed from Models compiled from this schema.
  *
@@ -2310,9 +2341,21 @@ Schema.prototype.plugin = function(fn, opts) {
  *
  * NOTE: `Schema.method()` adds instance methods to the `Schema.methods` object. You can also add instance methods directly to the `Schema.methods` object as seen in the [guide](https://mongoosejs.com/docs/guide.html#methods)
  *
+ * If the method has hooks registered via `schema.pre('meow')` or `schema.post('meow')`, you can allow callers
+ * to skip them for a single call by setting `supportsMiddlewareOption = true` on the function:
+ *
+ *     schema.method('meow', function(options = {}) {
+ *       console.log('meeeeeoooooooooooow');
+ *     });
+ *     schema.methods.meow.supportsMiddlewareOption = true;
+ *
+ *     // Skips `pre('meow')` and `post('meow')` hooks
+ *     await fizz.meow({ middleware: false });
+ *
  * @param {string|object} name The Method Name for a single function, or an Object of "string-function" pairs.
  * @param {Function} [fn] The Function in a single-function definition.
  * @api public
+ * @see Skip Middleware https://mongoosejs.com/docs/middleware.html#skip-custom-statics-and-methods
  */
 
 Schema.prototype.method = function(name, fn, options) {
@@ -2355,10 +2398,22 @@ Schema.prototype.method = function(name, fn, options) {
  *
  * If a hash of name/fn pairs is passed as the only argument, each name/fn pair will be added as statics.
  *
+ * If the static has hooks registered via `schema.pre('findByName')` or `schema.post('findByName')`, you can allow
+ * callers to skip them for a single call by setting `supportsMiddlewareOption = true` on the function:
+ *
+ *     schema.static('findByName', function(name, options = {}) {
+ *       return this.find({ name: name });
+ *     });
+ *     schema.statics.findByName.supportsMiddlewareOption = true;
+ *
+ *     // Skips `pre('findByName')` and `post('findByName')` hooks
+ *     await Drink.findByName('LaCroix', { middleware: false });
+ *
  * @param {string|object} name The Method Name for a single function, or an Object of "string-function" pairs.
  * @param {Function} [fn] The Function in a single-function definition.
  * @api public
  * @see Statics https://mongoosejs.com/docs/guide.html#statics
+ * @see Skip Middleware https://mongoosejs.com/docs/middleware.html#skip-custom-statics-and-methods
  */
 
 Schema.prototype.static = function(name, fn) {

package/lib/schemaType.js

@@ -176,8 +176,7 @@ SchemaType.prototype.path;
  */
 
 SchemaType.prototype.toJSON = function toJSON() {
-  const res = { ...this };
-  delete res.parentSchema;
+  const { parentSchema, ...res } = this;
   return res;
 };
 
@@ -1299,11 +1298,12 @@ SchemaType.prototype.ref = function(ref) {
  * @param {object} options
  * @param {object} [options.context]
  * @param {boolean} [options.skipCast]
+ * @param {object} [applySettersOptions] passed to applySetters
  * @return {any} The Stored default value.
  * @api private
  */
 
-SchemaType.prototype.getDefault = function getDefault(parentDoc, init, options) {
+SchemaType.prototype.getDefault = function getDefault(parentDoc, init, options, applySettersOptions) {
   let ret;
   if (this.defaultValue == null) {
     return this.defaultValue;
@@ -1337,7 +1337,13 @@ SchemaType.prototype.getDefault = function getDefault(parentDoc, init, options)
       return this._applySetters(ret, parentDoc);
     }
 
-    const casted = this.applySetters(ret, parentDoc, init, undefined, setOptionsForDefaults);
+    const casted = this.applySetters(
+      ret,
+      parentDoc,
+      init,
+      undefined,
+      applySettersOptions ?? setOptionsForDefaults
+    );
     if (casted && !Array.isArray(casted) && casted.$isSingleNested) {
       casted.$__parent = parentDoc;
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "9.9.4",
+  "version": "9.10.0",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -21,8 +21,8 @@
   "license": "MIT",
   "dependencies": {
     "@standard-schema/spec": "^1.1.0",
-    "kareem": "3.3.0",
-    "mongodb": "~7.5",
+    "kareem": "3.4.0",
+    "mongodb": "~7.6",
     "mpath": "0.9.0",
     "mquery": "6.0.0",
     "ms": "2.1.3",
@@ -40,20 +40,20 @@
     "c8": "12.0.0",
     "cheerio": "1.2.0",
     "dox": "1.0.0",
-    "eslint": "10.8.0",
+    "eslint": "10.9.1",
     "eslint-plugin-mocha-no-only": "1.2.0",
     "express": "5.2.1",
     "fs-extra": "~11.4.0",
     "glob": "^13.0.6",
     "globals": "^17.4.0",
-    "highlight.js": "11.11.1",
+    "highlight.js": "11.12.0",
     "linkinator": "8.x",
     "lodash.isequal": "4.5.0",
     "lodash.isequalwith": "4.4.0",
     "markdownlint-cli2": "0.23.2",
-    "marked": "18.0.7",
+    "marked": "18.0.11",
     "mkdirp": "^3.0.1",
-    "mocha": "12.0.0-rc.5",
+    "mocha": "12.0.0-rc.6",
     "moment": "2.30.1",
     "mongodb-client-encryption": "^7.2.0",
     "mongodb-memory-server": "11.2.0",
@@ -64,7 +64,7 @@
     "tstyche": "^7.0.0",
     "typescript": "5.9.3",
     "typescript-eslint": "^8.31.1",
-    "uuid": "14.0.1",
+    "uuid": "14.0.2",
     "xss": "1.0.15"
   },
   "directories": {