@cleverbrush/schema 0.0.16 → 1.0.0-beta.0

package/dist/validators/validateFunction.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateFunction = void 0;
+const validateFunction = async (obj, schema) => {
+    if (typeof obj === 'undefined' &&
+        typeof schema === 'object' &&
+        schema.isRequired === false) {
+        return {
+            valid: true
+        };
+    }
+    if (typeof obj !== 'function')
+        return {
+            valid: false,
+            errors: [`expected type function, but saw ${typeof obj}`]
+        };
+    return {
+        valid: true
+    };
+};
+exports.validateFunction = validateFunction;

package/dist/validators/validateNumber.d.ts

@@ -1,2 +1,2 @@
-import { ValidationResult, NumberSchemaDefinition, ISchemaValidator } from '../index';
-export declare const validateNumber: (obj: any, schema: NumberSchemaDefinition<any>, validator: ISchemaValidator<any>) => Promise<ValidationResult>;
+import { NumberSchema, ValidationResult } from '../schema.js';
+export declare const validateNumber: (obj: any, schema: NumberSchema) => Promise<ValidationResult>;

package/dist/validators/validateNumber.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateNumber = void 0;
-const validateNumber = async (obj, schema, validator) => {
+const validateNumber = async (obj, schema) => {
     if (typeof obj === 'undefined' &&
         typeof schema === 'object' &&
         schema.isRequired === false) {

package/dist/validators/validateObject.d.ts

@@ -1,2 +1,3 @@
-import { ValidationResult, ObjectSchemaDefinition, ISchemaValidator } from '../index';
-export declare const validateObject: (obj: any, schema: ObjectSchemaDefinition<any>, validator: ISchemaValidator<any, unknown[]>) => Promise<ValidationResult>;
+import { ObjectSchema, ValidationResult } from '../schema.js';
+import SchemaRegistry from '../schemaRegistry.js';
+export declare const validateObject: (obj: any, schema: ObjectSchema<any>, validator: SchemaRegistry<any>) => Promise<ValidationResult>;

package/dist/validators/validateObject.js

@@ -22,14 +22,26 @@ const validateObject = async (obj, schema, validator) => {
             if (key === '*')
                 return;
             if (typeof schema.preprocessors[key] === 'function') {
-                obj[key] = await Promise.resolve(schema.preprocessors[key](obj[key]));
+                const res = await Promise.resolve(schema.preprocessors[key](obj[key]));
+                if (typeof res !== 'undefined') {
+                    obj[key] = res;
+                }
+                else {
+                    delete obj[key];
+                }
             }
             else {
                 const preprocessor = validator.preprocessors.get(schema.preprocessors[key]);
                 if (typeof preprocessor !== 'function') {
                     throw new Error(`preprocessor '${schema.preprocessors[key]}' is unknown`);
                 }
-                obj[key] = await Promise.resolve(preprocessor(obj[key]));
+                const res = await Promise.resolve(preprocessor(obj[key]));
+                if (typeof res !== 'undefined') {
+                    obj[key] = res;
+                }
+                else {
+                    delete obj[key];
+                }
             }
         }));
         if ('*' in schema.preprocessors) {
@@ -47,15 +59,25 @@ const validateObject = async (obj, schema, validator) => {
         }
     }
     if (typeof schema.properties === 'object' && schema.properties) {
-        const errors = (await Promise.all(Object.entries(schema.properties).map(async ([name, schema]) => {
-            const result = await validator.validate(schema, obj[name]);
-            if (result.valid)
-                return result;
-            return {
-                valid: false,
-                errors: (result.errors || []).map((e) => `->${name} ${e}`)
-            };
-        })))
+        const errors = [
+            ...(await Promise.all(Object.entries(schema.properties).map(async ([name, schema]) => {
+                const result = await validator.validate(schema, obj[name]);
+                if (result.valid)
+                    return result;
+                return {
+                    valid: false,
+                    errors: (result.errors || []).map((e) => `->${name} ${e}`)
+                };
+            }))),
+            ...(schema.noUnknownProperties === false
+                ? []
+                : Object.keys(obj)
+                    .filter((k) => !(k in schema.properties))
+                    .map((k) => ({
+                    valid: false,
+                    errors: [`-> ${k} - unknown field`]
+                })))
+        ]
             .filter((r) => !r.valid)
             .map((r) => r.errors)
             .flat(Infinity);

package/dist/validators/validateString.d.ts

@@ -1,2 +1,2 @@
-import { ValidationResult, StringSchemaDefinition, ISchemaValidator } from '../index';
-export declare const validateString: (obj: any, schema: StringSchemaDefinition<any>, validator: ISchemaValidator<any>) => Promise<ValidationResult>;
+import { StringSchema, ValidationResult } from '../schema.js';
+export declare const validateString: (obj: any, schema: StringSchema) => Promise<ValidationResult>;

package/dist/validators/validateString.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateString = void 0;
-const validateString = async (obj, schema, validator) => {
+const validateString = async (obj, schema) => {
     if (typeof obj === 'undefined' &&
         typeof schema === 'object' &&
         schema.isRequired === false) {

package/dist/validators/validateUnion.d.ts

@@ -0,0 +1,3 @@
+import { UnionSchema, ValidationResult } from '../schema.js';
+import SchemaRegistry from '../schemaRegistry.js';
+export declare const validateUnion: (obj: any, schema: UnionSchema<any>, validator: SchemaRegistry<any>) => Promise<ValidationResult>;

package/dist/validators/validateUnion.js

@@ -0,0 +1,30 @@
+"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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cleverbrush/schema",
-    "version": "0.0.16",
+    "version": "1.0.0-beta.0",
     "keywords": [
         "object schema validator",
         "schema",
@@ -18,8 +18,8 @@
         "watch": "tsc --watch",
         "build": "tsc"
     },
-    "dependencies": {
-        "@cleverbrush/deep": "0.0.16"
+    "devDependencies": {
+        "@cleverbrush/deep": "1.0.0-beta.0"
     },
     "types": "./dist/index.d.ts"
 }

package/src/builders/AliasSchemaBuilder.test.ts

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

@@ -0,0 +1,250 @@
+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
+    });