mongoose 8.9.1 → 8.9.3

package/lib/aggregate.js

@@ -87,6 +87,24 @@ function Aggregate(pipeline, model) {
 
 Aggregate.prototype.options;
 
+/**
+ * Returns default options for this aggregate.
+ *
+ * @param {Model} model
+ * @api private
+ */
+
+Aggregate.prototype._optionsForExec = function() {
+  const options = this.options || {};
+
+  const asyncLocalStorage = this.model()?.db?.base.transactionAsyncLocalStorage?.getStore();
+  if (!options.hasOwnProperty('session') && asyncLocalStorage?.session != null) {
+    options.session = asyncLocalStorage.session;
+  }
+
+  return options;
+};
+
 /**
  * Get/set the model that this aggregation will execute on.
  *
@@ -914,6 +932,7 @@ Aggregate.prototype.option = function(value) {
  */
 
 Aggregate.prototype.cursor = function(options) {
+  this._optionsForExec();
   this.options.cursor = options || {};
   return new AggregationCursor(this); // return this;
 };
@@ -1022,10 +1041,7 @@ Aggregate.prototype.exec = async function exec() {
   applyGlobalMaxTimeMS(this.options, model.db.options, model.base.options);
   applyGlobalDiskUse(this.options, model.db.options, model.base.options);
 
-  const asyncLocalStorage = this.model()?.db?.base.transactionAsyncLocalStorage?.getStore();
-  if (!this.options.hasOwnProperty('session') && asyncLocalStorage?.session != null) {
-    this.options.session = asyncLocalStorage.session;
-  }
+  this._optionsForExec();
 
   if (this.options && this.options.cursor) {
     return new AggregationCursor(this);
@@ -1052,6 +1068,7 @@ Aggregate.prototype.exec = async function exec() {
   }
 
   const options = clone(this.options || {});
+
   let result;
   try {
     const cursor = await collection.aggregate(this._pipeline, options);

package/lib/connection.js

@@ -663,7 +663,7 @@ Connection.prototype.withSession = async function withSession(executor) {
  *
  *     const session = await conn.startSession();
  *     let doc = await Person.findOne({ name: 'Ned Stark' }, null, { session });
- *     await doc.remove();
+ *     await doc.deleteOne();
  *     // `doc` will always be null, even if reading from a replica set
  *     // secondary. Without causal consistency, it is possible to
  *     // get a doc back from the below query if the query reads from a

package/lib/cursor/queryCursor.js

@@ -557,17 +557,11 @@ function _onNext(error, doc) {
 
   if (this.ctx._batchDocs.length < this.ctx.options._populateBatchSize) {
     // If both `batchSize` and `_populateBatchSize` are huge, calling `next()` repeatedly may
-    // cause a stack overflow. So make sure we clear the stack regularly.
-    if (this.ctx._batchDocs.length > 0 && this.ctx._batchDocs.length % 1000 === 0) {
-      return immediate(() => this.ctx.cursor.next().then(
-        res => { _onNext.call(this, null, res); },
-        err => { _onNext.call(this, err); }
-      ));
-    }
-    this.ctx.cursor.next().then(
+    // cause a stack overflow. So make sure we clear the stack.
+    immediate(() => this.ctx.cursor.next().then(
       res => { _onNext.call(this, null, res); },
       err => { _onNext.call(this, err); }
-    );
+    ));
   } else {
     _populateBatch.call(this);
   }

package/lib/document.js

@@ -2357,17 +2357,17 @@ Document.prototype.$isDefault = function(path) {
 };
 
 /**
- * Getter/setter, determines whether the document was removed or not.
+ * Getter/setter, determines whether the document was deleted. The `Model.prototype.deleteOne()` method sets `$isDeleted` if the delete operation succeeded.
  *
  * #### Example:
  *
- *     const product = await product.remove();
+ *     const product = await product.deleteOne();
  *     product.$isDeleted(); // true
- *     product.remove(); // no-op, doesn't send anything to the db
+ *     product.deleteOne(); // no-op, doesn't send anything to the db
  *
  *     product.$isDeleted(false);
  *     product.$isDeleted(); // false
- *     product.remove(); // will execute a remove against the db
+ *     product.deleteOne(); // will execute a remove against the db
  *
  *
  * @param {Boolean} [val] optional, overrides whether mongoose thinks the doc is deleted
@@ -3703,8 +3703,10 @@ Document.prototype.$getAllSubdocs = function(options) {
   const subDocs = [];
   function getSubdocs(doc) {
     const newSubdocs = [];
-    for (const { path } of doc.$__schema.childSchemas) {
-      const val = doc.$__getValue(path);
+
+    for (const { model } of doc.$__schema.childSchemas) {
+      // Avoid using `childSchemas.path` to avoid compatibility versions with pre-8.8 versions of Mongoose
+      const val = doc.$__getValue(model.path);
       if (val == null) {
         continue;
       }
@@ -3726,6 +3728,7 @@ Document.prototype.$getAllSubdocs = function(options) {
         }
       }
     }
+
     for (const subdoc of newSubdocs) {
       getSubdocs(subdoc);
     }

package/lib/helpers/indexes/isIndexSpecEqual.js

@@ -0,0 +1,32 @@
+'use strict';
+
+/**
+ * Compares two index specifications to determine if they are equal.
+ *
+ * #### Example:
+ *     isIndexSpecEqual({ a: 1, b: 1 }, { a: 1, b: 1 }); // true
+ *     isIndexSpecEqual({ a: 1, b: 1 }, { b: 1, a: 1 }); // false
+ *     isIndexSpecEqual({ a: 1, b: -1 }, { a: 1, b: 1 }); // false
+ *
+ * @param {Object} spec1 The first index specification to compare.
+ * @param {Object} spec2 The second index specification to compare.
+ * @returns {Boolean} Returns true if the index specifications are equal, otherwise returns false.
+ */
+
+module.exports = function isIndexSpecEqual(spec1, spec2) {
+  const spec1Keys = Object.keys(spec1);
+  const spec2Keys = Object.keys(spec2);
+
+  if (spec1Keys.length !== spec2Keys.length) {
+    return false;
+  }
+
+  for (let i = 0; i < spec1Keys.length; i++) {
+    const key = spec1Keys[i];
+    if (key !== spec2Keys[i] || spec1[key] !== spec2[key]) {
+      return false;
+    }
+  }
+
+  return true;
+};

package/lib/model.js

@@ -69,6 +69,7 @@ const util = require('util');
 const utils = require('./utils');
 const minimize = require('./helpers/minimize');
 const MongooseBulkSaveIncompleteError = require('./error/bulkSaveIncompleteError');
+const ObjectExpectedError = require('./error/objectExpected');
 
 const modelCollectionSymbol = Symbol('mongoose#Model#collection');
 const modelDbSymbol = Symbol('mongoose#Model#db');
@@ -387,7 +388,11 @@ Model.prototype.$__handleSave = function(options, callback) {
 
     this[modelCollectionSymbol].updateOne(where, update, saveOptions).then(
       ret => {
-        ret.$where = where;
+        if (ret == null) {
+          ret = { $where: where };
+        } else {
+          ret.$where = where;
+        }
         callback(null, ret);
       },
       err => {
@@ -694,13 +699,20 @@ Model.prototype.$__where = function _where(where) {
 };
 
 /**
- * Delete this document from the db.
+ * Delete this document from the db. Returns a Query instance containing a `deleteOne` operation by this document's `_id`.
  *
  * #### Example:
  *
  *     await product.deleteOne();
  *     await Product.findById(product._id); // null
  *
+ * Since `deleteOne()` returns a Query, the `deleteOne()` will **not** execute unless you use either `await`, `.then()`, `.catch()`, or [`.exec()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.exec())
+ *
+ * #### Example:
+ *
+ *     product.deleteOne(); // Doesn't do anything
+ *     product.deleteOne().exec(); // Deletes the document, returns a promise
+ *
  * @return {Query} Query
  * @api public
  */
@@ -1879,8 +1891,6 @@ Model.translateAliases = function translateAliases(fields, errorOnDuplicates) {
 /**
  * Deletes the first document that matches `conditions` from the collection.
  * It returns an object with the property `deletedCount` indicating how many documents were deleted.
- * Behaves like `remove()`, but deletes at most one document regardless of the
- * `single` option.
  *
  * #### Example:
  *
@@ -1914,8 +1924,6 @@ Model.deleteOne = function deleteOne(conditions, options) {
 /**
  * Deletes all of the documents that match `conditions` from the collection.
  * It returns an object with the property `deletedCount` containing the number of documents deleted.
- * Behaves like `remove()`, but deletes all documents that match `conditions`
- * regardless of the `single` option.
  *
  * #### Example:
  *
@@ -2729,7 +2737,7 @@ Model.create = async function create(doc, options) {
  *     //   operationType: 'delete',
  *     //   ns: { db: 'mydb', coll: 'Person' },
  *     //   documentKey: { _id: 5a51b125c5500f5aa094c7bd } }
- *     await doc.remove();
+ *     await doc.deleteOne();
  *
  * @param {Array} [pipeline]
  * @param {Object} [options] see the [mongodb driver options](https://mongodb.github.io/node-mongodb-native/4.9/classes/Collection.html#watch)
@@ -2777,7 +2785,7 @@ Model.watch = function(pipeline, options) {
  *
  *     const session = await Person.startSession();
  *     let doc = await Person.findOne({ name: 'Ned Stark' }, null, { session });
- *     await doc.remove();
+ *     await doc.deleteOne();
  *     // `doc` will always be null, even if reading from a replica set
  *     // secondary. Without causal consistency, it is possible to
  *     // get a doc back from the below query if the query reads from a
@@ -3684,6 +3692,19 @@ Model.castObject = function castObject(obj, options) {
     }
 
     if (schemaType.$isMongooseDocumentArray) {
+      const castNonArraysOption = schemaType.options?.castNonArrays ?? schemaType.constructor.options.castNonArrays;
+      if (!Array.isArray(val)) {
+        if (!castNonArraysOption) {
+          if (!options.ignoreCastErrors) {
+            error = error || new ValidationError();
+            error.addError(path, new ObjectExpectedError(path, val));
+          }
+        } else {
+          cur[pieces[pieces.length - 1]] = [
+            Model.castObject.call(schemaType.caster, val)
+          ];
+        }
+      }
       continue;
     }
     if (schemaType.$isSingleNested || schemaType.$isMongooseDocumentArrayElement) {

package/lib/query.js

@@ -2247,10 +2247,7 @@ Query.prototype.error = function error(err) {
  */
 
 Query.prototype._unsetCastError = function _unsetCastError() {
-  if (this._error == null) {
-    return;
-  }
-  if (this._error != null && !(this._error instanceof CastError)) {
+  if (this._error == null || !(this._error instanceof CastError)) {
     return;
   }
   return this.error(null);

package/lib/schema.js

@@ -18,13 +18,13 @@ const getConstructorName = require('./helpers/getConstructorName');
 const getIndexes = require('./helpers/schema/getIndexes');
 const handleReadPreferenceAliases = require('./helpers/query/handleReadPreferenceAliases');
 const idGetter = require('./helpers/schema/idGetter');
+const isIndexSpecEqual = require('./helpers/indexes/isIndexSpecEqual');
 const merge = require('./helpers/schema/merge');
 const mpath = require('mpath');
 const setPopulatedVirtualValue = require('./helpers/populate/setPopulatedVirtualValue');
 const setupTimestamps = require('./helpers/timestamps/setupTimestamps');
 const utils = require('./utils');
 const validateRef = require('./helpers/populate/validateRef');
-const util = require('util');
 
 const hasNumericSubpathRegex = /\.\d+(\.|$)/;
 
@@ -899,7 +899,7 @@ Schema.prototype.removeIndex = function removeIndex(index) {
 
   if (typeof index === 'object') {
     for (let i = this._indexes.length - 1; i >= 0; --i) {
-      if (util.isDeepStrictEqual(this._indexes[i][0], index)) {
+      if (isIndexSpecEqual(this._indexes[i][0], index)) {
         this._indexes.splice(i, 1);
       }
     }
@@ -2147,8 +2147,8 @@ Schema.prototype.index = function(fields, options) {
   }
 
   for (const existingIndex of this.indexes()) {
-    if (util.isDeepStrictEqual(existingIndex[0], fields)) {
-      throw new MongooseError(`Schema already has an index on ${JSON.stringify(fields)}`);
+    if (options.name == null && existingIndex[1].name == null && isIndexSpecEqual(existingIndex[0], fields)) {
+      utils.warn(`Duplicate schema index on ${JSON.stringify(fields)} found. This is often due to declaring an index using both "index: true" and "schema.index()". Please remove the duplicate index definition.`);
     }
   }
 

package/lib/types/map.js

@@ -9,6 +9,7 @@ const handleSpreadDoc = require('../helpers/document/handleSpreadDoc');
 const util = require('util');
 const specialProperties = require('../helpers/specialProperties');
 const isBsonType = require('../helpers/isBsonType');
+const cleanModifiedSubpaths = require('../helpers/document/cleanModifiedSubpaths');
 
 const populateModelSymbol = require('../helpers/symbols').populateModelSymbol;
 
@@ -157,7 +158,13 @@ class MongooseMap extends Map {
     super.set(key, value);
 
     if (parent != null && parent.$__ != null && !deepEqual(value, priorVal)) {
-      parent.markModified(fullPath.call(this));
+      const path = fullPath.call(this);
+      parent.markModified(path);
+      // If overwriting the full document array or subdoc, make sure to clean up any paths that were modified
+      // before re: #15108
+      if (this.$__schemaType.$isMongooseDocumentArray || this.$__schemaType.$isSingleNested) {
+        cleanModifiedSubpaths(parent, path);
+      }
     }
 
     // Delay calculating full path unless absolutely necessary, because string

package/lib/utils.js

@@ -631,6 +631,9 @@ exports.getValue = function(path, obj, map) {
 const mapGetterOptions = Object.freeze({ getters: false });
 
 function getValueLookup(obj, part) {
+  if (part === '$*' && obj instanceof Map) {
+    return obj;
+  }
   let _from = obj?._doc || obj;
   if (_from != null && _from.isMongooseArrayProxy) {
     _from = _from.__array;

package/package.json

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

package/types/index.d.ts

@@ -491,7 +491,7 @@ declare module 'mongoose' {
     remove(paths: string | Array<string>): this;
 
     /** Removes index by name or index spec */
-    remove(index: string | AnyObject): this;
+    removeIndex(index: string | AnyObject): this;
 
     /** Returns an Array of path strings that are required by this schema. */
     requiredPaths(invalidate?: boolean): string[];
@@ -572,7 +572,8 @@ declare module 'mongoose' {
     | typeof Schema.Types.Number
     | typeof Schema.Types.String
     | typeof Schema.Types.Buffer
-    | typeof Schema.Types.ObjectId;
+    | typeof Schema.Types.ObjectId
+    | typeof Schema.Types.UUID;
 
 
   export type InferId<T> = T extends { _id?: any } ? T['_id'] : Types.ObjectId;
@@ -712,77 +713,95 @@ declare module 'mongoose' {
   /**
    * Converts any Buffer properties into mongodb.Binary instances, which is what `lean()` returns
    */
-  export type BufferToBinary<T> = T extends TreatAsPrimitives ? T : T extends Record<string, any> ? {
-    [K in keyof T]: T[K] extends Buffer
-      ? mongodb.Binary
-      : T[K] extends (Buffer | null | undefined)
-        ? mongodb.Binary | null | undefined
-        : T[K] extends Types.DocumentArray<infer ItemType>
-            ? Types.DocumentArray<BufferToBinary<ItemType>>
-            : T[K] extends Types.Subdocument<unknown, unknown, infer SubdocType>
-              ? HydratedSingleSubdocument<SubdocType>
-              : BufferToBinary<T[K]>;
-  } : T;
+  export type BufferToBinary<T> = T extends Buffer
+    ? mongodb.Binary
+    : T extends Document
+      ? T
+      : T extends TreatAsPrimitives
+        ? T
+        : T extends Record<string, any> ? {
+          [K in keyof T]: T[K] extends Buffer
+            ? mongodb.Binary
+            : T[K] extends Types.DocumentArray<infer ItemType>
+              ? Types.DocumentArray<BufferToBinary<ItemType>>
+              : T[K] extends Types.Subdocument<unknown, unknown, infer SubdocType>
+                ? HydratedSingleSubdocument<BufferToBinary<SubdocType>>
+                : BufferToBinary<T[K]>;
+      } : T;
 
   /**
    * Converts any Buffer properties into { type: 'buffer', data: [1, 2, 3] } format for JSON serialization
    */
-  export type BufferToJSON<T> = T extends TreatAsPrimitives ? T : T extends Record<string, any> ? {
-    [K in keyof T]: T[K] extends Buffer
-      ? { type: 'buffer', data: number[] }
-      : T[K] extends (Buffer | null | undefined)
-        ? { type: 'buffer', data: number[] } | null | undefined
-        : T[K] extends Types.DocumentArray<infer ItemType>
-            ? Types.DocumentArray<BufferToBinary<ItemType>>
-            : T[K] extends Types.Subdocument<unknown, unknown, infer SubdocType>
-              ? HydratedSingleSubdocument<SubdocType>
-              : BufferToBinary<T[K]>;
-  } : T;
+  export type BufferToJSON<T> = T extends Buffer
+    ? { type: 'buffer', data: number[] }
+    : T extends Document
+      ? T
+      : T extends TreatAsPrimitives
+        ? T
+        : T extends Record<string, any> ? {
+          [K in keyof T]: T[K] extends Buffer
+            ? { type: 'buffer', data: number[] }
+            : T[K] extends Types.DocumentArray<infer ItemType>
+                ? Types.DocumentArray<BufferToBinary<ItemType>>
+                : T[K] extends Types.Subdocument<unknown, unknown, infer SubdocType>
+                  ? HydratedSingleSubdocument<SubdocType>
+                  : BufferToBinary<T[K]>;
+        } : T;
 
   /**
    * Converts any ObjectId properties into strings for JSON serialization
    */
-  export type ObjectIdToString<T> = T extends TreatAsPrimitives ? T : T extends Record<string, any> ? {
-    [K in keyof T]: T[K] extends mongodb.ObjectId
-      ? string
-      : T[K] extends (mongodb.ObjectId | null | undefined)
-        ? string | null | undefined
-        : T[K] extends Types.DocumentArray<infer ItemType>
-            ? Types.DocumentArray<ObjectIdToString<ItemType>>
-            : T[K] extends Types.Subdocument<unknown, unknown, infer SubdocType>
-              ? HydratedSingleSubdocument<ObjectIdToString<SubdocType>>
-              : ObjectIdToString<T[K]>;
-  } : T;
+  export type ObjectIdToString<T> = T extends mongodb.ObjectId
+    ? string
+    : T extends Document
+      ? T
+      : T extends TreatAsPrimitives
+        ? T
+        : T extends Record<string, any> ? {
+          [K in keyof T]: T[K] extends mongodb.ObjectId
+            ? string
+            : T[K] extends Types.DocumentArray<infer ItemType>
+                ? Types.DocumentArray<ObjectIdToString<ItemType>>
+                : T[K] extends Types.Subdocument<unknown, unknown, infer SubdocType>
+                  ? HydratedSingleSubdocument<ObjectIdToString<SubdocType>>
+                  : ObjectIdToString<T[K]>;
+        } : T;
 
   /**
    * Converts any Date properties into strings for JSON serialization
    */
-  export type DateToString<T> = T extends TreatAsPrimitives ? T : T extends Record<string, any> ? {
-    [K in keyof T]: T[K] extends NativeDate
-      ? string
-      : T[K] extends (NativeDate | null | undefined)
-        ? string | null | undefined
-        : T[K] extends Types.DocumentArray<infer ItemType>
-            ? Types.DocumentArray<DateToString<ItemType>>
-            : T[K] extends Types.Subdocument<unknown, unknown, infer SubdocType>
-              ? HydratedSingleSubdocument<DateToString<SubdocType>>
-              : DateToString<T[K]>;
-  } : T;
+  export type DateToString<T> = T extends NativeDate
+    ? string
+    : T extends Document
+      ? T
+        : T extends TreatAsPrimitives
+        ? T
+        : T extends Record<string, any> ? {
+          [K in keyof T]: T[K] extends NativeDate
+            ? string
+            : T[K] extends (NativeDate | null | undefined)
+              ? string | null | undefined
+              : T[K] extends Types.DocumentArray<infer ItemType>
+                  ? Types.DocumentArray<DateToString<ItemType>>
+                  : T[K] extends Types.Subdocument<unknown, unknown, infer SubdocType>
+                    ? HydratedSingleSubdocument<DateToString<SubdocType>>
+                    : DateToString<T[K]>;
+        } : T;
 
   /**
    * Converts any Mongoose subdocuments (single nested or doc arrays) into POJO equivalents
    */
-  export type SubdocsToPOJOs<T> = T extends TreatAsPrimitives ? T : T extends Record<string, any> ? {
-    [K in keyof T]: T[K] extends NativeDate
-      ? string
-      : T[K] extends (NativeDate | null | undefined)
-        ? string | null | undefined
-        : T[K] extends Types.DocumentArray<infer ItemType>
-            ? ItemType[]
-            : T[K] extends Types.Subdocument<unknown, unknown, infer SubdocType>
-              ? SubdocType
-              : SubdocsToPOJOs<T[K]>;
-  } : T;
+  export type SubdocsToPOJOs<T> = T extends Document
+    ? T
+    : T extends TreatAsPrimitives
+      ? T
+      : T extends Record<string, any> ? {
+        [K in keyof T]: T[K] extends Types.DocumentArray<infer ItemType>
+          ? ItemType[]
+          : T[K] extends Types.Subdocument<unknown, unknown, infer SubdocType>
+            ? SubdocType
+            : SubdocsToPOJOs<T[K]>;
+      } : T;
 
   export type JSONSerialized<T> = SubdocsToPOJOs<
     FlattenMaps<

package/types/indexes.d.ts

@@ -10,6 +10,9 @@ declare module 'mongoose' {
   function syncIndexes(options?: SyncIndexesOptions): Promise<ConnectionSyncIndexesResult>;
 
   interface IndexManager {
+    /* Deletes all indexes that aren't defined in this model's schema. Used by `syncIndexes()`. Returns list of dropped index names. */
+    cleanIndexes(options?: { toDrop?: string[], hideIndexes?: boolean }): Promise<string[]>;
+
     /**
      * Similar to `ensureIndexes()`, except for it uses the [`createIndex`](https://mongodb.github.io/node-mongodb-native/4.9/classes/Collection.html#createIndex)
      * function.