validno 0.1.4 → 0.1.5

package/dist/checkRules.js

@@ -12,8 +12,8 @@ const ensureRuleHasCorrectType = (value, allowedTypes) => {
     return isInAllowedList;
 };
 const rulesFunctions = {
-    custom: (key, val, func) => {
-        return func(val);
+    custom: (key, val, func, extra) => {
+        return func(val, extra);
     },
     isEmail: (key, val) => {
         return {
@@ -91,13 +91,26 @@ const rulesFunctions = {
         };
     },
     enum: (key, value, allowedList) => {
-        return {
-            result: allowedList.includes(value),
-            details: `Значение "${value}" недопустимо`
+        const output = {
+            result: true,
+            details: ''
         };
+        if (!Array.isArray(value)) {
+            const isCorrect = allowedList.includes(value);
+            output.result = isCorrect,
+                output.details = isCorrect ? '' : `Значение "${value}" недопустимо`;
+        }
+        else {
+            const incorrectValues = [];
+            value.forEach((v) => !allowedList.includes(v) ? incorrectValues.push(v) : {});
+            const isCorrect = incorrectValues.length === 0;
+            output.result = isCorrect,
+                output.details = isCorrect ? '' : `Значения недопустимы: "${incorrectValues.join(', ')}"`;
+        }
+        return output;
     }
 };
-const checkRules = (key, value, requirements) => {
+function checkRules(key, value, requirements, inputObj) {
     const result = {
         ok: true,
         details: []
@@ -119,7 +132,7 @@ const checkRules = (key, value, requirements) => {
         }
         const func = rulesFunctions[ruleName];
         const args = rules[ruleName];
-        const result = func(key, value, args);
+        const result = func(key, value, args, { schema: this.schema, input: inputObj });
         allResults.push(result);
         i++;
     }
@@ -129,5 +142,6 @@ const checkRules = (key, value, requirements) => {
         result.details = failedResults.map(el => el.details);
     }
     return result;
-};
+}
+;
 export default checkRules;

package/dist/validate.js

@@ -35,7 +35,7 @@ export const mergeResults = (resultsOld, resultsNew) => {
     output.errorsByKeys = Object.assign(Object.assign({}, resultsOld.errorsByKeys), resultsNew.errorsByKeys);
     return output;
 };
-export const handleReqKey = (key, data, reqs, deepKey = key) => {
+export function handleReqKey(key, data, reqs, deepKey = key) {
     let results = getResultDefaults();
     const hasNested = checkIsNested(reqs);
     const missedCheck = [];
@@ -54,7 +54,7 @@ export const handleReqKey = (key, data, reqs, deepKey = key) => {
         let i = 0;
         while (i < nestedReqKeys.length) {
             const reqKeyI = nestedReqKeys[i];
-            const deepResults = handleReqKey(reqKeyI, data[key], reqs[reqKeyI], deepKey + '.' + reqKeyI);
+            const deepResults = handleReqKey.call(this, reqKeyI, data[key], reqs[reqKeyI], deepKey + '.' + reqKeyI);
             results = mergeResults(results, deepResults);
             i++;
         }
@@ -77,7 +77,7 @@ export const handleReqKey = (key, data, reqs, deepKey = key) => {
             results.errors.push(res.details);
         }
     });
-    const ruleCheck = checkRules(deepKey, data[key], reqs);
+    const ruleCheck = checkRules.call(this, deepKey, data[key], reqs, data);
     if (!ruleCheck.ok) {
         rulesChecked.push(false);
         ruleCheck.details.forEach((el) => {
@@ -100,16 +100,16 @@ export const handleReqKey = (key, data, reqs, deepKey = key) => {
     ];
     results.byKeys[deepKey] = (missedCheck.length + typeChecked.length + rulesChecked.length) === 0;
     return results;
-};
+}
 const isCheckNeeded = (key, hasLimits, onlyKeys) => {
     return !hasLimits || (key === onlyKeys || Array.isArray(onlyKeys) && (onlyKeys === null || onlyKeys === void 0 ? void 0 : onlyKeys.includes(key)));
 };
-const validate = (schema, data, onlyKeys) => {
+function validate(schema, data, onlyKeys) {
     let results = getResultDefaults();
     const areKeysLimited = (Array.isArray(onlyKeys) && onlyKeys.length > 0) || (typeof onlyKeys === 'string' && onlyKeys.length > 0);
     for (const [key, reqs] of Object.entries(schema.schema)) {
         if (isCheckNeeded(key, areKeysLimited, onlyKeys)) {
-            const keyResult = handleReqKey(key, data, reqs);
+            const keyResult = handleReqKey.call(this, key, data, reqs);
             results = mergeResults(results, keyResult);
         }
     }
@@ -118,5 +118,6 @@ const validate = (schema, data, onlyKeys) => {
     else
         results.ok = true;
     return results;
-};
+}
+;
 export default validate;

package/package.json

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

package/src/checkRules.ts

@@ -1,4 +1,4 @@
-import { TSchemaItem } from "./Schema.js";
+import { TSchema, TSchemaItem } from "./Schema.js";
 import _validations from "./utils/validations.js"
 
 export type TRule = {[key: string]: any}
@@ -21,8 +21,8 @@ const ensureRuleHasCorrectType = (value: any, allowedTypes: any[]) => {
 }
 
 const rulesFunctions: any = {
-    custom: (key: string, val: any, func: Function) => {
-        return func(val)
+    custom: (key: string, val: any, func: Function, extra: {schema: TSchema, input: {[key: string]: any}}) => {
+        return func(val, extra)
     },
     isEmail: (key: string, val: any) => {
         return {
@@ -102,10 +102,25 @@ const rulesFunctions: any = {
         }
     },
     enum: (key: string, value: any, allowedList: any[]) => {
-        return {
-            result: allowedList.includes(value),
-            details: `Значение "${value}" недопустимо`
+        const output = {
+            result: true,
+            details: ''
+        }
+
+        if (!Array.isArray(value)) {
+            const isCorrect = allowedList.includes(value)
+            output.result = isCorrect,
+            output.details = isCorrect ? '' : `Значение "${value}" недопустимо`
+        } else {
+            const incorrectValues: any[] = []
+            value.forEach((v: any) => !allowedList.includes(v) ? incorrectValues.push(v): {})
+            const isCorrect = incorrectValues.length === 0
+
+            output.result = isCorrect,
+            output.details = isCorrect ? '' : `Значения недопустимы: "${incorrectValues.join(', ')}"`
         }
+
+        return output
     }
 };
 
@@ -114,7 +129,7 @@ type TRulesResult = {
     details: string[]
 } 
 
-const checkRules = (key: string, value: any, requirements: TSchemaItem) => {
+function checkRules (this: any, key: string, value: any, requirements: TSchemaItem, inputObj: any) {
     const result: TRulesResult = {
         ok: true,
         details: []
@@ -146,7 +161,7 @@ const checkRules = (key: string, value: any, requirements: TSchemaItem) => {
         const func = rulesFunctions[ruleName]
         const args = rules[ruleName]
 
-        const result = func(key, value, args)
+        const result = func(key, value, args, {schema: this.schema, input: inputObj})
         allResults.push(result)
 
         i++;

package/src/validate.ts

@@ -51,10 +51,10 @@ export const mergeResults = (resultsOld: TResult, resultsNew: TResult) => {
   return output
 }
 
-export const handleReqKey = (key: string, data: any, reqs: TSchemaInput, deepKey = key) => {
+export function handleReqKey(this: any, key: string, data: any, reqs: TSchemaInput, deepKey = key) {
   let results = getResultDefaults()
   const hasNested = checkIsNested(reqs)
-  
+
   const missedCheck: boolean[] = [];
   const typeChecked: boolean[] = [];
   const rulesChecked: boolean[] = [];
@@ -80,7 +80,8 @@ export const handleReqKey = (key: string, data: any, reqs: TSchemaInput, deepKey
     while (i < nestedReqKeys.length) {
       const reqKeyI: string = nestedReqKeys[i]
 
-      const deepResults = handleReqKey(
+      const deepResults = handleReqKey.call(
+        this,
         reqKeyI,
         data[key],
         // @ts-ignore
@@ -122,7 +123,7 @@ export const handleReqKey = (key: string, data: any, reqs: TSchemaInput, deepKey
 
   // Check all rules
   // @ts-ignore
-  const ruleCheck = checkRules(deepKey, data[key], reqs);
+  const ruleCheck = checkRules.call(this, deepKey, data[key], reqs, data);
 
   if (!ruleCheck.ok) {
     rulesChecked.push(false)
@@ -158,14 +159,14 @@ const isCheckNeeded = (key: string, hasLimits: boolean, onlyKeys?: string | stri
   return !hasLimits || (key === onlyKeys || Array.isArray(onlyKeys) && onlyKeys?.includes(key))
 }
 
-const validate = (schema: Schema, data: any, onlyKeys?: string | string[]): TResult => {
+function validate(schema: Schema, data: any, onlyKeys?: string | string[]): TResult {
     let results: TResult = getResultDefaults()
     const areKeysLimited = (Array.isArray(onlyKeys) && onlyKeys.length > 0) || (typeof onlyKeys === 'string' && onlyKeys.length > 0)
 
     for (const [key, reqs] of Object.entries(schema.schema)) {
       if (isCheckNeeded(key, areKeysLimited, onlyKeys)) {
         // @ts-ignore
-        const keyResult = handleReqKey(key, data, reqs)
+        const keyResult = handleReqKey.call(this, key, data, reqs)
 
         results = mergeResults(results, keyResult)
       }

package/dist/Validator.js

@@ -1,100 +0,0 @@
-import checkRules from "./checkRules.js";
-import checkType from "./checkType.js";
-import { defaultSchemaKeys } from "./Schema.js";
-const getResultDefault = () => {
-    return {
-        ok: null,
-        missed: [],
-        failed: [],
-        passed: [],
-        errors: [],
-        byKeys: {}
-    };
-};
-const checkIsNested = (obj) => {
-    const objKeys = Object.keys(obj);
-    if (objKeys.every((k) => defaultSchemaKeys.includes(k))) {
-        return false;
-    }
-    else {
-        return true;
-    }
-};
-const handleReqKey = (key, data, reqs, deepKey = key) => {
-    console.log('..................... ', key);
-    const results = getResultDefault();
-    const hasNested = checkIsNested(reqs);
-    const missedCheck = [];
-    const typeChecked = [];
-    const rulesChecked = [];
-    if (hasNested) {
-        const nestedReqKeys = Object.keys(reqs);
-        let i = 0;
-        while (i < nestedReqKeys.length) {
-            const reqKeyI = nestedReqKeys[i];
-            const deepResults = handleReqKey(reqKeyI, data[key], reqs[reqKeyI], deepKey + '.' + reqKeyI);
-            results.failed = [...results.failed, ...deepResults.failed];
-            results.errors = [...results.errors, ...deepResults.errors];
-            results.missed = [...results.missed, ...deepResults.missed];
-            results.passed = [...results.passed, ...deepResults.passed];
-            results.byKeys = Object.assign(Object.assign({}, results.byKeys), deepResults.byKeys);
-            i++;
-        }
-        return results;
-    }
-    if (reqs.required === true && key in data === false) {
-        missedCheck.push(false);
-        results.errors.push(`Missing key '${deepKey}'`);
-        return results;
-    }
-    const typeCheck = checkType(key, data[key], reqs, deepKey);
-    typeCheck.forEach(res => {
-        if (res.passed === false) {
-            typeChecked.push(res.passed);
-            results.errors.push(res.details);
-        }
-    });
-    const ruleCheck = checkRules(deepKey, data[key], reqs);
-    if (!ruleCheck.ok) {
-        rulesChecked.push(false);
-        ruleCheck.details.forEach((el) => results.errors.push(el));
-    }
-    if (missedCheck.length) {
-        results.missed.push(deepKey);
-    }
-    if (typeChecked.length || rulesChecked.length) {
-        results.failed.push(deepKey);
-    }
-    else {
-        results.passed.push(deepKey);
-    }
-    console.log(missedCheck.length, typeChecked.length, rulesChecked.length);
-    results.byKeys[deepKey] = (missedCheck.length + typeChecked.length + rulesChecked.length) === 0;
-    console.log(results);
-    return results;
-};
-const validate = (schema, data) => {
-    const results = getResultDefault();
-    for (const [key, reqs] of Object.entries(schema.schema)) {
-        const keyResult = handleReqKey(key, data, reqs);
-        results.failed = [...results.failed, ...keyResult.failed];
-        results.errors = [...results.errors, ...keyResult.errors];
-        results.missed = [...results.missed, ...keyResult.missed];
-        results.passed = [...results.passed, ...keyResult.passed];
-        results.byKeys = Object.assign(Object.assign({}, results.byKeys), keyResult.byKeys);
-    }
-    if (results.failed.length)
-        results.ok = false;
-    else
-        results.ok = true;
-    results.missed = [...new Set(results.missed)];
-    results.failed = [...new Set(results.failed)];
-    results.passed = [...new Set(results.passed)];
-    results.errors = [...new Set(results.errors)];
-    return results;
-};
-class Validator {
-    constructor() { }
-}
-Validator.validate = validate;
-export default Validator;

package/dist/app.js

@@ -1,45 +0,0 @@
-import Schema from "./index.js";
-const schema = new Schema({
-    val: {
-        type: String,
-        required: true,
-    },
-    date: {
-        type: Date,
-        required: true,
-    },
-    obj: {
-        type: Object,
-        required: true,
-    },
-    bool: {
-        type: Boolean,
-        required: true,
-    },
-    val2: {
-        type: Number,
-        required: true,
-        rules: {
-            min: 3
-        }
-    },
-    srtOrNum: {
-        type: [String, Number],
-        required: true,
-    },
-    nl: {
-        type: null,
-        required: true,
-    },
-});
-const testObj = {
-    val: 'string',
-    val2: 4,
-    obj: {},
-    srtOrNum: ['ss'],
-    date: new Date(),
-    bool: true,
-    nl: null
-};
-const resAll = schema.validate(testObj);
-const str = 'test';

package/dist/sss.js

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

package/dist/validateKey.js

@@ -1,15 +0,0 @@
-import { getResultDefaults, handleReqKey, mergeResults } from "./validate.js";
-const validateKey = (schema, data, key) => {
-    if (key in schema.schema === false) {
-        throw new Error(`Ключ ${key} отсутствует в схеме`);
-    }
-    let results = getResultDefaults();
-    const keyResult = handleReqKey(key, data, schema.schema[key]);
-    results = mergeResults(results, keyResult);
-    if (results.failed.length)
-        results.ok = false;
-    else
-        results.ok = true;
-    return results;
-};
-export default validateKey;