@hosterai/types 0.0.27 → 0.0.29

package/dist/validators/admin-panel-tabs-validator.spec.js

@@ -7,24 +7,88 @@ const admin_panel_dto_1 = require("../dtos/admin-panel.dto");
 describe('validateAdminPanelTabsDto', () => {
     const validTab = { label: 'Tab', url: 'https://example.com' };
     const boundaryTab = { label: 'T', url: 'https://e.com' }; // Shortest valid values
-    const longTab = { label: 'L'.repeat(256), url: 'https://example.com/long-url' }; // Longest valid values
+    const longTab = {
+        label: 'L'.repeat(256),
+        url: 'https://example.com/long-url',
+    }; // Longest valid values
     const cases = [
         [{ product: [], item: [], client: [], user: [], order: [] }, false], // all empty => invalid
-        [{ product: [validTab], item: [validTab], client: [validTab], user: [validTab], order: [validTab] }, true],
+        [
+            {
+                product: [validTab],
+                item: [validTab],
+                client: [validTab],
+                user: [validTab],
+                order: [validTab],
+            },
+            true,
+        ],
         [{ product: [], item: [], client: [], user: [] }, false], // missing order
-        [{ product: [], item: 'not-an-array', client: [], user: [], order: [] }, false],
-        [{ product: [{ label: 123, url: 'invalid-url' }], item: [], client: [], user: [], order: [] }, false],
-        [{ product: [{ label: 123, url: 'invalid-url' }], item: [], client: [], user: [], order: [] }, false],
+        [
+            { product: [], item: 'not-an-array', client: [], user: [], order: [] },
+            false,
+        ],
+        [
+            {
+                product: [{ label: 123, url: 'invalid-url' }],
+                item: [],
+                client: [],
+                user: [],
+                order: [],
+            },
+            false,
+        ],
+        [
+            {
+                product: [{ label: 123, url: 'invalid-url' }],
+                item: [],
+                client: [],
+                user: [],
+                order: [],
+            },
+            false,
+        ],
     ];
     const additionalCases = [
-        [{ product: [boundaryTab], item: [boundaryTab], client: [boundaryTab], user: [boundaryTab], order: [boundaryTab] }, true], // boundary values
-        [{ product: [longTab], item: [longTab], client: [longTab], user: [longTab], order: [longTab] }, true], // long values
-        [{ product: [validTab], item: [validTab], client: [validTab], user: [validTab], order: [validTab], unexpected: 'extra' }, false], // unexpected property
+        [
+            {
+                product: [boundaryTab],
+                item: [boundaryTab],
+                client: [boundaryTab],
+                user: [boundaryTab],
+                order: [boundaryTab],
+            },
+            true,
+        ], // boundary values
+        [
+            {
+                product: [longTab],
+                item: [longTab],
+                client: [longTab],
+                user: [longTab],
+                order: [longTab],
+            },
+            true,
+        ], // long values
+        [
+            {
+                product: [validTab],
+                item: [validTab],
+                client: [validTab],
+                user: [validTab],
+                order: [validTab],
+                unexpected: 'extra',
+            },
+            false,
+        ], // unexpected property
     ];
     test.each([...cases, ...additionalCases])('validates %# as %s', (input, valid) => {
         const dto = (0, class_transformer_1.plainToInstance)(admin_panel_dto_1.AdminPanelTabsDto, input);
-        const errors = (0, class_validator_1.validateSync)(dto, { whitelist: true, forbidNonWhitelisted: true });
-        const classLevelError = errors.find(e => e.property === '');
+        const errors = (0, class_validator_1.validateSync)(dto, {
+            whitelist: true,
+            forbidNonWhitelisted: true,
+        });
+        const classLevelError = errors.find((e) => e.property === '');
         const hasClassLevelError = classLevelError !== undefined;
         if (valid) {
             expect(errors.length).toBe(0);

package/dist/validators/admin-panel-tabs.validator.d.ts

@@ -1,2 +1,2 @@
-import { ValidationError } from "class-validator";
+import { ValidationError } from 'class-validator';
 export declare function validateAdminPanelTabsDto(data: object): ValidationError[];

package/dist/validators/admin-panel-validator.spec.js

@@ -2,7 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
 const admin_panel_validator_1 = require("./admin-panel.validator");
-const validAction = { icon: 'add', openMethod: 'ajax_call', url: 'https://example.com/action' };
+const validAction = {
+    icon: 'add',
+    openMethod: 'ajax_call',
+    url: 'https://example.com/action',
+};
 const minimalValidMenuDtoWithUrl = {
     type: 'only-url',
     icon: 'https://example.com/icon.png',
@@ -40,17 +44,39 @@ describe('AdminPanelDto full validation', () => {
         // Empty object is invalid
         ['valid minimal empty object', {}, false],
         // Tabs tests
-        ['invalid all empty tabs and empty moreActions', {
+        [
+            'invalid all empty tabs and empty moreActions',
+            {
                 tabs: { product: [], item: [], client: [], user: [], order: [] },
                 moreActions: {},
-            }, false],
-        ['valid with one non-empty tab', {
-                tabs: { product: [{ label: 'Product', url: 'https://example.com/product' }] },
-            }, true],
-        ['invalid with one non-empty tab', {
-                tabs: { product: [{ label: 'Product', url: 'https://example.com/product' }], item: [], client: [], user: [], order: [] },
-            }, false],
-        ['invalid with multiple non-empty tabs', {
+            },
+            false,
+        ],
+        [
+            'valid with one non-empty tab',
+            {
+                tabs: {
+                    product: [{ label: 'Product', url: 'https://example.com/product' }],
+                },
+            },
+            true,
+        ],
+        [
+            'invalid with one non-empty tab',
+            {
+                tabs: {
+                    product: [{ label: 'Product', url: 'https://example.com/product' }],
+                    item: [],
+                    client: [],
+                    user: [],
+                    order: [],
+                },
+            },
+            false,
+        ],
+        [
+            'invalid with multiple non-empty tabs',
+            {
                 tabs: {
                     product: [{ label: 'Product', url: 'https://example.com/product' }],
                     item: [{ label: 'Item', url: 'https://example.com/item' }],
@@ -58,40 +84,144 @@ describe('AdminPanelDto full validation', () => {
                     user: [],
                     order: [],
                 },
-            }, false],
-        ['valid with multiple non-empty tabs', {
+            },
+            false,
+        ],
+        [
+            'valid with multiple non-empty tabs',
+            {
                 tabs: {
                     product: [{ label: 'Product', url: 'https://example.com/product' }],
                     item: [{ label: 'Item', url: 'https://example.com/item' }],
                 },
-            }, true],
+            },
+            true,
+        ],
         // MoreActions tests
-        ['valid with moreActions.client', { moreActions: { client: [validAction] } }, true],
-        ['valid with moreActions.item', { moreActions: { item: [validAction] } }, true],
-        ['valid with moreActions.invoice', { moreActions: { invoice: [validAction] } }, true],
-        ['valid with moreActions.order', { moreActions: { order: [validAction] } }, true],
-        ['valid with moreActions.user', { moreActions: { user: [validAction] } }, true],
-        ['invalid moreActions.client with bad openMethod', { moreActions: { client: [{ icon: 'add', openMethod: 'bad_method', url: 'https://example.com/action' }] } }, false],
+        [
+            'valid with moreActions.client',
+            { moreActions: { client: [validAction] } },
+            true,
+        ],
+        [
+            'valid with moreActions.item',
+            { moreActions: { item: [validAction] } },
+            true,
+        ],
+        [
+            'valid with moreActions.invoice',
+            { moreActions: { invoice: [validAction] } },
+            true,
+        ],
+        [
+            'valid with moreActions.order',
+            { moreActions: { order: [validAction] } },
+            true,
+        ],
+        [
+            'valid with moreActions.user',
+            { moreActions: { user: [validAction] } },
+            true,
+        ],
+        [
+            'invalid moreActions.client with bad openMethod',
+            {
+                moreActions: {
+                    client: [
+                        {
+                            icon: 'add',
+                            openMethod: 'bad_method',
+                            url: 'https://example.com/action',
+                        },
+                    ],
+                },
+            },
+            false,
+        ],
         // Menu and Settings valid combos
         ['valid menu with URL type', { menu: minimalValidMenuDtoWithUrl }, true],
-        ['valid menu with submenu type', { menu: minimalValidMenuDtoWithSubmenu }, true],
-        ['valid menu and settings URL', { menu: minimalValidMenuDtoWithUrl, settings: minimalValidSettingsWithUrlDto }, true],
-        ['valid menu and settings tabs', { menu: minimalValidMenuDtoWithSubmenu, settings: minimalValidSettingsWithTabsDto }, true],
+        [
+            'valid menu with submenu type',
+            { menu: minimalValidMenuDtoWithSubmenu },
+            true,
+        ],
+        [
+            'valid menu and settings URL',
+            {
+                menu: minimalValidMenuDtoWithUrl,
+                settings: minimalValidSettingsWithUrlDto,
+            },
+            true,
+        ],
+        [
+            'valid menu and settings tabs',
+            {
+                menu: minimalValidMenuDtoWithSubmenu,
+                settings: minimalValidSettingsWithTabsDto,
+            },
+            true,
+        ],
         // Invalid menu cases
-        ['invalid menu missing required fields', { menu: { type: 'only-url' } }, false],
-        ['invalid menu unknown type', { menu: { type: 'unknown', icon: 'https://icon.png', label: 'Label', url: 'https://example.com' } }, false],
-        ['invalid menu with extra property', { menu: { ...minimalValidMenuDtoWithUrl, extra: 'not allowed' } }, false],
-        ['invalid menu with submenu on URL menu', { menu: { ...minimalValidMenuDtoWithUrl, submenu: [{ url: 'https://example.com', label: 'Sub' }] } }, false],
+        [
+            'invalid menu missing required fields',
+            { menu: { type: 'only-url' } },
+            false,
+        ],
+        [
+            'invalid menu unknown type',
+            {
+                menu: {
+                    type: 'unknown',
+                    icon: 'https://icon.png',
+                    label: 'Label',
+                    url: 'https://example.com',
+                },
+            },
+            false,
+        ],
+        [
+            'invalid menu with extra property',
+            { menu: { ...minimalValidMenuDtoWithUrl, extra: 'not allowed' } },
+            false,
+        ],
+        [
+            'invalid menu with submenu on URL menu',
+            {
+                menu: {
+                    ...minimalValidMenuDtoWithUrl,
+                    submenu: [{ url: 'https://example.com', label: 'Sub' }],
+                },
+            },
+            false,
+        ],
         // Invalid tabs type
         ['invalid tabs not an object', { tabs: 'not-an-object' }, false],
         // Invalid extra property on root DTO
         ['invalid extra property on root', { extra: 'not allowed' }, false],
         // Settings validation edge cases
-        ['valid settings with SettingsWithUrlDto', { settings: minimalValidSettingsWithUrlDto }, true],
-        ['valid settings with SettingsWithTabsDto', { settings: minimalValidSettingsWithTabsDto }, true],
-        ['invalid settings missing required fields', { settings: { label: 'Missing url and tabs' } }, false],
-        ['invalid settings with extra property', { settings: { ...minimalValidSettingsWithUrlDto, extra: 'not allowed' } }, false],
-        ['invalid settings with both url and tabs', {
+        [
+            'valid settings with SettingsWithUrlDto',
+            { settings: minimalValidSettingsWithUrlDto },
+            true,
+        ],
+        [
+            'valid settings with SettingsWithTabsDto',
+            { settings: minimalValidSettingsWithTabsDto },
+            true,
+        ],
+        [
+            'invalid settings missing required fields',
+            { settings: { label: 'Missing url and tabs' } },
+            false,
+        ],
+        [
+            'invalid settings with extra property',
+            { settings: { ...minimalValidSettingsWithUrlDto, extra: 'not allowed' } },
+            false,
+        ],
+        [
+            'invalid settings with both url and tabs',
+            {
                 settings: {
                     url: 'https://example.com',
                     tabs: [{ label: 'Tab 1', url: 'https://example.com/tab1' }],
@@ -99,7 +229,9 @@ describe('AdminPanelDto full validation', () => {
                     icon: 'https://example.com/icon.png',
                     description: 'Should fail because both url and tabs are present',
                 },
-            }, false],
+            },
+            false,
+        ],
     ])('%s', async (_desc, input, expectedValid) => {
         const errors = await (0, admin_panel_validator_1.validateAdminPanelDto)(input);
         if (expectedValid) {

package/dist/validators/attachment-validator.spec.js

@@ -19,40 +19,40 @@ describe('AttachmentDto Validator', () => {
     describe('Missing required fields', () => {
         it('should return errors when all fields are missing', () => {
             const errors = (0, attachment_validator_1.validateAttachmentDto)({});
-            expect(errors.some(e => e.property === 'filename')).toBe(true);
-            expect(errors.some(e => e.property === 'content')).toBe(true);
+            expect(errors.some((e) => e.property === 'filename')).toBe(true);
+            expect(errors.some((e) => e.property === 'content')).toBe(true);
         });
         it('should return error when filename is missing', () => {
             const dto = { content: 'SGVsbG8=' };
             const errors = (0, attachment_validator_1.validateAttachmentDto)(dto);
-            expect(errors.some(e => e.property === 'filename')).toBe(true);
+            expect(errors.some((e) => e.property === 'filename')).toBe(true);
         });
         it('should return error when content is missing', () => {
             const dto = { filename: 'test.pdf' };
             const errors = (0, attachment_validator_1.validateAttachmentDto)(dto);
-            expect(errors.some(e => e.property === 'content')).toBe(true);
+            expect(errors.some((e) => e.property === 'content')).toBe(true);
         });
     });
     describe('Invalid field values', () => {
         it('should return error for empty filename', () => {
             const dto = { ...baseValidDto, filename: '' };
             const errors = (0, attachment_validator_1.validateAttachmentDto)(dto);
-            expect(errors.some(e => e.property === 'filename')).toBe(true);
+            expect(errors.some((e) => e.property === 'filename')).toBe(true);
         });
         it('should return error for empty content', () => {
             const dto = { ...baseValidDto, content: '' };
             const errors = (0, attachment_validator_1.validateAttachmentDto)(dto);
-            expect(errors.some(e => e.property === 'content')).toBe(true);
+            expect(errors.some((e) => e.property === 'content')).toBe(true);
         });
         it('should return error for non-base64 content', () => {
             const dto = { ...baseValidDto, content: 'not-valid-base64!!!' };
             const errors = (0, attachment_validator_1.validateAttachmentDto)(dto);
-            expect(errors.some(e => e.property === 'content')).toBe(true);
+            expect(errors.some((e) => e.property === 'content')).toBe(true);
         });
         it('should return error for non-string contentType', () => {
             const dto = { ...baseValidDto, contentType: 123 };
             const errors = (0, attachment_validator_1.validateAttachmentDto)(dto);
-            expect(errors.some(e => e.property === 'contentType')).toBe(true);
+            expect(errors.some((e) => e.property === 'contentType')).toBe(true);
         });
     });
 });

package/dist/validators/attribute-field-validator.spec.js

@@ -19,7 +19,11 @@ describe('AttributeFieldDto Validator', () => {
             expect((0, attribute_field_validator_1.validateAttributeFieldDto)(baseValidDto)).toHaveLength(0);
         });
         it('should return no errors with optional visibleInOrder and visibleInClientPanel', () => {
-            const dto = { ...baseValidDto, visibleInOrder: true, visibleInClientPanel: false };
+            const dto = {
+                ...baseValidDto,
+                visibleInOrder: true,
+                visibleInClientPanel: false,
+            };
             expect((0, attribute_field_validator_1.validateAttributeFieldDto)(dto)).toHaveLength(0);
         });
         it('should return no errors with both repeatableMin and repeatableMax', () => {
@@ -54,30 +58,37 @@ describe('AttributeFieldDto Validator', () => {
         it('should return error for non-boolean visibleInOrder', () => {
             const dto = { ...baseValidDto, visibleInOrder: 'yes' };
             const errors = (0, attribute_field_validator_1.validateAttributeFieldDto)(dto);
-            expect(errors.some(e => e.property === 'visibleInOrder')).toBe(true);
+            expect(errors.some((e) => e.property === 'visibleInOrder')).toBe(true);
         });
         it('should return error for non-boolean visibleInClientPanel', () => {
             const dto = { ...baseValidDto, visibleInClientPanel: 1 };
             const errors = (0, attribute_field_validator_1.validateAttributeFieldDto)(dto);
-            expect(errors.some(e => e.property === 'visibleInClientPanel')).toBe(true);
+            expect(errors.some((e) => e.property === 'visibleInClientPanel')).toBe(true);
         });
         it('should return error for non-number repeatableMin', () => {
             const dto = { ...baseValidDto, repeatableMin: 'one', repeatableMax: 5 };
             const errors = (0, attribute_field_validator_1.validateAttributeFieldDto)(dto);
-            expect(errors.some(e => e.property === 'repeatableMin')).toBe(true);
+            expect(errors.some((e) => e.property === 'repeatableMin')).toBe(true);
         });
         it('should return error for non-number repeatableMax', () => {
             const dto = { ...baseValidDto, repeatableMin: 1, repeatableMax: 'five' };
             const errors = (0, attribute_field_validator_1.validateAttributeFieldDto)(dto);
-            expect(errors.some(e => e.property === 'repeatableMax')).toBe(true);
+            expect(errors.some((e) => e.property === 'repeatableMax')).toBe(true);
         });
     });
     describe('Inherited FieldDto validation', () => {
         it('should return errors when inherited required fields are missing', () => {
             const errors = (0, attribute_field_validator_1.validateAttributeFieldDto)({});
-            const requiredProps = ['id', 'label', 'value', 'type', 'required', 'disabled'];
+            const requiredProps = [
+                'id',
+                'label',
+                'value',
+                'type',
+                'required',
+                'disabled',
+            ];
             for (const prop of requiredProps) {
-                expect(errors.some(e => e.property === prop)).toBe(true);
+                expect(errors.some((e) => e.property === prop)).toBe(true);
             }
         });
     });

package/dist/validators/client-panel-validator.spec.js

@@ -2,7 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
 const client_panel_validator_1 = require("./client-panel.validator"); // your validation function
-const validAction = { icon: 'add', openMethod: 'ajax_call', url: 'https://example.com/action' };
+const validAction = {
+    icon: 'add',
+    openMethod: 'ajax_call',
+    url: 'https://example.com/action',
+};
 const minimalValidMenuDtoWithUrl = {
     type: 'only-url',
     icon: 'https://example.com/icon.png',
@@ -25,18 +29,62 @@ describe('ClientPanelDto full validation', () => {
         // Tabs tests
         ['invalid empty tabs object', { tabs: {} }, false],
         ['invalid tabs with empty item array', { tabs: { item: [] } }, false],
-        ['valid tabs with one item', { tabs: { item: [{ label: 'Tab 1', url: 'https://example.com/tab1' }] } }, true],
+        [
+            'valid tabs with one item',
+            { tabs: { item: [{ label: 'Tab 1', url: 'https://example.com/tab1' }] } },
+            true,
+        ],
         // MoreActions tests
         ['invalid empty moreActions object', { moreActions: {} }, false],
-        ['invalid moreActions with empty item array', { moreActions: { item: [] } }, false],
-        ['valid moreActions with one item', { moreActions: { item: [validAction] } }, true],
+        [
+            'invalid moreActions with empty item array',
+            { moreActions: { item: [] } },
+            false,
+        ],
+        [
+            'valid moreActions with one item',
+            { moreActions: { item: [validAction] } },
+            true,
+        ],
         // Menu tests
         ['valid menu with URL type', { menu: minimalValidMenuDtoWithUrl }, true],
-        ['valid menu with submenu type', { menu: minimalValidMenuDtoWithSubmenu }, true],
-        ['invalid menu missing required fields', { menu: { type: 'only-url' } }, false],
-        ['invalid menu unknown type', { menu: { type: 'unknown', icon: 'https://icon.png', label: 'Label', url: 'https://example.com' } }, false],
-        ['invalid menu with extra property', { menu: { ...minimalValidMenuDtoWithUrl, extra: 'not allowed' } }, false],
-        ['invalid menu with submenu on URL menu', { menu: { ...minimalValidMenuDtoWithUrl, submenu: [{ url: 'https://example.com', label: 'Sub' }] } }, false],
+        [
+            'valid menu with submenu type',
+            { menu: minimalValidMenuDtoWithSubmenu },
+            true,
+        ],
+        [
+            'invalid menu missing required fields',
+            { menu: { type: 'only-url' } },
+            false,
+        ],
+        [
+            'invalid menu unknown type',
+            {
+                menu: {
+                    type: 'unknown',
+                    icon: 'https://icon.png',
+                    label: 'Label',
+                    url: 'https://example.com',
+                },
+            },
+            false,
+        ],
+        [
+            'invalid menu with extra property',
+            { menu: { ...minimalValidMenuDtoWithUrl, extra: 'not allowed' } },
+            false,
+        ],
+        [
+            'invalid menu with submenu on URL menu',
+            {
+                menu: {
+                    ...minimalValidMenuDtoWithUrl,
+                    submenu: [{ url: 'https://example.com', label: 'Sub' }],
+                },
+            },
+            false,
+        ],
         // Invalid extra property on root DTO
         ['invalid extra property on root', { extra: 'not allowed' }, false],
     ])('%s', async (_desc, input, expectedValid) => {

package/dist/validators/country-validator.spec.js

@@ -24,35 +24,35 @@ describe('CountryDto Validator', () => {
     describe('Missing required fields', () => {
         it('should return errors when all fields are missing', () => {
             const errors = (0, country_validator_1.validateCountryDto)({});
-            expect(errors.some(e => e.property === 'name')).toBe(true);
-            expect(errors.some(e => e.property === 'code')).toBe(true);
+            expect(errors.some((e) => e.property === 'name')).toBe(true);
+            expect(errors.some((e) => e.property === 'code')).toBe(true);
         });
         it('should return error when name is missing', () => {
             const dto = { code: country_enum_1.CountryEnum.GREECE };
             const errors = (0, country_validator_1.validateCountryDto)(dto);
-            expect(errors.some(e => e.property === 'name')).toBe(true);
+            expect(errors.some((e) => e.property === 'name')).toBe(true);
         });
         it('should return error when code is missing', () => {
             const dto = { name: 'Greece' };
             const errors = (0, country_validator_1.validateCountryDto)(dto);
-            expect(errors.some(e => e.property === 'code')).toBe(true);
+            expect(errors.some((e) => e.property === 'code')).toBe(true);
         });
     });
     describe('Invalid field values', () => {
         it('should return error for empty name', () => {
             const dto = { ...baseValidDto, name: '' };
             const errors = (0, country_validator_1.validateCountryDto)(dto);
-            expect(errors.some(e => e.property === 'name')).toBe(true);
+            expect(errors.some((e) => e.property === 'name')).toBe(true);
         });
         it('should return error for invalid country code', () => {
             const dto = { ...baseValidDto, code: 'INVALID' };
             const errors = (0, country_validator_1.validateCountryDto)(dto);
-            expect(errors.some(e => e.property === 'code')).toBe(true);
+            expect(errors.some((e) => e.property === 'code')).toBe(true);
         });
         it('should return error for non-boolean isEurope', () => {
             const dto = { ...baseValidDto, isEurope: 'yes' };
             const errors = (0, country_validator_1.validateCountryDto)(dto);
-            expect(errors.some(e => e.property === 'isEurope')).toBe(true);
+            expect(errors.some((e) => e.property === 'isEurope')).toBe(true);
         });
     });
 });