validno 0.1.1 → 0.1.3

package/dist/Schema.js

@@ -9,7 +9,7 @@ export class Schema {
     constructor(inputSchema) {
         this.schema = inputSchema;
     }
-    validate(data) {
-        return validate.call(this, this, data);
+    validate(data, keys) {
+        return validate.call(this, this, data, keys);
     }
 }

package/dist/app.js

@@ -0,0 +1,29 @@
+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/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/validate.js

@@ -3,7 +3,7 @@ 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: [],
@@ -25,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];
@@ -35,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 = [];
@@ -101,11 +101,17 @@ 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/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.1",
+  "version": "0.1.3",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/src/Schema.ts

@@ -34,7 +34,7 @@ export class Schema {
         this.schema = inputSchema
     }
 
-    validate(data: any) {
-        return validate.call(this, this, data)
+    validate(data: any, keys?: string | string[]) {
+        return validate.call(this, this, data, keys)
     }
 }

package/src/app.ts

@@ -0,0 +1,66 @@
+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)

package/src/checkRules.ts

@@ -5,6 +5,21 @@ 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)
@@ -67,6 +82,8 @@ const rulesFunctions: any = {
         }
     },
     lengthMin: (key: string, val:  TLengths, min: number) => {
+        ensureRuleHasCorrectType(val, rulesParams['lengthMin'].allowedTypes)
+
         return {
             result: _validations.lengthMin(val, min),
             details: `Длина не может быть меньше ${min} символов`
@@ -137,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/validate.ts

@@ -4,7 +4,7 @@ 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[],
@@ -14,7 +14,7 @@ type TResult = {
     errorsByKeys: {[key: string]: string[]}
 };
 
-const getResultDefaults = (): TResult => {
+export const getResultDefaults = (): TResult => {
   return {
     ok: null,
     missed: [],
@@ -38,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]
@@ -51,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)
   
@@ -154,14 +154,21 @@ const handleReqKey = (key: string, data: any, reqs: TSchemaInput, deepKey = key)
   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