validno 0.4.3 → 0.4.4

package/dist/dev.js

@@ -1,79 +1,10 @@
 import { Schema } from "./Schema.js";
 const test = () => {
     console.log('--- Custom Test ---');
-    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 schema = new Schema({
+        anyKey: { type: String }
     });
-    const settingsData = { text: 1 };
-    const res = collectionSettingsSchema.validate(settingsData);
-    console.log(res);
+    const result = schema.validate({ anyKey: null });
+    console.log(result);
 };
 test();

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":""}

package/dist/tests/customType.test.js

@@ -0,0 +1,146 @@
+import { describe, expect, test } from '@jest/globals';
+import { Schema } from '../Schema';
+class Parent {
+    constructor(value) {
+        this.value = value;
+        this.version = 1;
+    }
+    getV() {
+        return this.version;
+    }
+}
+class Child extends Parent {
+    constructor(value) {
+        super(value);
+        this.isDeep = true;
+    }
+}
+class CustomString extends String {
+    constructor(value) {
+        super(value);
+    }
+    isEmpty() {
+        return this !== undefined && this.length === 0;
+    }
+}
+describe('Тестирование кастомного типа', () => {
+    test('Значения, созданные из кастомных типов, корректно проходят проверку', () => {
+        const keys = ['cust1', 'cust2', 'cust3', 'badKey'];
+        const err = new Error('ops');
+        const parent = new Parent(1);
+        const child = new Child(2);
+        const child2 = new Child(3);
+        const schema = new Schema({
+            [keys[0]]: {
+                type: Error,
+                required: true
+            },
+            [keys[1]]: {
+                type: Parent,
+                required: true
+            },
+            [keys[2]]: {
+                type: Child,
+                required: true
+            },
+        });
+        const obj = {
+            [keys[0]]: err,
+            [keys[1]]: parent,
+            [keys[2]]: child,
+        };
+        const res = schema.validate(obj);
+        const allKeysArePassed = [
+            res.byKeys[keys[0]] === true,
+            res.byKeys[keys[1]] === true,
+            res.byKeys[keys[2]] === true,
+        ].every(k => k === true);
+        expect(res.ok).toBe(true);
+        expect(allKeysArePassed).toBe(true);
+    });
+    test('Дочерний класс не проходит проверку по родительскому классу', () => {
+        const keys = ['cust1', 'cust2', 'cust3'];
+        const parent = new Parent(1);
+        const child = new Child(2);
+        const schema = new Schema({
+            [keys[0]]: {
+                type: Parent,
+                required: true
+            },
+            [keys[1]]: {
+                type: Child,
+                required: true
+            },
+            [keys[2]]: {
+                type: Parent,
+                required: true
+            },
+        });
+        const obj = {
+            [keys[0]]: parent,
+            [keys[1]]: child,
+            [keys[2]]: child,
+        };
+        const res = schema.validate(obj);
+        const allKeysArePassed = [
+            res.byKeys[keys[0]] === true,
+            res.byKeys[keys[1]] === true,
+            res.byKeys[keys[2]] === false,
+        ].every(k => k === true);
+        expect(res.ok).toBe(false);
+        expect(allKeysArePassed).toBe(true);
+        expect(res.failed.includes(keys[2])).toBe(true);
+    });
+    test('Унаследованный класс от String не проходит проверку как String', () => {
+        const keys = ['cust0', 'cust1', 'cust2', 'cust3', 'undef'];
+        const origin = new String('str1');
+        const origin2 = 'str2';
+        const custom = new CustomString('str3');
+        const schema = new Schema({
+            [keys[0]]: {
+                type: String,
+                required: true,
+                title: "test String to String"
+            },
+            [keys[1]]: {
+                type: CustomString,
+                required: true,
+                title: "test CustomString to CustomString"
+            },
+            [keys[2]]: {
+                type: CustomString,
+                required: true,
+                title: "test String to CustomString"
+            },
+            [keys[3]]: {
+                type: String,
+                required: true,
+                title: "test CustomString to String"
+            },
+            [keys[4]]: {
+                type: String,
+                required: true,
+                title: "test undefined to String"
+            },
+        });
+        const obj = {
+            [keys[0]]: origin,
+            [keys[1]]: custom,
+            [keys[2]]: origin2,
+            [keys[3]]: custom,
+        };
+        const res = schema.validate(obj);
+        const allKeysArePassed = [
+            res.byKeys[keys[0]] === true,
+            res.byKeys[keys[1]] === true,
+            res.byKeys[keys[2]] === false,
+            res.byKeys[keys[3]] === false,
+            res.byKeys[keys[4]] === false,
+        ].every(k => k === true);
+        expect(res.ok).toBe(false);
+        expect(allKeysArePassed).toBe(true);
+        expect(res.failed.includes(keys[2])).toBe(true);
+        expect(res.failed.includes(keys[3])).toBe(true);
+        expect(res.failed.includes(keys[4])).toBe(true);
+    });
+});

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

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

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

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