validno 0.2.5 → 0.3.0

package/dist/validateEngine/methods/handleKey.js

@@ -0,0 +1,43 @@
+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.checkRulesForKey({ 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();
+        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(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/validateEngine/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/validateEngine/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/validateEngine/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;

package/dist/validateEngine/methods/validate.js

@@ -0,0 +1,14 @@
+import _helpers from "../../utils/helpers.js";
+function 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.handleKey({ key, data, reqs });
+        this.result.merge(keyResult);
+    }
+    return this.result.finish();
+}
+export default validate;

package/dist/validateEngine/methods/validateKey.js

@@ -0,0 +1,31 @@
+import _helpers from "../../utils/helpers.js";
+import ValidnoResult from "../../ValidnoResult.js";
+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 this.handleMissingNestedKey(nestedKey, results);
+    }
+    if (_helpers.checkIsNested(reqs)) {
+        return this.validateNestedKey({ results, key, data, reqs, nestedKey });
+    }
+    return this.validateKeyDetails({
+        results,
+        key,
+        nestedKey,
+        data,
+        reqs,
+        hasMissing,
+    });
+}
+export default validateKey;

package/dist/validateEngine/methods/validateKeyDetails.js

@@ -0,0 +1,13 @@
+function 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, value: data[key], reqs, nestedKey, typeChecked });
+    this.checkRulesForKey({ results, nestedKey, value: data[key], reqs, data, rulesChecked });
+    return this.finalizeValidation({ results, nestedKey, missedCheck, typeChecked, rulesChecked });
+}
+export default validateKeyDetails;

package/dist/validateEngine/methods/validateKeyValue.js

@@ -0,0 +1,13 @@
+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.checkValueType({ results, key, value: data[key], reqs, nestedKey, typeChecked });
+    this.checkRulesForKey({ results, nestedKey, value: data[key], reqs, data, rulesChecked });
+    return this.finalizeValidation({ results, nestedKey, missedCheck, typeChecked, rulesChecked });
+}
+export default validateKeyValue;

package/dist/validateEngine/methods/validateNestedKey.js

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

package/dist/validateEngine/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 ? null : _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/validateEngine/validate.js

@@ -0,0 +1,14 @@
+import _helpers from "../utils/helpers.js";
+function 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();
+}
+export default validate;

package/dist/{checkRules.js → validateRules.js}

@@ -110,7 +110,7 @@ const rulesFunctions = {
         return output;
     }
 };
-function checkRules(key, value, requirements, inputObj) {
+function validateRules(key, value, requirements, inputObj) {
     const result = {
         ok: true,
         details: []
@@ -156,4 +156,4 @@ function checkRules(key, value, requirements, inputObj) {
     return result;
 }
 ;
-export default checkRules;
+export default validateRules;

package/dist/validateSchema/ValidateEngine.js

@@ -0,0 +1,147 @@
+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();
+    }
+}
+export default ValidateEngine;

package/dist/validateSchema/index.js

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

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;