mongoose 8.24.0 → 8.24.1

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.24.0",
+  "version": "8.24.1",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",