🐛fix: improve inferred Schema Type

test/types/schema.test.ts

@@ -374,12 +374,12 @@ export function autoTypedSchema() {
     boolean2?: boolean;
     boolean3?: boolean;
     boolean4?: boolean;
-    mixed1?: any;
-    mixed2?: any;
-    mixed3?: any;
-    objectId1?: Schema.Types.ObjectId;
-    objectId2?: Schema.Types.ObjectId;
-    objectId3?: Schema.Types.ObjectId;
+    mixed1?: unknown;
+    mixed2?: unknown;
+    mixed3?: unknown;
+    objectId1?: Types.ObjectId;
+    objectId2?: Types.ObjectId;
+    objectId3?: Types.ObjectId;
     customSchema?: Int8;
     map1?: Map<string, string>;
     map2?: Map<string, number>;
@@ -388,9 +388,9 @@ export function autoTypedSchema() {
     array3?: any[];
     array4?: any[];
     array5?: any[];
-    decimal1?: Schema.Types.Decimal128;
-    decimal2?: Schema.Types.Decimal128;
-    decimal3?: Schema.Types.Decimal128;
+    decimal1?: Types.Decimal128;
+    decimal2?: Types.Decimal128;
+    decimal3?: Types.Decimal128;
   };
 
   const TestSchema = new Schema({
@@ -475,6 +475,17 @@ export function autoTypedSchema() {
         message: '{VALUE} is not supported'
       },
       required: true
+    },
+    friendID: {
+      type: Schema.Types.ObjectId
+    },
+    nestedArray: {
+      type: [
+        new Schema({
+          date: { type: Date, required: true },
+          messages: Number
+        })
+      ]
     }
   }, {
     statics: {
@@ -516,6 +527,11 @@ export type AutoTypedSchemaType = {
     },
     favoritDrink?: 'Tea' | 'Coffee',
     favoritColorMode: 'dark' | 'light'
+    friendID?: Types.ObjectId;
+    nestedArray: Array<{
+      date: Date;
+      messages?: number;
+    }>
   }
   , statics: {
     staticFn: () => 'Returned from staticFn'

types/inferschematype.d.ts

@@ -1,4 +1,4 @@
-import { Schema, InferSchemaType, SchemaType, SchemaTypeOptions, TypeKeyBaseType } from 'mongoose';
+import { Schema, Types, InferSchemaType, ObtainDocumentType, SchemaDefinitionProperty, SchemaType, SchemaTypeOptions, TypeKeyBaseType } from 'mongoose';
 
 declare module 'mongoose' {
   /**
@@ -10,8 +10,8 @@ declare module 'mongoose' {
    */
   type ObtainDocumentType<DocDefinition, EnforcedDocType = any, TypeKey extends TypeKeyBaseType = DefaultTypeKey> =
     IsItRecordAndNotAny<EnforcedDocType> extends true ? EnforcedDocType : {
-      [K in keyof (RequiredPaths<DocDefinition> &
-      OptionalPaths<DocDefinition>)]: ObtainDocumentPathType<DocDefinition[K], TypeKey>;
+      [K in keyof (RequiredPaths<DocDefinition, TypeKey> &
+      OptionalPaths<DocDefinition, TypeKey>)]: ObtainDocumentPathType<DocDefinition[K], TypeKey>;
     };
 
   /**
@@ -23,7 +23,7 @@ declare module 'mongoose' {
    * // result
    * type UserType = {userName?: string}
    */
-  type InferSchemaType<SchemaType> = ObtainSchemaGeneric<SchemaType, 'DocType'> ;
+  type InferSchemaType<SchemaType> = ObtainSchemaGeneric<SchemaType, 'DocType'>;
 
   /**
    * @summary Obtains schema Generic type by using generic alias.
@@ -74,42 +74,50 @@ type RequiredPathBaseType = { required: true | [true, string | undefined] };
  * @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 TypeKeyBaseType> = { [k in TypeKey]: any };
+type PathWithTypePropertyBaseType<TypeKey extends TypeKeyBaseType, T = any> = {
+  [k in TypeKey]: T;
+};
 
 /**
  * @summary A Utility to obtain schema's required path keys.
  * @param {T} T A generic refers to document definition.
  * @returns required paths keys of document definition.
  */
-type RequiredPathKeys<T> = {
-  [K in keyof T]: T[K] extends RequiredPathBaseType ? IfEquals<T[K], any, never, K> : never;
+type RequiredPathKeys<T, TypeKey extends TypeKeyBaseType> = {
+  [K in keyof T]: T[K] extends RequiredPathBaseType ? IfEquals<T[K], any, never, K>
+    : T[K] extends PathWithTypePropertyBaseType<TypeKey, any[]>
+      ? T[K] extends { default: undefined } ? never : K
+      : never;
 }[keyof T];
 
 /**
  * @summary A Utility to obtain schema's required paths.
  * @param {T} T A generic refers to document definition.
  * @returns a record contains required paths with the corresponding type.
  */
-type RequiredPaths<T> = {
-  [K in RequiredPathKeys<T>]: T[K];
+type RequiredPaths<T, TypeKey extends TypeKeyBaseType> = {
+  [K in RequiredPathKeys<T, TypeKey>]: T[K];
 };
 
 /**
  * @summary A Utility to obtain schema's optional path keys.
  * @param {T} T A generic refers to document definition.
  * @returns optional paths keys of document definition.
  */
-type OptionalPathKeys<T> = {
-  [K in keyof T]: T[K] extends RequiredPathBaseType ? never : K;
+type OptionalPathKeys<T, TypeKey extends TypeKeyBaseType> = {
+  [K in keyof T]: T[K] extends RequiredPathBaseType ? never :
+    T[K] extends PathWithTypePropertyBaseType<TypeKey, any[]>
+      ? T[K] extends { default: undefined } ? K : never
+      : K;
 }[keyof T];
 
 /**
  * @summary A Utility to obtain schema's optional paths.
  * @param {T} T A generic refers to document definition.
  * @returns a record contains optional paths with the corresponding type.
  */
-type OptionalPaths<T> = {
-  [K in OptionalPathKeys<T>]?: T[K];
+type OptionalPaths<T, TypeKey extends TypeKeyBaseType> = {
+  [K in OptionalPathKeys<T, TypeKey>]?: T[K];
 };
 
 /**
@@ -120,10 +128,13 @@ type OptionalPaths<T> = {
  */
 type ObtainDocumentPathType<PathValueType, TypeKey extends TypeKeyBaseType> = PathValueType extends Schema<any>
   ? InferSchemaType<PathValueType>
-  : ResolvePathType<
-  PathValueType extends PathWithTypePropertyBaseType<TypeKey> ? PathValueType[TypeKey] : PathValueType,
-  PathValueType extends PathWithTypePropertyBaseType<TypeKey> ? Omit<PathValueType, TypeKey> : {}
-  >;
+  : PathValueType extends PathWithTypePropertyBaseType<TypeKey, Schema<any>>
+    ? InferSchemaType<PathValueType[TypeKey]>
+    : ResolvePathType<
+    TypeKey,
+    PathValueType extends PathWithTypePropertyBaseType<TypeKey> ? PathValueType[TypeKey] : PathValueType,
+    PathValueType extends PathWithTypePropertyBaseType<TypeKey> ? Omit<PathValueType, TypeKey> : {}
+    >;
 
 /**
  * @param {T} T A generic refers to string path enums.
@@ -137,19 +148,17 @@ type PathEnumOrString<T extends SchemaTypeOptions<string>['enum']> = T extends (
  * @param {Options} Options Document definition path options except path type.
  * @returns Number, "Number" or "number" will be resolved to string type.
  */
-type ResolvePathType<PathValueType, Options extends SchemaTypeOptions<PathValueType> = {}> =
-  PathValueType extends (infer Item)[] ? IfEquals<Item, never, any, ResolvePathType<Item>>[] :
-    PathValueType extends StringConstructor | 'string' | 'String' | typeof Schema.Types.String ? PathEnumOrString<Options['enum']> :
-      PathValueType extends NumberConstructor | 'number' | 'Number' | typeof Schema.Types.Number ? number :
-        PathValueType extends DateConstructor | 'date' | 'Date' | typeof Schema.Types.Date ? Date :
-          PathValueType extends typeof Buffer | 'buffer' | 'Buffer' | typeof Schema.Types.Buffer ? Buffer :
-            PathValueType extends BooleanConstructor | 'boolean' | 'Boolean' | typeof Schema.Types.Boolean ? boolean :
-              PathValueType extends 'objectId' | 'ObjectId' | typeof Schema.Types.ObjectId ? Schema.Types.ObjectId :
-                PathValueType extends 'decimal128' | 'Decimal128' | typeof Schema.Types.Decimal128 ? Schema.Types.Decimal128 :
-                  PathValueType extends MapConstructor ? 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'] :
-                              unknown;
+type ResolvePathType<TypeKey extends TypeKeyBaseType, PathValueType, Options extends SchemaTypeOptions<PathValueType> = {}> =
+  PathValueType extends (infer Item)[] ? IfEquals<Item, never, any, ObtainDocumentPathType<Item, TypeKey>>[] :
+    PathValueType extends { [K: string]: SchemaDefinitionProperty } ? ObtainDocumentType<PathValueType, any, TypeKey> :
+      PathValueType extends StringConstructor | 'string' | 'String' | typeof Schema.Types.String ? PathEnumOrString<Options['enum']> :
+        PathValueType extends NumberConstructor | 'number' | 'Number' | typeof Schema.Types.Number ? number :
+          PathValueType extends DateConstructor | 'date' | 'Date' | typeof Schema.Types.Date ? Date :
+            PathValueType extends typeof Buffer | 'buffer' | 'Buffer' | typeof Schema.Types.Buffer ? Buffer :
+              PathValueType extends BooleanConstructor | 'boolean' | 'Boolean' | typeof Schema.Types.Boolean ? boolean :
+                PathValueType extends 'objectId' | 'ObjectId' | typeof Schema.Types.ObjectId ? Types.ObjectId :
+                  PathValueType extends 'decimal128' | 'Decimal128' | typeof Schema.Types.Decimal128 ? Types.Decimal128 :
+                    PathValueType extends MapConstructor ? Map<string, ResolvePathType<TypeKey, Options['of']>> :
+                      PathValueType extends ArrayConstructor ? any[] :
+                        PathValueType extends typeof SchemaType ? PathValueType['prototype'] :
+                          unknown;