fix: fix nested object schema type inference

src/Config.spec.ts

@@ -0,0 +1,39 @@
+import { Config } from './Config';
+import type { Equals, Expect } from './types';
+
+describe('Config', () => {
+  it('should parse nested object', () => {
+    const config = new Config({
+      s: Config.string(),
+      n: Config.number().require(),
+      foo: Config.object({
+        foo1: Config.string().require(),
+        foo2: Config.object({ foo3: Config.boolean() }),
+      }),
+    })
+      .parse({
+        s: 's',
+        n: 0,
+        foo: { foo1: 'foo1', foo2: { foo3: false } },
+      })
+      .getAll();
+
+    expect(config).toEqual({
+      s: 's',
+      n: 0,
+      foo: { foo1: 'foo1', foo2: { foo3: false } },
+    });
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    type Test = Expect<
+      Equals<
+        typeof config,
+        {
+          s: string | undefined;
+          n: number;
+          foo: { foo1: string; foo2: { foo3: boolean | undefined } };
+        }
+      >
+    >;
+  });
+});

src/Config.ts

@@ -1,13 +1,11 @@
-import type { InferType } from './InferType';
 import type { Schema, SchemaOptions } from './Schema';
 import { BooleanSchema, NumberSchema, StringSchema } from './Schema';
 import { ObjectSchema } from './Schema/ObjectSchema';
 import type { SchemaWithDefaultOptions } from './Schema/SchemaOptions';
-
-type RequiredSchema<T extends Schema> = T & { isRequired: true };
+import type { InferSchema, Prettify, RequiredSchema } from './types';
 
 export class Config<TSchema extends Record<string, Schema>> {
-  private value!: InferType<TSchema>;
+  private value!: InferSchema<TSchema>;
 
   constructor(private schema: TSchema) {}
 
@@ -18,7 +16,7 @@ export class Config<TSchema extends Record<string, Schema>> {
       s.key = key;
       s.setValue(this.value[key]);
       s.validate();
-      this.value[key as keyof InferType<TSchema>] = s.parse();
+      this.value[key as keyof InferSchema<TSchema>] = s.parse();
     });
 
     return this;
@@ -55,10 +53,10 @@ export class Config<TSchema extends Record<string, Schema>> {
   }
 
   public get<TKey extends keyof TSchema>(key: TKey) {
-    return this.value[key] as InferType<TSchema>[TKey];
+    return this.value[key] as Prettify<InferSchema<TSchema>[TKey]>;
   }
 
-  public getAll(): InferType<TSchema> {
-    return this.value as any;
+  public getAll() {
+    return this.value as Prettify<InferSchema<TSchema>>;
   }
 }

src/Schema/BooleanSchema.ts

@@ -2,12 +2,14 @@ import { Schema } from './Schema';
 import type { SchemaOptions } from './SchemaOptions';
 
 export class BooleanSchema<TInput = any> extends Schema<TInput, boolean> {
-  private falseRegex = /false/i;
+  #type = 'boolean'; // eslint-disable-line no-unused-private-class-members
+  #falseRegex = /false/i;
+
   constructor(options: SchemaOptions<boolean> = {}) {
     super({
       ...options,
       typeConstructor: n => {
-        if (typeof n === 'string' && this.falseRegex.test(n)) return false;
+        if (typeof n === 'string' && this.#falseRegex.test(n)) return false;
 
         return Boolean(n);
       },

src/Schema/NumberSchema.ts

@@ -25,6 +25,8 @@ class MaxNumberGuard implements Guard<number> {
 }
 
 export class NumberSchema<TInput = any> extends Schema<TInput, number> {
+  #type = 'number'; // eslint-disable-line no-unused-private-class-members
+
   constructor(options: SchemaOptions<number> = {}) {
     super({ ...options, typeConstructor: Number, type: 'number' });
   }

src/Schema/ObjectSchema.ts

@@ -17,6 +17,8 @@ class ObjectGuard implements Guard<Record<string, Schema>> {
 }
 
 export class ObjectSchema<TInput = any> extends Schema<TInput, TInput> {
+  #type = 'object'; // eslint-disable-line no-unused-private-class-members
+
   constructor(schema: Record<string, Schema>) {
     super({
       typeConstructor: x => x,

src/Schema/StringSchema.ts

@@ -2,6 +2,8 @@ import { Schema } from './Schema';
 import type { SchemaOptions } from './SchemaOptions';
 
 export class StringSchema<TInput = any> extends Schema<TInput, string> {
+  #type = 'string'; // eslint-disable-line no-unused-private-class-members
+
   constructor(options: SchemaOptions<string> = {}) {
     super({ ...options, typeConstructor: String, type: 'string' });
   }

src/index.ts

@@ -1,2 +1,2 @@
 export * from './Config';
-export type { InferType } from './InferType';
+export type { InferSchema } from './types';

src/types.ts

@@ -0,0 +1,32 @@
+import type { Schema, StringSchema } from './Schema';
+import type { ObjectSchema } from './Schema/ObjectSchema';
+
+export type Prettify<T> = {
+  [K in keyof T]: T[K];
+} & {}; // eslint-disable-line @typescript-eslint/ban-types
+
+export type InferObjectSchema<T extends ObjectSchema> = T extends ObjectSchema<
+  infer G
+>
+  ? G extends Record<string, Schema>
+    ? Prettify<InferSchema<G>>
+    : never
+  : never;
+
+export type InferSchema<T extends Record<string, Schema>> = {
+  [K in keyof T]: T[K] extends ObjectSchema
+    ? InferObjectSchema<T[K]>
+    : T[K]['isRequired'] extends true
+      ? NonNullable<T[K]['value']>
+      : T[K]['value'];
+};
+
+export type Expect<T extends true> = T;
+
+export type Equals<X, Y> = (<T>() => T extends X ? 1 : 2) extends <
+  T,
+>() => T extends Y ? 1 : 2
+  ? true
+  : false;
+
+export type RequiredSchema<T extends Schema> = T & { isRequired: true };