@cleverbrush/schema 0.0.10 → 0.0.13

package/dist/index.d.ts

@@ -24,7 +24,7 @@ export declare type ObjectSchemaDefinition<T> = Omit<SchemaDefintion<T>, 'type'>
         [S in keyof T]: Schema<PropType<T, S>>;
     }>;
     preprocessors?: Partial<{
-        [S in keyof T]: ((value: unknown) => PropType<T, S> | Promise<PropType<T, S>>) | string;
+        [S in keyof T | '*']: S extends keyof T ? ((value: unknown) => PropType<T, S> | Promise<PropType<T, S>>) | string : (value: T) => void | Promise<void>;
     }>;
 };
 export declare type AliasSchemaDefinition<T> = Omit<SchemaDefintion<T>, 'type'> & {
@@ -56,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;

package/dist/schemaValidator.d.ts

@@ -13,5 +13,5 @@ export default class SchemaValidator<T = Record<string, never>> implements ISche
     };
     private validateDefaultType;
     private checkValidators;
-    validate(schema: keyof T | DefaultSchemaType | Schema<any>, obj: any): Promise<ValidationResult>;
+    validate<K>(schema: keyof T | DefaultSchemaType | Schema<K>, obj: any): Promise<ValidationResult>;
 }

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

@@ -19,6 +19,8 @@ const validateObject = async (obj, schema, validator) => {
     }
     if (typeof schema.preprocessors === 'object' && schema.preprocessors) {
         await Promise.all(Object.keys(schema.preprocessors).map(async (key) => {
+            if (key === '*')
+                return;
             if (typeof schema.preprocessors[key] === 'function') {
                 obj[key] = await Promise.resolve(schema.preprocessors[key](obj[key]));
             }
@@ -30,6 +32,19 @@ const validateObject = async (obj, schema, validator) => {
                 obj[key] = await Promise.resolve(preprocessor(obj[key]));
             }
         }));
+        if ('*' in schema.preprocessors) {
+            const objectPreprocessor = schema.preprocessors['*'];
+            if (typeof objectPreprocessor === 'function') {
+                await Promise.resolve(objectPreprocessor(obj));
+            }
+            else {
+                const preprocessor = validator.preprocessors.get(objectPreprocessor);
+                if (typeof preprocessor !== 'function') {
+                    throw new Error(`preprocessor '${objectPreprocessor}' is unknown`);
+                }
+                await Promise.resolve(preprocessor(obj));
+            }
+        }
     }
     if (typeof schema.properties === 'object' && schema.properties) {
         const errors = (await Promise.all(Object.entries(schema.properties).map(async ([name, schema]) => {

package/package.json

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

package/src/index.ts

@@ -40,9 +40,13 @@ export type ObjectSchemaDefinition<T> = Omit<SchemaDefintion<T>, 'type'> & {
         [S in keyof T]: Schema<PropType<T, S>>;
     }>;
     preprocessors?: Partial<{
-        [S in keyof T]:
-            | ((value: unknown) => PropType<T, S> | Promise<PropType<T, S>>)
-            | string;
+        [S in keyof T | '*']: S extends keyof T
+            ?
+                  | ((
+                        value: unknown
+                    ) => PropType<T, S> | Promise<PropType<T, S>>)
+                  | string
+            : (value: T) => void | Promise<void>;
     }>;
 };
 
@@ -96,6 +100,7 @@ export type ArraySchemaDefinition<TObj> = Omit<
     'type'
 > & {
     type: 'array';
+    preprocessor?: ((value: unknown) => unknown | Promise<unknown>) | string;
     ofType?: Schema<any>;
     minLength?: number;
     maxLength?: number;

package/src/schemaValidator.test.ts

@@ -4,6 +4,7 @@ import { ValidationResult } from '../dist/index.js';
 import {
     NumberSchemaDefinition,
     ObjectSchemaDefinitionParam,
+    ObjectSchemaDefinition,
     Schema
 } from './index';
 import SchemaValidator from './schemaValidator';
@@ -829,7 +830,7 @@ test('Validate - object - 1', async () => {
                 b: 'number'
             },
             validators: [
-                (value) => {
+                (value: { a: number; b: number }) => {
                     if (value.a + value.b === 5) {
                         return {
                             valid: true
@@ -1299,3 +1300,160 @@ test('Preprocessors - 2', async () => {
         });
     }).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);
+});
+
+test('Preprocessors - 3', async () => {
+    const validator = new SchemaValidator();
+
+    type SomeType = { age: number; marriedAt: number };
+
+    const schema: ObjectSchemaDefinition<SomeType> = {
+        type: 'object',
+        properties: {
+            age: 'number',
+            marriedAt: 'number'
+        },
+        preprocessors: {
+            age: (value): number => 40,
+            '*': (value: SomeType): void => {
+                if (value.marriedAt > value.age) {
+                    value.marriedAt = value.age;
+                }
+            }
+        }
+    };
+
+    const obj = {
+        age: 50,
+        marriedAt: 80
+    };
+    await validator.validate(schema, obj);
+    expect(obj).toHaveProperty('marriedAt', 40);
+});
+
+test('Preprocessors - 4', 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

@@ -12,7 +12,8 @@ import {
     ArraySchemaDefinition,
     ISchemaValidator,
     DefaultSchemaType,
-    ObjectSchemaDefinition
+    ObjectSchemaDefinition,
+    SchemaDefintion
 } from './index';
 import { validateNumber } from './validators/validateNumber';
 import { validateString } from './validators/validateString';
@@ -213,8 +214,8 @@ export default class SchemaValidator<T = Record<string, never>>
         };
     }
 
-    public async validate(
-        schema: keyof T | DefaultSchemaType | Schema<any>,
+    public async validate<K>(
+        schema: keyof T | DefaultSchemaType | Schema<K>,
         obj: any
     ): Promise<ValidationResult> {
         if (!schema) throw new Error('schemaName is required');
@@ -293,7 +294,7 @@ export default class SchemaValidator<T = Record<string, never>>
                         'it is only possible to use a full schema schema definition as alias'
                     );
 
-                const schemaToMerge = { ...schema };
+                const schemaToMerge = { ...(schema as any) };
                 delete schemaToMerge.type;
                 delete schemaToMerge.schemaName;
                 const finalSchema: Schema<any> = deepExtend(

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

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