@cleverbrush/schema 0.0.17 → 1.0.0-beta.1

package/src/builders/ArraySchemaBuilder.test.ts

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

@@ -0,0 +1,381 @@
+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();