@cleverbrush/schema 1.0.0-beta.0 → 1.0.0-beta.1

package/dist/validators/validateUnion.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateUnion = void 0;
-const validateUnion = async (obj, schema, validator) => {
-    if (typeof obj === 'undefined' && schema.isRequired === false) {
-        return {
-            valid: true
-        };
-    }
-    if (obj === null && schema.isNullable) {
-        return {
-            valid: true
-        };
-    }
-    if (Array.isArray(schema.variants) && schema.variants.length > 0) {
-        for (let i = 0; i < schema.variants.length; i++) {
-            const variant = schema.variants[i];
-            const result = await validator.validate(variant, obj);
-            if (result.valid) {
-                return result;
-            }
-        }
-        return {
-            valid: false,
-            errors: ['object does not satisfy any scheme']
-        };
-    }
-    throw new Error('variants should be non empty array');
-};
-exports.validateUnion = validateUnion;

package/src/builders/AliasSchemaBuilder.test.ts

@@ -1,124 +0,0 @@
-import { Schema } from '../schema.js';
-import { alias } from './AliasSchemaBuilder.js';
-
-test('Clean', () => {
-    const schema = alias('Something');
-    expect(schema).toHaveProperty('type', 'alias');
-    expect(schema).toHaveProperty('schemaName', 'Something');
-    expect(schema).toHaveProperty('isRequired', true);
-    expect(schema).toHaveProperty('isNullable', false);
-});
-
-test('optional', () => {
-    const schema = alias('Something').optional();
-    expect(schema).toHaveProperty('type', 'alias');
-    expect(schema).toHaveProperty('isRequired', false);
-});
-
-test('optional - 2', () => {
-    const schema = alias('Something').optional().required();
-    expect(schema).toHaveProperty('type', 'alias');
-    expect(schema).toHaveProperty('isRequired', true);
-});
-
-test('optional - 3', () => {
-    const schema1 = alias('Something');
-    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 = alias('Something').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 = alias('Something');
-    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 = alias('Something').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 = alias('Something').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 = alias('Something').nullable();
-    expect(schema).toHaveProperty('type', 'alias');
-    expect(schema).toHaveProperty('isNullable', true);
-});
-
-test('nullable - 2', () => {
-    const schema = alias('Something').nullable().notNullable();
-    expect(schema).toHaveProperty('type', 'alias');
-    expect(schema).toHaveProperty('isNullable', false);
-});
-
-test('nullable - 3', () => {
-    const schema1 = alias('Something');
-    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 = alias('Something').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 = alias('Something');
-    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 = alias('Something');
-    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 = alias('Something').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);
-});

package/src/builders/AliasSchemaBuilder.ts

@@ -1,250 +0,0 @@
-import { ISchemaBuilder, SchemaBuilder } from './SchemaBuilder.js';
-import { InferType, Schema } from '../schema.js';
-import { defaultSchemas } from '../defaultSchemas.js';
-import { ISchemaRegistry } from '../index.js';
-
-export interface IAliasSchemaBuilder<
-    TSchemaName extends keyof TAliases,
-    TRequired extends boolean = true,
-    TNullable extends boolean = false,
-    TAliases extends Record<string, any> = never,
-    TAliasesCompiledType = any,
-    TExternalRegistryKeys extends Record<string, any> = {}
-> extends ISchemaBuilder<TRequired, TNullable> {
-    readonly type: 'alias';
-    schemaName: TSchemaName;
-    externalRegistry: ISchemaRegistry<TExternalRegistryKeys>;
-
-    optional(): IAliasSchemaBuilder<
-        TSchemaName,
-        false,
-        TNullable,
-        TAliases,
-        TAliasesCompiledType,
-        TExternalRegistryKeys
-    >;
-    required(): IAliasSchemaBuilder<
-        TSchemaName,
-        true,
-        TNullable,
-        TAliases,
-        TAliasesCompiledType,
-        TExternalRegistryKeys
-    >;
-    nullable(): IAliasSchemaBuilder<
-        TSchemaName,
-        TRequired,
-        true,
-        TAliases,
-        TAliasesCompiledType,
-        TExternalRegistryKeys
-    >;
-    notNullable(): IAliasSchemaBuilder<
-        TSchemaName,
-        TRequired,
-        false,
-        TAliases,
-        TAliasesCompiledType,
-        TExternalRegistryKeys
-    >;
-}
-
-class AliasSchemaBuilder<
-        TSchemaName extends keyof TAliases,
-        TRequired extends boolean = true,
-        TNullable extends boolean = false,
-        TAliases extends Record<string, any> = never,
-        TAliasesCompiledType = any,
-        TExternalRegistryKeys extends Record<string, any> = {}
-    >
-    extends SchemaBuilder<TRequired, TNullable>
-    implements
-        IAliasSchemaBuilder<
-            TSchemaName,
-            TRequired,
-            TNullable,
-            TAliases,
-            TAliasesCompiledType,
-            TExternalRegistryKeys
-        >
-{
-    public clone(): this {
-        return AliasSchemaBuilder.create(this._schema as any) as this;
-    }
-
-    public get _schema(): Schema {
-        return Object.assign(
-            {
-                type: this.type,
-                schemaName: this.schemaName,
-                externalRegistry: this.externalRegistry
-            },
-            this.getCommonSchema()
-        );
-    }
-
-    public static create<
-        TSchemaName extends keyof TAliases,
-        TRequired extends boolean = true,
-        TNullable extends boolean = false,
-        TAliases extends Record<string, any> = never,
-        TAliasesCompiledType = any,
-        TExternalRegistryKeys extends Record<string, any> = {}
-    >(obj?: {
-        schemaName: TSchemaName;
-        isRequired: TRequired;
-        isNullable: TNullable;
-        externalRegistry?: ISchemaRegistry<TExternalRegistryKeys>;
-    }): IAliasSchemaBuilder<
-        TSchemaName,
-        TRequired,
-        TNullable,
-        TAliases,
-        TAliasesCompiledType,
-        TExternalRegistryKeys
-    > {
-        return new AliasSchemaBuilder(obj as any) as any;
-    }
-
-    public schemaName: TSchemaName;
-    public externalRegistry: ISchemaRegistry<TExternalRegistryKeys>;
-
-    private constructor(obj: {
-        schemaName: TSchemaName;
-        isRequired: TRequired;
-        isNullable: TNullable;
-        externalRegistry?: ISchemaRegistry<any>;
-    }) {
-        super(obj);
-        if (typeof obj === 'object' && obj) {
-            if (typeof obj.schemaName === 'string') {
-                this.schemaName = obj.schemaName;
-            }
-            if (
-                typeof obj.externalRegistry === 'object' &&
-                obj.externalRegistry
-            ) {
-                this.externalRegistry = obj.externalRegistry;
-            }
-        } else {
-            const defaultSchema = defaultSchemas['alias'] as any;
-            this.isRequired = defaultSchema.isRequired;
-            this.isNullable = defaultSchema.isNullable;
-        }
-    }
-
-    get type(): 'alias' {
-        return 'alias';
-    }
-
-    optional(): IAliasSchemaBuilder<
-        TSchemaName,
-        false,
-        TNullable,
-        TAliases,
-        TAliasesCompiledType,
-        TExternalRegistryKeys
-    > {
-        if (this.isRequired === false) {
-            return this as any;
-        }
-
-        return AliasSchemaBuilder.create({
-            ...(this._schema as any),
-            isRequired: false
-        });
-    }
-
-    required(): IAliasSchemaBuilder<
-        TSchemaName,
-        true,
-        TNullable,
-        TAliases,
-        TAliasesCompiledType,
-        TExternalRegistryKeys
-    > {
-        if (this.isRequired === true) {
-            return this as any;
-        }
-
-        return AliasSchemaBuilder.create({
-            ...(this._schema as any),
-            isRequired: true
-        });
-    }
-
-    nullable(): IAliasSchemaBuilder<
-        TSchemaName,
-        TRequired,
-        true,
-        TAliases,
-        TAliasesCompiledType,
-        TExternalRegistryKeys
-    > {
-        if (this._isNullable === true) {
-            return this as any;
-        }
-        return AliasSchemaBuilder.create({
-            ...(this._schema as any),
-            isNullable: true
-        });
-    }
-
-    notNullable(): IAliasSchemaBuilder<
-        TSchemaName,
-        TRequired,
-        false,
-        TAliases,
-        TAliasesCompiledType,
-        TExternalRegistryKeys
-    > {
-        if (this.isNullable === false) {
-            return this as any;
-        }
-        return AliasSchemaBuilder.create({
-            ...(this._schema as any),
-            isNullable: false
-        });
-    }
-}
-
-export const alias = <
-    TSchemaName extends keyof TAliases,
-    TAliases extends Record<string, any>,
-    TAliasesCompiledType = InferType<TAliases[TSchemaName]>
->(
-    schemaName: TSchemaName
-) =>
-    AliasSchemaBuilder.create<
-        TSchemaName,
-        true,
-        false,
-        TAliases,
-        TAliasesCompiledType
-    >({
-        schemaName,
-        isRequired: true,
-        isNullable: false
-    });
-
-export const externalAlias = <
-    TSchemaName extends keyof TAliases,
-    TAliases extends Record<string, any>,
-    TExternalSchemaRegistry extends ISchemaRegistry<TAliases>,
-    TAliasesCompiledType = InferType<TAliases[TSchemaName]>
->(
-    registry: TExternalSchemaRegistry,
-    schemaName: TSchemaName
-) =>
-    AliasSchemaBuilder.create<
-        TSchemaName,
-        true,
-        false,
-        TAliases,
-        TAliasesCompiledType
-    >({
-        schemaName,
-        isRequired: true,
-        isNullable: false,
-        externalRegistry: registry
-    });