@cleverbrush/schema 0.0.17 → 1.0.0-beta.1

package/src/builders/StringSchemaBuilder.ts

@@ -0,0 +1,392 @@
+import { ISchemaBuilder, SchemaBuilder } from './SchemaBuilder.js';
+import { Schema, Validator } from '../schema.js';
+import { defaultSchemas } from '../defaultSchemas.js';
+
+export interface IStringSchemaBuilder<
+    TRequired extends boolean = true,
+    TNullable extends boolean = false,
+    TMinLength extends number | undefined = undefined,
+    TMaxLength extends number | undefined = undefined,
+    TEqualsTo extends string | undefined = undefined
+> extends ISchemaBuilder<TRequired, TNullable> {
+    optional(): IStringSchemaBuilder<
+        false,
+        TNullable,
+        TMinLength,
+        TMaxLength,
+        TEqualsTo
+    >;
+    required(): IStringSchemaBuilder<
+        true,
+        TNullable,
+        TMinLength,
+        TMaxLength,
+        TEqualsTo
+    >;
+    nullable(): IStringSchemaBuilder<
+        TRequired,
+        true,
+        TMinLength,
+        TMaxLength,
+        TEqualsTo
+    >;
+    notNullable(): IStringSchemaBuilder<
+        TRequired,
+        false,
+        TMinLength,
+        TMaxLength,
+        TEqualsTo
+    >;
+    minLength<K extends number>(
+        val: K
+    ): IStringSchemaBuilder<TRequired, TNullable, K, TMaxLength, TEqualsTo>;
+    clearMinLength(): IStringSchemaBuilder<
+        TRequired,
+        TNullable,
+        undefined,
+        TMaxLength,
+        TEqualsTo
+    >;
+    maxLength<K extends number>(
+        val: K
+    ): IStringSchemaBuilder<TRequired, TNullable, TMinLength, K, TEqualsTo>;
+    clearMaxLength(): IStringSchemaBuilder<
+        TRequired,
+        TNullable,
+        TMinLength,
+        undefined,
+        TEqualsTo
+    >;
+    equals<T extends string>(
+        val: T
+    ): IStringSchemaBuilder<TRequired, TNullable, TMinLength, TMaxLength, T>;
+    clearEquals(): IStringSchemaBuilder<
+        TRequired,
+        TNullable,
+        TMinLength,
+        TMaxLength,
+        undefined
+    >;
+}
+
+class StringSchemaBuilder<
+        TRequired extends boolean = true,
+        TNullable extends boolean = false,
+        TMinLength extends number | undefined = undefined,
+        TMaxLength extends number | undefined = undefined,
+        TEqualsTo extends string | undefined = undefined
+    >
+    extends SchemaBuilder<TRequired, TNullable>
+    implements
+        IStringSchemaBuilder<
+            TRequired,
+            TNullable,
+            TMinLength,
+            TMaxLength,
+            TEqualsTo
+        >
+{
+    protected _minLength?: TMinLength;
+    protected _maxLength?: TMaxLength;
+    protected _equals?: TEqualsTo;
+
+    protected readonly type = 'string';
+
+    public clone(): this {
+        return StringSchemaBuilder.create(this._schema as any) as this;
+    }
+
+    public get _schema(): 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 } : {}
+        );
+    }
+
+    public optional(): IStringSchemaBuilder<
+        false,
+        TNullable,
+        TMinLength,
+        TMaxLength,
+        TEqualsTo
+    > {
+        if (this.isRequired === false) {
+            return this as IStringSchemaBuilder<
+                false,
+                TNullable,
+                TMinLength,
+                TMaxLength,
+                TEqualsTo
+            >;
+        }
+        return StringSchemaBuilder.create({
+            ...(this._schema as any),
+            isRequired: false
+        });
+    }
+
+    public required(): IStringSchemaBuilder<
+        true,
+        TNullable,
+        TMinLength,
+        TMaxLength,
+        TEqualsTo
+    > {
+        if (this.isRequired === true) {
+            return this as any as IStringSchemaBuilder<
+                true,
+                TNullable,
+                TMinLength,
+                TMaxLength,
+                TEqualsTo
+            >;
+        }
+
+        return StringSchemaBuilder.create({
+            ...(this._schema as any),
+            isRequired: true
+        });
+    }
+
+    public nullable(): IStringSchemaBuilder<
+        TRequired,
+        true,
+        TMinLength,
+        TMaxLength,
+        TEqualsTo
+    > {
+        if (this.isNullable === true) {
+            return this as any as IStringSchemaBuilder<
+                TRequired,
+                true,
+                TMinLength,
+                TMaxLength,
+                TEqualsTo
+            >;
+        }
+        return StringSchemaBuilder.create({
+            ...(this._schema as any),
+            isNullable: true
+        });
+    }
+
+    public notNullable(): IStringSchemaBuilder<
+        TRequired,
+        false,
+        TMinLength,
+        TMaxLength,
+        TEqualsTo
+    > {
+        if (this.isNullable === false) {
+            return this as any as IStringSchemaBuilder<
+                TRequired,
+                false,
+                TMinLength,
+                TMaxLength,
+                TEqualsTo
+            >;
+        }
+        return StringSchemaBuilder.create({
+            ...(this._schema as any),
+            isNullable: false
+        });
+    }
+
+    public minLength<K extends number>(
+        val: K
+    ): IStringSchemaBuilder<TRequired, TNullable, K, TMaxLength, TEqualsTo> {
+        if ((this._minLength as any) === val) {
+            return this as any as IStringSchemaBuilder<
+                TRequired,
+                TNullable,
+                K,
+                TMaxLength,
+                TEqualsTo
+            >;
+        }
+        return StringSchemaBuilder.create({
+            ...(this._schema as any),
+            minLength: val
+        });
+    }
+
+    public clearMinLength(): IStringSchemaBuilder<
+        TRequired,
+        TNullable,
+        undefined,
+        TMaxLength,
+        TEqualsTo
+    > {
+        if (typeof this._minLength === 'undefined') {
+            return this as any as IStringSchemaBuilder<
+                TRequired,
+                TNullable,
+                undefined,
+                TMaxLength,
+                TEqualsTo
+            >;
+        }
+        return StringSchemaBuilder.create({
+            ...(this._schema as any),
+            minLength: undefined
+        });
+    }
+
+    public maxLength<K extends number>(
+        val: K
+    ): IStringSchemaBuilder<TRequired, TNullable, TMinLength, K, TEqualsTo> {
+        if ((this._maxLength as any) === val) {
+            return this as any as IStringSchemaBuilder<
+                TRequired,
+                TNullable,
+                TMinLength,
+                K,
+                TEqualsTo
+            >;
+        }
+        return StringSchemaBuilder.create({
+            ...(this._schema as any),
+            maxLength: val
+        });
+    }
+
+    public clearMaxLength(): IStringSchemaBuilder<
+        TRequired,
+        TNullable,
+        TMinLength,
+        undefined,
+        TEqualsTo
+    > {
+        if (typeof this._maxLength === 'undefined') {
+            return this as IStringSchemaBuilder<
+                TRequired,
+                TNullable,
+                TMinLength,
+                undefined,
+                TEqualsTo
+            >;
+        }
+        return StringSchemaBuilder.create({
+            ...(this._schema as any),
+            maxLength: undefined
+        });
+    }
+
+    public equals<T extends string>(
+        val: T
+    ): IStringSchemaBuilder<TRequired, TNullable, TMinLength, TMaxLength, T> {
+        if ((this._equals as any) === val) {
+            return this as any as IStringSchemaBuilder<
+                TRequired,
+                TNullable,
+                TMinLength,
+                TMaxLength,
+                T
+            >;
+        }
+
+        return StringSchemaBuilder.create({
+            ...(this._schema as any),
+            equals: val as T
+        });
+    }
+
+    public clearEquals(): IStringSchemaBuilder<
+        TRequired,
+        TNullable,
+        TMinLength,
+        TMaxLength,
+        undefined
+    > {
+        if (typeof this._equals === 'undefined') {
+            return this as IStringSchemaBuilder<
+                TRequired,
+                TNullable,
+                TMinLength,
+                TMaxLength,
+                undefined
+            >;
+        }
+        return StringSchemaBuilder.create({
+            ...(this._schema as any),
+            equals: undefined
+        });
+    }
+
+    public static create<
+        TRequired extends boolean = true,
+        TNullable extends boolean = false,
+        TMinLength extends number | undefined = undefined,
+        TMaxLength extends number | undefined = undefined,
+        TEqualsTo extends string | undefined = undefined
+    >(obj?: {
+        isRequired: TRequired;
+        isNullable: TNullable;
+        minLength?: TMinLength;
+        maxLength?: TMaxLength;
+        equals?: TEqualsTo;
+        validators?: Validator[];
+        preprocessor?:
+            | ((value: unknown) => unknown | Promise<unknown>)
+            | string;
+    }): IStringSchemaBuilder<
+        TRequired,
+        TNullable,
+        TMinLength,
+        TMaxLength,
+        TEqualsTo
+    > {
+        return new StringSchemaBuilder(obj as any);
+    }
+
+    private constructor(obj: {
+        isRequired: TRequired;
+        isNullable: TNullable;
+        minLength: TMinLength;
+        maxLength: TMaxLength;
+        equals: TEqualsTo;
+        validators?: Validator[];
+        preprocessor?:
+            | ((value: unknown) => unknown | Promise<unknown>)
+            | string;
+    }) {
+        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['string'] as any;
+            this.isRequired = defaultSchema.isRequired;
+            this.isNullable = defaultSchema.isNullable;
+        }
+    }
+}
+
+export const string = <T extends string | undefined = undefined>(
+    equals?: T
+): IStringSchemaBuilder<
+    true,
+    false,
+    undefined,
+    undefined,
+    T extends undefined ? undefined : T
+> => {
+    const res = StringSchemaBuilder.create();
+    return typeof equals === 'string' ? res.equals(equals) : res;
+};

package/src/builders/UnionSchemaBuilder.test.ts

@@ -0,0 +1,162 @@
+import { union } from './UnionSchemaBuilder.js';
+import { string } from './StringSchemaBuilder.js';
+import { number } from './NumberSchemaBuilder.js';
+
+test('Clean', () => {
+    const schema = union(string())._schema;
+    expect(schema).toHaveProperty('type', 'union');
+    expect(schema).toHaveProperty('variants');
+    expect(schema).toHaveProperty('variants.length', 1);
+    expect(schema).toHaveProperty('isRequired', true);
+    expect(schema).toHaveProperty('isNullable', false);
+});
+
+test('optional', () => {
+    const schema = union(number()).optional();
+    expect(schema).toHaveProperty('isRequired', false);
+});
+
+test('optional - 2', () => {
+    const schema = union(number()).optional().required();
+    expect(schema).toHaveProperty('isRequired', true);
+});
+
+test('optional - 3', () => {
+    const schema1 = union(number());
+    const schema2 = schema1.optional();
+    const e = (schema1 as any) === schema2;
+    const isRequiredEqual = (schema1 as any).isRequired !== schema2.isRequired;
+    expect(e).toEqual(false);
+    expect(isRequiredEqual).toEqual(true);
+});
+
+test('optional - 4', () => {
+    const schema1 = union(number()).optional();
+    const schema2 = schema1.optional();
+    const e = (schema1 as any) === schema2;
+    const isRequiredEqual = (schema1 as any).isRequired === schema2.isRequired;
+    expect(e).toEqual(true);
+    expect(isRequiredEqual).toEqual(true);
+});
+
+test('optional - 5', () => {
+    const schema1 = union(number());
+    const schema2 = schema1.required();
+    const e = (schema1 as any) === schema2;
+    const isRequiredEqual = (schema1 as any).isRequired === schema2.isRequired;
+    expect(e).toEqual(true);
+    expect(isRequiredEqual).toEqual(true);
+});
+
+test('optional - 6', () => {
+    const schema1 = union(number()).optional();
+    const schema2 = schema1.required();
+    const e = (schema1 as any) === schema2;
+    const isRequiredEqual = (schema1 as any).isRequired === schema2.isRequired;
+    expect(e).toEqual(false);
+    expect(isRequiredEqual).toEqual(false);
+});
+
+test('optional - 7', () => {
+    const schema1 = union(number()).optional().required();
+    const schema2 = schema1.required();
+    const e = (schema1 as any) === schema2;
+    const isRequiredEqual = (schema1 as any).isRequired === schema2.isRequired;
+    expect(e).toEqual(true);
+    expect(isRequiredEqual).toEqual(true);
+});
+
+test('nullable - 1', () => {
+    const schema = union(number()).nullable();
+    expect(schema).toHaveProperty('isNullable', true);
+});
+
+test('nullable - 2', () => {
+    const schema = union(number()).nullable().notNullable();
+    expect(schema).toHaveProperty('isNullable', false);
+});
+
+test('nullable - 3', () => {
+    const schema1 = union(string());
+    const schema2 = schema1.nullable();
+    const e = (schema1 as any) === schema2;
+    const isNullableEqual = (schema1 as any).isNullable !== schema2.isNullable;
+    expect(e).toEqual(false);
+    expect(isNullableEqual).toEqual(true);
+});
+
+test('nullable - 4', () => {
+    const schema1 = union(number()).nullable();
+    const schema2 = schema1.nullable();
+    const e = (schema1 as any) === schema2;
+    const isNullableEqual = (schema1 as any).isNullable === schema2.isNullable;
+    expect(e).toEqual(true);
+    expect(isNullableEqual).toEqual(true);
+});
+
+test('nullable - 5', () => {
+    const schema1 = union(number());
+    const schema2 = schema1.nullable();
+    const e = (schema1 as any) === schema2;
+    const isNullableEqual = (schema1 as any).isNullable === schema2.isNullable;
+    expect(e).toEqual(false);
+    expect(isNullableEqual).toEqual(false);
+});
+
+test('nullable - 6', () => {
+    const schema1 = union(number());
+    const schema2 = schema1.notNullable();
+    const e = (schema1 as any) === schema2;
+    const isNullableEqual = (schema1 as any).isNullable === schema2.isNullable;
+    expect(e).toEqual(true);
+    expect(isNullableEqual).toEqual(true);
+});
+
+test('nullable - 7', () => {
+    const schema1 = union(number()).nullable();
+    const schema2 = schema1.notNullable();
+    const e = (schema1 as any) === schema2;
+    const isNullableEqual = (schema1 as any).isNullable === schema2.isNullable;
+    expect(e).toEqual(false);
+    expect(isNullableEqual).toEqual(false);
+});
+test('or - 1', () => {
+    const schema1 = union(string());
+    const schema2 = schema1.or(number());
+    const equal = (schema1 as any) === schema2;
+    expect(equal).toEqual(false);
+    expect(schema2._schema).toHaveProperty('type', 'union');
+    expect(schema2._schema).toHaveProperty('variants');
+    expect(schema2._schema).toHaveProperty('variants.length', 2);
+    expect(schema2._schema).toHaveProperty('isRequired', true);
+    expect(schema2._schema).toHaveProperty('isNullable', false);
+});
+
+test('or - 2', () => {
+    const schema1 = union(string()).or(number());
+    const schema2 = schema1.clearVariants();
+    const equal = (schema1 as any) === schema2;
+    expect(equal).toEqual(false);
+    expect(schema2._schema).toHaveProperty('type', 'union');
+    expect(schema2._schema).toHaveProperty('variants');
+    expect(schema2._schema).toHaveProperty('variants.length', 0);
+    expect(schema2._schema).toHaveProperty('isRequired', true);
+    expect(schema2._schema).toHaveProperty('isNullable', false);
+});
+
+test('or - 3', () => {
+    const schema1 = union(string()).or(number()).clearVariants();
+    const schema2 = schema1.clearVariants();
+    const equal = (schema1 as any) === schema2;
+    expect(equal).toEqual(true);
+    expect(schema2._schema).toHaveProperty('type', 'union');
+    expect(schema2._schema).toHaveProperty('variants');
+    expect(schema2._schema).toHaveProperty('variants.length', 0);
+    expect(schema2._schema).toHaveProperty('isRequired', true);
+    expect(schema2._schema).toHaveProperty('isNullable', false);
+});
+
+test('or - 4', () => {
+    const schema1 = union(string('123'), string('321'));
+    expect(schema1._schema.variants.length).toEqual(2);
+});

package/src/builders/UnionSchemaBuilder.ts

@@ -0,0 +1,154 @@
+import { Schema } from '../schema.js';
+import { SchemaBuilder, 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, []>;
+}
+
+class UnionSchemaBuilder<
+        TRequired extends boolean = true,
+        TNullable extends boolean = false,
+        TVariants extends any[] = []
+    >
+    extends SchemaBuilder<TRequired, TNullable>
+    implements IUnionSchemaBuilder<TRequired, TNullable, TVariants>
+{
+    protected readonly type = 'union';
+
+    get _schema(): Schema {
+        return Object.assign(
+            {
+                type: this.type
+            },
+            this.getCommonSchema(),
+            {
+                variants: this._variants
+            }
+        );
+    }
+
+    public clone(): this {
+        return UnionSchemaBuilder.create(this._schema as any) as this;
+    }
+
+    protected _variants: TVariants;
+
+    public static create<
+        TRequired extends boolean = true,
+        TNullable extends boolean = false,
+        TSchemas extends Schema[] = []
+    >(obj: {
+        isRequired: TRequired;
+        isNullable: TNullable;
+        variants?: TSchemas;
+    }): IUnionSchemaBuilder<TRequired, TNullable, TSchemas> {
+        return new UnionSchemaBuilder(obj);
+    }
+
+    private constructor(obj: {
+        isRequired: TRequired;
+        isNullable: TNullable;
+        variants?: TVariants;
+    }) {
+        super(obj);
+        this._variants = [] as TVariants;
+        if (Array.isArray(obj.variants)) {
+            for (let i = 0; i < obj.variants.length; i++) {
+                this._variants.push(obj.variants[i]);
+            }
+        }
+    }
+
+    optional(): IUnionSchemaBuilder<false, TNullable, TVariants> {
+        if (this.isRequired === false) {
+            return this as IUnionSchemaBuilder<false, TNullable, TVariants>;
+        }
+        return UnionSchemaBuilder.create({
+            ...(this._schema as any),
+            isRequired: false
+        });
+    }
+
+    required(): IUnionSchemaBuilder<true, TNullable, TVariants> {
+        if (this.isRequired === true) {
+            return this as IUnionSchemaBuilder<true, TNullable, TVariants>;
+        }
+        return UnionSchemaBuilder.create({
+            ...(this._schema as any),
+            isRequired: true
+        });
+    }
+
+    nullable(): IUnionSchemaBuilder<TRequired, true, TVariants> {
+        if (this.isNullable === true) {
+            return this as IUnionSchemaBuilder<TRequired, true, TVariants>;
+        }
+        return UnionSchemaBuilder.create({
+            ...(this._schema as any),
+            isNullable: true
+        });
+    }
+
+    notNullable(): IUnionSchemaBuilder<TRequired, false, TVariants> {
+        if (this.isNullable === false) {
+            return this as IUnionSchemaBuilder<TRequired, false, TVariants>;
+        }
+        return UnionSchemaBuilder.create({
+            ...(this._schema as any),
+            isNullable: false
+        });
+    }
+
+    or<T>(
+        schema: T
+    ): IUnionSchemaBuilder<TRequired, TNullable, [...TVariants, T]> {
+        return UnionSchemaBuilder.create({
+            ...(this._schema as any),
+            variants: [...this._variants, schema]
+        });
+    }
+
+    clearVariants(): IUnionSchemaBuilder<TRequired, TNullable, []> {
+        if (this._variants.length === 0)
+            return this as any as IUnionSchemaBuilder<TRequired, TNullable, []>;
+        return UnionSchemaBuilder.create({
+            ...(this._schema as any),
+            variants: []
+        });
+    }
+}
+
+export const union = <
+    T extends ISchemaBuilder,
+    K extends T[],
+    TRequired extends boolean = true,
+    TNullable extends boolean = false
+>(
+    ...schemas: K
+): IUnionSchemaBuilder<TRequired, TNullable, K> => {
+    if (schemas.length < 1) {
+        throw new Error('should provide at least one variant');
+    }
+    let res = UnionSchemaBuilder.create({
+        isRequired: true,
+        isNullable: false,
+        variants: [schemas[0] as any]
+    });
+
+    for (let i = 1; i < schemas.length; i++) {
+        res = res.or(schemas[i]);
+    }
+
+    return res as any;
+};