validno 0.1.0

package/.eslintrc.cjs

@@ -0,0 +1,13 @@
+module.exports = {
+    "env": {
+        "browser": true,
+        "es2021": true
+    },
+    "extends": "eslint:recommended",
+    "parserOptions": {
+        "ecmaVersion": "latest",
+        "sourceType": "module"
+    },
+    "rules": {
+    }
+}

package/.eslintrc.json

@@ -0,0 +1,16 @@
+{
+    "env": {
+        "browser": true,
+        "commonjs": true,
+        "es2021": true,
+        "node": true
+    },
+    "extends": [
+        "eslint:recommended"
+    ],
+    "parserOptions": {
+        "ecmaVersion": 12
+    },
+    "rules": {
+    }
+}

package/README.md

@@ -0,0 +1 @@
+#TODO

package/dist/Schema.js

@@ -0,0 +1,15 @@
+import validate from "./validate.js";
+export const defaultSchemaKeys = [
+    "required",
+    "type",
+    "eachType",
+    "rules"
+];
+export class Schema {
+    constructor(inputSchema) {
+        this.schema = inputSchema;
+    }
+    validate(data) {
+        return validate.call(this, this, data);
+    }
+}

package/dist/Validator.js

@@ -0,0 +1,100 @@
+import checkRules from "./checkRules.js";
+import checkType from "./checkType.js";
+import { defaultSchemaKeys } from "./Schema.js";
+const getResultDefault = () => {
+    return {
+        ok: null,
+        missed: [],
+        failed: [],
+        passed: [],
+        errors: [],
+        byKeys: {}
+    };
+};
+const checkIsNested = (obj) => {
+    const objKeys = Object.keys(obj);
+    if (objKeys.every((k) => defaultSchemaKeys.includes(k))) {
+        return false;
+    }
+    else {
+        return true;
+    }
+};
+const handleReqKey = (key, data, reqs, deepKey = key) => {
+    console.log('..................... ', key);
+    const results = getResultDefault();
+    const hasNested = checkIsNested(reqs);
+    const missedCheck = [];
+    const typeChecked = [];
+    const rulesChecked = [];
+    if (hasNested) {
+        const nestedReqKeys = Object.keys(reqs);
+        let i = 0;
+        while (i < nestedReqKeys.length) {
+            const reqKeyI = nestedReqKeys[i];
+            const deepResults = handleReqKey(reqKeyI, data[key], reqs[reqKeyI], deepKey + '.' + reqKeyI);
+            results.failed = [...results.failed, ...deepResults.failed];
+            results.errors = [...results.errors, ...deepResults.errors];
+            results.missed = [...results.missed, ...deepResults.missed];
+            results.passed = [...results.passed, ...deepResults.passed];
+            results.byKeys = Object.assign(Object.assign({}, results.byKeys), deepResults.byKeys);
+            i++;
+        }
+        return results;
+    }
+    if (reqs.required === true && key in data === false) {
+        missedCheck.push(false);
+        results.errors.push(`Missing key '${deepKey}'`);
+        return results;
+    }
+    const typeCheck = checkType(key, data[key], reqs, deepKey);
+    typeCheck.forEach(res => {
+        if (res.passed === false) {
+            typeChecked.push(res.passed);
+            results.errors.push(res.details);
+        }
+    });
+    const ruleCheck = checkRules(deepKey, data[key], reqs);
+    if (!ruleCheck.ok) {
+        rulesChecked.push(false);
+        ruleCheck.details.forEach((el) => results.errors.push(el));
+    }
+    if (missedCheck.length) {
+        results.missed.push(deepKey);
+    }
+    if (typeChecked.length || rulesChecked.length) {
+        results.failed.push(deepKey);
+    }
+    else {
+        results.passed.push(deepKey);
+    }
+    console.log(missedCheck.length, typeChecked.length, rulesChecked.length);
+    results.byKeys[deepKey] = (missedCheck.length + typeChecked.length + rulesChecked.length) === 0;
+    console.log(results);
+    return results;
+};
+const validate = (schema, data) => {
+    const results = getResultDefault();
+    for (const [key, reqs] of Object.entries(schema.schema)) {
+        const keyResult = handleReqKey(key, data, reqs);
+        results.failed = [...results.failed, ...keyResult.failed];
+        results.errors = [...results.errors, ...keyResult.errors];
+        results.missed = [...results.missed, ...keyResult.missed];
+        results.passed = [...results.passed, ...keyResult.passed];
+        results.byKeys = Object.assign(Object.assign({}, results.byKeys), keyResult.byKeys);
+    }
+    if (results.failed.length)
+        results.ok = false;
+    else
+        results.ok = true;
+    results.missed = [...new Set(results.missed)];
+    results.failed = [...new Set(results.failed)];
+    results.passed = [...new Set(results.passed)];
+    results.errors = [...new Set(results.errors)];
+    return results;
+};
+class Validator {
+    constructor() { }
+}
+Validator.validate = validate;
+export default Validator;

package/dist/checkRules.js

@@ -0,0 +1,122 @@
+import _validations from "./utils/validations.js";
+const rulesFunctions = {
+    custom: (key, val, func) => {
+        return func(val);
+    },
+    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.lengthMin(val, max),
+            details: `Длина должна быть от ${min} до ${max} символов`
+        };
+    },
+    lengthMin: (key, val, min) => {
+        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) => {
+        return {
+            result: allowedList.includes(value),
+            details: `Значение "${value}" не допустимо`
+        };
+    }
+};
+const checkRules = (key, value, requirements) => {
+    const result = {
+        ok: true,
+        details: []
+    };
+    if (requirements.required !== true && value === undefined)
+        return result;
+    if ('rules' in requirements === false)
+        return result;
+    if (!requirements || !requirements.rules || !Object.keys(requirements.rules).length) {
+        return result;
+    }
+    const rules = requirements.rules;
+    const allResults = [];
+    const allRules = Object.keys(rules);
+    let i = 0;
+    while (i < allRules.length) {
+        const ruleName = allRules[i];
+        if (ruleName in rulesFunctions === false) {
+            i++;
+            continue;
+        }
+        const func = rulesFunctions[ruleName];
+        const args = rules[ruleName];
+        const result = func(key, value, args);
+        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 checkRules;

package/dist/checkType.js

@@ -0,0 +1,151 @@
+import _validations from "./utils/validations.js";
+const getErrorDetails = (key, expectedType, receivedValue) => {
+    let receivedType = '';
+    if (typeof receivedValue === 'string')
+        receivedType = 'String';
+    else if (typeof receivedValue === 'number')
+        receivedType = 'Number';
+    else if (typeof receivedValue === 'boolean')
+        receivedType = 'Noolean';
+    else if (receivedValue === null)
+        receivedType = 'null';
+    else if (Array.isArray(receivedValue))
+        receivedType = 'Array';
+    else if (_validations.isDate(receivedValue))
+        receivedType = 'Date';
+    else if (_validations.isObject(receivedValue))
+        receivedType = 'Object';
+    else if (receivedValue === undefined)
+        receivedType = 'undefined';
+    return `Проверьте тип "${key}": ожидался ${(expectedType === null || expectedType === void 0 ? void 0 : expectedType.name) || expectedType}, получен ${receivedType || 'unknown'}`;
+};
+const checkTypeMultiple = (key, value, requirements, keyName = key) => {
+    const constructorNames = requirements.type.map((el) => String((el === null || el === void 0 ? void 0 : el.name) || el));
+    const result = {
+        key: keyName,
+        passed: false,
+        details: getErrorDetails(keyName, constructorNames.join('/'), value)
+    };
+    let i = 0;
+    while (i < requirements.type.length) {
+        const requirementsRe = Object.assign(Object.assign({}, requirements), { type: requirements.type[i] });
+        const check = checkType(key, value, requirementsRe);
+        if (check[0].passed === true) {
+            result.passed = true;
+            result.details = 'Passed';
+            return result;
+        }
+        i++;
+    }
+    return result;
+};
+const checkType = (key, value, requirements, keyName = key) => {
+    if (value === undefined && requirements.required) {
+        return [{ key: keyName, passed: false, details: `Key ${keyName} is missing` }];
+    }
+    let result = [];
+    if (Array.isArray(requirements.type)) {
+        return [checkTypeMultiple(key, value, requirements)];
+    }
+    if (value === undefined && requirements.required !== true) {
+        result.push({
+            key: keyName,
+            passed: true,
+            details: 'Passed'
+        });
+        return result;
+    }
+    switch (requirements.type) {
+        case 'any':
+            result.push({
+                key: keyName,
+                passed: true,
+                details: 'Passed'
+            });
+            break;
+        case Number:
+            const isNumber = _validations.isNumber(value);
+            result.push({
+                key: keyName,
+                passed: isNumber,
+                details: isNumber ? 'Passed' : getErrorDetails(keyName, requirements.type, value)
+            });
+            break;
+        case String:
+            const isString = _validations.isString(value);
+            result.push({
+                key: keyName,
+                passed: isString,
+                details: isString ? 'Passed' : getErrorDetails(keyName, requirements.type, value)
+            });
+            break;
+        case Date:
+            const isDate = _validations.isDate(value);
+            result.push({
+                key: keyName,
+                passed: isDate,
+                details: isDate ? 'Passed' : getErrorDetails(keyName, requirements.type, value)
+            });
+            break;
+        case Boolean:
+            const isBoolean = _validations.isBoolean(value);
+            result.push({
+                key: keyName,
+                passed: isBoolean,
+                details: isBoolean ? 'Passed' : getErrorDetails(keyName, requirements.type, value)
+            });
+            break;
+        case Array:
+            const isArray = _validations.isArray(value);
+            let isEachChecked = { passed: true, details: "" };
+            if ('eachType' in requirements) {
+                isEachChecked.passed = value.every((el) => {
+                    const checkResult = checkType('each of ' + key, el, { type: requirements.eachType, required: true });
+                    if (!checkResult[0].passed) {
+                        isEachChecked.details = checkResult[0].details;
+                        isEachChecked.passed = false;
+                    }
+                    return true;
+                });
+            }
+            const isOk = isArray && isEachChecked.passed;
+            result.push({
+                key: keyName,
+                passed: isOk,
+                details: isOk ? 'Passed' : !isEachChecked.passed ? isEachChecked.details : getErrorDetails(keyName, requirements.type, value)
+            });
+            break;
+        case Object:
+            const isObject = _validations.isObject(value);
+            result.push({
+                key: keyName,
+                passed: isObject,
+                details: isObject ? 'Passed' : getErrorDetails(keyName, requirements.type, value)
+            });
+            break;
+        case RegExp:
+            const isRegex = _validations.isRegex(value);
+            result.push({
+                key: keyName,
+                passed: isRegex,
+                details: isRegex ? 'Passed' : getErrorDetails(keyName, requirements.type, value)
+            });
+            break;
+        case null:
+            const isNull = _validations.isNull(value);
+            result.push({
+                key: keyName,
+                passed: isNull,
+                details: isNull ? 'Passed' : getErrorDetails(keyName, requirements.type, value)
+            });
+            break;
+        default:
+            result.push({
+                key: keyName,
+                passed: false,
+                details: `No type specified for key: '${keyName}'`
+            });
+    }
+    return result;
+};
+export default checkType;

package/dist/index.js

@@ -0,0 +1,2 @@
+import { Schema } from "./Schema.js";
+export default Schema;

package/dist/utils/validations.js

@@ -0,0 +1,87 @@
+const _validations = {};
+_validations.isString = (value) => {
+    return typeof value === 'string';
+};
+_validations.isDate = (value) => {
+    return value instanceof Date && String(value) !== 'Invalid Date';
+};
+_validations.isNumber = (value) => {
+    return typeof value === 'number';
+};
+_validations.isNumberGte = (value, gte) => {
+    return typeof value === 'number' && value >= gte;
+};
+_validations.isNumberLte = (value, lte) => {
+    return typeof value === 'number' && value <= lte;
+};
+_validations.isArray = (value) => {
+    return Array.isArray(value);
+};
+_validations.isObject = (value) => {
+    return typeof value === 'object' && !Array.isArray(value) && value !== null;
+};
+_validations.lengthIs = (value, length) => {
+    return value.length === length;
+};
+_validations.lengthNot = (value, length) => {
+    return value.length !== length;
+};
+_validations.lengthMin = (value, min) => {
+    return value.length >= min;
+};
+_validations.lengthMax = (value, max) => {
+    return value.length <= max;
+};
+_validations.isEmail = (value) => {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(value);
+};
+_validations.isRegex = (value) => {
+    return value instanceof RegExp;
+};
+_validations.hasKey = (obj, key) => {
+    return key in obj;
+};
+_validations.isNot = (value, not) => {
+    if (typeof not === 'object' && Array.isArray(not)) {
+        for (let i = 0; i < not.length; i++) {
+            if (value === not[i])
+                return false;
+        }
+        return true;
+    }
+    return value !== not;
+};
+_validations.is = (value, compareTo) => {
+    if (typeof compareTo === 'object' && Array.isArray(compareTo)) {
+        for (let i = 0; i < compareTo.length; i++) {
+            if (value === compareTo[i])
+                return true;
+        }
+        return false;
+    }
+    return value === compareTo;
+};
+_validations.isDateYYYYMMDD = (value) => {
+    const regex = /^\d{4}-\d{2}-\d{2}$/;
+    return regex.test(value);
+};
+_validations.regexTested = (value, regex) => {
+    if (!regex)
+        throw new Error('regex argument is not defined');
+    return regex.test(value);
+};
+_validations.isHex = (value) => {
+    const regex = /^#(?:[0-9a-fA-F]{3}){1,2}$/;
+    return regex.test(value);
+};
+_validations.isBoolean = (value) => {
+    return typeof value === 'boolean';
+};
+_validations.isNull = (value) => {
+    return value === null;
+};
+_validations.isUndefined = (value) => {
+    return value === undefined;
+};
+export default _validations;

package/dist/validate.js

@@ -0,0 +1,110 @@
+import checkRules from "./checkRules.js";
+import checkType from "./checkType.js";
+import { defaultSchemaKeys } from "./Schema.js";
+import _validations from "./utils/validations.js";
+const getResultDefaults = () => {
+    return {
+        ok: null,
+        missed: [],
+        failed: [],
+        passed: [],
+        errors: [],
+        byKeys: {},
+        errorsByKeys: {}
+    };
+};
+const checkIsNested = (obj) => {
+    if (!_validations.isObject(obj))
+        return false;
+    const objKeys = Object.keys(obj);
+    if (objKeys.every((k) => defaultSchemaKeys.includes(k))) {
+        return false;
+    }
+    else {
+        return true;
+    }
+};
+const mergeResults = (resultsOld, resultsNew) => {
+    const output = getResultDefaults();
+    output.failed = [...resultsOld.failed, ...resultsNew.failed];
+    output.errors = [...resultsOld.errors, ...resultsNew.errors];
+    output.missed = [...resultsOld.missed, ...resultsNew.missed];
+    output.passed = [...resultsOld.passed, ...resultsNew.passed];
+    output.byKeys = Object.assign(Object.assign({}, resultsOld.byKeys), resultsNew.byKeys);
+    output.errorsByKeys = Object.assign(Object.assign({}, resultsOld.errorsByKeys), resultsNew.errorsByKeys);
+    return output;
+};
+const handleReqKey = (key, data, reqs, deepKey = key) => {
+    let results = getResultDefaults();
+    const hasNested = checkIsNested(reqs);
+    const missedCheck = [];
+    const typeChecked = [];
+    const rulesChecked = [];
+    if (reqs.required && (data === undefined ||
+        (_validations.isObject(data) && !Object.keys(data).length))) {
+        results.missed.push(deepKey);
+        results.failed.push(deepKey);
+        results.byKeys[deepKey] = false;
+        return results;
+    }
+    if (hasNested) {
+        const nestedReqKeys = Object.keys(reqs);
+        results.byKeys[deepKey] = true;
+        let i = 0;
+        while (i < nestedReqKeys.length) {
+            const reqKeyI = nestedReqKeys[i];
+            const deepResults = handleReqKey(reqKeyI, data[key], reqs[reqKeyI], deepKey + '.' + reqKeyI);
+            results = mergeResults(results, deepResults);
+            i++;
+        }
+        return results;
+    }
+    if (reqs.required === true && key in data === false || data === undefined) {
+        missedCheck.push(false);
+        results.errors.push(`Missing key '${deepKey}'`);
+        return results;
+    }
+    const typeCheck = checkType(key, data[key], reqs, deepKey);
+    typeCheck.forEach(res => {
+        if (res.passed === false) {
+            typeChecked.push(res.passed);
+            results.errors.push(res.details);
+        }
+    });
+    const ruleCheck = checkRules(deepKey, data[key], reqs);
+    if (!ruleCheck.ok) {
+        rulesChecked.push(false);
+        ruleCheck.details.forEach((el) => {
+            if (deepKey in results.errorsByKeys)
+                results.errorsByKeys[deepKey] = [];
+            results.errors.push(el);
+            results.errorsByKeys[deepKey] = ['1'];
+        });
+    }
+    if (missedCheck.length)
+        results.missed.push(deepKey);
+    if (typeChecked.length || rulesChecked.length) {
+        results.failed.push(deepKey);
+    }
+    else {
+        results.passed.push(deepKey);
+    }
+    results.errorsByKeys[deepKey] = [
+        ...results.errors
+    ];
+    results.byKeys[deepKey] = (missedCheck.length + typeChecked.length + rulesChecked.length) === 0;
+    return results;
+};
+const validate = (schema, data) => {
+    let results = getResultDefaults();
+    for (const [key, reqs] of Object.entries(schema.schema)) {
+        const keyResult = handleReqKey(key, data, reqs);
+        results = mergeResults(results, keyResult);
+    }
+    if (results.failed.length)
+        results.ok = false;
+    else
+        results.ok = true;
+    return results;
+};
+export default validate;