validno 0.2.2 → 0.2.3

package/dist/ValidnoResult.js

@@ -10,24 +10,35 @@ class ValidnoResult {
         this.errorsByKeys = (results === null || results === void 0 ? void 0 : results.errorsByKeys) || {};
         this.byKeys = (results === null || results === void 0 ? void 0 : results.byKeys) || {};
     }
-    fixByKey(key, result) {
+    setKeyStatus(key, result) {
         this.byKeys[key] = result;
-        if (result === true)
-            this.passed.push(key);
+    }
+    fixParentByChilds(parentKey, childChecks = []) {
+        const isEveryOk = childChecks.every(c => c === true);
+        this.setKeyStatus(parentKey, isEveryOk);
+        if (isEveryOk === true)
+            this.setPassed(parentKey);
         else
-            this.failed.push(key);
+            this.setFailed(parentKey);
     }
-    pushMissing(key, errMsg) {
-        this.missed.push(key);
-        this.fixByKey(key, false);
+    setMissing(key, errMsg) {
         const error = errMsg || _errors.getMissingError(key);
-        this.pushError(key, error);
+        this.missed.push(key);
+        this.setFailed(key, error);
+        this.setKeyStatus(key, false);
     }
-    pushError(key, msg) {
+    setPassed(key) {
+        this.passed.push(key);
+        this.setKeyStatus(key, true);
+    }
+    setFailed(key, msg) {
         if (key in this.errorsByKeys === false) {
             this.errorsByKeys[key] = [];
         }
-        this.byKeys[key] = false;
+        this.failed.push(key);
+        this.setKeyStatus(key, false);
+        if (!msg)
+            return;
         this.errors.push(msg);
         this.errorsByKeys[key].push(msg);
     }
@@ -50,11 +61,19 @@ class ValidnoResult {
         }
         return this;
     }
+    clearEmptyErrorsByKeys() {
+        for (const key in this.errorsByKeys) {
+            if (!this.errorsByKeys[key].length) {
+                delete this.errorsByKeys[key];
+            }
+        }
+    }
     finish() {
         if (this.failed.length)
             this.ok = false;
         else
             this.ok = true;
+        this.clearEmptyErrorsByKeys();
         return this;
     }
 }

package/dist/dev.js

@@ -1,105 +1,91 @@
-import { isDeepStrictEqual } from 'node:util';
-import _validations from './utils/validations.js';
-const listSame = [];
-const TEST_MAX = 1 * 1000000;
-const TYPES = [
-    'json',
-    'date',
-    'string',
-    'number',
-    'array',
-    'null',
-    'boolean'
-];
-const str = 'string';
-const date = () => new Date(2025, 0, 1, 0, 0, 0, 0);
-const json = () => {
-    return {
-        "surname": "Иванов",
-        "name": "Иван",
-        "patronymic": "Иванович",
-        "birthdate": "01.01.1990",
-        "birthplace": "Москва",
-        "phone": "8 926 766 48 48"
-    };
-};
-console.time('autofill');
-let i = 0;
-while (i < TEST_MAX) {
-    if (TYPES.includes('null'))
-        listSame.push(null);
-    if (TYPES.includes('boolean'))
-        listSame.push(true);
-    if (TYPES.includes('json'))
-        listSame.push(() => json());
-    if (TYPES.includes('date'))
-        listSame.push(() => date());
-    if (TYPES.includes('string'))
-        listSame.push(str);
-    if (TYPES.includes('number'))
-        listSame.push(Math.random());
-    if (TYPES.includes('array'))
-        listSame.push(() => [{ x: 1, y: { z: 0 } }, { x: 1 }, { x: 1 }]);
-    if (TYPES.includes('array'))
-        listSame.push(() => [1234451, 5535433, 7839262, 2134573, 10239752]);
-    if (TYPES.includes('array'))
-        listSame.push(() => [true, true, false, true, false]);
-    if (TYPES.includes('array'))
-        listSame.push(() => ['true', 'true', 'false', 'true', 'false']);
-    i++;
-}
-console.timeEnd('autofill');
-const compareArrs = (v1, v2) => {
-    if (v1.length !== v2.length)
-        return false;
-    return v1.every((el, i) => {
-        if (_validations.isObject(el)) {
-            return JSON.stringify(el) === JSON.stringify(v2[i]);
-        }
-        return v2[i] === el;
+import { Schema } from "./Schema.js";
+const validateConfig = (cfg) => {
+    const cfgSchema = new Schema({
+        methods: {
+            create: {
+                type: Object,
+                required: false,
+            },
+            createMany: {
+                type: Object,
+                required: false,
+            },
+            get: {
+                type: Object,
+                required: false,
+            },
+            getAll: {
+                type: Object,
+                required: false,
+            },
+            update: {
+                type: Object,
+                required: false,
+            },
+            delete: {
+                type: Object,
+                required: false,
+            },
+            deleteMany: {
+                type: Object,
+                required: false,
+            },
+            export: {
+                type: Object,
+                required: false,
+            },
+            distinct: {
+                type: Object,
+                required: false,
+            },
+            custom: {
+                type: Array,
+                required: false,
+                rules: {},
+            },
+        },
     });
-};
-const is = (value, compareTo) => {
-    if (value === compareTo) {
-        return true;
-    }
-    const bothArrays = _validations.isArray(value) && _validations.isArray(compareTo);
-    if (bothArrays) {
-        return compareArrs(value, compareTo);
-    }
-    const bothObjects = _validations.isObject(value) && _validations.isObject(compareTo);
-    if (bothObjects) {
-        const valueStr = JSON.stringify(value);
-        const compareToStr = JSON.stringify(compareTo);
-        return valueStr === compareToStr;
+    const res = cfgSchema.validate(cfg);
+    console.log(res);
+    if (res.ok !== true) {
+        const errorsMsg = res.errors.join('; ');
+        throw new Error(errorsMsg);
     }
-    const bothDates = _validations.isDate(value) && _validations.isDate(compareTo);
-    if (bothDates) {
-        return value.getTime() === compareTo.getTime();
-    }
-    return value === compareTo;
-};
-const is2 = (value, compareTo) => {
-    return true;
 };
-const is3 = (v1, v2) => {
-    return isDeepStrictEqual(v1, v2);
-};
-const doTest = (func) => {
-    console.time('test ' + func.name);
-    let y = 0;
-    while (y < TEST_MAX) {
-        const v1 = typeof listSame[y] === 'function' ? listSame[y]() : listSame[y];
-        const v2 = typeof listSame[y] === 'function' ? listSame[y]() : listSame[y];
-        const result = func(v1, v2);
-        if (result !== true) {
-            console.log(v1);
-            console.log(v2);
-            throw new Error('RESULT != TRUE');
-        }
-        y++;
-    }
-    console.timeEnd('test ' + func.name);
+const uniTestService = {
+    methods: {
+        getAll: {
+            isActive: true,
+            sort: {
+                default: 'createdAt',
+            },
+            search: {
+                fields: ['title'],
+            },
+        },
+        export: {
+            isActive: false,
+        },
+        get: {
+            isActive: true,
+        },
+        create: null,
+        createMany: {
+            isActive: true,
+        },
+        update: {
+            isActive: true,
+        },
+        delete: {
+            isActive: true,
+        },
+        deleteMany: {
+            isActive: true,
+        },
+        distinct: {
+            isActive: true,
+            fields: ['title', '_id'],
+        },
+    },
 };
-doTest(is);
-doTest(is3);
+validateConfig(uniTestService);

package/dist/validate.js

@@ -24,7 +24,7 @@ function generateMsg(input) {
 function handleDeepKey(input) {
     const { results, key, deepKey, data, reqs } = input;
     const nesctedKeys = Object.keys(reqs);
-    results.fixByKey(deepKey, false);
+    const nestedResults = [];
     let i = 0;
     while (i < nesctedKeys.length) {
         const nestedKey = nesctedKeys[i];
@@ -35,9 +35,11 @@ function handleDeepKey(input) {
             deepKey: `${deepKey}.${nestedKey}`
         };
         const deepResults = handleKey.call(this, deepParams);
+        nestedResults.push(deepResults.ok);
         results.merge(deepResults);
         i++;
     }
+    results.fixParentByChilds(deepKey, nestedResults);
     return results;
 }
 export function handleKey(input) {
@@ -52,7 +54,7 @@ export function handleKey(input) {
     const typeChecked = [];
     const rulesChecked = [];
     if (_helpers.checkNestedIsMissing(reqs, data)) {
-        results.pushMissing(deepKey);
+        results.setMissing(deepKey);
         return results;
     }
     if (hasNested) {
@@ -61,7 +63,7 @@ export function handleKey(input) {
     if (hasMissing) {
         let errMsg = generateMsg.call(this, input);
         missedCheck.push(false);
-        results.pushMissing(deepKey, errMsg);
+        results.setMissing(deepKey, errMsg);
         return results;
     }
     const typeCheck = checkType(key, data[key], reqs, deepKey);
@@ -82,12 +84,17 @@ export function handleKey(input) {
         });
     }
     if (missedCheck.length)
-        results.pushMissing(deepKey);
+        results.setMissing(deepKey);
     const isPassed = (!typeChecked.length && !rulesChecked.length && !missedCheck.length);
-    results.fixByKey(deepKey, isPassed);
-    results.errorsByKeys[deepKey] = [
-        ...results.errors
-    ];
+    if (!isPassed) {
+        results.setFailed(deepKey);
+        results.errorsByKeys[deepKey] = [
+            ...results.errors
+        ];
+    }
+    else {
+        results.setPassed(deepKey);
+    }
     return results.finish();
 }
 function validate(schema, data, keysToCheck) {

package/package.json

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