validno 0.4.0 → 0.4.3

package/dist/validateEngine/methods/validateType.js

@@ -1,134 +0,0 @@
-import { ValidationDetails, ValidationIds } from "../../constants/details.js";
-import _validations from "../../utils/validations.js";
-import _errors from "../../utils/errors.js";
-import _validateType from "../../utils/validateType.js";
-const validateUnionType = (key, value, requirements, keyName = key) => {
-    const typeList = Array.isArray(requirements.type)
-        ? requirements.type.map((el) => String((el === null || el === void 0 ? void 0 : el.name) || el))
-        : [];
-    const results = [];
-    for (let i = 0; i < typeList.length; i++) {
-        const requirementsRe = Object.assign(Object.assign({}, requirements), { type: requirements.type[i] });
-        const result = handleTypeValidation(key, value, requirementsRe);
-        results.push(result[0].passed);
-        if (results[i] === true)
-            return _validateType.getResult(keyName, true);
-    }
-    const isPassed = results.some((r) => r === true);
-    const result = _validateType.getResult(keyName, isPassed, isPassed ? null : _errors.getErrorDetails(keyName, typeList.join('/'), value));
-    return result;
-};
-const handleTypeValidation = (key, value, requirements, keyName = key) => {
-    var _a;
-    const isNotNull = value !== null;
-    const keyTitle = 'title' in requirements ? requirements.title : keyName;
-    const hasCustomMessage = requirements.customMessage && typeof requirements.customMessage === 'function';
-    if (value === undefined && requirements.required) {
-        return [_validateType.getResult(keyName, false, _errors.getMissingError(keyName))];
-    }
-    if (Array.isArray(requirements.type)) {
-        return [validateUnionType(key, value, requirements)];
-    }
-    if (value === undefined && requirements.required !== true) {
-        return [_validateType.getResult(keyName, true)];
-    }
-    const customErrDetails = hasCustomMessage ?
-        requirements.customMessage({
-            keyword: ValidationIds.Type,
-            value: value,
-            key: keyName,
-            title: keyTitle,
-            reqs: requirements,
-            schema: null
-        }) :
-        null;
-    const baseErrDetails = _errors.getErrorDetails(keyName, requirements.type, value);
-    const getDetails = (isOK, errorText) => isOK ?
-        ValidationDetails.OK :
-        errorText || customErrDetails || baseErrDetails;
-    const typeBySchema = requirements.type;
-    const result = [];
-    switch (typeBySchema) {
-        case 'any': {
-            result.push(_validateType.getResult(keyName, true, getDetails(true)));
-            break;
-        }
-        case Number: {
-            const isNumber = isNotNull && value.constructor === Number;
-            result.push(_validateType.getResult(keyName, isNumber, getDetails(isNumber)));
-            break;
-        }
-        case String: {
-            const isString = isNotNull && value.constructor === String;
-            result.push(_validateType.getResult(keyName, isString, getDetails(isString)));
-            break;
-        }
-        case Date: {
-            const isDate = isNotNull && value.constructor === Date;
-            const isValid = isDate && !isNaN(value.getTime());
-            const isValidDate = isDate && isValid;
-            result.push(_validateType.getResult(keyName, isValidDate, getDetails(isValidDate, ValidationDetails.INVALID_DATE)));
-            break;
-        }
-        case Boolean: {
-            const isBoolean = isNotNull && value.constructor === Boolean;
-            result.push(_validateType.getResult(keyName, isBoolean, getDetails(isBoolean)));
-            break;
-        }
-        case Array: {
-            const isArray = isNotNull && value.constructor === Array;
-            if (!isArray) {
-                result.push(_validateType.getResult(keyName, false, getDetails(isArray)));
-                break;
-            }
-            let isEachChecked = { passed: true, details: "" };
-            if ('eachType' in requirements) {
-                for (const el of value) {
-                    const result = handleTypeValidation(`each of ${key}`, el, { type: requirements.eachType, required: true });
-                    if (!result[0].passed) {
-                        isEachChecked.passed = false;
-                        isEachChecked.details = result[0].details || '';
-                        break;
-                    }
-                }
-            }
-            const isOk = isArray && isEachChecked.passed;
-            const details = !isEachChecked.passed ? isEachChecked.details : getDetails(isOk);
-            result.push(_validateType.getResult(keyName, isOk, details));
-            break;
-        }
-        case Object: {
-            const isObject = _validations.isObject(value) && value.constructor === Object;
-            result.push(_validateType.getResult(keyName, isObject, getDetails(isObject)));
-            break;
-        }
-        case RegExp: {
-            const isRegex = _validations.isRegex(value);
-            result.push(_validateType.getResult(keyName, isRegex, getDetails(isRegex)));
-            break;
-        }
-        case null: {
-            const isNull = value === null;
-            result.push(_validateType.getResult(keyName, isNull, getDetails(isNull)));
-            break;
-        }
-        default: {
-            const isInstanceOf = typeof typeBySchema === 'function' && value instanceof typeBySchema;
-            const isConstructorSame = typeof typeBySchema === 'function' && ((_a = value.constructor) === null || _a === void 0 ? void 0 : _a.name) === (typeBySchema === null || typeBySchema === void 0 ? void 0 : typeBySchema.name);
-            const isOK = isInstanceOf && isConstructorSame;
-            result.push(_validateType.getResult(keyName, isOK, getDetails(isOK)));
-        }
-    }
-    return result;
-};
-function validateType(input) {
-    const { results, key, value, reqs, nestedKey, typeChecked } = input;
-    const typeCheck = handleTypeValidation(key, value, reqs, nestedKey);
-    typeCheck.forEach((res) => {
-        if (!res.passed) {
-            typeChecked.push(false);
-            results.errors.push(res.details || '');
-        }
-    });
-}
-export default validateType;

package/dist/validateEngine/validate.js

@@ -1,14 +0,0 @@
-import _helpers from "../utils/helpers.js";
-function validate(data, validationKeys) {
-    const hasKeysToCheck = _helpers.areKeysLimited(validationKeys);
-    const schemaKeys = Object.entries(this.definition);
-    for (const [key, reqs] of schemaKeys) {
-        const toBeValidated = _helpers.needValidation(key, hasKeysToCheck, validationKeys);
-        if (!toBeValidated)
-            continue;
-        const keyResult = this.validateKey({ key, data, reqs });
-        this.result.merge(keyResult);
-    }
-    return this.result.finish();
-}
-export default validate;

package/dist/validateRules.js

@@ -1,159 +0,0 @@
-import _validations from "./utils/validations.js";
-export const rulesParams = {
-    lengthMin: {
-        allowedTypes: [String]
-    }
-};
-const ensureRuleHasCorrectType = (value, allowedTypes) => {
-    const isInAllowedList = allowedTypes.some(TYPE => {
-        const getType = (el) => Object.prototype.toString.call(el);
-        return getType(new TYPE()) == getType(value);
-    });
-    return isInAllowedList;
-};
-const rulesFunctions = {
-    custom: (key, val, func, extra) => {
-        return func(val, extra);
-    },
-    isEmail: (key, val) => {
-        return {
-            result: _validations.isEmail(val),
-            details: `Значение должно соответствовать формату name@email.ru`
-        };
-    },
-    is: (key, val, equalTo) => {
-        return {
-            result: _validations.is(val, equalTo),
-            details: `Значение должно быть "${equalTo}"`
-        };
-    },
-    isNot: (key, val, notEqualTo) => {
-        return {
-            result: _validations.isNot(val, notEqualTo),
-            details: `Значение "${notEqualTo}" недопустимо`
-        };
-    },
-    min: (key, val, min) => {
-        return {
-            result: _validations.isNumberGte(val, min),
-            details: "Значение не может быть меньше " + min
-        };
-    },
-    max: (key, val, max) => {
-        return {
-            result: _validations.isNumberLte(val, max),
-            details: "Значение не может быть больше " + max
-        };
-    },
-    minMax: (key, val, minMax) => {
-        const [min, max] = minMax;
-        return {
-            result: _validations.isNumberGte(val, min) && _validations.isNumberLte(val, max),
-            details: `Значение должно быть в пределах ${min}-${max}`
-        };
-    },
-    length: (key, val, length) => {
-        return {
-            result: _validations.lengthIs(val, length),
-            details: "Количество символов должно быть равным " + length
-        };
-    },
-    lengthNot: (key, val, lengthNot) => {
-        return {
-            result: _validations.lengthNot(val, lengthNot),
-            details: "Количество символов не должно быть равным " + lengthNot
-        };
-    },
-    lengthMinMax: (key, val, minMax) => {
-        const [min, max] = minMax;
-        return {
-            result: _validations.lengthMin(val, min) && _validations.lengthMax(val, max),
-            details: `Длина должна быть от ${min} до ${max} символов`
-        };
-    },
-    lengthMin: (key, val, min) => {
-        ensureRuleHasCorrectType(val, rulesParams['lengthMin'].allowedTypes);
-        return {
-            result: _validations.lengthMin(val, min),
-            details: `Длина не может быть меньше ${min} символов`
-        };
-    },
-    lengthMax: (key, val, max) => {
-        return {
-            result: _validations.lengthMax(val, max),
-            details: `Длина не может быть больше ${max} символов`
-        };
-    },
-    regex: (key, val, regex) => {
-        return {
-            result: _validations.regexTested(val, regex),
-            details: "Значение не соответствует допустимому формату"
-        };
-    },
-    enum: (key, value, allowedList) => {
-        const output = {
-            result: true,
-            details: ''
-        };
-        if (!Array.isArray(value)) {
-            const isCorrect = allowedList.includes(value);
-            output.result = isCorrect,
-                output.details = isCorrect ? '' : `Значение "${value}" недопустимо`;
-        }
-        else {
-            const incorrectValues = [];
-            value.forEach((v) => !allowedList.includes(v) ? incorrectValues.push(v) : {});
-            const isCorrect = incorrectValues.length === 0;
-            output.result = isCorrect,
-                output.details = isCorrect ? '' : `Значения недопустимы: "${incorrectValues.join(', ')}"`;
-        }
-        return output;
-    }
-};
-function validateRules(key, value, requirements, inputObj) {
-    const result = {
-        ok: true,
-        details: []
-    };
-    if (requirements.required !== true && value === undefined)
-        return result;
-    if (!requirements || !requirements.rules || !Object.keys(requirements.rules).length) {
-        return result;
-    }
-    const rules = requirements.rules;
-    const title = requirements.title || key;
-    const allResults = [];
-    const allRulesKeys = Object.keys(rules);
-    let i = 0;
-    while (i < allRulesKeys.length) {
-        const ruleName = allRulesKeys[i];
-        if (ruleName in rulesFunctions === false) {
-            i++;
-            continue;
-        }
-        const func = rulesFunctions[ruleName];
-        const args = rules[ruleName];
-        const result = func(key, value, args, { schema: this.schema, input: inputObj });
-        if (requirements.customMessage && typeof requirements.customMessage === 'function') {
-            result.details = requirements.customMessage({
-                keyword: ruleName,
-                value: value,
-                key: key,
-                title: title,
-                reqs: requirements,
-                schema: this.schema,
-                rules: rules,
-            });
-        }
-        allResults.push(result);
-        i++;
-    }
-    const failedResults = allResults.filter(el => el.result === false);
-    if (failedResults.length) {
-        result.ok = false;
-        result.details = failedResults.map(el => el.details);
-    }
-    return result;
-}
-;
-export default validateRules;

package/dist/validateSchema/ValidateEngine.js

@@ -1,147 +0,0 @@
-import validateType from "../validateType.js";
-import validateRules from "../validateRules.js";
-import { ValidationIds } from "../constants/details.js";
-import ValidnoResult from "../ValidnoResult.js";
-import _errors from "../utils/errors.js";
-import _helpers from "../utils/helpers.js";
-class ValidateEngine {
-    constructor(definition) {
-        this.definition = definition;
-        this.result = new ValidnoResult();
-    }
-    validate(data, validationKeys) {
-        const hasKeysToCheck = _helpers.areKeysLimited(validationKeys);
-        const schemaKeys = Object.entries(this.definition);
-        for (const [key, reqs] of schemaKeys) {
-            const toBeValidated = _helpers.needValidation(key, hasKeysToCheck, validationKeys);
-            if (!toBeValidated)
-                continue;
-            const keyResult = this.validateKey({ key, data, reqs });
-            this.result.merge(keyResult);
-        }
-        return this.result.finish();
-    }
-    handleMissingKey(schema, input) {
-        const { key, nestedKey, data, reqs } = input;
-        const messageKey = nestedKey || key;
-        const messageTitle = reqs.title || messageKey;
-        if (!reqs.customMessage) {
-            return _errors.getMissingError(messageKey);
-        }
-        const errorMessage = reqs.customMessage({
-            keyword: ValidationIds.Missing,
-            value: data[key],
-            key: messageKey,
-            title: messageTitle,
-            reqs,
-            schema,
-        });
-        return errorMessage;
-    }
-    validateNestedKey(input) {
-        const { results, key, nestedKey, data, reqs } = input;
-        const nestedKeys = Object.keys(reqs);
-        const nestedResults = [];
-        for (const itemKey of nestedKeys) {
-            const deepParams = {
-                key: itemKey,
-                data: data[key],
-                reqs: reqs[itemKey],
-                nestedKey: `${nestedKey}.${itemKey}`
-            };
-            const deepResults = this.validateKey(deepParams);
-            nestedResults.push(deepResults.ok);
-            results.merge(deepResults);
-        }
-        results.fixParentByChilds(nestedKey, nestedResults);
-        return results;
-    }
-    validateKey(input) {
-        let { results, key, nestedKey, data, reqs } = input;
-        if (data === undefined) {
-            const noDataResult = new ValidnoResult();
-            noDataResult.setNoData();
-            noDataResult.finish();
-            return noDataResult;
-        }
-        if (!results)
-            results = new ValidnoResult();
-        if (!nestedKey)
-            nestedKey = key;
-        const hasMissing = _helpers.hasMissing(input);
-        if (_helpers.checkNestedIsMissing(reqs, data)) {
-            return this.handleMissingNestedKey(results, nestedKey);
-        }
-        if (_helpers.checkIsNested(reqs)) {
-            return this.validateNestedKey({ results, key, data, reqs, nestedKey });
-        }
-        return this.validateKeyDetails({
-            results,
-            key,
-            nestedKey,
-            data,
-            reqs,
-            hasMissing,
-        });
-    }
-    handleMissingNestedKey(results, nestedKey) {
-        results.setMissing(nestedKey);
-        return results;
-    }
-    validateKeyDetails(params) {
-        const { results, key, nestedKey, data, reqs, hasMissing } = params;
-        const missedCheck = [];
-        const typeChecked = [];
-        const rulesChecked = [];
-        if (hasMissing) {
-            return this.handleMissingKeyValidation({ results, key, nestedKey, data, reqs }, missedCheck);
-        }
-        this.checkValueType(results, key, data[key], reqs, nestedKey, typeChecked);
-        this.checkRulesForKey(results, nestedKey, data[key], reqs, data, rulesChecked);
-        return this.finalizeValidation({ results, nestedKey, missedCheck, typeChecked, rulesChecked });
-    }
-    handleMissingKeyValidation(params, missedCheck) {
-        const schema = this.definition;
-        const { results, key, nestedKey, data, reqs } = params;
-        const errMsg = this.handleMissingKey(schema, { key, nestedKey, data, reqs });
-        missedCheck.push(false);
-        results.setMissing(nestedKey, errMsg);
-        return results;
-    }
-    checkValueType(results, key, value, reqs, nestedKey, typeChecked) {
-        const typeCheck = validateType(key, value, reqs, nestedKey);
-        typeCheck.forEach((res) => {
-            if (!res.passed) {
-                typeChecked.push(false);
-                results.errors.push(res.details || '');
-            }
-        });
-    }
-    checkRulesForKey(results, nestedKey, value, reqs, data, rulesChecked) {
-        const ruleCheck = validateRules.call(this, nestedKey, value, reqs, data);
-        if (!ruleCheck.ok) {
-            rulesChecked.push(false);
-            ruleCheck.details.forEach((el) => {
-                if (!(nestedKey in results.errorsByKeys))
-                    results.errorsByKeys[nestedKey] = [];
-                results.errors.push(el);
-                results.errorsByKeys[nestedKey] = ['1'];
-            });
-        }
-    }
-    finalizeValidation(checks) {
-        const { results, nestedKey, missedCheck, typeChecked, rulesChecked } = checks;
-        if (missedCheck.length)
-            results.setMissing(nestedKey);
-        const isPassed = !typeChecked.length && !rulesChecked.length && !missedCheck.length;
-        if (!isPassed) {
-            results.setFailed(nestedKey);
-            results.errorsByKeys[nestedKey] = [...results.errors];
-        }
-        else {
-            results.setPassed(nestedKey);
-        }
-        return results.finish();
-    }
-}
-export default ValidateEngine;

package/dist/validateSchema/index.js

@@ -1,6 +0,0 @@
-import ValidateEngine from "./ValidateEngine.js";
-const validateSchema = (schemaDef, data, keysToValidate) => {
-    const engine = new ValidateEngine(schemaDef);
-    return engine.validate(data, keysToValidate);
-};
-export default validateSchema;

package/dist/validateSchema/validate.js

@@ -1,151 +0,0 @@
-import validateType from "../validateType.js";
-import validateRules from "../validateRules.js";
-import { ValidationIds } from "../constants/details.js";
-import ValidnoResult from "../ValidnoResult.js";
-import _errors from "../utils/errors.js";
-import _helpers from "../utils/helpers.js";
-class ValidateEngine {
-    constructor(definition) {
-        this.definition = definition;
-        this.result = new ValidnoResult();
-    }
-    validate(data, validationKeys) {
-        const hasKeysToCheck = _helpers.areKeysLimited(validationKeys);
-        const schemaKeys = Object.entries(this.definition);
-        for (const [key, reqs] of schemaKeys) {
-            const toBeValidated = _helpers.needValidation(key, hasKeysToCheck, validationKeys);
-            if (!toBeValidated)
-                continue;
-            const keyResult = this.validateKey({ key, data, reqs });
-            this.result.merge(keyResult);
-        }
-        return this.result.finish();
-    }
-    handleMissingKey(schema, input) {
-        const { key, nestedKey, data, reqs } = input;
-        const messageKey = nestedKey || key;
-        const messageTitle = reqs.title || messageKey;
-        if (!reqs.customMessage) {
-            return _errors.getMissingError(messageKey);
-        }
-        const errorMessage = reqs.customMessage({
-            keyword: ValidationIds.Missing,
-            value: data[key],
-            key: messageKey,
-            title: messageTitle,
-            reqs,
-            schema,
-        });
-        return errorMessage;
-    }
-    validateNestedKey(input) {
-        const { results, key, nestedKey, data, reqs } = input;
-        const nestedKeys = Object.keys(reqs);
-        const nestedResults = [];
-        for (const itemKey of nestedKeys) {
-            const deepParams = {
-                key: itemKey,
-                data: data[key],
-                reqs: reqs[itemKey],
-                nestedKey: `${nestedKey}.${itemKey}`
-            };
-            const deepResults = this.validateKey(deepParams);
-            nestedResults.push(deepResults.ok);
-            results.merge(deepResults);
-        }
-        results.fixParentByChilds(nestedKey, nestedResults);
-        return results;
-    }
-    validateKey(input) {
-        let { results, key, nestedKey, data, reqs } = input;
-        if (data === undefined) {
-            const noDataResult = new ValidnoResult();
-            noDataResult.setNoData();
-            noDataResult.finish();
-            return noDataResult;
-        }
-        if (!results)
-            results = new ValidnoResult();
-        if (!nestedKey)
-            nestedKey = key;
-        const hasMissing = _helpers.hasMissing(input);
-        if (_helpers.checkNestedIsMissing(reqs, data)) {
-            return this.handleMissingNestedKey(results, nestedKey);
-        }
-        if (_helpers.checkIsNested(reqs)) {
-            return this.validateNestedKey({ results, key, data, reqs, nestedKey });
-        }
-        return this.validateKeyDetails({
-            results,
-            key,
-            nestedKey,
-            data,
-            reqs,
-            hasMissing,
-        });
-    }
-    handleMissingNestedKey(results, nestedKey) {
-        results.setMissing(nestedKey);
-        return results;
-    }
-    validateKeyDetails(params) {
-        const { results, key, nestedKey, data, reqs, hasMissing } = params;
-        const missedCheck = [];
-        const typeChecked = [];
-        const rulesChecked = [];
-        if (hasMissing) {
-            return this.handleMissingKeyValidation({ results, key, nestedKey, data, reqs }, missedCheck);
-        }
-        this.checkValueType(results, key, data[key], reqs, nestedKey, typeChecked);
-        this.checkRulesForKey(results, nestedKey, data[key], reqs, data, rulesChecked);
-        return this.finalizeValidation({ results, nestedKey, missedCheck, typeChecked, rulesChecked });
-    }
-    handleMissingKeyValidation(params, missedCheck) {
-        const schema = this.definition;
-        const { results, key, nestedKey, data, reqs } = params;
-        const errMsg = this.handleMissingKey(schema, { key, nestedKey, data, reqs });
-        missedCheck.push(false);
-        results.setMissing(nestedKey, errMsg);
-        return results;
-    }
-    checkValueType(results, key, value, reqs, nestedKey, typeChecked) {
-        const typeCheck = validateType(key, value, reqs, nestedKey);
-        typeCheck.forEach((res) => {
-            if (!res.passed) {
-                typeChecked.push(false);
-                results.errors.push(res.details || '');
-            }
-        });
-    }
-    checkRulesForKey(results, nestedKey, value, reqs, data, rulesChecked) {
-        const ruleCheck = validateRules.call(this, nestedKey, value, reqs, data);
-        if (!ruleCheck.ok) {
-            rulesChecked.push(false);
-            ruleCheck.details.forEach((el) => {
-                if (!(nestedKey in results.errorsByKeys))
-                    results.errorsByKeys[nestedKey] = [];
-                results.errors.push(el);
-                results.errorsByKeys[nestedKey] = ['1'];
-            });
-        }
-    }
-    finalizeValidation(checks) {
-        const { results, nestedKey, missedCheck, typeChecked, rulesChecked } = checks;
-        if (missedCheck.length)
-            results.setMissing(nestedKey);
-        const isPassed = !typeChecked.length && !rulesChecked.length && !missedCheck.length;
-        if (!isPassed) {
-            results.setFailed(nestedKey);
-            results.errorsByKeys[nestedKey] = [...results.errors];
-        }
-        else {
-            results.setPassed(nestedKey);
-        }
-        return results.finish();
-    }
-}
-const validateSchema = (schemaDef, data, keysToValidate) => {
-    const engine = new ValidateEngine(schemaDef);
-    return engine.validate(data, keysToValidate);
-};
-export default validateSchema;

package/dist/validateSchema.js

@@ -1,6 +0,0 @@
-import ValidateEngine from "./validateEngine/index.js";
-const validateSchema = (schemaDef, data, keysToValidate) => {
-    const engine = new ValidateEngine(schemaDef);
-    return engine.validate(data, keysToValidate);
-};
-export default validateSchema;