@cleverbrush/schema 0.0.14 → 0.0.17

package/README.md

@@ -274,6 +274,31 @@ There is a possibility to register a schema, give it a name and then reuse it:
 
     // { valid: true }
 
+Also there is a possibility to organize schemas in modules (or even submodules):
+
+    const validator = new SchemaValidator().addSchemaType("Module1.DTOs.Address", {
+        properties: {
+            id: {
+            type: "number",
+            min: 1,
+            },
+            street: "string",
+            zip: "number",
+        }
+    }).addSchemaType("Module1.Models.Person", {
+        properties: {
+            firstName: "string",
+            lastName: "string"
+        },
+    });
+
+    const resultPerson = await validator.schemas.Module1.Models.Person.validate({
+         fistName: 'John',
+         lastName: 'Smith'
+         });
+
+    const resultAddress = await validator.schemas.Module1.DTOs.Address.validate({ });
+
 ## Examples
 
 For Examples see unit tests in the schemaValidator.tests.ts

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import { Merge } from '@cleverbrush/deep';
 import SchemaValidator from './schemaValidator';
 export declare type DefaultSchemaType = 'object' | 'boolean' | 'function' | 'number' | 'string' | 'array' | 'alias';
 export declare type PropType<TObj, TProp extends keyof TObj> = TObj[TProp];
@@ -24,7 +25,7 @@ export declare type ObjectSchemaDefinition<T> = Omit<SchemaDefintion<T>, 'type'>
         [S in keyof T]: Schema<PropType<T, S>>;
     }>;
     preprocessors?: Partial<{
-        [S in keyof T | '*']: S extends keyof T ? ((value: unknown) => PropType<T, S> | Promise<PropType<T, S>>) | string : (value: T) => void | Promise<void>;
+        [S in keyof T | '*']: S extends keyof T ? ((value: unknown) => undefined | PropType<T, S> | Promise<PropType<T, S>>) | string : (value: T) => void | Promise<void>;
     }>;
 };
 export declare type AliasSchemaDefinition<T> = Omit<SchemaDefintion<T>, 'type'> & {
@@ -68,22 +69,26 @@ export declare type ArraySchemaDefinition<TObj> = Omit<SchemaDefintion<TObj>, 't
 export declare type CompositeSchema<TObj> = TObj extends (...args: any) => any ? FunctionSchemaDefinition<TObj> : TObj extends number ? NumberSchemaDefinition<TObj> : TObj extends string ? StringSchemaDefinition<TObj> | 'string' : BooleanSchemaDefinition<TObj> | NumberSchemaDefinition<TObj> | StringSchemaDefinition<TObj> | ArraySchemaDefinition<TObj> | ObjectSchemaDefinition<TObj> | AliasSchemaDefinition<TObj>;
 export declare type SingleSchema<TObj = Record<string, never>> = number | string | DefaultSchemaType | CompositeSchema<TObj>;
 export declare type Schema<TObj> = SingleSchema<TObj> | Array<SingleSchema<TObj>>;
-export interface ISchemaActions<K, T extends keyof K> {
+export declare type Cons<H, T extends unknown[] = []> = T['length'] extends 0 ? [H] : ((h: H, ...t: T) => void) extends (...r: infer R) => void ? R : never;
+export interface ISchemaActions<S> {
     validate(value: any): Promise<ValidationResult>;
-    schema: PropType<K, T>;
+    schema: S;
 }
-export interface ISchemasProvider<T = Record<string, never>> {
-    schemas: {
-        [K in keyof T]: ISchemaActions<T, K>;
-    };
+export interface ISchemasProvider<T extends unknown[]> {
+    schemas: Merge<T>;
 }
-export interface ISchemaValidator<T = Record<string, never>> {
+export interface ISchemaValidator<T extends Record<string, never> = Record<string, never>, SchemaTypesStructures extends unknown[] = []> {
     get preprocessors(): Map<string, (value: unknown) => unknown | Promise<unknown>>;
-    addPreprocessor(name: string, preprocessor: (value: unknown) => unknown | Promise<unknown>): SchemaValidator<T>;
-    addSchemaType<K, L extends ObjectSchemaDefinitionParam<M>, M = any>(name: keyof K, schema: L | Array<Schema<any>>): SchemaValidator<T & {
+    addPreprocessor(name: string, preprocessor: (value: unknown) => unknown | Promise<unknown>): SchemaValidator<T, SchemaTypesStructures>;
+    addSchemaType<K, L extends ObjectSchemaDefinitionParam<M> | Array<Schema<any>>, M = any>(name: keyof K, schema: L): SchemaValidator<T & {
         [key in keyof K]: typeof schema;
-    }>;
+    }, Cons<Unfold<keyof K, ISchemaActions<L>>, SchemaTypesStructures>>;
     validate(schema: keyof T | DefaultSchemaType | Schema<any>, obj: any): Promise<ValidationResult>;
 }
+export declare type Unfold<T, K> = T extends string ? T extends `${infer F}.${infer L}` ? {
+    [k in F]: Unfold<L, K>;
+} : {
+    [k in T]: K;
+} : never;
 export { SchemaValidator };
 export default SchemaValidator;

package/dist/schemaValidator.d.ts

@@ -1,16 +1,15 @@
-import { ISchemasProvider, Schema, ISchemaActions, ObjectSchemaDefinitionParam, ValidationResult, ISchemaValidator, DefaultSchemaType } from './index';
-export default class SchemaValidator<T = Record<string, never>> implements ISchemasProvider<T>, ISchemaValidator<T> {
+import { Merge } from '@cleverbrush/deep';
+import { ISchemasProvider, Schema, ISchemaActions, ObjectSchemaDefinitionParam, ValidationResult, ISchemaValidator, DefaultSchemaType, Cons, Unfold } from './index';
+export default class SchemaValidator<T extends Record<string, never> = Record<string, never>, SchemaTypesStructures extends unknown[] = []> implements ISchemasProvider<SchemaTypesStructures>, ISchemaValidator<T, SchemaTypesStructures> {
     private _schemasMap;
     private _schemasCache;
     private _preprocessorsMap;
     get preprocessors(): Map<string, (value: unknown) => unknown>;
-    addPreprocessor(name: string, preprocessor: (value: unknown) => unknown | Promise<unknown>): SchemaValidator<T>;
-    addSchemaType<K, L extends ObjectSchemaDefinitionParam<M>, M = any>(name: keyof K, schema: L | Array<Schema<any>>): SchemaValidator<T & {
+    addPreprocessor(name: string, preprocessor: (value: unknown) => unknown | Promise<unknown>): SchemaValidator<T, SchemaTypesStructures>;
+    addSchemaType<K, L extends ObjectSchemaDefinitionParam<M> | Array<Schema<any>>, M = any>(name: keyof K, schema: L): SchemaValidator<T & {
         [key in keyof K]: L;
-    }>;
-    get schemas(): {
-        [K in keyof T]: ISchemaActions<T, K>;
-    };
+    }, Cons<Unfold<keyof K, ISchemaActions<L>>, SchemaTypesStructures>>;
+    get schemas(): Merge<SchemaTypesStructures>;
     private validateDefaultType;
     private checkValidators;
     validate<K>(schema: keyof T | DefaultSchemaType | Schema<K>, obj: any): Promise<ValidationResult>;

package/dist/schemaValidator.js

@@ -81,10 +81,22 @@ class SchemaValidator {
             return this._schemasCache;
         const res = {};
         for (const key of this._schemasMap.keys()) {
-            res[key] = {
-                validate: (value) => this.validate(this._schemasMap.get(key), value),
-                schema: this._schemasMap.get(key)
-            };
+            const parts = key.split('.');
+            let curr = res;
+            for (let i = 0; i < parts.length; i++) {
+                if (i === parts.length - 1) {
+                    curr[parts[i]] = {
+                        validate: (value) => this.validate(this._schemasMap.get(key), value),
+                        schema: this._schemasMap.get(key)
+                    };
+                }
+                else {
+                    if (typeof curr[parts[i]] === 'undefined') {
+                        curr[parts[i]] = {};
+                    }
+                }
+                curr = curr[parts[i]];
+            }
         }
         this._schemasCache = res;
         return this._schemasCache;
@@ -149,12 +161,11 @@ class SchemaValidator {
             if (isDefaultType(schema)) {
                 return await this.validateDefaultType(schema, obj);
             }
-            else if (typeof this.schemas[schema] !== 'undefined') {
-                if (Array.isArray(this.schemas[schema].schema)) {
-                    return this.validate(this.schemas[schema]
-                        .schema, obj);
+            else if (typeof this._schemasMap.get(schema) !== 'undefined') {
+                if (Array.isArray(this._schemasMap.get(schema))) {
+                    return this.validate(this._schemasMap.get(schema), obj);
                 }
-                const objSchema = (0, deep_1.deepExtend)(defaultSchemas.object, this.schemas[schema].schema);
+                const objSchema = (0, deep_1.deepExtend)(defaultSchemas.object, this._schemasMap.get(schema));
                 const res = await (0, validateObject_1.validateObject)(obj, objSchema, this);
                 if (!res.valid)
                     return res;
@@ -189,8 +200,10 @@ class SchemaValidator {
                 return await this.validateDefaultType(schema.type, obj, schema);
             }
             else if (schema.type === 'alias') {
-                const alias = this.schemas[schema.schemaName]
-                    .schema;
+                const alias = this._schemasMap.get(schema.schemaName);
+                if (typeof alias === 'undefined') {
+                    throw new Error(`Unknown schema alias - ${schema.schemaName}`);
+                }
                 if (Array.isArray(alias)) {
                     if ((!schema.isRequired && typeof obj === 'undefined') ||
                         (schema.isNullable && obj === null)) {

package/dist/validators/validateObject.d.ts

@@ -1,2 +1,2 @@
 import { ValidationResult, ObjectSchemaDefinition, ISchemaValidator } from '../index';
-export declare const validateObject: (obj: any, schema: ObjectSchemaDefinition<any>, validator: ISchemaValidator<any>) => Promise<ValidationResult>;
+export declare const validateObject: (obj: any, schema: ObjectSchemaDefinition<any>, validator: ISchemaValidator<any, unknown[]>) => Promise<ValidationResult>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cleverbrush/schema",
-    "version": "0.0.14",
+    "version": "0.0.17",
     "keywords": [
         "object schema validator",
         "schema",
@@ -19,7 +19,7 @@
         "build": "tsc"
     },
     "dependencies": {
-        "@cleverbrush/deep": "0.0.14"
+        "@cleverbrush/deep": "0.0.17"
     },
     "types": "./dist/index.d.ts"
 }

package/src/index.ts

@@ -1,3 +1,4 @@
+import { Merge } from '@cleverbrush/deep';
 import SchemaValidator from './schemaValidator';
 
 export type DefaultSchemaType =
@@ -45,7 +46,7 @@ export type ObjectSchemaDefinition<T> = Omit<SchemaDefintion<T>, 'type'> & {
             ?
                   | ((
                         value: unknown
-                    ) => PropType<T, S> | Promise<PropType<T, S>>)
+                    ) => undefined | PropType<T, S> | Promise<PropType<T, S>>)
                   | string
             : (value: T) => void | Promise<void>;
     }>;
@@ -137,18 +138,25 @@ export type SingleSchema<TObj = Record<string, never>> =
 
 export type Schema<TObj> = SingleSchema<TObj> | Array<SingleSchema<TObj>>;
 
-export interface ISchemaActions<K, T extends keyof K> {
+export type Cons<H, T extends unknown[] = []> = T['length'] extends 0
+    ? [H]
+    : ((h: H, ...t: T) => void) extends (...r: infer R) => void
+    ? R
+    : never;
+
+export interface ISchemaActions<S> {
     validate(value: any): Promise<ValidationResult>;
-    schema: PropType<K, T>;
+    schema: S;
 }
 
-export interface ISchemasProvider<T = Record<string, never>> {
-    schemas: {
-        [K in keyof T]: ISchemaActions<T, K>;
-    };
+export interface ISchemasProvider<T extends unknown[]> {
+    schemas: Merge<T>;
 }
 
-export interface ISchemaValidator<T = Record<string, never>> {
+export interface ISchemaValidator<
+    T extends Record<string, never> = Record<string, never>,
+    SchemaTypesStructures extends unknown[] = []
+> {
     get preprocessors(): Map<
         string,
         (value: unknown) => unknown | Promise<unknown>
@@ -156,12 +164,19 @@ export interface ISchemaValidator<T = Record<string, never>> {
     addPreprocessor(
         name: string,
         preprocessor: (value: unknown) => unknown | Promise<unknown>
-    ): SchemaValidator<T>;
+    ): SchemaValidator<T, SchemaTypesStructures>;
 
-    addSchemaType<K, L extends ObjectSchemaDefinitionParam<M>, M = any>(
+    addSchemaType<
+        K,
+        L extends ObjectSchemaDefinitionParam<M> | Array<Schema<any>>,
+        M = any
+    >(
         name: keyof K,
-        schema: L | Array<Schema<any>>
-    ): SchemaValidator<T & { [key in keyof K]: typeof schema }>;
+        schema: L
+    ): SchemaValidator<
+        T & { [key in keyof K]: typeof schema },
+        Cons<Unfold<keyof K, ISchemaActions<L>>, SchemaTypesStructures>
+    >;
 
     validate(
         schema: keyof T | DefaultSchemaType | Schema<any>,
@@ -169,5 +184,15 @@ export interface ISchemaValidator<T = Record<string, never>> {
     ): Promise<ValidationResult>;
 }
 
+export type Unfold<T, K> = T extends string
+    ? T extends `${infer F}.${infer L}`
+        ? {
+              [k in F]: Unfold<L, K>;
+          }
+        : {
+              [k in T]: K;
+          }
+    : never;
+
 export { SchemaValidator };
 export default SchemaValidator;

package/src/schemaValidator.test.ts

@@ -170,7 +170,7 @@ test('Validate - no schema', async () => {
     const validator = new SchemaValidator();
     const cth = jest.fn();
     validator
-        .validate(null, 10)
+        .validate(null as any, 10)
         .catch(cth)
         .then(() => {
             expect(cth).toBeCalled();
@@ -944,7 +944,7 @@ test('Validate - object - 2', async () => {
                     };
                 }
             ]
-        })
+        }) as any as ObjectSchemaDefinition<any>
     );
     const user: User = {
         id: 1,
@@ -1199,19 +1199,30 @@ test('Validate schema - 1', async () => {
 });
 
 test('Validate schema - 2', async () => {
-    const validator = new SchemaValidator().addSchemaType('Date', {
-        validators: [
-            (value) =>
-                value instanceof Date && !Number.isNaN(value)
-                    ? {
-                          valid: true
-                      }
-                    : {
-                          valid: false,
-                          errors: ['should be a valid Date object']
-                      }
-        ]
-    });
+    const validator = new SchemaValidator()
+        .addSchemaType('Date', {
+            validators: [
+                (value) =>
+                    value instanceof Date && !Number.isNaN(value)
+                        ? {
+                              valid: true
+                          }
+                        : {
+                              valid: false,
+                              errors: ['should be a valid Date object']
+                          }
+            ]
+        })
+        .addSchemaType('Module.Schema1', {
+            properties: {
+                a: 'string'
+            }
+        })
+        .addSchemaType('Module.Schema2', {
+            properties: {
+                b: 'number'
+            }
+        });
 
     const result = await validator.validate(
         {
@@ -1301,8 +1312,10 @@ test('Preprocessors - 1', async () => {
             bornAt: 'Date'
         },
         preprocessors: {
-            bornAt: (value: unknown): Date => {
-                const time = Date.parse(value.toString());
+            bornAt: (value: unknown): Date | undefined => {
+                const time = Date.parse(
+                    (value as Record<string, unknown>).toString()
+                );
                 if (Number.isNaN(time)) return undefined;
                 return new Date(time);
             }
@@ -1340,18 +1353,28 @@ test('Preprocessors - 2', async () => {
         }
     };
 
-    validator.addPreprocessor('StringToDate', (value: unknown): Date => {
-        const time = Date.parse(value.toString());
-        if (Number.isNaN(time)) return undefined;
-        return new Date(time);
-    });
-
-    expect(() =>
-        validator.addPreprocessor('StringToDate', (value: unknown): Date => {
-            const time = Date.parse(value.toString());
+    validator.addPreprocessor(
+        'StringToDate',
+        (value: unknown): Date | undefined => {
+            const time = Date.parse(
+                (value as Record<string, unknown>).toString()
+            );
             if (Number.isNaN(time)) return undefined;
             return new Date(time);
-        })
+        }
+    );
+
+    expect(() =>
+        validator.addPreprocessor(
+            'StringToDate',
+            (value: unknown): Date | undefined => {
+                const time = Date.parse(
+                    (value as Record<string, unknown>).toString()
+                );
+                if (Number.isNaN(time)) return undefined;
+                return new Date(time);
+            }
+        )
     ).toThrow();
 
     const result = await validator.validate(schema, {
@@ -1392,11 +1415,16 @@ test('Preprocessors - 3', async () => {
         ]
     });
 
-    validator.addPreprocessor('StringToDate', (value: unknown): Date => {
-        const time = Date.parse(value.toString());
-        if (Number.isNaN(time)) return undefined;
-        return new Date(time);
-    });
+    validator.addPreprocessor(
+        'StringToDate',
+        (value: unknown): Date | undefined => {
+            const time = Date.parse(
+                (value as Record<string, unknown>).toString()
+            );
+            if (Number.isNaN(time)) return undefined;
+            return new Date(time);
+        }
+    );
 
     let obj = [new Date().toJSON()];
 
@@ -1413,8 +1441,10 @@ test('Preprocessors - 3', async () => {
     obj = [new Date().toJSON()];
     result = await validator.validate(
         {
-            preprocessor: (value: unknown): Date => {
-                const time = Date.parse(value.toString());
+            preprocessor: (value: unknown): Date | undefined => {
+                const time = Date.parse(
+                    (value as Record<string, unknown>).toString()
+                );
                 if (Number.isNaN(time)) return undefined;
                 return new Date(time);
             },
@@ -1428,8 +1458,10 @@ test('Preprocessors - 3', async () => {
     obj = ['sdfsdf12', new Date().toJSON()];
     result = await validator.validate(
         {
-            preprocessor: (value: unknown): Date => {
-                const time = Date.parse(value.toString());
+            preprocessor: (value: unknown): Date | undefined => {
+                const time = Date.parse(
+                    (value as Record<string, unknown>).toString()
+                );
                 if (Number.isNaN(time)) return undefined;
                 return new Date(time);
             },
@@ -1485,11 +1517,16 @@ test('Preprocessors - 4', async () => {
         ]
     });
 
-    validator.addPreprocessor('StringToDate', (value: unknown): Date => {
-        const time = Date.parse(value.toString());
-        if (Number.isNaN(time)) return undefined;
-        return new Date(time);
-    });
+    validator.addPreprocessor(
+        'StringToDate',
+        (value: unknown): Date | undefined => {
+            const time = Date.parse(
+                (value as Record<string, unknown>).toString()
+            );
+            if (Number.isNaN(time)) return undefined;
+            return new Date(time);
+        }
+    );
 
     let obj = [new Date().toJSON()];
 
@@ -1506,8 +1543,10 @@ test('Preprocessors - 4', async () => {
     obj = [new Date().toJSON()];
     result = await validator.validate(
         {
-            preprocessor: (value: unknown): Date => {
-                const time = Date.parse(value.toString());
+            preprocessor: (value: unknown): Date | undefined => {
+                const time = Date.parse(
+                    (value as Record<string, unknown>).toString()
+                );
                 if (Number.isNaN(time)) return undefined;
                 return new Date(time);
             },
@@ -1521,8 +1560,10 @@ test('Preprocessors - 4', async () => {
     obj = ['sdfsdf12', new Date().toJSON()];
     result = await validator.validate(
         {
-            preprocessor: (value: unknown): Date => {
-                const time = Date.parse(value.toString());
+            preprocessor: (value: unknown): Date | undefined => {
+                const time = Date.parse(
+                    (value as Record<string, unknown>).toString()
+                );
                 if (Number.isNaN(time)) return undefined;
                 return new Date(time);
             },
@@ -1533,3 +1574,83 @@ test('Preprocessors - 4', async () => {
     );
     expect(result).toHaveProperty('valid', false);
 });
+
+test('Submodules - 1', async () => {
+    const validator = new SchemaValidator().addSchemaType(
+        'Module1.Schema1',
+        {}
+    );
+
+    const result = validator.schemas;
+
+    expect(result).toHaveProperty('Module1');
+    expect(result).toHaveProperty('Module1.Schema1');
+});
+
+test('Submodules - 2', async () => {
+    const validator = new SchemaValidator()
+        .addSchemaType('Module1.Schema1', {})
+        .addSchemaType('Module1.Schema2', {
+            properties: {
+                a: 'number'
+            }
+        });
+
+    const result = validator.schemas;
+
+    expect(result).toHaveProperty('Module1');
+    expect(result).toHaveProperty('Module1.Schema1');
+    expect(result).toHaveProperty('Module1.Schema2');
+
+    const result2 = await validator.schemas.Module1.Schema2.validate({
+        a: 234
+    });
+    expect(result2).toHaveProperty('valid', true);
+});
+
+test('Submodules - 3', async () => {
+    const validator = new SchemaValidator()
+        .addSchemaType('Module1.Schema1', {
+            properties: {
+                b: 'number'
+            }
+        })
+        .addSchemaType('Module1.Schema2', {
+            properties: {
+                a: {
+                    type: 'alias',
+                    schemaName: 'Module1.Schema1'
+                }
+            }
+        });
+
+    const result2 = await validator.schemas.Module1.Schema2.validate({
+        a: {
+            b: 20
+        }
+    });
+    expect(result2).toHaveProperty('valid', true);
+});
+
+test('Submodules - 4', async () => {
+    const validator = new SchemaValidator()
+        .addSchemaType('Module1.Schema1', {
+            properties: {
+                b: 'number'
+            }
+        })
+        .addSchemaType('Module1.Schema2', {
+            properties: {
+                a: {
+                    type: 'alias',
+                    schemaName: 'Module1.Schema3'
+                }
+            }
+        });
+
+    await validator.schemas.Module1.Schema2.validate({
+        a: {
+            b: 20
+        }
+    }).catch((e) => expect(e).toBeInstanceOf(Error));
+});

package/src/schemaValidator.ts

@@ -1,4 +1,4 @@
-import { deepExtend } from '@cleverbrush/deep';
+import { deepExtend, Merge } from '@cleverbrush/deep';
 import {
     ISchemasProvider,
     Schema,
@@ -13,7 +13,9 @@ import {
     ISchemaValidator,
     DefaultSchemaType,
     ObjectSchemaDefinition,
-    BooleanSchemaDefinition
+    BooleanSchemaDefinition,
+    Cons,
+    Unfold
 } from './index';
 import { validateNumber } from './validators/validateNumber';
 import { validateBoolean } from './validators/validateBoolean';
@@ -55,36 +57,40 @@ const defaultSchemasValidationStrategies = {
     number: (
         obj: any,
         schema: NumberSchemaDefinition<any>,
-        validator: ISchemaValidator<any>
+        validator: ISchemaValidator<any, unknown[]>
     ): Promise<ValidationResult> => validateNumber(obj, schema, validator),
     boolean: (
         obj: any,
         schema: BooleanSchemaDefinition<any>,
-        validator: ISchemaValidator<any>
+        validator: ISchemaValidator<any, unknown[]>
     ): Promise<ValidationResult> => validateBoolean(obj, schema, validator),
     string: (
         obj: any,
         schema: StringSchemaDefinition<any>,
-        validator: ISchemaValidator<any>
+        validator: ISchemaValidator<any, unknown[]>
     ): Promise<ValidationResult> => validateString(obj, schema, validator),
     array: (
         obj: any,
         schema: ArraySchemaDefinition<any>,
-        validator: ISchemaValidator<any>
+        validator: ISchemaValidator<any, unknown[]>
     ): Promise<ValidationResult> => validateArray(obj, schema, validator)
 };
 
 const isDefaultType = (name: string): boolean =>
     defaultSchemaNames.indexOf(name) !== -1;
 
-export default class SchemaValidator<T = Record<string, never>>
-    implements ISchemasProvider<T>, ISchemaValidator<T>
+export default class SchemaValidator<
+    T extends Record<string, never> = Record<string, never>,
+    SchemaTypesStructures extends unknown[] = []
+> implements
+        ISchemasProvider<SchemaTypesStructures>,
+        ISchemaValidator<T, SchemaTypesStructures>
 {
     private _schemasMap = new Map<string, Schema<any>>();
-    private _schemasCache: { [K in keyof T]: ISchemaActions<T, K> } = null;
+    private _schemasCache: Merge<SchemaTypesStructures> = null;
     private _preprocessorsMap = new Map<
         string,
-        (value: unknown) => unknown | Promise<unknown>
+        (value: unknown) => unknown | Promise<unknown> | undefined
     >();
 
     public get preprocessors(): Map<string, (value: unknown) => unknown> {
@@ -94,17 +100,24 @@ export default class SchemaValidator<T = Record<string, never>>
     public addPreprocessor(
         name: string,
         preprocessor: (value: unknown) => unknown | Promise<unknown>
-    ): SchemaValidator<T> {
+    ): SchemaValidator<T, SchemaTypesStructures> {
         if (this._preprocessorsMap.has(name))
             throw new Error(`Preprocessor '${name}' is already registered`);
         this._preprocessorsMap.set(name, preprocessor);
         return this;
     }
 
-    public addSchemaType<K, L extends ObjectSchemaDefinitionParam<M>, M = any>(
+    public addSchemaType<
+        K,
+        L extends ObjectSchemaDefinitionParam<M> | Array<Schema<any>>,
+        M = any
+    >(
         name: keyof K,
-        schema: L | Array<Schema<any>>
-    ): SchemaValidator<T & { [key in keyof K]: L }> {
+        schema: L
+    ): SchemaValidator<
+        T & { [key in keyof K]: L },
+        Cons<Unfold<keyof K, ISchemaActions<L>>, SchemaTypesStructures>
+    > {
         if (typeof name !== 'string' || !name)
             throw new Error('Name is required');
 
@@ -119,7 +132,10 @@ export default class SchemaValidator<T = Record<string, never>>
         if (Array.isArray(schema)) {
             this._schemasMap.set(name.toString(), schema as Schema<any>);
             this._schemasCache = null;
-            return this as any as SchemaValidator<T & { [key in keyof K]: L }>;
+            return this as any as SchemaValidator<
+                T & { [key in keyof K]: L },
+                Cons<Unfold<keyof K, ISchemaActions<L>>, SchemaTypesStructures>
+            >;
         }
 
         if (typeof schema !== 'object')
@@ -130,20 +146,34 @@ export default class SchemaValidator<T = Record<string, never>>
         } as Schema<any>);
         this._schemasCache = null;
 
-        return this as any as SchemaValidator<T & { [key in keyof K]: L }>;
+        return this as any as SchemaValidator<
+            T & { [key in keyof K]: L },
+            Cons<Unfold<keyof K, ISchemaActions<L>>, SchemaTypesStructures>
+        >;
     }
 
-    public get schemas(): { [K in keyof T]: ISchemaActions<T, K> } {
+    public get schemas(): Merge<SchemaTypesStructures> {
         if (this._schemasCache) return this._schemasCache;
         const res = {};
         for (const key of this._schemasMap.keys()) {
-            res[key] = {
-                validate: (value: any): Promise<any> =>
-                    this.validate(this._schemasMap.get(key), value),
-                schema: this._schemasMap.get(key)
-            };
+            const parts = key.split('.');
+            let curr = res;
+            for (let i = 0; i < parts.length; i++) {
+                if (i === parts.length - 1) {
+                    curr[parts[i]] = {
+                        validate: (value: any): Promise<any> =>
+                            this.validate(this._schemasMap.get(key), value),
+                        schema: this._schemasMap.get(key)
+                    };
+                } else {
+                    if (typeof curr[parts[i]] === 'undefined') {
+                        curr[parts[i]] = {};
+                    }
+                }
+                curr = curr[parts[i]];
+            }
         }
-        this._schemasCache = res as { [K in keyof T]: ISchemaActions<T, K> };
+        this._schemasCache = res as Merge<SchemaTypesStructures>;
         return this._schemasCache;
     }
 
@@ -155,14 +185,14 @@ export default class SchemaValidator<T = Record<string, never>>
         const strategy = defaultSchemasValidationStrategies[name] as (
             obj: any,
             schema: Schema<any>,
-            validator: ISchemaValidator<any>
+            validator: ISchemaValidator<any, unknown[]>
         ) => ValidationResult;
         let finalSchema = defaultSchemas[name] as CompositeSchema<
             Record<string, never>
         >;
         if (strategy) {
             if (typeof mergeSchema === 'object') {
-                finalSchema = deepExtend(finalSchema, mergeSchema);
+                finalSchema = deepExtend(finalSchema, mergeSchema) as any;
             }
             if (typeof mergeSchema === 'number') {
                 finalSchema = {
@@ -172,7 +202,11 @@ export default class SchemaValidator<T = Record<string, never>>
                 mergeSchema;
             }
 
-            let preliminaryResult = await strategy(value, finalSchema, this);
+            let preliminaryResult = await strategy(
+                value,
+                finalSchema,
+                this as any
+            );
             if (!preliminaryResult.valid) return preliminaryResult;
 
             preliminaryResult = await this.checkValidators(finalSchema, value);
@@ -236,19 +270,15 @@ export default class SchemaValidator<T = Record<string, never>>
                     schema as DefaultSchemaType,
                     obj
                 );
-            } else if (typeof this.schemas[schema as keyof T] !== 'undefined') {
-                if (Array.isArray(this.schemas[schema as keyof T].schema)) {
-                    return this.validate(
-                        this.schemas[schema as keyof T]
-                            .schema as any as Schema<any>,
-                        obj
-                    );
+            } else if (typeof this._schemasMap.get(schema) !== 'undefined') {
+                if (Array.isArray(this._schemasMap.get(schema))) {
+                    return this.validate(this._schemasMap.get(schema), obj);
                 }
                 const objSchema = deepExtend(
                     defaultSchemas.object,
-                    this.schemas[schema as keyof T].schema
+                    this._schemasMap.get(schema)
                 ) as ObjectSchemaDefinition<Record<string, never>>;
-                const res = await validateObject(obj, objSchema, this);
+                const res = await validateObject(obj, objSchema, this as any);
                 if (!res.valid) return res;
                 return await this.checkValidators(objSchema, obj);
             } else {
@@ -287,8 +317,12 @@ export default class SchemaValidator<T = Record<string, never>>
                     schema
                 );
             } else if (schema.type === 'alias') {
-                const alias = this.schemas[schema.schemaName]
-                    .schema as Schema<any>;
+                const alias = this._schemasMap.get(schema.schemaName);
+                if (typeof alias === 'undefined') {
+                    throw new Error(
+                        `Unknown schema alias - ${schema.schemaName}`
+                    );
+                }
                 if (Array.isArray(alias)) {
                     if (
                         (!schema.isRequired && typeof obj === 'undefined') ||
@@ -317,7 +351,7 @@ export default class SchemaValidator<T = Record<string, never>>
                 const preliminaryResult = await validateObject(
                     obj,
                     schema,
-                    this
+                    this as any
                 );
                 if (!preliminaryResult.valid) return preliminaryResult;
 

package/src/validators/validateObject.ts

@@ -8,7 +8,7 @@ import {
 export const validateObject = async (
     obj: any,
     schema: ObjectSchemaDefinition<any>,
-    validator: ISchemaValidator<any>
+    validator: ISchemaValidator<any, unknown[]>
 ): Promise<ValidationResult> => {
     if (
         typeof obj === 'undefined' &&