mongoose 8.23.1 → 8.24.1

package/lib/aggregate.js

@@ -1027,7 +1027,7 @@ Aggregate.prototype.search = function(options) {
  *
  *     MyModel.aggregate().match({ test: 1 }).pipeline(); // [{ $match: { test: 1 } }]
  *
- * @return {Array} The current pipeline similar to the operation that will be executed
+ * @return {PipelineStage[]} The current pipeline similar to the operation that will be executed
  * @api public
  */
 
@@ -1035,6 +1035,29 @@ Aggregate.prototype.pipeline = function() {
   return this._pipeline;
 };
 
+/**
+ * Returns the current pipeline as a `$unionWith`-safe pipeline.
+ * Throws if this pipeline contains `$out` or `$merge`.
+ *
+ * #### Example:
+ *
+ *     const base = MyModel.aggregate().match({ test: 1 });
+ *     base.pipelineForUnionWith(); // [{ $match: { test: 1 } }]
+ *
+ * @return {PipelineStage[]} The current pipeline with `$unionWith` stage restrictions
+ * @api public
+ */
+
+Aggregate.prototype.pipelineForUnionWith = function pipelineForUnionWith() {
+  for (const stage of this._pipeline) {
+    if (stage?.$out != null || stage?.$merge != null) {
+      throw new MongooseError('Aggregate pipeline for $unionWith cannot include `$out` or `$merge` stages');
+    }
+  }
+
+  return this._pipeline;
+};
+
 /**
  * Executes the aggregate pipeline on the currently bound Model.
  *

package/lib/cursor/changeStream.js

@@ -114,7 +114,20 @@ class ChangeStream extends EventEmitter {
     if (this.errored) {
       throw new MongooseError('Cannot call hasNext() on errored ChangeStream');
     }
-    return this.driverChangeStream.hasNext(cb);
+
+    if (this.driverChangeStream != null) {
+      return this.driverChangeStream.hasNext(cb);
+    }
+
+    return this.$driverChangeStreamPromise.then(
+      () => this.driverChangeStream.hasNext(cb),
+      err => {
+        if (cb != null) {
+          return cb(err);
+        }
+        throw err;
+      }
+    );
   }
 
   next(cb) {
@@ -135,7 +148,20 @@ class ChangeStream extends EventEmitter {
         };
       }
 
-      let maybePromise = this.driverChangeStream.next(cb);
+      let maybePromise;
+      if (this.driverChangeStream != null) {
+        maybePromise = this.driverChangeStream.next(cb);
+      } else {
+        maybePromise = this.$driverChangeStreamPromise.then(
+          () => this.driverChangeStream.next(cb),
+          err => {
+            if (cb != null) {
+              return cb(err);
+            }
+            throw err;
+          }
+        );
+      }
       if (maybePromise && typeof maybePromise.then === 'function') {
         maybePromise = maybePromise.then(data => {
           if (data.fullDocument != null) {
@@ -147,7 +173,19 @@ class ChangeStream extends EventEmitter {
       return maybePromise;
     }
 
-    return this.driverChangeStream.next(cb);
+    if (this.driverChangeStream != null) {
+      return this.driverChangeStream.next(cb);
+    }
+
+    return this.$driverChangeStreamPromise.then(
+      () => this.driverChangeStream.next(cb),
+      err => {
+        if (cb != null) {
+          return cb(err);
+        }
+        throw err;
+      }
+    );
   }
 
   addListener(event, handler) {

package/lib/document.js

@@ -1922,7 +1922,9 @@ Document.prototype.get = function(path, type, options) {
 
   // Fast path if we know we're just accessing top-level path on the document:
   // just get the schema path, avoid `$__path()` because that does string manipulation
-  let schema = noDottedPath ? this.$__schema.paths[path] : this.$__path(path);
+  let schema = noDottedPath ?
+    Object.hasOwn(this.$__schema.paths, path) ? this.$__schema.paths[path] : undefined :
+    this.$__path(path);
   if (schema == null) {
     schema = this.$__schema.virtualpath(path);
 
@@ -1932,7 +1934,7 @@ Document.prototype.get = function(path, type, options) {
   }
 
   if (noDottedPath) {
-    let obj = this._doc[path];
+    let obj = Object.hasOwn(this._doc, path) ? this._doc[path] : undefined;
     if (adhoc) {
       obj = adhoc.cast(obj);
     }
@@ -1959,6 +1961,10 @@ Document.prototype.get = function(path, type, options) {
   }
 
   for (let i = 0, l = pieces.length; i < l; i++) {
+    if (specialProperties.has(pieces[i])) {
+      return undefined;
+    }
+
     if (obj && obj._doc) {
       obj = obj._doc;
     }
@@ -1980,7 +1986,7 @@ Document.prototype.get = function(path, type, options) {
 
   if (schema != null && options.getters !== false) {
     obj = schema.applyGetters(obj, this);
-  } else if (this.$__schema.nested[path] && options.virtuals) {
+  } else if (Object.hasOwn(this.$__schema.nested, path) && options.virtuals) {
     // Might need to apply virtuals if this is a nested path
     return applyVirtuals(this, clone(obj) || {}, { path: path });
   }

package/lib/helpers/clone.js

@@ -202,10 +202,15 @@ function cloneArray(arr, options) {
 
   let ret = null;
   if (options?.retainDocuments) {
+    // Use the cloned parent doc (options.parentDoc) when available so the new
+    // array is wired up to the clone, not the source. Falling back to the
+    // source's parent preserves the previous behavior for callers that don't
+    // pass parentDoc.
+    const newParent = options.parentDoc ?? (arr.isMongooseArray ? arr.$parent() : undefined);
     if (arr.isMongooseDocumentArray) {
-      ret = new (arr.$schemaType().schema.base.Types.DocumentArray)([], arr.$path(), arr.$parent(), arr.$schemaType());
+      ret = new (arr.$schemaType().schema.base.Types.DocumentArray)([], arr.$path(), newParent, arr.$schemaType());
     } else if (arr.isMongooseArray) {
-      ret = new (arr.$parent().schema.base.Types.Array)([], arr.$path(), arr.$parent(), arr.$schemaType());
+      ret = new (arr.$parent().schema.base.Types.Array)([], arr.$path(), newParent, arr.$schemaType());
     } else {
       ret = new Array(len);
     }
@@ -218,9 +223,21 @@ function cloneArray(arr, options) {
     // Create new options object to avoid mutating the shared options.
     // Subdocs need parentArray to point to their own cloned array.
     options = { ...options, parentArray: ret };
-  }
-  for (i = 0; i < len; ++i) {
-    ret[i] = clone(arr[i], options, true);
+    // Skip change-tracking while populating the freshly cloned array: every
+    // index assignment would otherwise call markModified on the cloned parent
+    // doc and (before this guard) on the source parent doc.
+    for (i = 0; i < len; ++i) {
+      const doc = clone(arr[i], options, true);
+      // Document arrays can contain null entries, so only restamp actual subdocs.
+      if (typeof doc?.$setIndex === 'function') {
+        doc.$setIndex(i);
+      }
+      ret.set(i, doc, true);
+    }
+  } else {
+    for (i = 0; i < len; ++i) {
+      ret[i] = clone(arr[i], options, true);
+    }
   }
 
   return ret;

package/lib/schema.js

@@ -1213,7 +1213,7 @@ reserved.collection = 1;
 
 Schema.prototype.path = function(path, obj) {
   if (obj === undefined) {
-    if (this.paths[path] != null) {
+    if (Object.hasOwn(this.paths, path)) {
       return this.paths[path];
     }
     // Convert to '.$' to check subpaths re: gh-6405
@@ -1241,9 +1241,15 @@ Schema.prototype.path = function(path, obj) {
       : undefined;
   }
 
+  const subpaths = path.indexOf('.') === -1 ? [path] : path.split('.');
+  const last = subpaths.pop();
+  if (utils.specialProperties.has(last)) {
+    throw new Error('Cannot set special property `' + last + '` on a schema');
+  }
+
   // some path names conflict with document methods
-  const firstPieceOfPath = path.split('.')[0];
-  if (reserved[firstPieceOfPath] && !this.options.suppressReservedKeysWarning) {
+  const firstPieceOfPath = subpaths.length === 0 ? last : subpaths[0];
+  if (Object.hasOwn(reserved, firstPieceOfPath) && !this.options.suppressReservedKeysWarning) {
     const errorMessage = `\`${firstPieceOfPath}\` is a reserved schema pathname and may break some functionality. ` +
       'You are allowed to use it, but use at your own risk. ' +
       'To disable this warning pass `suppressReservedKeysWarning` as a schema option.';
@@ -1256,8 +1262,6 @@ Schema.prototype.path = function(path, obj) {
   }
 
   // update the tree
-  const subpaths = path.split(/\./);
-  const last = subpaths.pop();
   let branch = this.tree;
   let fullPath = '';
 
@@ -1488,7 +1492,7 @@ function getMapPath(schema, path) {
     } else if (val.schema && path.startsWith(cleanPath + '.')) {
       let remnant = path.slice(cleanPath.length + 1);
       remnant = remnant.slice(remnant.indexOf('.') + 1);
-      return val.schema.paths[remnant];
+      return val.schema.path(remnant);
     } else if (val.$isSchemaMap && path.startsWith(cleanPath + '.')) {
       let remnant = path.slice(cleanPath.length + 1);
       remnant = remnant.slice(remnant.indexOf('.') + 1);
@@ -2986,7 +2990,7 @@ Schema.prototype._getPathType = function(path) {
           };
         }
         return { schema: foundschema, pathType: 'real' };
-      } else if (p === parts.length && schema.nested[trypath]) {
+      } else if (p === parts.length && Object.hasOwn(schema.nested, trypath)) {
         return { schema: schema, pathType: 'nested' };
       }
     }

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

@@ -12,6 +12,7 @@ const arrayPathSymbol = require('../../../helpers/symbols').arrayPathSymbol;
 const arraySchemaSymbol = require('../../../helpers/symbols').arraySchemaSymbol;
 const documentArrayParent = require('../../../helpers/symbols').documentArrayParent;
 
+const _baseReverse = Array.prototype.reverse;
 const _baseToString = Array.prototype.toString;
 
 const methods = {
@@ -209,7 +210,7 @@ const methods = {
   },
 
   /**
-   * Wraps [`Array#push`](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/push) with proper change tracking.
+   * Wraps [`Array#push`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push) with proper change tracking.
    *
    * @param {...Object} [args]
    * @api public
@@ -218,8 +219,37 @@ const methods = {
    */
 
   push() {
+    const shouldReindex = _shouldReindexAfterPush(arguments);
     const ret = ArrayMethods.push.apply(this, arguments);
 
+    if (shouldReindex) {
+      _updateSubdocIndexes(this);
+    }
+    _updateParentPopulated(this);
+
+    return ret;
+  },
+
+  /**
+   * Wraps [`Array#pop`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop) with proper change tracking.
+   * @api private
+   */
+
+  pop() {
+    const ret = ArrayMethods.pop.apply(this, arguments);
+
+    _updateParentPopulated(this);
+
+    return ret;
+  },
+
+  /*!
+   * ignore
+   */
+
+  $pop() {
+    const ret = ArrayMethods.$pop.apply(this, arguments);
+
     _updateParentPopulated(this);
 
     return ret;
@@ -237,32 +267,96 @@ const methods = {
   pull() {
     const ret = ArrayMethods.pull.apply(this, arguments);
 
+    _updateSubdocIndexes(this);
     _updateParentPopulated(this);
 
     return ret;
   },
 
   /**
-   * Wraps [`Array#shift`](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/unshift) with proper change tracking.
+   * Wraps [`Array#shift`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/shift) with proper change tracking.
    * @api private
    */
 
   shift() {
     const ret = ArrayMethods.shift.apply(this, arguments);
 
+    _updateSubdocIndexes(this);
+    _updateParentPopulated(this);
+
+    return ret;
+  },
+
+  /*!
+   * ignore
+   */
+
+  $shift() {
+    const ret = ArrayMethods.$shift.apply(this, arguments);
+
+    _updateSubdocIndexes(this);
     _updateParentPopulated(this);
 
     return ret;
   },
 
   /**
-   * Wraps [`Array#splice`](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/splice) with proper change tracking and casting.
+   * Wraps [`Array#splice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice) with proper change tracking and casting.
    * @api private
    */
 
   splice() {
     const ret = ArrayMethods.splice.apply(this, arguments);
 
+    _updateSubdocIndexes(this);
+    _updateParentPopulated(this);
+
+    return ret;
+  },
+
+  /**
+   * Wraps [`Array#reverse`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse)
+   * with proper change tracking.
+   * @api private
+   */
+
+  reverse() {
+    _baseReverse.call(this.__array);
+    this._registerAtomic('$set', this);
+
+    _updateSubdocIndexes(this);
+    _updateParentPopulated(this);
+
+    return this;
+  },
+
+  /**
+   * Wraps [`Array#sort`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort)
+   * with proper change tracking.
+   *
+   * @param {Function} [compareFunction]
+   * @api private
+   */
+
+  sort() {
+    const ret = ArrayMethods.sort.apply(this, arguments);
+
+    _updateSubdocIndexes(this);
+    _updateParentPopulated(this);
+
+    return ret;
+  },
+
+  /**
+   * Wraps [`Array#unshift`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift)
+   * with proper change tracking.
+   * @api private
+   */
+
+  unshift() {
+    const ret = ArrayMethods.unshift.apply(this, arguments);
+
+    _updateSubdocIndexes(this);
     _updateParentPopulated(this);
 
     return ret;
@@ -387,6 +481,26 @@ const methods = {
 
 module.exports = methods;
 
+/*!
+ * ignore
+ */
+
+function _updateSubdocIndexes(arr) {
+  const rawArray = utils.isMongooseArray(arr) ? arr.__array : arr;
+
+  for (let i = 0; i < rawArray.length; ++i) {
+    if (typeof rawArray[i]?.$setIndex === 'function') {
+      rawArray[i].$setIndex(i);
+    }
+  }
+}
+
+function _shouldReindexAfterPush(args) {
+  return args[0] != null &&
+    utils.hasUserDefinedProperty(args[0], '$each') &&
+    args[0].$position != null;
+}
+
 /**
  * If this is a document array, each element may contain single
  * populated paths, so we need to modify the top-level document's

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "8.23.1",
+  "version": "8.24.1",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -36,9 +36,9 @@
     "@typescript-eslint/eslint-plugin": "^8.19.1",
     "@typescript-eslint/parser": "^8.19.1",
     "acquit": "1.4.0",
-    "acquit-ignore": "0.2.1",
+    "acquit-ignore": "0.2.2",
     "acquit-require": "0.1.1",
-    "ajv": "8.17.1",
+    "ajv": "8.20.0",
     "assert-browserify": "2.0.0",
     "babel-loader": "8.2.5",
     "broken-link-checker": "^0.7.8",
@@ -70,7 +70,7 @@
     "tsd": "0.33.0",
     "typescript": "5.9.3",
     "uuid": "11.1.0",
-    "webpack": "5.102.1"
+    "webpack": "5.106.2"
   },
   "directories": {
     "lib": "./lib/mongoose"

package/types/aggregate.d.ts

@@ -123,6 +123,9 @@ declare module 'mongoose' {
     /** Returns the current pipeline */
     pipeline(): PipelineStage[];
 
+    /** Returns the current pipeline typed for use in `$unionWith` */
+    pipelineForUnionWith(): PipelineStage.UnionWithPipelineStage[];
+
     /** Appends a new $project operator to this aggregate pipeline. */
     project(arg: PipelineStage.Project['$project'] | string): this;
 

package/types/inferrawdoctype.d.ts

@@ -72,7 +72,7 @@ declare module 'mongoose' {
         : // If the type key isn't callable, then this is an array of objects, in which case
           // we need to call InferRawDocType to correctly infer its type.
           Array<InferRawDocType<Item>>
-      : IsSchemaTypeFromBuiltinClass<Item> extends true ? ResolveRawPathType<Item, { enum: Options['enum'] }, TypeKey>[]
+      : IsSchemaTypeFromBuiltinClass<Item> extends true ? ResolveRawPathType<Item, { enum: Exclude<Options['enum'], undefined> }, TypeKey>[]
       : IsItRecordAndNotAny<Item> extends true ?
         Item extends Record<string, never> ?
           ObtainRawDocumentPathType<Item, TypeKey>[]

package/types/inferschematype.d.ts

@@ -287,7 +287,7 @@ type ResolvePathType<
         : // 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.
           Types.DocumentArray<ObtainDocumentType<Item, any, { typeKey: TypeKey }>>
-      : IsSchemaTypeFromBuiltinClass<Item> extends true ? ResolvePathType<Item, { enum: Options['enum'] }, TypeKey>[]
+      : IsSchemaTypeFromBuiltinClass<Item> extends true ? ResolvePathType<Item, { enum: Exclude<Options['enum'], undefined> }, TypeKey>[]
       : IsItRecordAndNotAny<Item> extends true ?
         Item extends Record<string, never> ?
           ObtainDocumentPathType<Item, TypeKey>[]

package/types/pipelinestage.d.ts

@@ -115,6 +115,7 @@ declare module 'mongoose' {
     }
 
     export type FacetPipelineStage = Exclude<PipelineStage, PipelineStage.CollStats | PipelineStage.Facet | PipelineStage.GeoNear | PipelineStage.IndexStats | PipelineStage.Out | PipelineStage.Merge | PipelineStage.PlanCacheStats>;
+    export type UnionWithPipelineStage = Exclude<PipelineStage, PipelineStage.Out | PipelineStage.Merge>;
 
     export interface GeoNear {
       /** [`$geoNear` reference](https://www.mongodb.com/docs/manual/reference/operator/aggregation/geoNear/) */
@@ -303,8 +304,8 @@ declare module 'mongoose' {
       /** [`$unionWith` reference](https://www.mongodb.com/docs/manual/reference/operator/aggregation/unionWith/) */
       $unionWith:
       | string
-      | { coll: string; pipeline?: Exclude<PipelineStage, PipelineStage.Out | PipelineStage.Merge>[] }
-      | { coll?: string; pipeline: Exclude<PipelineStage, PipelineStage.Out | PipelineStage.Merge>[] }
+      | { coll: string; pipeline?: UnionWithPipelineStage[] }
+      | { coll?: string; pipeline: UnionWithPipelineStage[] }
     }
 
     export interface Unset {

package/types/schematypes.d.ts

@@ -110,7 +110,7 @@ declare module 'mongoose' {
      * The default value for this path. If a function, Mongoose executes the function
      * and uses the return value as the default.
      */
-    default?: DefaultType<T> | ((this: EnforcedDocType, doc: any) => DefaultType<T> | null | undefined) | null;
+    default?: DefaultType<T> | ((this: EnforcedDocType, doc: any) => DefaultType<T> | null | undefined) | null | undefined;
 
     /**
      * The model that `populate()` should use if populating this path.