@hosterai/types 0.0.28 → 0.0.30

package/dist/validators/invoice-contact-data-validator.spec.js

@@ -40,49 +40,57 @@ describe('InvoiceContactData Validator', () => {
         it('should return errors when all fields are missing', () => {
             const errors = (0, invoice_contact_data_validator_1.validateInvoiceContactDataDto)({});
             const requiredProps = [
-                'invoiceContactId', 'isBusinessContact', 'firstName', 'lastName',
-                'email', 'telephone', 'address1', 'postcode', 'city', 'country',
+                'invoiceContactId',
+                'isBusinessContact',
+                'firstName',
+                'lastName',
+                'email',
+                'telephone',
+                'address1',
+                'postcode',
+                'city',
+                'country',
             ];
             for (const prop of requiredProps) {
-                expect(errors.some(e => e.property === prop)).toBe(true);
+                expect(errors.some((e) => e.property === prop)).toBe(true);
             }
         });
         it('should return error when invoiceContactId is missing', () => {
             const { invoiceContactId, ...dto } = baseValidDto;
             const errors = (0, invoice_contact_data_validator_1.validateInvoiceContactDataDto)(dto);
-            expect(errors.some(e => e.property === 'invoiceContactId')).toBe(true);
+            expect(errors.some((e) => e.property === 'invoiceContactId')).toBe(true);
         });
     });
     describe('Invalid field values', () => {
         it('should return error for invalid email', () => {
             const dto = { ...baseValidDto, email: 'not-an-email' };
             const errors = (0, invoice_contact_data_validator_1.validateInvoiceContactDataDto)(dto);
-            expect(errors.some(e => e.property === 'email')).toBe(true);
+            expect(errors.some((e) => e.property === 'email')).toBe(true);
         });
         it('should return error for invalid telephone', () => {
             const dto = { ...baseValidDto, telephone: '123' };
             const errors = (0, invoice_contact_data_validator_1.validateInvoiceContactDataDto)(dto);
-            expect(errors.some(e => e.property === 'telephone')).toBe(true);
+            expect(errors.some((e) => e.property === 'telephone')).toBe(true);
         });
         it('should return error for invalid country code', () => {
             const dto = { ...baseValidDto, country: 'INVALID' };
             const errors = (0, invoice_contact_data_validator_1.validateInvoiceContactDataDto)(dto);
-            expect(errors.some(e => e.property === 'country')).toBe(true);
+            expect(errors.some((e) => e.property === 'country')).toBe(true);
         });
         it('should return error for address1 exceeding max length', () => {
             const dto = { ...baseValidDto, address1: 'a'.repeat(251) };
             const errors = (0, invoice_contact_data_validator_1.validateInvoiceContactDataDto)(dto);
-            expect(errors.some(e => e.property === 'address1')).toBe(true);
+            expect(errors.some((e) => e.property === 'address1')).toBe(true);
         });
         it('should return error for postcode exceeding max length', () => {
             const dto = { ...baseValidDto, postcode: '1'.repeat(17) };
             const errors = (0, invoice_contact_data_validator_1.validateInvoiceContactDataDto)(dto);
-            expect(errors.some(e => e.property === 'postcode')).toBe(true);
+            expect(errors.some((e) => e.property === 'postcode')).toBe(true);
         });
         it('should return error for invalid mobile phone', () => {
             const dto = { ...baseValidDto, mobile: 'not-a-phone' };
             const errors = (0, invoice_contact_data_validator_1.validateInvoiceContactDataDto)(dto);
-            expect(errors.some(e => e.property === 'mobile')).toBe(true);
+            expect(errors.some((e) => e.property === 'mobile')).toBe(true);
         });
     });
 });

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

@@ -20,7 +20,11 @@ describe('InvoiceInfoDto Validator', () => {
         it('should return no errors with all supported types', () => {
             const dto = {
                 ...baseValidDto,
-                supportedTypes: [invoice_types_enum_1.InvoiceTypesEnum.INVOICE, invoice_types_enum_1.InvoiceTypesEnum.CREDIT_NOTE, invoice_types_enum_1.InvoiceTypesEnum.PROFORMA],
+                supportedTypes: [
+                    invoice_types_enum_1.InvoiceTypesEnum.INVOICE,
+                    invoice_types_enum_1.InvoiceTypesEnum.CREDIT_NOTE,
+                    invoice_types_enum_1.InvoiceTypesEnum.PROFORMA,
+                ],
             };
             expect((0, invoice_info_validator_1.validateInvoiceInfoDto)(dto)).toHaveLength(0);
         });
@@ -37,45 +41,45 @@ describe('InvoiceInfoDto Validator', () => {
     describe('Missing required fields', () => {
         it('should return errors when all fields are missing', () => {
             const errors = (0, invoice_info_validator_1.validateInvoiceInfoDto)({});
-            expect(errors.some(e => e.property === 'title')).toBe(true);
-            expect(errors.some(e => e.property === 'supportedLanguages')).toBe(true);
+            expect(errors.some((e) => e.property === 'title')).toBe(true);
+            expect(errors.some((e) => e.property === 'supportedLanguages')).toBe(true);
         });
         it('should return error when title is missing', () => {
             const { title, ...dto } = baseValidDto;
             const errors = (0, invoice_info_validator_1.validateInvoiceInfoDto)(dto);
-            expect(errors.some(e => e.property === 'title')).toBe(true);
+            expect(errors.some((e) => e.property === 'title')).toBe(true);
         });
         it('should return error when supportedLanguages is missing', () => {
             const { supportedLanguages, ...dto } = baseValidDto;
             const errors = (0, invoice_info_validator_1.validateInvoiceInfoDto)(dto);
-            expect(errors.some(e => e.property === 'supportedLanguages')).toBe(true);
+            expect(errors.some((e) => e.property === 'supportedLanguages')).toBe(true);
         });
     });
     describe('Invalid field values', () => {
         it('should return error for invalid supportedTypes enum', () => {
             const dto = { ...baseValidDto, supportedTypes: ['invalid-type'] };
             const errors = (0, invoice_info_validator_1.validateInvoiceInfoDto)(dto);
-            expect(errors.some(e => e.property === 'supportedTypes')).toBe(true);
+            expect(errors.some((e) => e.property === 'supportedTypes')).toBe(true);
         });
         it('should return error for empty title', () => {
             const dto = { ...baseValidDto, title: '' };
             const errors = (0, invoice_info_validator_1.validateInvoiceInfoDto)(dto);
-            expect(errors.some(e => e.property === 'title')).toBe(true);
+            expect(errors.some((e) => e.property === 'title')).toBe(true);
         });
         it('should return error for empty supportedLanguages array', () => {
             const dto = { ...baseValidDto, supportedLanguages: [] };
             const errors = (0, invoice_info_validator_1.validateInvoiceInfoDto)(dto);
-            expect(errors.some(e => e.property === 'supportedLanguages')).toBe(true);
+            expect(errors.some((e) => e.property === 'supportedLanguages')).toBe(true);
         });
         it('should return error for invalid language enum', () => {
             const dto = { ...baseValidDto, supportedLanguages: ['INVALID'] };
             const errors = (0, invoice_info_validator_1.validateInvoiceInfoDto)(dto);
-            expect(errors.some(e => e.property === 'supportedLanguages')).toBe(true);
+            expect(errors.some((e) => e.property === 'supportedLanguages')).toBe(true);
         });
         it('should return error for invalid logo URL', () => {
             const dto = { ...baseValidDto, logo: 'not-a-url' };
             const errors = (0, invoice_info_validator_1.validateInvoiceInfoDto)(dto);
-            expect(errors.some(e => e.property === 'logo')).toBe(true);
+            expect(errors.some((e) => e.property === 'logo')).toBe(true);
         });
     });
 });

package/dist/validators/invoice-item-data-validator.spec.js

@@ -27,19 +27,19 @@ describe('InvoiceItemDataDto Validator', () => {
         it('should return error when action is missing', () => {
             const { action, ...dto } = baseValidDto;
             const errors = (0, invoice_item_data_validator_1.validateInvoiceItemDataDto)(dto);
-            expect(errors.some(e => e.property === 'action')).toBe(true);
+            expect(errors.some((e) => e.property === 'action')).toBe(true);
         });
         it('should return errors for inherited required fields when missing', () => {
             const errors = (0, invoice_item_data_validator_1.validateInvoiceItemDataDto)({});
-            expect(errors.some(e => e.property === 'action')).toBe(true);
-            expect(errors.some(e => e.property === 'productId')).toBe(true);
+            expect(errors.some((e) => e.property === 'action')).toBe(true);
+            expect(errors.some((e) => e.property === 'productId')).toBe(true);
         });
     });
     describe('Invalid field values', () => {
         it('should return error for invalid action enum', () => {
             const dto = { ...baseValidDto, action: 'invalid-action' };
             const errors = (0, invoice_item_data_validator_1.validateInvoiceItemDataDto)(dto);
-            expect(errors.some(e => e.property === 'action')).toBe(true);
+            expect(errors.some((e) => e.property === 'action')).toBe(true);
         });
     });
 });

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

@@ -33,47 +33,55 @@ describe('ItemDataDto Validator', () => {
     describe('Missing required fields', () => {
         it('should return errors when all fields are missing', () => {
             const errors = (0, item_data_validator_1.validateItemDataDto)({});
-            const requiredProps = ['productId', 'productName', 'resourceName', 'productAttributes', 'itemAttributes', 'startDate', 'endDate'];
+            const requiredProps = [
+                'productId',
+                'productName',
+                'resourceName',
+                'productAttributes',
+                'itemAttributes',
+                'startDate',
+                'endDate',
+            ];
             for (const prop of requiredProps) {
-                expect(errors.some(e => e.property === prop)).toBe(true);
+                expect(errors.some((e) => e.property === prop)).toBe(true);
             }
         });
         it('should return error when productId is missing', () => {
             const { productId, ...dto } = baseValidDto;
             const errors = (0, item_data_validator_1.validateItemDataDto)(dto);
-            expect(errors.some(e => e.property === 'productId')).toBe(true);
+            expect(errors.some((e) => e.property === 'productId')).toBe(true);
         });
         it('should return error when productAttributes is missing', () => {
             const { productAttributes, ...dto } = baseValidDto;
             const errors = (0, item_data_validator_1.validateItemDataDto)(dto);
-            expect(errors.some(e => e.property === 'productAttributes')).toBe(true);
+            expect(errors.some((e) => e.property === 'productAttributes')).toBe(true);
         });
         it('should return error when itemAttributes is missing', () => {
             const { itemAttributes, ...dto } = baseValidDto;
             const errors = (0, item_data_validator_1.validateItemDataDto)(dto);
-            expect(errors.some(e => e.property === 'itemAttributes')).toBe(true);
+            expect(errors.some((e) => e.property === 'itemAttributes')).toBe(true);
         });
     });
     describe('Invalid field values', () => {
         it('should return error for empty productId', () => {
             const dto = { ...baseValidDto, productId: '' };
             const errors = (0, item_data_validator_1.validateItemDataDto)(dto);
-            expect(errors.some(e => e.property === 'productId')).toBe(true);
+            expect(errors.some((e) => e.property === 'productId')).toBe(true);
         });
         it('should return error for empty startDate', () => {
             const dto = { ...baseValidDto, startDate: '' };
             const errors = (0, item_data_validator_1.validateItemDataDto)(dto);
-            expect(errors.some(e => e.property === 'startDate')).toBe(true);
+            expect(errors.some((e) => e.property === 'startDate')).toBe(true);
         });
         it('should return error for non-number price', () => {
             const dto = { ...baseValidDto, price: 'free' };
             const errors = (0, item_data_validator_1.validateItemDataDto)(dto);
-            expect(errors.some(e => e.property === 'price')).toBe(true);
+            expect(errors.some((e) => e.property === 'price')).toBe(true);
         });
         it('should return error for non-number discountPrice', () => {
             const dto = { ...baseValidDto, discountPrice: 'half-off' };
             const errors = (0, item_data_validator_1.validateItemDataDto)(dto);
-            expect(errors.some(e => e.property === 'discountPrice')).toBe(true);
+            expect(errors.some((e) => e.property === 'discountPrice')).toBe(true);
         });
     });
 });

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

@@ -4,41 +4,43 @@ require("reflect-metadata");
 const menu_with_submenu_validator_1 = require("./menu-with-submenu.validator");
 describe('validateMenuDto', () => {
     test.each([
-        ['valid data with submenu',
+        [
+            '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' }
-                ],
+                submenu: [{ label: 'Submenu 1', url: 'https://example.com/sub1' }],
             },
-            true
+            true,
         ],
-        ['missing required icon',
+        [
+            'missing required icon',
             {
                 type: 'with-submenu',
                 label: 'Menu Label',
                 submenu: [{ label: 'Submenu 1', url: 'https://example.com/sub1' }],
             },
-            false
+            false,
         ],
-        ['missing submenu',
+        [
+            'missing submenu',
             {
                 type: 'with-submenu',
                 icon: 'https://example.com/icon.png',
                 label: 'Menu Label',
             },
-            false
+            false,
         ],
-        ['submenu with missing label',
+        [
+            'submenu with missing label',
             {
                 type: 'with-submenu',
                 icon: 'https://example.com/icon.png',
                 label: 'Menu Label',
                 submenu: [{ url: 'https://example.com/sub1' }],
             },
-            false
+            false,
         ],
     ])('%s', (_, input, expectedValid) => {
         const errors = (0, menu_with_submenu_validator_1.validateMenuWithSubmenuDto)(input);

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

@@ -22,7 +22,7 @@ describe('validateMenuWithUrlDto', () => {
         };
         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);
+        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 = {
@@ -33,7 +33,7 @@ describe('validateMenuWithUrlDto', () => {
         };
         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);
+        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 = {
@@ -43,17 +43,27 @@ describe('validateMenuWithUrlDto', () => {
         };
         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);
+        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' },
+            {
+                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);
+            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', () => {

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

@@ -6,40 +6,46 @@ const notification_message_type_enum_1 = require("../enums/notification/notifica
 const item_actions_enum_1 = require("../enums/item-actions.enum");
 const language_enum_1 = require("../enums/language.enum");
 describe('NotificationInfoDto Validator', () => {
-    const validUnit = { id: "ram", unitDescription: "MB", intervalDescription: "month" };
+    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: [item_actions_enum_1.ProductItemActionsEnum.CREATE],
+                supportedActions: [item_actions_enum_1.ProductActionsEnum.CREATE],
                 supportedLanguages: [language_enum_1.LanguageEnum.ENGLISH],
-                payPerUseUnits: [validUnit]
+                payPerUseUnits: [validUnit],
             },
-            expectedErrorsLength: 0
+            expectedErrorsLength: 0,
         },
         {
             description: 'should return error for missing type',
             dto: {
                 title: 'Valid Title',
-                supportedActions: [item_actions_enum_1.ProductItemActionsEnum.CREATE],
+                supportedActions: [item_actions_enum_1.ProductActionsEnum.CREATE],
                 supportedLanguages: [language_enum_1.LanguageEnum.ENGLISH],
-                payPerUseUnits: [validUnit]
+                payPerUseUnits: [validUnit],
             },
-            expectedErrorsLength: 1
+            expectedErrorsLength: 1,
         },
         {
             description: 'should return error for invalid payPerUseUnits',
             dto: {
                 type: notification_message_type_enum_1.NotificationMessageTypeEnum.EMAIL,
                 title: 'Valid Title',
-                supportedActions: [item_actions_enum_1.ProductItemActionsEnum.CREATE],
+                supportedActions: [item_actions_enum_1.ProductActionsEnum.CREATE],
                 supportedLanguages: [language_enum_1.LanguageEnum.ENGLISH],
-                payPerUseUnits: [{ id: "", unitDescription: "", intervalDescription: "" }] // Invalid unit
+                payPerUseUnits: [
+                    { id: '', unitDescription: '', intervalDescription: '' },
+                ], // Invalid unit
             },
-            expectedErrorsLength: 1
-        }
+            expectedErrorsLength: 1,
+        },
     ];
     testCases.forEach(({ description, dto, expectedErrorsLength }) => {
         it(description, async () => {
@@ -52,29 +58,31 @@ describe('NotificationInfoDto Validator', () => {
             description: 'should return ValidationError for missing title',
             dto: {
                 type: notification_message_type_enum_1.NotificationMessageTypeEnum.EMAIL,
-                supportedActions: [item_actions_enum_1.ProductItemActionsEnum.CREATE],
+                supportedActions: [item_actions_enum_1.ProductActionsEnum.CREATE],
                 supportedLanguages: [language_enum_1.LanguageEnum.ENGLISH],
-                payPerUseUnits: [validUnit]
+                payPerUseUnits: [validUnit],
             },
-            expectedErrors: ['title']
+            expectedErrors: ['title'],
         },
         {
             description: 'should return ValidationError for invalid payPerUseUnits',
             dto: {
                 type: notification_message_type_enum_1.NotificationMessageTypeEnum.EMAIL,
                 title: 'Valid Title',
-                supportedActions: [item_actions_enum_1.ProductItemActionsEnum.CREATE],
+                supportedActions: [item_actions_enum_1.ProductActionsEnum.CREATE],
                 supportedLanguages: [language_enum_1.LanguageEnum.ENGLISH],
-                payPerUseUnits: [{ id: "", unitDescription: "", intervalDescription: "" }]
+                payPerUseUnits: [
+                    { id: '', unitDescription: '', intervalDescription: '' },
+                ],
             },
-            expectedErrors: ['payPerUseUnits']
-        }
+            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 => {
+            const errorProperties = errors.map((error) => error.property);
+            expectedErrors.forEach((expectedError) => {
                 expect(errorProperties).toContain(expectedError);
             });
         });