@hosterai/types 0.0.31 → 0.0.32

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

@@ -1,10 +1,7 @@
 import { ValidationError } from 'class-validator';
 /**
  * Validates an AddonFieldDto object.
- *
- * The nested `field` (a discriminated `AnyFieldDto`) is validated separately
- * via the dispatcher; its errors are merged into the returned list under the
- * `field` property.
+ * Since AddonFieldDto is an empty subclass of FieldDto, this delegates to validateFieldDto.
  *
  * @param data The object to validate as an AddonFieldDto.
  * @returns An array of validation errors, empty if validation succeeds.

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

@@ -1,33 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateAddonFieldDto = validateAddonFieldDto;
-const class_validator_1 = require("class-validator");
-const class_transformer_1 = require("class-transformer");
-const addon_field_dto_1 = require("../dtos/addon-field.dto");
-const any_field_validator_1 = require("./any-field-validator");
+const field_validator_1 = require("./field-validator");
 /**
  * Validates an AddonFieldDto object.
- *
- * The nested `field` (a discriminated `AnyFieldDto`) is validated separately
- * via the dispatcher; its errors are merged into the returned list under the
- * `field` property.
+ * Since AddonFieldDto is an empty subclass of FieldDto, this delegates to validateFieldDto.
  *
  * @param data The object to validate as an AddonFieldDto.
  * @returns An array of validation errors, empty if validation succeeds.
  */
 function validateAddonFieldDto(data) {
-    const dto = (0, class_transformer_1.plainToInstance)(addon_field_dto_1.AddonFieldDto, data);
-    const errors = (0, class_validator_1.validateSync)(dto);
-    const field = data === null || data === void 0 ? void 0 : data.field;
-    if (field && typeof field === 'object') {
-        const fieldErrors = (0, any_field_validator_1.validateAnyFieldDto)(field);
-        if (fieldErrors.length > 0) {
-            const wrapped = new class_validator_1.ValidationError();
-            wrapped.property = 'field';
-            wrapped.value = field;
-            wrapped.children = fieldErrors;
-            errors.push(wrapped);
-        }
-    }
-    return errors;
+    return (0, field_validator_1.validateFieldDto)(data);
 }

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

@@ -2,17 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
 const addon_field_validator_1 = require("./addon-field-validator");
+const field_type_enum_1 = require("../enums/field-type.enum");
 const language_enum_1 = require("../enums/language.enum");
-const validField = {
+const baseValidDto = {
     id: 'addon-1',
     label: [{ language: language_enum_1.LanguageEnum.ENGLISH, text: 'Addon Field' }],
-    type: 'TEXT',
+    value: 'test-value',
+    type: field_type_enum_1.FieldTypeEnum.TEXT_BOX,
     required: true,
     disabled: false,
-    value: 'test-value',
-};
-const baseValidDto = {
-    field: validField,
+    upgradable: false,
 };
 describe('AddonFieldDto Validator', () => {
     describe('Valid cases', () => {
@@ -21,19 +20,26 @@ describe('AddonFieldDto Validator', () => {
         });
     });
     describe('Missing required fields', () => {
-        it('should return error when the nested `field` is missing', () => {
+        it('should return errors when all fields are missing', () => {
             const errors = (0, addon_field_validator_1.validateAddonFieldDto)({});
-            expect(errors.some((e) => e.property === 'field')).toBe(true);
+            const requiredProps = [
+                'id',
+                'label',
+                'value',
+                'type',
+                'required',
+                'disabled',
+            ];
+            for (const prop of requiredProps) {
+                expect(errors.some((e) => e.property === prop)).toBe(true);
+            }
         });
     });
     describe('Invalid field values', () => {
-        it('should surface errors from the nested field validator under `field`', () => {
-            var _a;
-            const errors = (0, addon_field_validator_1.validateAddonFieldDto)({
-                field: { ...validField, type: 'NOT_REAL' },
-            });
-            const fieldErr = errors.find((e) => e.property === 'field');
-            expect((_a = fieldErr === null || fieldErr === void 0 ? void 0 : fieldErr.children) === null || _a === void 0 ? void 0 : _a.some((c) => c.property === 'type')).toBe(true);
+        it('should return error for invalid type enum', () => {
+            const dto = { ...baseValidDto, type: 'not-a-valid-type' };
+            const errors = (0, addon_field_validator_1.validateAddonFieldDto)(dto);
+            expect(errors.some((e) => e.property === 'type')).toBe(true);
         });
     });
 });

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

@@ -2,10 +2,6 @@ import { ValidationError } from 'class-validator';
 /**
  * Validates an AttributeFieldDto object using class-validator decorators.
  *
- * The nested `field` (a discriminated `AnyFieldDto`) is validated separately
- * by dispatching to the matching concrete DTO's validator; its errors are
- * merged into the returned list under the `field` property.
- *
  * @param data The object to validate as an AttributeFieldDto.
  * @returns An array of validation errors, empty if validation succeeds.
  */

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

@@ -4,30 +4,14 @@ exports.validateAttributeFieldDto = validateAttributeFieldDto;
 const class_validator_1 = require("class-validator");
 const class_transformer_1 = require("class-transformer");
 const attribute_field_dto_1 = require("../dtos/attribute-field.dto");
-const any_field_validator_1 = require("./any-field-validator");
 /**
  * Validates an AttributeFieldDto object using class-validator decorators.
  *
- * The nested `field` (a discriminated `AnyFieldDto`) is validated separately
- * by dispatching to the matching concrete DTO's validator; its errors are
- * merged into the returned list under the `field` property.
- *
  * @param data The object to validate as an AttributeFieldDto.
  * @returns An array of validation errors, empty if validation succeeds.
  */
 function validateAttributeFieldDto(data) {
     const dto = (0, class_transformer_1.plainToInstance)(attribute_field_dto_1.AttributeFieldDto, data);
     const errors = (0, class_validator_1.validateSync)(dto);
-    const field = data === null || data === void 0 ? void 0 : data.field;
-    if (field && typeof field === 'object') {
-        const fieldErrors = (0, any_field_validator_1.validateAnyFieldDto)(field);
-        if (fieldErrors.length > 0) {
-            const wrapped = new class_validator_1.ValidationError();
-            wrapped.property = 'field';
-            wrapped.value = field;
-            wrapped.children = fieldErrors;
-            errors.push(wrapped);
-        }
-    }
     return errors;
 }

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

@@ -2,21 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
 const attribute_field_validator_1 = require("./attribute-field-validator");
+const field_type_enum_1 = require("../enums/field-type.enum");
 const language_enum_1 = require("../enums/language.enum");
-const validField = {
+const baseValidDto = {
     id: 'attr-1',
     label: [{ language: language_enum_1.LanguageEnum.ENGLISH, text: 'CPU Cores' }],
-    type: 'NUMBER',
+    value: '4',
+    type: field_type_enum_1.FieldTypeEnum.TEXT_BOX,
     required: true,
     disabled: false,
-    value: 4,
-};
-const baseValidDto = {
-    field: validField,
+    upgradable: false,
 };
 describe('AttributeFieldDto Validator', () => {
     describe('Valid cases', () => {
-        it('should return no errors for a valid DTO with only field', () => {
+        it('should return no errors for a valid DTO (inherited fields only)', () => {
             expect((0, attribute_field_validator_1.validateAttributeFieldDto)(baseValidDto)).toHaveLength(0);
         });
         it('should return no errors with optional visibleInOrder and visibleInClientPanel', () => {
@@ -36,12 +35,6 @@ describe('AttributeFieldDto Validator', () => {
             expect((0, attribute_field_validator_1.validateAttributeFieldDto)(dto)).toHaveLength(0);
         });
     });
-    describe('Missing required fields', () => {
-        it('should return error when the nested `field` is missing', () => {
-            const errors = (0, attribute_field_validator_1.validateAttributeFieldDto)({});
-            expect(errors.some((e) => e.property === 'field')).toBe(true);
-        });
-    });
     describe('AllOrNone constraint on repeatableMin/repeatableMax', () => {
         it('should return error when only repeatableMin is provided', () => {
             const dto = { ...baseValidDto, repeatableMin: 1 };
@@ -83,23 +76,20 @@ describe('AttributeFieldDto Validator', () => {
             expect(errors.some((e) => e.property === 'repeatableMax')).toBe(true);
         });
     });
-    describe('Nested field validation', () => {
-        it('should surface errors from the nested field validator under `field`', () => {
-            var _a;
-            const errors = (0, attribute_field_validator_1.validateAttributeFieldDto)({
-                field: { ...validField, type: 'NUMBER', value: 'four' },
-            });
-            const fieldErr = errors.find((e) => e.property === 'field');
-            expect(fieldErr).toBeDefined();
-            expect((_a = fieldErr === null || fieldErr === void 0 ? void 0 : fieldErr.children) === null || _a === void 0 ? void 0 : _a.some((c) => c.property === 'value')).toBe(true);
-        });
-        it('should surface a type error when nested type literal is unknown', () => {
-            var _a;
-            const errors = (0, attribute_field_validator_1.validateAttributeFieldDto)({
-                field: { ...validField, type: 'NOT_REAL' },
-            });
-            const fieldErr = errors.find((e) => e.property === 'field');
-            expect((_a = fieldErr === null || fieldErr === void 0 ? void 0 : fieldErr.children) === null || _a === void 0 ? void 0 : _a.some((c) => c.property === 'type')).toBe(true);
+    describe('Inherited FieldDto validation', () => {
+        it('should return errors when inherited required fields are missing', () => {
+            const errors = (0, attribute_field_validator_1.validateAttributeFieldDto)({});
+            const requiredProps = [
+                'id',
+                'label',
+                'value',
+                'type',
+                'required',
+                'disabled',
+            ];
+            for (const prop of requiredProps) {
+                expect(errors.some((e) => e.property === prop)).toBe(true);
+            }
         });
     });
 });

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

@@ -1,6 +1,8 @@
 import { ValidationError } from 'class-validator';
 /**
- * @deprecated Use `validateAnyFieldDto` (or a concrete per-type validator like
- * `validateTextFieldDto`) instead. Kept for one release for backward compatibility.
+ * Validates a FieldDto object using class-validator decorators.
+ *
+ * @param data The object to validate as a FieldDto.
+ * @returns An array of validation errors, empty if validation succeeds.
  */
 export declare function validateFieldDto(data: object): ValidationError[];

package/dist/validators/field-validator.js

@@ -1,11 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateFieldDto = validateFieldDto;
-const any_field_validator_1 = require("./any-field-validator");
+const class_validator_1 = require("class-validator");
+const class_transformer_1 = require("class-transformer");
+const field_dto_1 = require("../dtos/field.dto");
 /**
- * @deprecated Use `validateAnyFieldDto` (or a concrete per-type validator like
- * `validateTextFieldDto`) instead. Kept for one release for backward compatibility.
+ * Validates a FieldDto object using class-validator decorators.
+ *
+ * @param data The object to validate as a FieldDto.
+ * @returns An array of validation errors, empty if validation succeeds.
  */
 function validateFieldDto(data) {
-    return (0, any_field_validator_1.validateAnyFieldDto)(data);
+    const dto = (0, class_transformer_1.plainToInstance)(field_dto_1.FieldDto, data);
+    const errors = (0, class_validator_1.validateSync)(dto);
+    return errors;
 }

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

@@ -2,36 +2,99 @@
 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.ENGLISH, text: 'Test Label' }],
-    type: 'TEXT',
+    value: 'test-value',
+    type: field_type_enum_1.FieldTypeEnum.TEXT_BOX,
     required: true,
     disabled: false,
+    upgradable: false,
 };
-describe('Deprecated validateFieldDto (dispatcher delegate)', () => {
+describe('FieldDto Validator', () => {
     describe('Valid cases', () => {
-        it('routes a TEXT payload', () => {
+        it('should return no errors for a valid DTO', () => {
             expect((0, field_validator_1.validateFieldDto)(baseValidDto)).toHaveLength(0);
         });
-        it('routes a NUMBER payload', () => {
-            expect((0, field_validator_1.validateFieldDto)({ ...baseValidDto, type: 'NUMBER', value: 1 })).toHaveLength(0);
-        });
-    });
-    describe('Invalid field values', () => {
-        it('returns a synthetic type error when discriminator is unknown', () => {
-            const errors = (0, field_validator_1.validateFieldDto)({
+        it('should return no errors for a valid DTO with optional error messages', () => {
+            const dto = {
                 ...baseValidDto,
-                type: 'not-a-valid-type',
-            });
-            expect(errors.some((e) => e.property === 'type')).toBe(true);
+                regexValidationErrorMessage: [
+                    { language: language_enum_1.LanguageEnum.ENGLISH, text: 'Invalid format' },
+                ],
+                remoteValidationErrorMessage: [
+                    { language: language_enum_1.LanguageEnum.ENGLISH, text: 'Invalid value' },
+                ],
+            };
+            expect((0, field_validator_1.validateFieldDto)(dto)).toHaveLength(0);
         });
-        it('returns errors for missing required base fields after routing', () => {
-            const errors = (0, field_validator_1.validateFieldDto)({ type: 'TEXT' });
-            for (const prop of ['id', 'label', 'required', 'disabled']) {
+    });
+    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',
+            ];
+            for (const prop of requiredProps) {
                 expect(errors.some((e) => e.property === prop)).toBe(true);
             }
         });
+        it('should return error if value is missing', () => {
+            const dto = { ...baseValidDto };
+            delete dto.value;
+            const errors = (0, field_validator_1.validateFieldDto)(dto);
+            expect(errors.some((e) => e.property === 'value')).toBe(true);
+        });
+    });
+    describe('Invalid field values', () => {
+        it.each([
+            [{ ...baseValidDto, type: 'not-a-valid-type' }, 'type'],
+            [{}, 'id'],
+            [
+                {
+                    ...baseValidDto,
+                    regexValidation: 'regex',
+                    regexValidationErrorMessage: 'not-an-array',
+                },
+                'regexValidationErrorMessage',
+            ],
+            [
+                {
+                    ...baseValidDto,
+                    triggersRemoteValidation: true,
+                    remoteValidationErrorMessage: 'not-an-array',
+                },
+                'remoteValidationErrorMessage',
+            ],
+        ])('should return error for invalid %s', (dto, expectedProp) => {
+            const errors = (0, field_validator_1.validateFieldDto)(dto);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors.some((e) => e.property === expectedProp)).toBe(true);
+        });
+    });
+    describe('Invalid `value` field', () => {
+        it.each([
+            [true, 'boolean'],
+            [null, 'null'],
+            [undefined, 'undefined'],
+            [{}, 'object'],
+            [[], 'array'],
+        ])('should return error if value is invalid type (%s)', (invalidValue, _label) => {
+            const dto = { ...baseValidDto, value: invalidValue };
+            const errors = (0, field_validator_1.validateFieldDto)(dto);
+            expect(errors.some((e) => e.property === 'value')).toBe(true);
+        });
+        it('should return error if value is empty string when required', () => {
+            const dto = { ...baseValidDto, value: '' };
+            const errors = (0, field_validator_1.validateFieldDto)(dto);
+            expect(errors.some((e) => e.property === 'value')).toBe(true);
+        });
     });
 });

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

@@ -1,24 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
+// import { ProductInfoDto } from '../dtos/product/product-info.dto';
 const item_actions_enum_1 = require("../enums/item-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 validField = {
-        field: {
-            id: 'field',
-            label: [{ language: language_enum_1.LanguageEnum.ENGLISH, text: 'label' }],
-            type: 'TEXT',
-            required: false,
-            disabled: false,
-            hidden: false,
-            upgradable: false,
-            value: 'string',
-        },
+    const field = {
+        id: 'field',
+        label: [{ language: language_enum_1.LanguageEnum.ENGLISH, text: 'label' }],
+        value: 'string',
+        type: field_type_enum_1.FieldTypeEnum.TEXT_BOX,
+        required: false,
+        disabled: false,
+        hidden: false,
+        upgradable: false,
     };
     const invalidField = {
-    // missing required field, so `field` is undefined
+        id: 'field',
+        label: [{ language: language_enum_1.LanguageEnum.ENGLISH, text: 'label' }],
+        value: 'string',
+        type: field_type_enum_1.FieldTypeEnum.TEXT_BOX,
+        disabled: false,
+        upgradable: false,
     };
     const testCases = [
         {
@@ -27,13 +32,13 @@ describe('ProductInfoDto Validator', () => {
                 title: 'Test',
                 supportedActions: [item_actions_enum_1.ProductActionsEnum.CREATE],
                 supportedLanguages: [language_enum_1.LanguageEnum.ENGLISH],
-                productAttributes: [validField],
-                itemAttributes: [validField],
+                productAttributes: [field],
+                itemAttributes: [field],
             },
             expectedErrorsLength: 0,
         },
         {
-            description: 'should return error for missing field in attribute',
+            description: 'should return error for invalid required and hidden',
             dto: {
                 title: 'Test',
                 supportedActions: [item_actions_enum_1.ProductActionsEnum.CREATE],
@@ -48,8 +53,8 @@ describe('ProductInfoDto Validator', () => {
                 title: '',
                 supportedActions: [item_actions_enum_1.ProductActionsEnum.CREATE],
                 supportedLanguages: [language_enum_1.LanguageEnum.ENGLISH],
-                productAttributes: [validField],
-                itemAttributes: [validField],
+                productAttributes: [field],
+                itemAttributes: [field],
             },
             expectedErrorsLength: 1,
         },
@@ -59,8 +64,8 @@ describe('ProductInfoDto Validator', () => {
                 title: 'Test',
                 supportedActions: ['update'],
                 supportedLanguages: [language_enum_1.LanguageEnum.ENGLISH],
-                productAttributes: [validField],
-                itemAttributes: [validField],
+                productAttributes: [field],
+                itemAttributes: [field],
             },
             expectedErrorsLength: 1,
         },
@@ -70,8 +75,8 @@ describe('ProductInfoDto Validator', () => {
                 title: 'Test',
                 supportedActions: [item_actions_enum_1.ProductActionsEnum.CREATE],
                 supportedLanguages: [],
-                productAttributes: [validField],
-                itemAttributes: [validField],
+                productAttributes: [field],
+                itemAttributes: [field],
             },
             expectedErrorsLength: 1,
         },
@@ -81,8 +86,8 @@ describe('ProductInfoDto Validator', () => {
                 title: 'Test',
                 supportedActions: [item_actions_enum_1.ProductActionsEnum.CREATE],
                 supportedLanguages: [language_enum_1.LanguageEnum.ENGLISH],
-                productAttributes: [validField],
-                itemAttributes: [validField],
+                productAttributes: [field],
+                itemAttributes: [field],
                 adminPanel: {
                     tabs: {
                         product: [{ label: 'Product', url: 'https://example.com/product' }],
@@ -100,10 +105,14 @@ describe('ProductInfoDto Validator', () => {
                 title: '',
                 supportedActions: [item_actions_enum_1.ProductActionsEnum.CREATE],
                 supportedLanguages: [language_enum_1.LanguageEnum.ENGLISH],
-                productAttributes: [validField],
-                itemAttributes: [validField],
-                adminPanel: {},
-                clientPanel: {},
+                productAttributes: [field],
+                itemAttributes: [field],
+                adminPanel: {
+                /* invalid admin panel data */
+                },
+                clientPanel: {
+                /* invalid client panel data */
+                },
             },
             expectedErrorsLength: 3,
         },
@@ -113,8 +122,8 @@ describe('ProductInfoDto Validator', () => {
                 title: 'Test',
                 supportedActions: [item_actions_enum_1.ProductActionsEnum.CREATE],
                 supportedLanguages: [language_enum_1.LanguageEnum.ENGLISH],
-                productAttributes: [validField],
-                itemAttributes: [validField],
+                productAttributes: [field],
+                itemAttributes: [field],
                 payPerUseUnits: [
                     { id: 'ram', unitDescription: 'MB', intervalDescription: 'month' },
                 ],
@@ -127,8 +136,8 @@ describe('ProductInfoDto Validator', () => {
                 title: 'Test',
                 supportedActions: [item_actions_enum_1.ProductActionsEnum.CREATE],
                 supportedLanguages: [language_enum_1.LanguageEnum.ENGLISH],
-                productAttributes: [validField],
-                itemAttributes: [validField],
+                productAttributes: [field],
+                itemAttributes: [field],
                 payPerUseUnits: [
                     { id: '', unitDescription: '', intervalDescription: '' },
                 ],
@@ -142,10 +151,49 @@ describe('ProductInfoDto Validator', () => {
             expect(errors.length).toBe(expectedErrorsLength);
         });
     });
-    describe('AttributeFieldDto class-level constraints inside ProductInfoDto', () => {
-        it('fails when an AttributeFieldDto has only repeatableMin (AllOrNone)', () => {
+    const validationErrorTestCases = [
+        {
+            description: 'should return ValidationError for missing title',
+            dto: {
+                supportedActions: [item_actions_enum_1.ProductActionsEnum.CREATE],
+                supportedLanguages: [language_enum_1.LanguageEnum.ENGLISH],
+                productAttributes: [field],
+                itemAttributes: [field],
+            },
+            expectedErrors: ['title'],
+        },
+        {
+            description: 'should return ValidationError for unsupported action',
+            dto: {
+                title: 'Test',
+                supportedActions: ['update'],
+                supportedLanguages: [language_enum_1.LanguageEnum.ENGLISH],
+                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 repeatableMin (AllOrNone)', () => {
             const fieldWithOnlyMin = {
-                ...validField,
+                id: 'f1',
+                label: [{ language: language_enum_1.LanguageEnum.ENGLISH, text: 'label' }],
+                value: 'v',
+                type: field_type_enum_1.FieldTypeEnum.TEXT_BOX,
+                required: false,
+                disabled: false,
+                hidden: false,
+                upgradable: false,
                 repeatableMin: 1,
             };
             const dto = {
@@ -157,9 +205,16 @@ describe('ProductInfoDto Validator', () => {
             const errors = (0, product_info_validator_1.validateProductInfoDto)(dto);
             expect(errors.length).toBeGreaterThan(0);
         });
-        it('fails when an AttributeFieldDto has only repeatableMax (AllOrNone)', () => {
+        it('fails when a FieldDto has only repeatableMax (AllOrNone)', () => {
             const fieldWithOnlyMax = {
-                ...validField,
+                id: 'f2',
+                label: [{ language: language_enum_1.LanguageEnum.ENGLISH, text: 'label' }],
+                value: 'v',
+                type: field_type_enum_1.FieldTypeEnum.TEXT_BOX,
+                required: false,
+                disabled: false,
+                upgradable: false,
+                hidden: false,
                 repeatableMax: 5,
             };
             const dto = {
@@ -171,11 +226,15 @@ describe('ProductInfoDto Validator', () => {
             const errors = (0, product_info_validator_1.validateProductInfoDto)(dto);
             expect(errors.length).toBeGreaterThan(0);
         });
-        it('passes when an AttributeFieldDto has both min and max with min <= max', () => {
+        it('passes when a FieldDto has both min and max with min <= max', () => {
             const fieldOk = {
-                ...validField,
-                repeatableMin: 1,
-                repeatableMax: 3,
+                id: 'f3',
+                label: [{ language: language_enum_1.LanguageEnum.ENGLISH, text: 'label' }],
+                value: 'v',
+                type: field_type_enum_1.FieldTypeEnum.TEXT_BOX,
+                required: false,
+                disabled: false,
+                hidden: false,
             };
             const dto = {
                 title: 'Test',
@@ -185,9 +244,16 @@ describe('ProductInfoDto Validator', () => {
             };
             expect((0, product_info_validator_1.validateProductInfoDto)(dto)).toHaveLength(0);
         });
-        it('fails when an AttributeFieldDto has min > max (Min<=Max)', () => {
+        it('fails when a FieldDto has both min and max with min > max (Min<=Max)', () => {
             const fieldBad = {
-                ...validField,
+                id: 'f4',
+                label: [{ language: language_enum_1.LanguageEnum.ENGLISH, text: 'label' }],
+                value: 'v',
+                type: field_type_enum_1.FieldTypeEnum.TEXT_BOX,
+                required: false,
+                disabled: false,
+                hidden: false,
+                upgradable: false,
                 repeatableMin: 5,
                 repeatableMax: 2,
             };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hosterai/types",
-  "version": "0.0.31",
+  "version": "0.0.32",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {