validno 0.2.5 → 0.3.0

package/dist/utils/validations.js

@@ -1,154 +1,158 @@
 import _helpers from "./helpers.js";
-const _validations = {};
-_validations.isString = (value) => {
-    return typeof value === 'string';
-};
-_validations.isNumber = (value) => {
-    return typeof value === 'number';
-};
-_validations.isArray = (value) => {
-    return Array.isArray(value);
-};
-_validations.isObject = (value) => {
-    var _a;
-    return value !== null && typeof value === 'object' && ((_a = value === null || value === void 0 ? void 0 : value.constructor) === null || _a === void 0 ? void 0 : _a.name) === 'Object' && !Array.isArray(value);
-};
-_validations.isDate = (value) => {
-    return value instanceof Date && String(value) !== 'Invalid Date';
-};
-_validations.isRegex = (value) => {
-    return value instanceof RegExp;
-};
-_validations.isBoolean = (value) => {
-    return typeof value === 'boolean';
-};
-_validations.isNull = (value) => {
-    return value === null;
-};
-_validations.isUndefined = (value) => {
-    return value === undefined;
-};
-_validations.isNullOrUndefined = (value) => {
-    return value === undefined || value === null;
-};
-_validations.isEmail = (value) => {
-    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-    return emailRegex.test(value);
-};
-_validations.isDateYYYYMMDD = (value) => {
-    const regex = /^\d{4}-\d{2}-\d{2}$/;
-    return regex.test(value);
-};
-_validations.isHex = (value) => {
-    const regex = /^#(?:[0-9a-fA-F]{3}){1,2}$/;
-    return regex.test(value);
-};
-_validations.lengthIs = (value, length) => {
-    if (typeof value !== 'string' && !Array.isArray(value))
-        return false;
-    if (typeof length !== 'number')
-        return false;
-    return value.length === length;
-};
-_validations.lengthNot = (value, length) => {
-    if (typeof value !== 'string' && !Array.isArray(value))
-        return false;
-    if (typeof length !== 'number')
-        return false;
-    return value.length !== length;
-};
-_validations.lengthMin = (value, min) => {
-    if (typeof value !== 'string' && !Array.isArray(value))
-        return false;
-    if (typeof min !== 'number')
-        return false;
-    return value.length >= min;
-};
-_validations.lengthMax = (value, max) => {
-    if (typeof value !== 'string' && !Array.isArray(value))
-        return false;
-    if (typeof max !== 'number')
-        return false;
-    return value.length <= max;
-};
-_validations.isNumberGte = (value, gte) => {
-    return typeof value === 'number' && value >= gte;
-};
-_validations.isNumberGt = (value, gt) => {
-    return typeof value === 'number' && value > gt;
-};
-_validations.isNumberLte = (value, lte) => {
-    return typeof value === 'number' && value <= lte;
-};
-_validations.isNumberLt = (value, lt) => {
-    return typeof value === 'number' && value < lt;
-};
-_validations.isDateGte = (date1, date2) => {
-    if (!_validations.isDate(date1) || !_validations.isDate(date2)) {
-        return false;
-    }
-    return date1 >= date2;
-};
-_validations.isDateGt = (date1, date2) => {
-    if (!_validations.isDate(date1) || !_validations.isDate(date2)) {
-        return false;
-    }
-    return date1 > date2;
-};
-_validations.isDateLte = (date1, date2) => {
-    if (!_validations.isDate(date1) || !_validations.isDate(date2)) {
-        return false;
-    }
-    return date1 <= date2;
-};
-_validations.isDateLt = (date1, date2) => {
-    if (!_validations.isDate(date1) || !_validations.isDate(date2)) {
-        return false;
-    }
-    return date1 < date2;
-};
-_validations.hasKey = (obj, key) => {
-    if (_validations.isObject(obj) === false)
-        return false;
-    return key in obj;
-};
-_validations.is = (value, compareTo) => {
-    if (value === compareTo) {
-        return true;
-    }
-    const bothArrays = _validations.isArray(value) && _validations.isArray(compareTo);
-    if (bothArrays) {
-        return _helpers.compareArrs(value, compareTo);
-    }
-    const bothObjects = _validations.isObject(value) && _validations.isObject(compareTo);
-    if (bothObjects) {
-        return _helpers.compareObjs(value, compareTo);
-    }
-    const bothDates = _validations.isDate(value) && _validations.isDate(compareTo);
-    if (bothDates) {
-        return value.getTime() === compareTo.getTime();
-    }
-    return value === compareTo;
-};
-_validations.not = (value, not) => {
-    return !_validations.is(value, not);
-};
-_validations.regexTested = (value, regexp) => {
-    if (!regexp || regexp instanceof RegExp !== true) {
-        throw new Error('regexp argument is incorrect');
-    }
-    return regexp.test(value);
-};
-_validations.gt = _validations.isNumberGt;
-_validations.gte = _validations.isNumberGte;
-_validations.lte = _validations.isNumberLte;
-_validations.lt = _validations.isNumberLt;
-_validations.eq = _validations.is;
-_validations.isNot = _validations.not;
-_validations.ne = _validations.not;
-_validations.neq = _validations.not;
-_validations.regexpTested = _validations.regexpTested;
-_validations.regex = _validations.regexTested;
-_validations.regexp = _validations.regexTested;
-_validations.test = _validations.regexTested;
-export default _validations;
+class ValidationUtility {
+    isString(value) {
+        return typeof value === 'string';
+    }
+    isNumber(value) {
+        return typeof value === 'number';
+    }
+    isArray(value) {
+        return Array.isArray(value);
+    }
+    isObject(value) {
+        let _a;
+        return value !== null &&
+            typeof value === 'object' &&
+            ((_a = value === null || value === void 0 ? void 0 : value.constructor) === null || _a === void 0 ? void 0 : _a.name) === 'Object' &&
+            !Array.isArray(value);
+    }
+    isDate(value) {
+        return value instanceof Date && String(value) !== 'Invalid Date';
+    }
+    isRegex(value) {
+        return value instanceof RegExp;
+    }
+    isBoolean(value) {
+        return typeof value === 'boolean';
+    }
+    isNull(value) {
+        return value === null;
+    }
+    isUndefined(value) {
+        return value === undefined;
+    }
+    isNullOrUndefined(value) {
+        return value === undefined || value === null;
+    }
+    isEmail(value) {
+        const emailRegex = /^(?!.*\.\.)[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        return emailRegex.test(value);
+    }
+    isDateYYYYMMDD(value) {
+        const regex = /^\d{4}-\d{2}-\d{2}$/;
+        return regex.test(value);
+    }
+    isHex(value) {
+        const regex = /^#(?:[0-9a-fA-F]{3}){1,2}$/;
+        return regex.test(value);
+    }
+    lengthIs(value, length) {
+        if (typeof value !== 'string' && !Array.isArray(value))
+            return false;
+        if (typeof length !== 'number')
+            return false;
+        return value.length === length;
+    }
+    lengthNot(value, length) {
+        if (typeof value !== 'string' && !Array.isArray(value))
+            return false;
+        if (typeof length !== 'number')
+            return false;
+        return value.length !== length;
+    }
+    lengthMin(value, min) {
+        if (typeof value !== 'string' && !Array.isArray(value))
+            return false;
+        if (typeof min !== 'number')
+            return false;
+        return value.length >= min;
+    }
+    lengthMax(value, max) {
+        if (typeof value !== 'string' && !Array.isArray(value))
+            return false;
+        if (typeof max !== 'number')
+            return false;
+        return value.length <= max;
+    }
+    isNumberGte(value, gte) {
+        return typeof value === 'number' && value >= gte;
+    }
+    isNumberGt(value, gt) {
+        return typeof value === 'number' && value > gt;
+    }
+    isNumberLte(value, lte) {
+        return typeof value === 'number' && value <= lte;
+    }
+    isNumberLt(value, lt) {
+        return typeof value === 'number' && value < lt;
+    }
+    isDateGte(date1, date2) {
+        if (!this.isDate(date1) || !this.isDate(date2)) {
+            return false;
+        }
+        return date1 >= date2;
+    }
+    isDateGt(date1, date2) {
+        if (!this.isDate(date1) || !this.isDate(date2)) {
+            return false;
+        }
+        return date1 > date2;
+    }
+    isDateLte(date1, date2) {
+        if (!this.isDate(date1) || !this.isDate(date2)) {
+            return false;
+        }
+        return date1 <= date2;
+    }
+    isDateLt(date1, date2) {
+        if (!this.isDate(date1) || !this.isDate(date2)) {
+            return false;
+        }
+        return date1 < date2;
+    }
+    hasKey(obj, key) {
+        if (!this.isObject(obj))
+            return false;
+        return key in obj;
+    }
+    is(value, compareTo) {
+        if (value === compareTo) {
+            return true;
+        }
+        const bothArrays = this.isArray(value) && this.isArray(compareTo);
+        if (bothArrays) {
+            return _helpers.compareArrs(value, compareTo);
+        }
+        const bothObjects = this.isObject(value) && this.isObject(compareTo);
+        if (bothObjects) {
+            return _helpers.compareObjs(value, compareTo);
+        }
+        const bothDates = this.isDate(value) && this.isDate(compareTo);
+        if (bothDates) {
+            return value.getTime() === compareTo.getTime();
+        }
+        return value === compareTo;
+    }
+    not(value, not) {
+        return !this.is(value, not);
+    }
+    regexTested(value, regexp) {
+        if (!regexp || !(regexp instanceof RegExp)) {
+            throw new Error('regexp argument is incorrect');
+        }
+        return regexp.test(value);
+    }
+    get gt() { return this.isNumberGt; }
+    get gte() { return this.isNumberGte; }
+    get lte() { return this.isNumberLte; }
+    get lt() { return this.isNumberLt; }
+    get eq() { return this.is; }
+    get isNot() { return this.not; }
+    get ne() { return this.not; }
+    get neq() { return this.not; }
+    get regex() { return this.regexTested; }
+    get regexp() { return this.regexTested; }
+    get test() { return this.regexTested; }
+}
+const validations = new ValidationUtility();
+export default validations;

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;