@cleverbrush/schema 1.0.0-beta.5 → 1.0.0

package/src/builders/ArraySchemaBuilder.test.ts

@@ -1,270 +0,0 @@
-import { Schema } from '../schema.js';
-import { array } from './ArraySchemaBuilder.js';
-import { number } from './NumberSchemaBuilder.js';
-
-test('Clean', () => {
-    const schema = array();
-    expect(schema).toHaveProperty('type', 'array');
-    expect(schema).toHaveProperty('isRequired', true);
-    expect(schema).toHaveProperty('isNullable', false);
-});
-
-test('optional', () => {
-    const schema = array().optional();
-    expect(schema).toHaveProperty('type', 'array');
-    expect(schema).toHaveProperty('isRequired', false);
-});
-
-test('optional - 2', () => {
-    const schema = array().optional().required();
-    expect(schema).toHaveProperty('type', 'array');
-    expect(schema).toHaveProperty('isRequired', true);
-});
-
-test('optional - 3', () => {
-    const schema1 = array();
-    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 = array().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 = array();
-    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 = array().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 = array().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', () => {
-    const schema = array().nullable();
-    expect(schema).toHaveProperty('type', 'array');
-    expect(schema).toHaveProperty('isNullable', true);
-});
-
-test('nullable - 2', () => {
-    const schema = array().nullable().notNullable();
-    expect(schema).toHaveProperty('type', 'array');
-    expect(schema).toHaveProperty('isNullable', false);
-});
-
-test('nullable - 3', () => {
-    const schema1 = array();
-    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 = array().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 = array();
-    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 = array();
-    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 = array().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('ofType - 1', () => {
-    const s: Schema = {
-        type: 'number'
-    };
-    const schema = array().ofType(s)._schema;
-    expect(schema).toHaveProperty('type', 'array');
-    expect(schema).toHaveProperty('ofType', s);
-});
-
-test('ofType - 2', () => {
-    const s: Schema = {
-        type: 'array'
-    };
-    const schema = array().ofType(s).clearOfType()._schema;
-    expect(schema).toHaveProperty('type', 'array');
-    expect(schema).not.toHaveProperty('ofType');
-});
-
-test('ofType - 3', () => {
-    const schema1 = array();
-    const schema2 = schema1.ofType(number());
-    const equal = (schema1 as any) === schema2;
-    expect(equal).toEqual(false);
-});
-
-test('ofType - 4', () => {
-    const schema1 = array().ofType(number());
-    const schema2 = schema1.ofType(number());
-    const equal = (schema1 as any) === schema2;
-    expect(equal).toEqual(false);
-});
-
-test('ofType - 5', () => {
-    const schema1 = array().ofType(number());
-    const schema2 = schema1.clone();
-    const equal = schema1._schema.ofType === schema2._schema.ofType;
-    expect(equal).toEqual(false);
-});
-
-test('ofType - 6', () => {
-    const schema1 = array().ofType(number());
-    const schema2 = schema1.clearOfType();
-    const equal = (schema1 as any) === schema2;
-    expect(equal).toEqual(false);
-});
-
-test('ofType - 7', () => {
-    const schema1 = array().ofType(number()).clearOfType();
-    const schema2 = schema1.clearOfType();
-    const equal = (schema1 as any) === schema2;
-    expect(equal).toEqual(true);
-});
-
-test('maxLength - 1', () => {
-    const schema = array()._schema;
-    expect(schema).toHaveProperty('type', 'array');
-    expect(schema).not.toHaveProperty('maxLength');
-});
-
-test('maxLength - 2', () => {
-    const s: Schema = {
-        type: 'array'
-    };
-    const schema = array().ofType(s).maxLength(10)._schema;
-    expect(schema).toHaveProperty('type', 'array');
-    expect(schema).toHaveProperty('maxLength', 10);
-});
-
-test('maxLength - 3', () => {
-    const s: Schema = {
-        type: 'array'
-    };
-    const schema = array().ofType(s).maxLength(10).clearMaxLength()._schema;
-    expect(schema).toHaveProperty('type', 'array');
-    expect(schema).not.toHaveProperty('maxLength');
-});
-
-test('maxLength - 4', () => {
-    const schema1 = array().maxLength(10).clearMaxLength();
-    const schema2 = schema1.clearMaxLength();
-    const equal = (schema1 as any) === schema2;
-    expect(equal).toEqual(true);
-});
-
-test('maxLength - 5', () => {
-    const schema1 = array().maxLength(20);
-    const schema2 = schema1.clearMaxLength();
-    const equal = (schema1 as any) === schema2;
-    expect(equal).toEqual(false);
-});
-
-test('minLength - 1', () => {
-    const schema = array()._schema;
-    expect(schema).toHaveProperty('type', 'array');
-    expect(schema).not.toHaveProperty('minLength');
-});
-
-test('minLength - 2', () => {
-    const s: Schema = {
-        type: 'array'
-    };
-    const schema = array().ofType(s).minLength(10)._schema;
-    expect(schema).toHaveProperty('type', 'array');
-    expect(schema).toHaveProperty('minLength', 10);
-});
-
-test('minLength - 3', () => {
-    const s: Schema = {
-        type: 'array'
-    };
-    const schema = array().ofType(s).minLength(10).clearMinLength()._schema;
-    expect(schema).toHaveProperty('type', 'array');
-    expect(schema).not.toHaveProperty('minLength');
-});
-
-test('minLength - 4', () => {
-    const schema1 = array().minLength(10).clearMinLength();
-    const schema2 = schema1.clearMinLength();
-    const equal = (schema1 as any) === schema2;
-    expect(equal).toEqual(true);
-});
-
-test('minLength - 5', () => {
-    const schema1 = array().minLength(20);
-    const schema2 = schema1.clearMinLength();
-    const equal = (schema1 as any) === schema2;
-    expect(equal).toEqual(false);
-});
-
-test('minLength - 6', () => {
-    const schema1 = array().minLength(20).clearMinLength();
-    const schema2 = schema1.clearMinLength();
-    const equal = (schema1 as any) === schema2;
-    expect(equal).toEqual(true);
-});
-
-test('min/max lengths - 1', () => {
-    const s: Schema = {
-        type: 'array'
-    };
-    const schema = array().ofType(s).minLength(10).maxLength(100)._schema;
-    expect(schema).toHaveProperty('type', 'array');
-    expect(schema).toHaveProperty('minLength', 10);
-    expect(schema).toHaveProperty('maxLength', 100);
-});

package/src/builders/ArraySchemaBuilder.ts

@@ -1,381 +0,0 @@
-import { ISchemaBuilder, SchemaBuilder } from './SchemaBuilder.js';
-import { Schema, Validator } from '../schema.js';
-import { defaultSchemas } from '../defaultSchemas.js';
-
-export interface IArraySchemaBuilder<
-    TRequired extends boolean = true,
-    TNullable extends boolean = false,
-    TOfType extends Schema | undefined = undefined,
-    TMaxLength extends number | undefined = undefined,
-    TMinLength extends number | undefined = undefined
-> extends ISchemaBuilder<TRequired, TNullable> {
-    optional(): IArraySchemaBuilder<
-        false,
-        TNullable,
-        TOfType,
-        TMaxLength,
-        TMinLength
-    >;
-    required(): IArraySchemaBuilder<
-        true,
-        TNullable,
-        TOfType,
-        TMaxLength,
-        TMinLength
-    >;
-    ofType<T extends Schema>(
-        schema: T
-    ): IArraySchemaBuilder<TRequired, TNullable, T, TMaxLength, TMinLength>;
-    nullable(): IArraySchemaBuilder<
-        TRequired,
-        true,
-        TOfType,
-        TMaxLength,
-        TMinLength
-    >;
-    notNullable(): IArraySchemaBuilder<
-        TRequired,
-        false,
-        TOfType,
-        TMaxLength,
-        TMinLength
-    >;
-    clearOfType(): IArraySchemaBuilder<
-        TRequired,
-        TNullable,
-        undefined,
-        TMaxLength,
-        TMinLength
-    >;
-
-    maxLength<T extends number>(
-        length: T
-    ): IArraySchemaBuilder<TRequired, TNullable, TOfType, T, TMinLength>;
-    clearMaxLength(): IArraySchemaBuilder<
-        TRequired,
-        TNullable,
-        TOfType,
-        undefined,
-        TMinLength
-    >;
-    minLength<T extends number>(
-        length: T
-    ): IArraySchemaBuilder<TRequired, TNullable, TOfType, TMaxLength, T>;
-
-    clearMinLength(): IArraySchemaBuilder<
-        TRequired,
-        TNullable,
-        TOfType,
-        TMaxLength,
-        TMinLength
-    >;
-}
-
-class ArraySchemaBuilder<
-        TRequired extends boolean = true,
-        TNullable extends boolean = false,
-        TOfType extends Schema | undefined = undefined,
-        TMaxLength extends number | undefined = undefined,
-        TMinLength extends number | undefined = undefined
-    >
-    extends SchemaBuilder<TRequired, TNullable>
-    implements
-        IArraySchemaBuilder<
-            TRequired,
-            TNullable,
-            TOfType,
-            TMaxLength,
-            TMinLength
-        >
-{
-    public clone(): this {
-        return ArraySchemaBuilder.create(this._schema as any) as this;
-    }
-
-    public get _schema(): Schema {
-        return Object.assign(
-            {
-                type: this.type
-            },
-            this.getCommonSchema(),
-            typeof this._ofType !== 'undefined'
-                ? {
-                      ofType: this._ofType as any
-                  }
-                : {},
-            typeof this._minLength !== 'undefined'
-                ? { minLength: this._minLength }
-                : {},
-            typeof this._maxLength !== 'undefined'
-                ? { maxLength: this._maxLength }
-                : {}
-        );
-    }
-
-    public static create<
-        TRequired extends boolean = true,
-        TNullable extends boolean = false,
-        TOfType extends Schema | undefined = undefined,
-        TMaxLength extends number | undefined = undefined,
-        TMinLength extends number | undefined = undefined
-    >(obj?: {
-        isRequired: TRequired;
-        isNullable: TNullable;
-        ofType?: TOfType;
-        maxLength?: TMaxLength;
-        minLength?: TMinLength;
-        validators?: Validator[];
-        preprocessor?:
-            | ((value: unknown) => unknown | Promise<unknown>)
-            | string;
-    }): IArraySchemaBuilder<
-        TRequired,
-        TNullable,
-        TOfType,
-        TMaxLength,
-        TMinLength
-    > {
-        return new ArraySchemaBuilder(obj as any);
-    }
-
-    private constructor(obj: {
-        isRequired: TRequired;
-        isNullable: TNullable;
-        ofType?: TOfType;
-        maxLength?: TMaxLength;
-        minLength?: TMinLength;
-        validators?: Validator[];
-        preprocessor?:
-            | ((value: unknown) => unknown | Promise<unknown>)
-            | string;
-    }) {
-        super(obj);
-        if (typeof obj === 'object' && obj) {
-            if (typeof obj.ofType !== 'undefined') {
-                this._ofType =
-                    obj.ofType instanceof SchemaBuilder
-                        ? obj.ofType.clone()
-                        : { ...(obj.ofType as any) };
-            }
-            if (typeof obj.maxLength !== 'undefined') {
-                this._maxLength = obj.maxLength;
-            }
-            if (typeof obj.minLength !== 'undefined') {
-                this._minLength = obj.minLength;
-            }
-        } else {
-            const defaultSchema = defaultSchemas['array'] as any;
-            this.isRequired = defaultSchema.isRequired;
-            this.isNullable = defaultSchema.isNullable;
-        }
-    }
-
-    protected readonly type = 'array';
-
-    protected _ofType?: TOfType;
-    protected _maxLength?: TMaxLength;
-    protected _minLength?: TMinLength;
-
-    optional(): IArraySchemaBuilder<
-        false,
-        TNullable,
-        TOfType,
-        TMaxLength,
-        TMinLength
-    > {
-        if (this.isRequired === false) {
-            return this as IArraySchemaBuilder<
-                false,
-                TNullable,
-                TOfType,
-                TMaxLength,
-                TMinLength
-            >;
-        }
-
-        return ArraySchemaBuilder.create({
-            ...(this._schema as any),
-            isRequired: false
-        });
-    }
-
-    required(): IArraySchemaBuilder<
-        true,
-        TNullable,
-        TOfType,
-        TMaxLength,
-        TMinLength
-    > {
-        if (this.isRequired === true) {
-            return this as IArraySchemaBuilder<
-                true,
-                TNullable,
-                TOfType,
-                TMaxLength,
-                TMinLength
-            >;
-        }
-
-        return ArraySchemaBuilder.create({
-            ...(this._schema as any),
-            isRequired: true
-        });
-    }
-
-    nullable(): IArraySchemaBuilder<
-        TRequired,
-        true,
-        TOfType,
-        TMaxLength,
-        TMinLength
-    > {
-        if (this._isNullable === true) {
-            return this as IArraySchemaBuilder<
-                TRequired,
-                true,
-                TOfType,
-                TMaxLength,
-                TMinLength
-            >;
-        }
-        return ArraySchemaBuilder.create({
-            ...(this._schema as any),
-            isNullable: true
-        });
-    }
-
-    notNullable(): IArraySchemaBuilder<
-        TRequired,
-        false,
-        TOfType,
-        TMaxLength,
-        TMinLength
-    > {
-        if (this.isNullable === false) {
-            return this as IArraySchemaBuilder<
-                TRequired,
-                false,
-                TOfType,
-                TMaxLength,
-                TMinLength
-            >;
-        }
-        return ArraySchemaBuilder.create({
-            ...(this._schema as any),
-            isNullable: false
-        });
-    }
-
-    ofType<T extends Schema>(
-        schema: T
-    ): IArraySchemaBuilder<TRequired, TNullable, T, TMaxLength, TMinLength> {
-        return ArraySchemaBuilder.create({
-            ...(this._schema as any),
-            ofType: schema
-        });
-    }
-
-    clearOfType(): IArraySchemaBuilder<
-        TRequired,
-        TNullable,
-        undefined,
-        TMaxLength,
-        TMinLength
-    > {
-        if (typeof this._ofType === 'undefined') {
-            return this as IArraySchemaBuilder<
-                TRequired,
-                TNullable,
-                undefined,
-                TMaxLength,
-                TMinLength
-            >;
-        }
-        return ArraySchemaBuilder.create({
-            ...(this._schema as any),
-            ofType: undefined
-        });
-    }
-
-    maxLength<T extends number>(
-        length: T
-    ): IArraySchemaBuilder<TRequired, TNullable, TOfType, T, TMinLength> {
-        if ((this._maxLength as any) === length) {
-            return this as any as IArraySchemaBuilder<
-                TRequired,
-                TNullable,
-                TOfType,
-                T,
-                TMinLength
-            >;
-        }
-        return ArraySchemaBuilder.create({
-            ...(this._schema as any),
-            maxLength: length
-        });
-    }
-
-    clearMaxLength(): IArraySchemaBuilder<
-        TRequired,
-        TNullable,
-        TOfType,
-        undefined,
-        TMinLength
-    > {
-        if (typeof this._maxLength === 'undefined') {
-            return this as IArraySchemaBuilder<
-                TRequired,
-                TNullable,
-                TOfType,
-                undefined,
-                TMinLength
-            >;
-        }
-        return ArraySchemaBuilder.create({
-            ...(this._schema as any),
-            maxLength: undefined
-        });
-    }
-
-    minLength<T extends number>(
-        length: T
-    ): IArraySchemaBuilder<TRequired, TNullable, TOfType, TMaxLength, T> {
-        if ((this._minLength as any) === length) {
-            return this as any as IArraySchemaBuilder<
-                TRequired,
-                TNullable,
-                TOfType,
-                TMaxLength,
-                T
-            >;
-        }
-        return ArraySchemaBuilder.create({
-            ...(this._schema as any),
-            minLength: length
-        });
-    }
-
-    clearMinLength(): IArraySchemaBuilder<
-        TRequired,
-        TNullable,
-        TOfType,
-        TMaxLength,
-        TMinLength
-    > {
-        if (typeof this._minLength === 'undefined') {
-            return this as IArraySchemaBuilder<
-                TRequired,
-                TNullable,
-                TOfType,
-                TMaxLength,
-                TMinLength
-            >;
-        }
-        return ArraySchemaBuilder.create({
-            ...(this._schema as any),
-            minLength: undefined
-        });
-    }
-}
-
-export const array = () => ArraySchemaBuilder.create();