validno 0.1.1 → 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/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 = [];

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.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

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

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;