@cleverbrush/schema 0.0.17 → 1.0.0-beta.0

package/dist/schema.d.ts

@@ -0,0 +1,242 @@
+import { ISchemaBuilder } from './builders/SchemaBuilder.js';
+import { IAliasSchemaBuilder } from './builders/AliasSchemaBuilder.js';
+import { IUnionSchemaBuilder } from './builders/UnionSchemaBuilder.js';
+import { IStringSchemaBuilder } from './builders/StringSchemaBuilder.js';
+import { IObjectSchemaBuilder } from './builders/ObjectSchemaBuilder.js';
+import { INumberSchemaBuilder } from './builders/NumberSchemaBuilder.js';
+import { IArraySchemaBuilder } from './builders/ArraySchemaBuilder.js';
+import { IBooleanSchemaBuilder } from './builders/BooleanSchemaBuilder.js';
+import { IFunctionSchemaBuilder } from './builders/FunctionSchemaBuilder.js';
+import { ISchemaRegistry } from './index.js';
+export declare type DefaultSchemaType = 'alias' | 'boolean' | 'number' | 'string' | 'array' | 'object' | 'union' | 'function';
+export declare type KeysWithNoNever<T> = {
+    [k in keyof T]: T[k] extends never ? never : k;
+}[keyof T];
+export declare type OmitNever<T> = {
+    [k in KeysWithNoNever<T>]: T[k];
+};
+declare type MakePropOptional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
+export declare type Union<T1, T2> = {
+    [k in keyof Omit<T1, keyof T2>]: T1[k];
+} & T2;
+export declare type DefaultCommonSchema = {
+    isRequired: true;
+    isNullable: false;
+};
+export declare type DefaultBooleanSchema = DefaultCommonSchema & {
+    type: 'boolean';
+};
+export declare type DefaultNumberSchema = DefaultCommonSchema & {
+    type: 'number';
+    ensureNotNaN: true;
+    ensureIsFinite: true;
+};
+export declare type DefaultStringSchema = DefaultCommonSchema & {
+    type: 'string';
+};
+export declare type DefaultArraySchema = DefaultCommonSchema & {
+    type: 'array';
+};
+export declare type DefaultUnionSchema = DefaultCommonSchema & {
+    type: 'union';
+};
+export declare type DefaultObjectSchema = DefaultCommonSchema & {
+    type: 'object';
+    noUnknownProperties: true;
+};
+export declare type DefaultFunctionSchema = DefaultCommonSchema & {
+    type: 'function';
+};
+export declare type ValidationResultRaw = {
+    valid: boolean;
+    errors?: Array<string>;
+};
+export declare type ValidationResult = ValidationResultRaw | Promise<ValidationResultRaw>;
+export declare type ValidationResultWithObject<T> = {
+    valid: boolean;
+    errors?: Array<string>;
+    object?: T;
+};
+export declare type Validator = (value: any) => ValidationResult;
+export declare type CommonSchemaSpecification<TRequired extends boolean = true, TNullable extends boolean = false> = {
+    isRequired?: TRequired;
+    isNullable?: TNullable;
+    validators?: Array<Validator>;
+};
+export declare type BooleanSchema = CommonSchemaSpecification<any, any> & {
+    type: 'boolean';
+    equals?: boolean;
+};
+export declare type NumberSchema = CommonSchemaSpecification<any, any> & {
+    type: 'number';
+    min?: number;
+    max?: number;
+    equals?: number;
+    isInteger?: boolean;
+    ensureNotNaN?: boolean;
+    ensureIsFinite?: boolean;
+};
+export declare type ArraySchema<T> = CommonSchemaSpecification<any, any> & {
+    type: 'array';
+    preprocessor?: ((value: unknown) => unknown | Promise<unknown>) | string;
+    ofType?: T;
+    minLength?: number;
+    maxLength?: number;
+};
+export declare type ObjectSchema<T extends Record<string, Schema> = never> = CommonSchemaSpecification<any, any> & {
+    type: 'object';
+    noUnknownProperties?: boolean;
+    properties?: T;
+    preprocessors?: {
+        [S in keyof T | '*']?: S extends keyof T ? ((value: any) => undefined | InferType<T[S]> | Promise<InferType<T[S]>>) | string : (value: InferType<T>) => void | Promise<void>;
+    };
+};
+export declare type AliasSchema = CommonSchemaSpecification<any, any> & {
+    type: 'alias';
+    schemaName: string;
+    externalRegistry?: ISchemaRegistry<any>;
+};
+export declare type UnionSchema<T extends any[]> = CommonSchemaSpecification<any, any> & {
+    type: 'union';
+    variants: T;
+};
+export declare type StringSchema = CommonSchemaSpecification<any, any> & {
+    type: 'string';
+    equals?: string;
+    minLength?: number;
+    maxLength?: number;
+};
+export declare type FunctionSchema = CommonSchemaSpecification<any, any> & {
+    type: 'function';
+};
+export declare type SchemaSpecification = ObjectSchema | BooleanSchema | NumberSchema | ArraySchema<any> | AliasSchema | UnionSchema<any> | StringSchema | FunctionSchema;
+export declare type Schema<T = any> = T extends Record<string, any> ? any : T extends number ? NumberSchema | number | 'number' : T extends string ? StringSchema | string | 'string' : T extends boolean ? BooleanSchema | boolean : number | DefaultSchemaType | SchemaSpecification | Schema[];
+export declare type MakeOptional<T> = T extends IAliasSchemaBuilder<infer TSchemaName, infer TRequired, infer TNullable, infer TAliases, infer TAliasesCompiledType> ? IAliasSchemaBuilder<TSchemaName, false, TNullable, TAliases, TAliasesCompiledType> : T extends IUnionSchemaBuilder<infer TRequired, infer TNullable, infer TVariants> ? IUnionSchemaBuilder<false, TNullable, TVariants> : T extends IStringSchemaBuilder<infer TRequired, infer TNullable, infer TMinLength, infer TMaxLength, infer TEqualsTo> ? IStringSchemaBuilder<false, TNullable, TMinLength, TMaxLength, TEqualsTo> : T extends IObjectSchemaBuilder<infer TRequired, infer TNullable, infer TNoUnknownProperties, infer TProperties, infer TMapToType> ? IObjectSchemaBuilder<false, TNullable, TNoUnknownProperties, TProperties, TMapToType> : T extends INumberSchemaBuilder<infer TRequired, infer TNullable, infer TMin, infer TMax, infer TIsInteger, infer TEnsureNotNaN, infer TEnsureIsFinite, infer TEqualsTo> ? INumberSchemaBuilder<false, TNullable, TMin, TMax, TIsInteger, TEnsureNotNaN, TEnsureIsFinite, TEqualsTo> : T extends IArraySchemaBuilder<infer TRequired, infer TNullable, infer TOfType, infer TMaxLength, infer TMinLength> ? IArraySchemaBuilder<false, TNullable, TOfType, TMaxLength, TMinLength> : T extends IBooleanSchemaBuilder<infer TRequired, infer TNullable, infer TEqualsTo> ? IBooleanSchemaBuilder<false, TNullable, TEqualsTo> : T extends IFunctionSchemaBuilder<infer TRequired, infer TNullable> ? IFunctionSchemaBuilder<false, TNullable> : T & {
+    isRequired: false;
+};
+export declare type MakeRequired<T> = T extends IAliasSchemaBuilder<infer TSchemaName, infer TRequired, infer TNullable, infer TAliases, infer TAliasesCompiledType> ? IAliasSchemaBuilder<TSchemaName, true, TNullable, TAliases, TAliasesCompiledType> : T extends IUnionSchemaBuilder<infer TRequired, infer TNullable, infer TVariants> ? IUnionSchemaBuilder<true, TNullable, TVariants> : T extends IStringSchemaBuilder<infer TRequired, infer TNullable, infer TMinLength, infer TMaxLength, infer TEqualsTo> ? IStringSchemaBuilder<true, TNullable, TMinLength, TMaxLength, TEqualsTo> : T extends IObjectSchemaBuilder<infer TRequired, infer TNullable, infer TNoUnknownProperties, infer TProperties, infer TMapToType> ? IObjectSchemaBuilder<true, TNullable, TNoUnknownProperties, TProperties, TMapToType> : T extends INumberSchemaBuilder<infer TRequired, infer TNullable, infer TMin, infer TMax, infer TIsInteger, infer TEnsureNotNaN, infer TEnsureIsFinite, infer TEqualsTo> ? INumberSchemaBuilder<true, TNullable, TMin, TMax, TIsInteger, TEnsureNotNaN, TEnsureIsFinite, TEqualsTo> : T extends IArraySchemaBuilder<infer TRequired, infer TNullable, infer TOfType, infer TMaxLength, infer TMinLength> ? IArraySchemaBuilder<true, TNullable, TOfType, TMaxLength, TMinLength> : T extends IBooleanSchemaBuilder<infer TRequired, infer TNullable, infer TEqualsTo> ? IBooleanSchemaBuilder<true, TNullable, TEqualsTo> : T extends IFunctionSchemaBuilder<infer TRequired, infer TNullable> ? IFunctionSchemaBuilder<true, TNullable> : T & {
+    isRequired: true;
+};
+export declare type MakeNullable<T> = T extends IAliasSchemaBuilder<infer TSchemaName, infer TRequired, infer TNullable, infer TAliases, infer TAliasesCompiledType> ? IAliasSchemaBuilder<TSchemaName, TRequired, true, TAliases, TAliasesCompiledType> : T extends IUnionSchemaBuilder<infer TRequired, infer TNullable, infer TVariants> ? IUnionSchemaBuilder<TRequired, true, TVariants> : T extends IStringSchemaBuilder<infer TRequired, infer TNullable, infer TMinLength, infer TMaxLength, infer TEqualsTo> ? IStringSchemaBuilder<TRequired, true, TMinLength, TMaxLength, TEqualsTo> : T extends IObjectSchemaBuilder<infer TRequired, infer TNullable, infer TNoUnknownProperties, infer TProperties, infer TMapToType> ? IObjectSchemaBuilder<TRequired, true, TNoUnknownProperties, TProperties, TMapToType> : T extends INumberSchemaBuilder<infer TRequired, infer TNullable, infer TMin, infer TMax, infer TIsInteger, infer TEnsureNotNaN, infer TEnsureIsFinite, infer TEqualsTo> ? INumberSchemaBuilder<TRequired, true, TMin, TMax, TIsInteger, TEnsureNotNaN, TEnsureIsFinite, TEqualsTo> : T extends IArraySchemaBuilder<infer TRequired, infer TNullable, infer TOfType, infer TMaxLength, infer TMinLength> ? IArraySchemaBuilder<TRequired, true, TOfType, TMaxLength, TMinLength> : T extends IBooleanSchemaBuilder<infer TRequired, infer TNullable, infer TEqualsTo> ? IBooleanSchemaBuilder<TRequired, true, TEqualsTo> : T extends IFunctionSchemaBuilder<infer TRequired, infer TNullable> ? IFunctionSchemaBuilder<TRequired, true> : T & {
+    isNullable: true;
+};
+export declare type MakeNotNullable<T> = T extends IAliasSchemaBuilder<infer TSchemaName, infer TRequired, infer TNullable, infer TAliases, infer TAliasesCompiledType> ? IAliasSchemaBuilder<TSchemaName, TRequired, false, TAliases, TAliasesCompiledType> : T extends IUnionSchemaBuilder<infer TRequired, infer TNullable, infer TVariants> ? IUnionSchemaBuilder<TRequired, false, TVariants> : T extends IStringSchemaBuilder<infer TRequired, infer TNullable, infer TMinLength, infer TMaxLength, infer TEqualsTo> ? IStringSchemaBuilder<TRequired, false, TMinLength, TMaxLength, TEqualsTo> : T extends IObjectSchemaBuilder<infer TRequired, infer TNullable, infer TNoUnknownProperties, infer TProperties, infer TMapToType> ? IObjectSchemaBuilder<TRequired, false, TNoUnknownProperties, TProperties, TMapToType> : T extends INumberSchemaBuilder<infer TRequired, infer TNullable, infer TMin, infer TMax, infer TIsInteger, infer TEnsureNotNaN, infer TEnsureIsFinite, infer TEqualsTo> ? INumberSchemaBuilder<TRequired, false, TMin, TMax, TIsInteger, TEnsureNotNaN, TEnsureIsFinite, TEqualsTo> : T extends IArraySchemaBuilder<infer TRequired, infer TNullable, infer TOfType, infer TMaxLength, infer TMinLength> ? IArraySchemaBuilder<TRequired, false, TOfType, TMaxLength, TMinLength> : T extends IBooleanSchemaBuilder<infer TRequired, infer TNullable, infer TEqualsTo> ? IBooleanSchemaBuilder<TRequired, false, TEqualsTo> : T extends IFunctionSchemaBuilder<infer TRequired, infer TNullable> ? IFunctionSchemaBuilder<TRequired, false> : T & {
+    isNullable: false;
+};
+export declare type ExpandUnionVariants<TVariants extends any[]> = TVariants extends [
+    infer T
+] ? [ExpandSchemaBuilder<T>] : TVariants extends [infer T, ...infer Rest] ? [ExpandSchemaBuilder<T>, ExpandUnionVariants<[...Rest]>] : never;
+export declare type ExpandSchemaBuilder<TSchema> = TSchema extends [
+    infer TType,
+    ...infer TParams
+] ? TType extends 'object' ? TParams extends [
+    infer TRequired extends boolean,
+    infer TNullable extends boolean,
+    infer TNoUnknownProperties extends boolean | undefined,
+    infer TProperties,
+    infer TMapToType
+] ? IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, {
+    [k in keyof TProperties]: ExpandSchemaBuilder<TProperties[k]>;
+}, TMapToType> : IObjectSchemaBuilder : TType extends 'string' ? TParams extends [
+    infer TRequired extends boolean,
+    infer TNullable extends boolean,
+    infer TMinLength extends number | undefined,
+    infer TMaxLength extends number | undefined,
+    infer TEqualsTo extends string | undefined
+] ? TEqualsTo extends undefined ? IStringSchemaBuilder<TRequired, TNullable, TMinLength, TMaxLength, undefined> : IStringSchemaBuilder<TRequired, TNullable, TMinLength, TMaxLength, TEqualsTo> : IStringSchemaBuilder : TType extends 'number' ? TParams extends [
+    infer TRequired extends boolean,
+    infer TNullable extends boolean,
+    infer TMin extends number | undefined,
+    infer TMax extends number | undefined,
+    infer TIsInteger extends boolean | undefined,
+    infer TEnsureNotNaN extends boolean | undefined,
+    infer TEnsureIsFinite extends boolean | undefined,
+    infer TEqualsTo extends number | undefined
+] ? TEqualsTo extends undefined ? INumberSchemaBuilder<TRequired, TNullable, TMin, TMax, TIsInteger, TEnsureNotNaN, TEnsureIsFinite, TEqualsTo> : INumberSchemaBuilder<TRequired, TNullable, TMin, TMax, TIsInteger, TEnsureNotNaN, TEnsureIsFinite, undefined> : INumberSchemaBuilder : TType extends 'alias' ? TParams extends [
+    infer TSchemaName extends string,
+    infer TRequired extends boolean,
+    infer TNullable extends boolean,
+    infer TAliasesCompiledType
+] ? IAliasSchemaBuilder<TSchemaName, TRequired, TNullable, any, TAliasesCompiledType> : IAliasSchemaBuilder<any> : TType extends 'array' ? TParams extends [
+    infer TRequired extends boolean,
+    infer TNullable extends boolean,
+    infer TOfType,
+    infer TMaxLength extends number | undefined,
+    infer TMinLength extends number | undefined
+] ? IArraySchemaBuilder<TRequired, TNullable, ExpandSchemaBuilder<TOfType>, TMaxLength, TMinLength> : IArraySchemaBuilder : TType extends 'union' ? TParams extends [
+    infer TRequired extends boolean,
+    infer TNullable extends boolean,
+    infer TVariants extends any[]
+] ? IUnionSchemaBuilder<TRequired, TNullable, ExpandUnionVariants<TVariants>> : IUnionSchemaBuilder : TType extends 'boolean' ? TParams extends [
+    infer TRequired extends boolean,
+    infer TNullable extends boolean,
+    infer TEqualsTo extends boolean | undefined
+] ? IBooleanSchemaBuilder<TRequired, TNullable, TEqualsTo extends undefined ? undefined : boolean> : IBooleanSchemaBuilder : TType extends 'function' ? TParams extends [
+    infer TRequired extends boolean,
+    infer TNullable extends boolean
+] ? IFunctionSchemaBuilder<TRequired, TNullable> : IFunctionSchemaBuilder : TSchema : TSchema;
+export declare type ReduceSchemaBuilder<TBuilder> = TBuilder extends IObjectSchemaBuilder<infer TRequired, infer TNullable, infer TNoUnknownProperties, infer TProperties, infer TMapToType> ? [
+    'object',
+    TRequired,
+    TNullable,
+    TNoUnknownProperties,
+    {
+        [k in keyof TProperties]: ReduceSchemaBuilder<TProperties[k]>;
+    },
+    TMapToType
+] : TBuilder extends IStringSchemaBuilder<infer TRequired, infer TNullable, infer TMinLength, infer TMaxLength, infer TEqualsTo> ? ['string', TRequired, TNullable, TMinLength, TMaxLength, TEqualsTo] : TBuilder extends INumberSchemaBuilder<infer TRequired, infer TNullable, infer TMin, infer TMax, infer TIsInteger, infer TEnsureNotNaN, infer TEnsureIsFinite, infer TEqualsTo> ? [
+    'number',
+    TRequired,
+    TNullable,
+    TMin,
+    TMax,
+    TIsInteger,
+    TEnsureNotNaN,
+    TEnsureIsFinite,
+    TEqualsTo
+] : TBuilder extends IAliasSchemaBuilder<infer TSchemaName, infer TRequired, infer TNullable, infer TAliases> ? [
+    'alias',
+    TSchemaName,
+    TRequired,
+    TNullable,
+    InferType<ExpandSchemaBuilder<TAliases[TSchemaName]>>
+] : TBuilder extends IArraySchemaBuilder<infer TRequired, infer TNullable, infer TOfType, infer TMaxLength, infer TMinLength> ? [
+    'array',
+    TRequired,
+    TNullable,
+    ReduceSchemaBuilder<TOfType>,
+    TMaxLength,
+    TMinLength
+] : TBuilder extends IUnionSchemaBuilder<infer TRequired, infer TNullable, infer TVariants> ? ['union', TRequired, TNullable, ReduceSchemaBuilder<TVariants>] : TBuilder extends IBooleanSchemaBuilder<infer TRequired, infer TNullable, infer TEqualsTo> ? ['boolean', TRequired, TNullable, TEqualsTo] : TBuilder extends IFunctionSchemaBuilder<infer TRequired, infer TNullable> ? ['function', TRequired, TNullable] : TBuilder extends [infer F] ? [ReduceSchemaBuilder<F>] : TBuilder extends [infer F, ...infer Rest] ? [ReduceSchemaBuilder<F>, ...ReduceSchemaBuilder<Rest>] : TBuilder;
+export declare type InferType<S> = S extends DefaultSchemaType ? S extends 'string' ? string : S extends 'boolean' ? boolean : S extends 'number' ? number : S extends 'array' ? Array<any> : S extends 'object' ? Record<string, never> : S extends 'function' ? Function : never : S extends number ? S : S extends BooleanSchema ? S['equals'] extends undefined ? boolean : S['equals'] : S extends UnionSchema<infer K> ? InferType<K> : S extends {
+    type: 'union';
+    variants: infer K;
+} ? K extends any[] ? InferType<K> : any : S extends IObjectSchemaBuilder<infer TRequired, infer TNullable, infer TNoUnknownProperties, infer TProperties, infer TMapToType> ? TMapToType extends undefined ? InferType<CommonSchemaSpecification<TRequired, TNullable> & {
+    type: 'object';
+} & (TNoUnknownProperties extends true ? {
+    noUnknownProperties: true;
+} : {
+    noUnknownProperties: false;
+}) & (TProperties extends Record<string, any> ? {
+    properties: TProperties;
+} : {})> : TMapToType : S extends INumberSchemaBuilder<infer TRequired, infer TNullable, infer TMin, infer TMax, infer TIsInteger, infer TEnsureNotNaN, infer TEnsureIsFinite, infer TEqualsTo> ? TRequired extends true ? TEqualsTo extends undefined ? number : TEqualsTo : TEqualsTo extends undefined ? number | undefined : TEqualsTo | undefined : S extends IBooleanSchemaBuilder<infer TRequired, infer TNullable, infer TEqualsTo> ? TRequired extends true ? TEqualsTo extends undefined ? boolean : TEqualsTo : TEqualsTo extends undefined ? boolean | undefined : TEqualsTo | undefined : S extends IStringSchemaBuilder<infer TRequired, infer TNullable, infer TMinLength, infer TMaxLength, infer TEqualsTo> ? TRequired extends true ? TEqualsTo extends undefined ? string : TEqualsTo : TEqualsTo extends undefined ? string | undefined : TEqualsTo | undefined : S extends IUnionSchemaBuilder<infer TRequired, infer TNullable, infer TVariants> ? TRequired extends true ? InferType<TVariants> : InferType<TVariants> | undefined : S extends IAliasSchemaBuilder<infer TSchemaName, infer TRequired, infer TNullable, infer TAliases, infer TAliasesCompiledType> ? TRequired extends true ? TAliasesCompiledType : TAliasesCompiledType | undefined : S extends IArraySchemaBuilder<infer TRequired, infer TNullable, infer TOfType, infer TMaxLength, infer TMinLength> ? TRequired extends true ? TOfType extends undefined ? any[] : InferType<TOfType>[] : TOfType extends undefined ? any[] | undefined : InferType<TOfType>[] | undefined : S extends IFunctionSchemaBuilder<infer TRequired, infer TNullable> ? TRequired extends true ? Function : Function | undefined : S extends StringSchema ? S['equals'] extends undefined ? string : S['equals'] : S extends NumberSchema ? S['equals'] extends undefined ? number : S['equals'] : S extends ObjectSchema<infer K> ? OptionalPropertiesOf<K> extends never ? {
+    [k in keyof K]: InferType<K[k]>;
+} : MakePropOptional<{
+    [k in keyof K]: InferType<K[k]>;
+}, OptionalPropertiesOf<K>> : S extends {
+    type: 'object';
+    properties: infer K;
+} ? OptionalPropertiesOf<K> extends never ? {
+    [k in keyof K]: InferType<K[k]>;
+} : MakePropOptional<{
+    [k in keyof K]: InferType<K[k]>;
+}, OptionalPropertiesOf<K>> : S extends [infer F] ? InferType<F> : S extends [infer F, ...infer Rest] ? InferType<F> | InferType<Rest> : S extends ArraySchema<infer L> ? InferType<L> extends never ? Array<any> : InferType<L>[] : S extends {
+    type: 'array';
+    ofType: infer L;
+} ? InferType<L>[] : S extends {
+    type: 'array';
+} ? Array<any> : any;
+declare type OptionalPropertiesOf<T> = {
+    [k in keyof T]: T[k] extends ISchemaBuilder<infer TRequired, any> ? TRequired extends false ? k : never : never;
+}[keyof T];
+export {};

package/dist/schema.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/schemaRegistry.d.ts

@@ -0,0 +1,54 @@
+import { ISchemaRegistry as ISchemaRegistry, Unfold } from './index.js';
+import { Schema, ReduceSchemaBuilder, ValidationResult, InferType, ExpandSchemaBuilder } from './schema.js';
+import { number } from './builders/NumberSchemaBuilder.js';
+import { union } from './builders/UnionSchemaBuilder.js';
+import { object } from './builders/ObjectSchemaBuilder.js';
+import { string } from './builders/StringSchemaBuilder.js';
+import { boolean } from './builders/BooleanSchemaBuilder.js';
+import { array } from './builders/ArraySchemaBuilder.js';
+import { IAliasSchemaBuilder } from './builders/AliasSchemaBuilder.js';
+import { func } from './builders/FunctionSchemaBuilder.js';
+import { ISchemaBuilder } from './builders/SchemaBuilder.js';
+export default class SchemaRegistry<T extends Record<string, Schema> = {}> implements ISchemaRegistry<T> {
+    private _schemasMap;
+    private _schemasCache;
+    private _preprocessorsMap;
+    get preprocessors(): Map<string, (value: unknown) => unknown>;
+    addPreprocessor(name: string, preprocessor: (value: unknown) => unknown | Promise<unknown>): SchemaRegistry<T>;
+    addSchemaFrom<TOldName extends keyof T, TName extends string, TParam extends Record<string, any> | ((params: {
+        schema: ExpandSchemaBuilder<T[TOldName]>;
+        boolean: typeof boolean;
+        func: typeof func;
+        array: typeof array;
+        string: typeof string;
+        number: typeof number;
+        union: typeof union;
+        object: typeof object;
+        alias: <TSchemaName extends keyof T, TCompiledType = InferType<ExpandSchemaBuilder<T[TSchemaName]>>>(schemaName: TSchemaName) => IAliasSchemaBuilder<TSchemaName, true, false, {
+            [k in keyof T]: TSchemaName extends k ? T[k] : never;
+        }, TCompiledType>;
+    }) => TSchema), TSchema extends Schema | ISchemaBuilder>(oldName: TOldName, name: TName, param: TParam): SchemaRegistry<T & {
+        [key in TName]: TParam extends (...args: any[]) => any ? ReduceSchemaBuilder<ReturnType<TParam>> : TParam;
+    }>;
+    addSchema<TName extends string, TParam extends Record<string, any> | ((params: {
+        boolean: typeof boolean;
+        array: typeof array;
+        string: typeof string;
+        number: typeof number;
+        union: typeof union;
+        object: typeof object;
+        func: typeof func;
+        alias: <TSchemaName extends keyof T, TCompiledType = InferType<ExpandSchemaBuilder<T[TSchemaName]>>>(schemaName: TSchemaName) => IAliasSchemaBuilder<TSchemaName, true, false, {
+            [k in keyof T]: TSchemaName extends k ? T[k] : never;
+        }, TCompiledType>;
+        external: <TRegistryKeys extends Record<string, any>, TSchemaName extends keyof TRegistryKeys, TCompiledType = InferType<ExpandSchemaBuilder<TRegistryKeys[TSchemaName]>>>(registry: ISchemaRegistry<TRegistryKeys>, schemaName: TSchemaName) => IAliasSchemaBuilder<TSchemaName, true, false, {
+            [k in keyof TRegistryKeys]: TSchemaName extends k ? TRegistryKeys[k] : never;
+        }, TCompiledType>;
+    }) => TSchema), TSchema extends Schema | ISchemaBuilder>(name: TName, param: TParam): SchemaRegistry<T & {
+        [key in TName]: TParam extends (...args: any[]) => any ? ReduceSchemaBuilder<ReturnType<TParam>> : TParam;
+    }>;
+    get schemas(): Unfold<T>;
+    private validateDefaultType;
+    private checkValidators;
+    validate(schemaToValidate: keyof T | Schema, obj: any): Promise<ValidationResult>;
+}

package/dist/schemaRegistry.js

@@ -0,0 +1,301 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const validateNumber_js_1 = require("./validators/validateNumber.js");
+const validateBoolean_js_1 = require("./validators/validateBoolean.js");
+const validateString_js_1 = require("./validators/validateString.js");
+const validateArray_js_1 = require("./validators/validateArray.js");
+const validateObject_js_1 = require("./validators/validateObject.js");
+const validateUnion_js_1 = require("./validators/validateUnion.js");
+const validateFunction_js_1 = require("./validators/validateFunction.js");
+const NumberSchemaBuilder_js_1 = require("./builders/NumberSchemaBuilder.js");
+const UnionSchemaBuilder_js_1 = require("./builders/UnionSchemaBuilder.js");
+const ObjectSchemaBuilder_js_1 = require("./builders/ObjectSchemaBuilder.js");
+const StringSchemaBuilder_js_1 = require("./builders/StringSchemaBuilder.js");
+const BooleanSchemaBuilder_js_1 = require("./builders/BooleanSchemaBuilder.js");
+const ArraySchemaBuilder_js_1 = require("./builders/ArraySchemaBuilder.js");
+const AliasSchemaBuilder_js_1 = require("./builders/AliasSchemaBuilder.js");
+const FunctionSchemaBuilder_js_1 = require("./builders/FunctionSchemaBuilder.js");
+const defaultSchemas_js_1 = require("./defaultSchemas.js");
+const SchemaBuilder_js_1 = require("./builders/SchemaBuilder.js");
+const defaultSchemaNames = ['string', 'boolean', 'number', 'array', 'function'];
+const defaultSchemasValidationStrategies = {
+    number: (obj, schema) => (0, validateNumber_js_1.validateNumber)(obj, schema),
+    boolean: (obj, schema) => (0, validateBoolean_js_1.validateBoolean)(obj, schema),
+    string: (obj, schema) => (0, validateString_js_1.validateString)(obj, schema),
+    array: (obj, schema, validator) => (0, validateArray_js_1.validateArray)(obj, schema, validator),
+    function: (obj, schema) => (0, validateFunction_js_1.validateFunction)(obj, schema)
+};
+const isDefaultType = (name) => defaultSchemaNames.indexOf(name) !== -1;
+class SchemaRegistry {
+    _schemasMap = new Map();
+    _schemasCache = null;
+    _preprocessorsMap = new Map();
+    get preprocessors() {
+        return this._preprocessorsMap;
+    }
+    addPreprocessor(name, preprocessor) {
+        if (this._preprocessorsMap.has(name))
+            throw new Error(`Preprocessor '${name}' is already registered`);
+        if (typeof preprocessor !== 'function') {
+            throw new Error('preprocessor must be a function');
+        }
+        this._preprocessorsMap.set(name, preprocessor);
+        return this;
+    }
+    addSchemaFrom(oldName, name, param) {
+        if (!this._schemasMap.has(oldName.toString())) {
+            throw new Error(`unknown schema name ${oldName.toString()}`);
+        }
+        const oldSchema = this._schemasMap.get(oldName.toString());
+        const schema = typeof param === 'function'
+            ? param({
+                schema: oldSchema,
+                alias: AliasSchemaBuilder_js_1.alias,
+                array: ArraySchemaBuilder_js_1.array,
+                boolean: BooleanSchemaBuilder_js_1.boolean,
+                func: FunctionSchemaBuilder_js_1.func,
+                number: NumberSchemaBuilder_js_1.number,
+                object: ObjectSchemaBuilder_js_1.object,
+                string: StringSchemaBuilder_js_1.string,
+                union: UnionSchemaBuilder_js_1.union
+            })
+            : param;
+        if (Array.isArray(schema)) {
+            this._schemasMap.set(name.toString(), schema);
+            this._schemasCache = null;
+            return this;
+        }
+        if (typeof schema !== 'object')
+            throw new Error('Array or Object is required');
+        this._schemasMap.set(name.toString(), {
+            ...(schema instanceof SchemaBuilder_js_1.SchemaBuilder
+                ? schema._schema
+                : schema)
+        });
+        this._schemasCache = null;
+        return this;
+    }
+    addSchema(name, param) {
+        if (typeof name !== 'string' || !name)
+            throw new Error('Name is required');
+        if (isDefaultType(name.toString()))
+            throw new Error(`You can't add a schema named "${name}" because it's a name of a default schema, please consider another name to be used`);
+        if (this._schemasMap.has(name.toString())) {
+            throw new Error(`Schema "${name}" already exists`);
+        }
+        const schema = typeof param === 'function'
+            ? param({
+                alias: AliasSchemaBuilder_js_1.alias,
+                external: AliasSchemaBuilder_js_1.externalAlias,
+                array: ArraySchemaBuilder_js_1.array,
+                boolean: BooleanSchemaBuilder_js_1.boolean,
+                number: NumberSchemaBuilder_js_1.number,
+                object: ObjectSchemaBuilder_js_1.object,
+                string: StringSchemaBuilder_js_1.string,
+                union: UnionSchemaBuilder_js_1.union,
+                func: FunctionSchemaBuilder_js_1.func
+            })
+            : param;
+        if (Array.isArray(schema)) {
+            this._schemasMap.set(name.toString(), schema);
+            this._schemasCache = null;
+            return this;
+        }
+        if (typeof schema !== 'object')
+            throw new Error('Array or Object is required');
+        this._schemasMap.set(name.toString(), schema instanceof SchemaBuilder_js_1.SchemaBuilder ? schema.clone() : schema);
+        this._schemasCache = null;
+        return this;
+    }
+    get schemas() {
+        if (this._schemasCache)
+            return this._schemasCache;
+        const res = {};
+        for (const key of this._schemasMap.keys()) {
+            const parts = key.split('.');
+            let curr = res;
+            for (let i = 0; i < parts.length; i++) {
+                if (i === parts.length - 1) {
+                    curr[parts[i]] = {
+                        validate: async (value) => {
+                            const result = await this.validate(this._schemasMap.get(key), value);
+                            if (!result.valid) {
+                                return result;
+                            }
+                            return {
+                                ...result,
+                                object: 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;
+    }
+    async validateDefaultType(name, value, mergeSchema) {
+        const strategy = defaultSchemasValidationStrategies[name];
+        let finalSchema = defaultSchemas_js_1.defaultSchemas[name];
+        if (strategy) {
+            if (typeof mergeSchema === 'object' && mergeSchema) {
+                finalSchema = Object.assign({}, finalSchema, mergeSchema);
+            }
+            if (typeof mergeSchema === 'number') {
+                finalSchema = {
+                    ...finalSchema,
+                    equals: mergeSchema
+                };
+                mergeSchema;
+            }
+            let preliminaryResult = await strategy(value, finalSchema, this);
+            if (!preliminaryResult.valid)
+                return preliminaryResult;
+            preliminaryResult = await this.checkValidators(finalSchema, value);
+            return preliminaryResult;
+        }
+        throw new Error('not implemented');
+    }
+    async checkValidators(schema, value) {
+        if (!schema.isRequired && typeof value === 'undefined') {
+            return {
+                valid: true
+            };
+        }
+        if (Array.isArray(schema.validators)) {
+            const validatorsResults = await Promise.allSettled(schema.validators.map((v) => Promise.resolve(v(value))));
+            const rejections = validatorsResults
+                .filter((f) => f.status === 'rejected')
+                .map((f) => f.reason);
+            const errors = validatorsResults
+                .filter((f) => f.status === 'fulfilled' &&
+                typeof f.value !== 'boolean' &&
+                f.value.valid === false)
+                .map((f) => f.value)
+                .map((f) => f.errors);
+            if (rejections.length === 0 && errors.length === 0) {
+                return {
+                    valid: true
+                };
+            }
+            return {
+                valid: false,
+                errors: [...rejections, ...errors]
+            };
+        }
+        return {
+            valid: true
+        };
+    }
+    async validate(schemaToValidate, obj) {
+        if (!schemaToValidate)
+            throw new Error('schemaName is required');
+        const schema = schemaToValidate instanceof SchemaBuilder_js_1.SchemaBuilder
+            ? schemaToValidate._schema
+            : schemaToValidate;
+        if (typeof schema === 'string') {
+            if (isDefaultType(schema)) {
+                return await this.validateDefaultType(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 = Object.assign({}, defaultSchemas_js_1.defaultSchemas.object, this._schemasMap.get(schema));
+                const res = await (0, validateObject_js_1.validateObject)(obj, objSchema, this);
+                if (!res.valid)
+                    return res;
+                return await this.checkValidators(objSchema, obj);
+            }
+            else {
+                return await this.validateDefaultType('string', obj, {
+                    type: 'string',
+                    equals: schema
+                });
+            }
+        }
+        if (Array.isArray(schema)) {
+            for (let i = 0; i < schema.length; i++) {
+                const res = await this.validate(schema[i], obj);
+                if (res.valid) {
+                    return res;
+                }
+            }
+            return {
+                valid: false,
+                errors: ['object does not match any schema']
+            };
+        }
+        if (typeof schema === 'number') {
+            return await this.validateDefaultType('number', obj, schema);
+        }
+        if (typeof schema === 'object') {
+            const spec = schema;
+            if (typeof spec.type !== 'string')
+                throw new Error('Schema has no type');
+            if (isDefaultType(spec.type)) {
+                return await this.validateDefaultType(spec.type, obj, schema);
+            }
+            else if (spec.type === 'alias') {
+                if (spec.isRequired === false && typeof obj === 'undefined') {
+                    return {
+                        valid: true
+                    };
+                }
+                if (spec.isNullable === true && obj === null) {
+                    return {
+                        valid: true
+                    };
+                }
+                const registry = (spec.externalRegistry ||
+                    this);
+                const alias = registry._schemasMap.get(spec.schemaName);
+                if (typeof alias === 'undefined') {
+                    throw new Error(`Unknown schema alias - ${spec.schemaName}`);
+                }
+                if (Array.isArray(alias)) {
+                    if ((!spec.isRequired && typeof obj === 'undefined') ||
+                        (spec.isNullable && obj === null)) {
+                        return {
+                            valid: true
+                        };
+                    }
+                    return await registry.validate(alias, obj);
+                }
+                if (typeof alias !== 'object')
+                    throw new Error('it is only possible to use a full schema schema definition as alias');
+                let schemaToValidate = alias;
+                if (alias instanceof SchemaBuilder_js_1.SchemaBuilder) {
+                    if (typeof schema.isRequired === 'boolean') {
+                        schemaToValidate = schemaToValidate[schema.isRequired ? 'required' : 'optional']();
+                    }
+                    if (typeof schema.isNullable === 'boolean') {
+                        schemaToValidate = schemaToValidate[schema.isNullable ? 'nullable' : 'notNullable']();
+                    }
+                }
+                return await registry.validate(schemaToValidate, obj);
+            }
+            else if (spec.type === 'union') {
+                return await (0, validateUnion_js_1.validateUnion)(obj, spec, this);
+            }
+            else if (spec.type === 'object') {
+                const preliminaryResult = await (0, validateObject_js_1.validateObject)(obj, schema, this);
+                if (!preliminaryResult.valid)
+                    return preliminaryResult;
+                return await this.checkValidators(schema, obj);
+            }
+            else if (spec.type === 'function') {
+                return await (0, validateFunction_js_1.validateFunction)(obj, spec);
+            }
+        }
+        throw new Error("Couldn't understand the Schema provided");
+    }
+}
+exports.default = SchemaRegistry;

package/dist/validators/validateArray.d.ts

@@ -1,2 +1,3 @@
-import { ValidationResult, ArraySchemaDefinition, ISchemaValidator } from '../index';
-export declare const validateArray: (obj: any, schema: ArraySchemaDefinition<any>, validator: ISchemaValidator<any>) => Promise<ValidationResult>;
+import { ArraySchema, ValidationResult } from '../schema.js';
+import SchemaRegistry from '../schemaRegistry.js';
+export declare const validateArray: (obj: any, schema: ArraySchema<any>, validator: SchemaRegistry<any>) => Promise<ValidationResult>;

package/dist/validators/validateBoolean.d.ts

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

package/dist/validators/validateBoolean.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateBoolean = void 0;
-const validateBoolean = async (obj, schema, validator) => {
+const validateBoolean = async (obj, schema) => {
     if (typeof obj === 'undefined' &&
         typeof schema === 'object' &&
         schema.isRequired === false) {
@@ -14,9 +14,6 @@ const validateBoolean = async (obj, schema, validator) => {
             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

package/dist/validators/validateFunction.d.ts

@@ -0,0 +1,2 @@
+import { FunctionSchema, ValidationResult } from '../schema.js';
+export declare const validateFunction: (obj: any, schema: FunctionSchema) => Promise<ValidationResult>;