@cleverbrush/schema 0.0.16 → 1.0.0-beta.0

package/src/builders/SchemaBuilder.test.ts

@@ -0,0 +1,73 @@
+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

@@ -0,0 +1,135 @@
+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

@@ -0,0 +1,318 @@
+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);
+});