validno 0.1.8 → 0.1.10

package/dist/checkRules.js

@@ -121,6 +121,7 @@ function checkRules(key, value, requirements, inputObj) {
         return result;
     }
     const rules = requirements.rules;
+    const title = requirements.title || key;
     const allResults = [];
     const allRulesKeys = Object.keys(rules);
     let i = 0;
@@ -133,6 +134,17 @@ function checkRules(key, value, requirements, inputObj) {
         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++;
     }

package/dist/checkType.js

@@ -1,3 +1,4 @@
+import { ErrorKeywords } from "./constants/details.js";
 import _validations from "./utils/validations.js";
 const getErrorDetails = (key, expectedType, receivedValue) => {
     let receivedType = '';
@@ -32,7 +33,7 @@ const checkTypeMultiple = (key, value, requirements, keyName = key) => {
         const check = checkType(key, value, requirementsRe);
         if (check[0].passed === true) {
             result.passed = true;
-            result.details = 'Passed';
+            result.details = 'OK';
             return result;
         }
         i++;
@@ -41,8 +42,10 @@ const checkTypeMultiple = (key, value, requirements, keyName = key) => {
 };
 const checkType = (key, value, requirements, keyName = key) => {
     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 [{ key: keyName, passed: false, details: `Key ${keyName} is missing` }];
+        return [{ key: keyName, passed: false, details: `Значение "${keyName}" отсутствует` }];
     }
     let result = [];
     if (Array.isArray(requirements.type)) {
@@ -52,16 +55,28 @@ const checkType = (key, value, requirements, keyName = key) => {
         result.push({
             key: keyName,
             passed: true,
-            details: 'Passed'
+            details: 'OK'
         });
         return result;
     }
+    const customErrDetails = hasCustomMessage ?
+        requirements.customMessage({
+            keyword: ErrorKeywords.Type,
+            value: value,
+            key: keyName,
+            title: keyTitle,
+            reqs: requirements,
+            schema: null
+        }) :
+        null;
+    const baseErrDetails = getErrorDetails(keyName, requirements.type, value);
+    const getDetails = (isOK) => isOK ? 'OK' : customErrDetails || baseErrDetails;
     switch (requirements.type) {
         case 'any':
             result.push({
                 key: keyName,
                 passed: true,
-                details: 'Passed'
+                details: 'OK'
             });
             break;
         case Number:
@@ -69,7 +84,7 @@ const checkType = (key, value, requirements, keyName = key) => {
             result.push({
                 key: keyName,
                 passed: isNumber,
-                details: isNumber ? 'Passed' : getErrorDetails(keyName, requirements.type, value)
+                details: getDetails(isNumber)
             });
             break;
         case String:
@@ -77,17 +92,17 @@ const checkType = (key, value, requirements, keyName = key) => {
             result.push({
                 key: keyName,
                 passed: isString,
-                details: isString ? 'Passed' : getErrorDetails(keyName, requirements.type, value)
+                details: getDetails(isString)
             });
             break;
         case Date:
             const isDate = isNotNull && value.constructor === Date;
             const isValid = isDate && !isNaN(value.getTime());
-            const errorMsg = isValid ? getErrorDetails(keyName, requirements.type, value) : 'Дата невалидна';
+            const errorMsg = isValid ? getDetails(isDate) : 'Дата невалидна';
             result.push({
                 key: keyName,
                 passed: isDate && isValid,
-                details: isDate && isValid ? 'Passed' : errorMsg
+                details: isDate && isValid ? 'OK' : errorMsg
             });
             break;
         case Boolean:
@@ -95,7 +110,7 @@ const checkType = (key, value, requirements, keyName = key) => {
             result.push({
                 key: keyName,
                 passed: isBoolean,
-                details: isBoolean ? 'Passed' : getErrorDetails(keyName, requirements.type, value)
+                details: isBoolean ? 'OK' : getDetails(isBoolean)
             });
             break;
         case Array:
@@ -104,7 +119,7 @@ const checkType = (key, value, requirements, keyName = key) => {
                 result.push({
                     key: keyName,
                     passed: false,
-                    details: getErrorDetails(keyName, requirements.type, value)
+                    details: getDetails(isArray)
                 });
                 break;
             }
@@ -123,7 +138,7 @@ const checkType = (key, value, requirements, keyName = key) => {
             result.push({
                 key: keyName,
                 passed: isOk,
-                details: isOk ? 'Passed' : !isEachChecked.passed ? isEachChecked.details : getErrorDetails(keyName, requirements.type, value)
+                details: isOk ? 'OK' : !isEachChecked.passed ? isEachChecked.details : getDetails(isOk)
             });
             break;
         case Object:
@@ -131,7 +146,7 @@ const checkType = (key, value, requirements, keyName = key) => {
             result.push({
                 key: keyName,
                 passed: isObject,
-                details: isObject ? 'Passed' : getErrorDetails(keyName, requirements.type, value)
+                details: isObject ? 'OK' : getDetails(isObject)
             });
             break;
         case RegExp:
@@ -139,7 +154,7 @@ const checkType = (key, value, requirements, keyName = key) => {
             result.push({
                 key: keyName,
                 passed: isRegex,
-                details: isRegex ? 'Passed' : getErrorDetails(keyName, requirements.type, value)
+                details: isRegex ? 'OK' : getDetails(isRegex)
             });
             break;
         case null:
@@ -147,7 +162,7 @@ const checkType = (key, value, requirements, keyName = key) => {
             result.push({
                 key: keyName,
                 passed: isNull,
-                details: isNull ? 'Passed' : getErrorDetails(keyName, requirements.type, value)
+                details: isNull ? 'OK' : getDetails(isNull)
             });
             break;
         default:

package/dist/constants/details.js

@@ -0,0 +1,6 @@
+export var ErrorKeywords;
+(function (ErrorKeywords) {
+    ErrorKeywords["Missing"] = "missing";
+    ErrorKeywords["Type"] = "type";
+    ErrorKeywords["Rule"] = "rule";
+})(ErrorKeywords || (ErrorKeywords = {}));

package/dist/dev.js

@@ -0,0 +1,63 @@
+import { Schema } from "./Schema.js";
+const schema = new Schema({
+    wrongType: {
+        type: Number,
+        required: true,
+        title: 'Не по типу',
+        customMessage: (input) => {
+            return 'wrong type 1 msg ' + input.keyword;
+        }
+    },
+    missingKey: {
+        type: Date,
+        required: true,
+        title: 'Отсутствующий',
+        customMessage: (input) => {
+            return 'missing msg ' + input.keyword;
+        }
+    },
+    wrongRule1: {
+        type: String,
+        required: true,
+        title: 'Wrong Rule #1',
+        rules: {
+            is: 'xxx'
+        },
+        customMessage: (input) => {
+            return 'wrong rule #1 msg ' + input.keyword;
+        }
+    },
+    wrongRule2: {
+        type: String,
+        required: true,
+        title: 'Wrong Rule #2',
+        rules: {
+            lengthMin: 999
+        },
+        customMessage: (input) => {
+            return 'wrong rule #2 msg ' + input.keyword;
+        }
+    },
+    wrongRule3: {
+        type: String,
+        required: true,
+        title: 'Wrong Rule #3',
+        rules: {
+            lengthMax: 1
+        },
+        customMessage: (input) => {
+            const { keyword, value, key, title, reqs, schema, rules } = input;
+            if (keyword === 'lengthMax') {
+                return `Значение ${value} недопустимо для поля ${title}. Минимальная длина ${rules.lengthMax} символов`;
+            }
+            return 'Проверьте значение, кажется, что-то не в порядке';
+        }
+    },
+});
+const obj = {
+    wrongType: 'String',
+    wrongRule1: 'qwertyuiop',
+    wrongRule2: 'asdfghjkl',
+    wrongRule3: 'zxcvbnmasd'
+};
+console.log('finalResult', schema.validate(obj));

package/dist/validate.js

@@ -3,6 +3,7 @@ import checkType from "./checkType.js";
 import _errors from "./utils/errors.js";
 import _validations from "./utils/validations.js";
 import { defaultSchemaKeys } from "./Schema.js";
+import { ErrorKeywords } from "./constants/details.js";
 export const getResultDefaults = () => {
     return {
         ok: null,
@@ -11,9 +12,7 @@ export const getResultDefaults = () => {
         passed: [],
         errors: [],
         byKeys: {},
-        byTitles: {},
         errorsByKeys: {},
-        errorsByTitles: {}
     };
 };
 const checkIsNested = (obj) => {
@@ -34,9 +33,7 @@ export const mergeResults = (resultsOld, resultsNew) => {
     output.missed = [...resultsOld.missed, ...resultsNew.missed];
     output.passed = [...resultsOld.passed, ...resultsNew.passed];
     output.byKeys = Object.assign(Object.assign({}, resultsOld.byKeys), resultsNew.byKeys);
-    output.byTitles = Object.assign(Object.assign({}, resultsOld.byTitles), resultsNew.byTitles);
     output.errorsByKeys = Object.assign(Object.assign({}, resultsOld.errorsByKeys), resultsNew.errorsByKeys);
-    output.errorsByTitles = Object.assign(Object.assign({}, resultsOld.errorsByTitles), resultsNew.errorsByTitles);
     return output;
 };
 export function handleReqKey(key, data, reqs, deepKey = key) {
@@ -51,13 +48,11 @@ export function handleReqKey(key, data, reqs, deepKey = key) {
         results.missed.push(deepKey);
         results.failed.push(deepKey);
         results.byKeys[deepKey] = false;
-        results.byTitles[keyTitle] = false;
         return results;
     }
     if (hasNested) {
         const nestedReqKeys = Object.keys(reqs);
         results.byKeys[deepKey] = true;
-        results.byTitles[keyTitle] = true;
         let i = 0;
         while (i < nestedReqKeys.length) {
             const reqKeyI = nestedReqKeys[i];
@@ -71,7 +66,12 @@ export function handleReqKey(key, data, reqs, deepKey = key) {
         let errMsg = _errors.getMissingError(deepKey);
         if (reqs.customMessage && typeof reqs.customMessage === 'function') {
             errMsg = reqs.customMessage({
-                value: data[key], key: deepKey, title: keyTitle, reqs: reqs, schema: this.schema
+                keyword: ErrorKeywords.Missing,
+                value: data[key],
+                key: deepKey,
+                title: keyTitle,
+                reqs: reqs,
+                schema: this.schema
             });
         }
         missedCheck.push(false);
@@ -79,9 +79,6 @@ export function handleReqKey(key, data, reqs, deepKey = key) {
         results.failed.push(deepKey);
         results.errors.push(errMsg);
         results.byKeys[deepKey] = false;
-        results.byTitles[keyTitle] = false;
-        results.errorsByKeys[deepKey] = [errMsg];
-        results.errorsByTitles[keyTitle] = [errMsg];
         return results;
     }
     const typeCheck = checkType(key, data[key], reqs, deepKey);
@@ -97,11 +94,8 @@ export function handleReqKey(key, data, reqs, deepKey = key) {
         ruleCheck.details.forEach((el) => {
             if (deepKey in results.errorsByKeys)
                 results.errorsByKeys[deepKey] = [];
-            if (deepKey in results.errorsByTitles)
-                results.errorsByTitles[keyTitle] = [];
             results.errors.push(el);
             results.errorsByKeys[deepKey] = ['1'];
-            results.errorsByTitles[keyTitle] = ['1'];
         });
     }
     if (missedCheck.length)
@@ -115,21 +109,18 @@ export function handleReqKey(key, data, reqs, deepKey = key) {
     results.errorsByKeys[deepKey] = [
         ...results.errors
     ];
-    results.errorsByTitles[keyTitle] = [
-        ...results.errors
-    ];
     results.byKeys[deepKey] = (missedCheck.length + typeChecked.length + rulesChecked.length) === 0;
-    results.byTitles[keyTitle] = (missedCheck.length + typeChecked.length + rulesChecked.length) === 0;
     return results;
 }
-const isCheckNeeded = (key, hasLimits, onlyKeys) => {
+const checkIfValidationIsNeeded = (key, hasLimits, onlyKeys) => {
     return !hasLimits || (key === onlyKeys || Array.isArray(onlyKeys) && (onlyKeys === null || onlyKeys === void 0 ? void 0 : onlyKeys.includes(key)));
 };
 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 isValidationRequired = checkIfValidationIsNeeded(key, areKeysLimited, onlyKeys);
+        if (isValidationRequired) {
             const keyResult = handleReqKey.call(this, key, data, reqs);
             results = mergeResults(results, keyResult);
         }

package/package.json

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

package/src/Schema.ts

@@ -1,46 +0,0 @@
-import validate from "./validate.js"
-
-export type TSchemaItem = {
-    required: boolean,
-    type: any,
-    eachType?: any,
-    rules?: {},
-    title?: string,
-    customMessage?: Function
-}
-
-export type TSchemaInput = {
-    [key: string]: TSchemaItem | TSchemaInput
-}
-
-export const enum ESchemaFields {
-    Required = 'required',
-    Type = 'type',
-    EachType = 'eachType',
-    Rules = 'rules',
-    Title = 'title',
-    CustomMessage = 'customMessage'
-}
-
-export const defaultSchemaKeys = [
-    ESchemaFields.Required,
-    ESchemaFields.Type,
-    ESchemaFields.EachType,
-    ESchemaFields.Rules,
-    ESchemaFields.Title,
-    ESchemaFields.CustomMessage
-]
-
-export type TSchema = TSchemaInput
-
-export class Schema {
-    schema: TSchema
-
-    constructor(inputSchema: TSchema) {
-        this.schema = inputSchema
-    }
-
-    validate(data: any, keys?: string | string[]) {
-        return validate.call(this, this, data, keys)
-    }
-}

package/src/checkRules.ts

@@ -1,181 +0,0 @@
-import { TSchema, TSchemaItem } from "./Schema.js";
-import _validations from "./utils/validations.js"
-
-export type TRule = {[key: string]: any}
-
-type TLengths = string | Array<any>
-
-export const rulesParams = {
-    lengthMin: {
-        allowedTypes: [String]
-    }
-}
-
-const ensureRuleHasCorrectType = (value: any, allowedTypes: any[]) => {
-    const isInAllowedList = allowedTypes.some(TYPE => {
-        const getType = (el: any) => Object.prototype.toString.call(el)
-        return getType(new TYPE()) == getType(value)
-    })
-
-    return isInAllowedList
-}
-
-const rulesFunctions: any = {
-    custom: (key: string, val: any, func: Function, extra: {schema: TSchema, input: {[key: string]: any}}) => {
-        return func(val, extra)
-    },
-    isEmail: (key: string, val: any) => {
-        return {
-            result: _validations.isEmail(val),
-            details: `Значение должно соответствовать формату name@email.ru`
-        }
-    },
-    is: (key: string, val: any, equalTo: any) => {
-        return {
-            result: _validations.is(val, equalTo),
-            details: `Значение должно быть "${equalTo}"`
-        }
-    },
-    isNot: (key: string, val: any, notEqualTo: any) => {
-        return {
-            result: _validations.isNot(val, notEqualTo),
-            details: `Значение "${notEqualTo}" недопустимо`
-        }
-    },
-    min: (key: string, val: number, min: number) => {
-        return {
-            result: _validations.isNumberGte(val, min),
-            details: "Значение не может быть меньше " + min
-        }
-    },
-    max: (key: string, val: number, max: number) => {
-        return {
-            result: _validations.isNumberLte(val, max),
-            details: "Значение не может быть больше " + max
-        }
-    },
-    minMax: (key: string, val: number, minMax: [min: number, max: number]) => {
-        const [min, max] = minMax
-        return {
-            result: _validations.isNumberGte(val, min) && _validations.isNumberLte(val, max),
-            details: `Значение должно быть в пределах ${min}-${max}`
-        }
-    },
-    length: (key: string, val: TLengths, length: number) => {
-        return {
-            result: _validations.lengthIs(val, length),
-            details: "Количество символов должно быть равным " + length
-        }
-    },
-    lengthNot: (key: string, val:  TLengths, lengthNot: number) => {
-        return {
-            result: _validations.lengthNot(val, lengthNot),
-            details: "Количество символов не должно быть равным " + lengthNot
-        }
-    },
-    lengthMinMax: (key: string, val:  TLengths, minMax: [min: number, max: number]) => {
-        const [min, max] = minMax
-
-        return {
-            result: _validations.lengthMin(val, min) && _validations.lengthMax(val, max),
-            details: `Длина должна быть от ${min} до ${max} символов`
-        }
-    },
-    lengthMin: (key: string, val:  TLengths, min: number) => {
-        ensureRuleHasCorrectType(val, rulesParams['lengthMin'].allowedTypes)
-
-        return {
-            result: _validations.lengthMin(val, min),
-            details: `Длина не может быть меньше ${min} символов`
-        }
-    },
-    lengthMax: (key: string, val:  TLengths, max: number) => {
-        return {
-            result: _validations.lengthMax(val, max),
-            details: `Длина не может быть больше ${max} символов`
-        }
-    },
-    regex: (key: string, val: any, regex: RegExp) => {
-        return {
-            result: _validations.regexTested(val, regex),
-            details: "Значение не соответствует допустимому формату"
-        }
-    },
-    enum: (key: string, value: any, allowedList: any[]) => {
-        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
-    }
-};
-
-type TRulesResult = {
-    ok: boolean,
-    details: string[]
-} 
-
-function checkRules (this: any, key: string, value: any, requirements: TSchemaItem, inputObj: any) {
-    const result: TRulesResult = {
-        ok: true,
-        details: []
-    };
-
-    // Значение отсутствует, но НЕ является обязательным
-    if (requirements.required !== true && value === undefined) return result
-
-    // Для этого ключа нет правил
-    if (!requirements || !requirements.rules || !Object.keys(requirements.rules).length) {
-        return result
-    }
-
-    const rules: TRule = requirements.rules
-
-    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})
-        allResults.push(result)
-
-        i++;
-    }
-  
-    // If key has failed rules checks
-    const failedResults = allResults.filter(el => el.result === false)
-    
-    if (failedResults.length) {
-        result.ok = false
-        result.details = failedResults.map(el => el.details)
-    }
-
-    return result;
-  };
-
-  export default checkRules