validno 0.1.3 → 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 {
@@ -30,7 +30,7 @@ const rulesFunctions = {
     isNot: (key, val, notEqualTo) => {
         return {
             result: _validations.isNot(val, notEqualTo),
-            details: `Значение не должно быть "${notEqualTo}"`
+            details: `Значение "${notEqualTo}" недопустимо`
         };
     },
     min: (key, val, min) => {
@@ -91,37 +91,48 @@ 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: []
     };
     if (requirements.required !== true && value === undefined)
         return result;
-    if ('rules' in requirements === false)
-        return result;
     if (!requirements || !requirements.rules || !Object.keys(requirements.rules).length) {
         return result;
     }
     const rules = requirements.rules;
     const allResults = [];
-    const allRules = Object.keys(rules);
+    const allRulesKeys = Object.keys(rules);
     let i = 0;
-    while (i < allRules.length) {
-        const ruleName = allRules[i];
+    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);
+        const result = func(key, value, args, { schema: this.schema, input: inputObj });
         allResults.push(result);
         i++;
     }
@@ -131,5 +142,6 @@ const checkRules = (key, value, requirements) => {
         result.details = failedResults.map(el => el.details);
     }
     return result;
-};
+}
+;
 export default checkRules;

package/dist/checkType.js

@@ -40,6 +40,7 @@ const checkTypeMultiple = (key, value, requirements, keyName = key) => {
     return result;
 };
 const checkType = (key, value, requirements, keyName = key) => {
+    const isNotNull = value !== null;
     if (value === undefined && requirements.required) {
         return [{ key: keyName, passed: false, details: `Key ${keyName} is missing` }];
     }
@@ -64,7 +65,7 @@ const checkType = (key, value, requirements, keyName = key) => {
             });
             break;
         case Number:
-            const isNumber = _validations.isNumber(value);
+            const isNumber = isNotNull && value.constructor === Number;
             result.push({
                 key: keyName,
                 passed: isNumber,
@@ -72,7 +73,7 @@ const checkType = (key, value, requirements, keyName = key) => {
             });
             break;
         case String:
-            const isString = _validations.isString(value);
+            const isString = isNotNull && value.constructor === String;
             result.push({
                 key: keyName,
                 passed: isString,
@@ -80,7 +81,7 @@ const checkType = (key, value, requirements, keyName = key) => {
             });
             break;
         case Date:
-            const isDate = _validations.isDate(value);
+            const isDate = isNotNull && value.constructor === Date;
             result.push({
                 key: keyName,
                 passed: isDate,
@@ -88,7 +89,7 @@ const checkType = (key, value, requirements, keyName = key) => {
             });
             break;
         case Boolean:
-            const isBoolean = _validations.isBoolean(value);
+            const isBoolean = isNotNull && value.constructor === Boolean;
             result.push({
                 key: keyName,
                 passed: isBoolean,
@@ -96,7 +97,15 @@ const checkType = (key, value, requirements, keyName = key) => {
             });
             break;
         case Array:
-            const isArray = _validations.isArray(value);
+            const isArray = isNotNull && value.constructor === Array;
+            if (!isArray) {
+                result.push({
+                    key: keyName,
+                    passed: false,
+                    details: getErrorDetails(keyName, requirements.type, value)
+                });
+                break;
+            }
             let isEachChecked = { passed: true, details: "" };
             if ('eachType' in requirements) {
                 isEachChecked.passed = value.every((el) => {
@@ -116,7 +125,7 @@ const checkType = (key, value, requirements, keyName = key) => {
             });
             break;
         case Object:
-            const isObject = _validations.isObject(value);
+            const isObject = _validations.isObject(value) && value.constructor === Object;
             result.push({
                 key: keyName,
                 passed: isObject,
@@ -132,7 +141,7 @@ const checkType = (key, value, requirements, keyName = key) => {
             });
             break;
         case null:
-            const isNull = _validations.isNull(value);
+            const isNull = value === null;
             result.push({
                 key: keyName,
                 passed: isNull,
@@ -143,7 +152,7 @@ const checkType = (key, value, requirements, keyName = key) => {
             result.push({
                 key: keyName,
                 passed: false,
-                details: `No type specified for key: '${keyName}'`
+                details: `Тип '${keyName}' не определен`
             });
     }
     return result;

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,12 +1,12 @@
 {
   "name": "validno",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
     "tsc": "tsc -b src/",
     "tsc-watch": "tsc --b --watch src/",
-    "dev": "nodemon dist/app.js",
+    "dev": "nodemon dist/dev.js",
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"
   },
   "author": "lesha2r",
@@ -22,5 +22,16 @@
     "@types/node": "^18.14.2",
     "eslint": "^8.14.0",
     "jest": "^29.7.0"
-  }
+  },
+  "directories": {
+    "test": "tests"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lesha2r/validno.git"
+  },
+  "bugs": {
+    "url": "https://github.com/lesha2r/validno/issues"
+  },
+  "homepage": "https://github.com/lesha2r/validno#readme"
 }

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 {
@@ -39,7 +39,7 @@ const rulesFunctions: any = {
     isNot: (key: string, val: any, notEqualTo: any) => {
         return {
             result: _validations.isNot(val, notEqualTo),
-            details: `Значение не должно быть "${notEqualTo}"`
+            details: `Значение "${notEqualTo}" недопустимо`
         }
     },
     min: (key: string, val: number, min: number) => {
@@ -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,17 +129,16 @@ 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: []
     };
 
-    // If value is not provided AND not required by schema
+    // Значение отсутствует, но НЕ является обязательным
     if (requirements.required !== true && value === undefined) return result
 
-    // No rules specified for the key
-    if ('rules' in requirements === false) return result
+    // Для этого ключа нет правил
     if (!requirements || !requirements.rules || !Object.keys(requirements.rules).length) {
         return result
     }
@@ -132,12 +146,13 @@ const checkRules = (key: string, value: any, requirements: TSchemaItem) => {
     const rules: TRule = requirements.rules
 
     const allResults = []
-    const allRules = Object.keys(rules)
+    const allRulesKeys = Object.keys(rules)
     
     let i = 0;
-    while (i < allRules.length) {
-        const ruleName = allRules[i]
+    while (i < allRulesKeys.length) {
+        const ruleName = allRulesKeys[i]
 
+        // Если правило, указанное для ключа, отсутствует в списке доступных
         if (ruleName in rulesFunctions === false) {
             i++
             continue
@@ -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/checkType.ts

@@ -18,6 +18,7 @@ const getErrorDetails = (key: string, expectedType: any, receivedValue: any) =>
 
 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,
@@ -44,6 +45,8 @@ const checkTypeMultiple = (key: string, value: any, requirements: TSchemaItem |
 type TCheckTypeResult = {key: string, passed: boolean, details: string}
 
 const checkType = (key: string, value: any, requirements: TSchemaItem | TSchemaInput, keyName = key): TCheckTypeResult[] => {
+    const isNotNull = value !== null
+    
     if (value === undefined && requirements.required) {
       return [{key: keyName, passed: false, details: `Key ${keyName} is missing`}]
     }
@@ -72,7 +75,8 @@ const checkType = (key: string, value: any, requirements: TSchemaItem | TSchemaI
         })
         break;
       case Number:
-        const isNumber = _validations.isNumber(value)
+        const isNumber = isNotNull && value.constructor === Number 
+
         result.push({
           key: keyName,
           passed: isNumber,
@@ -81,7 +85,8 @@ const checkType = (key: string, value: any, requirements: TSchemaItem | TSchemaI
 
         break;
       case String:
-        const isString = _validations.isString(value);
+        const isString = isNotNull && value.constructor === String
+
         result.push({
           key: keyName,
           passed: isString,
@@ -89,7 +94,8 @@ const checkType = (key: string, value: any, requirements: TSchemaItem | TSchemaI
         })
         break;
       case Date:
-        const isDate = _validations.isDate(value)
+        const isDate = isNotNull && value.constructor === Date
+
         result.push({
           key: keyName,
           passed: isDate,
@@ -97,7 +103,8 @@ const checkType = (key: string, value: any, requirements: TSchemaItem | TSchemaI
         })
         break;
       case Boolean:
-        const isBoolean = _validations.isBoolean(value);
+        const isBoolean = isNotNull && value.constructor === Boolean
+
         result.push({
           key: keyName,
           passed: isBoolean,
@@ -105,7 +112,17 @@ const checkType = (key: string, value: any, requirements: TSchemaItem | TSchemaI
         })
         break;
       case Array:
-        const isArray = _validations.isArray(value);
+        const isArray = isNotNull && value.constructor === Array
+
+        if (!isArray) {
+          result.push({
+              key: keyName,
+              passed: false,
+              details: getErrorDetails(keyName, requirements.type, value)
+          });
+          
+          break;
+      }
 
         let isEachChecked = { passed: true, details: ""}
         
@@ -132,7 +149,7 @@ const checkType = (key: string, value: any, requirements: TSchemaItem | TSchemaI
 
         break;
       case Object:
-        const isObject = _validations.isObject(value)
+        const isObject = _validations.isObject(value) && value.constructor === Object
         result.push({
           key: keyName,
           passed: isObject,
@@ -150,7 +167,8 @@ const checkType = (key: string, value: any, requirements: TSchemaItem | TSchemaI
 
         break;
       case null:
-        const isNull = _validations.isNull(value);
+        const isNull = value === null
+
         result.push({
           key: keyName,
           passed: isNull,
@@ -162,7 +180,7 @@ const checkType = (key: string, value: any, requirements: TSchemaItem | TSchemaI
         result.push({
           key: keyName,
           passed: false,
-          details: `No type specified for key: '${keyName}'`
+          details: `Тип '${keyName}' не определен`
         })
     }
   

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/tests/types.test.js

@@ -280,6 +280,10 @@ describe("Проверка всех типов сразу", () => {
             },
             date: {
                 type: Date
+            },
+            test: {
+                type: Object,
+                required: true
             }
         })
 
@@ -290,7 +294,8 @@ describe("Проверка всех типов сразу", () => {
             arr: null,
             null: {},
             bool: new Date(),
-            date: true
+            date: true,
+            test: undefined
         }
 
         const res = schema.validate(obj)

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,29 +0,0 @@
-import Schema from "./index.js";
-const schema = new Schema({
-    val: {
-        type: String,
-        required: true,
-    },
-    val2: {
-        type: Number,
-        required: true,
-        rules: {
-            min: 3
-        }
-    },
-    val3: {
-        type: String,
-        required: true,
-    },
-});
-const testObj = {
-    val: 'string',
-    val2: 1,
-    val3: 'ss'
-};
-const resAll = schema.validate(testObj);
-const res = schema.validate(testObj, ['val', 'val2']);
-const res2 = schema.validate(testObj, 'val2');
-console.log(resAll);
-console.log(res);
-console.log(res2);

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;

package/src/app.ts

@@ -1,66 +0,0 @@
-import Schema from "./index.js";
-
-// const testSchema = new Schema({
-//   field: {
-//     type: Number,
-//     required: true,
-//     rules: {
-//       lengthMin: 99
-//     }
-//   },
-//   field2: {
-//     type: "xxx",
-//     required: true,
-//     rules: {
-//       lengthMin: 10
-//     }
-//   }
-// });
-
-// class StringOwn {
-//   constructor(v: any) {
-//     v = v
-//   }
-// }
-
-// const strOwn = new StringOwn('xxxxuis')
-
-// const body = {
-//   "field": 33,
-//   "field2": "Ssdasjk"
-// }
-
-// const validationResult = testSchema.validate(body);
-
-
-const schema = new Schema({
-  val: {
-    type: String,
-    required: true,
-  },
-  val2: {
-    type: Number,
-    required: true,
-    rules: {
-      min: 3
-    }
-  },
-  val3: {
-    type: String,
-    required: true,
-  },
-})
-
-const testObj = {
-  val: 'string',
-  val2: 1,
-  val3: 'ss'
-}
-
-const resAll = schema.validate(testObj)
-const res = schema.validate(testObj, ['val', 'val2'])
-const res2 = schema.validate(testObj, 'val2')
-
-console.log(resAll)
-console.log(res)
-console.log(res2)