validno 0.1.2 → 0.1.4

package/dist/Schema.js

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

package/dist/app.js

@@ -4,19 +4,42 @@ const schema = new Schema({
         type: String,
         required: true,
     },
+    date: {
+        type: Date,
+        required: true,
+    },
+    obj: {
+        type: Object,
+        required: true,
+    },
+    bool: {
+        type: Boolean,
+        required: true,
+    },
     val2: {
         type: Number,
         required: true,
         rules: {
             min: 3
         }
-    }
+    },
+    srtOrNum: {
+        type: [String, Number],
+        required: true,
+    },
+    nl: {
+        type: null,
+        required: true,
+    },
 });
 const testObj = {
     val: 'string',
-    val2: 1
+    val2: 4,
+    obj: {},
+    srtOrNum: ['ss'],
+    date: new Date(),
+    bool: true,
+    nl: null
 };
-const res = schema.validate(testObj);
-const res2 = schema.validateKey('val2', testObj);
-console.log(res);
-console.log(res2);
+const resAll = schema.validate(testObj);
+const str = 'test';

package/dist/checkRules.js

@@ -30,7 +30,7 @@ const rulesFunctions = {
     isNot: (key, val, notEqualTo) => {
         return {
             result: _validations.isNot(val, notEqualTo),
-            details: `Значение не должно быть "${notEqualTo}"`
+            details: `Значение "${notEqualTo}" недопустимо`
         };
     },
     min: (key, val, min) => {
@@ -93,7 +93,7 @@ const rulesFunctions = {
     enum: (key, value, allowedList) => {
         return {
             result: allowedList.includes(value),
-            details: `Значение "${value}" не допустимо`
+            details: `Значение "${value}" недопустимо`
         };
     }
 };
@@ -104,17 +104,15 @@ const checkRules = (key, value, requirements) => {
     };
     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;

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

@@ -101,11 +101,17 @@ export const handleReqKey = (key, data, reqs, deepKey = key) => {
     results.byKeys[deepKey] = (missedCheck.length + typeChecked.length + rulesChecked.length) === 0;
     return results;
 };
-const validate = (schema, data) => {
+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) => {
     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)) {
-        const keyResult = handleReqKey(key, data, reqs);
-        results = mergeResults(results, keyResult);
+        if (isCheckNeeded(key, areKeysLimited, onlyKeys)) {
+            const keyResult = handleReqKey(key, data, reqs);
+            results = mergeResults(results, keyResult);
+        }
     }
     if (results.failed.length)
         results.ok = false;

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "validno",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "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/Schema.ts

@@ -1,5 +1,4 @@
 import validate from "./validate.js"
-import validateKey from "./validateKey.js"
 
 export type TSchemaItem = {
     required: boolean,
@@ -35,11 +34,7 @@ export class Schema {
         this.schema = inputSchema
     }
 
-    validate(data: any) {
-        return validate.call(this, this, data)
-    }
-
-    validateKey(key: string, data: any) {
-        return validateKey.call(this, this, data, key)
+    validate(data: any, keys?: string | string[]) {
+        return validate.call(this, this, data, keys)
     }
 }

package/src/checkRules.ts

@@ -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) => {
@@ -104,7 +104,7 @@ const rulesFunctions: any = {
     enum: (key: string, value: any, allowedList: any[]) => {
         return {
             result: allowedList.includes(value),
-            details: `Значение "${value}" не допустимо`
+            details: `Значение "${value}" недопустимо`
         }
     }
 };
@@ -120,11 +120,10 @@ const checkRules = (key: string, value: any, requirements: TSchemaItem) => {
         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 +131,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

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

@@ -154,14 +154,21 @@ export const handleReqKey = (key: string, data: any, reqs: TSchemaInput, deepKey
   return results
 }
 
-const validate = (schema: Schema, data: any): TResult => {
+const isCheckNeeded = (key: string, hasLimits: boolean, onlyKeys?: string | string[]) => {
+  return !hasLimits || (key === onlyKeys || Array.isArray(onlyKeys) && onlyKeys?.includes(key))
+}
+
+const 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)) {
-      // @ts-ignore
-      const keyResult = handleReqKey(key, data, reqs)
+      if (isCheckNeeded(key, areKeysLimited, onlyKeys)) {
+        // @ts-ignore
+        const keyResult = handleReqKey(key, data, reqs)
 
-      results = mergeResults(results, keyResult)
+        results = mergeResults(results, keyResult)
+      }
     }
   
     if (results.failed.length) results.ok = false

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/src/app.ts

@@ -1,59 +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
-    }
-  }
-})
-
-const testObj = {
-  val: 'string',
-  val2: 1
-}
-
-const res = schema.validate(testObj)
-const res2 = schema.validateKey('val2', testObj)
-
-console.log(res)
-console.log(res2)

package/src/validateKey.ts

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