validno 0.1.0 → 0.1.1

package/dist/sss.js

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

package/dist/utils/errors.js

@@ -0,0 +1,3 @@
+const _errors = {};
+_errors.getMissingError = (key) => `Ключ '${key}' отсутствует`;
+export default _errors;

package/dist/validate.js

@@ -1,6 +1,7 @@
 import checkRules from "./checkRules.js";
 import checkType from "./checkType.js";
 import { defaultSchemaKeys } from "./Schema.js";
+import _errors from "./utils/errors.js";
 import _validations from "./utils/validations.js";
 const getResultDefaults = () => {
     return {
@@ -60,8 +61,13 @@ const handleReqKey = (key, data, reqs, deepKey = key) => {
         return results;
     }
     if (reqs.required === true && key in data === false || data === undefined) {
+        const errMsg = _errors.getMissingError(deepKey);
         missedCheck.push(false);
-        results.errors.push(`Missing key '${deepKey}'`);
+        results.missed.push(deepKey);
+        results.failed.push(deepKey);
+        results.errors.push(errMsg);
+        results.byKeys[deepKey] = false;
+        results.errorsByKeys[deepKey] = [errMsg];
         return results;
     }
     const typeCheck = checkType(key, data[key], reqs, deepKey);

package/package.json

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

package/src/checkRules.ts

@@ -3,6 +3,8 @@ import _validations from "./utils/validations.js"
 
 export type TRule = {[key: string]: any}
 
+type TLengths = string | Array<any>
+
 const rulesFunctions: any = {
     custom: (key: string, val: any, func: Function) => {
         return func(val)
@@ -25,38 +27,38 @@ const rulesFunctions: any = {
             details: `Значение не должно быть "${notEqualTo}"`
         }
     },
-    min: (key: string, val: any, min: number) => {
+    min: (key: string, val: number, min: number) => {
         return {
             result: _validations.isNumberGte(val, min),
             details: "Значение не может быть меньше " + min
         }
     },
-    max: (key: string, val: any, max: number) => {
+    max: (key: string, val: number, max: number) => {
         return {
             result: _validations.isNumberLte(val, max),
             details: "Значение не может быть больше " + max
         }
     },
-    minMax: (key: string, val: any, minMax: [min: number, max: number]) => {
+    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: any, length: number) => {
+    length: (key: string, val: TLengths, length: number) => {
         return {
             result: _validations.lengthIs(val, length),
             details: "Количество символов должно быть равным " + length
         }
     },
-    lengthNot: (key: string, val: any, lengthNot: number) => {
+    lengthNot: (key: string, val:  TLengths, lengthNot: number) => {
         return {
             result: _validations.lengthNot(val, lengthNot),
             details: "Количество символов не должно быть равным " + lengthNot
         }
     },
-    lengthMinMax: (key: string, val: any, minMax: [min: number, max: number]) => {
+    lengthMinMax: (key: string, val:  TLengths, minMax: [min: number, max: number]) => {
         const [min, max] = minMax
 
         return {
@@ -64,13 +66,13 @@ const rulesFunctions: any = {
             details: `Длина должна быть от ${min} до ${max} символов`
         }
     },
-    lengthMin: (key: string, val: any, min: number) => {
+    lengthMin: (key: string, val:  TLengths, min: number) => {
         return {
             result: _validations.lengthMin(val, min),
             details: `Длина не может быть меньше ${min} символов`
         }
     },
-    lengthMax: (key: string, val: any, max: number) => {
+    lengthMax: (key: string, val:  TLengths, max: number) => {
         return {
             result: _validations.lengthMax(val, max),
             details: `Длина не может быть больше ${max} символов`

package/src/utils/errors.ts

@@ -0,0 +1,6 @@
+const _errors: {[key: string]: Function} = {}
+
+_errors.getMissingError = (key: string) => `Ключ '${key}' отсутствует`
+
+export default _errors
+

package/src/validate.ts

@@ -1,6 +1,7 @@
 import checkRules from "./checkRules.js";
 import checkType from "./checkType.js";
 import { defaultSchemaKeys, Schema, TSchemaInput } from "./Schema.js";
+import _errors from "./utils/errors.js";
 import _validations from "./utils/validations.js";
 
 type TResult = {
@@ -98,8 +99,14 @@ const handleReqKey = (key: string, data: any, reqs: TSchemaInput, deepKey = key)
   // Check missing keys
   // @ts-ignore
   if (reqs.required === true && key in data === false || data === undefined) {
+    const errMsg = _errors.getMissingError(deepKey)
+
     missedCheck.push(false)
-    results.errors.push(`Missing key '${deepKey}'`)
+    results.missed.push(deepKey)
+    results.failed.push(deepKey)
+    results.errors.push(errMsg)
+    results.byKeys[deepKey] = false
+    results.errorsByKeys[deepKey] = [errMsg]
     return results
   }
 

package/tests/missing.test.js

@@ -0,0 +1,131 @@
+import {describe, expect, test} from '@jest/globals';
+import { Schema } from '../dist/Schema.js';
+import _errors from '../dist/utils/errors.js';
+
+describe('Тестирование обработки пропущенных свойста', () => {
+    test('Отсутствующий ключ правильно отображается в результате', () => {
+        const missedKey = 'testKey'
+        const missedKey2 = 'testKey2'
+
+        const okKey = 'okKey'
+
+        const scheme = new Schema({
+            [missedKey]: {
+                required: true,
+                type: String
+            },
+            [missedKey2]: {
+                required: true,
+                type: String
+            },
+            [okKey]: {
+                required: true,
+                type: String
+            }
+        })
+
+        const obj = {
+            [okKey]: 'string'
+        }
+
+        const result = scheme.validate(obj)
+
+        expect(result).toEqual({
+            ok: false,
+            failed: [missedKey, missedKey2],
+            missed: [missedKey, missedKey2],
+            errors: [
+                _errors.getMissingError(missedKey),
+                _errors.getMissingError(missedKey2)
+            ],
+            passed: [okKey],
+            byKeys: {
+                [missedKey]: false,
+                [missedKey2]: false,
+                [okKey]: true
+            },
+            errorsByKeys: {
+                [okKey]: [],
+                [missedKey]: [_errors.getMissingError(missedKey)],
+                [missedKey2]: [_errors.getMissingError(missedKey2)]
+            }
+        })
+    })
+
+    test('Присутствующий ключ правильно отображается в результате', () => {
+        const key = 'testKey'
+        const key2 = 'testKey2'
+
+        const scheme = new Schema({
+            [key]: {
+                required: true,
+                type: String
+            },
+            [key2]: {
+                required: true,
+                type: String
+            }
+        })
+
+        const obj = {
+            [key]: 'string',
+            [key2]: 'string'
+        }
+
+        const result = scheme.validate(obj)
+        
+        expect(result).toEqual({
+            ok: true,
+            failed: [],
+            missed: [],
+            errors: [],
+            passed: [key, key2],
+            byKeys: {
+                [key]: true,
+                [key2]: true
+            },
+            errorsByKeys: {
+                [key]: [],
+                [key2]: []
+            }
+        })
+    })
+
+    test('Отсутствующий необязательный ключ правильно отображается в результах', () => {
+        const key = 'testKey'
+        const key2 = 'testKey2'
+
+        const scheme = new Schema({
+            [key]: {
+                required: false,
+                type: String
+            },
+            [key2]: {
+                required: true,
+                type: String
+            }
+        })
+
+        const obj = {
+            [key2]: 'string'
+        }
+
+        const result = scheme.validate(obj)
+        
+        expect(result).toEqual({
+            ok: true,
+            failed: [],
+            missed: [],
+            errors: [],
+            passed: [key, key2],
+            byKeys: {
+                [key]: true,
+                [key2]: true
+            },
+            errorsByKeys: {
+                [key]: [],
+                [key2]: []
+            }
+        })
+    })
+})

package/tests/types.test.js

@@ -1,7 +1,7 @@
 import {describe, expect, test} from '@jest/globals';
 import { Schema } from '../dist/Schema.js';
 
-describe("Проверка каждого типа по отдельности", () => {
+describe('Проверка каждого типа по отдельности', () => {
     test('Тест String', () => {
         const key = 'testKey'
         const scheme = new Schema({

package/src/app.ts

@@ -1,199 +0,0 @@
-import Schema from "./index.js";
-
-const testSchema1 = new Schema({
-  isMissing: {
-    required: false,
-    type: 'any',
-  },
-  category: {
-    required: true,
-    type: String,
-    rules: {
-      lengthMinMax: [5,10]
-    }
-  },
-  costPrice: {
-    required: true,
-    type: Number,
-  },
-  dateFrom: {
-    required: true,
-    type: Date,
-    
-  },
-  isActive: {
-    required: true,
-    type: Boolean,
-  },
-  list: {
-    required: true,
-    type: Array,
-  },
-  listTyped: {
-    required: true,
-    type: Array,
-    eachType: Number
-  },
-  xNull: {
-    required: true,
-    type: [null, Number]
-  },
-  reg: {
-    required: true,
-    type: RegExp
-  },
-  oneOfStr: {
-    required: false,
-    type: String,
-    rules: {
-      enum: ['done', 'new', 'cancel']
-    }
-  },
-  email: {
-    required: true,
-    type: String,
-    rules: {
-      isEmail: true,
-      lengthMin: 55
-    },
-  }
-}
-)
-
-const okObj1 = {
-    unknown: 1,
-    category: 'xx',
-    isMissing: '...',
-    isActive: true,
-    costPrice: 100,
-    dateFrom: new Date(),
-    list: [],
-    listTyped: [1, 2, 3, 0.00001],
-    xNull: null,
-    reg: new RegExp('.*'),
-    oneOfStr: 'done',
-    email: 'xxx@gmail.com'
-}
-
-const okObjResult = testSchema1.validate(okObj1)
-console.log(okObjResult)
-
-// const rulesSchema = new Schema({
-//     xMultiple: {
-//       required: true,
-//       type: [String, null]
-//     },
-//     xNumb: {
-//         required: true,
-//         type: 'any',
-//         rules: {
-//             custom: (v: any) => v === 3,
-//             is: 3,
-//             isNot: 2,
-//             min: 3,
-//             max: 3,
-//             regex: /3|4/
-//         }
-//     },
-//     xStr: {
-//         required: true,
-//         type: String,
-//         rules: {
-//             custom: (v: any) => typeof v === 'string',
-//             is: 'lol',
-//             isNot: 'rofl',
-//             length: 3,
-//             lengthNot: 999,
-//             lengthMin: 3,
-//             lengthMax: 3,
-//             regex: /\D{3}/
-//         }
-//     },
-//     xArrEach: {
-//       required: true,
-//       type: Array,
-//       eachType: [Number, String]
-//     },
-//     str: {
-//       required: false,
-//       type: String
-//     }
-// })
-
-// const rulesObj = {
-//     xMultiple: 'str',
-//     xNumb: 3,
-//     xStr: 'lol',
-//     xArrEach: [3,2,1,null],
-//     str: '233'
-// }
-
-// const rulesObjResult = Validator.validate(rulesSchema, rulesObj)
-// console.log(rulesObjResult)
-
-const deepObjScheme = new Schema({
-  nameStr: {
-    required: true,
-    type: String,
-    rules: {
-      lengthMin: 5
-    }
-  },
-  address: {
-    city: {
-      required: true,
-      type: String,
-    },
-    street: {
-      required: true,
-      type: String
-    },
-    coords: {
-      x: {
-        required: true,
-        type: Number,
-      },
-      y: {
-        required: true,
-        type: Number,
-        rules: {
-          min: 1
-        }
-      }
-    },
-  },
-  deep1: {
-    deep2: {
-      deep3: {
-        deep4: {
-          required: true,
-          type: String,
-          rules: {
-            lengthMinMax: [10,15]
-          }
-        }
-      }
-    }
-  }
-})
-
-const deepTestObj = {
-  nameStr: "Alek",
-  address: {
-    city: 'Moscow',
-    street: "41, Komsomolskiy",
-    coords: {
-      x: 1,
-      y: 2
-    }
-  },
-  deep1: {
-    deep2: {
-      deep3: {
-        deep4: 'ssss'
-      }
-    }
-  }
-}
-
-console.log('deepObj', deepObjScheme.validate(deepTestObj).ok)