validno 0.1.0 → 0.1.2

package/dist/Schema.js

@@ -1,4 +1,5 @@
 import validate from "./validate.js";
+import validateKey from "./validateKey.js";
 export const defaultSchemaKeys = [
     "required",
     "type",
@@ -12,4 +13,7 @@ export class Schema {
     validate(data) {
         return validate.call(this, this, data);
     }
+    validateKey(key, data) {
+        return validateKey.call(this, this, data, key);
+    }
 }

package/dist/app.js

@@ -0,0 +1,22 @@
+import Schema from "./index.js";
+const schema = new Schema({
+    val: {
+        type: String,
+        required: true,
+    },
+    val2: {
+        type: Number,
+        required: true,
+        rules: {
+            min: 3
+        }
+    }
+});
+const testObj = {
+    val: 'string',
+    val2: 1
+};
+const res = schema.validate(testObj);
+const res2 = schema.validateKey('val2', testObj);
+console.log(res);
+console.log(res2);

package/dist/checkRules.js

@@ -1,4 +1,16 @@
 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) => {
         return func(val);
@@ -60,6 +72,7 @@ const rulesFunctions = {
         };
     },
     lengthMin: (key, val, min) => {
+        ensureRuleHasCorrectType(val, rulesParams['lengthMin'].allowedTypes);
         return {
             result: _validations.lengthMin(val, min),
             details: `Длина не может быть меньше ${min} символов`

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,8 +1,9 @@
 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 = () => {
+export const getResultDefaults = () => {
     return {
         ok: null,
         missed: [],
@@ -24,7 +25,7 @@ const checkIsNested = (obj) => {
         return true;
     }
 };
-const mergeResults = (resultsOld, resultsNew) => {
+export const mergeResults = (resultsOld, resultsNew) => {
     const output = getResultDefaults();
     output.failed = [...resultsOld.failed, ...resultsNew.failed];
     output.errors = [...resultsOld.errors, ...resultsNew.errors];
@@ -34,7 +35,7 @@ const mergeResults = (resultsOld, resultsNew) => {
     output.errorsByKeys = Object.assign(Object.assign({}, resultsOld.errorsByKeys), resultsNew.errorsByKeys);
     return output;
 };
-const handleReqKey = (key, data, reqs, deepKey = key) => {
+export const handleReqKey = (key, data, reqs, deepKey = key) => {
     let results = getResultDefaults();
     const hasNested = checkIsNested(reqs);
     const missedCheck = [];
@@ -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/dist/validateKey.js

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

package/package.json

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

package/src/Schema.ts

@@ -1,4 +1,5 @@
 import validate from "./validate.js"
+import validateKey from "./validateKey.js"
 
 export type TSchemaItem = {
     required: boolean,
@@ -37,4 +38,8 @@ export class Schema {
     validate(data: any) {
         return validate.call(this, this, data)
     }
+
+    validateKey(key: string, data: any) {
+        return validateKey.call(this, this, data, key)
+    }
 }

package/src/app.ts

@@ -1,199 +1,59 @@
 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 testSchema = new Schema({
+//   field: {
+//     type: Number,
+//     required: true,
+//     rules: {
+//       lengthMin: 99
+//     }
+//   },
+//   field2: {
+//     type: "xxx",
+//     required: true,
+//     rules: {
+//       lengthMin: 10
+//     }
+//   }
+// });
 
-const okObjResult = testSchema1.validate(okObj1)
-console.log(okObjResult)
+// class StringOwn {
+//   constructor(v: any) {
+//     v = v
+//   }
+// }
 
-// 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 strOwn = new StringOwn('xxxxuis')
 
-// const rulesObj = {
-//     xMultiple: 'str',
-//     xNumb: 3,
-//     xStr: 'lol',
-//     xArrEach: [3,2,1,null],
-//     str: '233'
+// const body = {
+//   "field": 33,
+//   "field2": "Ssdasjk"
 // }
 
-// const rulesObjResult = Validator.validate(rulesSchema, rulesObj)
-// console.log(rulesObjResult)
+// const validationResult = testSchema.validate(body);
 
-const deepObjScheme = new Schema({
-  nameStr: {
-    required: true,
+
+const schema = new Schema({
+  val: {
     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
-        }
-      }
-    },
+    required: true,
   },
-  deep1: {
-    deep2: {
-      deep3: {
-        deep4: {
-          required: true,
-          type: String,
-          rules: {
-            lengthMinMax: [10,15]
-          }
-        }
-      }
+  val2: {
+    type: Number,
+    required: true,
+    rules: {
+      min: 3
     }
   }
 })
 
-const deepTestObj = {
-  nameStr: "Alek",
-  address: {
-    city: 'Moscow',
-    street: "41, Komsomolskiy",
-    coords: {
-      x: 1,
-      y: 2
-    }
-  },
-  deep1: {
-    deep2: {
-      deep3: {
-        deep4: 'ssss'
-      }
-    }
-  }
+const testObj = {
+  val: 'string',
+  val2: 1
 }
 
-console.log('deepObj', deepObjScheme.validate(deepTestObj).ok)
+const res = schema.validate(testObj)
+const res2 = schema.validateKey('val2', testObj)
+
+console.log(res)
+console.log(res2)

package/src/checkRules.ts

@@ -3,6 +3,23 @@ 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) => {
         return func(val)
@@ -25,38 +42,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 +81,15 @@ const rulesFunctions: any = {
             details: `Длина должна быть от ${min} до ${max} символов`
         }
     },
-    lengthMin: (key: string, val: any, min: number) => {
+    lengthMin: (key: string, val:  TLengths, min: number) => {
+        ensureRuleHasCorrectType(val, rulesParams['lengthMin'].allowedTypes)
+
         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} символов`
@@ -135,6 +154,7 @@ const checkRules = (key: string, value: any, requirements: TSchemaItem) => {
   
     // 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)

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,9 +1,10 @@
 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 = {
+export type TResult = {
     ok: null | boolean,
     missed: string[],
     failed: string[],
@@ -13,7 +14,7 @@ type TResult = {
     errorsByKeys: {[key: string]: string[]}
 };
 
-const getResultDefaults = (): TResult => {
+export const getResultDefaults = (): TResult => {
   return {
     ok: null,
     missed: [],
@@ -37,7 +38,7 @@ const checkIsNested = (obj: {[key: string]: any}) => {
   }
 }
 
-const mergeResults = (resultsOld: TResult, resultsNew: TResult) => {
+export const mergeResults = (resultsOld: TResult, resultsNew: TResult) => {
   const output = getResultDefaults()
 
   output.failed = [...resultsOld.failed, ...resultsNew.failed]
@@ -50,7 +51,7 @@ const mergeResults = (resultsOld: TResult, resultsNew: TResult) => {
   return output
 }
 
-const handleReqKey = (key: string, data: any, reqs: TSchemaInput, deepKey = key) => {
+export const handleReqKey = (key: string, data: any, reqs: TSchemaInput, deepKey = key) => {
   let results = getResultDefaults()
   const hasNested = checkIsNested(reqs)
   
@@ -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/src/validateKey.ts

@@ -0,0 +1,21 @@
+import { Schema } from "./Schema.js";
+import { getResultDefaults, handleReqKey, mergeResults, TResult } from "./validate.js";
+
+const validateKey = (schema: Schema, data: any, key: string): TResult => {
+    if (key in schema.schema === false) {
+      throw new Error(`Ключ ${key} отсутствует в схеме`)
+    }
+
+    let results: TResult = getResultDefaults()
+    //@ts-ignore
+    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;

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({