validno 0.2.6 → 0.3.0

package/dist/validateSchema/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/validateSchema.js

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

package/dist/validateType.js

@@ -1,4 +1,4 @@
-import { EValidationDetails, EValidationId } from "./constants/details.js";
+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";
@@ -34,7 +34,7 @@ const validateType = (key, value, requirements, keyName = key) => {
     }
     const customErrDetails = hasCustomMessage ?
         requirements.customMessage({
-            keyword: EValidationId.Type,
+            keyword: ValidationIds.Type,
             value: value,
             key: keyName,
             title: keyTitle,
@@ -44,7 +44,7 @@ const validateType = (key, value, requirements, keyName = key) => {
         null;
     const baseErrDetails = _errors.getErrorDetails(keyName, requirements.type, value);
     const getDetails = (isOK, errorText) => isOK ?
-        EValidationDetails.OK :
+        ValidationDetails.OK :
         errorText || customErrDetails || baseErrDetails;
     const typeBySchema = requirements.type;
     const result = [];
@@ -67,7 +67,7 @@ const validateType = (key, value, requirements, keyName = key) => {
             const isDate = isNotNull && value.constructor === Date;
             const isValid = isDate && !isNaN(value.getTime());
             const isValidDate = isDate && isValid;
-            result.push(_validateType.getResult(keyName, isValidDate, getDetails(isValidDate, EValidationDetails.INVALID_DATE)));
+            result.push(_validateType.getResult(keyName, isValidDate, getDetails(isValidDate, ValidationDetails.INVALID_DATE)));
             break;
         }
         case Boolean: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "validno",
-  "version": "0.2.6",
+  "version": "0.3.0",
   "description": "",
   "main": "dist/index.js",
   "scripts": {