validno 0.2.6 → 0.3.0

package/dist/Schema.js

@@ -1,14 +1,15 @@
-import { ESchemaFields } from "./constants/schema.js";
-import validate from "./validate.js";
-export const defaultSchemaKeys = Object.values(ESchemaFields);
+import { SchemaFields } from "./constants/schema.js";
+import ValidateEngine from "./engine/ValidateEngine.js";
+export const defaultSchemaKeys = Object.values(SchemaFields);
 export class Schema {
     constructor(inputSchemaDefinition) {
         if (!inputSchemaDefinition || typeof inputSchemaDefinition !== 'object') {
             throw new Error("Invalid schema input");
         }
-        this.schema = inputSchemaDefinition;
+        this.definition = inputSchemaDefinition;
     }
     validate(inputData, validationKeys) {
-        return validate.call(this, inputData, validationKeys);
+        const engine = new ValidateEngine(this.definition);
+        return engine.validate(inputData, validationKeys);
     }
 }

package/dist/ValidnoResult.js

@@ -17,12 +17,14 @@ class ValidnoResult {
         this.byKeys[key] = result;
     }
     fixParentByChilds(parentKey, childChecks = []) {
-        const isEveryOk = childChecks.every(c => c === true);
+        const isEveryOk = childChecks.every(check => check === true);
         this.setKeyStatus(parentKey, isEveryOk);
-        if (isEveryOk === true)
+        if (isEveryOk) {
             this.setPassed(parentKey);
-        else
+        }
+        else {
             this.setFailed(parentKey);
+        }
     }
     setMissing(key, errMsg) {
         const error = errMsg || _errors.getMissingError(key);
@@ -35,7 +37,7 @@ class ValidnoResult {
         this.setKeyStatus(key, true);
     }
     setFailed(key, msg) {
-        if (key in this.errorsByKeys === false) {
+        if (!(key in this.errorsByKeys)) {
             this.errorsByKeys[key] = [];
         }
         this.failed.push(key);
@@ -55,8 +57,9 @@ class ValidnoResult {
         this.passed = [...this.passed, ...resultsNew.passed];
         this.byKeys = Object.assign(Object.assign({}, this.byKeys), resultsNew.byKeys);
         for (const key in resultsNew.errorsByKeys) {
-            if (key in this.errorsByKeys === false)
+            if (!(key in this.errorsByKeys)) {
                 this.errorsByKeys[key] = [];
+            }
             this.errorsByKeys[key] = [
                 ...this.errorsByKeys[key],
                 ...resultsNew.errorsByKeys[key]
@@ -72,10 +75,12 @@ class ValidnoResult {
         }
     }
     finish() {
-        if (this.failed.length || this.errors.length)
+        if (this.failed.length || this.errors.length) {
             this.ok = false;
-        else
+        }
+        else {
             this.ok = true;
+        }
         this.clearEmptyErrorsByKeys();
         return this;
     }

package/dist/checkType.js

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

package/dist/constants/details.js

@@ -1,11 +1,11 @@
-export var EValidationId;
-(function (EValidationId) {
-    EValidationId["Missing"] = "missing";
-    EValidationId["Type"] = "type";
-    EValidationId["Rule"] = "rule";
-})(EValidationId || (EValidationId = {}));
-export var EValidationDetails;
-(function (EValidationDetails) {
-    EValidationDetails["OK"] = "ok";
-    EValidationDetails["INVALID_DATE"] = "\u0414\u0430\u0442\u0430 \u043D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u0430";
-})(EValidationDetails || (EValidationDetails = {}));
+export var ValidationIds;
+(function (ValidationIds) {
+    ValidationIds["Missing"] = "missing";
+    ValidationIds["Type"] = "type";
+    ValidationIds["Rule"] = "rule";
+})(ValidationIds || (ValidationIds = {}));
+export var ValidationDetails;
+(function (ValidationDetails) {
+    ValidationDetails["OK"] = "OK";
+    ValidationDetails["INVALID_DATE"] = "Invalid date";
+})(ValidationDetails || (ValidationDetails = {}));

package/dist/constants/schema.js

@@ -1,10 +1,10 @@
-export var ESchemaFields;
-(function (ESchemaFields) {
-    ESchemaFields["Required"] = "required";
-    ESchemaFields["Type"] = "type";
-    ESchemaFields["EachType"] = "eachType";
-    ESchemaFields["Rules"] = "rules";
-    ESchemaFields["Title"] = "title";
-    ESchemaFields["CustomMessage"] = "customMessage";
-    ESchemaFields["JoinErrors"] = "joinErrors";
-})(ESchemaFields || (ESchemaFields = {}));
+export var SchemaFields;
+(function (SchemaFields) {
+    SchemaFields["Required"] = "required";
+    SchemaFields["Type"] = "type";
+    SchemaFields["EachType"] = "eachType";
+    SchemaFields["Rules"] = "rules";
+    SchemaFields["Title"] = "title";
+    SchemaFields["CustomMessage"] = "customMessage";
+    SchemaFields["JoinErrors"] = "joinErrors";
+})(SchemaFields || (SchemaFields = {}));

package/dist/dev.js

@@ -1,30 +1,70 @@
-import { Schema } from "./Schema.js";
-const testSchema = new Schema({
-    parent: {
-        collection: {
-            type: [String, Array],
-            required: true
+import Schema from './index.js';
+const schema = new Schema({
+    name: {
+        type: String,
+        required: true
+    },
+    lastVisit: {
+        type: Date,
+        required: true,
+    },
+    age: {
+        type: Number,
+        required: true,
+    },
+    email: {
+        type: String,
+        required: true,
+        rules: {
+            isEmail: true
         }
-    }
+    },
+    isAwesome: {
+        type: Boolean,
+        required: true
+    },
+    friends: {
+        type: Array,
+        required: true,
+        eachType: String,
+    },
+    broRegex: {
+        type: RegExp,
+        required: true,
+    },
+    socials: {
+        x: {
+            type: String,
+            required: false
+        },
+        instagram: {
+            type: String,
+            required: false
+        }
+    },
+    nullableField: {
+        type: null,
+        required: false,
+    },
 });
-const testObj = {
-    parent: {
-        collection: ['xxxx']
-    }
-};
-const testObj2 = {
-    parent: {
-        collection: false
-    }
-};
-const testObj3 = {
-    parent: {
-        collection: 'str'
-    }
+const exampleObj = {
+    name: 'Barney Stinson',
+    age: 35,
+    lastVisit: new Date('2025-05-05'),
+    email: 'legggen@dary.com',
+    isAwesome: true,
+    friends: [
+        'Ted Mosby',
+        'Marshall Eriksen',
+        'Lily Aldrin',
+        'Robin Scherbatsky'
+    ],
+    socials: {
+        x: '@barney_stinson',
+        insstagram: '@barney_stinson'
+    },
+    broRegex: /bro/i,
+    deletedAt: null,
 };
-const res = testSchema.validate(testObj);
-console.log(res.ok === true ? '#1 ✅' : '#1 ❌');
-const res2 = testSchema.validate(testObj2);
-console.log(res2.ok === false ? '#2 ✅' : '#2 ❌');
-const res3 = testSchema.validate(testObj3);
-console.log(res3.ok === true ? '#3 ✅' : '#3 ❌');
+const validation = schema.validate(exampleObj);
+console.log(validation);

package/dist/engine/ValidateEngine.js

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

package/dist/engine/ValidnoResult.js

@@ -0,0 +1,102 @@
+import _errors from "../utils/errors.js";
+class ValidnoResult {
+    constructor(results) {
+        this.ok = (results === null || results === void 0 ? void 0 : results.ok) !== undefined ? results.ok : null;
+        this.missed = (results === null || results === void 0 ? void 0 : results.missed) || [];
+        this.failed = (results === null || results === void 0 ? void 0 : results.failed) || [];
+        this.passed = (results === null || results === void 0 ? void 0 : results.passed) || [];
+        this.errors = (results === null || results === void 0 ? void 0 : results.errors) || [];
+        this.byKeys = (results === null || results === void 0 ? void 0 : results.byKeys) || {};
+        this.errorsByKeys = (results === null || results === void 0 ? void 0 : results.errorsByKeys) || {};
+    }
+    setNoData(key) {
+        this.ok = false;
+        this.errors = [`Missing value for '${key}'`];
+    }
+    setKeyStatus(key, result) {
+        this.byKeys[key] = result;
+    }
+    fixParentByChilds(parentKey, childChecks = []) {
+        const isEveryOk = childChecks.every(check => check === true);
+        this.setKeyStatus(parentKey, isEveryOk);
+        if (isEveryOk) {
+            this.setPassed(parentKey);
+        }
+        else {
+            this.setFailed(parentKey);
+        }
+    }
+    setMissing(key, errMsg) {
+        const error = errMsg || _errors.getMissingError(key);
+        this.missed.push(key);
+        this.setFailed(key, error);
+        this.setKeyStatus(key, false);
+    }
+    setPassed(key) {
+        this.passed.push(key);
+        this.setKeyStatus(key, true);
+    }
+    setFailed(key, msg) {
+        if (!(key in this.errorsByKeys)) {
+            this.errorsByKeys[key] = [];
+        }
+        this.failed.push(key);
+        this.setKeyStatus(key, false);
+        if (!msg)
+            return;
+        this.errors.push(msg);
+        this.errorsByKeys[key].push(msg);
+    }
+    joinErrors(separator = '; ') {
+        return _errors.joinErrors(this.errors, separator);
+    }
+    merge(resultsNew) {
+        this.failed = [...this.failed, ...resultsNew.failed];
+        this.errors = [...this.errors, ...resultsNew.errors];
+        this.missed = [...this.missed, ...resultsNew.missed];
+        this.passed = [...this.passed, ...resultsNew.passed];
+        this.byKeys = Object.assign(Object.assign({}, this.byKeys), resultsNew.byKeys);
+        for (const key in resultsNew.errorsByKeys) {
+            if (!(key in this.errorsByKeys)) {
+                this.errorsByKeys[key] = [];
+            }
+            this.errorsByKeys[key] = [
+                ...this.errorsByKeys[key],
+                ...resultsNew.errorsByKeys[key]
+            ];
+        }
+        return this;
+    }
+    clearEmptyErrorsByKeys() {
+        for (const key in this.errorsByKeys) {
+            if (!this.errorsByKeys[key].length) {
+                delete this.errorsByKeys[key];
+            }
+        }
+    }
+    finish() {
+        if (this.failed.length || this.errors.length) {
+            this.ok = false;
+        }
+        else {
+            this.ok = true;
+        }
+        this.clearEmptyErrorsByKeys();
+        return this;
+    }
+    data() {
+        return {
+            ok: this.ok,
+            missed: this.missed,
+            failed: this.failed,
+            passed: this.passed,
+            errors: this.errors,
+            byKeys: this.byKeys,
+            errorsByKeys: this.errorsByKeys,
+        };
+    }
+    isValid() {
+        return this.ok === true;
+    }
+}
+export default ValidnoResult;

package/dist/engine/index.js

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

package/dist/engine/methods/finishValidation.js

@@ -0,0 +1,15 @@
+function finishValidation(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 finishValidation;

package/dist/engine/methods/handleKey.js

@@ -0,0 +1,41 @@
+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.validateRules({ 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(nestedKey);
+    }
+    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/engine/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/engine/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/engine/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/engine/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/engine/methods/validateRules.js

@@ -0,0 +1,172 @@
+import _validations from "../../utils/validations.js";
+export const rulesParams = {
+    lengthMin: {
+        allowedTypes: [String]
+    }
+};
+const ensureRuleHasCorrectType = (value, allowedTypes) => {
+    const isInAllowedList = allowedTypes.some(TYPE => {
+        const getType = (el) => Object.prototype.toString.call(el);
+        return getType(new TYPE()) == getType(value);
+    });
+    return isInAllowedList;
+};
+const rulesFunctions = {
+    custom: (key, val, func, extra) => {
+        return func(val, extra);
+    },
+    isEmail: (key, val) => {
+        return {
+            result: _validations.isEmail(val),
+            details: `Value must be a valid email address`
+        };
+    },
+    is: (key, val, equalTo) => {
+        return {
+            result: _validations.is(val, equalTo),
+            details: `Value must be equal to "${equalTo}"`
+        };
+    },
+    isNot: (key, val, notEqualTo) => {
+        return {
+            result: _validations.isNot(val, notEqualTo),
+            details: `Value must not be equal to "${notEqualTo}"`
+        };
+    },
+    min: (key, val, min) => {
+        return {
+            result: _validations.isNumberGte(val, min),
+            details: `Value must be greater than or equal to ${min}`
+        };
+    },
+    max: (key, val, max) => {
+        return {
+            result: _validations.isNumberLte(val, max),
+            details: `Value must be less than or equal to ${max}`
+        };
+    },
+    minMax: (key, val, minMax) => {
+        const [min, max] = minMax;
+        return {
+            result: _validations.isNumberGte(val, min) && _validations.isNumberLte(val, max),
+            details: `Value must be between ${min} and ${max}`
+        };
+    },
+    length: (key, val, length) => {
+        return {
+            result: _validations.lengthIs(val, length),
+            details: `Value must be equal to ${length}`
+        };
+    },
+    lengthNot: (key, val, lengthNot) => {
+        return {
+            result: _validations.lengthNot(val, lengthNot),
+            details: `Value must not be equal to ${lengthNot}`
+        };
+    },
+    lengthMinMax: (key, val, minMax) => {
+        const [min, max] = minMax;
+        return {
+            result: _validations.lengthMin(val, min) && _validations.lengthMax(val, max),
+            details: `Value must be between ${min} and ${max} characters`
+        };
+    },
+    lengthMin: (key, val, min) => {
+        ensureRuleHasCorrectType(val, rulesParams['lengthMin'].allowedTypes);
+        return {
+            result: _validations.lengthMin(val, min),
+            details: `Value must be at least ${min} characters`
+        };
+    },
+    lengthMax: (key, val, max) => {
+        return {
+            result: _validations.lengthMax(val, max),
+            details: `Value must not be exceed ${max} characters`
+        };
+    },
+    regex: (key, val, regex) => {
+        return {
+            result: _validations.regexTested(val, regex),
+            details: `Value must match the format ${regex}`
+        };
+    },
+    enum: (key, value, allowedList) => {
+        const output = {
+            result: true,
+            details: ''
+        };
+        if (!Array.isArray(value)) {
+            const isCorrect = allowedList.includes(value);
+            output.result = isCorrect,
+                output.details = isCorrect ? '' : `Value "${value}" is not allowed`;
+        }
+        else {
+            const incorrectValues = [];
+            value.forEach((v) => !allowedList.includes(v) ? incorrectValues.push(v) : {});
+            const isCorrect = incorrectValues.length === 0;
+            output.result = isCorrect,
+                output.details = isCorrect ? '' : `Values are not allowed: "${incorrectValues.join(', ')}"`;
+        }
+        return output;
+    }
+};
+function unnamed(key, value, requirements, inputObj) {
+    const result = {
+        ok: true,
+        details: []
+    };
+    if (requirements.required !== true && value === undefined)
+        return result;
+    if (!requirements || !requirements.rules || !Object.keys(requirements.rules).length) {
+        return result;
+    }
+    const rules = requirements.rules;
+    const title = requirements.title || key;
+    const allResults = [];
+    const allRulesKeys = Object.keys(rules);
+    let i = 0;
+    while (i < allRulesKeys.length) {
+        const ruleName = allRulesKeys[i];
+        if (ruleName in rulesFunctions === false) {
+            i++;
+            continue;
+        }
+        const func = rulesFunctions[ruleName];
+        const args = rules[ruleName];
+        const result = func(key, value, args, { schema: this.schema, input: inputObj });
+        if (requirements.customMessage && typeof requirements.customMessage === 'function') {
+            result.details = requirements.customMessage({
+                keyword: ruleName,
+                value: value,
+                key: key,
+                title: title,
+                reqs: requirements,
+                schema: this.schema,
+                rules: rules,
+            });
+        }
+        allResults.push(result);
+        i++;
+    }
+    const failedResults = allResults.filter(el => el.result === false);
+    if (failedResults.length) {
+        result.ok = false;
+        result.details = failedResults.map(el => el.details);
+    }
+    return result;
+}
+;
+function validateRules(input) {
+    const { results, nestedKey, value, reqs, data, rulesChecked } = input;
+    const ruleCheck = unnamed.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 validateRules;