validno 0.2.6 → 0.3.0

package/dist/engine/methods/validateType.js

@@ -0,0 +1,134 @@
+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";
+const validateUnionType = (key, value, requirements, keyName = key) => {
+    const typeList = Array.isArray(requirements.type)
+        ? requirements.type.map((el) => String((el === null || el === void 0 ? void 0 : el.name) || el))
+        : [];
+    const results = [];
+    for (let i = 0; i < typeList.length; i++) {
+        const requirementsRe = Object.assign(Object.assign({}, requirements), { type: requirements.type[i] });
+        const result = handleTypeValidation(key, value, requirementsRe);
+        results.push(result[0].passed);
+        if (results[i] === true)
+            return _validateType.getResult(keyName, true);
+    }
+    const isPassed = results.some((r) => r === true);
+    const result = _validateType.getResult(keyName, isPassed, isPassed ? undefined : _errors.getErrorDetails(keyName, typeList.join('/'), value));
+    return result;
+};
+const handleTypeValidation = (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 [_validateType.getResult(keyName, false, _errors.getMissingError(keyName))];
+    }
+    if (Array.isArray(requirements.type)) {
+        return [validateUnionType(key, value, requirements)];
+    }
+    if (value === undefined && requirements.required !== true) {
+        return [_validateType.getResult(keyName, true)];
+    }
+    const customErrDetails = hasCustomMessage ?
+        requirements.customMessage({
+            keyword: ValidationIds.Type,
+            value: value,
+            key: keyName,
+            title: keyTitle,
+            reqs: requirements,
+            schema: null
+        }) :
+        null;
+    const baseErrDetails = _errors.getErrorDetails(keyName, requirements.type, value);
+    const getDetails = (isOK, errorText) => isOK ?
+        ValidationDetails.OK :
+        errorText || customErrDetails || baseErrDetails;
+    const typeBySchema = requirements.type;
+    const result = [];
+    switch (typeBySchema) {
+        case 'any': {
+            result.push(_validateType.getResult(keyName, true, getDetails(true)));
+            break;
+        }
+        case Number: {
+            const isNumber = isNotNull && value.constructor === Number;
+            result.push(_validateType.getResult(keyName, isNumber, getDetails(isNumber)));
+            break;
+        }
+        case String: {
+            const isString = isNotNull && value.constructor === String;
+            result.push(_validateType.getResult(keyName, isString, getDetails(isString)));
+            break;
+        }
+        case Date: {
+            const isDate = isNotNull && value.constructor === Date;
+            const isValid = isDate && !isNaN(value.getTime());
+            const isValidDate = isDate && isValid;
+            result.push(_validateType.getResult(keyName, isValidDate, getDetails(isValidDate, ValidationDetails.INVALID_DATE)));
+            break;
+        }
+        case Boolean: {
+            const isBoolean = isNotNull && value.constructor === Boolean;
+            result.push(_validateType.getResult(keyName, isBoolean, getDetails(isBoolean)));
+            break;
+        }
+        case Array: {
+            const isArray = isNotNull && value.constructor === Array;
+            if (!isArray) {
+                result.push(_validateType.getResult(keyName, false, getDetails(isArray)));
+                break;
+            }
+            let isEachChecked = { passed: true, details: "" };
+            if ('eachType' in requirements) {
+                for (const el of value) {
+                    const result = handleTypeValidation(`each of ${key}`, el, { type: requirements.eachType, required: true });
+                    if (!result[0].passed) {
+                        isEachChecked.passed = false;
+                        isEachChecked.details = result[0].details || '';
+                        break;
+                    }
+                }
+            }
+            const isOk = isArray && isEachChecked.passed;
+            const details = !isEachChecked.passed ? isEachChecked.details : getDetails(isOk);
+            result.push(_validateType.getResult(keyName, isOk, details));
+            break;
+        }
+        case Object: {
+            const isObject = _validations.isObject(value) && value.constructor === Object;
+            result.push(_validateType.getResult(keyName, isObject, getDetails(isObject)));
+            break;
+        }
+        case RegExp: {
+            const isRegex = _validations.isRegex(value);
+            result.push(_validateType.getResult(keyName, isRegex, getDetails(isRegex)));
+            break;
+        }
+        case null: {
+            const isNull = value === null;
+            result.push(_validateType.getResult(keyName, isNull, 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 isOK = isInstanceOf && isConstructorSame;
+            result.push(_validateType.getResult(keyName, isOK, getDetails(isOK)));
+        }
+    }
+    return result;
+};
+function validateType(input) {
+    const { results, key, value, reqs, nestedKey, typeChecked } = input;
+    const typeCheck = handleTypeValidation(key, value, reqs, nestedKey);
+    typeCheck.forEach((res) => {
+        if (!res.passed) {
+            typeChecked.push(false);
+            results.errors.push(res.details || '');
+        }
+    });
+}
+export default validateType;

package/dist/types/common.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/errors.js

@@ -1,21 +1,30 @@
-const _errors = {};
-_errors.getMissingError = (key = 'na') => `Отсутствует значение '${key}'`;
-_errors.getErrorDetails = (key, expectedType, receivedValue) => {
-    var _a;
-    let receivedType = '';
-    if (receivedValue === undefined)
-        receivedType = 'undefined';
-    else if (receivedValue === null)
-        receivedType = 'null';
-    else
-        receivedType = ((_a = receivedValue.constructor) === null || _a === void 0 ? void 0 : _a.name) || typeof receivedValue || 'na';
-    const expectedOutput = (expectedType === null || expectedType === void 0 ? void 0 : expectedType.name) || expectedType;
-    const receivedOutput = receivedType || 'na';
-    if (String(expectedOutput) === String(receivedOutput))
-        return '';
-    return `Проверьте тип '${key}': ожидался ${expectedOutput}, получен ${receivedOutput}`;
-};
-_errors.joinErrors = (errorsArr, separator = '; ') => {
-    return (errorsArr === null || errorsArr === void 0 ? void 0 : errorsArr.join(`${separator}`)) || '';
-};
-export default _errors;
+class ErrorUtility {
+    getMissingError(key = 'na') {
+        return `Missing value for '${key}'`;
+    }
+    getErrorDetails(key, expectedType, receivedValue) {
+        const receivedType = this.getTypeString(receivedValue);
+        const expectedOutput = this.getExpectedTypeString(expectedType);
+
+        if (expectedOutput === receivedType) return '';
+
+        return `Check the type of '${key}': expected ${expectedOutput}, received ${receivedType}`;
+    }
+    joinErrors(errorsArr, separator = '; ') {
+        let _a;
+        return ((_a = errorsArr === null || errorsArr === void 0 ? void 0 : errorsArr.filter(error => error === null || error === void 0 ? void 0 : error.trim())) === null || _a === void 0 ? void 0 : _a.join(separator)) || '';
+    }
+    getTypeString(value) {
+        let _a;
+        if (value === undefined)
+            return 'undefined';
+        if (value === null)
+            return 'null';
+        return ((_a = value.constructor) === null || _a === void 0 ? void 0 : _a.name) || typeof value || 'unknown';
+    }
+    getExpectedTypeString(expectedType) {
+        return (expectedType === null || expectedType === void 0 ? void 0 : expectedType.name) || String(expectedType) || 'unknown';
+    }
+}
+const errors = new ErrorUtility();
+export default errors;

package/dist/utils/helpers.js

@@ -1,69 +1,67 @@
-import { defaultSchemaKeys } from "../Schema.js";
 import _validations from "./validations.js";
-const _helpers = {};
-_helpers.checkIsNested = (obj) => {
-    if (!_validations.isObject(obj))
-        return false;
-    const objKeys = Object.keys(obj);
-    if (objKeys.every((k) => defaultSchemaKeys.includes(k))) {
-        return false;
+import { defaultSchemaKeys } from "../Schema.js";
+class HelperUtility {
+    checkIsNested(obj) {
+        if (!_validations.isObject(obj)) {
+            return false;
+        }
+        const objKeys = Object.keys(obj);
+        return !objKeys.every(key => defaultSchemaKeys.includes(key));
     }
-    else {
-        return true;
+    checkNestedIsMissing(reqs, data) {
+        const isRequired = reqs.required;
+        const isUndefined = data === undefined;
+        const isEmpty = _validations.isObject(data) && Object.keys(data).length === 0;
+        return isRequired && (isUndefined || isEmpty);
     }
-};
-_helpers.checkNestedIsMissing = (reqs, data) => {
-    const isRequired = reqs.required;
-    const isUndef = data === undefined;
-    const isEmpty = _validations.isObject(data) && !Object.keys(data).length;
-    return isRequired && (isUndef || isEmpty);
-};
-_helpers.areKeysLimited = (onlyKeys) => {
-    const hasArrayOfKeys = (Array.isArray(onlyKeys) && onlyKeys.length > 0);
-    const hasStringKey = (typeof onlyKeys === 'string' && onlyKeys.length > 0);
-    return hasArrayOfKeys || hasStringKey;
-};
-_helpers.needValidation = (key, hasLimits, onlyKeys) => {
-    const noLimits = !hasLimits;
-    const keyIsInList = (key === onlyKeys || Array.isArray(onlyKeys) && (onlyKeys === null || onlyKeys === void 0 ? void 0 : onlyKeys.includes(key)));
-    return noLimits || keyIsInList;
-};
-_helpers.hasMissing = (input) => {
-    const { reqs, data, key } = input;
-    const isRequired = reqs.required === true;
-    const missingData = (data === undefined || key in data === false || data[key] === undefined);
-    return isRequired && missingData;
-};
-_helpers.compareArrs = (v1, v2) => {
-    if (v1.length !== v2.length)
-        return false;
-    return v1.every((el, i) => {
-        if (_validations.isObject(el)) {
-            return JSON.stringify(el) === JSON.stringify(v2[i]);
+    areKeysLimited(onlyKeys) {
+        const hasArrayOfKeys = Array.isArray(onlyKeys) && onlyKeys.length > 0;
+        const hasStringKey = typeof onlyKeys === 'string' && onlyKeys.length > 0;
+        return hasArrayOfKeys || hasStringKey;
+    }
+    needValidation(key, hasLimits, onlyKeys) {
+        if (!hasLimits) {
+            return true;
         }
-        return v2[i] === el;
-    });
-};
-_helpers.compareObjs = (obj1, obj2) => {
-    function deepEqual(obj1, obj2) {
-        if (obj1 === obj2) {
+        return key === onlyKeys || (Array.isArray(onlyKeys) && onlyKeys.includes(key));
+    }
+    hasMissing(input) {
+        const { reqs, data, key } = input;
+        const isRequired = !!reqs.required;
+        const missingData = (data === undefined ||
+            !(key in data) ||
+            data[key] === undefined);
+        return isRequired && missingData;
+    }
+    compareArrs(v1, v2) {
+        if (v1.length !== v2.length) {
+            return false;
+        }
+        return v1.every((element, index) => {
+            if (_validations.isObject(element)) {
+                return JSON.stringify(element) === JSON.stringify(v2[index]);
+            }
+            return v2[index] === element;
+        });
+    }
+    compareObjs(obj1, obj2) {
+        return this.deepEqual(obj1, obj2);
+    }
+    deepEqual(value1, value2) {
+        if (value1 === value2) {
             return true;
         }
-        if (typeof obj1 !== 'object' || obj1 === null || typeof obj2 !== 'object' || obj2 === null) {
+        if (typeof value1 !== 'object' || value1 === null ||
+            typeof value2 !== 'object' || value2 === null) {
             return false;
         }
-        const keys1 = Object.keys(obj1);
-        const keys2 = Object.keys(obj2);
+        const keys1 = Object.keys(value1);
+        const keys2 = Object.keys(value2);
         if (keys1.length !== keys2.length) {
             return false;
         }
-        for (let key of keys1) {
-            if (!keys2.includes(key) || !deepEqual(obj1[key], obj2[key])) {
-                return false;
-            }
-        }
-        return true;
+        return keys1.every(key => keys2.includes(key) && this.deepEqual(value1[key], value2[key]));
     }
-    return deepEqual(obj1, obj2);
-};
-export default _helpers;
+}
+const helpers = new HelperUtility();
+export default helpers;

package/dist/utils/validateType.js

@@ -1,11 +1,12 @@
-import { EValidationDetails } from "../constants/details.js";
-const _validateType = {
-    getResult: (key, passed, details = EValidationDetails.OK) => {
+import { ValidationDetails } from "../constants/details.js";
+class TypeValidationUtility {
+    getResult(key, passed, details = ValidationDetails.OK) {
         return {
-            key: key,
-            passed: passed,
-            details: details,
+            key,
+            passed,
+            details
         };
     }
-};
-export default _validateType;
+}
+const validateType = new TypeValidationUtility();
+export default validateType;

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;