@hosterai/types 0.0.26 → 0.0.28

package/dist/validators/country-validator.d.ts

@@ -0,0 +1,8 @@
+import { ValidationError } from 'class-validator';
+/**
+ * Validates a CountryDto object using class-validator decorators.
+ *
+ * @param data The object to validate as a CountryDto.
+ * @returns An array of validation errors, empty if validation succeeds.
+ */
+export declare function validateCountryDto(data: object): ValidationError[];

package/dist/validators/country-validator.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCountryDto = validateCountryDto;
+const class_validator_1 = require("class-validator");
+const class_transformer_1 = require("class-transformer");
+const country_dto_1 = require("../dtos/country.dto");
+/**
+ * Validates a CountryDto object using class-validator decorators.
+ *
+ * @param data The object to validate as a CountryDto.
+ * @returns An array of validation errors, empty if validation succeeds.
+ */
+function validateCountryDto(data) {
+    const dto = (0, class_transformer_1.plainToInstance)(country_dto_1.CountryDto, data);
+    const errors = (0, class_validator_1.validateSync)(dto);
+    return errors;
+}

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

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

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const country_validator_1 = require("./country-validator");
+const country_enum_1 = require("../enums/country.enum");
+const baseValidDto = {
+    name: 'Greece',
+    code: country_enum_1.CountryEnum.GREECE,
+};
+describe('CountryDto Validator', () => {
+    describe('Valid cases', () => {
+        it('should return no errors for a valid DTO', () => {
+            expect((0, country_validator_1.validateCountryDto)(baseValidDto)).toHaveLength(0);
+        });
+        it('should return no errors with optional isEurope', () => {
+            const dto = { ...baseValidDto, isEurope: true };
+            expect((0, country_validator_1.validateCountryDto)(dto)).toHaveLength(0);
+        });
+        it('should return no errors with isEurope false', () => {
+            const dto = { ...baseValidDto, isEurope: false };
+            expect((0, country_validator_1.validateCountryDto)(dto)).toHaveLength(0);
+        });
+    });
+    describe('Missing required fields', () => {
+        it('should return errors when all fields are missing', () => {
+            const errors = (0, country_validator_1.validateCountryDto)({});
+            expect(errors.some(e => e.property === 'name')).toBe(true);
+            expect(errors.some(e => e.property === 'code')).toBe(true);
+        });
+        it('should return error when name is missing', () => {
+            const dto = { code: country_enum_1.CountryEnum.GREECE };
+            const errors = (0, country_validator_1.validateCountryDto)(dto);
+            expect(errors.some(e => e.property === 'name')).toBe(true);
+        });
+        it('should return error when code is missing', () => {
+            const dto = { name: 'Greece' };
+            const errors = (0, country_validator_1.validateCountryDto)(dto);
+            expect(errors.some(e => e.property === 'code')).toBe(true);
+        });
+    });
+    describe('Invalid field values', () => {
+        it('should return error for empty name', () => {
+            const dto = { ...baseValidDto, name: '' };
+            const errors = (0, country_validator_1.validateCountryDto)(dto);
+            expect(errors.some(e => e.property === 'name')).toBe(true);
+        });
+        it('should return error for invalid country code', () => {
+            const dto = { ...baseValidDto, code: 'INVALID' };
+            const errors = (0, country_validator_1.validateCountryDto)(dto);
+            expect(errors.some(e => e.property === 'code')).toBe(true);
+        });
+        it('should return error for non-boolean isEurope', () => {
+            const dto = { ...baseValidDto, isEurope: 'yes' };
+            const errors = (0, country_validator_1.validateCountryDto)(dto);
+            expect(errors.some(e => e.property === 'isEurope')).toBe(true);
+        });
+    });
+});

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

@@ -11,8 +11,6 @@ const baseValidDto = {
     type: field_type_enum_1.FieldTypeEnum.TEXT_BOX,
     required: true,
     disabled: false,
-    visibleInOrder: false,
-    visibleInClientPanel: false,
     upgradable: false,
 };
 describe('FieldDto Validator', () => {
@@ -32,7 +30,7 @@ describe('FieldDto Validator', () => {
     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', 'visibleInOrder', 'visibleInClientPanel'];
+            const requiredProps = ['id', 'label', 'value', 'type', 'required', 'disabled'];
             for (const prop of requiredProps) {
                 expect(errors.some(e => e.property === prop)).toBe(true);
             }
@@ -74,30 +72,4 @@ describe('FieldDto Validator', () => {
             expect(errors.some(e => e.property === 'value')).toBe(true);
         });
     });
-    describe('Repeatable constraints (AllOrNone and Min<=Max)', () => {
-        it('should fail when only repeatableMin is present', () => {
-            const dto = { ...baseValidDto, repeatableMin: 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 repeatableMax is present', () => {
-            const dto = { ...baseValidDto, repeatableMax: 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 repeatableMin <= repeatableMax', () => {
-            const dto = { ...baseValidDto, repeatableMin: 1, repeatableMax: 2 };
-            const errors = (0, field_validator_1.validateFieldDto)(dto);
-            expect(errors).toHaveLength(0);
-        });
-        it('should fail when both present and repeatableMin > repeatableMax', () => {
-            const dto = { ...baseValidDto, repeatableMin: 3, repeatableMax: 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/info-validator.d.ts

@@ -0,0 +1,8 @@
+import { ValidationError } from 'class-validator';
+/**
+ * Validates an InfoDto object using class-validator decorators.
+ *
+ * @param data The object to validate as an InfoDto.
+ * @returns An array of validation errors, empty if validation succeeds.
+ */
+export declare function validateInfoDto(data: object): ValidationError[];

package/dist/validators/info-validator.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateInfoDto = validateInfoDto;
+const class_validator_1 = require("class-validator");
+const class_transformer_1 = require("class-transformer");
+const info_dto_1 = require("../dtos/info.dto");
+/**
+ * Validates an InfoDto object using class-validator decorators.
+ *
+ * @param data The object to validate as an InfoDto.
+ * @returns An array of validation errors, empty if validation succeeds.
+ */
+function validateInfoDto(data) {
+    const dto = (0, class_transformer_1.plainToInstance)(info_dto_1.InfoDto, data);
+    const errors = (0, class_validator_1.validateSync)(dto);
+    return errors;
+}

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

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

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

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const info_validator_1 = require("./info-validator");
+const language_enum_1 = require("../enums/language.enum");
+const events_enum_1 = require("../enums/events.enum");
+const roles_enum_1 = require("../enums/roles.enum");
+const baseValidDto = {
+    title: 'My Integration',
+    supportedLanguages: [language_enum_1.LanguageEnum.ENGLISH],
+};
+describe('InfoDto Validator', () => {
+    describe('Valid cases', () => {
+        it('should return no errors for a valid DTO with required fields only', () => {
+            expect((0, info_validator_1.validateInfoDto)(baseValidDto)).toHaveLength(0);
+        });
+        it('should return no errors with all optional fields', () => {
+            const dto = {
+                ...baseValidDto,
+                logo: 'https://example.com/logo.png',
+                description: 'A test integration',
+                listenEvents: [events_enum_1.EventsEnum.USER_CREATED],
+                requiredRoles: [roles_enum_1.RolesEnum.FULL_ACCESS],
+                onboardingUrl: 'https://example.com/onboarding',
+            };
+            expect((0, info_validator_1.validateInfoDto)(dto)).toHaveLength(0);
+        });
+        it('should return no errors with multiple supported languages', () => {
+            const dto = {
+                ...baseValidDto,
+                supportedLanguages: [language_enum_1.LanguageEnum.ENGLISH, language_enum_1.LanguageEnum.FRENCH],
+            };
+            expect((0, info_validator_1.validateInfoDto)(dto)).toHaveLength(0);
+        });
+    });
+    describe('Missing required fields', () => {
+        it('should return errors when all fields are missing', () => {
+            const errors = (0, info_validator_1.validateInfoDto)({});
+            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, info_validator_1.validateInfoDto)(dto);
+            expect(errors.some(e => e.property === 'title')).toBe(true);
+        });
+        it('should return error when supportedLanguages is missing', () => {
+            const { supportedLanguages, ...dto } = baseValidDto;
+            const errors = (0, info_validator_1.validateInfoDto)(dto);
+            expect(errors.some(e => e.property === 'supportedLanguages')).toBe(true);
+        });
+    });
+    describe('Invalid field values', () => {
+        it('should return error for empty title', () => {
+            const dto = { ...baseValidDto, title: '' };
+            const errors = (0, info_validator_1.validateInfoDto)(dto);
+            expect(errors.some(e => e.property === 'title')).toBe(true);
+        });
+        it('should return error for empty supportedLanguages array', () => {
+            const dto = { ...baseValidDto, supportedLanguages: [] };
+            const errors = (0, info_validator_1.validateInfoDto)(dto);
+            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, info_validator_1.validateInfoDto)(dto);
+            expect(errors.some(e => e.property === 'supportedLanguages')).toBe(true);
+        });
+        it('should return error for invalid logo URL (not https)', () => {
+            const dto = { ...baseValidDto, logo: 'http://example.com/logo.png' };
+            const errors = (0, info_validator_1.validateInfoDto)(dto);
+            expect(errors.some(e => e.property === 'logo')).toBe(true);
+        });
+        it('should return error for invalid logo URL (not a URL)', () => {
+            const dto = { ...baseValidDto, logo: 'not-a-url' };
+            const errors = (0, info_validator_1.validateInfoDto)(dto);
+            expect(errors.some(e => e.property === 'logo')).toBe(true);
+        });
+        it('should return error for invalid onboardingUrl', () => {
+            const dto = { ...baseValidDto, onboardingUrl: 'not-a-url' };
+            const errors = (0, info_validator_1.validateInfoDto)(dto);
+            expect(errors.some(e => e.property === 'onboardingUrl')).toBe(true);
+        });
+    });
+});

package/dist/validators/invoice-contact-data-validator.d.ts

@@ -0,0 +1,8 @@
+import { ValidationError } from 'class-validator';
+/**
+ * Validates an InvoiceContactData object using class-validator decorators.
+ *
+ * @param data The object to validate as an InvoiceContactData.
+ * @returns An array of validation errors, empty if validation succeeds.
+ */
+export declare function validateInvoiceContactDataDto(data: object): ValidationError[];

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateInvoiceContactDataDto = validateInvoiceContactDataDto;
+const class_validator_1 = require("class-validator");
+const class_transformer_1 = require("class-transformer");
+const invoice_contact_data_dto_1 = require("../dtos/invoice-contact-data.dto");
+/**
+ * Validates an InvoiceContactData object using class-validator decorators.
+ *
+ * @param data The object to validate as an InvoiceContactData.
+ * @returns An array of validation errors, empty if validation succeeds.
+ */
+function validateInvoiceContactDataDto(data) {
+    const dto = (0, class_transformer_1.plainToInstance)(invoice_contact_data_dto_1.InvoiceContactData, data);
+    const errors = (0, class_validator_1.validateSync)(dto);
+    return errors;
+}

package/dist/validators/invoice-contact-data-validator.spec.d.ts

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

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

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const invoice_contact_data_validator_1 = require("./invoice-contact-data-validator");
+const country_enum_1 = require("../enums/country.enum");
+const baseValidDto = {
+    invoiceContactId: 'ic-001',
+    isBusinessContact: false,
+    firstName: 'John',
+    lastName: 'Doe',
+    email: 'john@example.com',
+    telephone: '+14155552671',
+    address1: '123 Main St',
+    postcode: '12345',
+    city: 'Anytown',
+    country: country_enum_1.CountryEnum.UNITED_STATES,
+};
+describe('InvoiceContactData Validator', () => {
+    describe('Valid cases', () => {
+        it('should return no errors for a valid DTO', () => {
+            expect((0, invoice_contact_data_validator_1.validateInvoiceContactDataDto)(baseValidDto)).toHaveLength(0);
+        });
+        it('should return no errors for a business contact with all optional fields', () => {
+            const dto = {
+                ...baseValidDto,
+                isBusinessContact: true,
+                businessName: 'Acme Corp',
+                mobile: '+14155552672',
+                address2: 'Suite 100',
+                address3: 'Building A',
+                state: 'California',
+                tin: 'US123456789',
+                taxOffice: 'IRS',
+                profession: 'Software Development',
+            };
+            expect((0, invoice_contact_data_validator_1.validateInvoiceContactDataDto)(dto)).toHaveLength(0);
+        });
+    });
+    describe('Missing required fields', () => {
+        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',
+            ];
+            for (const prop of requiredProps) {
+                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);
+        });
+    });
+    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);
+        });
+        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);
+        });
+        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);
+        });
+        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);
+        });
+        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);
+        });
+        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);
+        });
+    });
+});

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

@@ -0,0 +1,8 @@
+import { ValidationError } from 'class-validator';
+/**
+ * Validates an InvoiceInfoDto object using class-validator decorators.
+ *
+ * @param data The object to validate as an InvoiceInfoDto.
+ * @returns An array of validation errors, empty if validation succeeds.
+ */
+export declare function validateInvoiceInfoDto(data: object): ValidationError[];

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateInvoiceInfoDto = validateInvoiceInfoDto;
+const class_validator_1 = require("class-validator");
+const class_transformer_1 = require("class-transformer");
+const invoice_info_dto_1 = require("../dtos/invoice/invoice-info.dto");
+/**
+ * Validates an InvoiceInfoDto object using class-validator decorators.
+ *
+ * @param data The object to validate as an InvoiceInfoDto.
+ * @returns An array of validation errors, empty if validation succeeds.
+ */
+function validateInvoiceInfoDto(data) {
+    const dto = (0, class_transformer_1.plainToInstance)(invoice_info_dto_1.InvoiceInfoDto, data);
+    const errors = (0, class_validator_1.validateSync)(dto);
+    return errors;
+}

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

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

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

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const invoice_info_validator_1 = require("./invoice-info-validator");
+const language_enum_1 = require("../enums/language.enum");
+const invoice_types_enum_1 = require("../enums/invoice/invoice-types.enum");
+const country_enum_1 = require("../enums/country.enum");
+const baseValidDto = {
+    title: 'Invoice Integration',
+    supportedLanguages: [language_enum_1.LanguageEnum.ENGLISH],
+    supportedTypes: [invoice_types_enum_1.InvoiceTypesEnum.INVOICE],
+    supportedCountries: [country_enum_1.CountryEnum.GREECE],
+};
+describe('InvoiceInfoDto Validator', () => {
+    describe('Valid cases', () => {
+        it('should return no errors for a valid DTO', () => {
+            const errors = (0, invoice_info_validator_1.validateInvoiceInfoDto)(baseValidDto);
+            expect(errors).toHaveLength(0);
+        });
+        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],
+            };
+            expect((0, invoice_info_validator_1.validateInvoiceInfoDto)(dto)).toHaveLength(0);
+        });
+        it('should return no errors with optional inherited fields', () => {
+            const dto = {
+                ...baseValidDto,
+                logo: 'https://example.com/logo.png',
+                description: 'An invoice integration',
+                onboardingUrl: 'https://example.com/onboarding',
+            };
+            expect((0, invoice_info_validator_1.validateInvoiceInfoDto)(dto)).toHaveLength(0);
+        });
+    });
+    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);
+        });
+        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);
+        });
+        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);
+        });
+    });
+    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);
+        });
+        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);
+        });
+        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);
+        });
+        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);
+        });
+        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);
+        });
+    });
+});

package/dist/validators/invoice-item-data-validator.d.ts

@@ -0,0 +1,8 @@
+import { ValidationError } from 'class-validator';
+/**
+ * Validates an InvoiceItemDataDto object using class-validator decorators.
+ *
+ * @param data The object to validate as an InvoiceItemDataDto.
+ * @returns An array of validation errors, empty if validation succeeds.
+ */
+export declare function validateInvoiceItemDataDto(data: object): ValidationError[];

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateInvoiceItemDataDto = validateInvoiceItemDataDto;
+const class_validator_1 = require("class-validator");
+const class_transformer_1 = require("class-transformer");
+const invoice_item_data_dto_1 = require("../dtos/invoice/invoice-item-data.dto");
+/**
+ * Validates an InvoiceItemDataDto object using class-validator decorators.
+ *
+ * @param data The object to validate as an InvoiceItemDataDto.
+ * @returns An array of validation errors, empty if validation succeeds.
+ */
+function validateInvoiceItemDataDto(data) {
+    const dto = (0, class_transformer_1.plainToInstance)(invoice_item_data_dto_1.InvoiceItemDataDto, data);
+    const errors = (0, class_validator_1.validateSync)(dto);
+    return errors;
+}

package/dist/validators/invoice-item-data-validator.spec.d.ts

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

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const invoice_item_data_validator_1 = require("./invoice-item-data-validator");
+const invoice_item_actions_enum_1 = require("../enums/invoice/invoice-item-actions.enum");
+const baseValidDto = {
+    productId: 'prod-123',
+    productName: 'Web Hosting',
+    resourceName: 'hosting-basic',
+    productAttributes: { plan: 'basic' },
+    itemAttributes: { domain: 'example.com' },
+    startDate: '2025-01-01',
+    endDate: '2025-12-31',
+    action: invoice_item_actions_enum_1.InvoiceItemActionsEnum.CREATE,
+};
+describe('InvoiceItemDataDto Validator', () => {
+    describe('Valid cases', () => {
+        it('should return no errors for a valid DTO', () => {
+            expect((0, invoice_item_data_validator_1.validateInvoiceItemDataDto)(baseValidDto)).toHaveLength(0);
+        });
+        it.each(Object.values(invoice_item_actions_enum_1.InvoiceItemActionsEnum))('should accept action %s', (action) => {
+            const dto = { ...baseValidDto, action };
+            expect((0, invoice_item_data_validator_1.validateInvoiceItemDataDto)(dto)).toHaveLength(0);
+        });
+    });
+    describe('Missing required fields', () => {
+        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);
+        });
+        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);
+        });
+    });
+    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);
+        });
+    });
+});

package/dist/validators/item-data-validator.d.ts

@@ -0,0 +1,8 @@
+import { ValidationError } from 'class-validator';
+/**
+ * Validates an ItemDataDto object using class-validator decorators.
+ *
+ * @param data The object to validate as an ItemDataDto.
+ * @returns An array of validation errors, empty if validation succeeds.
+ */
+export declare function validateItemDataDto(data: object): ValidationError[];

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateItemDataDto = validateItemDataDto;
+const class_validator_1 = require("class-validator");
+const class_transformer_1 = require("class-transformer");
+const item_data_dto_1 = require("../dtos/item-data.dto");
+/**
+ * Validates an ItemDataDto object using class-validator decorators.
+ *
+ * @param data The object to validate as an ItemDataDto.
+ * @returns An array of validation errors, empty if validation succeeds.
+ */
+function validateItemDataDto(data) {
+    const dto = (0, class_transformer_1.plainToInstance)(item_data_dto_1.ItemDataDto, data);
+    const errors = (0, class_validator_1.validateSync)(dto);
+    return errors;
+}

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

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