@cleverbrush/schema 0.0.8 → 0.0.11

package/dist/index.d.ts

@@ -23,6 +23,9 @@ export declare type ObjectSchemaDefinition<T> = Omit<SchemaDefintion<T>, 'type'>
     properties?: Partial<{
         [S in keyof T]: Schema<PropType<T, S>>;
     }>;
+    preprocessors?: Partial<{
+        [S in keyof T]: ((value: unknown) => PropType<T, S> | Promise<PropType<T, S>>) | string;
+    }>;
 };
 export declare type AliasSchemaDefinition<T> = Omit<SchemaDefintion<T>, 'type'> & {
     type: 'alias';
@@ -53,6 +56,7 @@ export declare type StringSchemaDefinition<TObj> = Omit<SchemaDefintion<TObj>, '
 };
 export declare type ArraySchemaDefinition<TObj> = Omit<SchemaDefintion<TObj>, 'type'> & {
     type: 'array';
+    preprocessor?: ((value: unknown) => unknown | Promise<unknown>) | string;
     ofType?: Schema<any>;
     minLength?: number;
     maxLength?: number;
@@ -70,6 +74,8 @@ export interface ISchemasProvider<T = Record<string, never>> {
     };
 }
 export interface ISchemaValidator<T = Record<string, never>> {
+    get preprocessors(): Map<string, (value: unknown) => unknown | Promise<unknown>>;
+    addPreprocessor(name: string, preprocessor: (value: unknown) => unknown | Promise<unknown>): SchemaValidator<T>;
     addSchemaType<K, L extends ObjectSchemaDefinitionParam<M>, M = any>(name: keyof K, schema: L | Array<Schema<any>>): SchemaValidator<T & {
         [key in keyof K]: typeof schema;
     }>;

package/dist/schemaValidator.d.ts

@@ -2,6 +2,9 @@ import { ISchemasProvider, Schema, ISchemaActions, ObjectSchemaDefinitionParam,
 export default class SchemaValidator<T = Record<string, never>> implements ISchemasProvider<T>, ISchemaValidator<T> {
     private _schemasMap;
     private _schemasCache;
+    private _preprocessorsMap;
+    get preprocessors(): Map<string, (value: unknown) => unknown>;
+    addPreprocessor(name: string, preprocessor: (value: unknown) => unknown | Promise<unknown>): SchemaValidator<T>;
     addSchemaType<K, L extends ObjectSchemaDefinitionParam<M>, M = any>(name: keyof K, schema: L | Array<Schema<any>>): SchemaValidator<T & {
         [key in keyof K]: L;
     }>;

package/dist/schemaValidator.js

@@ -37,6 +37,16 @@ const isDefaultType = (name) => defaultSchemaNames.indexOf(name) !== -1;
 class SchemaValidator {
     _schemasMap = new Map();
     _schemasCache = null;
+    _preprocessorsMap = new Map();
+    get preprocessors() {
+        return this._preprocessorsMap;
+    }
+    addPreprocessor(name, preprocessor) {
+        if (this._preprocessorsMap.has(name))
+            throw new Error(`Preprocessor '${name}' is already registered`);
+        this._preprocessorsMap.set(name, preprocessor);
+        return this;
+    }
     addSchemaType(name, schema) {
         if (typeof name !== 'string' || !name)
             throw new Error('Name is required');
@@ -174,8 +184,15 @@ class SchemaValidator {
             else if (schema.type === 'alias') {
                 const alias = this.schemas[schema.schemaName]
                     .schema;
-                if (Array.isArray(alias))
-                    throw new Error('it is impossible to use alternative schema alias as "type" field');
+                if (Array.isArray(alias)) {
+                    if ((!schema.isRequired && typeof obj === 'undefined') ||
+                        (schema.isNullable && obj === null)) {
+                        return {
+                            valid: true
+                        };
+                    }
+                    return await this.validate(alias, obj);
+                }
                 if (typeof alias !== 'object')
                     throw new Error('it is only possible to use a full schema schema definition as alias');
                 const schemaToMerge = { ...schema };

package/dist/validators/validateArray.js

@@ -14,6 +14,17 @@ const validateArray = async (obj, schema, validator) => {
             valid: false,
             errors: ['expected type array']
         };
+    if (schema.preprocessor) {
+        const preprocessor = typeof schema.preprocessor === 'function'
+            ? schema.preprocessor
+            : validator.preprocessors.get(schema.preprocessor);
+        if (typeof preprocessor !== 'function') {
+            throw new Error(`unknown preprocessor '${schema.preprocessor}'`);
+        }
+        for (let i = 0; i < obj.length; i++) {
+            obj[i] = await Promise.resolve(preprocessor(obj[i]));
+        }
+    }
     if (typeof schema.minLength === 'number' && obj.length < schema.minLength) {
         return {
             valid: false,

package/dist/validators/validateObject.js

@@ -17,6 +17,20 @@ const validateObject = async (obj, schema, validator) => {
             ]
         };
     }
+    if (typeof schema.preprocessors === 'object' && schema.preprocessors) {
+        await Promise.all(Object.keys(schema.preprocessors).map(async (key) => {
+            if (typeof schema.preprocessors[key] === 'function') {
+                obj[key] = await Promise.resolve(schema.preprocessors[key](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]));
+            }
+        }));
+    }
     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]);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cleverbrush/schema",
-    "version": "0.0.8",
+    "version": "0.0.11",
     "keywords": [
         "object schema validator",
         "schema",
@@ -19,7 +19,7 @@
         "build": "tsc"
     },
     "dependencies": {
-        "@cleverbrush/deep": "0.0.8"
+        "@cleverbrush/deep": "0.0.11"
     },
     "types": "./dist/index.d.ts"
 }

package/src/index.ts

@@ -39,6 +39,11 @@ export type ObjectSchemaDefinition<T> = Omit<SchemaDefintion<T>, 'type'> & {
     properties?: Partial<{
         [S in keyof T]: Schema<PropType<T, S>>;
     }>;
+    preprocessors?: Partial<{
+        [S in keyof T]:
+            | ((value: unknown) => PropType<T, S> | Promise<PropType<T, S>>)
+            | string;
+    }>;
 };
 
 export type AliasSchemaDefinition<T> = Omit<SchemaDefintion<T>, 'type'> & {
@@ -91,6 +96,7 @@ export type ArraySchemaDefinition<TObj> = Omit<
     'type'
 > & {
     type: 'array';
+    preprocessor?: ((value: unknown) => unknown | Promise<unknown>) | string;
     ofType?: Schema<any>;
     minLength?: number;
     maxLength?: number;
@@ -129,6 +135,15 @@ export interface ISchemasProvider<T = Record<string, never>> {
 }
 
 export interface ISchemaValidator<T = Record<string, never>> {
+    get preprocessors(): Map<
+        string,
+        (value: unknown) => unknown | Promise<unknown>
+    >;
+    addPreprocessor(
+        name: string,
+        preprocessor: (value: unknown) => unknown | Promise<unknown>
+    ): SchemaValidator<T>;
+
     addSchemaType<K, L extends ObjectSchemaDefinitionParam<M>, M = any>(
         name: keyof K,
         schema: L | Array<Schema<any>>

package/src/schemaValidator.test.ts

@@ -1152,3 +1152,214 @@ test('Validate schema - 2', async () => {
 
     expect(result).toHaveProperty('valid', true);
 });
+
+test('Not required alternative schema alias', async () => {
+    const validator = new SchemaValidator()
+        .addSchemaType('Alternate1', {
+            properties: {
+                a1: 'string'
+            }
+        })
+        .addSchemaType('Alternate2', {
+            properties: {
+                a2: 'string'
+            }
+        })
+        .addSchemaType('Alternate', ['Alternate1', 'Alternate2']);
+
+    let result = await validator.validate(
+        {
+            type: 'alias',
+            isRequired: false,
+            schemaName: 'Alternate'
+        },
+        undefined
+    );
+
+    expect(result).toHaveProperty('valid', true);
+
+    result = await validator.validate(
+        {
+            type: 'alias',
+            isRequired: false,
+            schemaName: 'Alternate'
+        },
+        {
+            a2: 'something'
+        }
+    );
+
+    expect(result).toHaveProperty('valid', true);
+
+    result = await validator.validate(
+        {
+            type: 'alias',
+            isRequired: false,
+            schemaName: 'Alternate'
+        },
+        'invalid'
+    );
+
+    expect(result).toHaveProperty('valid', false);
+});
+
+test('Preprocessors - 1', async () => {
+    const validator = new SchemaValidator().addSchemaType('Date', {
+        validators: [
+            (value) =>
+                value instanceof Date && !Number.isNaN(value)
+                    ? {
+                          valid: true
+                      }
+                    : {
+                          valid: false,
+                          errors: ['should be a valid Date object']
+                      }
+        ]
+    });
+
+    const schema: Schema<{ bornAt: Date }> = {
+        type: 'object',
+        properties: {
+            bornAt: 'Date'
+        },
+        preprocessors: {
+            bornAt: (value: unknown): Date => {
+                const time = Date.parse(value.toString());
+                if (Number.isNaN(time)) return undefined;
+                return new Date(time);
+            }
+        }
+    };
+
+    const result = await validator.validate(schema, {
+        bornAt: new Date().toJSON()
+    });
+    expect(result).toHaveProperty('valid', true);
+});
+
+test('Preprocessors - 2', async () => {
+    const validator = new SchemaValidator().addSchemaType('Date', {
+        validators: [
+            (value) =>
+                value instanceof Date && !Number.isNaN(value)
+                    ? {
+                          valid: true
+                      }
+                    : {
+                          valid: false,
+                          errors: ['should be a valid Date object']
+                      }
+        ]
+    });
+
+    let schema: Schema<{ bornAt: Date; diedAt?: Date }> = {
+        type: 'object',
+        properties: {
+            bornAt: 'Date'
+        },
+        preprocessors: {
+            bornAt: 'StringToDate'
+        }
+    };
+
+    validator.addPreprocessor('StringToDate', (value: unknown): Date => {
+        const time = Date.parse(value.toString());
+        if (Number.isNaN(time)) return undefined;
+        return new Date(time);
+    });
+
+    expect(() =>
+        validator.addPreprocessor('StringToDate', (value: unknown): Date => {
+            const time = Date.parse(value.toString());
+            if (Number.isNaN(time)) return undefined;
+            return new Date(time);
+        })
+    ).toThrow();
+
+    const result = await validator.validate(schema, {
+        bornAt: new Date().toJSON()
+    });
+    expect(result).toHaveProperty('valid', true);
+
+    schema = {
+        type: 'object',
+        properties: {
+            bornAt: 'Date',
+            diedAt: 'Date'
+        },
+        preprocessors: {
+            bornAt: 'StringToDate',
+            diedAt: 'Unregistered'
+        }
+    };
+    expect(async () => {
+        await validator.validate(schema, {
+            bornAt: new Date().toJSON()
+        });
+    }).rejects.toBeInstanceOf(Error);
+});
+
+test('Preprocessors - 3', async () => {
+    const validator = new SchemaValidator().addSchemaType('Date', {
+        validators: [
+            (value) =>
+                value instanceof Date && !Number.isNaN(value)
+                    ? {
+                          valid: true
+                      }
+                    : {
+                          valid: false,
+                          errors: ['should be a valid Date object']
+                      }
+        ]
+    });
+
+    validator.addPreprocessor('StringToDate', (value: unknown): Date => {
+        const time = Date.parse(value.toString());
+        if (Number.isNaN(time)) return undefined;
+        return new Date(time);
+    });
+
+    let obj = [new Date().toJSON()];
+
+    let result = await validator.validate(
+        {
+            preprocessor: 'StringToDate',
+            type: 'array',
+            ofType: 'Date'
+        },
+        obj
+    );
+    expect(result).toHaveProperty('valid', true);
+
+    obj = [new Date().toJSON()];
+    result = await validator.validate(
+        {
+            preprocessor: (value: unknown): Date => {
+                const time = Date.parse(value.toString());
+                if (Number.isNaN(time)) return undefined;
+                return new Date(time);
+            },
+            type: 'array',
+            ofType: 'Date'
+        },
+        obj
+    );
+    expect(result).toHaveProperty('valid', true);
+
+    obj = ['sdfsdf12', new Date().toJSON()];
+    result = await validator.validate(
+        {
+            preprocessor: (value: unknown): Date => {
+                const time = Date.parse(value.toString());
+                if (Number.isNaN(time)) return undefined;
+                return new Date(time);
+            },
+            type: 'array',
+            ofType: 'Date'
+        },
+        obj
+    );
+    expect(result).toHaveProperty('valid', false);
+});

package/src/schemaValidator.ts

@@ -70,6 +70,24 @@ export default class SchemaValidator<T = Record<string, never>>
 {
     private _schemasMap = new Map<string, Schema<any>>();
     private _schemasCache: { [K in keyof T]: ISchemaActions<T, K> } = null;
+    private _preprocessorsMap = new Map<
+        string,
+        (value: unknown) => unknown | Promise<unknown>
+    >();
+
+    public get preprocessors(): Map<string, (value: unknown) => unknown> {
+        return this._preprocessorsMap;
+    }
+
+    public addPreprocessor(
+        name: string,
+        preprocessor: (value: unknown) => unknown | Promise<unknown>
+    ): SchemaValidator<T> {
+        if (this._preprocessorsMap.has(name))
+            throw new Error(`Preprocessor '${name}' is already registered`);
+        this._preprocessorsMap.set(name, preprocessor);
+        return this;
+    }
 
     public addSchemaType<K, L extends ObjectSchemaDefinitionParam<M>, M = any>(
         name: keyof K,
@@ -259,10 +277,17 @@ export default class SchemaValidator<T = Record<string, never>>
             } else if (schema.type === 'alias') {
                 const alias = this.schemas[schema.schemaName]
                     .schema as Schema<any>;
-                if (Array.isArray(alias))
-                    throw new Error(
-                        'it is impossible to use alternative schema alias as "type" field'
-                    );
+                if (Array.isArray(alias)) {
+                    if (
+                        (!schema.isRequired && typeof obj === 'undefined') ||
+                        (schema.isNullable && obj === null)
+                    ) {
+                        return {
+                            valid: true
+                        };
+                    }
+                    return await this.validate(alias, obj);
+                }
                 if (typeof alias !== 'object')
                     throw new Error(
                         'it is only possible to use a full schema schema definition as alias'

package/src/validators/validateArray.ts

@@ -24,6 +24,19 @@ export const validateArray = async (
             errors: ['expected type array']
         };
 
+    if (schema.preprocessor) {
+        const preprocessor =
+            typeof schema.preprocessor === 'function'
+                ? schema.preprocessor
+                : validator.preprocessors.get(schema.preprocessor);
+        if (typeof preprocessor !== 'function') {
+            throw new Error(`unknown preprocessor '${schema.preprocessor}'`);
+        }
+        for (let i = 0; i < obj.length; i++) {
+            obj[i] = await Promise.resolve(preprocessor(obj[i]));
+        }
+    }
+
     if (typeof schema.minLength === 'number' && obj.length < schema.minLength) {
         return {
             valid: false,

package/src/validators/validateObject.ts

@@ -28,6 +28,30 @@ export const validateObject = async (
         };
     }
 
+    if (typeof schema.preprocessors === 'object' && schema.preprocessors) {
+        await Promise.all(
+            Object.keys(schema.preprocessors).map(async (key: string) => {
+                if (typeof schema.preprocessors[key] === 'function') {
+                    obj[key] = await Promise.resolve(
+                        (schema.preprocessors[key] as (unknown) => unknown)(
+                            obj[key]
+                        )
+                    );
+                } else {
+                    const preprocessor = validator.preprocessors.get(
+                        schema.preprocessors[key] as string
+                    );
+                    if (typeof preprocessor !== 'function') {
+                        throw new Error(
+                            `preprocessor '${schema.preprocessors[key]}' is unknown`
+                        );
+                    }
+                    obj[key] = await Promise.resolve(preprocessor(obj[key]));
+                }
+            })
+        );
+    }
+
     if (typeof schema.properties === 'object' && schema.properties) {
         const errors = (
             await Promise.all(