@cleverbrush/schema 0.0.13 → 0.0.16

package/dist/index.d.ts

@@ -1,5 +1,6 @@
+import { Merge } from '@cleverbrush/deep';
 import SchemaValidator from './schemaValidator';
-export declare type DefaultSchemaType = 'object' | 'function' | 'number' | 'string' | 'array' | 'alias';
+export declare type DefaultSchemaType = 'object' | 'boolean' | 'function' | 'number' | 'string' | 'array' | 'alias';
 export declare type PropType<TObj, TProp extends keyof TObj> = TObj[TProp];
 export declare type DefaultPropertyDefinition = {
     isRequired: boolean;
@@ -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'> & {
@@ -39,6 +40,10 @@ export declare type FunctionSchemaDefinition<T extends (...args: any) => any> =
     type: 'function';
     params?: ParamsValidators<T>;
 };
+export declare type BooleanSchemaDefinition<TObj> = Omit<SchemaDefintion<TObj>, 'type'> & {
+    type: 'boolean';
+    equals?: boolean;
+};
 export declare type NumberSchemaDefinition<TObj> = Omit<SchemaDefintion<TObj>, 'type'> & {
     type: 'number';
     min?: number;
@@ -61,25 +66,29 @@ export declare type ArraySchemaDefinition<TObj> = Omit<SchemaDefintion<TObj>, 't
     minLength?: number;
     maxLength?: number;
 };
-export declare type CompositeSchema<TObj> = TObj extends (...args: any) => any ? FunctionSchemaDefinition<TObj> : TObj extends number ? NumberSchemaDefinition<TObj> : TObj extends string ? StringSchemaDefinition<TObj> | 'string' : NumberSchemaDefinition<TObj> | StringSchemaDefinition<TObj> | ArraySchemaDefinition<TObj> | ObjectSchemaDefinition<TObj> | AliasSchemaDefinition<TObj>;
+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

@@ -2,10 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const deep_1 = require("@cleverbrush/deep");
 const validateNumber_1 = require("./validators/validateNumber");
+const validateBoolean_1 = require("./validators/validateBoolean");
 const validateString_1 = require("./validators/validateString");
 const validateArray_1 = require("./validators/validateArray");
 const validateObject_1 = require("./validators/validateObject");
-const defaultSchemaNames = ['string', 'number', 'date', 'array'];
+const defaultSchemaNames = ['string', 'boolean', 'number', 'date', 'array'];
 const defaultSchemas = {
     number: {
         type: 'number',
@@ -14,6 +15,11 @@ const defaultSchemas = {
         ensureNotNaN: true,
         ensureIsFinite: true
     },
+    boolean: {
+        type: 'boolean',
+        isRequired: true,
+        isNullable: false
+    },
     string: {
         type: 'string',
         isNullable: false,
@@ -30,6 +36,7 @@ const defaultSchemas = {
 };
 const defaultSchemasValidationStrategies = {
     number: (obj, schema, validator) => (0, validateNumber_1.validateNumber)(obj, schema, validator),
+    boolean: (obj, schema, validator) => (0, validateBoolean_1.validateBoolean)(obj, schema, validator),
     string: (obj, schema, validator) => (0, validateString_1.validateString)(obj, schema, validator),
     array: (obj, schema, validator) => (0, validateArray_1.validateArray)(obj, schema, validator)
 };
@@ -74,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;
@@ -142,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;
@@ -182,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/validateBoolean.d.ts

@@ -0,0 +1,2 @@
+import { ValidationResult, BooleanSchemaDefinition, ISchemaValidator } from '../index';
+export declare const validateBoolean: (obj: any, schema: BooleanSchemaDefinition<any>, validator: ISchemaValidator<any>) => Promise<ValidationResult>;

package/dist/validators/validateBoolean.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateBoolean = void 0;
+const validateBoolean = async (obj, schema, validator) => {
+    if (typeof obj === 'undefined' &&
+        typeof schema === 'object' &&
+        schema.isRequired === false) {
+        return {
+            valid: true
+        };
+    }
+    if (typeof obj !== 'boolean')
+        return {
+            valid: false,
+            errors: [`expected type boolean, but saw ${typeof obj}`]
+        };
+    if (typeof schema === 'boolean') {
+        return { valid: true };
+    }
+    const bool = obj;
+    if (typeof schema.equals === 'boolean') {
+        return schema.equals === bool
+            ? { valid: true }
+            : {
+                valid: false,
+                errors: [`must be equal to ${schema.equals}`]
+            };
+    }
+    return {
+        valid: true
+    };
+};
+exports.validateBoolean = validateBoolean;

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.13",
+    "version": "0.0.16",
     "keywords": [
         "object schema validator",
         "schema",
@@ -19,7 +19,7 @@
         "build": "tsc"
     },
     "dependencies": {
-        "@cleverbrush/deep": "0.0.13"
+        "@cleverbrush/deep": "0.0.16"
     },
     "types": "./dist/index.d.ts"
 }

package/src/index.ts

@@ -1,7 +1,9 @@
+import { Merge } from '@cleverbrush/deep';
 import SchemaValidator from './schemaValidator';
 
 export type DefaultSchemaType =
     | 'object'
+    | 'boolean'
     | 'function'
     | 'number'
     | 'string'
@@ -44,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>;
     }>;
@@ -72,6 +74,14 @@ export type FunctionSchemaDefinition<T extends (...args: any) => any> = Omit<
     params?: ParamsValidators<T>;
 };
 
+export type BooleanSchemaDefinition<TObj> = Omit<
+    SchemaDefintion<TObj>,
+    'type'
+> & {
+    type: 'boolean';
+    equals?: boolean;
+};
+
 export type NumberSchemaDefinition<TObj> = Omit<
     SchemaDefintion<TObj>,
     'type'
@@ -113,6 +123,7 @@ export type CompositeSchema<TObj> = TObj extends (...args: any) => any
     : TObj extends string
     ? StringSchemaDefinition<TObj> | 'string'
     :
+          | BooleanSchemaDefinition<TObj>
           | NumberSchemaDefinition<TObj>
           | StringSchemaDefinition<TObj>
           | ArraySchemaDefinition<TObj>
@@ -127,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>
@@ -146,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>,
@@ -159,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();
@@ -554,6 +554,82 @@ test('Validate - number by schema - custom validators - 2', async () => {
     expect(result).toHaveProperty('valid', false);
 });
 
+test('Validate - boolean - 1', async () => {
+    const validator = new SchemaValidator();
+    const result = await validator.validate(
+        {
+            type: 'boolean'
+        },
+        300
+    );
+
+    expect(result).toHaveProperty('valid', false);
+});
+
+test('Validate - boolean - 2', async () => {
+    const validator = new SchemaValidator();
+    const result = await validator.validate(
+        {
+            type: 'boolean'
+        },
+        true
+    );
+
+    expect(result).toHaveProperty('valid', true);
+});
+
+test('Validate - boolean - 3', async () => {
+    const validator = new SchemaValidator();
+    const result = await validator.validate(
+        {
+            type: 'boolean'
+        },
+        false
+    );
+
+    expect(result).toHaveProperty('valid', true);
+});
+
+test('Validate - boolean - 4', async () => {
+    const validator = new SchemaValidator();
+    const result = await validator.validate(
+        {
+            type: 'boolean',
+            equals: true
+        },
+        false
+    );
+
+    expect(result).toHaveProperty('valid', false);
+});
+
+test('Validate - boolean - 5', async () => {
+    const validator = new SchemaValidator();
+    const result = await validator.validate(
+        {
+            type: 'boolean',
+            equals: false
+        },
+        false
+    );
+
+    expect(result).toHaveProperty('valid', true);
+});
+
+test('Validate - boolean - 6', async () => {
+    const validator = new SchemaValidator();
+    const result = await validator.validate('boolean', false);
+
+    expect(result).toHaveProperty('valid', true);
+});
+
+test('Validate - boolean - 7', async () => {
+    const validator = new SchemaValidator();
+    const result = await validator.validate('boolean', '123');
+
+    expect(result).toHaveProperty('valid', false);
+});
+
 test('Validate - string - 1', async () => {
     const validator = new SchemaValidator();
     const result = await validator.validate('string', '12345');
@@ -868,7 +944,7 @@ test('Validate - object - 2', async () => {
                     };
                 }
             ]
-        })
+        }) as any as ObjectSchemaDefinition<any>
     );
     const user: User = {
         id: 1,
@@ -1123,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(
         {
@@ -1225,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);
             }
@@ -1264,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, {
@@ -1316,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()];
 
@@ -1337,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);
             },
@@ -1352,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);
             },
@@ -1409,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()];
 
@@ -1430,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);
             },
@@ -1445,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);
             },
@@ -1457,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,14 +13,17 @@ import {
     ISchemaValidator,
     DefaultSchemaType,
     ObjectSchemaDefinition,
-    SchemaDefintion
+    BooleanSchemaDefinition,
+    Cons,
+    Unfold
 } from './index';
 import { validateNumber } from './validators/validateNumber';
+import { validateBoolean } from './validators/validateBoolean';
 import { validateString } from './validators/validateString';
 import { validateArray } from './validators/validateArray';
 import { validateObject } from './validators/validateObject';
 
-const defaultSchemaNames = ['string', 'number', 'date', 'array'];
+const defaultSchemaNames = ['string', 'boolean', 'number', 'date', 'array'];
 
 const defaultSchemas: { [key in DefaultSchemaType]?: Schema<any> } = {
     number: {
@@ -30,6 +33,11 @@ const defaultSchemas: { [key in DefaultSchemaType]?: Schema<any> } = {
         ensureNotNaN: true,
         ensureIsFinite: true
     },
+    boolean: {
+        type: 'boolean',
+        isRequired: true,
+        isNullable: false
+    },
     string: {
         type: 'string',
         isNullable: false,
@@ -49,31 +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, 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> {
@@ -83,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');
 
@@ -108,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')
@@ -119,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;
     }
 
@@ -144,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 = {
@@ -161,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);
@@ -225,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 {
@@ -276,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') ||
@@ -306,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/validateBoolean.ts

@@ -0,0 +1,45 @@
+import {
+    ValidationResult,
+    BooleanSchemaDefinition,
+    ISchemaValidator
+} from '../index';
+
+export const validateBoolean = async (
+    obj: any,
+    schema: BooleanSchemaDefinition<any>,
+    validator: ISchemaValidator<any>
+): Promise<ValidationResult> => {
+    if (
+        typeof obj === 'undefined' &&
+        typeof schema === 'object' &&
+        schema.isRequired === false
+    ) {
+        return {
+            valid: true
+        };
+    }
+    if (typeof obj !== 'boolean')
+        return {
+            valid: false,
+            errors: [`expected type boolean, but saw ${typeof obj}`]
+        };
+
+    if (typeof schema === 'boolean') {
+        return { valid: true };
+    }
+
+    const bool = obj as boolean;
+
+    if (typeof schema.equals === 'boolean') {
+        return schema.equals === bool
+            ? { valid: true }
+            : {
+                  valid: false,
+                  errors: [`must be equal to ${schema.equals}`]
+              };
+    }
+
+    return {
+        valid: true
+    };
+};

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' &&