@cleverbrush/schema 0.0.16 → 1.0.0-beta.0

package/dist/builders/StringSchemaBuilder.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.string = void 0;
+const SchemaBuilder_js_1 = require("./SchemaBuilder.js");
+const defaultSchemas_js_1 = require("../defaultSchemas.js");
+class StringSchemaBuilder extends SchemaBuilder_js_1.SchemaBuilder {
+    _minLength;
+    _maxLength;
+    _equals;
+    type = 'string';
+    clone() {
+        return StringSchemaBuilder.create(this._schema);
+    }
+    get _schema() {
+        return Object.assign({
+            type: this.type
+        }, this.getCommonSchema(), typeof this._minLength !== 'undefined'
+            ? { minLength: this._minLength }
+            : {}, typeof this._maxLength !== 'undefined'
+            ? { maxLength: this._maxLength }
+            : {}, typeof this._equals !== 'undefined' ? { equals: this._equals } : {});
+    }
+    optional() {
+        if (this.isRequired === false) {
+            return this;
+        }
+        return StringSchemaBuilder.create({
+            ...this._schema,
+            isRequired: false
+        });
+    }
+    required() {
+        if (this.isRequired === true) {
+            return this;
+        }
+        return StringSchemaBuilder.create({
+            ...this._schema,
+            isRequired: true
+        });
+    }
+    nullable() {
+        if (this.isNullable === true) {
+            return this;
+        }
+        return StringSchemaBuilder.create({
+            ...this._schema,
+            isNullable: true
+        });
+    }
+    notNullable() {
+        if (this.isNullable === false) {
+            return this;
+        }
+        return StringSchemaBuilder.create({
+            ...this._schema,
+            isNullable: false
+        });
+    }
+    minLength(val) {
+        if (this._minLength === val) {
+            return this;
+        }
+        return StringSchemaBuilder.create({
+            ...this._schema,
+            minLength: val
+        });
+    }
+    clearMinLength() {
+        if (typeof this._minLength === 'undefined') {
+            return this;
+        }
+        return StringSchemaBuilder.create({
+            ...this._schema,
+            minLength: undefined
+        });
+    }
+    maxLength(val) {
+        if (this._maxLength === val) {
+            return this;
+        }
+        return StringSchemaBuilder.create({
+            ...this._schema,
+            maxLength: val
+        });
+    }
+    clearMaxLength() {
+        if (typeof this._maxLength === 'undefined') {
+            return this;
+        }
+        return StringSchemaBuilder.create({
+            ...this._schema,
+            maxLength: undefined
+        });
+    }
+    equals(val) {
+        if (this._equals === val) {
+            return this;
+        }
+        return StringSchemaBuilder.create({
+            ...this._schema,
+            equals: val
+        });
+    }
+    clearEquals() {
+        if (typeof this._equals === 'undefined') {
+            return this;
+        }
+        return StringSchemaBuilder.create({
+            ...this._schema,
+            equals: undefined
+        });
+    }
+    static create(obj) {
+        return new StringSchemaBuilder(obj);
+    }
+    constructor(obj) {
+        super(obj);
+        if (typeof obj === 'object' && obj) {
+            if (typeof obj.minLength !== 'undefined') {
+                this._minLength = obj.minLength;
+            }
+            if (typeof obj.maxLength !== 'undefined') {
+                this._maxLength = obj.maxLength;
+            }
+            if (typeof obj.equals !== 'undefined') {
+                this._equals = obj.equals;
+            }
+        }
+        else {
+            const defaultSchema = defaultSchemas_js_1.defaultSchemas['string'];
+            this.isRequired = defaultSchema.isRequired;
+            this.isNullable = defaultSchema.isNullable;
+        }
+    }
+}
+const string = (equals) => {
+    const res = StringSchemaBuilder.create();
+    return typeof equals === 'string' ? res.equals(equals) : res;
+};
+exports.string = string;

package/dist/builders/UnionSchemaBuilder.d.ts

@@ -0,0 +1,10 @@
+import { ISchemaBuilder } from './SchemaBuilder.js';
+export interface IUnionSchemaBuilder<TRequired extends boolean = true, TNullable extends boolean = false, TVariants extends any[] = []> extends ISchemaBuilder<TRequired, TNullable> {
+    optional(): IUnionSchemaBuilder<false, TNullable, TVariants>;
+    required(): IUnionSchemaBuilder<true, TNullable, TVariants>;
+    nullable(): IUnionSchemaBuilder<TRequired, true, TVariants>;
+    notNullable(): IUnionSchemaBuilder<TRequired, false, TVariants>;
+    or<T>(schema: T): IUnionSchemaBuilder<TRequired, TNullable, [...TVariants, T]>;
+    clearVariants(): IUnionSchemaBuilder<TRequired, TNullable, []>;
+}
+export declare const union: <T extends ISchemaBuilder<true, false>, K extends T[], TRequired extends boolean = true, TNullable extends boolean = false>(...schemas: K) => IUnionSchemaBuilder<TRequired, TNullable, K>;

package/dist/builders/UnionSchemaBuilder.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.union = void 0;
+const SchemaBuilder_js_1 = require("./SchemaBuilder.js");
+class UnionSchemaBuilder extends SchemaBuilder_js_1.SchemaBuilder {
+    type = 'union';
+    get _schema() {
+        return Object.assign({
+            type: this.type
+        }, this.getCommonSchema(), {
+            variants: this._variants.map((variant) => {
+                if (variant instanceof SchemaBuilder_js_1.SchemaBuilder) {
+                    return variant._schema;
+                }
+                return JSON.parse(JSON.stringify(variant));
+            })
+        });
+    }
+    clone() {
+        return UnionSchemaBuilder.create(this._schema);
+    }
+    _variants;
+    static create(obj) {
+        return new UnionSchemaBuilder(obj);
+    }
+    constructor(obj) {
+        super(obj);
+        this._variants = [];
+        if (Array.isArray(obj.variants)) {
+            for (let i = 0; i < obj.variants.length; i++) {
+                this._variants.push(obj.variants[i]);
+            }
+        }
+    }
+    optional() {
+        if (this.isRequired === false) {
+            return this;
+        }
+        return UnionSchemaBuilder.create({
+            ...this._schema,
+            isRequired: false
+        });
+    }
+    required() {
+        if (this.isRequired === true) {
+            return this;
+        }
+        return UnionSchemaBuilder.create({
+            ...this._schema,
+            isRequired: true
+        });
+    }
+    nullable() {
+        if (this.isNullable === true) {
+            return this;
+        }
+        return UnionSchemaBuilder.create({
+            ...this._schema,
+            isNullable: true
+        });
+    }
+    notNullable() {
+        if (this.isNullable === false) {
+            return this;
+        }
+        return UnionSchemaBuilder.create({
+            ...this._schema,
+            isNullable: false
+        });
+    }
+    or(schema) {
+        return UnionSchemaBuilder.create({
+            ...this._schema,
+            variants: [...this._variants, schema]
+        });
+    }
+    clearVariants() {
+        if (this._variants.length === 0)
+            return this;
+        return UnionSchemaBuilder.create({
+            ...this._schema,
+            variants: []
+        });
+    }
+}
+const union = (...schemas) => {
+    if (schemas.length < 1) {
+        throw new Error('should provide at least one variant');
+    }
+    let res = UnionSchemaBuilder.create({
+        isRequired: true,
+        isNullable: false,
+        variants: [schemas[0]]
+    });
+    for (let i = 1; i < schemas.length; i++) {
+        res = res.or(schemas[i]);
+    }
+    return res;
+};
+exports.union = union;

package/dist/defaultSchemas.d.ts

@@ -0,0 +1,4 @@
+import { DefaultSchemaType, Schema } from './schema.js';
+export declare const defaultSchemas: {
+    [key in DefaultSchemaType]?: Schema;
+};

package/dist/defaultSchemas.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultSchemas = void 0;
+exports.defaultSchemas = {
+    alias: {
+        type: 'alias',
+        // TODO: remove
+        schemaName: '',
+        isRequired: true,
+        isNullable: false
+    },
+    number: {
+        type: 'number',
+        isRequired: true,
+        isNullable: false,
+        ensureNotNaN: true,
+        ensureIsFinite: true
+    },
+    boolean: {
+        type: 'boolean',
+        isRequired: true,
+        isNullable: false
+    },
+    string: {
+        type: 'string',
+        isRequired: true,
+        isNullable: false
+    },
+    array: {
+        type: 'array',
+        isRequired: true,
+        isNullable: false
+    },
+    object: {
+        type: 'object',
+        noUnknownProperties: true,
+        isNullable: false,
+        isRequired: true
+    },
+    function: {
+        type: 'function',
+        isRequired: true,
+        isNullable: false
+    }
+};

package/dist/index.d.ts

@@ -1,94 +1,42 @@
-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];
-export declare type DefaultPropertyDefinition = {
-    isRequired: boolean;
-    isNullable: boolean;
+import { InferType, ExpandSchemaBuilder, ValidationResultWithObject } from './schema.js';
+import SchemaRegistry from './schemaRegistry.js';
+import { alias } from './builders/AliasSchemaBuilder.js';
+import { array } from './builders/ArraySchemaBuilder.js';
+import { boolean } from './builders/BooleanSchemaBuilder.js';
+import { number } from './builders/NumberSchemaBuilder.js';
+import { object } from './builders/ObjectSchemaBuilder.js';
+import { string } from './builders/StringSchemaBuilder.js';
+import { union } from './builders/UnionSchemaBuilder.js';
+import { func } from './builders/FunctionSchemaBuilder.js';
+export declare type GetNodes<T extends Record<string, any>, TPrefix extends string = ''> = {
+    [k in keyof T]: k extends `${TPrefix}${infer F}.${infer S}` ? F : never;
+}[keyof T];
+export declare type GetLeafs<T extends Record<string, any>, TPrefix extends string = ''> = {
+    [k in keyof T]: k extends `${TPrefix}${infer F}` ? F extends `${infer S}.${infer G}` ? never : F : never;
+}[keyof T];
+export declare type Unfold<TBag extends Record<string, any>, TPrefix extends string = ''> = {
+    [k in GetLeafs<TBag, TPrefix>]: ISchemaActions<TBag[`${TPrefix}${k}`]>;
+} & {
+    [k in GetNodes<TBag, TPrefix>]: Unfold<TBag, `${TPrefix}${k}.`>;
 };
-export declare type ValidationResultRaw = {
-    valid: boolean;
-    errors?: Array<string>;
-};
-export declare type ValidationResult = ValidationResultRaw | Promise<ValidationResultRaw>;
-export declare type Validator<TObj> = (value: TObj) => ValidationResult;
-export declare type SchemaDefintion<TObj> = {
-    type: DefaultSchemaType;
-    isRequired?: boolean;
-    isNullable?: boolean;
-    validators?: Array<Validator<TObj>>;
-};
-export declare type ObjectSchemaDefinition<T> = Omit<SchemaDefintion<T>, 'type'> & {
-    type: 'object';
-    extends?: string;
-    properties?: Partial<{
-        [S in keyof T]: Schema<PropType<T, S>>;
-    }>;
-    preprocessors?: Partial<{
-        [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'> & {
-    type: 'alias';
-    schemaName: string;
-};
-export declare type ObjectSchemaDefinitionParam<T> = Omit<ObjectSchemaDefinition<T>, 'type'>;
-export declare type ParamsValidators<TFunc extends (...args: any) => any> = {
-    [S in keyof Parameters<TFunc>]: SingleSchema<Parameters<TFunc>[S]>;
-};
-export declare type FunctionSchemaDefinition<T extends (...args: any) => any> = Omit<SchemaDefintion<T>, 'type'> & {
-    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;
-    max?: number;
-    equals?: number;
-    isInteger?: boolean;
-    ensureNotNaN?: boolean;
-    ensureIsFinite?: boolean;
-};
-export declare type StringSchemaDefinition<TObj> = Omit<SchemaDefintion<TObj>, 'type'> & {
-    type: 'string';
-    equals?: string;
-    minLength?: number;
-    maxLength?: number;
-};
-export declare type ArraySchemaDefinition<TObj> = Omit<SchemaDefintion<TObj>, 'type'> & {
-    type: 'array';
-    preprocessor?: ((value: unknown) => unknown | Promise<unknown>) | string;
-    ofType?: Schema<any>;
-    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' : 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 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: S;
-}
-export interface ISchemasProvider<T extends unknown[]> {
-    schemas: Merge<T>;
+    validate(value: any): Promise<ValidationResultWithObject<InferType<ExpandSchemaBuilder<S>>>>;
+    schema: ExpandSchemaBuilder<S>;
 }
-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, 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 interface ISchemaRegistry<T extends Record<string, any>> {
+    schemas: Unfold<T>;
 }
-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;
+export { SchemaRegistry };
+declare const _default: {
+    SchemaRegistry: typeof SchemaRegistry;
+    alias: <TSchemaName extends keyof TAliases, TAliases extends Record<string, any>, TAliasesCompiledType = InferType<TAliases[TSchemaName]>>(schemaName: TSchemaName) => import("./builders/AliasSchemaBuilder.js").IAliasSchemaBuilder<TSchemaName, true, false, TAliases, TAliasesCompiledType, {}>;
+    array: () => import("./builders/ArraySchemaBuilder.js").IArraySchemaBuilder<true, false, undefined, undefined, undefined>;
+    boolean: () => import("./builders/BooleanSchemaBuilder.js").IBooleanSchemaBuilder<true, false, undefined>;
+    number: () => import("./builders/NumberSchemaBuilder.js").INumberSchemaBuilder<true, false, undefined, undefined, undefined, true, true, undefined>;
+    object: <T>(properties?: T) => import("./builders/ObjectSchemaBuilder.js").IObjectSchemaBuilder<true, false, true, T extends undefined ? {} : T, undefined>;
+    string: <T_1 extends string = undefined>(equals?: T_1) => import("./builders/StringSchemaBuilder.js").IStringSchemaBuilder<true, false, undefined, undefined, T_1 extends undefined ? undefined : T_1>;
+    union: <T_2 extends import("./builders/SchemaBuilder.js").ISchemaBuilder<true, false>, K extends T_2[], TRequired extends boolean = true, TNullable extends boolean = false>(...schemas: K) => import("./builders/UnionSchemaBuilder.js").IUnionSchemaBuilder<TRequired, TNullable, K>;
+    func: () => import("./builders/FunctionSchemaBuilder.js").IFunctionSchemaBuilder<true, false>;
+};
+export default _default;
+export { alias, array, boolean, number, object, string, union, func, InferType };

package/dist/index.js

@@ -3,7 +3,33 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaValidator = void 0;
-const schemaValidator_1 = __importDefault(require("./schemaValidator"));
-exports.SchemaValidator = schemaValidator_1.default;
-exports.default = schemaValidator_1.default;
+exports.func = exports.union = exports.string = exports.object = exports.number = exports.boolean = exports.array = exports.alias = exports.SchemaRegistry = void 0;
+const schemaRegistry_js_1 = __importDefault(require("./schemaRegistry.js"));
+exports.SchemaRegistry = schemaRegistry_js_1.default;
+const AliasSchemaBuilder_js_1 = require("./builders/AliasSchemaBuilder.js");
+Object.defineProperty(exports, "alias", { enumerable: true, get: function () { return AliasSchemaBuilder_js_1.alias; } });
+const ArraySchemaBuilder_js_1 = require("./builders/ArraySchemaBuilder.js");
+Object.defineProperty(exports, "array", { enumerable: true, get: function () { return ArraySchemaBuilder_js_1.array; } });
+const BooleanSchemaBuilder_js_1 = require("./builders/BooleanSchemaBuilder.js");
+Object.defineProperty(exports, "boolean", { enumerable: true, get: function () { return BooleanSchemaBuilder_js_1.boolean; } });
+const NumberSchemaBuilder_js_1 = require("./builders/NumberSchemaBuilder.js");
+Object.defineProperty(exports, "number", { enumerable: true, get: function () { return NumberSchemaBuilder_js_1.number; } });
+const ObjectSchemaBuilder_js_1 = require("./builders/ObjectSchemaBuilder.js");
+Object.defineProperty(exports, "object", { enumerable: true, get: function () { return ObjectSchemaBuilder_js_1.object; } });
+const StringSchemaBuilder_js_1 = require("./builders/StringSchemaBuilder.js");
+Object.defineProperty(exports, "string", { enumerable: true, get: function () { return StringSchemaBuilder_js_1.string; } });
+const UnionSchemaBuilder_js_1 = require("./builders/UnionSchemaBuilder.js");
+Object.defineProperty(exports, "union", { enumerable: true, get: function () { return UnionSchemaBuilder_js_1.union; } });
+const FunctionSchemaBuilder_js_1 = require("./builders/FunctionSchemaBuilder.js");
+Object.defineProperty(exports, "func", { enumerable: true, get: function () { return FunctionSchemaBuilder_js_1.func; } });
+exports.default = {
+    SchemaRegistry: schemaRegistry_js_1.default,
+    alias: AliasSchemaBuilder_js_1.alias,
+    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
+};