@hosterai/types 0.0.17 → 0.0.19

package/dist/transformers/menu.transformer.d.ts

@@ -0,0 +1,2 @@
+import { MenuDtoWithUrl, MenuDtoWithSubmenu, BaseMenuDto } from '../dtos/menu.dto';
+export declare function transformMenu(value: any): MenuDtoWithUrl | MenuDtoWithSubmenu | BaseMenuDto | undefined;

package/dist/transformers/menu.transformer.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformMenu = transformMenu;
+const class_transformer_1 = require("class-transformer");
+const menu_dto_1 = require("../dtos/menu.dto");
+function transformMenu(value) {
+    if (!value)
+        return undefined;
+    if (value.type === 'only-url') {
+        return (0, class_transformer_1.plainToInstance)(menu_dto_1.MenuDtoWithUrl, value);
+    }
+    else if (value.type === 'with-submenu') {
+        return (0, class_transformer_1.plainToInstance)(menu_dto_1.MenuDtoWithSubmenu, value);
+    }
+    return (0, class_transformer_1.plainToInstance)(menu_dto_1.BaseMenuDto, value);
+}

package/dist/transformers/settings.transformer.d.ts

@@ -0,0 +1 @@
+export declare function transformSettings(value: any): any;

package/dist/transformers/settings.transformer.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformSettings = transformSettings;
+const class_transformer_1 = require("class-transformer");
+const settings_dto_1 = require("../dtos/settings.dto");
+const settings_dto_2 = require("../dtos/settings.dto");
+function transformSettings(value) {
+    if (value === null || value === void 0 ? void 0 : value.tabs) {
+        return (0, class_transformer_1.plainToInstance)(settings_dto_2.SettingsWithTabsDto, value);
+    }
+    else if (value === null || value === void 0 ? void 0 : value.url) {
+        return (0, class_transformer_1.plainToInstance)(settings_dto_1.SettingsWithUrlDto, value);
+    }
+    return value;
+}

package/dist/validators/action-validator.spec.d.ts

@@ -0,0 +1 @@
+import 'reflect-metadata';

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const action_validator_1 = require("./action-validator");
+const open_method_enum_1 = require("../enums/open-method.enum");
+describe('ActionDto Validator', () => {
+    it('should return no errors for valid DTO', () => {
+        const validDto = {
+            icon: 'test-icon',
+            openMethod: open_method_enum_1.OpenMethodEnum.AJAX_CALL,
+            url: 'https://example.com',
+        };
+        const errors = (0, action_validator_1.validateActionDto)(validDto);
+        expect(errors).toHaveLength(0);
+    });
+    it('should return error for invalid URL', () => {
+        const invalidDto = {
+            icon: 'test-icon',
+            openMethod: open_method_enum_1.OpenMethodEnum.AJAX_CALL,
+            url: 'not-a-url',
+        };
+        const errors = (0, action_validator_1.validateActionDto)(invalidDto);
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors.some((e) => e.property === 'url')).toBe(true);
+    });
+    it('should return error for invalid openMethod', () => {
+        const invalidDto = {
+            icon: 'test-icon',
+            openMethod: 'not-an-enum',
+            url: 'http://example.com',
+        };
+        const errors = (0, action_validator_1.validateActionDto)(invalidDto);
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors.some((e) => e.property === 'openMethod')).toBe(true);
+    });
+    it('should return error for missing required fields', () => {
+        const invalidDto = {
+            // missing 'icon' and 'url'
+            openMethod: open_method_enum_1.OpenMethodEnum.AJAX_CALL
+        };
+        const errors = (0, action_validator_1.validateActionDto)(invalidDto);
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors.some((e) => e.property === 'icon')).toBe(true);
+        expect(errors.some((e) => e.property === 'url')).toBe(true);
+    });
+    it('should return error for invalid data types', () => {
+        const invalidDto = {
+            icon: 123, // should be a string
+            openMethod: open_method_enum_1.OpenMethodEnum.AJAX_CALL,
+            url: 456 // should be a string
+        };
+        const errors = (0, action_validator_1.validateActionDto)(invalidDto);
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors.some((e) => e.property === 'icon')).toBe(true);
+        expect(errors.some((e) => e.property === 'url')).toBe(true);
+    });
+    it('should handle unexpected fields gracefully', () => {
+        const validDto = {
+            icon: 'test-icon',
+            openMethod: open_method_enum_1.OpenMethodEnum.AJAX_CALL,
+            url: 'https://example.com',
+            unexpectedField: 'unexpected' // additional field
+        };
+        const errors = (0, action_validator_1.validateActionDto)(validDto);
+        expect(errors).toHaveLength(0);
+    });
+});

package/dist/validators/admin-panel-more-actions-validator.spec.d.ts

@@ -0,0 +1 @@
+import 'reflect-metadata';

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

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const class_validator_1 = require("class-validator");
+const action_dto_1 = require("../dtos/action.dto");
+const open_method_enum_1 = require("../enums/open-method.enum");
+const admin_panel_dto_1 = require("../dtos/admin-panel.dto");
+const admin_panel_more_actions_validator_1 = require("./admin-panel-more-actions.validator");
+const minimalValidActionDto = () => {
+    const action = new action_dto_1.ActionDto();
+    action.icon = 'add';
+    action.openMethod = open_method_enum_1.OpenMethodEnum.AJAX_CALL;
+    action.url = 'https://example.com/api';
+    return action;
+};
+describe('AdminPanelMoreActionsDto', () => {
+    it('fails when all keys are undefined', async () => {
+        const dto = new admin_panel_dto_1.AdminPanelMoreActionsDto();
+        const errors = await (0, class_validator_1.validate)(dto);
+        expect(errors.length).toBeGreaterThan(0);
+    });
+    it('fails when all keys are empty arrays', async () => {
+        const dto = new admin_panel_dto_1.AdminPanelMoreActionsDto();
+        dto.client = [];
+        dto.item = [];
+        dto.invoice = [];
+        dto.user = [];
+        dto.order = [];
+        const errors = await (0, class_validator_1.validate)(dto);
+        expect(errors.length).toBeGreaterThan(0);
+    });
+    it('passes when one key has a non-empty array', async () => {
+        const dto = new admin_panel_dto_1.AdminPanelMoreActionsDto();
+        dto.client = [minimalValidActionDto()];
+        const errors = await (0, class_validator_1.validate)(dto);
+        expect(errors.length).toBe(0);
+    });
+    it('passes when multiple keys have non-empty arrays', async () => {
+        const dto = new admin_panel_dto_1.AdminPanelMoreActionsDto();
+        dto.client = [minimalValidActionDto()];
+        dto.order = [minimalValidActionDto()];
+        const errors = await (0, class_validator_1.validate)(dto);
+        expect(errors.length).toBe(0);
+    });
+    it('fails when a key has a non-array non-object value', async () => {
+        const dto = new admin_panel_dto_1.AdminPanelMoreActionsDto();
+        // @ts-expect-error testing invalid value
+        dto.client = 'invalid';
+        const errors = await (0, class_validator_1.validate)(dto);
+        expect(errors.length).toBeGreaterThan(0);
+    });
+    it('passes when nested ActionDto is valid', async () => {
+        const dto = new admin_panel_dto_1.AdminPanelMoreActionsDto();
+        dto.client = [minimalValidActionDto()];
+        const errors = await (0, class_validator_1.validate)(dto);
+        expect(errors.length).toBe(0);
+    });
+    it('fails when nested ActionDto is invalid', async () => {
+        const dto = new admin_panel_dto_1.AdminPanelMoreActionsDto();
+        const invalidAction = minimalValidActionDto();
+        // @ts-expect-error testing invalid value
+        invalidAction.url = 123; // should be a string
+        dto.client = [invalidAction];
+        const errors = await (0, class_validator_1.validate)(dto);
+        expect(errors.length).toBeGreaterThan(0);
+    });
+    it('handles unexpected keys gracefully', async () => {
+        const dto = new admin_panel_dto_1.AdminPanelMoreActionsDto();
+        dto.client = [minimalValidActionDto()];
+        // @ts-expect-error testing unexpected key
+        dto.unexpectedKey = 'unexpected';
+        const errors = await (0, class_validator_1.validate)(dto);
+        expect(errors.length).toBe(0);
+    });
+    it('fails when input object cannot be converted', async () => {
+        const invalidData = {
+            client: 'not-an-object',
+        };
+        const errors = (0, admin_panel_more_actions_validator_1.validateAdminPanelMoreActionsDto)(invalidData);
+        expect(errors.length).toBeGreaterThan(0);
+    });
+    it('validates complex nested structures', async () => {
+        const complexData = {
+            client: [{
+                    icon: 'add',
+                    openMethod: open_method_enum_1.OpenMethodEnum.AJAX_CALL,
+                    url: 'https://example.com/api',
+                    nested: [{
+                            icon: 'nested-icon',
+                            openMethod: open_method_enum_1.OpenMethodEnum.AJAX_CALL,
+                            url: 'https://example.com/nested'
+                        }]
+                }]
+        };
+        const errors = (0, admin_panel_more_actions_validator_1.validateAdminPanelMoreActionsDto)(complexData);
+        expect(errors.length).toBe(0);
+    });
+    it('handles edge cases with empty objects', async () => {
+        const emptyData = {};
+        const errors = (0, admin_panel_more_actions_validator_1.validateAdminPanelMoreActionsDto)(emptyData);
+        expect(errors.length).toBeGreaterThan(0);
+    });
+    it('fails when all properties are empty arrays', async () => {
+        const data = {
+            client: [],
+            item: [],
+            invoice: [],
+            user: [],
+            order: []
+        };
+        const errors = (0, admin_panel_more_actions_validator_1.validateAdminPanelMoreActionsDto)(data);
+        expect(errors.length).toBeGreaterThan(0);
+    });
+    it('passes with one non-empty property', async () => {
+        const data = {
+            client: [minimalValidActionDto()]
+        };
+        const errors = (0, admin_panel_more_actions_validator_1.validateAdminPanelMoreActionsDto)(data);
+        expect(errors.length).toBe(0);
+    });
+    it('passes with multiple non-empty properties', async () => {
+        const data = {
+            client: [minimalValidActionDto()],
+            item: [minimalValidActionDto()]
+        };
+        const errors = (0, admin_panel_more_actions_validator_1.validateAdminPanelMoreActionsDto)(data);
+        expect(errors.length).toBe(0);
+    });
+});

package/dist/validators/admin-panel-more-actions.validator.d.ts

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

package/dist/validators/admin-panel-more-actions.validator.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAdminPanelMoreActionsDto = validateAdminPanelMoreActionsDto;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const admin_panel_dto_1 = require("../dtos/admin-panel.dto");
+function validateAdminPanelMoreActionsDto(data) {
+    const dto = (0, class_transformer_1.plainToInstance)(admin_panel_dto_1.AdminPanelMoreActionsDto, data);
+    const errors = (0, class_validator_1.validateSync)(dto);
+    return errors;
+}

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

@@ -0,0 +1 @@
+import 'reflect-metadata';

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const class_validator_1 = require("class-validator");
+const class_transformer_1 = require("class-transformer");
+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 cases = [
+        [{ product: [], item: [], client: [], user: [], order: [] }, false], // all empty => invalid
+        [{ 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],
+    ];
+    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
+    ];
+    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 hasClassLevelError = classLevelError !== undefined;
+        if (valid) {
+            expect(errors.length).toBe(0);
+        }
+        else {
+            expect(errors.length).toBeGreaterThan(0);
+            if (hasClassLevelError) {
+                expect(classLevelError.constraints).toHaveProperty('AtLeastOneNonEmpty');
+            }
+        }
+    });
+});

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

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

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAdminPanelTabsDto = validateAdminPanelTabsDto;
+const class_transformer_1 = require("class-transformer");
+const admin_panel_dto_1 = require("../dtos/admin-panel.dto");
+const class_validator_1 = require("class-validator");
+function validateAdminPanelTabsDto(data) {
+    const dto = (0, class_transformer_1.plainToInstance)(admin_panel_dto_1.AdminPanelTabsDto, data);
+    const errors = (0, class_validator_1.validateSync)(dto);
+    return errors;
+}

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

@@ -0,0 +1 @@
+import 'reflect-metadata';

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

@@ -0,0 +1,112 @@
+"use strict";
+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 minimalValidMenuDtoWithUrl = {
+    type: 'only-url',
+    icon: 'https://example.com/icon.png',
+    label: 'Main Menu',
+    url: 'https://example.com/menu',
+};
+const minimalValidMenuDtoWithSubmenu = {
+    type: 'with-submenu',
+    icon: 'https://example.com/icon.png',
+    label: 'Main Menu',
+    submenu: [
+        { url: 'https://example.com/sub1', label: 'Submenu 1' },
+        { url: 'https://example.com/sub2', label: 'Submenu 2' },
+    ],
+};
+const minimalValidSettingsWithUrlDto = {
+    url: 'https://settings.com',
+    label: 'Settings',
+    icon: 'https://example.com/icon.png',
+    description: 'Settings description',
+};
+const minimalValidSettingsWithTabsDto = {
+    tabs: [
+        {
+            label: 'Tab 1',
+            url: 'https://example.com/tab1',
+        },
+    ],
+    label: 'Settings',
+    icon: 'https://example.com/icon.png',
+    description: 'Settings description',
+};
+describe('AdminPanelDto full validation', () => {
+    test.each([
+        // Empty object is invalid
+        ['valid minimal empty object', {}, false],
+        // Tabs tests
+        ['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', {
+                tabs: {
+                    product: [{ label: 'Product', url: 'https://example.com/product' }],
+                    item: [{ label: 'Item', url: 'https://example.com/item' }],
+                    client: [],
+                    user: [],
+                    order: [],
+                },
+            }, 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],
+        // 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],
+        // 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],
+        // 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 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', {
+                settings: {
+                    url: 'https://example.com',
+                    tabs: [{ label: 'Tab 1', url: 'https://example.com/tab1' }],
+                    label: 'Invalid Union',
+                    icon: 'https://example.com/icon.png',
+                    description: 'Should fail because both url and tabs are present',
+                },
+            }, false],
+    ])('%s', async (_desc, input, expectedValid) => {
+        const errors = await (0, admin_panel_validator_1.validateAdminPanelDto)(input);
+        if (expectedValid) {
+            expect(errors.length).toBe(0);
+        }
+        else {
+            expect(errors.length).toBeGreaterThan(0);
+        }
+    });
+});

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

@@ -0,0 +1,2 @@
+import { ValidationError } from 'class-validator';
+export declare function validateAdminPanelDto(data: object): Promise<ValidationError[]>;

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAdminPanelDto = validateAdminPanelDto;
+const class_validator_1 = require("class-validator");
+const class_transformer_1 = require("class-transformer");
+const admin_panel_dto_1 = require("../dtos/admin-panel.dto");
+async function validateAdminPanelDto(data) {
+    const dto = (0, class_transformer_1.plainToInstance)(admin_panel_dto_1.AdminPanelDto, data);
+    const errors = await (0, class_validator_1.validate)(dto, {
+        whitelist: true, // strips unknown props
+        forbidNonWhitelisted: true, // throws error if unknown props present
+    });
+    return errors;
+}

package/dist/validators/client-data-validator.spec.d.ts

@@ -0,0 +1 @@
+import 'reflect-metadata';

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const client_data_validator_1 = require("./client-data-validator");
+const country_enum_1 = require("../enums/country.enum");
+describe('validateClientDataDto', () => {
+    it('should return no errors for a valid client data object', async () => {
+        const validClientData = {
+            email: 'test@example.com',
+            firstName: 'John',
+            lastName: 'Doe',
+            telephone: '+14155552671',
+            address1: '123 Main St',
+            postcode: '12345',
+            city: 'Anytown',
+            country: country_enum_1.CountryEnum.UNITED_STATES,
+        };
+        const errors = await (0, client_data_validator_1.validateClientDataDto)(validClientData);
+        expect(errors.length).toBe(0);
+    });
+    it('should return errors for an invalid client data object', async () => {
+        const invalidClientData = {
+            email: 'not-an-email',
+            firstName: '', // empty
+            lastName: 'Doe',
+            telephone: '123', // invalid
+            address1: '123 Main St',
+            postcode: '12345',
+            city: 'Anytown',
+            country: 'invalid-country',
+        };
+        const errors = await (0, client_data_validator_1.validateClientDataDto)(invalidClientData);
+        expect(errors.length).toBeGreaterThan(0);
+    });
+});

package/dist/validators/client-panel-validator.spec.d.ts

@@ -0,0 +1 @@
+import 'reflect-metadata';

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

@@ -0,0 +1,51 @@
+"use strict";
+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 minimalValidMenuDtoWithUrl = {
+    type: 'only-url',
+    icon: 'https://example.com/icon.png',
+    label: 'Client Menu',
+    url: 'https://example.com/menu',
+};
+const minimalValidMenuDtoWithSubmenu = {
+    type: 'with-submenu',
+    icon: 'https://example.com/icon.png',
+    label: 'Client Menu',
+    submenu: [
+        { url: 'https://example.com/sub1', label: 'Submenu 1' },
+        { url: 'https://example.com/sub2', label: 'Submenu 2' },
+    ],
+};
+describe('ClientPanelDto full validation', () => {
+    test.each([
+        // Empty object is invalid (all optional)
+        ['invalid minimal empty object', {}, false],
+        // 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],
+        // 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],
+        // 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],
+        // Invalid extra property on root DTO
+        ['invalid extra property on root', { extra: 'not allowed' }, false],
+    ])('%s', async (_desc, input, expectedValid) => {
+        const errors = await (0, client_panel_validator_1.validateClientPanelDto)(input);
+        if (expectedValid) {
+            expect(errors.length).toBe(0);
+        }
+        else {
+            expect(errors.length).toBeGreaterThan(0);
+        }
+    });
+});

package/dist/validators/client-panel.validator.d.ts

@@ -0,0 +1,2 @@
+import { ValidationError } from 'class-validator';
+export declare function validateClientPanelDto(data: object): Promise<ValidationError[]>;

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateClientPanelDto = validateClientPanelDto;
+const class_validator_1 = require("class-validator");
+const class_transformer_1 = require("class-transformer");
+const client_panel_dto_1 = require("../dtos/client-panel.dto");
+async function validateClientPanelDto(data) {
+    const dto = (0, class_transformer_1.plainToInstance)(client_panel_dto_1.ClientPanelDto, data);
+    const errors = await (0, class_validator_1.validate)(dto, {
+        whitelist: true,
+        forbidNonWhitelisted: true,
+    });
+    return errors;
+}

package/dist/validators/company-data-validator.spec.d.ts

@@ -0,0 +1 @@
+import 'reflect-metadata';

package/dist/validators/company-data-validator.spec.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const company_data_validator_1 = require("./company-data-validator");
+const country_enum_1 = require("../enums/country.enum");
+const language_enum_1 = require("../enums/language.enum");
+describe('CompanyDataDto Validator', () => {
+    it('should return no errors for valid DTO', () => {
+        const validDto = {
+            id: '123',
+            name: 'Test Company',
+            emails: ['test@example.com'],
+            invoiceEmail: 'invoice@example.com',
+            privacyPolicyUrl: 'https://example.com/privacy',
+            defaultLanguage: language_enum_1.LanguageEnum.EN,
+            languages: [language_enum_1.LanguageEnum.EN, language_enum_1.LanguageEnum.FR],
+            telephone: '+12133734253',
+            address1: '123 Main St',
+            postcode: '12345',
+            city: 'Test City',
+            country: country_enum_1.CountryEnum.UNITED_STATES,
+        };
+        const errors = (0, company_data_validator_1.validateCompanyDataDto)(validDto);
+        expect(errors).toHaveLength(0);
+    });
+    it('should return error when required fields are missing', () => {
+        const invalidDto = {
+        // Missing required fields
+        };
+        const errors = (0, company_data_validator_1.validateCompanyDataDto)(invalidDto);
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors.some((e) => e.property === 'id')).toBe(true);
+        expect(errors.some((e) => e.property === 'name')).toBe(true);
+    });
+    it('should return error for invalid email format', () => {
+        const invalidDto = {
+            id: '123',
+            name: 'Test Company',
+            emails: ['not-an-email'],
+            invoiceEmail: 'invoice@example.com',
+            privacyPolicyUrl: 'http://example.com/privacy',
+            defaultLanguage: language_enum_1.LanguageEnum.EN,
+            languages: [language_enum_1.LanguageEnum.EN, language_enum_1.LanguageEnum.FR],
+            telephone: '+12133734253',
+            address1: '123 Main St',
+            postcode: '12345',
+            city: 'Test City',
+            country: country_enum_1.CountryEnum.UNITED_STATES,
+        };
+        const errors = (0, company_data_validator_1.validateCompanyDataDto)(invalidDto);
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors.some((e) => e.property === 'emails')).toBe(true);
+    });
+    it('should return error for invalid URL format', () => {
+        const invalidDto = {
+            id: '123',
+            name: 'Test Company',
+            emails: ['test@example.com'],
+            invoiceEmail: 'invoice@example.com',
+            privacyPolicyUrl: 'not-a-url',
+            defaultLanguage: language_enum_1.LanguageEnum.EN,
+            languages: [language_enum_1.LanguageEnum.EN, language_enum_1.LanguageEnum.FR],
+            telephone: '+12133734253',
+            address1: '123 Main St',
+            postcode: '12345',
+            city: 'Test City',
+            country: country_enum_1.CountryEnum.UNITED_STATES,
+        };
+        const errors = (0, company_data_validator_1.validateCompanyDataDto)(invalidDto);
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors.some((e) => e.property === 'privacyPolicyUrl')).toBe(true);
+    });
+});