@hosterai/types 0.0.17 → 0.0.19

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,102 @@
+"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);
+        });
+    });
+    describe('Repeatable constraints (AllOrNone and Min<=Max)', () => {
+        it('should fail when only reapetableMin is present', () => {
+            const dto = { ...baseValidDto, reapetableMin: 1 };
+            const errors = (0, field_validator_1.validateFieldDto)(dto);
+            expect(errors.length).toBeGreaterThan(0);
+            // Class-level error; ensure at least one constraint exists
+            expect(errors.some(e => e.constraints && (e.constraints['AllOrNone'] || Object.values(e.constraints).some(msg => msg.includes('All of'))))).toBe(true);
+        });
+        it('should fail when only reapetableMax is present', () => {
+            const dto = { ...baseValidDto, reapetableMax: 2 };
+            const errors = (0, field_validator_1.validateFieldDto)(dto);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors.some(e => e.constraints && (e.constraints['AllOrNone'] || Object.values(e.constraints).some(msg => msg.includes('All of'))))).toBe(true);
+        });
+        it('should pass when both present and reapetableMin <= reapetableMax', () => {
+            const dto = { ...baseValidDto, reapetableMin: 1, reapetableMax: 2 };
+            const errors = (0, field_validator_1.validateFieldDto)(dto);
+            expect(errors).toHaveLength(0);
+        });
+        it('should fail when both present and reapetableMin > reapetableMax', () => {
+            const dto = { ...baseValidDto, reapetableMin: 3, reapetableMax: 2 };
+            const errors = (0, field_validator_1.validateFieldDto)(dto);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors.some(e => e.constraints && (e.constraints['MinLessOrEqualMax'] || Object.values(e.constraints).some(msg => msg.includes('must be less than or equal'))))).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';

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

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const notification_info_validator_1 = require("./notification-info.validator");
+const notification_message_type_enum_1 = require("../enums/notification/notification-message-type.enum");
+const actions_enum_1 = require("../enums/actions.enum");
+const language_enum_1 = require("../enums/language.enum");
+describe('NotificationInfoDto Validator', () => {
+    const validUnit = { id: "ram", unitDescription: "MB", intervalDescription: "month" };
+    const testCases = [
+        {
+            description: 'should return no errors for valid DTO',
+            dto: {
+                type: notification_message_type_enum_1.NotificationMessageTypeEnum.EMAIL,
+                title: 'Valid Title',
+                supportedActions: [actions_enum_1.ActionsEnum.CREATE],
+                supportedLanguages: [language_enum_1.LanguageEnum.EN],
+                payPerUseUnits: [validUnit]
+            },
+            expectedErrorsLength: 0
+        },
+        {
+            description: 'should return error for missing type',
+            dto: {
+                title: 'Valid Title',
+                supportedActions: [actions_enum_1.ActionsEnum.CREATE],
+                supportedLanguages: [language_enum_1.LanguageEnum.EN],
+                payPerUseUnits: [validUnit]
+            },
+            expectedErrorsLength: 1
+        },
+        {
+            description: 'should return error for invalid payPerUseUnits',
+            dto: {
+                type: notification_message_type_enum_1.NotificationMessageTypeEnum.EMAIL,
+                title: 'Valid Title',
+                supportedActions: [actions_enum_1.ActionsEnum.CREATE],
+                supportedLanguages: [language_enum_1.LanguageEnum.EN],
+                payPerUseUnits: [{ id: "", unitDescription: "", intervalDescription: "" }] // Invalid unit
+            },
+            expectedErrorsLength: 1
+        }
+    ];
+    testCases.forEach(({ description, dto, expectedErrorsLength }) => {
+        it(description, async () => {
+            const errors = await (0, notification_info_validator_1.validateNotificationInfoDto)(dto);
+            expect(errors).toHaveLength(expectedErrorsLength);
+        });
+    });
+    const validationErrorTestCases = [
+        {
+            description: 'should return ValidationError for missing title',
+            dto: {
+                type: notification_message_type_enum_1.NotificationMessageTypeEnum.EMAIL,
+                supportedActions: [actions_enum_1.ActionsEnum.CREATE],
+                supportedLanguages: [language_enum_1.LanguageEnum.EN],
+                payPerUseUnits: [validUnit]
+            },
+            expectedErrors: ['title']
+        },
+        {
+            description: 'should return ValidationError for invalid payPerUseUnits',
+            dto: {
+                type: notification_message_type_enum_1.NotificationMessageTypeEnum.EMAIL,
+                title: 'Valid Title',
+                supportedActions: [actions_enum_1.ActionsEnum.CREATE],
+                supportedLanguages: [language_enum_1.LanguageEnum.EN],
+                payPerUseUnits: [{ id: "", unitDescription: "", intervalDescription: "" }]
+            },
+            expectedErrors: ['payPerUseUnits']
+        }
+    ];
+    validationErrorTestCases.forEach(({ description, dto, expectedErrors }) => {
+        it(description, async () => {
+            const errors = await (0, notification_info_validator_1.validateNotificationInfoDto)(dto);
+            const errorProperties = errors.map(error => error.property);
+            expectedErrors.forEach(expectedError => {
+                expect(errorProperties).toContain(expectedError);
+            });
+        });
+    });
+});

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

@@ -0,0 +1,7 @@
+import { ValidationError } from 'class-validator';
+/**
+ * Validates a NotificationInfoDto object.
+ * @param dto The NotificationInfoDto object to validate.
+ * @returns An array of validation errors, if any.
+ */
+export declare function validateNotificationInfoDto(dto: object): ValidationError[];

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateNotificationInfoDto = validateNotificationInfoDto;
+const class_validator_1 = require("class-validator");
+const class_transformer_1 = require("class-transformer");
+const notification_info_dto_1 = require("../dtos/notification/notification-info.dto");
+/**
+ * Validates a NotificationInfoDto object.
+ * @param dto The NotificationInfoDto object to validate.
+ * @returns An array of validation errors, if any.
+ */
+function validateNotificationInfoDto(dto) {
+    const notificationInfoDto = (0, class_transformer_1.plainToInstance)(notification_info_dto_1.NotificationInfoDto, dto);
+    const errors = (0, class_validator_1.validateSync)(notificationInfoDto);
+    return errors;
+}

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

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

package/dist/validators/notification-request-validator.spec.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const notification_request_validator_1 = require("./notification-request-validator");
+describe('NotificationRequestDto Validator', () => {
+    // Valid test case
+    it('should return no errors for valid DTO', () => {
+        const validDto = {
+            notificationId: 'test-notification-123',
+            sender: {
+                // Using EmailSenderDto as an example
+                email: 'test@example.com',
+                name: 'Test Sender',
+            },
+            receiver: {
+                // Using EmailReceiverDto as an example
+                email: 'recipient@example.com',
+            },
+        };
+        const errors = (0, notification_request_validator_1.validateNotificationRequestDto)(validDto);
+        expect(errors).toHaveLength(0);
+    });
+    // Invalid test cases
+    describe('notificationId validation', () => {
+        it('should return error when notificationId is missing', () => {
+            const invalidDto = {
+                sender: { email: 'test@example.com', name: 'Test Sender' },
+                receiver: { email: 'recipient@example.com' },
+            };
+            const errors = (0, notification_request_validator_1.validateNotificationRequestDto)(invalidDto);
+            expect(errors).toHaveLength(1);
+            expect(errors[0].property).toBe('notificationId');
+            expect(errors[0].constraints).toHaveProperty('isNotEmpty');
+        });
+        it('should return error when notificationId is not a string', () => {
+            const invalidDto = {
+                notificationId: 123, // Number instead of string
+                sender: { email: 'test@example.com', name: 'Test Sender' },
+                receiver: { email: 'recipient@example.com' },
+            };
+            const errors = (0, notification_request_validator_1.validateNotificationRequestDto)(invalidDto);
+            expect(errors).toHaveLength(1);
+            expect(errors[0].property).toBe('notificationId');
+            expect(errors[0].constraints).toHaveProperty('isString');
+        });
+    });
+    describe('sender validation', () => {
+        it('should return error when sender is missing', () => {
+            const invalidDto = {
+                notificationId: 'test-notification-123',
+                receiver: { email: 'recipient@example.com' },
+            };
+            const errors = (0, notification_request_validator_1.validateNotificationRequestDto)(invalidDto);
+            expect(errors).toHaveLength(1);
+            expect(errors[0].property).toBe('sender');
+            expect(errors[0].constraints).toHaveProperty('isNotEmpty');
+        });
+        it('should return error when sender is not an object', () => {
+            const invalidDto = {
+                notificationId: 'test-notification-123',
+                sender: 'not-an-object',
+                receiver: { email: 'recipient@example.com' },
+            };
+            const errors = (0, notification_request_validator_1.validateNotificationRequestDto)(invalidDto);
+            expect(errors).toHaveLength(1);
+            expect(errors[0].property).toBe('sender');
+            expect(errors[0].constraints).toHaveProperty('isObject');
+        });
+        it('should return error when sender is null', () => {
+            const invalidDto = {
+                notificationId: 'test-notification-123',
+                sender: null,
+                receiver: { email: 'recipient@example.com' },
+            };
+            const errors = (0, notification_request_validator_1.validateNotificationRequestDto)(invalidDto);
+            expect(errors).toHaveLength(1);
+            expect(errors[0].property).toBe('sender');
+            expect(errors[0].constraints).toHaveProperty('isObject');
+        });
+    });
+    describe('receiver validation', () => {
+        it('should return error when receiver is missing', () => {
+            const invalidDto = {
+                notificationId: 'test-notification-123',
+                sender: { email: 'test@example.com', name: 'Test Sender' },
+            };
+            const errors = (0, notification_request_validator_1.validateNotificationRequestDto)(invalidDto);
+            expect(errors).toHaveLength(1);
+            expect(errors[0].property).toBe('receiver');
+            expect(errors[0].constraints).toHaveProperty('isNotEmpty');
+        });
+        it('should return error when receiver is not an object', () => {
+            const invalidDto = {
+                notificationId: 'test-notification-123',
+                sender: { email: 'test@example.com', name: 'Test Sender' },
+                receiver: 'invalid-receiver',
+            };
+            const errors = (0, notification_request_validator_1.validateNotificationRequestDto)(invalidDto);
+            expect(errors).toHaveLength(1);
+            expect(errors[0].property).toBe('receiver');
+            expect(errors[0].constraints).toHaveProperty('isObject');
+        });
+        it('should return error when receiver is null', () => {
+            const invalidDto = {
+                notificationId: 'test-notification-123',
+                sender: { email: 'test@example.com', name: 'Test Sender' },
+                receiver: null,
+            };
+            const errors = (0, notification_request_validator_1.validateNotificationRequestDto)(invalidDto);
+            expect(errors).toHaveLength(1);
+            expect(errors[0].property).toBe('receiver');
+            expect(errors[0].constraints).toHaveProperty('isObject');
+        });
+    });
+});

package/dist/validators/product-create-request-validator.spec.d.ts

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