@hosterai/types 0.0.28 → 0.0.30

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);
         });
     });
 });

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

@@ -21,8 +21,12 @@ describe('FieldDto Validator', () => {
         it('should return no errors for a valid DTO with optional error messages', () => {
             const dto = {
                 ...baseValidDto,
-                regexValidationErrorMessage: [{ language: language_enum_1.LanguageEnum.ENGLISH, text: 'Invalid format' }],
-                remoteValidationErrorMessage: [{ language: language_enum_1.LanguageEnum.ENGLISH, text: 'Invalid value' }],
+                regexValidationErrorMessage: [
+                    { language: language_enum_1.LanguageEnum.ENGLISH, text: 'Invalid format' },
+                ],
+                remoteValidationErrorMessage: [
+                    { language: language_enum_1.LanguageEnum.ENGLISH, text: 'Invalid value' },
+                ],
             };
             expect((0, field_validator_1.validateFieldDto)(dto)).toHaveLength(0);
         });
@@ -30,28 +34,49 @@ describe('FieldDto Validator', () => {
     describe('Missing required fields', () => {
         it('should return errors for all missing required fields (except upgradable)', () => {
             const errors = (0, field_validator_1.validateFieldDto)({});
-            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);
             }
         });
         it('should return error if value is missing', () => {
             const dto = { ...baseValidDto };
             delete dto.value;
             const errors = (0, field_validator_1.validateFieldDto)(dto);
-            expect(errors.some(e => e.property === 'value')).toBe(true);
+            expect(errors.some((e) => e.property === 'value')).toBe(true);
         });
     });
     describe('Invalid field values', () => {
         it.each([
             [{ ...baseValidDto, type: 'not-a-valid-type' }, 'type'],
             [{}, 'id'],
-            [{ ...baseValidDto, regexValidation: 'regex', regexValidationErrorMessage: 'not-an-array' }, 'regexValidationErrorMessage'],
-            [{ ...baseValidDto, triggersRemoteValidation: true, remoteValidationErrorMessage: 'not-an-array' }, 'remoteValidationErrorMessage'],
+            [
+                {
+                    ...baseValidDto,
+                    regexValidation: 'regex',
+                    regexValidationErrorMessage: 'not-an-array',
+                },
+                'regexValidationErrorMessage',
+            ],
+            [
+                {
+                    ...baseValidDto,
+                    triggersRemoteValidation: true,
+                    remoteValidationErrorMessage: 'not-an-array',
+                },
+                'remoteValidationErrorMessage',
+            ],
         ])('should return error for invalid %s', (dto, expectedProp) => {
             const errors = (0, field_validator_1.validateFieldDto)(dto);
             expect(errors.length).toBeGreaterThan(0);
-            expect(errors.some(e => e.property === expectedProp)).toBe(true);
+            expect(errors.some((e) => e.property === expectedProp)).toBe(true);
         });
     });
     describe('Invalid `value` field', () => {
@@ -64,12 +89,12 @@ describe('FieldDto Validator', () => {
         ])('should return error if value is invalid type (%s)', (invalidValue, _label) => {
             const dto = { ...baseValidDto, value: invalidValue };
             const errors = (0, field_validator_1.validateFieldDto)(dto);
-            expect(errors.some(e => e.property === 'value')).toBe(true);
+            expect(errors.some((e) => e.property === 'value')).toBe(true);
         });
         it('should return error if value is empty string when required', () => {
             const dto = { ...baseValidDto, value: '' };
             const errors = (0, field_validator_1.validateFieldDto)(dto);
-            expect(errors.some(e => e.property === 'value')).toBe(true);
+            expect(errors.some((e) => e.property === 'value')).toBe(true);
         });
     });
 });

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

@@ -36,50 +36,50 @@ describe('InfoDto Validator', () => {
     describe('Missing required fields', () => {
         it('should return errors when all fields are missing', () => {
             const errors = (0, info_validator_1.validateInfoDto)({});
-            expect(errors.some(e => e.property === 'title')).toBe(true);
-            expect(errors.some(e => e.property === 'supportedLanguages')).toBe(true);
+            expect(errors.some((e) => e.property === 'title')).toBe(true);
+            expect(errors.some((e) => e.property === 'supportedLanguages')).toBe(true);
         });
         it('should return error when title is missing', () => {
             const { title, ...dto } = baseValidDto;
             const errors = (0, info_validator_1.validateInfoDto)(dto);
-            expect(errors.some(e => e.property === 'title')).toBe(true);
+            expect(errors.some((e) => e.property === 'title')).toBe(true);
         });
         it('should return error when supportedLanguages is missing', () => {
             const { supportedLanguages, ...dto } = baseValidDto;
             const errors = (0, info_validator_1.validateInfoDto)(dto);
-            expect(errors.some(e => e.property === 'supportedLanguages')).toBe(true);
+            expect(errors.some((e) => e.property === 'supportedLanguages')).toBe(true);
         });
     });
     describe('Invalid field values', () => {
         it('should return error for empty title', () => {
             const dto = { ...baseValidDto, title: '' };
             const errors = (0, info_validator_1.validateInfoDto)(dto);
-            expect(errors.some(e => e.property === 'title')).toBe(true);
+            expect(errors.some((e) => e.property === 'title')).toBe(true);
         });
         it('should return error for empty supportedLanguages array', () => {
             const dto = { ...baseValidDto, supportedLanguages: [] };
             const errors = (0, info_validator_1.validateInfoDto)(dto);
-            expect(errors.some(e => e.property === 'supportedLanguages')).toBe(true);
+            expect(errors.some((e) => e.property === 'supportedLanguages')).toBe(true);
         });
         it('should return error for invalid language enum', () => {
             const dto = { ...baseValidDto, supportedLanguages: ['INVALID'] };
             const errors = (0, info_validator_1.validateInfoDto)(dto);
-            expect(errors.some(e => e.property === 'supportedLanguages')).toBe(true);
+            expect(errors.some((e) => e.property === 'supportedLanguages')).toBe(true);
         });
         it('should return error for invalid logo URL (not https)', () => {
             const dto = { ...baseValidDto, logo: 'http://example.com/logo.png' };
             const errors = (0, info_validator_1.validateInfoDto)(dto);
-            expect(errors.some(e => e.property === 'logo')).toBe(true);
+            expect(errors.some((e) => e.property === 'logo')).toBe(true);
         });
         it('should return error for invalid logo URL (not a URL)', () => {
             const dto = { ...baseValidDto, logo: 'not-a-url' };
             const errors = (0, info_validator_1.validateInfoDto)(dto);
-            expect(errors.some(e => e.property === 'logo')).toBe(true);
+            expect(errors.some((e) => e.property === 'logo')).toBe(true);
         });
         it('should return error for invalid onboardingUrl', () => {
             const dto = { ...baseValidDto, onboardingUrl: 'not-a-url' };
             const errors = (0, info_validator_1.validateInfoDto)(dto);
-            expect(errors.some(e => e.property === 'onboardingUrl')).toBe(true);
+            expect(errors.some((e) => e.property === 'onboardingUrl')).toBe(true);
         });
     });
 });