validno 0.2.5 → 0.3.0

package/dist/Schema.js

@@ -1,14 +1,15 @@
-import { ESchemaFields } from "./constants/schema.js";
-import validate from "./validate.js";
-export const defaultSchemaKeys = Object.values(ESchemaFields);
+import { SchemaFields } from "./constants/schema.js";
+import ValidateEngine from "./engine/ValidateEngine.js";
+export const defaultSchemaKeys = Object.values(SchemaFields);
 export class Schema {
     constructor(inputSchemaDefinition) {
         if (!inputSchemaDefinition || typeof inputSchemaDefinition !== 'object') {
             throw new Error("Invalid schema input");
         }
-        this.schema = inputSchemaDefinition;
+        this.definition = inputSchemaDefinition;
     }
     validate(inputData, validationKeys) {
-        return validate.call(this, inputData, validationKeys);
+        const engine = new ValidateEngine(this.definition);
+        return engine.validate(inputData, validationKeys);
     }
 }

package/dist/ValidnoResult.js

@@ -9,16 +9,22 @@ class ValidnoResult {
         this.byKeys = (results === null || results === void 0 ? void 0 : results.byKeys) || {};
         this.errorsByKeys = (results === null || results === void 0 ? void 0 : results.errorsByKeys) || {};
     }
+    setNoData() {
+        this.ok = false;
+        this.errors = ['Отсутствует объект для проверки'];
+    }
     setKeyStatus(key, result) {
         this.byKeys[key] = result;
     }
     fixParentByChilds(parentKey, childChecks = []) {
-        const isEveryOk = childChecks.every(c => c === true);
+        const isEveryOk = childChecks.every(check => check === true);
         this.setKeyStatus(parentKey, isEveryOk);
-        if (isEveryOk === true)
+        if (isEveryOk) {
             this.setPassed(parentKey);
-        else
+        }
+        else {
             this.setFailed(parentKey);
+        }
     }
     setMissing(key, errMsg) {
         const error = errMsg || _errors.getMissingError(key);
@@ -31,7 +37,7 @@ class ValidnoResult {
         this.setKeyStatus(key, true);
     }
     setFailed(key, msg) {
-        if (key in this.errorsByKeys === false) {
+        if (!(key in this.errorsByKeys)) {
             this.errorsByKeys[key] = [];
         }
         this.failed.push(key);
@@ -51,8 +57,9 @@ class ValidnoResult {
         this.passed = [...this.passed, ...resultsNew.passed];
         this.byKeys = Object.assign(Object.assign({}, this.byKeys), resultsNew.byKeys);
         for (const key in resultsNew.errorsByKeys) {
-            if (key in this.errorsByKeys === false)
+            if (!(key in this.errorsByKeys)) {
                 this.errorsByKeys[key] = [];
+            }
             this.errorsByKeys[key] = [
                 ...this.errorsByKeys[key],
                 ...resultsNew.errorsByKeys[key]
@@ -68,10 +75,12 @@ class ValidnoResult {
         }
     }
     finish() {
-        if (this.failed.length)
+        if (this.failed.length || this.errors.length) {
             this.ok = false;
-        else
+        }
+        else {
             this.ok = true;
+        }
         this.clearEmptyErrorsByKeys();
         return this;
     }
@@ -86,5 +95,8 @@ class ValidnoResult {
             errorsByKeys: this.errorsByKeys,
         };
     }
+    isValid() {
+        return this.ok === true;
+    }
 }
 export default ValidnoResult;

package/dist/checkType.js

@@ -1,167 +1 @@
-import { ErrorKeywords } from "./constants/details.js";
-import _validations from "./utils/validations.js";
-import _errors from "./utils/errors.js";
-const checkTypeMultiple = (key, value, requirements, keyName = key) => {
-    const constructorNames = Array.isArray(requirements.type)
-        ? requirements.type.map((el) => String((el === null || el === void 0 ? void 0 : el.name) || el))
-        : [];
-    const result = {
-        key: keyName,
-        passed: false,
-        details: _errors.getErrorDetails(keyName, constructorNames.join('/'), value)
-    };
-    let i = 0;
-    if (Array.isArray(requirements.type)) {
-        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 = 'OK';
-                return result;
-            }
-            i++;
-        }
-    }
-    return result;
-};
-const checkType = (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 [{ key: keyName, passed: false, details: `Значение "${keyName}" отсутствует` }];
-    }
-    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: 'OK'
-        });
-        return result;
-    }
-    const customErrDetails = hasCustomMessage ?
-        requirements.customMessage({
-            keyword: ErrorKeywords.Type,
-            value: value,
-            key: keyName,
-            title: keyTitle,
-            reqs: requirements,
-            schema: null
-        }) :
-        null;
-    const baseErrDetails = _errors.getErrorDetails(keyName, requirements.type, value);
-    const getDetails = (isOK) => isOK ? 'OK' : customErrDetails || baseErrDetails;
-    const typeBySchema = requirements.type;
-    switch (typeBySchema) {
-        case 'any':
-            result.push({
-                key: keyName,
-                passed: true,
-                details: 'OK'
-            });
-            break;
-        case Number:
-            const isNumber = isNotNull && value.constructor === Number;
-            result.push({
-                key: keyName,
-                passed: isNumber,
-                details: getDetails(isNumber)
-            });
-            break;
-        case String:
-            const isString = isNotNull && value.constructor === String;
-            result.push({
-                key: keyName,
-                passed: isString,
-                details: getDetails(isString)
-            });
-            break;
-        case Date:
-            const isDate = isNotNull && value.constructor === Date;
-            const isValid = isDate && !isNaN(value.getTime());
-            const errorMsg = isValid ? getDetails(isDate) : 'Дата невалидна';
-            result.push({
-                key: keyName,
-                passed: isDate && isValid,
-                details: isDate && isValid ? 'OK' : errorMsg
-            });
-            break;
-        case Boolean:
-            const isBoolean = isNotNull && value.constructor === Boolean;
-            result.push({
-                key: keyName,
-                passed: isBoolean,
-                details: isBoolean ? 'OK' : getDetails(isBoolean)
-            });
-            break;
-        case Array:
-            const isArray = isNotNull && value.constructor === Array;
-            if (!isArray) {
-                result.push({
-                    key: keyName,
-                    passed: false,
-                    details: getDetails(isArray)
-                });
-                break;
-            }
-            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 ? 'OK' : !isEachChecked.passed ? isEachChecked.details : getDetails(isOk)
-            });
-            break;
-        case Object:
-            const isObject = _validations.isObject(value) && value.constructor === Object;
-            result.push({
-                key: keyName,
-                passed: isObject,
-                details: isObject ? 'OK' : getDetails(isObject)
-            });
-            break;
-        case RegExp:
-            const isRegex = _validations.isRegex(value);
-            result.push({
-                key: keyName,
-                passed: isRegex,
-                details: isRegex ? 'OK' : getDetails(isRegex)
-            });
-            break;
-        case null:
-            const isNull = value === null;
-            result.push({
-                key: keyName,
-                passed: isNull,
-                details: isNull ? 'OK' : 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 checked = isInstanceOf && isConstructorSame;
-            result.push({
-                key: keyName,
-                passed: checked,
-                details: getDetails(checked)
-            });
-    }
-    return result;
-};
-export default checkType;
+"use strict";

package/dist/constants/details.js

@@ -1,6 +1,11 @@
-export var ErrorKeywords;
-(function (ErrorKeywords) {
-    ErrorKeywords["Missing"] = "missing";
-    ErrorKeywords["Type"] = "type";
-    ErrorKeywords["Rule"] = "rule";
-})(ErrorKeywords || (ErrorKeywords = {}));
+export var ValidationIds;
+(function (ValidationIds) {
+    ValidationIds["Missing"] = "missing";
+    ValidationIds["Type"] = "type";
+    ValidationIds["Rule"] = "rule";
+})(ValidationIds || (ValidationIds = {}));
+export var ValidationDetails;
+(function (ValidationDetails) {
+    ValidationDetails["OK"] = "OK";
+    ValidationDetails["INVALID_DATE"] = "Invalid date";
+})(ValidationDetails || (ValidationDetails = {}));

package/dist/constants/schema.js

@@ -1,10 +1,10 @@
-export var ESchemaFields;
-(function (ESchemaFields) {
-    ESchemaFields["Required"] = "required";
-    ESchemaFields["Type"] = "type";
-    ESchemaFields["EachType"] = "eachType";
-    ESchemaFields["Rules"] = "rules";
-    ESchemaFields["Title"] = "title";
-    ESchemaFields["CustomMessage"] = "customMessage";
-    ESchemaFields["JoinErrors"] = "joinErrors";
-})(ESchemaFields || (ESchemaFields = {}));
+export var SchemaFields;
+(function (SchemaFields) {
+    SchemaFields["Required"] = "required";
+    SchemaFields["Type"] = "type";
+    SchemaFields["EachType"] = "eachType";
+    SchemaFields["Rules"] = "rules";
+    SchemaFields["Title"] = "title";
+    SchemaFields["CustomMessage"] = "customMessage";
+    SchemaFields["JoinErrors"] = "joinErrors";
+})(SchemaFields || (SchemaFields = {}));

package/dist/dev.js

@@ -1,51 +1,70 @@
-import { Schema } from "./Schema.js";
-const validateConfig = (cfg) => {
-    const cfgSchema = new Schema({
-        str1: {
-            type: String,
-            required: true
-        },
-        str2: {
-            deep1: {
-                type: String,
-                required: true,
-            }
+import Schema from './index.js';
+const schema = new Schema({
+    name: {
+        type: String,
+        required: true
+    },
+    lastVisit: {
+        type: Date,
+        required: true,
+    },
+    age: {
+        type: Number,
+        required: true,
+    },
+    email: {
+        type: String,
+        required: true,
+        rules: {
+            isEmail: true
         }
-    });
-    const res = cfgSchema.validate(cfg);
-    console.log(res);
-};
-const uniTestService = {
-    str1: 'xxxx'
-};
-validateConfig(uniTestService);
-console.log(uniTestService);
-console.log(uniTestService);
-const obj = {
-    top: {
-        mid1: {
-            low1a: false,
-            low1b: false
+    },
+    isAwesome: {
+        type: Boolean,
+        required: true
+    },
+    friends: {
+        type: Array,
+        required: true,
+        eachType: String,
+    },
+    broRegex: {
+        type: RegExp,
+        required: true,
+    },
+    socials: {
+        x: {
+            type: String,
+            required: false
         },
-        mid2: {
-            low2a: false
+        instagram: {
+            type: String,
+            required: false
         }
     },
-    top2: false
-};
-const setNestedValue = (linkedObj, keysLevels, curLevel, valueToSet) => {
-    const lvKey = keysLevels[curLevel];
-    if (curLevel < keysLevels.length - 1) {
-        if (!linkedObj[lvKey] || typeof linkedObj[lvKey] !== 'object') {
-            linkedObj[lvKey] = {};
-        }
-        return setNestedValue(linkedObj[lvKey], keysLevels, curLevel + 1, valueToSet);
-    }
-    else {
-        linkedObj[lvKey] = valueToSet;
-    }
-};
-const setDeepValue = (obj, keysChain, valueToSet) => {
-    const keysLevels = keysChain.split('.');
-    setNestedValue(obj, keysLevels, 0, valueToSet);
+    nullableField: {
+        type: null,
+        required: false,
+    },
+});
+const exampleObj = {
+    name: 'Barney Stinson',
+    age: 35,
+    lastVisit: new Date('2025-05-05'),
+    email: 'legggen@dary.com',
+    isAwesome: true,
+    friends: [
+        'Ted Mosby',
+        'Marshall Eriksen',
+        'Lily Aldrin',
+        'Robin Scherbatsky'
+    ],
+    socials: {
+        x: '@barney_stinson',
+        insstagram: '@barney_stinson'
+    },
+    broRegex: /bro/i,
+    deletedAt: null,
 };
+const validation = schema.validate(exampleObj);
+console.log(validation);

package/dist/engine/ValidateEngine.js

@@ -0,0 +1,44 @@
+import ValidnoResult from "./ValidnoResult.js";
+import validate from "./methods/validate.js";
+import validateType from "./methods/validateType.js";
+import validateRules from "./methods/validateRules.js";
+import handleMissingKey from "./methods/handleMissingKey.js";
+import handleNestedKey from "./methods/handleNestedKey.js";
+import handleKey from "./methods/handleKey.js";
+import handleMissingKeyValidation from "./methods/handleMissingKeyValidation.js";
+import finishValidation from "./methods/finishValidation.js";
+class ValidateEngine {
+    constructor(definition) {
+        this.definition = definition;
+        this.result = new ValidnoResult();
+    }
+    validate(data, validationKeys) {
+        return validate.call(this, data, validationKeys);
+    }
+    handleKey(input) {
+        return handleKey.call(this, input);
+    }
+    handleNestedKey(input) {
+        return handleNestedKey.call(this, input);
+    }
+    handleMissingKey(schema, input) {
+        return handleMissingKey(schema, input);
+    }
+    handleMissingNestedKey(nestedKey, results) {
+        results.setMissing(nestedKey);
+        return results;
+    }
+    handleMissingKeyValidation(params) {
+        return handleMissingKeyValidation.call(this, params);
+    }
+    validateType(input) {
+        return validateType(input);
+    }
+    validateRules(input) {
+        return validateRules.call(this, input);
+    }
+    finishValidation(checks) {
+        return finishValidation(checks);
+    }
+}
+export default ValidateEngine;

package/dist/engine/ValidnoResult.js

@@ -0,0 +1,102 @@
+import _errors from "../utils/errors.js";
+class ValidnoResult {
+    constructor(results) {
+        this.ok = (results === null || results === void 0 ? void 0 : results.ok) !== undefined ? results.ok : null;
+        this.missed = (results === null || results === void 0 ? void 0 : results.missed) || [];
+        this.failed = (results === null || results === void 0 ? void 0 : results.failed) || [];
+        this.passed = (results === null || results === void 0 ? void 0 : results.passed) || [];
+        this.errors = (results === null || results === void 0 ? void 0 : results.errors) || [];
+        this.byKeys = (results === null || results === void 0 ? void 0 : results.byKeys) || {};
+        this.errorsByKeys = (results === null || results === void 0 ? void 0 : results.errorsByKeys) || {};
+    }
+    setNoData(key) {
+        this.ok = false;
+        this.errors = [`Missing value for '${key}'`];
+    }
+    setKeyStatus(key, result) {
+        this.byKeys[key] = result;
+    }
+    fixParentByChilds(parentKey, childChecks = []) {
+        const isEveryOk = childChecks.every(check => check === true);
+        this.setKeyStatus(parentKey, isEveryOk);
+        if (isEveryOk) {
+            this.setPassed(parentKey);
+        }
+        else {
+            this.setFailed(parentKey);
+        }
+    }
+    setMissing(key, errMsg) {
+        const error = errMsg || _errors.getMissingError(key);
+        this.missed.push(key);
+        this.setFailed(key, error);
+        this.setKeyStatus(key, false);
+    }
+    setPassed(key) {
+        this.passed.push(key);
+        this.setKeyStatus(key, true);
+    }
+    setFailed(key, msg) {
+        if (!(key in this.errorsByKeys)) {
+            this.errorsByKeys[key] = [];
+        }
+        this.failed.push(key);
+        this.setKeyStatus(key, false);
+        if (!msg)
+            return;
+        this.errors.push(msg);
+        this.errorsByKeys[key].push(msg);
+    }
+    joinErrors(separator = '; ') {
+        return _errors.joinErrors(this.errors, separator);
+    }
+    merge(resultsNew) {
+        this.failed = [...this.failed, ...resultsNew.failed];
+        this.errors = [...this.errors, ...resultsNew.errors];
+        this.missed = [...this.missed, ...resultsNew.missed];
+        this.passed = [...this.passed, ...resultsNew.passed];
+        this.byKeys = Object.assign(Object.assign({}, this.byKeys), resultsNew.byKeys);
+        for (const key in resultsNew.errorsByKeys) {
+            if (!(key in this.errorsByKeys)) {
+                this.errorsByKeys[key] = [];
+            }
+            this.errorsByKeys[key] = [
+                ...this.errorsByKeys[key],
+                ...resultsNew.errorsByKeys[key]
+            ];
+        }
+        return this;
+    }
+    clearEmptyErrorsByKeys() {
+        for (const key in this.errorsByKeys) {
+            if (!this.errorsByKeys[key].length) {
+                delete this.errorsByKeys[key];
+            }
+        }
+    }
+    finish() {
+        if (this.failed.length || this.errors.length) {
+            this.ok = false;
+        }
+        else {
+            this.ok = true;
+        }
+        this.clearEmptyErrorsByKeys();
+        return this;
+    }
+    data() {
+        return {
+            ok: this.ok,
+            missed: this.missed,
+            failed: this.failed,
+            passed: this.passed,
+            errors: this.errors,
+            byKeys: this.byKeys,
+            errorsByKeys: this.errorsByKeys,
+        };
+    }
+    isValid() {
+        return this.ok === true;
+    }
+}
+export default ValidnoResult;

package/dist/engine/index.js

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

package/dist/engine/methods/finishValidation.js

@@ -0,0 +1,15 @@
+function finishValidation(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 finishValidation;

package/dist/engine/methods/handleKey.js

@@ -0,0 +1,41 @@
+import _helpers from "../../utils/helpers.js";
+import ValidnoResult from "../ValidnoResult.js";
+function validateKeyValue(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.validateType({ results, key, value: data[key], reqs, nestedKey, typeChecked });
+    this.validateRules({ results, nestedKey, value: data[key], reqs, data, rulesChecked });
+    return this.finishValidation({ results, nestedKey, missedCheck, typeChecked, rulesChecked });
+}
+function validateKey(input) {
+    let { results, key, nestedKey, data, reqs } = input;
+    if (data === undefined) {
+        const noDataResult = new ValidnoResult();
+        noDataResult.setNoData(nestedKey);
+    }
+    if (!results)
+        results = new ValidnoResult();
+    if (!nestedKey)
+        nestedKey = key;
+    const hasMissing = _helpers.hasMissing(input);
+    if (_helpers.checkNestedIsMissing(reqs, data)) {
+        return this.handleMissingNestedKey(nestedKey, results);
+    }
+    if (_helpers.checkIsNested(reqs)) {
+        return this.handleNestedKey({ results, key, data, reqs, nestedKey });
+    }
+    return validateKeyValue.call(this, {
+        results,
+        key,
+        nestedKey,
+        data,
+        reqs,
+        hasMissing,
+    });
+}
+export default validateKey;

package/dist/engine/methods/handleMissingKey.js

@@ -0,0 +1,19 @@
+import { ValidationIds } from "../../constants/details.js";
+import _errors from "../../utils/errors.js";
+function 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;
+}
+export default handleMissingKey;

package/dist/engine/methods/handleMissingKeyValidation.js

@@ -0,0 +1,9 @@
+function handleMissingKeyValidation(params) {
+    const schema = this.definition;
+    const { results, key, nestedKey, data, reqs, missedCheck } = params;
+    const errMsg = this.handleMissingKey(schema, { key, nestedKey, data, reqs });
+    missedCheck.push(false);
+    results.setMissing(nestedKey, errMsg);
+    return results;
+}
+export default handleMissingKeyValidation;

package/dist/engine/methods/handleNestedKey.js

@@ -0,0 +1,19 @@
+function handleNestedKey(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.handleKey(deepParams);
+        nestedResults.push(deepResults.ok);
+        results.merge(deepResults);
+    }
+    results.fixParentByChilds(nestedKey, nestedResults);
+    return results;
+}
+export default handleNestedKey;