@depup/mongoose 9.1.3-depup.0 → 9.1.5-depup.0

package/lib/cursor/queryCursor.js

@@ -599,6 +599,9 @@ function _nextDoc(ctx, doc, pop, callback) {
     if (err != null) {
       return callback(err);
     }
+    if (options.session != null) {
+      doc.$session(options.session);
+    }
     ctx.model.hooks.execPost('find', ctx.query, [[doc]]).then(() => callback(null, doc), err => callback(err));
   });
 }

package/lib/document.js

@@ -2824,7 +2824,13 @@ function _getPathsToValidate(doc, pathsToValidate, pathsToSkip, isNestedValidate
 
     // Optimization: if primitive path with no validators, or array of primitives
     // with no validators, skip validating this path entirely.
-    if (!_pathType.schema && !_pathType.embeddedSchemaType && _pathType.validators.length === 0 && !_pathType.$parentSchemaDocArray) {
+    if (!_pathType.schema &&
+      !_pathType.embeddedSchemaType &&
+      _pathType.validators.length === 0 &&
+      !_pathType.$parentSchemaDocArray &&
+      // gh-15957: skip this optimization for SchemaMap as maps can contain subdocuments
+      // that need validation even if the map itself has no validators
+      !_pathType.$isSchemaMap) {
       paths.delete(path);
     } else if (_pathType.$isMongooseArray &&
       !_pathType.$isMongooseDocumentArray && // Skip document arrays...

package/lib/helpers/clone.js

@@ -51,11 +51,20 @@ function clone(obj, options, isArrayChild) {
           clonedDoc.__index = obj.__index;
         }
         if (obj.__parentArray != null) {
-          clonedDoc.__parentArray = obj.__parentArray;
+          clonedDoc.__parentArray = options.parentArray ?? obj.__parentArray;
         }
         clonedDoc.$__setParent(options.parentDoc ?? obj.$__parent);
         return clonedDoc;
       }
+      if (options.retainDocuments && obj.$isMongooseMap) {
+        const clonedParent = options.parentDoc ?? obj.$__parent;
+        const MongooseMap = obj.constructor;
+        const ret = new MongooseMap({}, obj.$__path, clonedParent, obj.$__schemaType);
+        for (const [key, value] of obj) {
+          ret.$__set(key, clone(value, options));
+        }
+        return ret;
+      }
     }
 
     if (isPOJO(obj) && obj.$__ != null && obj._doc != null) {
@@ -187,6 +196,11 @@ function cloneArray(arr, options) {
   }
 
   arr = isMongooseArray(arr) ? arr.__array : arr;
+  if (ret.isMongooseDocumentArray) {
+    // 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);
   }

package/lib/helpers/discriminator/mergeDiscriminatorSchema.js

@@ -46,6 +46,11 @@ module.exports = function mergeDiscriminatorSchema(to, from, path, seen) {
     if (specialProperties.has(key)) {
       continue;
     }
+    if (key === 'parentSchema') {
+      // Skip parentSchema to avoid merging parent schema multiple times
+      // through child paths' back-references (gh-15966)
+      continue;
+    }
     if (to[key] == null) {
       to[key] = from[key];
     } else if (isObject(from[key])) {

package/lib/helpers/document/compile.js

@@ -76,6 +76,9 @@ function defineKey({ prop, subprops, prototype, prefix, options }) {
       enumerable: true,
       configurable: true,
       get: function() {
+        if (!this.$__) {
+          return undefined;
+        }
         const _this = this;
         if (!this.$__.getters) {
           this.$__.getters = {};

package/lib/schema/array.js

@@ -398,6 +398,9 @@ SchemaArray.prototype.cast = function(value, doc, init, prev, options) {
           if (options.hydratedPopulatedDocs) {
             opts.hydratedPopulatedDocs = options.hydratedPopulatedDocs;
           }
+          if (options.virtuals) {
+            opts.virtuals = options.virtuals;
+          }
           rawValue[i] = caster.applySetters(rawValue[i], doc, init, void 0, opts);
         }
       } catch (e) {

package/lib/schema/map.js

@@ -58,14 +58,10 @@ class SchemaMap extends SchemaType {
       return val;
     }
 
-    const path = this.path;
+    const path = options?.path ?? this.path;
 
     if (init) {
-      const map = new MongooseMap({}, path, doc, this.$__schemaType, options);
-
-      // Use the map's path for passing to nested casts.
-      // If map's parent is a subdocument, use the relative path so nested casts get relative paths.
-      const mapPath = map.$__pathRelativeToParent != null ? map.$__pathRelativeToParent : map.$__path;
+      const map = new MongooseMap({}, path, doc, this.$__schemaType);
 
       if (val instanceof global.Map) {
         for (const key of val.keys()) {
@@ -73,7 +69,7 @@ class SchemaMap extends SchemaType {
           if (_val == null) {
             _val = map.$__schemaType._castNullish(_val);
           } else {
-            _val = map.$__schemaType.cast(_val, doc, true, null, { ...options, path: mapPath + '.' + key });
+            _val = map.$__schemaType.cast(_val, doc, true, null, { ...options, path: path + '.' + key });
           }
           map.$init(key, _val);
         }
@@ -83,7 +79,7 @@ class SchemaMap extends SchemaType {
           if (_val == null) {
             _val = map.$__schemaType._castNullish(_val);
           } else {
-            _val = map.$__schemaType.cast(_val, doc, true, null, { ...options, path: mapPath + '.' + key });
+            _val = map.$__schemaType.cast(_val, doc, true, null, { ...options, path: path + '.' + key });
           }
           map.$init(key, _val);
         }
@@ -92,7 +88,7 @@ class SchemaMap extends SchemaType {
       return map;
     }
 
-    return new MongooseMap(val, path, doc, this.$__schemaType, options);
+    return new MongooseMap(val, path, doc, this.$__schemaType);
   }
 
   /**

package/lib/types/map.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const Mixed = require('../schema/mixed');
 const MongooseError = require('../error/mongooseError');
 const clone = require('../helpers/clone');
 const deepEqual = require('../utils').deepEqual;
@@ -17,30 +18,14 @@ const populateModelSymbol = require('../helpers/symbols').populateModelSymbol;
  */
 
 class MongooseMap extends Map {
-  constructor(v, path, doc, schemaType, options) {
+  constructor(v, path, doc, schemaType) {
     if (getConstructorName(v) === 'Object') {
       v = Object.keys(v).reduce((arr, key) => arr.concat([[key, v[key]]]), []);
     }
     super(v);
     this.$__parent = doc?.$__ != null ? doc : null;
-
-    // Calculate the full path from the root document
-    // Priority: parent.$basePath (from subdoc) > options.path (from parent map/structure) > path (schema path)
-    // Subdocuments have the most up-to-date path info, so prefer that over options.path
-    if (this.$__parent?.$isSingleNested && this.$__parent.$basePath) {
-      this.$__path = this.$__parent.$basePath + '.' + path;
-      // Performance optimization: store path relative to parent subdocument
-      // to avoid string operations in set() hot path
-      this.$__pathRelativeToParent = path;
-    } else if (options?.path) {
-      this.$__path = options.path;
-      this.$__pathRelativeToParent = null;
-    } else {
-      this.$__path = path;
-      this.$__pathRelativeToParent = null;
-    }
-
-    this.$__schemaType = schemaType;
+    this.$__path = path;
+    this.$__schemaType = schemaType == null ? new Mixed(path) : schemaType;
 
     this.$__runDeferred();
   }
@@ -52,14 +37,6 @@ class MongooseMap extends Map {
 
     if (value?.$isSingleNested) {
       value.$basePath = this.$__path + '.' + key;
-      // Store the path relative to parent subdoc for efficient markModified()
-      if (this.$__pathRelativeToParent != null) {
-        // Map's parent is a subdocument, store path relative to that subdoc
-        value.$pathRelativeToParent = this.$__pathRelativeToParent + '.' + key;
-      } else {
-        // Map's parent is root document, store the full path
-        value.$pathRelativeToParent = this.$__path + '.' + key;
-      }
     }
   }
 
@@ -159,16 +136,9 @@ class MongooseMap extends Map {
       }
     } else {
       try {
-        let options = null;
-        if (this.$__schemaType.$isMongooseDocumentArray || this.$__schemaType.$isSingleNested || this.$__schemaType.$isMongooseArray || this.$__schemaType.$isSchemaMap) {
-          options = { path: fullPath.call(this) };
-          // For subdocuments, also pass the relative path to avoid string operations
-          if (this.$__schemaType.$isSingleNested) {
-            options.pathRelativeToParent = this.$__pathRelativeToParent != null ?
-              this.$__pathRelativeToParent + '.' + key :
-              this.$__path + '.' + key;
-          }
-        }
+        const options = this.$__schemaType.$isMongooseDocumentArray || this.$__schemaType.$isSingleNested || this.$__schemaType.$isMongooseArray || this.$__schemaType.$isSchemaMap ?
+          { path: fullPath.call(this) } :
+          null;
         value = this.$__schemaType.applySetters(
           value,
           this.$__parent,
@@ -187,34 +157,13 @@ class MongooseMap extends Map {
 
     super.set(key, value);
 
-    // Set relative path on subdocuments to avoid string operations in markModified()
-    // The path should be relative to the parent subdocument (if any), not just the key
-    if (value?.$isSingleNested) {
-      if (this.$__pathRelativeToParent != null) {
-        // Map's parent is a subdocument, store path relative to that subdoc (e.g., 'items.i2')
-        value.$pathRelativeToParent = this.$__pathRelativeToParent + '.' + key;
-      } else {
-        // Map's parent is root document, store just the full path
-        value.$pathRelativeToParent = this.$__path + '.' + key;
-      }
-    }
-
     if (parent?.$__ != null && !deepEqual(value, priorVal)) {
-      // Optimization: if parent is a subdocument, use precalculated relative path
-      // to avoid building a full path just to strip the parent's prefix
-      let pathToMark;
-      if (this.$__pathRelativeToParent != null) {
-        // Parent is a subdocument - use precalculated relative path (e.g., 'items.i1')
-        pathToMark = this.$__pathRelativeToParent + '.' + key;
-      } else {
-        // Parent is root document or map - use full path
-        pathToMark = fullPath.call(this);
-      }
-      parent.markModified(pathToMark);
+      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, pathToMark);
+        cleanModifiedSubpaths(parent, path);
       }
     }
 

package/lib/types/subdocument.js

@@ -26,21 +26,7 @@ function Subdocument(value, fields, parent, options) {
   if (options?.path != null) {
     this.$basePath = options.path;
   }
-  if (options?.pathRelativeToParent != null) {
-    this.$pathRelativeToParent = options.pathRelativeToParent;
-  }
-
-  // Don't pass `path` to Document constructor: path is used for storing the
-  // absolute path to this schematype relative to the top-level document, but
-  // subdocuments use relative paths (relative to the parent document) to track changes.
-  // This avoids the subdocument's fields receiving the subdocument's path as options.path.
-  let documentOptions = options;
-  if (options?.path != null) {
-    documentOptions = Object.assign({}, options);
-    delete documentOptions.path;
-  }
-
-  Document.call(this, value, fields, documentOptions);
+  Document.call(this, value, fields, options);
 
   delete this.$__.priorDoc;
 }
@@ -125,12 +111,6 @@ Subdocument.prototype.$__fullPath = function(path) {
  */
 
 Subdocument.prototype.$__pathRelativeToParent = function(p) {
-  // If this subdocument has a stored relative path (set by map when subdoc is created),
-  // use it directly to avoid string operations
-  if (this.$pathRelativeToParent != null) {
-    return p == null ? this.$pathRelativeToParent : this.$pathRelativeToParent + '.' + p;
-  }
-
   if (p == null) {
     return this.$basePath;
   }
@@ -183,13 +163,9 @@ Subdocument.prototype.$isValid = function(path) {
 Subdocument.prototype.markModified = function(path) {
   Document.prototype.markModified.call(this, path);
   const parent = this.$parent();
+  const fullPath = this.$__pathRelativeToParent(path);
 
-  if (parent == null) {
-    return;
-  }
-
-  const pathToMark = this.$__pathRelativeToParent(path);
-  if (pathToMark == null) {
+  if (parent == null || fullPath == null) {
     return;
   }
 
@@ -197,8 +173,7 @@ Subdocument.prototype.markModified = function(path) {
   if (parent.isDirectModified(myPath) || this.isNew) {
     return;
   }
-
-  this.$__parent.markModified(pathToMark, this);
+  this.$__parent.markModified(fullPath, this);
 };
 
 /*!

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@depup/mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "9.1.3-depup.0",
+  "version": "9.1.5-depup.0",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -29,7 +29,7 @@
   },
   "devDependencies": {
     "@ark/attest": "0.56.0",
-    "@mongodb-js/mongodb-downloader": "^1.1.4",
+    "@mongodb-js/mongodb-downloader": "^1.1.6",
     "acquit": "1.4.0",
     "acquit-ignore": "^0.2.2",
     "acquit-require": "0.1.1",
@@ -51,7 +51,7 @@
     "mocha": "11.7.5",
     "moment": "2.30.1",
     "mongodb-memory-server": "11.0.1",
-    "mongodb-runner": "^6.5.2",
+    "mongodb-runner": "^6.5.4",
     "mongodb-client-encryption": "~7.0",
     "ncp": "^2.0.0",
     "nyc": "^17.1.0",
@@ -59,7 +59,7 @@
     "sinon": "21.0.1",
     "tsd": "0.33.0",
     "typescript": "5.9.3",
-    "typescript-eslint": "^8.53.0",
+    "typescript-eslint": "^8.53.1",
     "uuid": "^13.0.0"
   },
   "directories": {

package/types/inferrawdoctype.d.ts

@@ -29,7 +29,9 @@ declare module 'mongoose' {
     SchemaDefinition,
     TSchemaOptions extends Record<any, any> = DefaultSchemaOptions,
     TTransformOptions = { bufferToBinary: false }
-  > = Require_id<InferRawDocTypeWithout_id<SchemaDefinition, TSchemaOptions, TTransformOptions>>;
+  > = TSchemaOptions extends { _id: false }
+    ? InferRawDocTypeWithout_id<SchemaDefinition, TSchemaOptions, TTransformOptions>
+    : Require_id<InferRawDocTypeWithout_id<SchemaDefinition, TSchemaOptions, TTransformOptions>>;
 
   /**
    * @summary Allows users to optionally choose their own type for a schema field for stronger typing.
@@ -88,12 +90,25 @@ declare module 'mongoose' {
      > =
        IsNotNever<TypeHint> extends true ? TypeHint
        : [PathValueType] extends [neverOrAny] ? PathValueType
-       : PathValueType extends Schema<infer RawDocType, any, any, any, any, any, any, any, any, infer TSchemaDefinition> ? IsItRecordAndNotAny<RawDocType> extends true ? RawDocType : InferRawDocType<TSchemaDefinition, DefaultSchemaOptions, TTransformOptions>
+     : PathValueType extends Schema<infer RawDocType, any, any, any, any, any, infer TSchemaOptions, infer DocType, any, infer TSchemaDefinition> ?
+         IsItRecordAndNotAny<RawDocType> extends true ?
+         RawDocType :
+         string extends keyof TSchemaDefinition ?
+          TSchemaOptions extends { _id: false } ?
+            FlattenMaps<SubdocsToPOJOs<DocType>> :
+            Require_id<FlattenMaps<SubdocsToPOJOs<DocType>>> :
+          InferRawDocType<TSchemaDefinition, TSchemaOptions & Record<any, any>, TTransformOptions>
        : PathValueType extends ReadonlyArray<infer Item> ?
          IfEquals<Item, never> extends true ? any[]
-         : Item extends Schema<infer RawDocType, any, any, any, any, any, any, any, any, infer TSchemaDefinition> ?
+         : Item extends Schema<infer RawDocType, any, any, any, any, any, infer TSchemaOptions, infer DocType, any, infer TSchemaDefinition> ?
            // If Item is a schema, infer its type.
-           Array<IsItRecordAndNotAny<RawDocType> extends true ? RawDocType : InferRawDocType<TSchemaDefinition, DefaultSchemaOptions, TTransformOptions>>
+           Array<IsItRecordAndNotAny<RawDocType> extends true ?
+            RawDocType :
+            string extends keyof TSchemaDefinition ?
+              TSchemaOptions extends { _id: false } ?
+                FlattenMaps<SubdocsToPOJOs<DocType>> :
+                Require_id<FlattenMaps<SubdocsToPOJOs<DocType>>> :
+              InferRawDocType<TSchemaDefinition, TSchemaOptions & Record<any, any>, TTransformOptions>>
          : TypeKey extends keyof Item ?
            Item[TypeKey] extends Function | String ?
              // If Item has a type key that's a string or a callable, it must be a scalar,