@cleverbrush/schema 0.0.17 → 1.0.0-beta.1

package/src/builders/BooleanSchemaBuilder.test.ts

@@ -0,0 +1,196 @@
+import { deepEqual } from '@cleverbrush/deep';
+
+import { Schema } from '../schema.js';
+import { boolean } from './BooleanSchemaBuilder.js';
+
+test('Clean', () => {
+    const schema = boolean();
+    expect(schema).toHaveProperty('type', 'boolean');
+    expect(schema).toHaveProperty('isRequired', true);
+    expect(schema).toHaveProperty('isNullable', false);
+});
+
+test('optional', () => {
+    const schema = boolean().optional();
+    expect(schema).toHaveProperty('type', 'boolean');
+    expect(schema).toHaveProperty('isRequired', false);
+});
+
+test('optional - 2', () => {
+    const schema = boolean().optional().required();
+    expect(schema).toHaveProperty('type', 'boolean');
+    expect(schema).toHaveProperty('isRequired', true);
+});
+
+test('optional - 3', () => {
+    const schema1 = boolean();
+    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 = boolean().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 = boolean();
+    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 = boolean().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 = boolean().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 = boolean().nullable();
+    expect(schema).toHaveProperty('type', 'boolean');
+    expect(schema).toHaveProperty('isNullable', true);
+});
+
+test('nullable - 2', () => {
+    const schema = boolean().nullable().notNullable();
+    expect(schema).toHaveProperty('type', 'boolean');
+    expect(schema).toHaveProperty('isNullable', false);
+});
+
+test('nullable - 3', () => {
+    const schema1 = boolean();
+    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 = boolean().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 = boolean();
+    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 = boolean();
+    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 = boolean().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 = boolean().equals(true);
+    expect(schema._schema).toHaveProperty('type', 'boolean');
+    expect(schema._schema).toHaveProperty('equals', true);
+});
+
+test('equals - 2', () => {
+    const schema = boolean().equals(false);
+    expect(schema._schema).toHaveProperty('type', 'boolean');
+    expect(schema._schema).toHaveProperty('equals', false);
+});
+
+test('equals - 3', () => {
+    const schema = boolean();
+    expect(schema._schema).toHaveProperty('type', 'boolean');
+    expect(schema._schema).not.toHaveProperty('equals');
+});
+
+test('equals - 4', () => {
+    const schema = boolean().equals(true).clearEqualsTo();
+    expect(schema._schema).toHaveProperty('type', 'boolean');
+    expect(schema._schema).not.toHaveProperty('equals');
+});
+
+test('equals - 5', () => {
+    const schema1 = boolean().equals(true);
+    const schema2 = schema1.equals(true);
+    const equal = (schema1 as any) === schema2;
+    expect(equal).toEqual(true);
+    expect(schema1._schema).toHaveProperty('equals', true);
+    expect(schema2._schema).toHaveProperty('equals', true);
+});
+
+test('equals - 6', () => {
+    const schema1 = boolean();
+    const schema2 = schema1.equals(true);
+    const equal = (schema1 as any) === schema2;
+    expect(equal).toEqual(false);
+    expect(schema1._schema).not.toHaveProperty('equals');
+    expect(schema2._schema).toHaveProperty('equals', true);
+});
+
+test('equals - 7', () => {
+    const schema1 = boolean();
+    const schema2 = schema1.clearEqualsTo();
+    const equal = (schema1 as any) === schema2;
+    expect(equal).toEqual(true);
+    expect(schema1._schema).not.toHaveProperty('equals');
+    expect(schema2._schema).not.toHaveProperty('equals');
+});
+
+test('equals - 8', () => {
+    const schema1 = boolean().clearEqualsTo();
+    const schema2 = schema1.equals(false);
+    const equal = (schema1 as any) === schema2;
+    expect(equal).toEqual(false);
+    expect(schema1._schema).not.toHaveProperty('equals');
+    expect(schema2._schema).toHaveProperty('equals', false);
+});
+
+test('Clone', () => {
+    const schema1 = boolean()
+        .addValidator(() => ({ valid: true }))
+        .equals(true);
+    const schema2 = schema1.clone();
+    const equal = (schema1 as any) === schema2;
+    expect(equal).toEqual(false);
+    const equal2 = deepEqual(schema1._schema, schema2._schema);
+    expect(equal2).toEqual(true);
+});

package/src/builders/BooleanSchemaBuilder.ts

@@ -0,0 +1,155 @@
+import { Schema, Validator } from '../schema.js';
+import { ISchemaBuilder, SchemaBuilder } from './SchemaBuilder.js';
+import { defaultSchemas } from '../defaultSchemas.js';
+
+export interface IBooleanSchemaBuilder<
+    TRequired extends boolean = true,
+    TNullable extends boolean = false,
+    TEqualsTo extends boolean | undefined = undefined
+> extends ISchemaBuilder<TRequired, TNullable> {
+    equals<T extends boolean>(
+        val: T
+    ): IBooleanSchemaBuilder<TRequired, TNullable, T>;
+    clearEqualsTo(): IBooleanSchemaBuilder<TRequired, TNullable, undefined>;
+    optional(): IBooleanSchemaBuilder<false, TNullable, TEqualsTo>;
+    required(): IBooleanSchemaBuilder<true, TNullable, TEqualsTo>;
+    nullable(): IBooleanSchemaBuilder<TRequired, true, TEqualsTo>;
+    notNullable(): IBooleanSchemaBuilder<TRequired, false, TEqualsTo>;
+}
+
+export class BooleanSchemaBuilder<
+        TRequired extends boolean = true,
+        TNullable extends boolean = false,
+        TEqualsTo extends boolean | undefined = undefined
+    >
+    extends SchemaBuilder<TRequired, TNullable>
+    implements IBooleanSchemaBuilder<TRequired, TNullable, TEqualsTo>
+{
+    protected readonly type = 'boolean';
+
+    public get _schema(): Schema {
+        return Object.assign(
+            {
+                type: this.type
+            },
+            this.getCommonSchema(),
+            typeof this._equals !== 'undefined' ? { equals: this._equals } : {}
+        );
+    }
+
+    public clone(): this {
+        return BooleanSchemaBuilder.create(this._schema as any) as this;
+    }
+
+    public static create<
+        TRequired extends boolean = true,
+        TNullable extends boolean = false,
+        TEqualsTo extends boolean | undefined = undefined
+    >(obj?: {
+        isRequired: TRequired;
+        isNullable: TNullable;
+        equals?: TEqualsTo;
+        validators?: Validator[];
+        preprocessor?:
+            | ((value: unknown) => unknown | Promise<unknown>)
+            | string;
+    }): IBooleanSchemaBuilder<TRequired, TNullable, TEqualsTo> {
+        return new BooleanSchemaBuilder(obj as any);
+    }
+
+    private constructor(obj: {
+        isRequired: TRequired;
+        isNullable: TNullable;
+        equals: TEqualsTo;
+        validators?: Validator[];
+        preprocessor?:
+            | ((value: unknown) => unknown | Promise<unknown>)
+            | string;
+    }) {
+        super(obj);
+        if (typeof obj === 'object' && obj) {
+            if (typeof obj.equals !== 'undefined') {
+                this._equals = obj.equals;
+            }
+        } else {
+            const defaultSchema = defaultSchemas['boolean'] as any;
+            this.isRequired = defaultSchema.isRequired;
+            this.isNullable = defaultSchema.isNullable;
+        }
+    }
+
+    protected _equals?: TEqualsTo;
+
+    equals<T extends boolean>(
+        val: T
+    ): IBooleanSchemaBuilder<TRequired, TNullable, T> {
+        if ((this._equals as any) === val) {
+            return this as any as IBooleanSchemaBuilder<
+                TRequired,
+                TNullable,
+                T
+            >;
+        }
+        return BooleanSchemaBuilder.create({
+            ...(this._schema as any),
+            equals: val
+        });
+    }
+
+    clearEqualsTo(): IBooleanSchemaBuilder<TRequired, TNullable, undefined> {
+        if (typeof this._equals === 'undefined') {
+            return this as IBooleanSchemaBuilder<
+                TRequired,
+                TNullable,
+                undefined
+            >;
+        }
+        return BooleanSchemaBuilder.create({
+            ...(this._schema as any),
+            equals: undefined
+        });
+    }
+
+    optional(): IBooleanSchemaBuilder<false, TNullable, TEqualsTo> {
+        if (this.isRequired === false) {
+            return this as IBooleanSchemaBuilder<false, TNullable, TEqualsTo>;
+        }
+        return BooleanSchemaBuilder.create({
+            ...(this._schema as any),
+            isRequired: false
+        });
+    }
+
+    required(): IBooleanSchemaBuilder<true, TNullable, TEqualsTo> {
+        if (this.isRequired === true) {
+            return this as IBooleanSchemaBuilder<true, TNullable, TEqualsTo>;
+        }
+        return BooleanSchemaBuilder.create({
+            ...(this._schema as any),
+            isRequired: true
+        });
+    }
+
+    nullable(): IBooleanSchemaBuilder<TRequired, true, TEqualsTo> {
+        if (this.isNullable === true) {
+            return this as IBooleanSchemaBuilder<TRequired, true, TEqualsTo>;
+        }
+        return BooleanSchemaBuilder.create({
+            ...(this._schema as any),
+            isNullable: true
+        });
+    }
+
+    notNullable(): IBooleanSchemaBuilder<TRequired, false, TEqualsTo> {
+        if (this.isNullable === false) {
+            return this as IBooleanSchemaBuilder<TRequired, false, TEqualsTo>;
+        }
+        return BooleanSchemaBuilder.create({
+            ...(this._schema as any),
+            isNullable: false
+        });
+    }
+}
+
+export const boolean = (): IBooleanSchemaBuilder =>
+    BooleanSchemaBuilder.create();

package/src/builders/FunctionSchemaBuilder.test.ts

@@ -0,0 +1,134 @@
+import { deepEqual } from '@cleverbrush/deep';
+
+import { Schema } from '../schema.js';
+import { func } from './FunctionSchemaBuilder.js';
+
+test('Clean', () => {
+    const schema = func();
+    expect(schema).toHaveProperty('type', 'function');
+    expect(schema).toHaveProperty('isRequired', true);
+    expect(schema).toHaveProperty('isNullable', false);
+});
+
+test('optional', () => {
+    const schema = func().optional();
+    expect(schema).toHaveProperty('type', 'function');
+    expect(schema).toHaveProperty('isRequired', false);
+});
+
+test('optional - 2', () => {
+    const schema = func().optional().required();
+    expect(schema).toHaveProperty('type', 'function');
+    expect(schema).toHaveProperty('isRequired', true);
+});
+
+test('optional - 3', () => {
+    const schema1 = func();
+    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 = func().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 = func();
+    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 = func().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 = func().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 = func().nullable();
+    expect(schema).toHaveProperty('type', 'function');
+    expect(schema).toHaveProperty('isNullable', true);
+});
+
+test('nullable - 2', () => {
+    const schema = func().nullable().notNullable();
+    expect(schema).toHaveProperty('type', 'function');
+    expect(schema).toHaveProperty('isNullable', false);
+});
+
+test('nullable - 3', () => {
+    const schema1 = func();
+    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 = func().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 = func();
+    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 = func();
+    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 = func().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('Clone', () => {
+    const schema1 = func().addValidator(() => ({ valid: true }));
+    const schema2 = schema1.clone();
+    const equal = (schema1 as any) === schema2;
+    expect(equal).toEqual(false);
+    const equal2 = deepEqual(schema1._schema, schema2._schema);
+    expect(equal2).toEqual(true);
+});

package/src/builders/FunctionSchemaBuilder.ts

@@ -0,0 +1,109 @@
+import { Schema, Validator } from '../schema.js';
+import { ISchemaBuilder, SchemaBuilder } from './SchemaBuilder.js';
+import { defaultSchemas } from '../defaultSchemas.js';
+
+export interface IFunctionSchemaBuilder<
+    TRequired extends boolean = true,
+    TNullable extends boolean = false
+> extends ISchemaBuilder<TRequired, TNullable> {
+    optional(): IFunctionSchemaBuilder<false, TNullable>;
+    required(): IFunctionSchemaBuilder<true, TNullable>;
+    nullable(): IFunctionSchemaBuilder<TRequired, true>;
+    notNullable(): IFunctionSchemaBuilder<TRequired, false>;
+}
+
+export class FunctionSchemaBuilder<
+        TRequired extends boolean = true,
+        TNullable extends boolean = false
+    >
+    extends SchemaBuilder<TRequired, TNullable>
+    implements IFunctionSchemaBuilder<TRequired, TNullable>
+{
+    protected readonly type = 'function';
+
+    public get _schema(): Schema {
+        return Object.assign(
+            {
+                type: this.type
+            },
+            this.getCommonSchema()
+        );
+    }
+
+    public clone(): this {
+        return FunctionSchemaBuilder.create(this._schema as any) as this;
+    }
+
+    public static create<
+        TRequired extends boolean = true,
+        TNullable extends boolean = false
+    >(obj?: {
+        isRequired: TRequired;
+        isNullable: TNullable;
+        validators?: Validator[];
+        preprocessor?:
+            | ((value: unknown) => unknown | Promise<unknown>)
+            | string;
+    }): IFunctionSchemaBuilder<TRequired, TNullable> {
+        return new FunctionSchemaBuilder(obj as any);
+    }
+
+    private constructor(obj: {
+        isRequired: TRequired;
+        isNullable: TNullable;
+        validators?: Validator[];
+        preprocessor?:
+            | ((value: unknown) => unknown | Promise<unknown>)
+            | string;
+    }) {
+        super(obj);
+        if (typeof obj !== 'object' || !obj) {
+            const defaultSchema = defaultSchemas['function'] as any;
+            this.isRequired = defaultSchema.isRequired;
+            this.isNullable = defaultSchema.isNullable;
+        }
+    }
+
+    optional(): IFunctionSchemaBuilder<false, TNullable> {
+        if (this.isRequired === false) {
+            return this as IFunctionSchemaBuilder<false, TNullable>;
+        }
+        return FunctionSchemaBuilder.create({
+            ...(this._schema as any),
+            isRequired: false
+        });
+    }
+
+    required(): IFunctionSchemaBuilder<true, TNullable> {
+        if (this.isRequired === true) {
+            return this as IFunctionSchemaBuilder<true, TNullable>;
+        }
+        return FunctionSchemaBuilder.create({
+            ...(this._schema as any),
+            isRequired: true
+        });
+    }
+
+    nullable(): IFunctionSchemaBuilder<TRequired, true> {
+        if (this.isNullable === true) {
+            return this as IFunctionSchemaBuilder<TRequired, true>;
+        }
+        return FunctionSchemaBuilder.create({
+            ...(this._schema as any),
+            isNullable: true
+        });
+    }
+
+    notNullable(): IFunctionSchemaBuilder<TRequired, false> {
+        if (this.isNullable === false) {
+            return this as IFunctionSchemaBuilder<TRequired, false>;
+        }
+        return FunctionSchemaBuilder.create({
+            ...(this._schema as any),
+            isNullable: false
+        });
+    }
+}
+
+export const func = (): IFunctionSchemaBuilder =>
+    FunctionSchemaBuilder.create();