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

package/dist/schemaRegistry.js

@@ -1,301 +0,0 @@
-"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 AliasSchemaBuilder_js_1 = require("./builders/AliasSchemaBuilder.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;
-    }
-    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({
-                schema: oldSchema,
-                alias: AliasSchemaBuilder_js_1.alias,
-                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: AliasSchemaBuilder_js_1.alias,
-                external: AliasSchemaBuilder_js_1.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 === 'alias') {
-                if (spec.isRequired === false && typeof obj === 'undefined') {
-                    return {
-                        valid: true
-                    };
-                }
-                if (spec.isNullable === true && obj === null) {
-                    return {
-                        valid: true
-                    };
-                }
-                const registry = (spec.externalRegistry ||
-                    this);
-                const alias = registry._schemasMap.get(spec.schemaName);
-                if (typeof alias === 'undefined') {
-                    throw new Error(`Unknown schema alias - ${spec.schemaName}`);
-                }
-                if (Array.isArray(alias)) {
-                    if ((!spec.isRequired && typeof obj === 'undefined') ||
-                        (spec.isNullable && obj === null)) {
-                        return {
-                            valid: true
-                        };
-                    }
-                    return await registry.validate(alias, obj);
-                }
-                if (typeof alias !== 'object')
-                    throw new Error('it is only possible to use a full schema schema definition as alias');
-                let schemaToValidate = alias;
-                if (alias instanceof SchemaBuilder_js_1.SchemaBuilder) {
-                    if (typeof schema.isRequired === 'boolean') {
-                        schemaToValidate = schemaToValidate[schema.isRequired ? 'required' : 'optional']();
-                    }
-                    if (typeof schema.isNullable === 'boolean') {
-                        schemaToValidate = schemaToValidate[schema.isNullable ? 'nullable' : 'notNullable']();
-                    }
-                }
-                return await registry.validate(schemaToValidate, obj);
-            }
-            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

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

@@ -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 { BooleanSchema, ValidationResult } from '../schema.js';
-export declare const validateBoolean: (obj: any, schema: BooleanSchema) => Promise<ValidationResult>;

package/dist/validators/validateBoolean.js

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

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

package/dist/validators/validateFunction.js

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

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

package/dist/validators/validateNumber.js

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

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

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

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

package/dist/validators/validateString.js

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

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