@depup/mongoose 9.4.1-depup.0 → 9.8.0-depup.0

package/lib/query.js

@@ -20,6 +20,7 @@ const castArrayFilters = require('./helpers/update/castArrayFilters');
 const castNumber = require('./cast/number');
 const castUpdate = require('./helpers/query/castUpdate');
 const clone = require('./helpers/clone');
+const decorateUpdateWithVersionKey = require('./helpers/update/decorateUpdateWithVersionKey');
 const getDiscriminatorByValue = require('./helpers/discriminator/getDiscriminatorByValue');
 const helpers = require('./queryHelpers');
 const internalToObjectOptions = require('./options').internalToObjectOptions;
@@ -41,6 +42,8 @@ const updateValidators = require('./helpers/updateValidators');
 const util = require('util');
 const utils = require('./utils');
 const queryMiddlewareFunctions = require('./constants').queryMiddlewareFunctions;
+const { createTracedChannel } = require('./tracing');
+const { trace: traceQuery } = createTracedChannel('mongoose:query');
 
 const queryOptionMethods = new Set([
   'allowDiskUse',
@@ -85,6 +88,8 @@ const opToThunk = new Map([
   ['findOneAndDelete', '_findOneAndDelete']
 ]);
 
+const queryUpdateSymbol = Symbol('mongoose#Query#update');
+
 /**
  * Query constructor used for building queries. You do not need
  * to instantiate a `Query` directly. Instead use Model functions like
@@ -196,6 +201,18 @@ function checkRequireFilter(filter, options) {
 Query.prototype = new mquery();
 Query.prototype.constructor = Query;
 
+Object.defineProperty(Query.prototype, '_update', {
+  configurable: true,
+  enumerable: true,
+  get: function() {
+    _cloneUpdateIfShared(this);
+    return this[queryUpdateSymbol];
+  },
+  set: function(v) {
+    this[queryUpdateSymbol] = v;
+  }
+});
+
 // Remove some legacy methods that we removed in Mongoose 8, but
 // are still in mquery 5.
 Query.prototype.count = undefined;
@@ -300,7 +317,7 @@ Query.prototype.toConstructor = function toConstructor() {
   p.op = this.op;
   p._conditions = clone(this._conditions);
   p._fields = clone(this._fields);
-  p._update = clone(this._update, {
+  p[queryUpdateSymbol] = clone(this[queryUpdateSymbol], {
     flattenDecimals: false
   });
   p._path = this._path;
@@ -348,7 +365,7 @@ Query.prototype.clone = function() {
   q.op = this.op;
   q._conditions = clone(this._conditions);
   q._fields = clone(this._fields);
-  q._update = clone(this._update, {
+  q[queryUpdateSymbol] = clone(this[queryUpdateSymbol], {
     flattenDecimals: false
   });
   q._path = this._path;
@@ -1365,7 +1382,7 @@ Query.prototype.toString = function toString() {
       this.op === 'update' ||
       this.op === 'updateMany' ||
       this.op === 'updateOne') {
-    return `${this.model.modelName}.${this.op}(${util.inspect(this._conditions)}, ${util.inspect(this._update)})`;
+    return `${this.model.modelName}.${this.op}(${util.inspect(this._conditions)}, ${util.inspect(this[queryUpdateSymbol])})`;
   }
 
   // 'estimatedDocumentCount' or any others
@@ -1669,6 +1686,7 @@ Query.prototype.getOptions = function() {
  * - [upsert](https://www.mongodb.com/docs/manual/reference/method/db.collection.update/)
  * - [writeConcern](https://www.mongodb.com/docs/manual/reference/method/db.collection.update/)
  * - [timestamps](https://mongoosejs.com/docs/guide.html#timestamps): If `timestamps` is set in the schema, set this option to `false` to skip timestamps for that particular update. Has no effect if `timestamps` is not enabled in the schema options.
+ * - cloneUpdate: set to `false` to skip cloning the update before executing the query.
  * - overwriteDiscriminatorKey: allow setting the discriminator key in the update. Will use the correct discriminator schema if the update changes the discriminator key.
  * - overwriteImmutable: allow overwriting properties that are set to `immutable` in the schema. Defaults to false.
  *
@@ -1679,6 +1697,7 @@ Query.prototype.getOptions = function() {
  * - [projection](https://mongoosejs.com/docs/api/query.html#Query.prototype.projection())
  * - sanitizeProjection
  * - useBigInt64
+ * - defaults: if `false`, skip applying default values to the returned document(s). Defaults to true.
  *
  * The following options are only for all operations **except** `updateOne()`, `updateMany()`, `deleteOne()`, and `deleteMany()`:
  *
@@ -1751,6 +1770,10 @@ Query.prototype.setOptions = function(options, overwrite) {
     this._mongooseOptions.updatePipeline = options.updatePipeline;
     delete options.updatePipeline;
   }
+  if ('cloneUpdate' in options) {
+    this._mongooseOptions.cloneUpdate = options.cloneUpdate;
+    delete options.cloneUpdate;
+  }
   if ('sanitizeProjection' in options) {
     if (options.sanitizeProjection && !this._mongooseOptions.sanitizeProjection) {
       sanitizeProjection(this._fields);
@@ -1984,12 +2007,17 @@ Query.prototype.getUpdate = function() {
  *     query.getUpdate(); // { $set: { b: 6 } }
  *
  * @param {object} new update operation
+ * @param {boolean} [cloneUpdate=true] if `false`, Mongoose will not clone the update
  * @return {undefined}
  * @api public
  */
 
-Query.prototype.setUpdate = function(val) {
-  this._update = clone(val);
+Query.prototype.setUpdate = function(val, cloneUpdate) {
+  this[queryUpdateSymbol] = cloneUpdate === false ? val : clone(val);
+  if (cloneUpdate != null) {
+    this._mongooseOptions.cloneUpdate = cloneUpdate;
+  }
+  this._updateIsShared = false;
 };
 
 /**
@@ -2022,7 +2050,7 @@ Query.prototype._fieldsForExec = function() {
  */
 
 Query.prototype._updateForExec = function() {
-  const update = clone(this._update, {
+  const update = clone(this[queryUpdateSymbol], {
     transform: false,
     depopulate: true
   });
@@ -2216,6 +2244,8 @@ Query.prototype.lean = function(v) {
  */
 
 Query.prototype.set = function(path, val) {
+  _cloneUpdateIfShared(this);
+
   if (typeof path === 'object') {
     const keys = Object.keys(path);
     for (const key of keys) {
@@ -2224,12 +2254,16 @@ Query.prototype.set = function(path, val) {
     return this;
   }
 
-  this._update = this._update || {};
-  if (path in this._update) {
-    delete this._update[path];
+  let update = this[queryUpdateSymbol];
+  if (update == null) {
+    update = {};
+    this[queryUpdateSymbol] = update;
+  }
+  if (path in update) {
+    delete update[path];
   }
-  this._update.$set = this._update.$set || {};
-  this._update.$set[path] = val;
+  update.$set = update.$set || {};
+  update.$set[path] = val;
   return this;
 };
 
@@ -2249,7 +2283,7 @@ Query.prototype.set = function(path, val) {
  */
 
 Query.prototype.get = function get(path) {
-  const update = this._update;
+  const update = this[queryUpdateSymbol];
   if (update == null) {
     return void 0;
   }
@@ -2333,6 +2367,7 @@ Query.prototype._unsetCastError = function _unsetCastError() {
  * - `strictQuery`: controls how Mongoose handles keys that aren't in the schema for the query `filter`. This option is `false` by default, which means Mongoose will allow `Model.find({ foo: 'bar' })` even if `foo` is not in the schema. See the [`strictQuery` docs](https://mongoosejs.com/docs/guide.html#strictQuery) for more information.
  * - `nearSphere`: use `$nearSphere` instead of `near()`. See the [`Query.prototype.nearSphere()` docs](https://mongoosejs.com/docs/api/query.html#Query.prototype.nearSphere())
  * - `schemaLevelProjections`: if `false`, Mongoose will not apply schema-level `select: false` or `select: true` for this query
+ * - `cloneUpdate`: if `false`, Mongoose will not clone updates before executing the query
  *
  * Mongoose maintains a separate object for internal options because
  * Mongoose sends `Query.prototype.options` to the MongoDB server, and the
@@ -2421,6 +2456,12 @@ Query.prototype._find = async function _find() {
     lean: mongooseOptions.lean || null
   };
 
+  // Only pass `defaults` through when it is non-nullish; `null` and
+  // `undefined` are treated as "not set" and omitted from `createModel()`.
+  if (mongooseOptions.defaults != null) {
+    completeManyOptions.defaults = mongooseOptions.defaults;
+  }
+
   const options = this._optionsForExec();
 
   const filter = this._conditions;
@@ -2553,9 +2594,10 @@ Query.prototype.merge = function(source) {
       utils.merge(this.options, source.options, opts);
     }
 
-    if (source._update) {
-      this._update || (this._update = {});
-      utils.mergeClone(this._update, source._update);
+    if (source[queryUpdateSymbol] != null) {
+      _cloneUpdateIfShared(this);
+      this[queryUpdateSymbol] || (this[queryUpdateSymbol] = {});
+      utils.mergeClone(this[queryUpdateSymbol], source[queryUpdateSymbol]);
     }
 
     if (source._distinct) {
@@ -2691,7 +2733,7 @@ Query.prototype._completeMany = async function _completeMany(docs, fields, userP
   const model = this.model;
   return Promise.all(docs.map(doc => new Promise((resolve, reject) => {
     const rawDoc = doc;
-    doc = helpers.createModel(model, doc, fields, userProvidedFields);
+    doc = helpers.createModel(model, doc, fields, userProvidedFields, opts);
     if (opts.session != null) {
       doc.$session(opts.session);
     }
@@ -2849,9 +2891,10 @@ Query.prototype._applyTranslateAliases = function _applyTranslateAliases() {
   }
 
   if (this.model?.schema?.aliases && utils.hasOwnKeys(this.model.schema.aliases)) {
+    _cloneUpdateIfShared(this);
     this.model.translateAliases(this._conditions, true);
     this.model.translateAliases(this._fields, true);
-    this.model.translateAliases(this._update, true);
+    this.model.translateAliases(this[queryUpdateSymbol], true);
     if (this._distinct != null && this.model.schema.aliases[this._distinct] != null) {
       this._distinct = this.model.schema.aliases[this._distinct];
     }
@@ -3405,6 +3448,7 @@ function prepareDiscriminatorCriteria(query) {
  * @param {object|Query} [filter]
  * @param {object} [update]
  * @param {object} [options]
+ * @param {boolean} [options.cloneUpdate=true] if `false`, Mongoose will not clone the update before executing the query
  * @param {boolean} [options.includeResultMetadata] if true, returns the full [ModifyResult from the MongoDB driver](https://mongodb.github.io/node-mongodb-native/7.0/interfaces/ModifyResult.html) rather than just the document
  * @param {boolean|'throw'} [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).
@@ -3481,11 +3525,20 @@ Query.prototype.findOneAndUpdate = function(filter, update, options) {
     options.updatePipeline = updatePipeline;
   }
 
+  if (!options.updatePipeline && Array.isArray(update)) {
+    throw new MongooseError('Cannot pass an array to query updates unless the `updatePipeline` option is set.');
+  }
+
   this.setOptions(options);
 
   // apply doc
   if (update) {
-    this._mergeUpdate(update);
+    if (this[queryUpdateSymbol] == null || utils.isEmptyObject(this[queryUpdateSymbol])) {
+      this[queryUpdateSymbol] = update;
+      this._updateIsShared = true;
+    } else {
+      this._mergeUpdate(update);
+    }
   }
 
   return this;
@@ -3523,49 +3576,51 @@ Query.prototype._findOneAndUpdate = async function _findOneAndUpdate() {
   const options = this._optionsForExec(this.model);
   convertNewToReturnDocument(options);
 
-  this._update = this._castUpdate(this._update);
+  this[queryUpdateSymbol] = this._castUpdate(this[queryUpdateSymbol]);
+  this._updateIsShared = false;
+  decorateUpdateWithVersionKey(this[queryUpdateSymbol], options, this.schema.options.versionKey);
 
-  this._update = setDefaultsOnInsert(
+  this[queryUpdateSymbol] = setDefaultsOnInsert(
     this._conditions,
     this.model.schema,
-    this._update,
+    this[queryUpdateSymbol],
     options,
     this._mongooseOptions,
     this
   );
 
-  if (!this._update || utils.hasOwnKeys(this._update) === false) {
+  if (!this[queryUpdateSymbol] || utils.hasOwnKeys(this[queryUpdateSymbol]) === false) {
     if (options.upsert) {
       // still need to do the upsert to empty doc
-      const $set = clone(this._update);
+      const $set = clone(this[queryUpdateSymbol]);
       delete $set._id;
-      this._update = { $set };
+      this[queryUpdateSymbol] = { $set };
     } else {
       this._execCount = 0;
       const res = await this._findOne();
       return res;
     }
-  } else if (this._update instanceof Error) {
-    throw this._update;
+  } else if (this[queryUpdateSymbol] instanceof Error) {
+    throw this[queryUpdateSymbol];
   } else {
     // In order to make MongoDB 2.6 happy (see
     // https://jira.mongodb.org/browse/SERVER-12266 and related issues)
     // if we have an actual update document but $set is empty, junk the $set.
-    if (this._update.$set && utils.hasOwnKeys(this._update.$set) === false) {
-      delete this._update.$set;
+    if (this[queryUpdateSymbol].$set && utils.hasOwnKeys(this[queryUpdateSymbol].$set) === false) {
+      delete this[queryUpdateSymbol].$set;
     }
   }
 
   const runValidators = _getOption(this, 'runValidators', false);
   if (runValidators) {
-    await this.validate(this._update, options, false);
+    await this.validate(this[queryUpdateSymbol], options, false);
   }
 
-  if (typeof this._update.toBSON === 'function') {
-    this._update = this._update.toBSON();
+  if (typeof this[queryUpdateSymbol].toBSON === 'function') {
+    this[queryUpdateSymbol] = this[queryUpdateSymbol].toBSON();
   }
 
-  let res = await this.mongooseCollection.findOneAndUpdate(this._conditions, this._update, options);
+  let res = await this.mongooseCollection.findOneAndUpdate(this._conditions, this[queryUpdateSymbol], options);
   for (const fn of this._transforms) {
     res = fn(res);
   }
@@ -3701,6 +3756,7 @@ Query.prototype._findOneAndDelete = async function _findOneAndDelete() {
  * @param {object} [filter]
  * @param {object} [replacement]
  * @param {object} [options]
+ * @param {boolean} [options.cloneUpdate=true] if `false`, Mongoose will not clone the update before executing the query
  * @param {boolean} [options.includeResultMetadata] if true, returns the full [ModifyResult from the MongoDB driver](https://mongodb.github.io/node-mongodb-native/7.0/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|'throw'} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
@@ -3796,13 +3852,13 @@ Query.prototype._findOneAndReplace = async function _findOneAndReplace() {
   const runValidators = _getOption(this, 'runValidators', false);
 
   try {
-    const update = new this.model(this._update, null, modelOpts);
+    const update = new this.model(this[queryUpdateSymbol], null, modelOpts);
     if (runValidators) {
       await update.validate();
     } else if (update.$__.validationError) {
       throw update.$__.validationError;
     }
-    this._update = update.toBSON();
+    this[queryUpdateSymbol] = update.toBSON();
   } catch (err) {
     if (err instanceof ValidationError) {
       throw err;
@@ -3812,7 +3868,7 @@ Query.prototype._findOneAndReplace = async function _findOneAndReplace() {
     throw validationError;
   }
 
-  let res = await this.mongooseCollection.findOneAndReplace(filter, this._update, options);
+  let res = await this.mongooseCollection.findOneAndReplace(filter, this[queryUpdateSymbol], options);
 
   for (const fn of this._transforms) {
     res = fn(res);
@@ -3874,6 +3930,7 @@ Query.prototype.findById = function(id, projection, options) {
  * @param {any} id value of `_id` to query by
  * @param {object} [doc]
  * @param {object} [options]
+ * @param {boolean} [options.cloneUpdate=true] if `false`, Mongoose will not clone the update before executing the query
  * @param {boolean} [options.includeResultMetadata] if true, returns the full [ModifyResult from the MongoDB driver](https://mongodb.github.io/node-mongodb-native/7.0/interfaces/ModifyResult.html) rather than just the document
  * @param {boolean|'throw'} [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).
@@ -4049,12 +4106,14 @@ function _completeManyLean(schema, docs, path, opts) {
  */
 
 Query.prototype._mergeUpdate = function(update) {
+  _cloneUpdateIfShared(this);
+
   const updatePipeline = this._mongooseOptions.updatePipeline;
   if (!updatePipeline && Array.isArray(update)) {
     throw new MongooseError('Cannot pass an array to query updates unless the `updatePipeline` option is set.');
   }
-  if (!this._update) {
-    this._update = Array.isArray(update) ? [] : {};
+  if (!this[queryUpdateSymbol]) {
+    this[queryUpdateSymbol] = Array.isArray(update) ? [] : {};
   }
 
   if (update == null || (typeof update === 'object' && utils.hasOwnKeys(update) === false)) {
@@ -4062,28 +4121,28 @@ Query.prototype._mergeUpdate = function(update) {
   }
 
   if (update instanceof Query) {
-    if (Array.isArray(this._update)) {
-      throw new MongooseError(`Cannot mix array and object updates (current: ${_previewUpdate(this._update)}, incoming: ${_previewUpdate(update._update)})`);
+    if (Array.isArray(this[queryUpdateSymbol])) {
+      throw new MongooseError(`Cannot mix array and object updates (current: ${_previewUpdate(this[queryUpdateSymbol])}, incoming: ${_previewUpdate(update[queryUpdateSymbol])})`);
     }
-    if (update._update) {
-      utils.mergeClone(this._update, update._update);
+    if (update[queryUpdateSymbol]) {
+      utils.mergeClone(this[queryUpdateSymbol], update[queryUpdateSymbol]);
     }
   } else if (Array.isArray(update)) {
-    if (!Array.isArray(this._update)) {
+    if (!Array.isArray(this[queryUpdateSymbol])) {
       // `_update` may be empty object by default, like in `doc.updateOne()`
       // because we create the query first, then run hooks, then apply the update.
-      if (this._update == null || utils.isEmptyObject(this._update)) {
-        this._update = [];
+      if (this[queryUpdateSymbol] == null || utils.isEmptyObject(this[queryUpdateSymbol])) {
+        this[queryUpdateSymbol] = [];
       } else {
-        throw new MongooseError(`Cannot mix array and object updates (current: ${_previewUpdate(this._update)}, incoming: ${_previewUpdate(update)})`);
+        throw new MongooseError(`Cannot mix array and object updates (current: ${_previewUpdate(this[queryUpdateSymbol])}, incoming: ${_previewUpdate(update)})`);
       }
     }
-    this._update = this._update.concat(update);
+    this[queryUpdateSymbol] = this[queryUpdateSymbol].concat(update);
   } else {
-    if (Array.isArray(this._update)) {
-      throw new MongooseError(`Cannot mix array and object updates (current: ${_previewUpdate(this._update)}, incoming: ${_previewUpdate(update)})`);
+    if (Array.isArray(this[queryUpdateSymbol])) {
+      throw new MongooseError(`Cannot mix array and object updates (current: ${_previewUpdate(this[queryUpdateSymbol])}, incoming: ${_previewUpdate(update)})`);
     }
-    utils.mergeClone(this._update, update);
+    utils.mergeClone(this[queryUpdateSymbol], update);
   }
 };
 
@@ -4157,30 +4216,31 @@ Query.prototype._updateMany = async function _updateMany() {
   }
 
   const options = this._optionsForExec(this.model);
-  this._update = this._castUpdate(this._update);
-  if (this._update == null || utils.hasOwnKeys(this._update) === false) {
+  _cloneUpdateIfShared(this);
+  this[queryUpdateSymbol] = this._castUpdate(this[queryUpdateSymbol]);
+  if (this[queryUpdateSymbol] == null || utils.hasOwnKeys(this[queryUpdateSymbol]) === false) {
     return { acknowledged: false };
   }
-  removeUnusedArrayFilters(this._update, options);
+  removeUnusedArrayFilters(this[queryUpdateSymbol], options);
 
-  this._update = setDefaultsOnInsert(
+  this[queryUpdateSymbol] = setDefaultsOnInsert(
     this._conditions,
     this.model.schema,
-    this._update,
+    this[queryUpdateSymbol],
     options,
     this._mongooseOptions,
     this
   );
 
   if (_getOption(this, 'runValidators', false)) {
-    await this.validate(this._update, options, false);
+    await this.validate(this[queryUpdateSymbol], options, false);
   }
 
-  if (typeof this._update.toBSON === 'function') {
-    this._update = this._update.toBSON();
+  if (typeof this[queryUpdateSymbol].toBSON === 'function') {
+    this[queryUpdateSymbol] = this[queryUpdateSymbol].toBSON();
   }
 
-  return this.mongooseCollection.updateMany(this._conditions, this._update, options);
+  return this.mongooseCollection.updateMany(this._conditions, this[queryUpdateSymbol], options);
 };
 
 /**
@@ -4202,30 +4262,31 @@ Query.prototype._updateOne = async function _updateOne() {
   }
 
   const options = this._optionsForExec(this.model);
-  this._update = this._castUpdate(this._update);
-  if (this._update == null || utils.hasOwnKeys(this._update) === false) {
+  _cloneUpdateIfShared(this);
+  this[queryUpdateSymbol] = this._castUpdate(this[queryUpdateSymbol]);
+  if (this[queryUpdateSymbol] == null || utils.hasOwnKeys(this[queryUpdateSymbol]) === false) {
     return { acknowledged: false };
   }
-  removeUnusedArrayFilters(this._update, options);
+  removeUnusedArrayFilters(this[queryUpdateSymbol], options);
 
-  this._update = setDefaultsOnInsert(
+  this[queryUpdateSymbol] = setDefaultsOnInsert(
     this._conditions,
     this.model.schema,
-    this._update,
+    this[queryUpdateSymbol],
     options,
     this._mongooseOptions,
     this
   );
 
   if (_getOption(this, 'runValidators', false)) {
-    await this.validate(this._update, options, false);
+    await this.validate(this[queryUpdateSymbol], options, false);
   }
 
-  if (typeof this._update.toBSON === 'function') {
-    this._update = this._update.toBSON();
+  if (typeof this[queryUpdateSymbol].toBSON === 'function') {
+    this[queryUpdateSymbol] = this[queryUpdateSymbol].toBSON();
   }
 
-  return this.mongooseCollection.updateOne(this._conditions, this._update, options);
+  return this.mongooseCollection.updateOne(this._conditions, this[queryUpdateSymbol], options);
 };
 
 /**
@@ -4247,18 +4308,18 @@ Query.prototype._replaceOne = async function _replaceOne() {
   }
 
   const options = this._optionsForExec(this.model);
-  this._update = new this.model(this._update, null, { skipId: true });
-  removeUnusedArrayFilters(this._update, options);
+  this[queryUpdateSymbol] = new this.model(this[queryUpdateSymbol], null, { skipId: true });
+  removeUnusedArrayFilters(this[queryUpdateSymbol], options);
 
   if (_getOption(this, 'runValidators', false)) {
-    await this.validate(this._update, options, true);
+    await this.validate(this[queryUpdateSymbol], options, true);
   }
 
-  if (typeof this._update.toBSON === 'function') {
-    this._update = this._update.toBSON();
+  if (typeof this[queryUpdateSymbol].toBSON === 'function') {
+    this[queryUpdateSymbol] = this[queryUpdateSymbol].toBSON();
   }
 
-  return this.mongooseCollection.replaceOne(this._conditions, this._update, options);
+  return this.mongooseCollection.replaceOne(this._conditions, this[queryUpdateSymbol], options);
 };
 
 /**
@@ -4285,6 +4346,7 @@ Query.prototype._replaceOne = async function _replaceOne() {
  * @param {object} [filter]
  * @param {object|Array} [update] the update command. If array, this update will be treated as an update pipeline and not casted.
  * @param {object} [options]
+ * @param {boolean} [options.cloneUpdate=true] if `false`, Mongoose will not clone the update before executing the 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|'throw'} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
  * @param {boolean} [options.upsert=false] if true, and no documents found, insert a new document
@@ -4360,6 +4422,7 @@ Query.prototype.updateMany = function(conditions, doc, options, callback) {
  * @param {object} [filter]
  * @param {object|Array} [update] the update command. If array, this update will be treated as an update pipeline and not casted.
  * @param {object} [options]
+ * @param {boolean} [options.cloneUpdate=true] if `false`, Mongoose will not clone the update before executing the 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|'throw'} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
  * @param {boolean} [options.upsert=false] if true, and no documents found, insert a new document
@@ -4429,6 +4492,7 @@ Query.prototype.updateOne = function(conditions, doc, options, callback) {
  * @param {object} [filter]
  * @param {object} [doc] the update command
  * @param {object} [options]
+ * @param {boolean} [options.cloneUpdate=true] if `false`, Mongoose will not clone the update before executing the 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|'throw'} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
  * @param {boolean} [options.upsert=false] if true, and no documents found, insert a new document
@@ -4510,11 +4574,20 @@ function _update(query, op, filter, doc, options, callback) {
     options.updatePipeline = updatePipeline;
   }
 
+  if (!options?.updatePipeline && Array.isArray(doc)) {
+    throw new MongooseError('Cannot pass an array to query updates unless the `updatePipeline` option is set.');
+  }
+
   if (utils.isObject(options)) {
     query.setOptions(options);
   }
 
-  query._mergeUpdate(doc);
+  if (query[queryUpdateSymbol] == null || utils.isEmptyObject(query[queryUpdateSymbol])) {
+    query[queryUpdateSymbol] = doc;
+    query._updateIsShared = true;
+  } else {
+    query._mergeUpdate(doc);
+  }
 
   // Hooks
   if (callback) {
@@ -4707,42 +4780,56 @@ Query.prototype.exec = async function exec(op) {
   }
   this._execCount++;
 
-  let skipWrappedFunction = null;
-  try {
-    await this._hooks.execPre('exec', this, []);
-  } catch (err) {
-    if (err instanceof Kareem.skipWrappedFunction) {
-      skipWrappedFunction = err;
-    } else {
-      throw err;
+  const _this = this;
+  return traceQuery(async function maybeTracedQueryExec() {
+    let skipWrappedFunction = null;
+    try {
+      await _this._hooks.execPre('exec', _this, []);
+    } catch (err) {
+      if (err instanceof Kareem.skipWrappedFunction) {
+        skipWrappedFunction = err;
+      } else {
+        throw err;
+      }
     }
-  }
 
-  let res;
+    let res;
 
-  let error = null;
-  try {
-    await _executePreHooks(this);
-    res = skipWrappedFunction ? skipWrappedFunction.args[0] : await this[thunk]();
+    let error = null;
+    try {
+      await _executePreHooks(_this);
+      res = skipWrappedFunction ? skipWrappedFunction.args[0] : await _this[thunk]();
 
-    for (const fn of this._transforms) {
-      res = fn(res);
-    }
-  } catch (err) {
-    if (err instanceof Kareem.skipWrappedFunction) {
-      res = err.args[0];
-    } else {
-      error = err;
-    }
+      for (const fn of _this._transforms) {
+        res = fn(res);
+      }
+    } catch (err) {
+      if (err instanceof Kareem.skipWrappedFunction) {
+        res = err.args[0];
+      } else {
+        error = err;
+      }
 
-    error = this.model.schema._transformDuplicateKeyError(error);
-  }
+      error = _this.model.schema._transformDuplicateKeyError(error);
+    }
 
-  res = await _executePostHooks(this, res, error);
+    res = await _executePostHooks(_this, res, error);
 
-  await this._hooks.execPost('exec', this, []);
+    await _this._hooks.execPost('exec', _this, []);
 
-  return res;
+    return res;
+  }, () => ({
+    operation: _this.op,
+    collection: _this.mongooseCollection.name,
+    database: _this.model.db?.name,
+    serverAddress: _this.model.db?.host,
+    serverPort: _this.model.db?.port,
+    args: {
+      filter: _this.getFilter(),
+      fields: _this._fields,
+      options: _this._mongooseOptions
+    }
+  }));
 };
 
 /*!
@@ -4789,6 +4876,20 @@ function _executePreHooks(query, op) {
   );
 }
 
+function _cloneUpdateIfShared(query) {
+  if (!query._updateIsShared) {
+    return;
+  }
+  if (query.mongooseOptions().cloneUpdate === false) {
+    return;
+  }
+
+  query[queryUpdateSymbol] = clone(query[queryUpdateSymbol], {
+    flattenDecimals: false
+  });
+  query._updateIsShared = false;
+}
+
 /**
  * Executes the query returning a `Promise` which will be
  * resolved with either the doc(s) or rejected with the error.
@@ -4987,12 +5088,17 @@ Query.prototype._castUpdate = function _castUpdate(obj) {
  * @param {object} [match] Conditions for the population query
  * @param {object} [options] Options for the population query (sort, etc)
  * @param {string} [options.path=null] The path to populate.
+ * @param {string|PopulateOptions} [options.populate=null] Recursively populate paths in the populated documents. See [deep populate docs](https://mongoosejs.com/docs/populate.html#deep-populate).
  * @param {boolean} [options.retainNullValues=false] by default, Mongoose removes null and undefined values from populated arrays. Use this option to make `populate()` retain `null` and `undefined` array entries.
  * @param {boolean} [options.getters=false] if true, Mongoose will call any getters defined on the `localField`. By default, Mongoose gets the raw value of `localField`. For example, you would need to set this option to `true` if you wanted to [add a `lowercase` getter to your `localField`](https://mongoosejs.com/docs/schematypes.html#schematype-options).
  * @param {boolean} [options.clone=false] When you do `BlogPost.find().populate('author')`, blog posts with the same author will share 1 copy of an `author` doc. Enable this option to make Mongoose clone populated docs before assigning them.
  * @param {object|Function} [options.match=null] Add an additional filter to the populate query. Can be a filter object containing [MongoDB query syntax](https://www.mongodb.com/docs/manual/tutorial/query-documents/), or a function that returns a filter object.
+ * @param {boolean} [options.skipInvalidIds=false] By default, Mongoose throws a cast error if `localField` and `foreignField` schemas don't line up. If you enable this option, Mongoose will instead filter out any `localField` properties that cannot be casted to `foreignField`'s schema type.
+ * @param {number} [options.perDocumentLimit=null] For legacy reasons, `limit` with `populate()` may give incorrect results because it only executes a single query for every document being populated. If you set `perDocumentLimit`, Mongoose will ensure correct `limit` per document by executing a separate query for each document to `populate()`. For example, `.find().populate({ path: 'test', perDocumentLimit: 2 })` will execute 2 additional queries if `.find()` returns 2 documents.
+ * @param {boolean} [options.strictPopulate=true] Set to false to allow populating paths that aren't defined in the given model's schema.
  * @param {Function} [options.transform=null] Function that Mongoose will call on every populated document that allows you to transform the populated document.
  * @param {object} [options.options=null] Additional options like `limit` and `lean`.
+ * @param {boolean} [options.ordered=false] Set to `true` to execute any populate queries one at a time, as opposed to in parallel. Set this option to `true` if populating multiple paths or paths with multiple models in transactions.
  * @see population https://mongoosejs.com/docs/populate.html
  * @see Query#select https://mongoosejs.com/docs/api/query.html#Query.prototype.select()
  * @see Model.populate https://mongoosejs.com/docs/api/model.html#Model.populate()