@hosterai/types 0.0.17 → 0.0.19

package/dist/validators/product-create-request-validator.spec.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+require("reflect-metadata");
+const product_create_request_validator_1 = require("./product-create-request-validator");
+const country_enum_1 = require("../enums/country.enum");
+const duration_enum_1 = require("../enums/duration.enum");
+describe('validateProductCreateRequestDto', () => {
+    it('should return no errors for a valid request', async () => {
+        const validRequest = {
+            clientData: {
+                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,
+            },
+            itemData: {
+                productAttributes: { key: 'value' },
+                itemAttributes: { key: 'value' },
+                duration: duration_enum_1.DurationEnum.ONE_MONTH,
+            },
+        };
+        const errors = await (0, product_create_request_validator_1.validateProductCreateRequestDto)(validRequest);
+        expect(errors.length).toBe(0);
+    });
+    it('should return errors for an invalid request', async () => {
+        const invalidRequest = {
+            clientData: {
+                email: 'not-an-email',
+            },
+            itemData: {
+                productAttributes: {},
+                itemAttributes: {},
+                duration: 'invalid-duration',
+            },
+        };
+        const errors = await (0, product_create_request_validator_1.validateProductCreateRequestDto)(invalidRequest);
+        expect(errors.length).toBeGreaterThan(0);
+    });
+});

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

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

package/dist/validators/product-delete-request-validator.spec.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const product_delete_request_validator_1 = require("./product-delete-request-validator");
+const country_enum_1 = require("../enums/country.enum");
+const duration_enum_1 = require("../enums/duration.enum");
+describe('validateProductDeleteRequestDto', () => {
+    it('should return no errors for a valid request', async () => {
+        const validRequest = {
+            clientData: {
+                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,
+            },
+            itemData: {
+                itemId: 'item-123',
+                productAttributes: { key: 'value' },
+                itemAttributes: { key: 'value' },
+                duration: duration_enum_1.DurationEnum.ONE_MONTH,
+            },
+        };
+        const errors = await (0, product_delete_request_validator_1.validateProductDeleteRequestDto)(validRequest);
+        expect(errors.length).toBe(0);
+    });
+    it('should return errors for an invalid request', async () => {
+        const invalidRequest = {
+            clientData: {
+                email: 'not-an-email',
+            },
+            itemData: {},
+        };
+        const errors = await (0, product_delete_request_validator_1.validateProductDeleteRequestDto)(invalidRequest);
+        expect(errors.length).toBeGreaterThan(0);
+    });
+});

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

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

package/dist/validators/product-downgradable-request-validator.spec.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const product_downgradable_request_validator_1 = require("./product-downgradable-request-validator");
+const country_enum_1 = require("../enums/country.enum");
+const duration_enum_1 = require("../enums/duration.enum");
+describe('validateProductDowngradableRequestDto', () => {
+    it('should return no errors for a valid request', async () => {
+        const validRequest = {
+            clientData: {
+                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,
+            },
+            itemData: {
+                itemId: 'item-123',
+                productAttributes: { key: 'value' },
+                itemAttributes: { key: 'value' },
+                duration: duration_enum_1.DurationEnum.ONE_MONTH,
+            },
+        };
+        const errors = await (0, product_downgradable_request_validator_1.validateProductDowngradableRequestDto)(validRequest);
+        expect(errors.length).toBe(0);
+    });
+    it('should return errors for an invalid request', async () => {
+        const invalidRequest = {
+            clientData: {
+                email: 'not-an-email',
+            },
+            itemData: {},
+        };
+        const errors = await (0, product_downgradable_request_validator_1.validateProductDowngradableRequestDto)(invalidRequest);
+        expect(errors.length).toBeGreaterThan(0);
+    });
+});

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

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

package/dist/validators/product-downgrade-request-validator.spec.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const product_downgrade_request_validator_1 = require("./product-downgrade-request-validator");
+const country_enum_1 = require("../enums/country.enum");
+const duration_enum_1 = require("../enums/duration.enum");
+describe('validateProductDowngradeRequestDto', () => {
+    it('should return no errors for a valid request', async () => {
+        const validRequest = {
+            clientData: {
+                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,
+            },
+            itemData: {
+                itemId: 'item-123',
+                productAttributes: { key: 'value' },
+                itemAttributes: { key: 'value' },
+                duration: duration_enum_1.DurationEnum.ONE_MONTH,
+            },
+            previousItemData: {
+                itemId: 'item-123',
+                productAttributes: { key: 'value' },
+                itemAttributes: { key: 'value' },
+                duration: duration_enum_1.DurationEnum.ONE_MONTH,
+            },
+        };
+        const errors = await (0, product_downgrade_request_validator_1.validateProductDowngradeRequestDto)(validRequest);
+        expect(errors.length).toBe(0);
+    });
+    it('should return errors for an invalid request', async () => {
+        const invalidRequest = {
+            clientData: {
+                email: 'not-an-email',
+            },
+            itemData: {},
+        };
+        const errors = await (0, product_downgrade_request_validator_1.validateProductDowngradeRequestDto)(invalidRequest);
+        expect(errors.length).toBeGreaterThan(0);
+    });
+});

package/dist/validators/product-downgradeable-request-validator.d.ts

@@ -0,0 +1,8 @@
+import { ValidationError } from 'class-validator';
+/**
+ * Validates a product downgradable request object.
+ *
+ * @param {Record<string, unknown>} plainObject - The plain object to validate.
+ * @returns {Promise<ValidationError[]>} - A promise that resolves with an array of validation errors.
+ */
+export declare const validateProductDowngradableRequestDto: (plainObject: Record<string, unknown>) => Promise<ValidationError[]>;

package/dist/validators/product-downgradeable-request-validator.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateProductDowngradableRequestDto = void 0;
+const class_validator_1 = require("class-validator");
+const class_transformer_1 = require("class-transformer");
+const product_downgradable_request_dto_1 = require("../dtos/product/requests/product-downgradable-request.dto");
+/**
+ * Validates a product downgradable request object.
+ *
+ * @param {Record<string, unknown>} plainObject - The plain object to validate.
+ * @returns {Promise<ValidationError[]>} - A promise that resolves with an array of validation errors.
+ */
+const validateProductDowngradableRequestDto = async (plainObject) => {
+    const request = (0, class_transformer_1.plainToInstance)(product_downgradable_request_dto_1.ProductDowngradableRequestDto, plainObject);
+    return await (0, class_validator_1.validate)(request);
+};
+exports.validateProductDowngradableRequestDto = validateProductDowngradableRequestDto;

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

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

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

@@ -0,0 +1,259 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+// import { ProductInfoDto } from '../dtos/product/product-info.dto';
+const actions_enum_1 = require("../enums/actions.enum");
+const language_enum_1 = require("../enums/language.enum");
+const field_type_enum_1 = require("../enums/field-type.enum");
+const product_info_validator_1 = require("./product-info.validator");
+describe('ProductInfoDto Validator', () => {
+    const field = {
+        id: 'field',
+        label: [{ language: language_enum_1.LanguageEnum.EN, text: "label" }],
+        value: 'string',
+        type: field_type_enum_1.FieldTypeEnum.TEXT_BOX,
+        required: false,
+        disabled: false,
+        hidden: false,
+        upgradable: false
+    };
+    const invalidField = {
+        id: 'field',
+        label: [{ language: language_enum_1.LanguageEnum.EN, text: "label" }],
+        value: 'string',
+        type: field_type_enum_1.FieldTypeEnum.TEXT_BOX,
+        disabled: false,
+        upgradable: false
+    };
+    const testCases = [
+        {
+            description: 'should return no errors for valid DTO',
+            dto: {
+                title: 'Test',
+                supportedActions: [actions_enum_1.ActionsEnum.CREATE],
+                supportedLanguages: [language_enum_1.LanguageEnum.EN],
+                productAttributes: [field],
+                itemAttributes: [field]
+            },
+            expectedErrorsLength: 0
+        },
+        {
+            description: 'should return error for invalid required and hidden',
+            dto: {
+                title: 'Test',
+                supportedActions: [actions_enum_1.ActionsEnum.CREATE],
+                supportedLanguages: [language_enum_1.LanguageEnum.EN],
+                itemAttributes: [invalidField]
+            },
+            expectedErrorsLength: 1
+        },
+        {
+            description: 'should return error for invalid title',
+            dto: {
+                title: '',
+                supportedActions: [actions_enum_1.ActionsEnum.CREATE],
+                supportedLanguages: [language_enum_1.LanguageEnum.EN],
+                productAttributes: [field],
+                itemAttributes: [field]
+            },
+            expectedErrorsLength: 1
+        },
+        {
+            description: 'should return error for unsupported action',
+            dto: {
+                title: 'Test',
+                supportedActions: ['update'],
+                supportedLanguages: [language_enum_1.LanguageEnum.EN],
+                productAttributes: [field],
+                itemAttributes: [field]
+            },
+            expectedErrorsLength: 1
+        },
+        {
+            description: 'should return error for unsupported language',
+            dto: {
+                title: 'Test',
+                supportedActions: [actions_enum_1.ActionsEnum.CREATE],
+                supportedLanguages: [],
+                productAttributes: [field],
+                itemAttributes: [field]
+            },
+            expectedErrorsLength: 1
+        },
+        {
+            description: 'should return no errors for valid DTO with adminPanel and clientPanel',
+            dto: {
+                title: 'Test',
+                supportedActions: [actions_enum_1.ActionsEnum.CREATE],
+                supportedLanguages: [language_enum_1.LanguageEnum.EN],
+                productAttributes: [field],
+                itemAttributes: [field],
+                adminPanel: { tabs: { product: [{ label: 'Product', url: 'https://example.com/product' }] } },
+                clientPanel: { tabs: { item: [{ label: 'Item', url: 'https://example.com/item' }] } }
+            },
+            expectedErrorsLength: 0
+        },
+        {
+            description: 'should return error for invalid DTO with adminPanel and clientPanel',
+            dto: {
+                title: '',
+                supportedActions: [actions_enum_1.ActionsEnum.CREATE],
+                supportedLanguages: [language_enum_1.LanguageEnum.EN],
+                productAttributes: [field],
+                itemAttributes: [field],
+                adminPanel: { /* invalid admin panel data */},
+                clientPanel: { /* invalid client panel data */}
+            },
+            expectedErrorsLength: 3
+        },
+        {
+            description: 'should return no errors for valid DTO with payPerUseUnits',
+            dto: {
+                title: 'Test',
+                supportedActions: [actions_enum_1.ActionsEnum.CREATE],
+                supportedLanguages: [language_enum_1.LanguageEnum.EN],
+                productAttributes: [field],
+                itemAttributes: [field],
+                payPerUseUnits: [{ id: "ram", unitDescription: "MB", intervalDescription: "month" }]
+            },
+            expectedErrorsLength: 0
+        },
+        {
+            description: 'should return error for invalid DTO with payPerUseUnits',
+            dto: {
+                title: 'Test',
+                supportedActions: [actions_enum_1.ActionsEnum.CREATE],
+                supportedLanguages: [language_enum_1.LanguageEnum.EN],
+                productAttributes: [field],
+                itemAttributes: [field],
+                payPerUseUnits: [{ id: "", unitDescription: "", intervalDescription: "" }]
+            },
+            expectedErrorsLength: 1
+        }
+    ];
+    testCases.forEach(({ description, dto, expectedErrorsLength }) => {
+        it(description, () => {
+            const errors = (0, product_info_validator_1.validateProductInfoDto)(dto);
+            expect(errors.length).toBe(expectedErrorsLength);
+        });
+    });
+    const validationErrorTestCases = [
+        {
+            description: 'should return ValidationError for missing title',
+            dto: {
+                supportedActions: [actions_enum_1.ActionsEnum.CREATE],
+                supportedLanguages: [language_enum_1.LanguageEnum.EN],
+                productAttributes: [field],
+                itemAttributes: [field]
+            },
+            expectedErrors: ['title']
+        },
+        {
+            description: 'should return ValidationError for unsupported action',
+            dto: {
+                title: 'Test',
+                supportedActions: ['update'],
+                supportedLanguages: [language_enum_1.LanguageEnum.EN],
+                productAttributes: [field],
+                itemAttributes: [field]
+            },
+            expectedErrors: ['supportedActions']
+        }
+    ];
+    validationErrorTestCases.forEach(({ description, dto, expectedErrors }) => {
+        it(description, async () => {
+            const errors = await (0, product_info_validator_1.validateProductInfoDto)(dto);
+            const errorProperties = errors.map(error => error.property);
+            expectedErrors.forEach(expectedError => {
+                expect(errorProperties).toContain(expectedError);
+            });
+        });
+    });
+    describe('FieldDto class-level constraints inside ProductInfoDto', () => {
+        it('fails when a FieldDto has only reapetableMin (AllOrNone)', () => {
+            const fieldWithOnlyMin = {
+                id: 'f1',
+                label: [{ language: language_enum_1.LanguageEnum.EN, text: 'label' }],
+                value: 'v',
+                type: field_type_enum_1.FieldTypeEnum.TEXT_BOX,
+                required: false,
+                disabled: false,
+                hidden: false,
+                upgradable: false,
+                reapetableMin: 1,
+            };
+            const dto = {
+                title: 'Test',
+                supportedActions: [actions_enum_1.ActionsEnum.CREATE],
+                supportedLanguages: [language_enum_1.LanguageEnum.EN],
+                productAttributes: [fieldWithOnlyMin],
+            };
+            const errors = (0, product_info_validator_1.validateProductInfoDto)(dto);
+            expect(errors.length).toBeGreaterThan(0);
+        });
+        it('fails when a FieldDto has only reapetableMax (AllOrNone)', () => {
+            const fieldWithOnlyMax = {
+                id: 'f2',
+                label: [{ language: language_enum_1.LanguageEnum.EN, text: 'label' }],
+                value: 'v',
+                type: field_type_enum_1.FieldTypeEnum.TEXT_BOX,
+                required: false,
+                disabled: false,
+                hidden: false,
+                upgradable: false,
+                reapetableMax: 2,
+            };
+            const dto = {
+                title: 'Test',
+                supportedActions: [actions_enum_1.ActionsEnum.CREATE],
+                supportedLanguages: [language_enum_1.LanguageEnum.EN],
+                itemAttributes: [fieldWithOnlyMax],
+            };
+            const errors = (0, product_info_validator_1.validateProductInfoDto)(dto);
+            expect(errors.length).toBeGreaterThan(0);
+        });
+        it('passes when a FieldDto has both min and max with min <= max', () => {
+            const fieldOk = {
+                id: 'f3',
+                label: [{ language: language_enum_1.LanguageEnum.EN, text: 'label' }],
+                value: 'v',
+                type: field_type_enum_1.FieldTypeEnum.TEXT_BOX,
+                required: false,
+                disabled: false,
+                hidden: false,
+                upgradable: false,
+                reapetableMin: 1,
+                reapetableMax: 2,
+            };
+            const dto = {
+                title: 'Test',
+                supportedActions: [actions_enum_1.ActionsEnum.CREATE],
+                supportedLanguages: [language_enum_1.LanguageEnum.EN],
+                productAttributes: [fieldOk],
+            };
+            expect((0, product_info_validator_1.validateProductInfoDto)(dto)).toHaveLength(0);
+        });
+        it('fails when a FieldDto has both min and max with min > max (Min<=Max)', () => {
+            const fieldBad = {
+                id: 'f4',
+                label: [{ language: language_enum_1.LanguageEnum.EN, text: 'label' }],
+                value: 'v',
+                type: field_type_enum_1.FieldTypeEnum.TEXT_BOX,
+                required: false,
+                disabled: false,
+                hidden: false,
+                upgradable: false,
+                reapetableMin: 5,
+                reapetableMax: 2,
+            };
+            const dto = {
+                title: 'Test',
+                supportedActions: [actions_enum_1.ActionsEnum.CREATE],
+                supportedLanguages: [language_enum_1.LanguageEnum.EN],
+                itemAttributes: [fieldBad],
+            };
+            const errors = (0, product_info_validator_1.validateProductInfoDto)(dto);
+            expect(errors.length).toBeGreaterThan(0);
+        });
+    });
+});

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

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

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

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

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

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

package/dist/validators/product-renew-request-validator.spec.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const product_renew_request_validator_1 = require("./product-renew-request-validator");
+const country_enum_1 = require("../enums/country.enum");
+const duration_enum_1 = require("../enums/duration.enum");
+describe('validateProductRenewRequestDto', () => {
+    it('should return no errors for a valid request', async () => {
+        const validRequest = {
+            clientData: {
+                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,
+            },
+            itemData: {
+                itemId: 'item-123',
+                productAttributes: { key: 'value' },
+                itemAttributes: { key: 'value' },
+                duration: duration_enum_1.DurationEnum.ONE_MONTH,
+            },
+        };
+        const errors = await (0, product_renew_request_validator_1.validateProductRenewRequestDto)(validRequest);
+        expect(errors.length).toBe(0);
+    });
+    it('should return errors for an invalid request', async () => {
+        const invalidRequest = {
+            clientData: {
+                email: 'not-an-email',
+            },
+            itemData: {},
+        };
+        const errors = await (0, product_renew_request_validator_1.validateProductRenewRequestDto)(invalidRequest);
+        expect(errors.length).toBeGreaterThan(0);
+    });
+});

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

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

package/dist/validators/product-suspend-request-validator.spec.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const product_suspend_request_validator_1 = require("./product-suspend-request-validator");
+const country_enum_1 = require("../enums/country.enum");
+const duration_enum_1 = require("../enums/duration.enum");
+describe('validateProductSuspendRequestDto', () => {
+    it('should return no errors for a valid request', async () => {
+        const validRequest = {
+            clientData: {
+                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,
+            },
+            itemData: {
+                itemId: 'item-123',
+                productAttributes: { key: 'value' },
+                itemAttributes: { key: 'value' },
+                duration: duration_enum_1.DurationEnum.ONE_MONTH,
+            },
+        };
+        const errors = await (0, product_suspend_request_validator_1.validateProductSuspendRequestDto)(validRequest);
+        expect(errors.length).toBe(0);
+    });
+    it('should return errors for an invalid request', async () => {
+        const invalidRequest = {
+            clientData: {
+                email: 'not-an-email',
+            },
+            itemData: {},
+        };
+        const errors = await (0, product_suspend_request_validator_1.validateProductSuspendRequestDto)(invalidRequest);
+        expect(errors.length).toBeGreaterThan(0);
+    });
+});

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

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

package/dist/validators/product-unsuspend-request-validator.spec.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const product_unsuspend_request_validator_1 = require("./product-unsuspend-request-validator");
+const country_enum_1 = require("../enums/country.enum");
+const duration_enum_1 = require("../enums/duration.enum");
+describe('validateProductUnsuspendRequestDto', () => {
+    it('should return no errors for a valid request', async () => {
+        const validRequest = {
+            clientData: {
+                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,
+            },
+            itemData: {
+                itemId: 'item-123',
+                productAttributes: { key: 'value' },
+                itemAttributes: { key: 'value' },
+                duration: duration_enum_1.DurationEnum.ONE_MONTH,
+            },
+        };
+        const errors = await (0, product_unsuspend_request_validator_1.validateProductUnsuspendRequestDto)(validRequest);
+        expect(errors.length).toBe(0);
+    });
+    it('should return errors for an invalid request', async () => {
+        const invalidRequest = {
+            clientData: {
+                email: 'not-an-email',
+            },
+            itemData: {},
+        };
+        const errors = await (0, product_unsuspend_request_validator_1.validateProductUnsuspendRequestDto)(invalidRequest);
+        expect(errors.length).toBeGreaterThan(0);
+    });
+});

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

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

package/dist/validators/product-upgradable-request-validator.spec.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const product_upgradable_request_validator_1 = require("./product-upgradable-request-validator");
+const country_enum_1 = require("../enums/country.enum");
+const duration_enum_1 = require("../enums/duration.enum");
+describe('validateProductUpgradableRequestDto', () => {
+    it('should return no errors for a valid request', async () => {
+        const validRequest = {
+            clientData: {
+                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,
+            },
+            itemData: {
+                itemId: 'item-123',
+                productAttributes: { key: 'value' },
+                itemAttributes: { key: 'value' },
+                duration: duration_enum_1.DurationEnum.ONE_MONTH,
+            },
+        };
+        const errors = await (0, product_upgradable_request_validator_1.validateProductUpgradableRequestDto)(validRequest);
+        expect(errors.length).toBe(0);
+    });
+    it('should return errors for an invalid request', async () => {
+        const invalidRequest = {
+            clientData: {
+                email: 'not-an-email',
+            },
+            itemData: {},
+        };
+        const errors = await (0, product_upgradable_request_validator_1.validateProductUpgradableRequestDto)(invalidRequest);
+        expect(errors.length).toBeGreaterThan(0);
+    });
+});