validno 0.1.9 → 0.1.11

package/dist/Schema.js

@@ -5,7 +5,8 @@ export const defaultSchemaKeys = [
     "eachType",
     "rules",
     "title",
-    "customMessage"
+    "customMessage",
+    "joinErrors"
 ];
 export class Schema {
     constructor(inputSchema) {

package/dist/dev.js

@@ -0,0 +1,41 @@
+import { Schema } from "./Schema.js";
+const schema = new Schema({
+    ops1: {
+        type: Number,
+        required: true,
+        title: 'titl',
+        customMessage: (input) => {
+            return 'Wrong type 1 msg ' + input.keyword;
+        }
+    },
+    ops2: {
+        type: String,
+        required: true,
+        title: 'titl',
+        customMessage: (input) => {
+            return 'Missing msg ' + input.keyword;
+        }
+    },
+    miss: {
+        type: String,
+        required: true,
+        title: 'titl',
+        customMessage: (input) => {
+            return 'Missing msg ' + input.keyword;
+        }
+    }
+});
+const obj = {
+    ops1: 'String',
+    ops2: 123
+};
+const obj2 = {
+    ops1: 222,
+    ops2: 'str',
+    miss: 'here'
+};
+const res = schema.validate(obj);
+const res2 = schema.validate(obj2);
+console.log('finalResult');
+console.log(res2);
+console.log(res2.joinErrors());

package/dist/validate.js

@@ -1,9 +1,13 @@
-import checkRules from "./checkRules.js";
 import checkType from "./checkType.js";
 import _errors from "./utils/errors.js";
+import checkRules from "./checkRules.js";
 import _validations from "./utils/validations.js";
-import { defaultSchemaKeys } from "./Schema.js";
 import { ErrorKeywords } from "./constants/details.js";
+import { defaultSchemaKeys } from "./Schema.js";
+function joinErrors(separator = ';') {
+    var _a;
+    return ((_a = this.errors) === null || _a === void 0 ? void 0 : _a.join(`${separator} `)) || '';
+}
 export const getResultDefaults = () => {
     return {
         ok: null,
@@ -78,6 +82,9 @@ export function handleReqKey(key, data, reqs, deepKey = key) {
         results.missed.push(deepKey);
         results.failed.push(deepKey);
         results.errors.push(errMsg);
+        if (deepKey in results.errorsByKeys === false)
+            results.errorsByKeys[deepKey] = [];
+        results.errorsByKeys[deepKey].push(errMsg);
         results.byKeys[deepKey] = false;
         return results;
     }
@@ -129,7 +136,23 @@ function validate(schema, data, onlyKeys) {
         results.ok = false;
     else
         results.ok = true;
-    return results;
+    return new ValidnoResult(results);
 }
 ;
+class ValidnoResult {
+    constructor(results) {
+        this.ok = results.ok;
+        this.missed = results.missed;
+        this.failed = results.failed;
+        this.passed = results.passed;
+        this.errors = results.errors;
+        this.byKeys = results.byKeys;
+        this.errorsByKeys = results.errorsByKeys;
+        this.byKeys = results.byKeys;
+    }
+    joinErrors(separator = '; ') {
+        var _a;
+        return ((_a = this.errors) === null || _a === void 0 ? void 0 : _a.join(`${separator} `)) || '';
+    }
+}
 export default validate;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "validno",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "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,196 +0,0 @@
-import { ErrorKeywords } from "./constants/details.js";
-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 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++;
-    }
-  
-    // 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

package/src/checkType.ts

@@ -1,213 +0,0 @@
-import { ErrorKeywords } from "./constants/details.js";
-import { TSchemaInput, TSchemaItem } from "./Schema.js";
-import _validations from "./utils/validations.js";
-
-const getErrorDetails = (key: string, expectedType: any, receivedValue: any) => {
-    let receivedType = ''
-
-    if (typeof receivedValue === 'string') receivedType = 'String'
-    else if (typeof receivedValue === 'number') receivedType = 'Number'
-    else if (typeof receivedValue === 'boolean') receivedType = 'Noolean'
-    else if (receivedValue === null) receivedType = 'null'
-    else if (Array.isArray(receivedValue)) receivedType = 'Array'
-    else if (_validations.isDate(receivedValue)) receivedType = 'Date'
-    else if (_validations.isObject(receivedValue)) receivedType = 'Object'
-    else if (receivedValue === undefined) receivedType = 'undefined'
-    
-    return `Проверьте тип "${key}": ожидался ${expectedType?.name || expectedType}, получен ${receivedType || 'unknown'}`;
-};
-
-const checkTypeMultiple = (key: string, value: any, requirements: TSchemaItem | TSchemaInput, keyName = key) => {
-  const constructorNames = requirements.type.map((el:any) => String(el?.name || el))
-  
-  const result = {
-    key: keyName,
-    passed: false,
-    details: getErrorDetails(keyName, constructorNames.join('/'), value)
-  };
-
-  let i = 0;
-  while (i < requirements.type.length) {
-    const requirementsRe = { ...requirements, type: requirements.type[i]}
-    const check = checkType(key, value, requirementsRe)
-
-    if (check[0].passed === true) {
-      result.passed = true
-      result.details = 'OK'
-      return result
-    }
-
-    i++
-  }
-
-  return result
-}
-
-type TCheckTypeResult = {key: string, passed: boolean, details: string}
-
-const checkType = (key: string, value: any, requirements: TSchemaItem | TSchemaInput, keyName = key): TCheckTypeResult[] => {
-    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: `Значение "${keyName}" отсутствует`}]
-    }
-
-    let result: TCheckTypeResult[] = []
-
-    if (Array.isArray(requirements.type)) {
-      return [checkTypeMultiple(key, value, requirements)]
-    }
-
-    if (value === undefined && requirements.required !== true) {
-      result.push({
-        key: keyName,
-        passed: true,
-        details: 'OK'
-      })
-      return result
-    }
-
-    
-    const customErrDetails = hasCustomMessage ?
-      //@ts-ignore
-      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: boolean) => isOK ? 'OK' : customErrDetails || baseErrDetails
-
-    switch (requirements.type) {
-      case 'any':
-        result.push({
-          key: keyName,
-          passed: true,
-          details: 'OK'
-        })
-        break;
-      case Number:
-        const isNumber = isNotNull && value.constructor === Number 
-
-        result.push({
-          key: keyName,
-          passed: isNumber,
-          details: getDetails(isNumber)
-        })
-
-        break;
-      case String:
-        const isString = isNotNull && value.constructor === String
-
-        result.push({
-          key: keyName,
-          passed: isString,
-          details: getDetails(isString)
-        })
-        break;
-      case Date:
-        const isDate = isNotNull && value.constructor === Date
-        const isValid = isDate && !isNaN(value.getTime())
-        const errorMsg = isValid ? getDetails(isDate) : 'Дата невалидна'
-
-        result.push({
-          key: keyName,
-          passed: isDate && isValid,
-          details: isDate && isValid ? 'OK' : errorMsg
-        })
-        break;
-      case Boolean:
-        const isBoolean = isNotNull && value.constructor === Boolean
-
-        result.push({
-          key: keyName,
-          passed: isBoolean,
-          details: isBoolean ? 'OK' : getDetails(isBoolean)
-        })
-        break;
-      case Array:
-        const isArray = isNotNull && value.constructor === Array
-
-        if (!isArray) {
-          result.push({
-              key: keyName,
-              passed: false,
-              details: getDetails(isArray)
-          });
-          
-          break;
-      }
-
-        let isEachChecked = { passed: true, details: ""}
-        
-        if ('eachType' in requirements) {
-          isEachChecked.passed = value.every((el: any) => {
-            const checkResult = checkType('each of ' + key, el, {type: requirements.eachType, required: true})
-            
-            if (!checkResult[0].passed) {
-              isEachChecked.details = checkResult[0].details
-              isEachChecked.passed = false
-            }
-
-            return true
-          })
-        }
-
-        const isOk = isArray && isEachChecked.passed
-
-        result.push({
-          key: keyName,
-          passed: isOk,
-          details: isOk ? 'OK' : !isEachChecked.passed ? isEachChecked.details : getDetails(isOk)
-        })
-
-        break;
-      case Object:
-        const isObject = _validations.isObject(value) && value.constructor === Object
-
-        result.push({
-          key: keyName,
-          passed: isObject,
-          details: isObject ? 'OK' : getDetails(isObject)
-        })
-
-        break;
-      case RegExp:
-        const isRegex = _validations.isRegex(value)
-        result.push({
-          key: keyName,
-          passed: isRegex,
-          details: isRegex ? 'OK' : getDetails(isRegex)
-        })
-
-        break;
-      case null:
-        const isNull = value === null
-
-        result.push({
-          key: keyName,
-          passed: isNull,
-          details: isNull ? 'OK' : getDetails(isNull)
-        })
-
-        break;
-      default:
-        result.push({
-          key: keyName,
-          passed: false,
-          details: `Тип '${keyName}' не определен`
-        })
-    }
-  
-    return result;
-};
-
-  export default checkType

package/src/constants/details.ts

@@ -1,5 +0,0 @@
-export enum ErrorKeywords {
-    Missing = 'missing',
-    Type = 'type',
-    Rule = 'rule'
-} 

package/src/index.ts

@@ -1,3 +0,0 @@
-import { Schema } from "./Schema.js";
-
-export default Schema