@cleverbrush/schema 0.0.17 → 1.0.0-beta.1

package/src/validators/validateObject.ts

@@ -1,14 +1,10 @@
-import {
-    ValidationResult,
-    ObjectSchemaDefinition,
-    ISchemaValidator,
-    Schema
-} from '../index';
+import { ObjectSchema, Schema, ValidationResult } from '../schema.js';
+import SchemaRegistry from '../schemaRegistry.js';
 
 export const validateObject = async (
     obj: any,
-    schema: ObjectSchemaDefinition<any>,
-    validator: ISchemaValidator<any, unknown[]>
+    schema: ObjectSchema<any>,
+    validator: SchemaRegistry<any>
 ): Promise<ValidationResult> => {
     if (
         typeof obj === 'undefined' &&
@@ -33,11 +29,14 @@ export const validateObject = async (
             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)(
-                            obj[key]
-                        )
+                    const res = await Promise.resolve(
+                        (schema.preprocessors[key] as any)(obj[key])
                     );
+                    if (typeof res !== 'undefined') {
+                        obj[key] = res;
+                    } else {
+                        delete obj[key];
+                    }
                 } else {
                     const preprocessor = validator.preprocessors.get(
                         schema.preprocessors[key] as string
@@ -47,16 +46,19 @@ export const validateObject = async (
                             `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) {
             const objectPreprocessor = schema.preprocessors['*'];
             if (typeof objectPreprocessor === 'function') {
-                await Promise.resolve(
-                    (objectPreprocessor as (unknown) => unknown)(obj)
-                );
+                await Promise.resolve((objectPreprocessor as any)(obj));
             } else {
                 const preprocessor = validator.preprocessors.get(
                     objectPreprocessor as string
@@ -72,10 +74,10 @@ export const validateObject = async (
     }
 
     if (typeof schema.properties === 'object' && schema.properties) {
-        const errors = (
-            await Promise.all(
+        const errors = [
+            ...(await Promise.all(
                 Object.entries(schema.properties).map(
-                    async ([name, schema]: [string, Schema<any>]) => {
+                    async ([name, schema]: [string, Schema]) => {
                         const result = await validator.validate(
                             schema,
                             obj[name]
@@ -89,11 +91,20 @@ export const validateObject = async (
                         };
                     }
                 )
-            )
-        )
+            )),
+            ...(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) as string[];
+
         if (errors.length) {
             return {
                 valid: false,

package/src/validators/validateString.ts

@@ -1,13 +1,8 @@
-import {
-    ValidationResult,
-    StringSchemaDefinition,
-    ISchemaValidator
-} from '../index';
+import { StringSchema, ValidationResult } from '../schema.js';
 
 export const validateString = async (
     obj: any,
-    schema: StringSchemaDefinition<any>,
-    validator: ISchemaValidator<any>
+    schema: StringSchema
 ): Promise<ValidationResult> => {
     if (
         typeof obj === 'undefined' &&

package/src/validators/validateUnion.ts

@@ -0,0 +1,36 @@
+import { UnionSchema, ValidationResult } from '../schema.js';
+import SchemaRegistry from '../schemaRegistry.js';
+
+export const validateUnion = async (
+    obj: any,
+    schema: UnionSchema<any>,
+    validator: SchemaRegistry<any>
+): Promise<ValidationResult> => {
+    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');
+};

package/dist/index.d.ts

@@ -1,94 +0,0 @@
-import { Merge } from '@cleverbrush/deep';
-import SchemaValidator from './schemaValidator';
-export declare type DefaultSchemaType = 'object' | 'boolean' | 'function' | 'number' | 'string' | 'array' | 'alias';
-export declare type PropType<TObj, TProp extends keyof TObj> = TObj[TProp];
-export declare type DefaultPropertyDefinition = {
-    isRequired: boolean;
-    isNullable: boolean;
-};
-export declare type ValidationResultRaw = {
-    valid: boolean;
-    errors?: Array<string>;
-};
-export declare type ValidationResult = ValidationResultRaw | Promise<ValidationResultRaw>;
-export declare type Validator<TObj> = (value: TObj) => ValidationResult;
-export declare type SchemaDefintion<TObj> = {
-    type: DefaultSchemaType;
-    isRequired?: boolean;
-    isNullable?: boolean;
-    validators?: Array<Validator<TObj>>;
-};
-export declare type ObjectSchemaDefinition<T> = Omit<SchemaDefintion<T>, 'type'> & {
-    type: 'object';
-    extends?: string;
-    properties?: Partial<{
-        [S in keyof T]: Schema<PropType<T, S>>;
-    }>;
-    preprocessors?: Partial<{
-        [S in keyof T | '*']: S extends keyof T ? ((value: unknown) => undefined | PropType<T, S> | Promise<PropType<T, S>>) | string : (value: T) => void | Promise<void>;
-    }>;
-};
-export declare type AliasSchemaDefinition<T> = Omit<SchemaDefintion<T>, 'type'> & {
-    type: 'alias';
-    schemaName: string;
-};
-export declare type ObjectSchemaDefinitionParam<T> = Omit<ObjectSchemaDefinition<T>, 'type'>;
-export declare type ParamsValidators<TFunc extends (...args: any) => any> = {
-    [S in keyof Parameters<TFunc>]: SingleSchema<Parameters<TFunc>[S]>;
-};
-export declare type FunctionSchemaDefinition<T extends (...args: any) => any> = Omit<SchemaDefintion<T>, 'type'> & {
-    type: 'function';
-    params?: ParamsValidators<T>;
-};
-export declare type BooleanSchemaDefinition<TObj> = Omit<SchemaDefintion<TObj>, 'type'> & {
-    type: 'boolean';
-    equals?: boolean;
-};
-export declare type NumberSchemaDefinition<TObj> = Omit<SchemaDefintion<TObj>, 'type'> & {
-    type: 'number';
-    min?: number;
-    max?: number;
-    equals?: number;
-    isInteger?: boolean;
-    ensureNotNaN?: boolean;
-    ensureIsFinite?: boolean;
-};
-export declare type StringSchemaDefinition<TObj> = Omit<SchemaDefintion<TObj>, 'type'> & {
-    type: 'string';
-    equals?: string;
-    minLength?: number;
-    maxLength?: number;
-};
-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;
-};
-export declare type CompositeSchema<TObj> = TObj extends (...args: any) => any ? FunctionSchemaDefinition<TObj> : TObj extends number ? NumberSchemaDefinition<TObj> : TObj extends string ? StringSchemaDefinition<TObj> | 'string' : BooleanSchemaDefinition<TObj> | NumberSchemaDefinition<TObj> | StringSchemaDefinition<TObj> | ArraySchemaDefinition<TObj> | ObjectSchemaDefinition<TObj> | AliasSchemaDefinition<TObj>;
-export declare type SingleSchema<TObj = Record<string, never>> = number | string | DefaultSchemaType | CompositeSchema<TObj>;
-export declare type Schema<TObj> = SingleSchema<TObj> | Array<SingleSchema<TObj>>;
-export declare type Cons<H, T extends unknown[] = []> = T['length'] extends 0 ? [H] : ((h: H, ...t: T) => void) extends (...r: infer R) => void ? R : never;
-export interface ISchemaActions<S> {
-    validate(value: any): Promise<ValidationResult>;
-    schema: S;
-}
-export interface ISchemasProvider<T extends unknown[]> {
-    schemas: Merge<T>;
-}
-export interface ISchemaValidator<T extends Record<string, never> = Record<string, never>, SchemaTypesStructures extends unknown[] = []> {
-    get preprocessors(): Map<string, (value: unknown) => unknown | Promise<unknown>>;
-    addPreprocessor(name: string, preprocessor: (value: unknown) => unknown | Promise<unknown>): SchemaValidator<T, SchemaTypesStructures>;
-    addSchemaType<K, L extends ObjectSchemaDefinitionParam<M> | Array<Schema<any>>, M = any>(name: keyof K, schema: L): SchemaValidator<T & {
-        [key in keyof K]: typeof schema;
-    }, Cons<Unfold<keyof K, ISchemaActions<L>>, SchemaTypesStructures>>;
-    validate(schema: keyof T | DefaultSchemaType | Schema<any>, obj: any): Promise<ValidationResult>;
-}
-export declare type Unfold<T, K> = T extends string ? T extends `${infer F}.${infer L}` ? {
-    [k in F]: Unfold<L, K>;
-} : {
-    [k in T]: K;
-} : never;
-export { SchemaValidator };
-export default SchemaValidator;

package/dist/index.js

@@ -1,9 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaValidator = void 0;
-const schemaValidator_1 = __importDefault(require("./schemaValidator"));
-exports.SchemaValidator = schemaValidator_1.default;
-exports.default = schemaValidator_1.default;

package/dist/schemaValidator.d.ts

@@ -1,16 +0,0 @@
-import { Merge } from '@cleverbrush/deep';
-import { ISchemasProvider, Schema, ISchemaActions, ObjectSchemaDefinitionParam, ValidationResult, ISchemaValidator, DefaultSchemaType, Cons, Unfold } from './index';
-export default class SchemaValidator<T extends Record<string, never> = Record<string, never>, SchemaTypesStructures extends unknown[] = []> implements ISchemasProvider<SchemaTypesStructures>, ISchemaValidator<T, SchemaTypesStructures> {
-    private _schemasMap;
-    private _schemasCache;
-    private _preprocessorsMap;
-    get preprocessors(): Map<string, (value: unknown) => unknown>;
-    addPreprocessor(name: string, preprocessor: (value: unknown) => unknown | Promise<unknown>): SchemaValidator<T, SchemaTypesStructures>;
-    addSchemaType<K, L extends ObjectSchemaDefinitionParam<M> | Array<Schema<any>>, M = any>(name: keyof K, schema: L): SchemaValidator<T & {
-        [key in keyof K]: L;
-    }, Cons<Unfold<keyof K, ISchemaActions<L>>, SchemaTypesStructures>>;
-    get schemas(): Merge<SchemaTypesStructures>;
-    private validateDefaultType;
-    private checkValidators;
-    validate<K>(schema: keyof T | DefaultSchemaType | Schema<K>, obj: any): Promise<ValidationResult>;
-}

package/dist/schemaValidator.js

@@ -1,234 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const deep_1 = require("@cleverbrush/deep");
-const validateNumber_1 = require("./validators/validateNumber");
-const validateBoolean_1 = require("./validators/validateBoolean");
-const validateString_1 = require("./validators/validateString");
-const validateArray_1 = require("./validators/validateArray");
-const validateObject_1 = require("./validators/validateObject");
-const defaultSchemaNames = ['string', 'boolean', 'number', 'date', 'array'];
-const defaultSchemas = {
-    number: {
-        type: 'number',
-        isRequired: true,
-        isNullable: false,
-        ensureNotNaN: true,
-        ensureIsFinite: true
-    },
-    boolean: {
-        type: 'boolean',
-        isRequired: true,
-        isNullable: false
-    },
-    string: {
-        type: 'string',
-        isNullable: false,
-        isRequired: true
-    },
-    array: {
-        type: 'array'
-    },
-    object: {
-        type: 'object',
-        isNullable: false,
-        isRequired: true
-    }
-};
-const defaultSchemasValidationStrategies = {
-    number: (obj, schema, validator) => (0, validateNumber_1.validateNumber)(obj, schema, validator),
-    boolean: (obj, schema, validator) => (0, validateBoolean_1.validateBoolean)(obj, schema, validator),
-    string: (obj, schema, validator) => (0, validateString_1.validateString)(obj, schema, validator),
-    array: (obj, schema, validator) => (0, validateArray_1.validateArray)(obj, schema, validator)
-};
-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');
-        if (isDefaultType(name.toString()))
-            throw new Error(`You can't add a schema named "${name}" because it's a name of a default schema, please consider another name to be used`);
-        if (this._schemasMap.has(name.toString())) {
-            throw new Error(`Schema "${name}" already exists`);
-        }
-        if (Array.isArray(schema)) {
-            this._schemasMap.set(name.toString(), schema);
-            this._schemasCache = null;
-            return this;
-        }
-        if (typeof schema !== 'object')
-            throw new Error('Array or Object is required');
-        this._schemasMap.set(name.toString(), {
-            ...schema,
-            type: 'object'
-        });
-        this._schemasCache = null;
-        return this;
-    }
-    get schemas() {
-        if (this._schemasCache)
-            return this._schemasCache;
-        const res = {};
-        for (const key of this._schemasMap.keys()) {
-            const parts = key.split('.');
-            let curr = res;
-            for (let i = 0; i < parts.length; i++) {
-                if (i === parts.length - 1) {
-                    curr[parts[i]] = {
-                        validate: (value) => this.validate(this._schemasMap.get(key), value),
-                        schema: this._schemasMap.get(key)
-                    };
-                }
-                else {
-                    if (typeof curr[parts[i]] === 'undefined') {
-                        curr[parts[i]] = {};
-                    }
-                }
-                curr = curr[parts[i]];
-            }
-        }
-        this._schemasCache = res;
-        return this._schemasCache;
-    }
-    async validateDefaultType(name, value, mergeSchema) {
-        const strategy = defaultSchemasValidationStrategies[name];
-        let finalSchema = defaultSchemas[name];
-        if (strategy) {
-            if (typeof mergeSchema === 'object') {
-                finalSchema = (0, deep_1.deepExtend)(finalSchema, mergeSchema);
-            }
-            if (typeof mergeSchema === 'number') {
-                finalSchema = {
-                    ...finalSchema,
-                    equals: mergeSchema
-                };
-                mergeSchema;
-            }
-            let preliminaryResult = await strategy(value, finalSchema, this);
-            if (!preliminaryResult.valid)
-                return preliminaryResult;
-            preliminaryResult = await this.checkValidators(finalSchema, value);
-            return preliminaryResult;
-        }
-        throw new Error('not implemented');
-    }
-    async checkValidators(schema, value) {
-        if (!schema.isRequired && typeof value === 'undefined') {
-            return {
-                valid: true
-            };
-        }
-        if (Array.isArray(schema.validators)) {
-            const validatorsResults = await Promise.allSettled(schema.validators.map((v) => Promise.resolve(v(value))));
-            const rejections = validatorsResults
-                .filter((f) => f.status === 'rejected')
-                .map((f) => f.reason);
-            const errors = validatorsResults
-                .filter((f) => f.status === 'fulfilled' &&
-                typeof f.value !== 'boolean' &&
-                f.value.valid === false)
-                .map((f) => f.value)
-                .map((f) => f.errors);
-            if (rejections.length === 0 && errors.length === 0) {
-                return {
-                    valid: true
-                };
-            }
-            return {
-                valid: false,
-                errors: [...rejections, ...errors]
-            };
-        }
-        return {
-            valid: true
-        };
-    }
-    async validate(schema, obj) {
-        if (!schema)
-            throw new Error('schemaName is required');
-        if (typeof schema === 'string') {
-            if (isDefaultType(schema)) {
-                return await this.validateDefaultType(schema, obj);
-            }
-            else if (typeof this._schemasMap.get(schema) !== 'undefined') {
-                if (Array.isArray(this._schemasMap.get(schema))) {
-                    return this.validate(this._schemasMap.get(schema), obj);
-                }
-                const objSchema = (0, deep_1.deepExtend)(defaultSchemas.object, this._schemasMap.get(schema));
-                const res = await (0, validateObject_1.validateObject)(obj, objSchema, this);
-                if (!res.valid)
-                    return res;
-                return await this.checkValidators(objSchema, obj);
-            }
-            else {
-                return await this.validateDefaultType('string', obj, {
-                    type: 'string',
-                    equals: schema
-                });
-            }
-        }
-        if (Array.isArray(schema)) {
-            for (let i = 0; i < schema.length; i++) {
-                const res = await this.validate(schema[i], obj);
-                if (res.valid) {
-                    return res;
-                }
-            }
-            return {
-                valid: false,
-                errors: ['object does not match any schema']
-            };
-        }
-        if (typeof schema === 'number') {
-            return await this.validateDefaultType('number', obj, schema);
-        }
-        if (typeof schema === 'object') {
-            if (typeof schema.type !== 'string')
-                throw new Error('Schema has no type');
-            if (isDefaultType(schema.type)) {
-                return await this.validateDefaultType(schema.type, obj, schema);
-            }
-            else if (schema.type === 'alias') {
-                const alias = this._schemasMap.get(schema.schemaName);
-                if (typeof alias === 'undefined') {
-                    throw new Error(`Unknown schema alias - ${schema.schemaName}`);
-                }
-                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 };
-                delete schemaToMerge.type;
-                delete schemaToMerge.schemaName;
-                const finalSchema = (0, deep_1.deepExtend)(alias, schemaToMerge);
-                return await this.validate(finalSchema, obj);
-            }
-            else if (schema.type === 'object') {
-                const preliminaryResult = await (0, validateObject_1.validateObject)(obj, schema, this);
-                if (!preliminaryResult.valid)
-                    return preliminaryResult;
-                return await this.checkValidators(schema, obj);
-            }
-        }
-        throw new Error("Coldn't understand the Schema provided");
-    }
-}
-exports.default = SchemaValidator;

package/dist/validators/validateArray.d.ts

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

package/dist/validators/validateArray.js

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateArray = void 0;
-const validateArray = async (obj, schema, validator) => {
-    if (typeof obj === 'undefined' &&
-        typeof schema === 'object' &&
-        schema.isRequired === false) {
-        return {
-            valid: true
-        };
-    }
-    if (!Array.isArray(obj))
-        return {
-            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,
-            errors: [`expected to be at least ${schema.minLength} chars long`]
-        };
-    }
-    if (typeof schema.maxLength === 'number' && obj.length > schema.maxLength) {
-        return {
-            valid: false,
-            errors: [`expected to be at most ${schema.maxLength} chars long`]
-        };
-    }
-    if (typeof schema.ofType !== 'undefined') {
-        const results = await Promise.all(obj.map((i) => validator.validate(schema.ofType, i)));
-        const errors = results
-            .filter((r) => !r.valid)
-            .map((r) => r.errors)
-            .flat(Infinity);
-        if (errors.length) {
-            return {
-                valid: false,
-                errors
-            };
-        }
-        return {
-            valid: true
-        };
-    }
-    return {
-        valid: true
-    };
-};
-exports.validateArray = validateArray;

package/dist/validators/validateBoolean.d.ts

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

package/dist/validators/validateBoolean.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateBoolean = void 0;
-const validateBoolean = async (obj, schema, validator) => {
-    if (typeof obj === 'undefined' &&
-        typeof schema === 'object' &&
-        schema.isRequired === false) {
-        return {
-            valid: true
-        };
-    }
-    if (typeof obj !== 'boolean')
-        return {
-            valid: false,
-            errors: [`expected type boolean, but saw ${typeof obj}`]
-        };
-    if (typeof schema === 'boolean') {
-        return { valid: true };
-    }
-    const bool = obj;
-    if (typeof schema.equals === 'boolean') {
-        return schema.equals === bool
-            ? { valid: true }
-            : {
-                valid: false,
-                errors: [`must be equal to ${schema.equals}`]
-            };
-    }
-    return {
-        valid: true
-    };
-};
-exports.validateBoolean = validateBoolean;

package/dist/validators/validateNumber.d.ts

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