mongoose 8.17.1 → 8.18.0

package/types/index.d.ts

@@ -140,9 +140,21 @@ declare module 'mongoose' {
     ? IfAny<U, T & { _id: Types.ObjectId }, T & Required<{ _id: U }>>
     : T & { _id: Types.ObjectId };
 
-  export type Default__v<T, TSchemaOptions = {}> = TSchemaOptions extends { versionKey: false } ? T : T extends { __v?: infer U }
+  export type Default__v<T, TSchemaOptions = {}> = TSchemaOptions extends { versionKey: false }
     ? T
-    : T & { __v: number };
+    : TSchemaOptions extends { versionKey: infer VK }
+      ? (
+          // If VK is a *literal* string, add that property
+          T & {
+            [K in VK as K extends string
+              ? (string extends K ? never : K) // drop if wide string
+              : never
+            ]: number
+          }
+        )
+      : T extends { __v?: infer U }
+        ? T
+        : T & { __v: number };
 
   /** Helper type for getting the hydrated document type from the raw document type. The hydrated document type is what `new MyModel()` returns. */
   export type HydratedDocument<

package/types/inferrawdoctype.d.ts

@@ -35,6 +35,10 @@ declare module 'mongoose' {
     TypeKey
   >;
 
+  type UnionToRawPathType<T extends readonly any[]> = T[number] extends infer U
+    ? ResolveRawPathType<U>
+    : never;
+
   /**
    * Same as inferSchemaType, except:
    *
@@ -109,11 +113,12 @@ declare module 'mongoose' {
                                                 IfEquals<PathValueType, Schema.Types.UUID> extends true ? Buffer :
                                                   PathValueType extends MapConstructor | 'Map' ? Map<string, ResolveRawPathType<Options['of']>> :
                                                     IfEquals<PathValueType, typeof Schema.Types.Map> extends true ? Map<string, ResolveRawPathType<Options['of']>> :
-                                                      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;
+                                                      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;
 }

package/types/inferschematype.d.ts

@@ -75,10 +75,7 @@ declare module 'mongoose' {
 
   type ApplySchemaOptions<T, O = DefaultSchemaOptions> = ResolveTimestamps<T, O>;
 
-  type ResolveTimestamps<T, O> = O extends { methods: any } | { statics: any } | { virtuals: any } | { timestamps?: false } ? T
-    // For some reason, TypeScript sets all the document properties to unknown
-    // if we use methods, statics, or virtuals. So avoid inferring timestamps
-    // if any of these are set for now. See gh-12807
+  type ResolveTimestamps<T, O> = O extends { timestamps?: false } ? T
     : O extends { timestamps: infer TimestampOptions } ? TimestampOptions extends true
       ? { createdAt: NativeDate; updatedAt: NativeDate; } & T
       : TimestampOptions extends SchemaTimestampsConfig
@@ -206,6 +203,10 @@ TypeHint<PathValueType>
  */
 type PathEnumOrString<T extends SchemaTypeOptions<string>['enum']> = T extends ReadonlyArray<infer E> ? E : T extends { values: any } ? PathEnumOrString<T['values']> : T extends Record<string, infer V> ? V : string;
 
+type UnionToType<T extends readonly any[]> = T[number] extends infer U
+  ? ResolvePathType<U>
+  : never;
+
 type IsSchemaTypeFromBuiltinClass<T> = T extends (typeof String)
   ? true
   : T extends (typeof Number)
@@ -317,11 +318,12 @@ type ResolvePathType<PathValueType, Options extends SchemaTypeOptions<PathValueT
                                                       IfEquals<PathValueType, Schema.Types.UUID> extends true ? Buffer :
                                                         PathValueType extends MapConstructor | 'Map' ? Map<string, ResolvePathType<Options['of']>> :
                                                           IfEquals<PathValueType, typeof Schema.Types.Map> extends true ? Map<string, ResolvePathType<Options['of']>> :
-                                                            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> ? ObtainDocumentType<PathValueType, any, { typeKey: TypeKey }> :
-                                                                        unknown,
+                                                            PathValueType extends 'Union' | 'union' | typeof Schema.Types.Union ? Options['of'] extends readonly any[] ? UnionToType<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> ? ObtainDocumentType<PathValueType, any, { typeKey: TypeKey }> :
+                                                                          unknown,
   TypeHint>;

package/types/schematypes.d.ts

@@ -188,7 +188,7 @@ declare module 'mongoose' {
     _id?: boolean;
 
     /** If set, specifies the type of this map's values. Mongoose will cast this map's values to the given type. */
-    of?: Function | SchemaDefinitionProperty<any>;
+    of?: Function | SchemaDefinitionProperty<any> | (Function | SchemaDefinitionProperty<any>)[];
 
     /** If true, uses Mongoose's default `_id` settings. Only allowed for ObjectIds */
     auto?: boolean;
@@ -569,6 +569,13 @@ declare module 'mongoose' {
         static defaultOptions: Record<string, any>;
       }
 
+      class Union extends SchemaType {
+        static schemaName: 'Union';
+
+        /** Default options for this SchemaType */
+        static defaultOptions: Record<string, any>;
+      }
+
       class UUID extends SchemaType {
         /** This schema type's name, to defend against minifiers that mangle function names. */
         static schemaName: 'UUID';