mongoose 8.18.3 → 8.19.0

package/lib/document.js

@@ -766,6 +766,8 @@ function init(self, obj, doc, opts, prefix) {
         doc[i] = {};
         if (!strict && !(i in docSchema.tree) && !(i in docSchema.methods) && !(i in docSchema.virtuals)) {
           self[i] = doc[i];
+        } else if (opts?.virtuals && (i in docSchema.virtuals)) {
+          self[i] = doc[i];
         }
       }
       init(self, value, doc[i], opts, path + '.');
@@ -773,6 +775,8 @@ function init(self, obj, doc, opts, prefix) {
       doc[i] = value;
       if (!strict && !prefix) {
         self[i] = value;
+      } else if (opts?.virtuals && (i in docSchema.virtuals)) {
+        self[i] = value;
       }
     } else {
       // Retain order when overwriting defaults
@@ -789,9 +793,9 @@ function init(self, obj, doc, opts, prefix) {
             if (opts && opts.setters) {
               // Call applySetters with `init = false` because otherwise setters are a noop
               const overrideInit = false;
-              doc[i] = schemaType.applySetters(value, self, overrideInit);
+              doc[i] = schemaType.applySetters(value, self, overrideInit, null, opts);
             } else {
-              doc[i] = schemaType.cast(value, self, true);
+              doc[i] = schemaType.cast(value, self, true, undefined, opts);
             }
           } catch (e) {
             self.invalidate(e.path, new ValidatorError({

package/lib/helpers/schema/getPath.js

@@ -24,7 +24,7 @@ module.exports = function getPath(schema, path, discriminatorValueMap) {
     cur = cur.length === 0 ? piece : cur + '.' + piece;
 
     schematype = schema.path(cur);
-    if (schematype != null && schematype.schema) {
+    if (schematype?.schema) {
       schema = schematype.schema;
       if (!isArray && schematype.$isMongooseDocumentArray) {
         isArray = true;
@@ -33,6 +33,9 @@ module.exports = function getPath(schema, path, discriminatorValueMap) {
         schema = schema.discriminators[discriminatorValueMap[cur]] ?? schema;
       }
       cur = '';
+    } else if (schematype?.instance === 'Mixed') {
+      // If we found a mixed path, no point in digging further, the end result is always Mixed
+      break;
     }
   }
 

package/lib/model.js

@@ -3966,6 +3966,7 @@ Model.buildBulkWriteOperations = function buildBulkWriteOperations(documents, op
  * @param {Object} [options] optional options
  * @param {Boolean} [options.setters=false] if true, apply schema setters when hydrating
  * @param {Boolean} [options.hydratedPopulatedDocs=false] if true, populates the docs if passing pre-populated data
+ * @param {Boolean} [options.virtuals=false] if true, sets any virtuals present on `obj`
  * @return {Document} document instance
  * @api public
  */
@@ -3973,6 +3974,10 @@ Model.buildBulkWriteOperations = function buildBulkWriteOperations(documents, op
 Model.hydrate = function(obj, projection, options) {
   _checkContext(this, 'hydrate');
 
+  if (options?.virtuals && options?.hydratedPopulatedDocs === false) {
+    throw new MongooseError('Cannot set `hydratedPopulatedDocs` option to false if `virtuals` option is truthy because `virtuals: true` also sets populated virtuals');
+  }
+
   if (projection != null) {
     if (obj != null && obj.$__ != null) {
       obj = obj.toObject(internalToObjectOptions);
@@ -4598,11 +4603,17 @@ async function _populatePath(model, docs, populateOptions) {
 
 function _execPopulateQuery(mod, match, select) {
   let subPopulate = clone(mod.options.populate);
-  const queryOptions = Object.assign({
-    skip: mod.options.skip,
-    limit: mod.options.limit,
-    perDocumentLimit: mod.options.perDocumentLimit
-  }, mod.options.options);
+  const queryOptions = {};
+  if (mod.options.skip !== undefined) {
+    queryOptions.skip = mod.options.skip;
+  }
+  if (mod.options.limit !== undefined) {
+    queryOptions.limit = mod.options.limit;
+  }
+  if (mod.options.perDocumentLimit !== undefined) {
+    queryOptions.perDocumentLimit = mod.options.perDocumentLimit;
+  }
+  Object.assign(queryOptions, mod.options.options);
 
   if (mod.count) {
     delete queryOptions.skip;

package/lib/schema/documentArray.js

@@ -492,7 +492,7 @@ SchemaDocumentArray.prototype.cast = function(value, doc, init, prev, options) {
         }
 
         subdoc = new Constructor(null, value, initDocumentOptions, selected, i);
-        rawArray[i] = subdoc.$init(rawArray[i]);
+        rawArray[i] = subdoc.$init(rawArray[i], options);
       } else {
         if (prev && typeof prev.id === 'function') {
           subdoc = prev.id(rawArray[i]._id);

package/lib/schema/map.js

@@ -39,7 +39,7 @@ class SchemaMap extends SchemaType {
           if (_val == null) {
             _val = map.$__schemaType._castNullish(_val);
           } else {
-            _val = map.$__schemaType.cast(_val, doc, true, null, { path: path + '.' + key });
+            _val = map.$__schemaType.cast(_val, doc, true, null, { ...options, path: path + '.' + key });
           }
           map.$init(key, _val);
         }
@@ -49,7 +49,7 @@ class SchemaMap extends SchemaType {
           if (_val == null) {
             _val = map.$__schemaType._castNullish(_val);
           } else {
-            _val = map.$__schemaType.cast(_val, doc, true, null, { path: path + '.' + key });
+            _val = map.$__schemaType.cast(_val, doc, true, null, { ...options, path: path + '.' + key });
           }
           map.$init(key, _val);
         }

package/lib/schema/subdocument.js

@@ -203,7 +203,7 @@ SchemaSubdocument.prototype.cast = function(val, doc, init, priorVal, options) {
   if (init) {
     subdoc = new Constructor(void 0, selected, doc, false, { defaults: false });
     delete subdoc.$__.defaults;
-    subdoc.$init(val);
+    subdoc.$init(val, options);
     const exclude = isExclusive(selected);
     applyDefaults(subdoc, selected, exclude);
   } else {

package/lib/schemaType.js

@@ -44,6 +44,7 @@ function SchemaType(path, options, instance) {
   this[schemaTypeSymbol] = true;
   this.path = path;
   this.instance = instance;
+  this.schemaName = this.constructor.schemaName;
   this.validators = [];
   this.getters = this.constructor.hasOwnProperty('getters') ?
     this.constructor.getters.slice() :

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "8.18.3",
+  "version": "8.19.0",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -22,13 +22,14 @@
   "dependencies": {
     "bson": "^6.10.4",
     "kareem": "2.6.3",
-    "mongodb": "~6.18.0",
+    "mongodb": "~6.20.0",
     "mpath": "0.9.0",
     "mquery": "5.0.0",
     "ms": "2.1.3",
     "sift": "17.1.3"
   },
   "devDependencies": {
+    "@ark/attest": "0.48.2",
     "@babel/core": "7.28.3",
     "@babel/preset-env": "7.28.3",
     "@mongodb-js/mongodb-downloader": "^0.4.2",
@@ -111,7 +112,8 @@
     "test-encryption": "mocha --exit ./test/encryption/*.test.js",
     "tdd": "mocha ./test/*.test.js --inspect --watch --recursive --watch-files ./**/*.{js,ts}",
     "test-coverage": "nyc --reporter=html --reporter=text npm test",
-    "ts-benchmark": "cd ./benchmarks/typescript/simple && npm install && npm run benchmark | node ../../../scripts/tsc-diagnostics-check"
+    "ts-benchmark": "cd ./benchmarks/typescript/simple && npm install && npm run benchmark | node ../../../scripts/tsc-diagnostics-check",
+    "attest-benchmark": "node ./benchmarks/typescript/infer.bench.mts"
   },
   "main": "./index.js",
   "types": "./types/index.d.ts",

package/types/index.d.ts

@@ -566,11 +566,18 @@ declare module 'mongoose' {
     static ObjectId: typeof Schema.Types.ObjectId;
   }
 
-  export type NumberSchemaDefinition = typeof Number | 'number' | 'Number' | typeof Schema.Types.Number;
-  export type StringSchemaDefinition = typeof String | 'string' | 'String' | typeof Schema.Types.String;
-  export type BooleanSchemaDefinition = typeof Boolean | 'boolean' | 'Boolean' | typeof Schema.Types.Boolean;
-  export type DateSchemaDefinition = DateConstructor | 'date' | 'Date' | typeof Schema.Types.Date;
-  export type ObjectIdSchemaDefinition = 'ObjectId' | 'ObjectID' | typeof Schema.Types.ObjectId;
+  export type NumberSchemaDefinition = typeof Number | 'number' | 'Number' | typeof Schema.Types.Number | Schema.Types.Number;
+  export type StringSchemaDefinition = typeof String | 'string' | 'String' | typeof Schema.Types.String | Schema.Types.String;
+  export type BooleanSchemaDefinition = typeof Boolean | 'boolean' | 'Boolean' | typeof Schema.Types.Boolean | Schema.Types.Boolean;
+  export type DateSchemaDefinition = DateConstructor | 'date' | 'Date' | typeof Schema.Types.Date | Schema.Types.Date;
+  export type ObjectIdSchemaDefinition = 'ObjectId' | 'ObjectID' | typeof Schema.Types.ObjectId | Schema.Types.ObjectId | Types.ObjectId;
+  export type BufferSchemaDefinition = typeof Buffer | 'buffer' | 'Buffer' | typeof Schema.Types.Buffer;
+  export type Decimal128SchemaDefinition = 'decimal128' | 'Decimal128' | typeof Schema.Types.Decimal128 | Schema.Types.Decimal128 | Types.Decimal128;
+  export type BigintSchemaDefinition = 'bigint' | 'BigInt' | typeof Schema.Types.BigInt | Schema.Types.BigInt | typeof BigInt | BigInt;
+  export type UuidSchemaDefinition = 'uuid' | 'UUID' | typeof Schema.Types.UUID | Schema.Types.UUID;
+  export type MapSchemaDefinition = MapConstructor | 'Map' | typeof Schema.Types.Map;
+  export type UnionSchemaDefinition = 'Union' | 'union' | typeof Schema.Types.Union | Schema.Types.Union;
+  export type DoubleSchemaDefinition = 'double' | 'Double' | typeof Schema.Types.Double | Schema.Types.Double;
 
   export type SchemaDefinitionWithBuiltInClass<T> = T extends number
     ? NumberSchemaDefinition
@@ -582,7 +589,9 @@ declare module 'mongoose' {
           ? DateSchemaDefinition
           : (Function | string);
 
-  export type SchemaDefinitionProperty<T = undefined, EnforcedDocType = any, THydratedDocumentType = HydratedDocument<EnforcedDocType>> = SchemaDefinitionWithBuiltInClass<T>
+  export type SchemaDefinitionProperty<T = undefined, EnforcedDocType = any, THydratedDocumentType = HydratedDocument<EnforcedDocType>> =
+    // ThisType intersection here avoids corrupting ThisType for SchemaTypeOptions (see test gh11828)
+    | SchemaDefinitionWithBuiltInClass<T> & ThisType<EnforcedDocType>
     | SchemaTypeOptions<T extends undefined ? any : T, EnforcedDocType, THydratedDocumentType>
     | typeof SchemaType
     | Schema<any, any, any>
@@ -905,8 +914,8 @@ declare module 'mongoose' {
    * https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types
    */
   type FlattenProperty<T> = T extends Map<any, infer V>
-    ? Record<string, V> : T extends TreatAsPrimitives
-      ? T : T extends Types.DocumentArray<infer ItemType>
+      ? Record<string, V> : T extends TreatAsPrimitives
+      ? T : T extends Document ? T : T extends Types.DocumentArray<infer ItemType>
         ? Types.DocumentArray<FlattenMaps<ItemType>> : FlattenMaps<T>;
 
   export type actualPrimitives = string | boolean | number | bigint | symbol | null | undefined;

package/types/inferrawdoctype.d.ts

@@ -1,24 +1,27 @@
 import {
-  IsPathRequired,
   IsSchemaTypeFromBuiltinClass,
-  RequiredPaths,
-  OptionalPaths,
-  PathWithTypePropertyBaseType,
-  PathEnumOrString
+  PathEnumOrString,
+  type OptionalPathKeys,
+  type RequiredPathKeys
 } from './inferschematype';
 
 declare module 'mongoose' {
-  export type InferRawDocType<
-    DocDefinition,
-    TSchemaOptions extends Record<any, any> = DefaultSchemaOptions
-  > = ApplySchemaOptions<{
-    [
-    K in keyof (RequiredPaths<DocDefinition, TSchemaOptions['typeKey']> &
-    OptionalPaths<DocDefinition, TSchemaOptions['typeKey']>)
-    ]: IsPathRequired<DocDefinition[K], TSchemaOptions['typeKey']> extends true
-      ? ObtainRawDocumentPathType<DocDefinition[K], TSchemaOptions['typeKey']>
-      : ObtainRawDocumentPathType<DocDefinition[K], TSchemaOptions['typeKey']> | null;
-  }, TSchemaOptions>;
+  export type InferRawDocType<DocDefinition, TSchemaOptions extends Record<any, any> = DefaultSchemaOptions> = Show<
+    ApplySchemaOptions<
+      {
+        [K in RequiredPathKeys<DocDefinition, TSchemaOptions['typeKey']>]: ObtainRawDocumentPathType<
+          DocDefinition[K],
+          TSchemaOptions['typeKey']
+        >;
+      } & {
+        [K in OptionalPathKeys<DocDefinition, TSchemaOptions['typeKey']>]?: ObtainRawDocumentPathType<
+          DocDefinition[K],
+          TSchemaOptions['typeKey']
+        > | null;
+      },
+      TSchemaOptions
+    >
+  >;
 
   /**
    * @summary Obtains schema Path type.
@@ -26,18 +29,15 @@ declare module 'mongoose' {
    * @param {PathValueType} PathValueType Document definition path type.
    * @param {TypeKey} TypeKey A generic refers to document definition.
    */
-  type ObtainRawDocumentPathType<
-    PathValueType,
-    TypeKey extends string = DefaultTypeKey
-  > = ResolveRawPathType<
-    PathValueType extends PathWithTypePropertyBaseType<TypeKey> ? PathValueType[TypeKey] : PathValueType,
-    PathValueType extends PathWithTypePropertyBaseType<TypeKey> ? Omit<PathValueType, TypeKey> : {},
-    TypeKey
-  >;
+  type ObtainRawDocumentPathType<PathValueType, TypeKey extends string = DefaultTypeKey> =
+    TypeKey extends keyof PathValueType ?
+      ResolveRawPathType<PathValueType[TypeKey], Omit<PathValueType, TypeKey>, TypeKey>
+    : ResolveRawPathType<PathValueType, {}, TypeKey>;
 
-  type UnionToRawPathType<T extends readonly any[]> = T[number] extends infer U
-    ? ResolveRawPathType<U>
-    : never;
+  // can be efficiently checked like:
+  // `[T] extends [neverOrAny] ? T : ...`
+  // to avoid edge cases
+  type neverOrAny = ' ~neverOrAny~';
 
   /**
    * Same as inferSchemaType, except:
@@ -52,73 +52,54 @@ declare module 'mongoose' {
    * @param {TypeKey} TypeKey A generic of literal string type."Refers to the property used for path type definition".
    * @returns Number, "Number" or "number" will be resolved to number type.
    */
-  type ResolveRawPathType<PathValueType, Options extends SchemaTypeOptions<PathValueType> = {}, TypeKey extends string = DefaultSchemaOptions['typeKey']> =
-  PathValueType extends Schema ?
-    InferSchemaType<PathValueType> :
-    PathValueType extends (infer Item)[] ?
-      IfEquals<Item, never, any[], Item extends Schema ?
+  type ResolveRawPathType<
+    PathValueType,
+    Options extends SchemaTypeOptions<PathValueType> = {},
+    TypeKey extends string = DefaultSchemaOptions['typeKey']
+  > =
+    [PathValueType] extends [neverOrAny] ? PathValueType
+    : PathValueType extends Schema ? InferSchemaType<PathValueType>
+    : PathValueType extends ReadonlyArray<infer Item> ?
+      Item extends never ? any[]
+      : Item extends Schema ?
         // If Item is a schema, infer its type.
-        Array<InferSchemaType<Item>> :
-        Item extends Record<TypeKey, any> ?
-          Item[TypeKey] extends Function | String ?
-            // If Item has a type key that's a string or a callable, it must be a scalar,
-            // so we can directly obtain its path type.
-            ObtainRawDocumentPathType<Item, TypeKey>[] :
-            // 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 ?
-            ObtainRawDocumentPathType<Item, TypeKey>[] :
-            IsItRecordAndNotAny<Item> extends true ?
-              Item extends Record<string, never> ?
-                ObtainRawDocumentPathType<Item, TypeKey>[] :
-                Array<InferRawDocType<Item>> :
-              ObtainRawDocumentPathType<Item, TypeKey>[]
-      >:
-      PathValueType extends ReadonlyArray<infer Item> ?
-        IfEquals<Item, never, any[], Item extends Schema ?
-          Array<InferSchemaType<Item>> :
-          Item extends Record<TypeKey, any> ?
-            Item[TypeKey] extends Function | String ?
-              ObtainRawDocumentPathType<Item, TypeKey>[] :
-              InferRawDocType<Item>[]:
-            IsSchemaTypeFromBuiltinClass<Item> extends true ?
-              ObtainRawDocumentPathType<Item, TypeKey>[] :
-              IsItRecordAndNotAny<Item> extends true ?
-                Item extends Record<string, never> ?
-                  ObtainRawDocumentPathType<Item, TypeKey>[] :
-                  Array<InferRawDocType<Item>> :
-                ObtainRawDocumentPathType<Item, TypeKey>[]
-        >:
-        PathValueType extends StringSchemaDefinition ? PathEnumOrString<Options['enum']> :
-          IfEquals<PathValueType, Schema.Types.String> extends true ? PathEnumOrString<Options['enum']> :
-            IfEquals<PathValueType, String> extends true ? PathEnumOrString<Options['enum']> :
-              PathValueType extends NumberSchemaDefinition ? Options['enum'] extends ReadonlyArray<any> ? Options['enum'][number] : number :
-                IfEquals<PathValueType, Schema.Types.Number> extends true ? number :
-                  PathValueType extends DateSchemaDefinition ? NativeDate :
-                    IfEquals<PathValueType, Schema.Types.Date> extends true ? NativeDate :
-                      PathValueType extends typeof Buffer | 'buffer' | 'Buffer' | typeof Schema.Types.Buffer ? Buffer :
-                        PathValueType extends BooleanSchemaDefinition ? boolean :
-                          IfEquals<PathValueType, Schema.Types.Boolean> extends true ? boolean :
-                            PathValueType extends ObjectIdSchemaDefinition ? Types.ObjectId :
-                              IfEquals<PathValueType, Types.ObjectId> extends true ? Types.ObjectId :
-                                IfEquals<PathValueType, Schema.Types.ObjectId> extends true ? Types.ObjectId :
-                                  PathValueType extends 'decimal128' | 'Decimal128' | typeof Schema.Types.Decimal128 ? Types.Decimal128 :
-                                    IfEquals<PathValueType, Schema.Types.Decimal128> extends true ? Types.Decimal128 :
-                                      IfEquals<PathValueType, Types.Decimal128> extends true ? Types.Decimal128 :
-                                        IfEquals<PathValueType, Schema.Types.BigInt> extends true ? bigint :
-                                          IfEquals<PathValueType, BigInt> extends true ? bigint :
-                                            PathValueType extends 'bigint' | 'BigInt' | typeof Schema.Types.BigInt | typeof BigInt ? bigint :
-                                              PathValueType extends 'uuid' | 'UUID' | typeof Schema.Types.UUID ? Buffer :
-                                                IfEquals<PathValueType, Schema.Types.UUID> extends true ? Buffer :
-                                                  PathValueType extends MapConstructor | 'Map' ? Map<string, ObtainRawDocumentPathType<Options['of']>> :
-                                                    IfEquals<PathValueType, typeof Schema.Types.Map> extends true ? Map<string, ObtainRawDocumentPathType<Options['of']>> :
-                                                      PathValueType extends 'Union' | 'union' | typeof Schema.Types.Union ? Options['of'] extends readonly any[] ? UnionToRawPathType<Options['of']> : never :
-                                                        PathValueType extends ArrayConstructor ? any[] :
-                                                          PathValueType extends typeof Schema.Types.Mixed ? any:
-                                                            IfEquals<PathValueType, ObjectConstructor> extends true ? any:
-                                                              IfEquals<PathValueType, {}> extends true ? any:
-                                                                PathValueType extends typeof SchemaType ? PathValueType['prototype'] :
-                                                                  PathValueType extends Record<string, any> ? InferRawDocType<PathValueType> :
-                                                                    unknown;
+        Array<InferSchemaType<Item>>
+      : 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,
+          // so we can directly obtain its path type.
+          ObtainRawDocumentPathType<Item, TypeKey>[]
+        : // 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>[]
+      : IsItRecordAndNotAny<Item> extends true ?
+        Item extends Record<string, never> ?
+          ObtainRawDocumentPathType<Item, TypeKey>[]
+        : Array<InferRawDocType<Item>>
+      : ObtainRawDocumentPathType<Item, TypeKey>[]
+    : PathValueType extends StringSchemaDefinition ? PathEnumOrString<Options['enum']>
+    : IfEquals<PathValueType, String> extends true ? PathEnumOrString<Options['enum']>
+    : PathValueType extends NumberSchemaDefinition ?
+      Options['enum'] extends ReadonlyArray<any> ?
+        Options['enum'][number]
+      : number
+    : PathValueType extends DateSchemaDefinition ? NativeDate
+    : PathValueType extends BufferSchemaDefinition ? Buffer
+    : PathValueType extends BooleanSchemaDefinition ? boolean
+    : PathValueType extends ObjectIdSchemaDefinition ? Types.ObjectId
+    : PathValueType extends Decimal128SchemaDefinition ? Types.Decimal128
+    : PathValueType extends BigintSchemaDefinition ? bigint
+    : PathValueType extends UuidSchemaDefinition ? Buffer
+    : PathValueType extends DoubleSchemaDefinition ? Types.Double
+    : PathValueType extends MapSchemaDefinition ? Map<string, ObtainRawDocumentPathType<Options['of']>>
+    : PathValueType extends UnionSchemaDefinition ?
+      ResolveRawPathType<Options['of'] extends ReadonlyArray<infer Item> ? Item : never>
+    : PathValueType extends ArrayConstructor ? any[]
+    : PathValueType extends typeof Schema.Types.Mixed ? any
+    : IfEquals<PathValueType, ObjectConstructor> extends true ? any
+    : IfEquals<PathValueType, {}> extends true ? any
+    : PathValueType extends typeof SchemaType ? PathValueType['prototype']
+    : PathValueType extends Record<string, any> ? InferRawDocType<PathValueType>
+    : unknown;
 }