@cleverbrush/schema 1.0.0-beta.5 → 1.1.0

package/src/builders/SchemaBuilder.test.ts

@@ -1,73 +0,0 @@
-import { number } from './NumberSchemaBuilder.js';
-
-test('Validators - 1', () => {
-    const schema = number();
-    expect(schema).not.toHaveProperty('validators');
-});
-
-test('Validators - 2', () => {
-    const schema = number().addValidator(() => ({ valid: true }));
-    expect(schema).toHaveProperty('validators');
-    expect(schema.validators).toHaveProperty('length', 1);
-});
-
-test('Validators - 3', () => {
-    const schema = number()
-        .addValidator(() => ({ valid: true }))
-        .addValidator(() => ({ valid: false }));
-    expect(schema).toHaveProperty('validators');
-    expect(schema.validators).toHaveProperty('length', 2);
-});
-
-test('Validators - 4', () => {
-    const schema = number()
-        .addValidator(() => ({ valid: true }))
-        .clearValidators();
-    expect(schema).not.toHaveProperty('validators');
-});
-
-test('Validators - 5', () => {
-    expect(() => {
-        number().addValidator('string' as any);
-    }).toThrow();
-});
-
-test('Preprocessor - 1', () => {
-    const schema = number();
-    expect(schema).not.toHaveProperty('preprocessor');
-});
-
-test('Preprocessor - 2', () => {
-    const schema = number().addPreprocessor(() => new Date());
-    expect(schema).toHaveProperty('preprocessor');
-});
-
-test('Preprocessor - 3', () => {
-    const schema = number()
-        .addPreprocessor(() => new Date())
-        .clearPreprocessor();
-    expect(schema).not.toHaveProperty('preprocessor');
-});
-
-test('Preprocessor - 4', () => {
-    const schema1 = number();
-    const schema2 = schema1.addPreprocessor(() => new Date());
-    const equal = (schema1 as any) === schema2;
-    expect(equal).toEqual(false);
-});
-
-test('Preprocessor - 5', () => {
-    const schema1 = number().addPreprocessor(() => new Date());
-    const schema2 = schema1.clearPreprocessor();
-    const equal = (schema1 as any) === schema2;
-    expect(equal).toEqual(false);
-});
-
-test('Preprocessor - 6', () => {
-    const schema1 = number()
-        .addPreprocessor(() => new Date())
-        .min(30);
-    const schema2 = schema1.clearPreprocessor();
-    const equal = (schema1 as any) === schema2;
-    expect(equal).toEqual(false);
-});

package/src/builders/SchemaBuilder.ts

@@ -1,135 +0,0 @@
-import { Schema, Validator } from '../schema.js';
-
-export interface ISchemaBuilder<
-    TRequired extends boolean = true,
-    TNullable extends boolean = false
-> {
-    readonly _schema: Schema;
-    isRequired: TRequired;
-    isNullable: TNullable;
-    validators?: Validator[];
-    preprocessor?: ((value: unknown) => unknown | Promise<unknown>) | string;
-    addValidator(validator: Validator): this;
-    clearValidators(): this;
-    addPreprocessor(
-        preprocessor: ((value: unknown) => unknown | Promise<unknown>) | string
-    ): this;
-    clearPreprocessor(): this;
-    clone(): this;
-}
-
-export abstract class SchemaBuilder<
-    TRequired extends boolean = true,
-    TNullable extends boolean = false
-> implements ISchemaBuilder<TRequired, TNullable>
-{
-    protected _isRequired: TRequired = true as any as TRequired;
-    protected _isNullable: TNullable = false as any as TNullable;
-
-    public validators?: Validator[];
-
-    public preprocessor?:
-        | ((value: unknown) => unknown | Promise<unknown>)
-        | string;
-
-    public abstract clone(): this;
-
-    public abstract get _schema(): Schema;
-
-    protected constructor(obj: {
-        isRequired?: boolean;
-        isNullable?: boolean;
-        preprocessor?:
-            | ((value: unknown) => unknown | Promise<unknown>)
-            | string;
-        validators?: Validator[];
-    }) {
-        if (typeof obj === 'object') {
-            if (typeof obj.isRequired !== 'undefined') {
-                this.isRequired = obj.isRequired;
-            }
-            if (typeof obj.isNullable !== 'undefined') {
-                this.isNullable = obj.isNullable;
-            }
-            if (Array.isArray(obj.validators)) {
-                this.validators = [...obj.validators];
-            }
-            if (typeof obj.preprocessor !== 'undefined') {
-                this.preprocessor = obj.preprocessor;
-            }
-        }
-    }
-
-    protected getCommonSchema() {
-        const schemas = [];
-        if (typeof this.preprocessor !== 'undefined') {
-            schemas.push({
-                preprocessor: this.preprocessor
-            });
-        }
-        if (typeof this.isRequired !== 'undefined') {
-            schemas.push({ isRequired: this.isRequired });
-        }
-        if (typeof this.isNullable !== 'undefined') {
-            schemas.push({ isNullable: this.isNullable });
-        }
-        if (typeof this.validators !== 'undefined') {
-            schemas.push({ validators: [...this.validators] });
-        }
-        return Object.assign({}, ...schemas);
-    }
-
-    addPreprocessor(
-        preprocessor: ((value: unknown) => unknown | Promise<unknown>) | string
-    ) {
-        const result = this.clone();
-        result.preprocessor = preprocessor;
-        return result;
-    }
-
-    clearPreprocessor(): this {
-        if (typeof this.preprocessor === 'undefined') {
-            return this;
-        }
-
-        const result = this.clone();
-        delete result.preprocessor;
-        return result;
-    }
-
-    addValidator(validator: Validator): this {
-        const result = this.clone();
-        if (typeof validator !== 'function')
-            throw new Error('validator should be a function');
-
-        if (Array.isArray(result.validators)) {
-            result.validators.push(validator);
-        } else {
-            result.validators = [validator];
-        }
-        return result;
-    }
-
-    clearValidators(): this {
-        if (typeof this.validators === 'undefined') return this;
-        const result = this.clone();
-        delete result.validators;
-        return result;
-    }
-
-    public get isRequired(): TRequired {
-        return this._isRequired;
-    }
-
-    protected set isRequired(val: boolean) {
-        this._isRequired = val as TRequired;
-    }
-
-    public get isNullable(): TNullable {
-        return this._isNullable;
-    }
-
-    protected set isNullable(val: boolean) {
-        this._isNullable = val as TNullable;
-    }
-}

package/src/builders/StringSchemaBuilder.test.ts

@@ -1,318 +0,0 @@
-import { deepEqual } from '@cleverbrush/deep';
-
-import { Schema } from '../schema.js';
-import { string } from './StringSchemaBuilder.js';
-
-test('Clean', () => {
-    const schema = string();
-    expect(schema).toHaveProperty('type', 'string');
-    expect(schema).toHaveProperty('isRequired', true);
-    expect(schema).toHaveProperty('isNullable', false);
-});
-
-test('optional', () => {
-    const schema = string().optional();
-    expect(schema).toHaveProperty('type', 'string');
-    expect(schema).toHaveProperty('isRequired', false);
-});
-
-test('optional - 2', () => {
-    const schema = string().optional().required();
-    expect(schema).toHaveProperty('type', 'string');
-    expect(schema).toHaveProperty('isRequired', true);
-});
-
-test('optional - 3', () => {
-    const schema1 = string();
-    const schema2 = schema1.optional();
-    const e = (schema1 as Schema) === (schema2 as Schema);
-    const isRequiredEqual = (schema1 as any).isRequired !== schema2.isRequired;
-    expect(e).toEqual(false);
-    expect(isRequiredEqual).toEqual(true);
-});
-
-test('optional - 4', () => {
-    const schema1 = string().optional();
-    const schema2 = schema1.optional();
-    const e = (schema1 as Schema) === (schema2 as Schema);
-    const isRequiredEqual = (schema1 as any).isRequired === schema2.isRequired;
-    expect(e).toEqual(true);
-    expect(isRequiredEqual).toEqual(true);
-});
-
-test('optional - 5', () => {
-    const schema1 = string();
-    const schema2 = schema1.required();
-    const e = (schema1 as Schema) === (schema2 as Schema);
-    const isRequiredEqual = (schema1 as any).isRequired === schema2.isRequired;
-    expect(e).toEqual(true);
-    expect(isRequiredEqual).toEqual(true);
-});
-
-test('optional - 6', () => {
-    const schema1 = string().optional();
-    const schema2 = schema1.required();
-    const e = (schema1 as Schema) === (schema2 as Schema);
-    const isRequiredEqual = (schema1 as any).isRequired === schema2.isRequired;
-    expect(e).toEqual(false);
-    expect(isRequiredEqual).toEqual(false);
-});
-
-test('optional - 7', () => {
-    const schema1 = string().optional().required();
-    const schema2 = schema1.required();
-    const e = (schema1 as Schema) === (schema2 as Schema);
-    const isRequiredEqual = (schema1 as any).isRequired === schema2.isRequired;
-    expect(e).toEqual(true);
-    expect(isRequiredEqual).toEqual(true);
-});
-
-test('nullable - 1', () => {
-    const schema = string().nullable();
-    expect(schema).toHaveProperty('type', 'string');
-    expect(schema).toHaveProperty('isNullable', true);
-});
-
-test('nullable - 2', () => {
-    const schema = string().nullable().notNullable();
-    expect(schema).toHaveProperty('type', 'string');
-    expect(schema).toHaveProperty('isNullable', false);
-});
-
-test('nullable - 3', () => {
-    const schema1 = string();
-    const schema2 = schema1.nullable();
-    const e = (schema1 as Schema) === (schema2 as Schema);
-    const isNullableEqual = (schema1 as any).isNullable !== schema2.isNullable;
-    expect(e).toEqual(false);
-    expect(isNullableEqual).toEqual(true);
-});
-
-test('nullable - 4', () => {
-    const schema1 = string().nullable();
-    const schema2 = schema1.nullable();
-    const e = (schema1 as Schema) === (schema2 as Schema);
-    const isNullableEqual = (schema1 as any).isNullable === schema2.isNullable;
-    expect(e).toEqual(true);
-    expect(isNullableEqual).toEqual(true);
-});
-
-test('nullable - 5', () => {
-    const schema1 = string();
-    const schema2 = schema1.nullable();
-    const e = (schema1 as Schema) === (schema2 as Schema);
-    const isNullableEqual = (schema1 as any).isNullable === schema2.isNullable;
-    expect(e).toEqual(false);
-    expect(isNullableEqual).toEqual(false);
-});
-
-test('nullable - 6', () => {
-    const schema1 = string();
-    const schema2 = schema1.notNullable();
-    const e = (schema1 as Schema) === (schema2 as Schema);
-    const isNullableEqual = (schema1 as any).isNullable === schema2.isNullable;
-    expect(e).toEqual(true);
-    expect(isNullableEqual).toEqual(true);
-});
-
-test('nullable - 7', () => {
-    const schema1 = string().nullable();
-    const schema2 = schema1.notNullable();
-    const e = (schema1 as Schema) === (schema2 as Schema);
-    const isNullableEqual = (schema1 as any).isNullable === schema2.isNullable;
-    expect(e).toEqual(false);
-    expect(isNullableEqual).toEqual(false);
-});
-
-test('equals - 1', () => {
-    const schema = string().equals('abc');
-    expect(schema._schema).toHaveProperty('type', 'string');
-    expect(schema._schema).toHaveProperty('equals', 'abc');
-});
-
-test('equals - 2', () => {
-    const schema = string();
-    expect(schema._schema).toHaveProperty('type', 'string');
-    expect(schema._schema).not.toHaveProperty('equals');
-});
-
-test('equals - 4', () => {
-    const schema = string().equals('abcd').clearEquals();
-    expect(schema._schema).toHaveProperty('type', 'string');
-    expect(schema._schema).not.toHaveProperty('equals');
-});
-
-test('equals - 5', () => {
-    const schema1 = string();
-    const schema2 = schema1.equals('abcde');
-    const equals = schema1._schema.equals === schema2._schema.equals;
-    expect(equals).toEqual(false);
-    expect(schema1._schema).not.toHaveProperty('equals');
-    expect(schema2._schema).toHaveProperty('equals', 'abcde');
-});
-
-test('equals - 6', () => {
-    const schema1 = string().equals('abcdef');
-    const schema2 = schema1.equals('abcdef');
-    const equals = schema1._schema.equals === schema2._schema.equals;
-    expect(equals).toEqual(true);
-    expect(schema1._schema).toHaveProperty('equals', 'abcdef');
-    expect(schema2._schema).toHaveProperty('equals', 'abcdef');
-});
-
-test('equals - 6', () => {
-    const schema1 = string().equals('abcdefg');
-    const schema2 = schema1.clearEquals();
-    const equals = schema1._schema.equals === schema2._schema.equals;
-    expect(equals).toEqual(false);
-    expect(schema1._schema).toHaveProperty('equals', 'abcdefg');
-    expect(schema2._schema).not.toHaveProperty('equals');
-});
-
-test('equals - 7', () => {
-    const schema1 = string().equals('abcdefgh').clearEquals();
-    const schema2 = schema1.clearEquals();
-    const equals = (schema1 as any) === schema2;
-    expect(equals).toEqual(true);
-});
-
-test('minLength - 1', () => {
-    const schema = string();
-    expect(schema._schema).not.toHaveProperty('minLength');
-});
-
-test('minLength - 2', () => {
-    const schema = string().minLength(20);
-    expect(schema._schema).toHaveProperty('minLength', 20);
-});
-
-test('minLength - 3', () => {
-    const schema = string().minLength(20).clearMinLength();
-    expect(schema._schema).not.toHaveProperty('minLength');
-});
-
-test('minLength - 4', () => {
-    const schema1 = string();
-    const schema2 = schema1.minLength(20);
-    const equal = (schema1 as any) === schema2;
-    expect(equal).toEqual(false);
-    expect(schema1._schema).not.toHaveProperty('minLength');
-    expect(schema2._schema).toHaveProperty('minLength', 20);
-});
-
-test('minLength - 5', () => {
-    const schema1 = string().minLength(20);
-    const schema2 = schema1.minLength(20);
-    const equal = (schema1 as any) === schema2;
-    expect(equal).toEqual(true);
-    expect(schema1._schema).toHaveProperty('minLength', 20);
-    expect(schema2._schema).toHaveProperty('minLength', 20);
-});
-
-test('minLength - 6', () => {
-    const schema1 = string().minLength(20);
-    const schema2 = schema1.clearMinLength();
-    const equal = (schema1 as any) === schema2;
-    expect(equal).toEqual(false);
-    expect(schema1._schema).toHaveProperty('minLength', 20);
-    expect(schema2._schema).not.toHaveProperty('minLength');
-});
-
-test('minLength - 7', () => {
-    const schema1 = string();
-    const schema2 = schema1.clearMinLength();
-    const equal = (schema1 as any) === schema2;
-    expect(equal).toEqual(true);
-    expect(schema1._schema).not.toHaveProperty('minLength');
-    expect(schema2._schema).not.toHaveProperty('minLength');
-});
-
-test('minLength - 8', () => {
-    const schema1 = string().clearMinLength();
-    const schema2 = schema1.clearMinLength();
-    const equal = (schema1 as any) === schema2;
-    expect(equal).toEqual(true);
-    expect(schema1._schema).not.toHaveProperty('minLength');
-    expect(schema2._schema).not.toHaveProperty('minLength');
-});
-
-test('maxLength - 1', () => {
-    const schema = string();
-    expect(schema._schema).not.toHaveProperty('maxLength');
-});
-
-test('maxLength - 2', () => {
-    const schema = string().maxLength(30);
-    expect(schema._schema).toHaveProperty('maxLength', 30);
-});
-
-test('maxLength - 3', () => {
-    const schema = string().maxLength(30).clearMaxLength();
-    expect(schema._schema).not.toHaveProperty('maxLength');
-});
-
-test('maxLength - 4', () => {
-    const schema1 = string();
-    const schema2 = schema1.maxLength(20);
-    const equal = (schema1 as any) === schema2;
-    expect(equal).toEqual(false);
-    expect(schema1._schema).not.toHaveProperty('maxLength');
-    expect(schema2._schema).toHaveProperty('maxLength', 20);
-});
-
-test('maxLength - 5', () => {
-    const schema1 = string().maxLength(20);
-    const schema2 = schema1.maxLength(20);
-    const equal = (schema1 as any) === schema2;
-    expect(equal).toEqual(true);
-    expect(schema1._schema).toHaveProperty('maxLength', 20);
-    expect(schema2._schema).toHaveProperty('maxLength', 20);
-});
-
-test('maxLength - 6', () => {
-    const schema1 = string().maxLength(20);
-    const schema2 = schema1.clearMaxLength();
-    const equal = (schema1 as any) === schema2;
-    expect(equal).toEqual(false);
-    expect(schema1._schema).toHaveProperty('maxLength', 20);
-    expect(schema2._schema).not.toHaveProperty('maxLength');
-});
-
-test('maxLength - 7', () => {
-    const schema1 = string();
-    const schema2 = schema1.clearMaxLength();
-    const equal = (schema1 as any) === schema2;
-    expect(equal).toEqual(true);
-    expect(schema1._schema).not.toHaveProperty('maxLength');
-    expect(schema2._schema).not.toHaveProperty('maxLength');
-});
-
-test('maxLength - 8', () => {
-    const schema1 = string().clearMaxLength();
-    const schema2 = schema1.clearMaxLength();
-    const equal = (schema1 as any) === schema2;
-    expect(equal).toEqual(true);
-    expect(schema1._schema).not.toHaveProperty('maxLength');
-    expect(schema2._schema).not.toHaveProperty('maxLength');
-});
-
-test('minLength,max - 1', () => {
-    const schema = string().minLength(20).maxLength(30);
-    expect(schema._schema).toHaveProperty('minLength', 20);
-    expect(schema._schema).toHaveProperty('maxLength', 30);
-});
-
-test('Clone', () => {
-    const schema1 = string()
-        .minLength(20)
-        .maxLength(30)
-        .addValidator(() => ({ valid: true }));
-    const schema2 = schema1.clone();
-    const equal = (schema1 as any) === schema2;
-    expect(equal).toEqual(false);
-    const equal2 = deepEqual(
-        (schema1 as any)._schema,
-        (schema2 as any)._schema
-    );
-    expect(equal2).toEqual(true);
-});