@cleverbrush/schema 0.0.16 → 1.0.0-beta.0

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/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;