@cleverbrush/schema 1.0.0-beta.2 → 1.0.0-beta.4

package/dist/schemaRegistry.js

@@ -0,0 +1,278 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const validateNumber_js_1 = require("./validators/validateNumber.js");
+const validateBoolean_js_1 = require("./validators/validateBoolean.js");
+const validateString_js_1 = require("./validators/validateString.js");
+const validateArray_js_1 = require("./validators/validateArray.js");
+const validateObject_js_1 = require("./validators/validateObject.js");
+const validateUnion_js_1 = require("./validators/validateUnion.js");
+const validateFunction_js_1 = require("./validators/validateFunction.js");
+const NumberSchemaBuilder_js_1 = require("./builders/NumberSchemaBuilder.js");
+const UnionSchemaBuilder_js_1 = require("./builders/UnionSchemaBuilder.js");
+const ObjectSchemaBuilder_js_1 = require("./builders/ObjectSchemaBuilder.js");
+const StringSchemaBuilder_js_1 = require("./builders/StringSchemaBuilder.js");
+const BooleanSchemaBuilder_js_1 = require("./builders/BooleanSchemaBuilder.js");
+const ArraySchemaBuilder_js_1 = require("./builders/ArraySchemaBuilder.js");
+const FunctionSchemaBuilder_js_1 = require("./builders/FunctionSchemaBuilder.js");
+const defaultSchemas_js_1 = require("./defaultSchemas.js");
+const SchemaBuilder_js_1 = require("./builders/SchemaBuilder.js");
+const defaultSchemaNames = ['string', 'boolean', 'number', 'array', 'function'];
+const defaultSchemasValidationStrategies = {
+    number: (obj, schema) => (0, validateNumber_js_1.validateNumber)(obj, schema),
+    boolean: (obj, schema) => (0, validateBoolean_js_1.validateBoolean)(obj, schema),
+    string: (obj, schema) => (0, validateString_js_1.validateString)(obj, schema),
+    array: (obj, schema, validator) => (0, validateArray_js_1.validateArray)(obj, schema, validator),
+    function: (obj, schema) => (0, validateFunction_js_1.validateFunction)(obj, schema)
+};
+const isDefaultType = (name) => defaultSchemaNames.indexOf(name) !== -1;
+class SchemaRegistry {
+    _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`);
+        if (typeof preprocessor !== 'function') {
+            throw new Error('preprocessor must be a function');
+        }
+        this._preprocessorsMap.set(name, preprocessor);
+        return this;
+    }
+    _aliasBuilder = (schemaName) => {
+        if (typeof schemaName !== 'string' || !schemaName)
+            throw new Error('schemaName must be non-empty string');
+        const aliasSchema = this._schemasMap.get(schemaName.toString());
+        if (!aliasSchema)
+            throw new Error(`Schema name ${schemaName} is not defined.`);
+        return aliasSchema;
+    };
+    _externalAlias = (registry, schemaName) => {
+        if (typeof schemaName !== 'string' || !schemaName)
+            throw new Error('schemaName must be non-empty string');
+        // TODO: accessing private property here...
+        const externalSchema = registry._schemasMap.get(schemaName);
+        if (!externalSchema)
+            throw new Error(`Schema name ${schemaName} is not defined.`);
+        return externalSchema;
+    };
+    addSchemaFrom(oldName, name, param) {
+        if (!this._schemasMap.has(oldName.toString())) {
+            throw new Error(`unknown schema name ${oldName.toString()}`);
+        }
+        const oldSchema = this._schemasMap.get(oldName.toString());
+        const schema = typeof param === 'function'
+            ? param({
+                base: oldSchema,
+                alias: this._aliasBuilder,
+                array: ArraySchemaBuilder_js_1.array,
+                boolean: BooleanSchemaBuilder_js_1.boolean,
+                func: FunctionSchemaBuilder_js_1.func,
+                number: NumberSchemaBuilder_js_1.number,
+                object: ObjectSchemaBuilder_js_1.object,
+                string: StringSchemaBuilder_js_1.string,
+                union: UnionSchemaBuilder_js_1.union
+            })
+            : param;
+        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 instanceof SchemaBuilder_js_1.SchemaBuilder
+                ? schema._schema
+                : schema)
+        });
+        this._schemasCache = null;
+        return this;
+    }
+    addSchema(name, param) {
+        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`);
+        }
+        const schema = typeof param === 'function'
+            ? param({
+                alias: this._aliasBuilder,
+                external: this._externalAlias,
+                array: ArraySchemaBuilder_js_1.array,
+                boolean: BooleanSchemaBuilder_js_1.boolean,
+                number: NumberSchemaBuilder_js_1.number,
+                object: ObjectSchemaBuilder_js_1.object,
+                string: StringSchemaBuilder_js_1.string,
+                union: UnionSchemaBuilder_js_1.union,
+                func: FunctionSchemaBuilder_js_1.func
+            })
+            : param;
+        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 instanceof SchemaBuilder_js_1.SchemaBuilder ? schema.clone() : schema);
+        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: async (value) => {
+                            const result = await this.validate(this._schemasMap.get(key), value);
+                            if (!result.valid) {
+                                return result;
+                            }
+                            return {
+                                ...result,
+                                object: 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_js_1.defaultSchemas[name];
+        if (strategy) {
+            if (typeof mergeSchema === 'object' && mergeSchema) {
+                finalSchema = Object.assign({}, 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(schemaToValidate, obj) {
+        if (!schemaToValidate)
+            throw new Error('schemaName is required');
+        const schema = schemaToValidate instanceof SchemaBuilder_js_1.SchemaBuilder
+            ? schemaToValidate._schema
+            : schemaToValidate;
+        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 = Object.assign({}, defaultSchemas_js_1.defaultSchemas.object, this._schemasMap.get(schema));
+                const res = await (0, validateObject_js_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') {
+            const spec = schema;
+            if (typeof spec.type !== 'string')
+                throw new Error('Schema has no type');
+            if (isDefaultType(spec.type)) {
+                return await this.validateDefaultType(spec.type, obj, schema);
+            }
+            else if (spec.type === 'union') {
+                return await (0, validateUnion_js_1.validateUnion)(obj, spec, this);
+            }
+            else if (spec.type === 'object') {
+                const preliminaryResult = await (0, validateObject_js_1.validateObject)(obj, schema, this);
+                if (!preliminaryResult.valid)
+                    return preliminaryResult;
+                return await this.checkValidators(schema, obj);
+            }
+            else if (spec.type === 'function') {
+                return await (0, validateFunction_js_1.validateFunction)(obj, spec);
+            }
+        }
+        throw new Error("Couldn't understand the Schema provided");
+    }
+}
+exports.default = SchemaRegistry;

package/dist/validators/validateArray.d.ts

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

package/dist/validators/validateArray.js

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

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

package/dist/validators/validateBoolean.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateBoolean = void 0;
+const validateBoolean = async (obj, schema) => {
+    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}`]
+        };
+    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/validateFunction.d.ts

@@ -0,0 +1,2 @@
+import { FunctionSchema, ValidationResult } from '../schema.js';
+export declare const validateFunction: (obj: any, schema: FunctionSchema) => Promise<ValidationResult>;

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

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

package/dist/validators/validateNumber.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateNumber = void 0;
+const validateNumber = async (obj, schema) => {
+    if (typeof obj === 'undefined' &&
+        typeof schema === 'object' &&
+        schema.isRequired === false) {
+        return {
+            valid: true
+        };
+    }
+    if (typeof obj !== 'number')
+        return {
+            valid: false,
+            errors: [`expected type number, but saw ${typeof obj}`]
+        };
+    if (typeof schema === 'number') {
+        return obj === schema
+            ? { valid: true }
+            : {
+                valid: false,
+                errors: [`should be equal to ${schema}`]
+            };
+    }
+    const num = obj;
+    if (schema.ensureNotNaN && Number.isNaN(num)) {
+        return {
+            valid: false,
+            errors: ['is not expected to be NaN']
+        };
+    }
+    if (schema.ensureIsFinite &&
+        !Number.isFinite(num) &&
+        schema.ensureNotNaN &&
+        !Number.isNaN(num)) {
+        return {
+            valid: false,
+            errors: ['is expected to be a finite number']
+        };
+    }
+    if (typeof schema.equals !== 'undefined' && num !== schema.equals) {
+        return {
+            valid: false,
+            errors: [`expected to be equal to ${schema.equals}`]
+        };
+    }
+    if (typeof schema.min !== 'undefined') {
+        if (typeof schema.min !== 'number')
+            throw new Error('min constraint should be a number');
+        if (num < schema.min)
+            return {
+                valid: false,
+                errors: [`expected to be at least ${schema.min}`]
+            };
+    }
+    if (typeof schema.max !== 'undefined') {
+        if (typeof schema.max !== 'number')
+            throw new Error('max constraint should be a number');
+        if (num > schema.max)
+            return {
+                valid: false,
+                errors: [`expected to be no more than ${schema.max}`]
+            };
+    }
+    return {
+        valid: true
+    };
+};
+exports.validateNumber = validateNumber;

package/dist/validators/validateObject.d.ts

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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateObject = void 0;
+const validateObject = async (obj, schema, validator) => {
+    if (typeof obj === 'undefined' &&
+        typeof schema === 'object' &&
+        schema.isRequired === false) {
+        return {
+            valid: true
+        };
+    }
+    if (typeof obj !== 'object') {
+        return {
+            valid: false,
+            errors: [
+                `expected to have type='object', but saw '${typeof obj}' instead`
+            ]
+        };
+    }
+    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') {
+                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`);
+                }
+                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(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]) => {
+                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);
+        if (errors.length) {
+            return {
+                valid: false,
+                errors
+            };
+        }
+    }
+    return {
+        valid: true
+    };
+};
+exports.validateObject = validateObject;

package/dist/validators/validateString.d.ts

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

package/dist/validators/validateString.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateString = void 0;
+const validateString = async (obj, schema) => {
+    if (typeof obj === 'undefined' &&
+        typeof schema === 'object' &&
+        schema.isRequired === false) {
+        return {
+            valid: true
+        };
+    }
+    if (typeof obj !== 'string')
+        return {
+            valid: false,
+            errors: [`expected type string, but saw ${typeof obj}`]
+        };
+    if (typeof schema === 'string') {
+        return obj === schema
+            ? { valid: true }
+            : {
+                valid: false,
+                errors: [`should be equal to ${schema}`]
+            };
+    }
+    const str = obj;
+    if (typeof schema.equals === 'string' && str !== schema.equals) {
+        return {
+            valid: false,
+            errors: [
+                `expected to be equal to '${schema.equals}' but saw '${str}'`
+            ]
+        };
+    }
+    if (typeof schema.minLength === 'number' && str.length < schema.minLength) {
+        return {
+            valid: false,
+            errors: [`expected to be at least ${schema.minLength} chars long`]
+        };
+    }
+    if (typeof schema.maxLength === 'number' && str.length > schema.maxLength) {
+        return {
+            valid: false,
+            errors: [`expected to be at most ${schema.maxLength} chars long`]
+        };
+    }
+    return {
+        valid: true
+    };
+};
+exports.validateString = validateString;

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;