mongoose 8.9.1 → 8.9.2

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

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

@@ -694,13 +694,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 +1886,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 +1919,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 +2732,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 +2780,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

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,7 +2147,7 @@ Schema.prototype.index = function(fields, options) {
   }
 
   for (const existingIndex of this.indexes()) {
-    if (util.isDeepStrictEqual(existingIndex[0], fields)) {
+    if (options.name == null && existingIndex[1].name == null && isIndexSpecEqual(existingIndex[0], fields)) {
       throw new MongooseError(`Schema already has an index on ${JSON.stringify(fields)}`);
     }
   }

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/package.json

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

package/types/index.d.ts

@@ -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,76 +713,82 @@ 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>
+  export type BufferToBinary<T> = T extends Buffer
+    ? mongodb.Binary
+    : 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<SubdocType>
               : BufferToBinary<T[K]>;
-  } : T;
+      } : 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 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 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 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]>;
+    [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<