mongoose 8.13.2 → 8.14.0

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/error/index.js

@@ -65,32 +65,32 @@ MongooseError.messages = require('./messages');
 MongooseError.Messages = MongooseError.messages;
 
 /**
- * An instance of this error class will be returned when `save()` fails
- * because the underlying
- * document was not found. The constructor takes one parameter, the
- * conditions that mongoose passed to `updateOne()` when trying to update
- * the document.
+ * An instance of this error class will be thrown when mongoose failed to
+ * cast a value.
  *
  * @api public
  * @memberOf Error
  * @static
  */
 
-MongooseError.DocumentNotFoundError = require('./notFound');
+MongooseError.CastError = require('./cast');
 
 /**
- * An instance of this error class will be returned when mongoose failed to
- * cast a value.
+ * An instance of this error class will be thrown when `save()` fails
+ * because the underlying
+ * document was not found. The constructor takes one parameter, the
+ * conditions that mongoose passed to `updateOne()` when trying to update
+ * the document.
  *
  * @api public
  * @memberOf Error
  * @static
  */
 
-MongooseError.CastError = require('./cast');
+MongooseError.DocumentNotFoundError = require('./notFound');
 
 /**
- * An instance of this error class will be returned when [validation](https://mongoosejs.com/docs/validation.html) failed.
+ * An instance of this error class will be thrown when [validation](https://mongoosejs.com/docs/validation.html) failed.
  * The `errors` property contains an object whose keys are the paths that failed and whose values are
  * instances of CastError or ValidationError.
  *
@@ -137,7 +137,7 @@ MongooseError.ValidationError = require('./validation');
 MongooseError.ValidatorError = require('./validator');
 
 /**
- * An instance of this error class will be returned when you call `save()` after
+ * An instance of this error class will be thrown when you call `save()` after
  * the document in the database was changed in a potentially unsafe way. See
  * the [`versionKey` option](https://mongoosejs.com/docs/guide.html#versionKey) for more information.
  *
@@ -149,7 +149,7 @@ MongooseError.ValidatorError = require('./validator');
 MongooseError.VersionError = require('./version');
 
 /**
- * An instance of this error class will be returned when you call `save()` multiple
+ * An instance of this error class will be thrown when you call `save()` multiple
  * times on the same document in parallel. See the [FAQ](https://mongoosejs.com/docs/faq.html) for more
  * information.
  *
@@ -181,6 +181,16 @@ MongooseError.OverwriteModelError = require('./overwriteModel');
 
 MongooseError.MissingSchemaError = require('./missingSchema');
 
+/**
+ * Thrown when some documents failed to save when calling `bulkSave()`
+ *
+ * @api public
+ * @memberOf Error
+ * @static
+ */
+
+MongooseError.MongooseBulkSaveIncompleteError = require('./bulkSaveIncompleteError');
+
 /**
  * Thrown when the MongoDB Node driver can't connect to a valid server
  * to send an operation to.
@@ -193,7 +203,7 @@ MongooseError.MissingSchemaError = require('./missingSchema');
 MongooseError.MongooseServerSelectionError = require('./serverSelection');
 
 /**
- * An instance of this error will be returned if you used an array projection
+ * An instance of this error will be thrown if you used an array projection
  * and then modified the array in an unsafe way.
  *
  * @api public

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/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;

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

@@ -3096,13 +3096,12 @@ function _handleSortValue(val, key) {
  *
  *     await Character.deleteOne({ name: 'Eddard Stark' });
  *
- * This function calls the MongoDB driver's [`Collection#deleteOne()` function](https://mongodb.github.io/node-mongodb-native/4.9/classes/Collection.html#deleteOne).
+ * This function calls the MongoDB driver's [`Collection#deleteOne()` function](https://mongodb.github.io/node-mongodb-native/6.15/classes/Collection.html#deleteOne).
  * The returned [promise](https://mongoosejs.com/docs/queries.html) resolves to an
- * object that contains 3 properties:
+ * object that contains 2 properties:
  *
- * - `ok`: `1` if no errors occurred
+ * - `acknowledged`: boolean
  * - `deletedCount`: the number of documents deleted
- * - `n`: the number of documents deleted. Equal to `deletedCount`.
  *
  * #### Example:
  *
@@ -3113,8 +3112,8 @@ function _handleSortValue(val, key) {
  * @param {Object|Query} [filter] mongodb selector
  * @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
  * @return {Query} this
- * @see DeleteResult https://mongodb.github.io/node-mongodb-native/4.9/interfaces/DeleteResult.html
- * @see deleteOne https://mongodb.github.io/node-mongodb-native/4.9/classes/Collection.html#deleteOne
+ * @see DeleteResult https://mongodb.github.io/node-mongodb-native/6.15/interfaces/DeleteResult.html
+ * @see deleteOne https://mongodb.github.io/node-mongodb-native/6.15/classes/Collection.html#deleteOne
  * @api public
  */
 
@@ -3169,13 +3168,12 @@ Query.prototype._deleteOne = async function _deleteOne() {
  *
  *     await Character.deleteMany({ name: /Stark/, age: { $gte: 18 } });
  *
- * This function calls the MongoDB driver's [`Collection#deleteMany()` function](https://mongodb.github.io/node-mongodb-native/4.9/classes/Collection.html#deleteMany).
+ * This function calls the MongoDB driver's [`Collection#deleteMany()` function](https://mongodb.github.io/node-mongodb-native/6.15/classes/Collection.html#deleteMany).
  * The returned [promise](https://mongoosejs.com/docs/queries.html) resolves to an
- * object that contains 3 properties:
+ * object that contains 2 properties:
  *
- * - `ok`: `1` if no errors occurred
+ * - `acknowledged`: boolean
  * - `deletedCount`: the number of documents deleted
- * - `n`: the number of documents deleted. Equal to `deletedCount`.
  *
  * #### Example:
  *
@@ -3186,8 +3184,8 @@ Query.prototype._deleteOne = async function _deleteOne() {
  * @param {Object|Query} [filter] mongodb selector
  * @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
  * @return {Query} this
- * @see DeleteResult https://mongodb.github.io/node-mongodb-native/4.9/interfaces/DeleteResult.html
- * @see deleteMany https://mongodb.github.io/node-mongodb-native/4.9/classes/Collection.html#deleteMany
+ * @see DeleteResult https://mongodb.github.io/node-mongodb-native/6.15/interfaces/DeleteResult.html
+ * @see deleteMany https://mongodb.github.io/node-mongodb-native/6.15/classes/Collection.html#deleteMany
  * @api public
  */
 
@@ -3309,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
@@ -3333,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.
@@ -3726,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.
@@ -4431,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/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/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/utils.js

@@ -234,6 +234,38 @@ exports.omit = function omit(obj, keys) {
   return ret;
 };
 
+/**
+ * Simplified version of `clone()` that only clones POJOs and arrays. Skips documents, dates, objectids, etc.
+ * @param {*} val
+ * @returns
+*/
+
+exports.clonePOJOsAndArrays = function clonePOJOsAndArrays(val) {
+  if (val == null) {
+    return val;
+  }
+  // Skip documents because we assume they'll be cloned later. See gh-15312 for how documents are handled with `merge()`.
+  if (val.$__ != null) {
+    return val;
+  }
+  if (isPOJO(val)) {
+    val = { ...val };
+    for (const key of Object.keys(val)) {
+      val[key] = exports.clonePOJOsAndArrays(val[key]);
+    }
+    return val;
+  }
+  if (Array.isArray(val)) {
+    val = [...val];
+    for (let i = 0; i < val.length; ++i) {
+      val[i] = exports.clonePOJOsAndArrays(val[i]);
+    }
+    return val;
+  }
+
+  return val;
+};
+
 /**
  * Merges `from` into `to` without overwriting existing properties.
  *
@@ -271,13 +303,7 @@ exports.merge = function merge(to, from, options, path) {
       continue;
     }
     if (to[key] == null) {
-      if (isPOJO(from[key])) {
-        to[key] = { ...from[key] };
-      } else if (Array.isArray(from[key])) {
-        to[key] = [...from[key]];
-      } else {
-        to[key] = from[key];
-      }
+      to[key] = exports.clonePOJOsAndArrays(from[key]);
     } else if (exports.isObject(from[key])) {
       if (!exports.isObject(to[key])) {
         to[key] = {};

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.2",
+  "version": "8.14.0",
   "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/aggregate.d.ts

@@ -124,7 +124,7 @@ declare module 'mongoose' {
     pipeline(): PipelineStage[];
 
     /** Appends a new $project operator to this aggregate pipeline. */
-    project(arg: PipelineStage.Project['$project']): this;
+    project(arg: PipelineStage.Project['$project'] | string): this;
 
     /** Sets the readPreference option for the aggregation query. */
     read(pref: mongodb.ReadPreferenceLike): this;

package/types/connection.d.ts

@@ -58,12 +58,34 @@ declare module 'mongoose' {
     sanitizeFilter?: boolean;
   }
 
+  export type AnyConnectionBulkWriteModel<TSchema extends AnyObject> = Omit<mongodb.ClientInsertOneModel<TSchema>, 'namespace'>
+    | Omit<mongodb.ClientReplaceOneModel<TSchema>, 'namespace'>
+    | Omit<mongodb.ClientUpdateOneModel<TSchema>, 'namespace'>
+    | Omit<mongodb.ClientUpdateManyModel<TSchema>, 'namespace'>
+    | Omit<mongodb.ClientDeleteOneModel<TSchema>, 'namespace'>
+    | Omit<mongodb.ClientDeleteManyModel<TSchema>, 'namespace'>;
+
+  export type ConnectionBulkWriteModel<SchemaMap extends Record<string, AnyObject> = Record<string, AnyObject>> = {
+      [ModelName in keyof SchemaMap]: AnyConnectionBulkWriteModel<SchemaMap[ModelName]> & {
+          model: ModelName;
+      };
+  }[keyof SchemaMap];
+
   class Connection extends events.EventEmitter implements SessionStarter {
     aggregate<ResultType = unknown>(pipeline?: PipelineStage[] | null, options?: AggregateOptions): Aggregate<Array<ResultType>>;
 
     /** Returns a promise that resolves when this connection successfully connects to MongoDB */
     asPromise(): Promise<this>;
 
+    bulkWrite<TSchemaMap extends Record<string, AnyObject>>(
+      ops: Array<ConnectionBulkWriteModel<TSchemaMap>>,
+      options: mongodb.ClientBulkWriteOptions & { ordered: false }
+    ): Promise<mongodb.ClientBulkWriteResult & { mongoose?: { validationErrors: Error[], results: Array<Error | mongodb.WriteError | null> } }>;
+    bulkWrite<TSchemaMap extends Record<string, AnyObject>>(
+      ops: Array<ConnectionBulkWriteModel<TSchemaMap>>,
+      options?: mongodb.ClientBulkWriteOptions
+    ): Promise<mongodb.ClientBulkWriteResult>;
+
     /** Closes the connection */
     close(force?: boolean): Promise<void>;
 

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/error.d.ts

@@ -129,5 +129,12 @@ declare module 'mongoose' {
       name: 'StrictPopulateError';
       path: string;
     }
+
+    export class MongooseBulkSaveIncompleteError extends MongooseError {
+      name: 'MongooseBulkSaveIncompleteError';
+      modelName: string;
+      bulkWriteResult: mongodb.BulkWriteResult;
+      numDocumentsNotUpdated: number;
+    }
   }
 }