mongoose 8.2.0 → 8.2.2

package/lib/connection.js

@@ -829,6 +829,30 @@ Connection.prototype.openUri = async function openUri(uri, options) {
   return this;
 };
 
+/*!
+ * Treat `on('error')` handlers as handling the initialConnection promise
+ * to avoid uncaught exceptions when using `on('error')`. See gh-14377.
+ */
+
+Connection.prototype.on = function on(event, callback) {
+  if (event === 'error' && this.$initialConnection) {
+    this.$initialConnection.catch(() => {});
+  }
+  return EventEmitter.prototype.on.call(this, event, callback);
+};
+
+/*!
+ * Treat `once('error')` handlers as handling the initialConnection promise
+ * to avoid uncaught exceptions when using `on('error')`. See gh-14377.
+ */
+
+Connection.prototype.once = function on(event, callback) {
+  if (event === 'error' && this.$initialConnection) {
+    this.$initialConnection.catch(() => {});
+  }
+  return EventEmitter.prototype.once.call(this, event, callback);
+};
+
 /*!
  * ignore
  */

package/lib/document.js

@@ -742,7 +742,7 @@ function init(self, obj, doc, opts, prefix) {
     if (i === '__proto__' || i === 'constructor') {
       return;
     }
-    path = prefix + i;
+    path = prefix ? prefix + i : i;
     schemaType = docSchema.path(path);
     // Should still work if not a model-level discriminator, but should not be
     // necessary. This is *only* to catch the case where we queried using the
@@ -751,7 +751,8 @@ function init(self, obj, doc, opts, prefix) {
       return;
     }
 
-    if (!schemaType && utils.isPOJO(obj[i])) {
+    const value = obj[i];
+    if (!schemaType && utils.isPOJO(value)) {
       // assume nested object
       if (!doc[i]) {
         doc[i] = {};
@@ -759,29 +760,30 @@ function init(self, obj, doc, opts, prefix) {
           self[i] = doc[i];
         }
       }
-      init(self, obj[i], doc[i], opts, path + '.');
+      init(self, value, doc[i], opts, path + '.');
     } else if (!schemaType) {
-      doc[i] = obj[i];
+      doc[i] = value;
       if (!strict && !prefix) {
-        self[i] = obj[i];
+        self[i] = value;
       }
     } else {
       // Retain order when overwriting defaults
-      if (doc.hasOwnProperty(i) && obj[i] !== void 0 && !opts.hydratedPopulatedDocs) {
+      if (doc.hasOwnProperty(i) && value !== void 0 && !opts.hydratedPopulatedDocs) {
         delete doc[i];
       }
-      if (obj[i] === null) {
+      if (value === null) {
         doc[i] = schemaType._castNullish(null);
-      } else if (obj[i] !== undefined) {
-        const wasPopulated = obj[i].$__ == null ? null : obj[i].$__.wasPopulated;
-        if ((schemaType && !wasPopulated) && !opts.hydratedPopulatedDocs) {
+      } else if (value !== undefined) {
+        const wasPopulated = value.$__ == null ? null : value.$__.wasPopulated;
+
+        if (schemaType && !wasPopulated && !opts.hydratedPopulatedDocs) {
           try {
             if (opts && opts.setters) {
               // Call applySetters with `init = false` because otherwise setters are a noop
               const overrideInit = false;
-              doc[i] = schemaType.applySetters(obj[i], self, overrideInit);
+              doc[i] = schemaType.applySetters(value, self, overrideInit);
             } else {
-              doc[i] = schemaType.cast(obj[i], self, true);
+              doc[i] = schemaType.cast(value, self, true);
             }
           } catch (e) {
             self.invalidate(e.path, new ValidatorError({
@@ -793,7 +795,7 @@ function init(self, obj, doc, opts, prefix) {
             }));
           }
         } else {
-          doc[i] = obj[i];
+          doc[i] = value;
         }
       }
       // mark as hydrated
@@ -1388,6 +1390,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
     if (schema.options &&
         Array.isArray(schema.options[typeKey]) &&
         schema.options[typeKey].length &&
+        schema.options[typeKey][0] &&
         schema.options[typeKey][0].ref &&
         _isManuallyPopulatedArray(val, schema.options[typeKey][0].ref)) {
       popOpts = { [populateModelSymbol]: val[0].constructor };
@@ -4735,7 +4738,7 @@ Document.prototype.$clone = function() {
   const clonedDoc = new Model();
   clonedDoc.$isNew = this.$isNew;
   if (this._doc) {
-    clonedDoc._doc = clone(this._doc);
+    clonedDoc._doc = clone(this._doc, { retainDocuments: true });
   }
   if (this.$__) {
     const Cache = this.$__.constructor;

package/lib/drivers/node-mongodb-native/collection.js

@@ -136,11 +136,10 @@ function iter(i) {
       let promise = null;
       let timeout = null;
       if (syncCollectionMethods[i] && typeof lastArg === 'function') {
-        this.addQueue(() => {
-          lastArg.call(this, null, this[i].apply(this, _args.slice(0, _args.length - 1)));
-        }, []);
+        this.addQueue(i, _args);
+        callback = lastArg;
       } else if (syncCollectionMethods[i]) {
-        promise = new Promise((resolve, reject) => {
+        promise = new this.Promise((resolve, reject) => {
           callback = function collectionOperationCallback(err, res) {
             if (timeout != null) {
               clearTimeout(timeout);

package/lib/helpers/clone.js

@@ -36,10 +36,23 @@ function clone(obj, options, isArrayChild) {
   }
 
   if (isMongooseObject(obj)) {
-    // Single nested subdocs should apply getters later in `applyGetters()`
-    // when calling `toObject()`. See gh-7442, gh-8295
-    if (options && options._skipSingleNestedGetters && obj.$isSingleNested) {
-      options = Object.assign({}, options, { getters: false });
+    if (options) {
+      // Single nested subdocs should apply getters later in `applyGetters()`
+      // when calling `toObject()`. See gh-7442, gh-8295
+      if (options._skipSingleNestedGetters && obj.$isSingleNested) {
+        options = Object.assign({}, options, { getters: false });
+      }
+      if (options.retainDocuments && obj.$__ != null) {
+        const clonedDoc = obj.$clone();
+        if (obj.__index != null) {
+          clonedDoc.__index = obj.__index;
+        }
+        if (obj.__parentArray != null) {
+          clonedDoc.__parentArray = obj.__parentArray;
+        }
+        clonedDoc.$__parent = obj.$__parent;
+        return clonedDoc;
+      }
     }
     const isSingleNested = obj.$isSingleNested;
 

package/lib/helpers/discriminator/applyEmbeddedDiscriminators.js

@@ -19,11 +19,10 @@ function applyEmbeddedDiscriminators(schema, seen = new WeakSet()) {
     if (schemaType._appliedDiscriminators) {
       continue;
     }
-    for (const disc of schemaType.schema._applyDiscriminators.keys()) {
-      schemaType.discriminator(
-        disc,
-        schemaType.schema._applyDiscriminators.get(disc)
-      );
+    for (const discriminatorKey of schemaType.schema._applyDiscriminators.keys()) {
+      const discriminatorSchema = schemaType.schema._applyDiscriminators.get(discriminatorKey);
+      applyEmbeddedDiscriminators(discriminatorSchema, seen);
+      schemaType.discriminator(discriminatorKey, discriminatorSchema);
     }
     schemaType._appliedDiscriminators = true;
   }

package/lib/helpers/schema/applyWriteConcern.js

@@ -6,6 +6,12 @@ module.exports = function applyWriteConcern(schema, options) {
   if (options.writeConcern != null) {
     return;
   }
+  // Don't apply default write concern to operations in transactions,
+  // because setting write concern on an operation in a transaction is an error
+  // See: https://www.mongodb.com/docs/manual/reference/write-concern/
+  if (options && options.session && options.session.transaction) {
+    return;
+  }
   const writeConcern = get(schema, 'options.writeConcern', {});
   if (Object.keys(writeConcern).length != 0) {
     options.writeConcern = {};

package/lib/model.js

@@ -351,12 +351,22 @@ Model.prototype.$__handleSave = function(options, callback) {
 
     const update = delta[1];
     if (this.$__schema.options.minimize) {
-      minimize(update);
-      // minimize might leave us with an empty object, which would
-      // lead to MongoDB throwing a "Update document requires atomic operators" error
-      if (Object.keys(update).length === 0) {
-        handleEmptyUpdate.call(this);
-        return;
+      for (const updateOp of Object.values(update)) {
+        if (updateOp == null) {
+          continue;
+        }
+        for (const key of Object.keys(updateOp)) {
+          if (updateOp[key] == null || typeof updateOp[key] !== 'object') {
+            continue;
+          }
+          if (!utils.isPOJO(updateOp[key])) {
+            continue;
+          }
+          minimize(updateOp[key]);
+          if (Object.keys(updateOp[key]).length === 0) {
+            updateOp[key] = null;
+          }
+        }
       }
     }
 
@@ -2532,6 +2542,7 @@ Model.$where = function $where() {
  * @param {Boolean} [options.setDefaultsOnInsert=true] 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
  * @param {Boolean} [options.includeResultMetadata] if true, returns the [raw result from the MongoDB driver](https://mongodb.github.io/node-mongodb-native/4.9/interfaces/ModifyResult.html)
  * @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.overwriteDiscriminatorKey=false] Mongoose removes discriminator key updates from `update` by default, set `overwriteDiscriminatorKey` to `true` to allow updating the discriminator key
  * @return {Query}
  * @see Tutorial https://mongoosejs.com/docs/tutorials/findoneandupdate.html
  * @see mongodb https://www.mongodb.com/docs/manual/reference/command/findAndModify/
@@ -2624,6 +2635,7 @@ Model.findOneAndUpdate = function(conditions, update, options) {
  * @param {Boolean} [options.new=false] if true, return the modified document rather than the original
  * @param {Object|String} [options.select] sets the document fields to return.
  * @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.overwriteDiscriminatorKey=false] Mongoose removes discriminator key updates from `update` by default, set `overwriteDiscriminatorKey` to `true` to allow updating the discriminator key
  * @return {Query}
  * @see Model.findOneAndUpdate https://mongoosejs.com/docs/api/model.html#Model.findOneAndUpdate()
  * @see mongodb https://www.mongodb.com/docs/manual/reference/command/findAndModify/
@@ -3073,7 +3085,7 @@ Model.startSession = function() {
  * @param {Object} [options] see the [mongodb driver options](https://mongodb.github.io/node-mongodb-native/4.9/classes/Collection.html#insertMany)
  * @param {Boolean} [options.ordered=true] if true, will fail fast on the first error encountered. If false, will insert all the documents it can and report errors later. An `insertMany()` with `ordered = false` is called an "unordered" `insertMany()`.
  * @param {Boolean} [options.rawResult=false] if false, the returned promise resolves to the documents that passed mongoose document validation. If `true`, will return the [raw result from the MongoDB driver](https://mongodb.github.io/node-mongodb-native/4.9/interfaces/InsertManyResult.html) with a `mongoose` property that contains `validationErrors` and `results` if this is an unordered `insertMany`.
- * @param {Boolean} [options.lean=false] if `true`, skips hydrating and validating the documents. This option is useful if you need the extra performance, but Mongoose won't validate the documents before inserting.
+ * @param {Boolean} [options.lean=false] if `true`, skips hydrating the documents. This means Mongoose will **not** cast or validate any of the documents passed to `insertMany()`. This option is useful if you need the extra performance, but comes with data integrity risk. Consider using with [`castObject()`](https://mongoosejs.com/docs/api/model.html#Model.castObject()).
  * @param {Number} [options.limit=null] this limits the number of documents being processed (validation/casting) by mongoose in parallel, this does **NOT** send the documents in batches to MongoDB. Use this option if you're processing a large number of documents and your app is running out of memory.
  * @param {String|Object|Array} [options.populate=null] populates the result documents. This option is a no-op if `rawResult` is set.
  * @param {Boolean} [options.throwOnValidationError=false] If true and `ordered: false`, throw an error if one of the operations failed validation, but all valid operations completed successfully.
@@ -3134,6 +3146,13 @@ Model.$__insertMany = function(arr, options, callback) {
   const results = ordered ? null : new Array(arr.length);
   const toExecute = arr.map((doc, index) =>
     callback => {
+      // If option `lean` is set to true bypass validation and hydration
+      if (lean) {
+        // we have to execute callback at the nextTick to be compatible
+        // with parallelLimit, as `results` variable has TDZ issue if we
+        // execute the callback synchronously
+        return immediate(() => callback(null, doc));
+      }
       if (!(doc instanceof _this)) {
         if (doc != null && typeof doc !== 'object') {
           return callback(new ObjectParameterError(doc, 'arr.' + index, 'insertMany'));
@@ -3214,7 +3233,7 @@ Model.$__insertMany = function(arr, options, callback) {
       callback(null, []);
       return;
     }
-    const docObjects = docAttributes.map(function(doc) {
+    const docObjects = lean ? docAttributes : docAttributes.map(function(doc) {
       if (doc.$__schema.options.versionKey) {
         doc[doc.$__schema.options.versionKey] = 0;
       }
@@ -3227,9 +3246,11 @@ Model.$__insertMany = function(arr, options, callback) {
 
     _this.$__collection.insertMany(docObjects, options).then(
       res => {
-        for (const attribute of docAttributes) {
-          attribute.$__reset();
-          _setIsNew(attribute, false);
+        if (!lean) {
+          for (const attribute of docAttributes) {
+            attribute.$__reset();
+            _setIsNew(attribute, false);
+          }
         }
 
         if (ordered === false && throwOnValidationError && validationErrors.length > 0) {
@@ -3331,6 +3352,9 @@ Model.$__insertMany = function(arr, options, callback) {
             return !isErrored;
           }).
           map(function setIsNewForInsertedDoc(doc) {
+            if (lean) {
+              return doc;
+            }
             doc.$__reset();
             _setIsNew(doc, false);
             return doc;
@@ -3373,6 +3397,7 @@ function _setIsNew(doc, val) {
  * trip to MongoDB.
  *
  * Mongoose will perform casting on all operations you provide.
+ * The only exception is [setting the `update` operator for `updateOne` or `updateMany` to a pipeline](https://www.mongodb.com/docs/manual/reference/method/db.collection.bulkWrite/#updateone-and-updatemany): Mongoose does **not** cast update pipelines.
  *
  * This function does **not** trigger any middleware, neither `save()`, nor `update()`.
  * If you need to trigger
@@ -3408,6 +3433,15 @@ function _setIsNew(doc, val) {
  *      console.log(res.insertedCount, res.modifiedCount, res.deletedCount);
  *     });
  *
+ *     // Mongoose does **not** cast update pipelines, so no casting for the `update` option below.
+ *     // Mongoose does still cast `filter`
+ *     await Character.bulkWrite([{
+ *       updateOne: {
+ *         filter: { name: 'Annika Hansen' },
+ *         update: [{ $set: { name: 7 } }] // Array means update pipeline, so Mongoose skips casting
+ *       }
+ *     }]);
+ *
  * The [supported operations](https://www.mongodb.com/docs/manual/reference/method/db.collection.bulkWrite/#db.collection.bulkWrite) are:
  *
  * - `insertOne`
@@ -3937,13 +3971,14 @@ Model.hydrate = function(obj, projection, options) {
  * - `updateMany()`
  *
  * @param {Object} filter
- * @param {Object|Array} update
+ * @param {Object|Array} update. If array, this update will be treated as an update pipeline and not casted.
  * @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
  * @param {Boolean|String} [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
  * @param {Object} [options.writeConcern=null] sets the [write concern](https://www.mongodb.com/docs/manual/reference/write-concern/) for replica sets. Overrides the [schema-level write concern](https://mongoosejs.com/docs/guide.html#writeConcern)
  * @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. Does nothing if schema-level timestamps are not set.
  * @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.overwriteDiscriminatorKey=false] Mongoose removes discriminator key updates from `update` by default, set `overwriteDiscriminatorKey` to `true` to allow updating the discriminator key
  * @return {Query}
  * @see Query docs https://mongoosejs.com/docs/queries.html
  * @see MongoDB docs https://www.mongodb.com/docs/manual/reference/command/update/#update-command-output
@@ -3976,13 +4011,14 @@ Model.updateMany = function updateMany(conditions, doc, options) {
  * - `updateOne()`
  *
  * @param {Object} filter
- * @param {Object|Array} update
+ * @param {Object|Array} update. If array, this update will be treated as an update pipeline and not casted.
  * @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
  * @param {Boolean|String} [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
  * @param {Object} [options.writeConcern=null] sets the [write concern](https://www.mongodb.com/docs/manual/reference/write-concern/) for replica sets. Overrides the [schema-level write concern](https://mongoosejs.com/docs/guide.html#writeConcern)
  * @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.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.overwriteDiscriminatorKey=false] Mongoose removes discriminator key updates from `update` by default, set `overwriteDiscriminatorKey` to `true` to allow updating the discriminator key
  * @return {Query}
  * @see Query docs https://mongoosejs.com/docs/queries.html
  * @see MongoDB docs https://www.mongodb.com/docs/manual/reference/command/update/#update-command-output

package/lib/mongoose.js

@@ -506,12 +506,14 @@ Mongoose.prototype.pluralize = function(fn) {
  *
  *     // or
  *
- *     const collectionName = 'actor'
- *     const M = mongoose.model('Actor', schema, collectionName)
+ *     const collectionName = 'actor';
+ *     const M = mongoose.model('Actor', schema, collectionName);
  *
  * @param {String|Function} name model name or class extending Model
  * @param {Schema} [schema] the schema to use.
  * @param {String} [collection] name (optional, inferred from model name)
+ * @param {Object} [options]
+ * @param {Boolean} [options.overwriteModels=false] If true, overwrite existing models with the same name to avoid `OverwriteModelError`
  * @return {Model} The model associated with `name`. Mongoose will create the model if it doesn't already exist.
  * @api public
  */

package/lib/query.js

@@ -3191,6 +3191,7 @@ function prepareDiscriminatorCriteria(query) {
  * @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.
+ * @param {Boolean} [options.overwriteDiscriminatorKey=false] Mongoose removes discriminator key updates from `update` by default, set `overwriteDiscriminatorKey` to `true` to allow updating the discriminator key
  * @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
@@ -3879,7 +3880,7 @@ Query.prototype._replaceOne = async function _replaceOne() {
  * - `updateMany()`
  *
  * @param {Object} [filter]
- * @param {Object|Array} [update] the update command
+ * @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.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|String} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
@@ -3887,6 +3888,7 @@ Query.prototype._replaceOne = async function _replaceOne() {
  * @param {Object} [options.writeConcern=null] sets the [write concern](https://www.mongodb.com/docs/manual/reference/write-concern/) for replica sets. Overrides the [schema-level write concern](https://mongoosejs.com/docs/guide.html#writeConcern)
  * @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. Does nothing if schema-level timestamps are not set.
  * @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.overwriteDiscriminatorKey=false] Mongoose removes discriminator key updates from `update` by default, set `overwriteDiscriminatorKey` to `true` to allow updating the discriminator key
  * @param {Function} [callback] params are (error, writeOpResult)
  * @return {Query} this
  * @see Model.update https://mongoosejs.com/docs/api/model.html#Model.update()
@@ -3948,14 +3950,15 @@ Query.prototype.updateMany = function(conditions, doc, options, callback) {
  * - `updateOne()`
  *
  * @param {Object} [filter]
- * @param {Object|Array} [update] the update command
+ * @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.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|String} [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
  * @param {Object} [options.writeConcern=null] sets the [write concern](https://www.mongodb.com/docs/manual/reference/write-concern/) for replica sets. Overrides the [schema-level write concern](https://mongoosejs.com/docs/guide.html#writeConcern)
  * @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.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.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.overwriteDiscriminatorKey=false] Mongoose removes discriminator key updates from `update` by default, set `overwriteDiscriminatorKey` to `true` to allow updating the discriminator key
  * @param {Function} [callback] params are (error, writeOpResult)
  * @return {Query} this
  * @see Model.update https://mongoosejs.com/docs/api/model.html#Model.update()

package/lib/schema.js

@@ -1014,6 +1014,9 @@ reserved.collection = 1;
 
 Schema.prototype.path = function(path, obj) {
   if (obj === undefined) {
+    if (this.paths[path] != null) {
+      return this.paths[path];
+    }
     // Convert to '.$' to check subpaths re: gh-6405
     const cleanPath = _pathToPositionalSyntax(path);
     let schematype = _getPath(this, path, cleanPath);

package/lib/types/array/methods/index.js

@@ -698,22 +698,21 @@ const methods = {
 
       if ((atomics.$push && atomics.$push.$each && atomics.$push.$each.length || 0) !== 0 &&
           atomics.$push.$position != atomic.$position) {
-        throw new MongooseError('Cannot call `Array#push()` multiple times ' +
-          'with different `$position`');
-      }
+        if (atomic.$position != null) {
+          [].splice.apply(arr, [atomic.$position, 0].concat(values));
+          ret = arr.length;
+        } else {
+          ret = [].push.apply(arr, values);
+        }
 
-      if (atomic.$position != null) {
+        this._registerAtomic('$set', this);
+      } else if (atomic.$position != null) {
         [].splice.apply(arr, [atomic.$position, 0].concat(values));
         ret = this.length;
       } else {
         ret = [].push.apply(arr, values);
       }
     } else {
-      if ((atomics.$push && atomics.$push.$each && atomics.$push.$each.length || 0) !== 0 &&
-          atomics.$push.$position != null) {
-        throw new MongooseError('Cannot call `Array#push()` multiple times ' +
-          'with different `$position`');
-      }
       atomic = values;
       ret = _basePush.apply(arr, values);
     }

package/lib/types/arraySubdocument.js

@@ -145,7 +145,7 @@ ArraySubdocument.prototype.$__fullPath = function(path, skipIndex) {
  */
 
 ArraySubdocument.prototype.$__pathRelativeToParent = function(path, skipIndex) {
-  if (this.__index == null) {
+  if (this.__index == null || (!this.__parentArray || !this.__parentArray.$path)) {
     return null;
   }
   if (skipIndex) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "8.2.0",
+  "version": "8.2.2",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -28,8 +28,8 @@
     "sift": "16.0.1"
   },
   "devDependencies": {
-    "@babel/core": "7.23.9",
-    "@babel/preset-env": "7.23.9",
+    "@babel/core": "7.24.0",
+    "@babel/preset-env": "7.24.0",
     "@typescript-eslint/eslint-plugin": "^6.2.1",
     "@typescript-eslint/parser": "^6.2.1",
     "acquit": "1.3.0",
@@ -43,9 +43,9 @@
     "buffer": "^5.6.0",
     "cheerio": "1.0.0-rc.12",
     "crypto-browserify": "3.12.0",
-    "dotenv": "16.4.1",
+    "dotenv": "16.4.5",
     "dox": "1.0.0",
-    "eslint": "8.56.0",
+    "eslint": "8.57.0",
     "eslint-plugin-markdown": "^3.0.1",
     "eslint-plugin-mocha-no-only": "1.1.1",
     "express": "^4.18.1",
@@ -56,7 +56,7 @@
     "markdownlint-cli2": "^0.12.1",
     "marked": "4.3.0",
     "mkdirp": "^3.0.1",
-    "mocha": "10.2.0",
+    "mocha": "10.3.0",
     "moment": "2.x",
     "mongodb-memory-server": "8.15.1",
     "ncp": "^2.0.0",
@@ -65,10 +65,10 @@
     "q": "1.5.1",
     "sinon": "17.0.1",
     "stream-browserify": "3.0.0",
-    "tsd": "0.30.4",
+    "tsd": "0.30.7",
     "typescript": "5.3.3",
     "uuid": "9.0.1",
-    "webpack": "5.90.1"
+    "webpack": "5.90.3"
   },
   "directories": {
     "lib": "./lib/mongoose"

package/types/inferschematype.d.ts

@@ -229,7 +229,7 @@ type ResolvePathType<PathValueType, Options extends SchemaTypeOptions<PathValueT
               ObtainDocumentPathType<Item, TypeKey>[] :
               // If the type key isn't callable, then this is an array of objects, in which case
               // we need to call ObtainDocumentType to correctly infer its type.
-              ObtainDocumentType<Item, any, { typeKey: TypeKey }>[] :
+              Types.DocumentArray<ObtainDocumentType<Item, any, { typeKey: TypeKey }>> :
             IsSchemaTypeFromBuiltinClass<Item> extends true ?
               ObtainDocumentPathType<Item, TypeKey>[] :
               IsItRecordAndNotAny<Item> extends true ?