mongoose 8.18.3 → 8.19.0

package/types/inferschematype.d.ts

@@ -1,20 +1,27 @@
 import {
-  Schema,
-  InferSchemaType,
-  SchemaType,
-  SchemaTypeOptions,
-  TypeKeyBaseType,
-  Types,
-  NumberSchemaDefinition,
-  StringSchemaDefinition,
+  AnyArray,
   BooleanSchemaDefinition,
+  BigintSchemaDefinition,
+  BufferSchemaDefinition,
   DateSchemaDefinition,
-  ObtainDocumentType,
+  Decimal128SchemaDefinition,
+  DefaultSchemaOptions,
   DefaultTypeKey,
-  ObjectIdSchemaDefinition,
+  DoubleSchemaDefinition,
   IfEquals,
-  DefaultSchemaOptions,
-  IsItRecordAndNotAny
+  InferSchemaType,
+  IsItRecordAndNotAny,
+  MapSchemaDefinition,
+  NumberSchemaDefinition,
+  ObjectIdSchemaDefinition,
+  ObtainDocumentType,
+  Schema,
+  SchemaType,
+  SchemaTypeOptions,
+  StringSchemaDefinition,
+  Types,
+  UnionSchemaDefinition,
+  UuidSchemaDefinition
 } from 'mongoose';
 
 declare module 'mongoose' {
@@ -29,16 +36,17 @@ declare module 'mongoose' {
     DocDefinition,
     EnforcedDocType = any,
     TSchemaOptions extends Record<any, any> = DefaultSchemaOptions
-  > = IsItRecordAndNotAny<EnforcedDocType> extends true ?
-    EnforcedDocType :
-    {
-      [
-      K in keyof (RequiredPaths<DocDefinition, TSchemaOptions['typeKey']> &
-      OptionalPaths<DocDefinition, TSchemaOptions['typeKey']>)
-      ]: IsPathRequired<DocDefinition[K], TSchemaOptions['typeKey']> extends true ?
-        ObtainDocumentPathType<DocDefinition[K], TSchemaOptions['typeKey']> :
-        ObtainDocumentPathType<DocDefinition[K], TSchemaOptions['typeKey']> | null;
-    };
+  > =
+    IsItRecordAndNotAny<EnforcedDocType> extends true ? EnforcedDocType
+    : {
+        [K in keyof (RequiredPaths<DocDefinition, TSchemaOptions['typeKey']> &
+          OptionalPaths<DocDefinition, TSchemaOptions['typeKey']>)]: IsPathRequired<
+          DocDefinition[K],
+          TSchemaOptions['typeKey']
+        > extends true ?
+          ObtainDocumentPathType<DocDefinition[K], TSchemaOptions['typeKey']>
+        : ObtainDocumentPathType<DocDefinition[K], TSchemaOptions['typeKey']> | null;
+      };
 
   /**
    * @summary Obtains document schema type from Schema instance.
@@ -56,48 +64,80 @@ declare module 'mongoose' {
    * @param {TSchema} TSchema A generic of schema type instance.
    * @param {alias} alias Targeted generic alias.
    */
-  type ObtainSchemaGeneric<TSchema, alias extends 'EnforcedDocType' | 'M' | 'TInstanceMethods' | 'TQueryHelpers' | 'TVirtuals' | 'TStaticMethods' | 'TSchemaOptions' | 'DocType' | 'THydratedDocumentType'> =
-   TSchema extends Schema<infer EnforcedDocType, infer M, infer TInstanceMethods, infer TQueryHelpers, infer TVirtuals, infer TStaticMethods, infer TSchemaOptions, infer DocType, infer THydratedDocumentType>
-     ? {
-       EnforcedDocType: EnforcedDocType;
-       M: M;
-       TInstanceMethods: TInstanceMethods;
-       TQueryHelpers: TQueryHelpers;
-       TVirtuals: TVirtuals;
-       TStaticMethods: TStaticMethods;
-       TSchemaOptions: TSchemaOptions;
-       DocType: DocType;
-       THydratedDocumentType: THydratedDocumentType;
-     }[alias]
-     : unknown;
+  type ObtainSchemaGeneric<
+    TSchema,
+    alias extends
+      | 'EnforcedDocType'
+      | 'M'
+      | 'TInstanceMethods'
+      | 'TQueryHelpers'
+      | 'TVirtuals'
+      | 'TStaticMethods'
+      | 'TSchemaOptions'
+      | 'DocType'
+      | 'THydratedDocumentType'
+  > =
+    TSchema extends (
+      Schema<
+        infer EnforcedDocType,
+        infer M,
+        infer TInstanceMethods,
+        infer TQueryHelpers,
+        infer TVirtuals,
+        infer TStaticMethods,
+        infer TSchemaOptions,
+        infer DocType,
+        infer THydratedDocumentType
+      >
+    ) ?
+      {
+        EnforcedDocType: EnforcedDocType;
+        M: M;
+        TInstanceMethods: TInstanceMethods;
+        TQueryHelpers: TQueryHelpers;
+        TVirtuals: TVirtuals;
+        TStaticMethods: TStaticMethods;
+        TSchemaOptions: TSchemaOptions;
+        DocType: DocType;
+        THydratedDocumentType: THydratedDocumentType;
+      }[alias]
+    : unknown;
 
   type ResolveSchemaOptions<T> = MergeType<DefaultSchemaOptions, T>;
 
   type ApplySchemaOptions<T, O = DefaultSchemaOptions> = ResolveTimestamps<T, O>;
 
-  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
-        ? {
-          -readonly [K in keyof Pick<
-            TimestampOptions,
-            'createdAt' | 'updatedAt'
-          > as TimestampOptions[K] extends true
-            ? K
-            : TimestampOptions[K] extends `${infer TimestampValue}`
-              ? TimestampValue
-              : never]: NativeDate;
-        } & T
-        : T
-      : T;
+  type DefaultTimestampProps = {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+  };
+
+  type ResolveTimestamps<T, O> =
+    O extends { timestamps?: false } ? T
+    : O extends { timestamps: infer TimestampOptions } ?
+      TimestampOptions extends true ? T & DefaultTimestampProps
+      : TimestampOptions extends SchemaTimestampsConfig ?
+        Show<
+          T & {
+            [K in keyof TimestampOptions & keyof DefaultTimestampProps as TimestampOptions[K] extends true ? K
+            : TimestampOptions[K] & string]: NativeDate;
+          }
+        >
+      : T
+    : T;
 }
 
-type IsPathDefaultUndefined<PathType> = PathType extends { default: undefined } ?
-  true :
-  PathType extends { default: (...args: any[]) => undefined } ?
-    true :
-    false;
+type IsPathDefaultUndefined<PathType> =
+  PathType extends { default: undefined } ? true
+  : PathType extends { default: (...args: any[]) => undefined } ? true
+  : false;
+
+type RequiredPropertyDefinition =
+  | {
+      required: true | string | [true, string | undefined] | { isRequired: true };
+    }
+  | ArrayConstructor
+  | any[];
 
 /**
  * @summary Checks if a document path is required or optional.
@@ -105,28 +145,20 @@ type IsPathDefaultUndefined<PathType> = PathType extends { default: undefined }
  * @param {TypeKey} TypeKey A generic of literal string type."Refers to the property used for path type definition".
  */
 type IsPathRequired<P, TypeKey extends string = DefaultTypeKey> =
-  P extends { required: true | string | [true, string | undefined] | { isRequired: true } } | ArrayConstructor | any[]
-    ? true
-    : P extends { required: boolean }
-      ? P extends { required: false }
-        ? false
-        : true
-      : P extends (Record<TypeKey, ArrayConstructor | any[]>)
-        ? IsPathDefaultUndefined<P> extends true
-          ? false
-          : true
-        : P extends (Record<TypeKey, any>)
-          ? P extends { default: any }
-            ? IfEquals<P['default'], undefined, false, true>
-            : false
-          : false;
-
-/**
- * @summary Path base type defined by using TypeKey
- * @description It helps to check if a path is defined by TypeKey OR not.
- * @param {TypeKey} TypeKey A literal string refers to path type property key.
- */
-type PathWithTypePropertyBaseType<TypeKey extends string = DefaultTypeKey> = { [k in TypeKey]: any };
+  P extends RequiredPropertyDefinition ? true
+  : P extends { required: boolean } ?
+    P extends { required: false } ?
+      false
+    : true
+  : P extends Record<TypeKey, ArrayConstructor | any[]> ?
+    IsPathDefaultUndefined<P> extends true ?
+      false
+    : true
+  : P extends Record<TypeKey, any> ?
+    P extends { default: any } ?
+      IfEquals<P['default'], undefined, false, true>
+    : false
+  : false;
 
 /**
  * @summary A Utility to obtain schema's required path keys.
@@ -134,9 +166,7 @@ type PathWithTypePropertyBaseType<TypeKey extends string = DefaultTypeKey> = { [
  * @param {TypeKey} TypeKey A generic of literal string type."Refers to the property used for path type definition".
  * @returns required paths keys of document definition.
  */
-type RequiredPathKeys<T, TypeKey extends string = DefaultTypeKey> = {
-  [K in keyof T]: IsPathRequired<T[K], TypeKey> extends true ? IfEquals<T[K], any, never, K> : never;
-}[keyof T];
+type RequiredPathKeys<T, TypeKey extends string = DefaultTypeKey> = Exclude<keyof T, OptionalPathKeys<T, TypeKey>>;
 
 /**
  * @summary A Utility to obtain schema's required paths.
@@ -173,8 +203,7 @@ type OptionalPaths<T, TypeKey extends string = DefaultTypeKey> = Pick<
 /**
  * @summary Allows users to optionally choose their own type for a schema field for stronger typing.
  */
-type TypeHint<T> = T extends { __typehint: infer U } ? U: never;
-
+type TypeHint<T> = T extends { __typehint: infer U } ? U : never;
 
 /**
  * @summary Obtains schema Path type.
@@ -183,71 +212,51 @@ type TypeHint<T> = T extends { __typehint: infer U } ? U: never;
  * @param {TypeKey} TypeKey A generic refers to document definition.
  */
 type ObtainDocumentPathType<PathValueType, TypeKey extends string = DefaultTypeKey> = ResolvePathType<
-  PathValueType extends PathWithTypePropertyBaseType<TypeKey>
-    ? PathValueType[TypeKey] extends PathWithTypePropertyBaseType<TypeKey>
-      ? PathValueType
-      : PathValueType[TypeKey]
-    : PathValueType,
-  PathValueType extends PathWithTypePropertyBaseType<TypeKey>
-    ? PathValueType[TypeKey] extends PathWithTypePropertyBaseType<TypeKey>
-      ? {}
-      : Omit<PathValueType, TypeKey>
-    : {},
-TypeKey,
-TypeHint<PathValueType>
+  TypeKey extends keyof PathValueType ?
+    TypeKey extends keyof PathValueType[TypeKey] ?
+      PathValueType
+    : PathValueType[TypeKey]
+  : PathValueType,
+  TypeKey extends keyof PathValueType ?
+    TypeKey extends keyof PathValueType[TypeKey] ?
+      {}
+    : Omit<PathValueType, TypeKey>
+  : {},
+  TypeKey,
+  TypeHint<PathValueType>
 >;
 
 /**
  * @param {T} T A generic refers to string path enums.
  * @returns Path enum values type as literal strings or string.
  */
-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 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 IsSchemaTypeFromBuiltinClass<T> = T extends (typeof String)
-  ? true
-  : T extends (typeof Number)
-    ? true
-    : T extends (typeof Boolean)
-      ? true
-      : T extends (typeof Buffer)
-        ? true
-        : T extends (typeof Schema.Types.ObjectId)
-          ? true
-          : T extends (typeof Schema.Types.UUID)
-            ? true
-            : T extends (typeof Schema.Types.Decimal128)
-              ? true
-              : T extends (typeof Schema.Types.Int32)
-                ? true
-                  : T extends (typeof Schema.Types.String)
-                    ? true
-                    : T extends (typeof Schema.Types.Number)
-                      ? true
-                      : T extends (typeof Schema.Types.Date)
-                        ? true
-                        : T extends (typeof Schema.Types.Double)
-                          ? true
-                          : T extends (typeof Schema.Types.Boolean)
-                            ? true
-                            : T extends Types.ObjectId
-                              ? true
-                              : T extends Types.Decimal128
-                                ? true
-                                : T extends NativeDate
-                                  ? true
-                                  : T extends (typeof Schema.Types.Mixed)
-                                    ? true
-                                    : IfEquals<T, Schema.Types.ObjectId, true, false> extends true
-                                      ? true
-                                      : unknown extends Buffer
-                                        ? false
-                                        : T extends Buffer
-                                          ? true
-                                          : false;
+type IsSchemaTypeFromBuiltinClass<T> =
+  T extends typeof String ? true
+  : T extends typeof Number ? true
+  : T extends typeof Boolean ? true
+  : T extends typeof Buffer ? true
+  : T extends typeof Schema.Types.ObjectId ? true
+  : T extends typeof Schema.Types.UUID ? true
+  : T extends typeof Schema.Types.Decimal128 ? true
+  : T extends typeof Schema.Types.Int32 ? true
+  : T extends typeof Schema.Types.String ? true
+  : T extends typeof Schema.Types.Number ? true
+  : T extends typeof Schema.Types.Date ? true
+  : T extends typeof Schema.Types.Double ? true
+  : T extends typeof Schema.Types.Boolean ? true
+  : T extends Types.ObjectId ? true
+  : T extends Types.Decimal128 ? true
+  : T extends NativeDate ? true
+  : T extends typeof Schema.Types.Mixed ? true
+  : unknown extends Buffer ? false
+  : T extends Buffer ? true
+  : false;
 
 /**
  * @summary Resolve path type by returning the corresponding type.
@@ -256,74 +265,66 @@ type IsSchemaTypeFromBuiltinClass<T> = T extends (typeof String)
  * @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 ResolvePathType<PathValueType, Options extends SchemaTypeOptions<PathValueType> = {}, TypeKey extends string = DefaultSchemaOptions['typeKey'], TypeHint = never> =
-  IfEquals<TypeHint, never,
-    PathValueType extends Schema ? InferSchemaType<PathValueType> :
-      PathValueType extends (infer Item)[] ?
-        IfEquals<Item, never, any[], Item extends Schema ?
-          // If Item is a schema, infer its type.
-          Types.DocumentArray<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.
-              ObtainDocumentPathType<Item, TypeKey>[] :
-              // 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>[] :
-              IsItRecordAndNotAny<Item> extends true ?
-                Item extends Record<string, never> ?
-                  ObtainDocumentPathType<Item, TypeKey>[] :
-                  Types.DocumentArray<ObtainDocumentType<Item, any, { typeKey: TypeKey }>> :
-                ObtainDocumentPathType<Item, TypeKey>[]
-        >:
-        PathValueType extends ReadonlyArray<infer Item> ?
-          IfEquals<Item, never, any[], Item extends Schema ?
-            Types.DocumentArray<InferSchemaType<Item>> :
-            Item extends Record<TypeKey, any> ?
-              Item[TypeKey] extends Function | String ?
-                ObtainDocumentPathType<Item, TypeKey>[] :
-                ObtainDocumentType<Item, any, { typeKey: TypeKey }>[]:
-              IsSchemaTypeFromBuiltinClass<Item> extends true ?
-                ObtainDocumentPathType<Item, TypeKey>[] :
-                IsItRecordAndNotAny<Item> extends true ?
-                  Item extends Record<string, never> ?
-                    ObtainDocumentPathType<Item, TypeKey>[] :
-                    Types.DocumentArray<ObtainDocumentType<Item, any, { typeKey: TypeKey }>> :
-                  ObtainDocumentPathType<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 :
-                                                    PathValueType extends 'double' | 'Double' | typeof Schema.Types.Double ? Types.Double :
-                                                      IfEquals<PathValueType, Schema.Types.UUID> extends true ? Buffer :
-                                                        PathValueType extends MapConstructor | 'Map' ? Map<string, ObtainDocumentPathType<Options['of']>> :
-                                                          IfEquals<PathValueType, typeof Schema.Types.Map> extends true ? Map<string, ObtainDocumentPathType<Options['of']>> :
-                                                            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>;
+type ResolvePathType<
+  PathValueType,
+  Options extends SchemaTypeOptions<PathValueType> = {},
+  TypeKey extends string = DefaultSchemaOptions['typeKey'],
+  TypeHint = never
+> = IfEquals<
+  TypeHint,
+  never,
+  PathValueType extends Schema ? InferSchemaType<PathValueType>
+  : PathValueType extends AnyArray<infer Item> ?
+    IfEquals<Item, never> extends true
+      ? any[]
+      : Item extends Schema ?
+        // If Item is a schema, infer its type.
+        Types.DocumentArray<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.
+          ObtainDocumentPathType<Item, TypeKey>[]
+        : // 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>[]
+      : IsItRecordAndNotAny<Item> extends true ?
+        Item extends Record<string, never> ?
+          ObtainDocumentPathType<Item, TypeKey>[]
+        : Types.DocumentArray<ObtainDocumentType<Item, any, { typeKey: TypeKey }>>
+      : ObtainDocumentPathType<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, ObtainDocumentPathType<Options['of']>>
+  : PathValueType extends UnionSchemaDefinition ?
+    Options['of'] extends AnyArray<infer U> ? ResolvePathType<U>
+    : 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
+>;