mongoose 9.10.0 → 9.10.2

package/lib/helpers/clone.js

@@ -197,6 +197,11 @@ function cloneObject(obj, options, isArrayChild) {
 }
 
 function cloneArray(arr, options) {
+  const seen = options?._seen;
+  if (seen && seen.has(arr)) {
+    return seen.get(arr);
+  }
+
   let i = 0;
   const len = arr.length;
 
@@ -218,6 +223,10 @@ function cloneArray(arr, options) {
     ret = new Array(len);
   }
 
+  if (seen) {
+    seen.set(arr, ret);
+  }
+
   arr = isMongooseArray(arr) ? arr.__array : arr;
   if (ret.isMongooseDocumentArray) {
     // Create new options object to avoid mutating the shared options.

package/lib/model.js

@@ -3951,6 +3951,18 @@ Model.castObject = function castObject(obj, options) {
   }
 
   if (error != null) {
+    // `{MODEL}` is replaced for query casting and document validation, so do it
+    // here too. Only the top-level call knows the model: the recursive calls for
+    // subdocuments are invoked on the subdocument constructor, which has no
+    // `modelName`, so this runs once over every collected error. (gh-8300)
+    if (this.modelName != null) {
+      for (const key of Object.keys(error.errors)) {
+        const err = error.errors[key];
+        if (typeof err.setModel === 'function') {
+          err.setModel(this);
+        }
+      }
+    }
     throw error;
   }
 

package/lib/schema/map.js

@@ -30,20 +30,6 @@ class SchemaMap extends SchemaType {
     this._createNestedSchemaType(parentSchema, key, options, schemaOptions);
   }
 
-  /**
-   * Sets a default option for all Map instances.
-   *
-   * @param {string} option The option you'd like to set the value for
-   * @param {any} value value for option
-   * @return {undefined}
-   * @function set
-   * @api public
-   */
-
-  set(option, value) {
-    return SchemaType.set(option, value);
-  }
-
   /**
    * Casts to Map
    *
@@ -143,6 +129,19 @@ class SchemaMap extends SchemaType {
   }
 }
 
+/**
+ * Sets a default option for all Map instances.
+ *
+ * @param {string} option The option you'd like to set the value for
+ * @param {any} value value for option
+ * @return {undefined}
+ * @function set
+ * @static
+ * @api public
+ */
+
+SchemaMap.set = SchemaType.set;
+
 /**
  * This schema type's name, to defend against minifiers that mangle
  * function names.

package/lib/schema.js

@@ -595,12 +595,6 @@ Schema.prototype.omit = function(paths, options) {
 
   newSchema.remove(paths);
 
-  for (const nested in newSchema.singleNestedPaths) {
-    if (paths.includes(nested)) {
-      delete newSchema.singleNestedPaths[nested];
-    }
-  }
-
   return newSchema;
 };
 
@@ -2831,6 +2825,7 @@ Schema.prototype.remove = function(path) {
         this.mapPaths = this.mapPaths.filter(
           schemaType => !schemaType.path.startsWith(name + '.')
         );
+        _deleteSubpaths(this, name);
 
         delete this.nested[name];
         _deletePath(this, name);
@@ -2849,6 +2844,11 @@ Schema.prototype.remove = function(path) {
       this.mapPaths = this.mapPaths.filter(
         schemaType => !schemaType.path.startsWith(name + '.')
       );
+      // A document array registers its element paths under `subpaths` and a
+      // single nested subdocument registers its paths under `singleNestedPaths`.
+      // Left behind, they keep answering `path()` and `pathType()`, and queries
+      // on the removed path keep being cast.
+      _deleteSubpaths(this, name);
       _deletePath(this, name);
 
       this._removeEncryptedField(name);
@@ -2861,6 +2861,20 @@ Schema.prototype.remove = function(path) {
  * ignore
  */
 
+function _deleteSubpaths(schema, name) {
+  const prefix = name + '.';
+  for (const subpath of Object.keys(schema.subpaths)) {
+    if (subpath === name || subpath.startsWith(prefix)) {
+      delete schema.subpaths[subpath];
+    }
+  }
+  for (const subpath of Object.keys(schema.singleNestedPaths)) {
+    if (subpath === name || subpath.startsWith(prefix)) {
+      delete schema.singleNestedPaths[subpath];
+    }
+  }
+}
+
 function _deletePath(schema, name) {
   const pieces = name.split('.');
   const last = pieces.pop();

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

@@ -211,6 +211,26 @@ const methods = {
     return this.constructor.prototype.toObject.apply(this, arguments);
   },
 
+  /**
+   * Wraps [`MongooseArray#addToSet`](https://mongoosejs.com/docs/api/array.html#MongooseArray.prototype.addToSet())
+   * with proper change tracking.
+   *
+   * @param {...object} [args]
+   * @api public
+   * @method addToSet
+   * @memberOf MongooseDocumentArray
+   */
+
+  addToSet() {
+    // Arguments are cast before duplicates are skipped, so any value added
+    // after a skipped duplicate is cast with an index that is too high.
+    const ret = ArrayMethods.addToSet.apply(this, arguments);
+
+    _updateSubdocIndexes(this);
+
+    return ret;
+  },
+
   /**
    * Wraps [`Array#push`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push) with proper change tracking.
    *

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "9.10.0",
+  "version": "9.10.2",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",

package/types/aggregate.d.ts

@@ -125,7 +125,7 @@ declare module 'mongoose' {
      * Binds this aggregate to a model.
      * @param model the model to which the aggregate is to be bound
      */
-    model(model: Model<any>): this;
+    model(model: Model<any, any, any, any>): this;
 
     /**
      * Returns the current model bound to this aggregate object

package/types/document.d.ts

@@ -252,7 +252,7 @@ declare module 'mongoose' {
 
     /** Populates document references. */
     populate<Paths = {}>(path: string | PopulateOptions | (string | PopulateOptions)[]): Promise<PopulateDocumentResult<this, Paths, PopulatedPathsDocumentType<DocType, Paths>, DocType>>;
-    populate<Paths = {}>(path: string, select?: string | AnyObject, model?: Model<any>, match?: AnyObject, options?: PopulateOptions): Promise<PopulateDocumentResult<this, Paths, PopulatedPathsDocumentType<DocType, Paths>, DocType>>;
+    populate<Paths = {}>(path: string, select?: string | AnyObject, model?: Model<any, any, any, any>, match?: AnyObject, options?: PopulateOptions): Promise<PopulateDocumentResult<this, Paths, PopulatedPathsDocumentType<DocType, Paths>, DocType>>;
 
     /** Gets _id(s) used during population of the given `path`. If the path was not populated, returns `undefined`. */
     populated(path: string): any;

package/types/populate.d.ts

@@ -60,7 +60,7 @@ declare module 'mongoose' {
     /** query conditions to match */
     match?: any;
     /** optional model to use for population */
-    model?: string | Model<any>;
+    model?: string | Model<any, any, any, any>;
     /** by default, Mongoose removes null and undefined values from populated arrays. Use this option to make `populate()` retain `null` and `undefined` array entries. */
     retainNullValues?: boolean;
     /** if true, Mongoose will call any getters defined on the `localField`. By default, Mongoose gets the raw value of `localField`. */

package/types/schematypes.d.ts

@@ -120,7 +120,7 @@ declare module 'mongoose' {
     /**
      * The model that `populate()` should use if populating this path.
      */
-    ref?: string | Model<any> | ((this: any, doc: any) => string | Model<any>);
+    ref?: string | Model<any, any, any, any> | ((this: any, doc: any) => string | Model<any, any, any, any>);
 
     /**
      * The path in the document that `populate()` should use to find the model
@@ -354,7 +354,7 @@ declare module 'mongoose' {
      * Set the model that this path refers to. This is the option that [populate](https://mongoosejs.com/docs/populate.html)
      * looks at to determine the foreign collection it should query.
      */
-    ref(ref: string | boolean | Model<any>): this;
+    ref(ref: string | boolean | Model<any, any, any, any>): this;
 
     /**
      * Adds a required validator to this SchemaType. The validator gets added