validno 0.2.6 → 0.3.0

package/dist/validate/index.js

@@ -0,0 +1 @@
+"use strict";

package/dist/validate/validate.js

@@ -0,0 +1,151 @@
+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/validate.js

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

package/dist/validateEngine/ValidateEngine.js

@@ -0,0 +1,44 @@
+import ValidnoResult from "../ValidnoResult.js";
+import validate from "./methods/validate.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 checkRulesForKey from "./methods/checkRulesForKey.js";
+import finishValidation from "./methods/finishValidation.js";
+import validateType from "./methods/validateType.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);
+    }
+    checkRulesForKey(input) {
+        return checkRulesForKey.call(this, input);
+    }
+    finishValidation(checks) {
+        return finishValidation(checks);
+    }
+}
+export default ValidateEngine;

package/dist/validateEngine/index.js

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

package/dist/validateEngine/methods/ValidateEngine.js

@@ -0,0 +1,139 @@
+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";
+import validate from "../validate.js";
+class ValidateEngine {
+    constructor(definition) {
+        this.definition = definition;
+        this.result = new ValidnoResult();
+    }
+    validate(data, validationKeys) {
+        return validate.call(this, data, validationKeys);
+    }
+    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/validateEngine/methods/checkRulesForKey.js

@@ -0,0 +1,15 @@
+import validateRules from "../../validateRules.js";
+function checkRulesForKey(input) {
+    const { results, nestedKey, value, reqs, data, rulesChecked } = input;
+    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'];
+        });
+    }
+}
+export default checkRulesForKey;