validno 0.4.1 → 0.4.4

package/dist/constants/details.d.ts

@@ -5,7 +5,8 @@ export declare enum ValidationIds {
 }
 export declare enum ValidationDetails {
     OK = "OK",
-    INVALID_DATE = "Invalid date",
-    CustomRuleFailed = "Custom rule failed"
+    InvalidDate = "Invalid date",
+    CustomRuleFailed = "Custom rule failed",
+    BadInput = "Validation input must be a plain object"
 }
 //# sourceMappingURL=details.d.ts.map

package/dist/constants/details.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"details.d.ts","sourceRoot":"","sources":["../../src/constants/details.ts"],"names":[],"mappings":"AAAA,oBAAY,aAAa;IACrB,OAAO,YAAY;IACnB,IAAI,SAAS;IACb,IAAI,SAAS;CAChB;AAED,oBAAY,iBAAiB;IACzB,EAAE,OAAO;IACT,YAAY,iBAAiB;IAC7B,gBAAgB,uBAAuB;CAC1C"}
+{"version":3,"file":"details.d.ts","sourceRoot":"","sources":["../../src/constants/details.ts"],"names":[],"mappings":"AAAA,oBAAY,aAAa;IACrB,OAAO,YAAY;IACnB,IAAI,SAAS;IACb,IAAI,SAAS;CAChB;AAED,oBAAY,iBAAiB;IACzB,EAAE,OAAO;IACT,WAAW,iBAAiB;IAC5B,gBAAgB,uBAAuB;IACvC,QAAQ,4CAA4C;CACvD"}

package/dist/constants/details.js

@@ -7,6 +7,7 @@ export var ValidationIds;
 export var ValidationDetails;
 (function (ValidationDetails) {
     ValidationDetails["OK"] = "OK";
-    ValidationDetails["INVALID_DATE"] = "Invalid date";
+    ValidationDetails["InvalidDate"] = "Invalid date";
     ValidationDetails["CustomRuleFailed"] = "Custom rule failed";
+    ValidationDetails["BadInput"] = "Validation input must be a plain object";
 })(ValidationDetails || (ValidationDetails = {}));

package/dist/dev.js

@@ -1,57 +1,10 @@
-import Schema from './index.js';
-const configSchema = new Schema({
-    api: {
-        port: {
-            type: Number,
-            required: true,
-            rules: { min: 1000, max: 9999 }
-        },
-        cors: {
-            enabled: { type: Boolean, required: true },
-            origins: {
-                type: Array,
-                eachType: String,
-                required: false
-            }
-        },
-        rateLimit: {
-            enabled: { type: Boolean, required: true },
-            maxRequests: {
-                type: Number,
-                required: false,
-                rules: { min: 1, max: 10000 }
-            },
-            windowMs: {
-                type: Number,
-                required: false,
-                rules: { min: 1000, max: 86400000 }
-            }
-        }
-    }
-});
-const exampleConfigFile = {
-    "app": {
-        "name": "MyApp",
-        "version": "1.0.0",
-        "environment": "development"
-    },
-    "database": {
-        "host": "localhost",
-        "port": 5432,
-        "name": "myappdb",
-        "ssl": false
-    },
-    "api": {
-        "port": 3000,
-        "cors": {
-            "enabled": true,
-            "origins": ["http://localhost:3000"]
-        },
-        "rateLimit": {
-            "enabled": true,
-            "maxRequests": 1000,
-            "windowMs": 60000
-        }
-    },
+import { Schema } from "./Schema.js";
+const test = () => {
+    console.log('--- Custom Test ---');
+    const schema = new Schema({
+        anyKey: { type: String }
+    });
+    const result = schema.validate({ anyKey: null });
+    console.log(result);
 };
-const res = configSchema.validate(exampleConfigFile);
+test();

package/dist/engine/methods/handleNestedKey.js

@@ -5,7 +5,7 @@ function handleNestedKey(input) {
     for (const itemKey of nestedKeys) {
         const deepParams = {
             key: itemKey,
-            data: data[key],
+            data: data ? data[key] : undefined,
             reqs: reqs[itemKey],
             nestedKey: `${nestedKey}.${itemKey}`
         };

package/dist/engine/methods/validate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../src/engine/methods/validate.ts"],"names":[],"mappings":"AACA,OAAO,aAAa,MAAM,qBAAqB,CAAA;AAC/C,OAAO,cAAwC,MAAM,sBAAsB,CAAA;AAE3E,iBAAS,QAAQ,CACb,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,GAAG,EACT,cAAc,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GACnC,aAAa,CAaf;AAED,eAAe,QAAQ,CAAC"}
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../src/engine/methods/validate.ts"],"names":[],"mappings":"AACA,OAAO,aAAa,MAAM,qBAAqB,CAAA;AAC/C,OAAO,cAAwC,MAAM,sBAAsB,CAAA;AAG3E,iBAAS,QAAQ,CACb,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,GAAG,EACT,cAAc,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GACnC,aAAa,CAmBf;AAED,eAAe,QAAQ,CAAC"}

package/dist/engine/methods/validate.js

@@ -1,5 +1,12 @@
 import _helpers from "../../utils/helpers.js";
+import ValidnoResult from "../ValidnoResult.js";
+import { ValidationDetails } from "../../constants/details.js";
 function validate(data, validationKeys) {
+    if (typeof data !== "object" || data === null || Array.isArray(data)) {
+        const result = new ValidnoResult();
+        result.setFailed("", ValidationDetails.BadInput);
+        return result.finish();
+    }
     const hasKeysToCheck = _helpers.areKeysLimited(validationKeys);
     const schemaKeys = Object.entries(this.definition);
     for (const [key, reqs] of schemaKeys) {

package/dist/engine/methods/validateType.js

@@ -69,7 +69,7 @@ const handleTypeValidation = (key, value, requirements, keyName = key) => {
             const isDate = isNotNull && value.constructor === Date;
             const isValid = isDate && !isNaN(value.getTime());
             const isValidDate = isDate && isValid;
-            result.push(_validateType.getResult(keyName, isValidDate, getDetails(isValidDate, ValidationDetails.INVALID_DATE)));
+            result.push(_validateType.getResult(keyName, isValidDate, getDetails(isValidDate, ValidationDetails.InvalidDate)));
             break;
         }
         case Boolean: {

package/dist/tests/cases/corruptedData.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=corruptedData.test.d.ts.map

package/dist/tests/cases/corruptedData.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"corruptedData.test.d.ts","sourceRoot":"","sources":["../../../src/tests/cases/corruptedData.test.ts"],"names":[],"mappings":""}

package/dist/tests/cases/corruptedData.test.js

@@ -0,0 +1,81 @@
+import { describe, expect, test } from '@jest/globals';
+import { Schema } from '../../Schema';
+const AccessScopes = {
+    Public: 'public',
+    Project: 'workspace',
+    User: 'user'
+};
+const collectionSettingsSchema = new Schema({
+    auth: { type: null },
+    scope: {
+        type: String,
+        rules: {
+            enum: Object.values(AccessScopes)
+        },
+    },
+    methods: {
+        get: {
+            isActive: { type: Boolean },
+            scope: {
+                type: String,
+                rules: { enum: Object.values(AccessScopes) },
+                required: false
+            }
+        },
+        getAll: {
+            isActive: { type: Boolean },
+            scope: {
+                type: String,
+                rules: {
+                    enum: Object.values(AccessScopes)
+                },
+                required: false
+            },
+            sort: { default: { type: String } },
+            filter: { fields: { type: Array, eachType: String } },
+            search: { fields: { type: Array, eachType: String } }
+        },
+        create: {
+            isActive: { type: Boolean },
+            scope: {
+                type: String,
+                rules: { enum: Object.values(AccessScopes) },
+                required: false
+            }
+        },
+        update: {
+            isActive: { type: Boolean },
+            scope: {
+                type: String,
+                rules: { enum: Object.values(AccessScopes) },
+                required: false
+            },
+            allowedFields: { type: Array, eachType: String }
+        },
+        delete: {
+            isActive: { type: Boolean },
+            scope: {
+                type: String,
+                rules: { enum: Object.values(AccessScopes) },
+                required: false
+            }
+        },
+        distinct: {
+            isActive: { type: Boolean },
+            scope: {
+                type: String,
+                rules: { enum: Object.values(AccessScopes) },
+                required: false
+            },
+            fields: { type: Array, eachType: String }
+        }
+    }
+});
+const settingsData = { test: 1 };
+describe('Corrupted data in nested keys', () => {
+    test('Corrupted data in nested keys should not pass the validation', () => {
+        const result = collectionSettingsSchema.validate(settingsData);
+        expect(result.ok).toBe(false);
+        expect(result.errors.length).toBeGreaterThan(1);
+    });
+});

package/dist/tests/cases/dataInputIsNotAnObject.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=dataInputIsNotAnObject.test.d.ts.map

package/dist/tests/cases/dataInputIsNotAnObject.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataInputIsNotAnObject.test.d.ts","sourceRoot":"","sources":["../../../src/tests/cases/dataInputIsNotAnObject.test.ts"],"names":[],"mappings":""}

package/dist/tests/cases/dataInputIsNotAnObject.test.js

@@ -0,0 +1,24 @@
+import { describe, expect, test } from '@jest/globals';
+import { Schema } from '../../Schema';
+describe('Data input is not an object → returns failed validation result', () => {
+    const schema = new Schema({
+        name: {
+            type: String
+        }
+    });
+    test('null input fails validation but not throws', () => {
+        const result = schema.validate(null);
+        expect(result).toBeDefined();
+        expect(result.ok).toBe(false);
+    });
+    test('array input fails validation but not throws', () => {
+        const result = schema.validate([]);
+        expect(result).toBeDefined();
+        expect(result.ok).toBe(false);
+    });
+    test('undefined input fails validation but not throws', () => {
+        const result = schema.validate(undefined);
+        expect(result).toBeDefined();
+        expect(result.ok).toBe(false);
+    });
+});

package/dist/tests/cases/notRequiredNestedKey.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=notRequiredNestedKey.test.d.ts.map

package/dist/tests/cases/notRequiredNestedKey.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notRequiredNestedKey.test.d.ts","sourceRoot":"","sources":["../../../src/tests/cases/notRequiredNestedKey.test.ts"],"names":[],"mappings":""}

package/dist/tests/cases/notRequiredNestedKey.test.js

@@ -0,0 +1,38 @@
+import { describe, expect, test } from '@jest/globals';
+import { Schema } from '../../Schema';
+describe('Not required nested key', () => {
+    test('[1] Nested key that is not required should pass the validation', () => {
+        const schema = new Schema({
+            query: { type: Object },
+            data: { type: Object },
+            params: {
+                upsert: { type: Boolean, required: false },
+            }
+        });
+        const data = {
+            query: {},
+            data: {}
+        };
+        const result = schema.validate(data);
+        expect(result.ok).toBe(true);
+        expect(result.missed).toEqual([]);
+    });
+    test('[2] Nested key that is required should not pass the validation', () => {
+        const schema = new Schema({
+            query: { type: Object },
+            data: { type: Object },
+            params: {
+                upsert: { type: Boolean, required: true },
+            }
+        });
+        const data = {
+            query: {},
+            data: {}
+        };
+        const result = schema.validate(data);
+        expect(result.ok).toBe(false);
+        expect(result.missed).toEqual(['params.upsert']);
+        expect(result.failed).toEqual(['params.upsert', 'params']);
+        expect(result.passed).toEqual(['query', 'data']);
+    });
+});

package/dist/tests/cases/secondLevelDeepValidates.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=secondLevelDeepValidates.test.d.ts.map

package/dist/tests/cases/secondLevelDeepValidates.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secondLevelDeepValidates.test.d.ts","sourceRoot":"","sources":["../../../src/tests/cases/secondLevelDeepValidates.test.ts"],"names":[],"mappings":""}

package/dist/tests/cases/secondLevelDeepValidates.test.js

@@ -0,0 +1,112 @@
+import { describe, expect, test } from '@jest/globals';
+import { Schema } from '../../Schema';
+const configSchema = new Schema({
+    app: {
+        name: {
+            type: String,
+            required: true,
+            rules: { lengthMin: 1, lengthMax: 50 }
+        },
+        version: {
+            type: String,
+            required: true,
+            rules: {
+                regex: /^\d+\.\d+\.\d+$/
+            }
+        },
+        environment: {
+            type: String,
+            required: true,
+            rules: {
+                enum: ['development', 'testing', 'staging', 'production']
+            }
+        }
+    },
+    database: {
+        host: {
+            type: String,
+            required: true,
+            rules: { lengthMin: 1 }
+        },
+        port: {
+            type: Number,
+            required: true,
+            rules: { min: 1, max: 65535 }
+        },
+        name: {
+            type: String,
+            required: true,
+            rules: { lengthMin: 1, lengthMax: 64 }
+        },
+        ssl: {
+            type: Boolean,
+            required: false
+        }
+    },
+    api: {
+        port: {
+            type: Number,
+            required: true,
+            rules: { min: 1000, max: 9999 }
+        },
+        cors: {
+            enabled: { type: Boolean, required: true },
+            origins: {
+                type: Array,
+                eachType: String,
+                required: false
+            }
+        },
+        rateLimit: {
+            enabled: { type: Boolean, required: true },
+            maxRequests: {
+                type: Number,
+                required: false,
+                rules: { min: 1, max: 10000 }
+            },
+            windowMs: {
+                type: Number,
+                required: false,
+                rules: { min: 1000, max: 86400000 }
+            }
+        }
+    }
+});
+const exampleConfigFile = {
+    "app": {
+        "name": "MyApp",
+        "version": "1.0.0",
+        "environment": "development"
+    },
+    "database": {
+        "host": "localhost",
+        "port": 5432,
+        "name": "myappdb",
+        "ssl": false
+    },
+    "api": {
+        "port": 3000,
+        "cors": {
+            "enabled": true,
+            "origins": ["http://localhost:3000"]
+        },
+        "rateLimit": {
+            "enabled": true,
+            "maxRequests": 1000,
+            "windowMs": 60000
+        }
+    },
+};
+describe('Second level deep validates as expected', () => {
+    test('should validate the api key', () => {
+        const res = configSchema.validate(exampleConfigFile);
+        expect(res.ok).toBe(true);
+        expect(res.failed).toEqual([]);
+        expect(res.missed).toEqual([]);
+    });
+    test('api key shouldn\'t validate with wrong port type', () => {
+        const res2 = configSchema.validate(Object.assign(Object.assign({}, exampleConfigFile), { api: Object.assign(Object.assign({}, exampleConfigFile.api), { port: '99999' }) }));
+        expect(res2.ok).toBe(false);
+        expect(res2.failed).toContain('api');
+    });
+});

package/dist/tests/customMessage.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=customMessage.test.d.ts.map

package/dist/tests/customMessage.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"customMessage.test.d.ts","sourceRoot":"","sources":["../../src/tests/customMessage.test.ts"],"names":[],"mappings":""}

package/dist/tests/customMessage.test.js

@@ -0,0 +1,102 @@
+import { describe, expect, test } from '@jest/globals';
+import { Schema } from '../Schema';
+describe('Тестирование кастомного сообщения об ошибке', () => {
+    test('Кастомные сообщения корректно отображаются в результате валидации', () => {
+        const wrongTypeKey = 'wrongType';
+        const missingKey = 'missingKey';
+        const wrongRule1 = 'wrongRule1';
+        const wrongRule2 = 'wrongRule2';
+        const wrongRule3 = 'wrongRule3';
+        const allKeys = [
+            wrongTypeKey,
+            missingKey,
+            wrongRule1,
+            wrongRule2,
+            wrongRule3
+        ];
+        const getCustomMsg = (key, variation = '') => key + ' custom' + variation;
+        const schema = new Schema({
+            [wrongTypeKey]: {
+                type: Number,
+                required: true,
+                title: 'Не по типу',
+                customMessage: (input) => {
+                    return getCustomMsg(wrongTypeKey);
+                }
+            },
+            [missingKey]: {
+                type: Date,
+                required: true,
+                title: 'Отсутствующий',
+                customMessage: (input) => {
+                    return getCustomMsg(missingKey);
+                }
+            },
+            [wrongRule1]: {
+                type: String,
+                required: true,
+                title: 'Wrong Rule #1',
+                rules: {
+                    is: 'xxx'
+                },
+                customMessage: (input) => {
+                    return getCustomMsg(wrongRule1);
+                }
+            },
+            [wrongRule2]: {
+                type: String,
+                required: true,
+                title: 'Wrong Rule #2',
+                rules: {
+                    lengthMin: 999
+                },
+                customMessage: (input) => {
+                    return getCustomMsg(wrongRule2);
+                }
+            },
+            [wrongRule3]: {
+                type: String,
+                required: true,
+                title: 'Wrong Rule #3',
+                rules: {
+                    lengthMax: 1
+                },
+                customMessage: (input) => {
+                    const { keyword, value, key, title, reqs, schema, rules } = input;
+                    if (keyword === 'lengthMax') {
+                        return getCustomMsg(wrongRule3);
+                    }
+                    return wrongRule3 + ' should reach here';
+                }
+            },
+        });
+        const obj = {
+            [wrongTypeKey]: 'abc',
+            [wrongRule1]: 'def',
+            [wrongRule2]: 'ghi',
+            [wrongRule3]: 'jkl'
+        };
+        const result = schema.validate(obj);
+        expect(result).toEqual({
+            ok: false,
+            missed: [missingKey],
+            failed: [...allKeys],
+            passed: [],
+            errors: allKeys.map(el => getCustomMsg(el)),
+            byKeys: {
+                wrongType: false,
+                missingKey: false,
+                wrongRule1: false,
+                wrongRule2: false,
+                wrongRule3: false
+            },
+            errorsByKeys: {
+                wrongType: [getCustomMsg(allKeys[0])],
+                missingKey: [getCustomMsg(allKeys[1])],
+                wrongRule1: [getCustomMsg(allKeys[2])],
+                wrongRule2: [getCustomMsg(allKeys[3])],
+                wrongRule3: [getCustomMsg(allKeys[4])],
+            }
+        });
+    });
+});

package/dist/tests/customType.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=customType.test.d.ts.map

package/dist/tests/customType.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"customType.test.d.ts","sourceRoot":"","sources":["../../src/tests/customType.test.ts"],"names":[],"mappings":""}