@hosterai/types 0.0.16 → 0.0.18

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

package/dist/validators/field-option-validator.spec.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const field_option_validator_1 = require("./field-option.validator");
+describe('validateFieldOptionDto', () => {
+    test.each([
+        // valid
+        [{ key: 'option1', value: 'Option 1' }, true],
+        [{ key: 'option2', value: 'Option 2', disabled: true }, true],
+        [{ key: 'option3', value: 'Option 3', disabled: false }, true],
+        // missing required
+        [{ value: 'Missing key' }, false],
+        [{ key: 'missingValue' }, false],
+        // wrong types
+        [{ key: 123, value: 'Valid string' }, false],
+        [{ key: 'validKey', value: 456 }, false],
+        [{ key: 'key', value: 'value', disabled: 'yes' }, false],
+        // disabled optional omitted
+        [{ key: 'noDisabled', value: 'Yes' }, true],
+    ])('validates %# - %# %#', (input, expectedValid) => {
+        const errors = (0, field_option_validator_1.validateFieldOptionDto)(input);
+        if (expectedValid) {
+            expect(errors.length).toBe(0);
+        }
+        else {
+            expect(errors.length).toBeGreaterThan(0);
+        }
+    });
+});

package/dist/validators/field-option.validator.d.ts

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

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

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

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

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

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

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const field_validator_1 = require("./field-validator");
+const field_type_enum_1 = require("../enums/field-type.enum");
+const language_enum_1 = require("../enums/language.enum");
+const baseValidDto = {
+    id: 'test-id',
+    label: [{ language: language_enum_1.LanguageEnum.EN, text: 'Test Label' }],
+    value: 'test-value',
+    type: field_type_enum_1.FieldTypeEnum.TEXT_BOX,
+    required: true,
+    disabled: false,
+    hidden: false,
+    upgradable: false,
+};
+describe('FieldDto Validator', () => {
+    describe('Valid cases', () => {
+        it('should return no errors for a valid DTO', () => {
+            expect((0, field_validator_1.validateFieldDto)(baseValidDto)).toHaveLength(0);
+        });
+        it('should return no errors for a valid DTO with optional error messages', () => {
+            const dto = {
+                ...baseValidDto,
+                regexValidationErrorMessage: [{ language: language_enum_1.LanguageEnum.EN, text: 'Invalid format' }],
+                remoteValidationErrorMessage: [{ language: language_enum_1.LanguageEnum.EN, text: 'Invalid value' }],
+            };
+            expect((0, field_validator_1.validateFieldDto)(dto)).toHaveLength(0);
+        });
+    });
+    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', 'hidden'];
+            for (const prop of requiredProps) {
+                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);
+        });
+    });
+    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'],
+        ])('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);
+        });
+    });
+    describe('Invalid `value` field', () => {
+        it.each([
+            [true, 'boolean'],
+            [null, 'null'],
+            [undefined, 'undefined'],
+            [{}, 'object'],
+            [[], 'array'],
+        ])('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);
+        });
+        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);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+require("reflect-metadata");
+const jwt_validator_1 = require("./jwt-validator");
+const roles_enum_1 = require("../enums/roles.enum");
+describe('JwtDto Validator', () => {
+    it('should return no errors for valid DTO', () => {
+        const validDto = {
+            jwt: {
+                integrationId: '123',
+                companyId: '456',
+                acceptedRoles: [roles_enum_1.RolesEnum.FULL_ACCESS],
+            },
+        };
+        const errors = (0, jwt_validator_1.validateJwtDto)(validDto);
+        expect(errors).toHaveLength(0);
+    });
+    it('should return error when nested jwt object is missing', () => {
+        const invalidDto = {
+        // Missing jwt object
+        };
+        const errors = (0, jwt_validator_1.validateJwtDto)(invalidDto);
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors.some((e) => e.property === 'jwt')).toBe(true);
+    });
+    it('should return error when required fields in jwt are missing', () => {
+        var _a;
+        const invalidDto = {
+            jwt: {
+                // Missing integrationId and companyId
+                acceptedRoles: [roles_enum_1.RolesEnum.FULL_ACCESS],
+            },
+        };
+        const errors = (0, jwt_validator_1.validateJwtDto)(invalidDto);
+        expect(errors.length).toBeGreaterThan(0);
+        // As the validation is on the nested object, the error will be in the children
+        const jwtErrors = (_a = errors[0]) === null || _a === void 0 ? void 0 : _a.children;
+        expect(jwtErrors).toBeDefined();
+        expect(jwtErrors.some((e) => e.property === 'integrationId')).toBe(true);
+        expect(jwtErrors.some((e) => e.property === 'companyId')).toBe(true);
+    });
+});

package/dist/validators/menu-with-submenu-validator.spec.d.ts

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

package/dist/validators/menu-with-submenu-validator.spec.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const menu_with_submenu_validator_1 = require("./menu-with-submenu.validator");
+describe('validateMenuDto', () => {
+    test.each([
+        ['valid data with submenu',
+            {
+                type: 'with-submenu',
+                icon: 'https://example.com/icon.png',
+                label: 'Menu Label',
+                submenu: [
+                    { label: 'Submenu 1', url: 'https://example.com/sub1' }
+                ],
+            },
+            true
+        ],
+        ['missing required icon',
+            {
+                type: 'with-submenu',
+                label: 'Menu Label',
+                submenu: [{ label: 'Submenu 1', url: 'https://example.com/sub1' }],
+            },
+            false
+        ],
+        ['missing submenu',
+            {
+                type: 'with-submenu',
+                icon: 'https://example.com/icon.png',
+                label: 'Menu Label',
+            },
+            false
+        ],
+        ['submenu with missing label',
+            {
+                type: 'with-submenu',
+                icon: 'https://example.com/icon.png',
+                label: 'Menu Label',
+                submenu: [{ url: 'https://example.com/sub1' }],
+            },
+            false
+        ],
+    ])('%s', (_, input, expectedValid) => {
+        const errors = (0, menu_with_submenu_validator_1.validateMenuWithSubmenuDto)(input);
+        if (expectedValid) {
+            expect(errors.length).toBe(0);
+        }
+        else {
+            expect(errors.length).toBeGreaterThan(0);
+        }
+    });
+});

package/dist/validators/menu-with-submenu.validator.d.ts

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

package/dist/validators/menu-with-submenu.validator.js

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

package/dist/validators/menu-with-url-validator.spec.d.ts

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

package/dist/validators/menu-with-url-validator.spec.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const menu_with_url_validator_1 = require("./menu-with-url.validator");
+describe('validateMenuWithUrlDto', () => {
+    it('passes with valid minimal object', () => {
+        const data = {
+            type: 'only-url',
+            icon: 'https://example.com/icon.png',
+            label: 'Dashboard',
+            url: 'https://example.com/page',
+        };
+        const errors = (0, menu_with_url_validator_1.validateMenuWithUrlDto)(data);
+        expect(errors.length).toBe(0);
+    });
+    it('fails if type is incorrect', () => {
+        const data = {
+            type: 'invalid-type',
+            icon: 'https://example.com/icon.png',
+            label: 'Dashboard',
+            url: 'https://example.com/page',
+        };
+        const errors = (0, menu_with_url_validator_1.validateMenuWithUrlDto)(data);
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors.some(e => { var _a; return (_a = e.constraints) === null || _a === void 0 ? void 0 : _a.isIn; })).toBe(true);
+    });
+    it('fails if icon is not a string', () => {
+        const data = {
+            type: 'only-url',
+            icon: 12345, // not a string
+            label: 'Dashboard',
+            url: 'https://example.com/page',
+        };
+        const errors = (0, menu_with_url_validator_1.validateMenuWithUrlDto)(data);
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors.some(e => { var _a; return (_a = e.constraints) === null || _a === void 0 ? void 0 : _a.isString; })).toBe(true);
+    });
+    it('fails if label is missing', () => {
+        const data = {
+            type: 'only-url',
+            icon: 'https://example.com/icon.png',
+            url: 'https://example.com/page',
+        };
+        const errors = (0, menu_with_url_validator_1.validateMenuWithUrlDto)(data);
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors.some(e => { var _a; return (_a = e.constraints) === null || _a === void 0 ? void 0 : _a.isNotEmpty; })).toBe(true);
+    });
+    it('fails if url is missing or invalid', () => {
+        const invalids = [
+            { type: 'only-url', icon: 12345, label: 'Dashboard' }, // icon not a string
+            { type: 'only-url', icon: 'https://example.com/icon.png', label: 'Dashboard', url: 'invalid-url' },
+        ];
+        for (const data of invalids) {
+            const errors = (0, menu_with_url_validator_1.validateMenuWithUrlDto)(data);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors.some(e => { var _a, _b, _c; return ((_a = e.constraints) === null || _a === void 0 ? void 0 : _a.isUrl) || ((_b = e.constraints) === null || _b === void 0 ? void 0 : _b.isString) || ((_c = e.constraints) === null || _c === void 0 ? void 0 : _c.isDefined); })).toBe(true);
+        }
+    });
+    it('fails if submenu is present', () => {
+        const data = {
+            type: 'only-url',
+            icon: 'https://example.com/icon.png',
+            label: 'Dashboard',
+            url: 'https://example.com/page',
+            submenu: [],
+        };
+        const errors = (0, menu_with_url_validator_1.validateMenuWithUrlDto)(data);
+        expect(errors.length).toBeGreaterThan(0);
+    });
+});

package/dist/validators/menu-with-url.validator.d.ts

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

package/dist/validators/menu-with-url.validator.js

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

package/dist/validators/multilang-text-validator.spec.d.ts

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

package/dist/validators/multilang-text-validator.spec.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const multilang_text_validator_1 = require("./multilang-text-validator");
+const language_enum_1 = require("../enums/language.enum");
+describe('MultilangTextDto Validator', () => {
+    it('should return no errors for valid DTO', () => {
+        const validDto = {
+            language: language_enum_1.LanguageEnum.EN,
+            text: 'Hello World',
+        };
+        const errors = (0, multilang_text_validator_1.validateMultilangTextDto)(validDto);
+        expect(errors).toHaveLength(0);
+    });
+    it('should return error for invalid language', () => {
+        const invalidDto = {
+            language: 'not-a-language',
+            text: 'Hello World',
+        };
+        const errors = (0, multilang_text_validator_1.validateMultilangTextDto)(invalidDto);
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors.some((e) => e.property === 'language')).toBe(true);
+    });
+    it('should return error for missing text', () => {
+        const invalidDto = {
+            language: language_enum_1.LanguageEnum.EN,
+            // Missing text
+        };
+        const errors = (0, multilang_text_validator_1.validateMultilangTextDto)(invalidDto);
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors.some((e) => e.property === 'text')).toBe(true);
+    });
+});

package/dist/validators/notification-info-validator.spec.d.ts

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