@fiado/type-kit 3.181.0 → 3.183.0

package/_test_/unit/retailOrg/dtos/requests/retailUserRequests.test.ts

@@ -0,0 +1,86 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import { CreateRetailUserRequest } from '../../../../../src/retailOrg/dtos/requests/CreateRetailUserRequest';
+import { UpdateRetailUserRequest } from '../../../../../src/retailOrg/dtos/requests/UpdateRetailUserRequest';
+import { ChangeRetailUserStatusRequest } from '../../../../../src/retailOrg/dtos/requests/ChangeRetailUserStatusRequest';
+import { TransferRetailUserRequest } from '../../../../../src/retailOrg/dtos/requests/TransferRetailUserRequest';
+import { EmploymentTypeEnum } from '../../../../../src/retailOrg/enums/EmploymentTypeEnum';
+import { RetailUserStatusEnum } from '../../../../../src/retailOrg/enums/RetailUserStatusEnum';
+
+const validCreate = {
+    cognitoSub: '5f7c8a90-1234-4abc-9def-0123456789ab',
+    homeStoreId: 'store_001',
+    employmentType: EmploymentTypeEnum.EMPLOYEE,
+    commissionTier: 'TIER_A',
+    zoneId: 'zone_001',
+};
+
+describe('CreateRetailUserRequest', () => {
+    it('valida happy path', async () => {
+        const dto = plainToInstance(CreateRetailUserRequest, validCreate);
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it('valida con zoneId en null', async () => {
+        const dto = plainToInstance(CreateRetailUserRequest, { ...validCreate, zoneId: null });
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it('falla si employmentType está fuera del enum', async () => {
+        const dto = plainToInstance(CreateRetailUserRequest, { ...validCreate, employmentType: 'INTERN' });
+        const errors = await validate(dto);
+        expect(errors.some(e => e.property === 'employmentType')).toBe(true);
+    });
+
+    it('falla si falta cognitoSub', async () => {
+        const { cognitoSub, ...rest } = validCreate;
+        const dto = plainToInstance(CreateRetailUserRequest, rest);
+        const errors = await validate(dto);
+        expect(errors.some(e => e.property === 'cognitoSub')).toBe(true);
+    });
+});
+
+describe('UpdateRetailUserRequest', () => {
+    it('valida vacío (todos opcionales)', async () => {
+        const dto = plainToInstance(UpdateRetailUserRequest, {});
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it('falla si employmentType enviado está fuera del enum', async () => {
+        const dto = plainToInstance(UpdateRetailUserRequest, { employmentType: 'INTERN' });
+        const errors = await validate(dto);
+        expect(errors.some(e => e.property === 'employmentType')).toBe(true);
+    });
+});
+
+describe('ChangeRetailUserStatusRequest', () => {
+    it('valida un status del enum', async () => {
+        const dto = plainToInstance(ChangeRetailUserStatusRequest, { status: RetailUserStatusEnum.SUSPENDED });
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it('falla si status está fuera del enum', async () => {
+        const dto = plainToInstance(ChangeRetailUserStatusRequest, { status: 'BANNED' });
+        const errors = await validate(dto);
+        expect(errors.some(e => e.property === 'status')).toBe(true);
+    });
+});
+
+describe('TransferRetailUserRequest', () => {
+    it('valida happy path', async () => {
+        const dto = plainToInstance(TransferRetailUserRequest, { newHomeStoreId: 'store_002' });
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it('falla si falta newHomeStoreId', async () => {
+        const dto = plainToInstance(TransferRetailUserRequest, {});
+        const errors = await validate(dto);
+        expect(errors.some(e => e.property === 'newHomeStoreId')).toBe(true);
+    });
+});

package/_test_/unit/retailOrg/dtos/requests/retailerRequests.test.ts

@@ -0,0 +1,153 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import { CreateRetailerRequest } from '../../../../../src/retailOrg/dtos/requests/CreateRetailerRequest';
+import { UpdateRetailerRequest } from '../../../../../src/retailOrg/dtos/requests/UpdateRetailerRequest';
+import { ChangeRetailerStatusRequest } from '../../../../../src/retailOrg/dtos/requests/ChangeRetailerStatusRequest';
+import { CreateSubdistributorRequest } from '../../../../../src/retailOrg/dtos/requests/CreateSubdistributorRequest';
+import { RetailerTypeEnum } from '../../../../../src/retailOrg/enums/RetailerTypeEnum';
+import { RetailerStatusEnum } from '../../../../../src/retailOrg/enums/RetailerStatusEnum';
+
+const address = {
+    address1: 'Av. Reforma',
+    externalNumber: '100',
+    city: 'Ciudad de México',
+    state: 'CDMX',
+    zipCode: '01000',
+    country: 'MX',
+};
+
+const validCreate = {
+    type: RetailerTypeEnum.CADENA,
+    name: 'Tiendas del Centro',
+    legalName: 'Tiendas del Centro SA de CV',
+    rfc: 'VEN123456ABC',
+    contactEmail: 'contacto@tdc.mx',
+    contactPhone: '+525512345678',
+    address,
+};
+
+describe('CreateRetailerRequest', () => {
+    it('valida happy path (0 errores)', async () => {
+        const dto = plainToInstance(CreateRetailerRequest, validCreate);
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it('NO expone campos server-assigned (retailerId/status/createdAt no están en el shape)', () => {
+        const dto = plainToInstance(
+            CreateRetailerRequest,
+            { ...validCreate, retailerId: 'hack', status: 'ACTIVE' } as object,
+            { excludeExtraneousValues: true },
+        );
+        expect((dto as unknown as Record<string, unknown>).retailerId).toBeUndefined();
+        expect((dto as unknown as Record<string, unknown>).status).toBeUndefined();
+    });
+
+    it('falla si rfc tiene 11 caracteres', async () => {
+        const dto = plainToInstance(CreateRetailerRequest, { ...validCreate, rfc: 'VEN123456AB' });
+        const errors = await validate(dto);
+        expect(errors.some(e => e.property === 'rfc')).toBe(true);
+    });
+
+    it('falla si contactEmail no es email', async () => {
+        const dto = plainToInstance(CreateRetailerRequest, { ...validCreate, contactEmail: 'nope' });
+        const errors = await validate(dto);
+        expect(errors.some(e => e.property === 'contactEmail')).toBe(true);
+    });
+
+    it('falla si address viene vacío', async () => {
+        const dto = plainToInstance(CreateRetailerRequest, { ...validCreate, address: {} });
+        const errors = await validate(dto);
+        expect(errors.some(e => e.property === 'address')).toBe(true);
+    });
+
+    it('falla si type está fuera del enum', async () => {
+        const dto = plainToInstance(CreateRetailerRequest, { ...validCreate, type: 'OTRO' });
+        const errors = await validate(dto);
+        expect(errors.some(e => e.property === 'type')).toBe(true);
+    });
+});
+
+describe('UpdateRetailerRequest', () => {
+    it('valida con todos los campos ausentes (todos opcionales)', async () => {
+        const dto = plainToInstance(UpdateRetailerRequest, {});
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it('valida un update parcial (solo name)', async () => {
+        const dto = plainToInstance(UpdateRetailerRequest, { name: 'Nuevo nombre' });
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it('valida el contenido de address si se envía (falla si incompleto)', async () => {
+        const dto = plainToInstance(UpdateRetailerRequest, { address: { city: 'CDMX' } });
+        const errors = await validate(dto);
+        expect(errors.some(e => e.property === 'address')).toBe(true);
+    });
+
+    it('NO permite editar rfc/type/status (no están en el shape)', () => {
+        const dto = plainToInstance(
+            UpdateRetailerRequest,
+            { rfc: 'X', type: 'CADENA', status: 'ACTIVE' } as object,
+            { excludeExtraneousValues: true },
+        );
+        expect((dto as unknown as Record<string, unknown>).rfc).toBeUndefined();
+        expect((dto as unknown as Record<string, unknown>).type).toBeUndefined();
+        expect((dto as unknown as Record<string, unknown>).status).toBeUndefined();
+    });
+});
+
+describe('ChangeRetailerStatusRequest', () => {
+    it('valida un status del enum', async () => {
+        const dto = plainToInstance(ChangeRetailerStatusRequest, { status: RetailerStatusEnum.SUSPENDED });
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it('falla si status está fuera del enum', async () => {
+        const dto = plainToInstance(ChangeRetailerStatusRequest, { status: 'FROZEN' });
+        const errors = await validate(dto);
+        expect(errors.some(e => e.property === 'status')).toBe(true);
+    });
+});
+
+describe('CreateSubdistributorRequest', () => {
+    it('valida SUBDISTRIBUIDOR', async () => {
+        const dto = plainToInstance(CreateSubdistributorRequest, {
+            ...validCreate,
+            type: RetailerTypeEnum.SUBDISTRIBUIDOR,
+        });
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it('valida FRANQUICIA', async () => {
+        const dto = plainToInstance(CreateSubdistributorRequest, {
+            ...validCreate,
+            type: RetailerTypeEnum.FRANQUICIA,
+        });
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it('falla si type es CADENA (un subdistribuidor no puede ser cadena raíz)', async () => {
+        const dto = plainToInstance(CreateSubdistributorRequest, {
+            ...validCreate,
+            type: RetailerTypeEnum.CADENA,
+        });
+        const errors = await validate(dto);
+        expect(errors.some(e => e.property === 'type')).toBe(true);
+    });
+
+    it('NO expone parentId (viene del path param)', () => {
+        const dto = plainToInstance(
+            CreateSubdistributorRequest,
+            { ...validCreate, type: RetailerTypeEnum.SUBDISTRIBUIDOR, parentId: 'ret_root' } as object,
+            { excludeExtraneousValues: true },
+        );
+        expect((dto as unknown as Record<string, unknown>).parentId).toBeUndefined();
+    });
+});

package/_test_/unit/retailOrg/dtos/requests/storeRequests.test.ts

@@ -0,0 +1,107 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import { CreateStoreRequest } from '../../../../../src/retailOrg/dtos/requests/CreateStoreRequest';
+import { UpdateStoreRequest } from '../../../../../src/retailOrg/dtos/requests/UpdateStoreRequest';
+import { ChangeStoreStatusRequest } from '../../../../../src/retailOrg/dtos/requests/ChangeStoreStatusRequest';
+import { StoreStatusEnum } from '../../../../../src/retailOrg/enums/StoreStatusEnum';
+
+const address = {
+    address1: 'Av. Constitución',
+    externalNumber: '500',
+    city: 'Monterrey',
+    state: 'Nuevo León',
+    zipCode: '64000',
+    country: 'MX',
+};
+
+const validCreate = {
+    zoneId: 'zone_001',
+    code: 'MTY-001',
+    name: 'Sucursal Centro',
+    address,
+    location: { lat: 25.6866, lng: -100.3161 },
+    phone: '+528112345678',
+    managerRetailUserId: 'ru_010',
+    schedule: 'L-V 9:00-18:00',
+    dailyAvgSalesCents: 1500000,
+};
+
+describe('CreateStoreRequest', () => {
+    it('valida happy path', async () => {
+        const dto = plainToInstance(CreateStoreRequest, validCreate);
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it('valida con los campos nullable en null', async () => {
+        const dto = plainToInstance(CreateStoreRequest, {
+            ...validCreate,
+            zoneId: null,
+            managerRetailUserId: null,
+            schedule: null,
+            dailyAvgSalesCents: null,
+        });
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it('falla si code supera 10 caracteres', async () => {
+        const dto = plainToInstance(CreateStoreRequest, { ...validCreate, code: 'ABCDEFGHIJK' });
+        const errors = await validate(dto);
+        expect(errors.some(e => e.property === 'code')).toBe(true);
+    });
+
+    it('falla si location está ausente (obligatoria)', async () => {
+        const { location, ...rest } = validCreate;
+        const dto = plainToInstance(CreateStoreRequest, rest);
+        const errors = await validate(dto);
+        expect(errors.some(e => e.property === 'location')).toBe(true);
+    });
+
+    it('falla si location viene sin lat/lng', async () => {
+        const dto = plainToInstance(CreateStoreRequest, { ...validCreate, location: {} });
+        const errors = await validate(dto);
+        expect(errors.some(e => e.property === 'location')).toBe(true);
+    });
+
+    it('falla si address viene vacío', async () => {
+        const dto = plainToInstance(CreateStoreRequest, { ...validCreate, address: {} });
+        const errors = await validate(dto);
+        expect(errors.some(e => e.property === 'address')).toBe(true);
+    });
+});
+
+describe('UpdateStoreRequest', () => {
+    it('valida vacío (todos opcionales)', async () => {
+        const dto = plainToInstance(UpdateStoreRequest, {});
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it('valida update parcial (solo phone)', async () => {
+        const dto = plainToInstance(UpdateStoreRequest, { phone: '+528100000000' });
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it('valida location si se envía (falla sin lat/lng)', async () => {
+        const dto = plainToInstance(UpdateStoreRequest, { location: {} });
+        const errors = await validate(dto);
+        expect(errors.some(e => e.property === 'location')).toBe(true);
+    });
+});
+
+describe('ChangeStoreStatusRequest', () => {
+    it('valida un status del enum', async () => {
+        const dto = plainToInstance(ChangeStoreStatusRequest, { status: StoreStatusEnum.SUSPENDED });
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it('falla si status está fuera del enum', async () => {
+        const dto = plainToInstance(ChangeStoreStatusRequest, { status: 'CLOSED' });
+        const errors = await validate(dto);
+        expect(errors.some(e => e.property === 'status')).toBe(true);
+    });
+});

package/_test_/unit/retailOrg/dtos/requests/zoneRequests.test.ts

@@ -0,0 +1,49 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import { CreateZoneRequest } from '../../../../../src/retailOrg/dtos/requests/CreateZoneRequest';
+import { UpdateZoneRequest } from '../../../../../src/retailOrg/dtos/requests/UpdateZoneRequest';
+import { ChangeZoneStatusRequest } from '../../../../../src/retailOrg/dtos/requests/ChangeZoneStatusRequest';
+import { ZoneStatusEnum } from '../../../../../src/retailOrg/enums/ZoneStatusEnum';
+
+describe('CreateZoneRequest', () => {
+    it('valida happy path', async () => {
+        const dto = plainToInstance(CreateZoneRequest, { name: 'Zona Norte', region: 'Nuevo León' });
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it('falla si falta name', async () => {
+        const dto = plainToInstance(CreateZoneRequest, { region: 'Nuevo León' });
+        const errors = await validate(dto);
+        expect(errors.some(e => e.property === 'name')).toBe(true);
+    });
+});
+
+describe('UpdateZoneRequest', () => {
+    it('valida vacío (todos opcionales)', async () => {
+        const dto = plainToInstance(UpdateZoneRequest, {});
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it('falla si name se envía con tipo inválido', async () => {
+        const dto = plainToInstance(UpdateZoneRequest, { name: 123 });
+        const errors = await validate(dto);
+        expect(errors.some(e => e.property === 'name')).toBe(true);
+    });
+});
+
+describe('ChangeZoneStatusRequest', () => {
+    it('valida un status del enum', async () => {
+        const dto = plainToInstance(ChangeZoneStatusRequest, { status: ZoneStatusEnum.INACTIVE });
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it('falla si status está fuera del enum', async () => {
+        const dto = plainToInstance(ChangeZoneStatusRequest, { status: 'PAUSED' });
+        const errors = await validate(dto);
+        expect(errors.some(e => e.property === 'status')).toBe(true);
+    });
+});

package/_test_/unit/retailOrg/dtos/responses/RetailerHierarchyResponse.test.ts

@@ -0,0 +1,42 @@
+import { RetailerHierarchyResponse } from '../../../../../src/retailOrg/dtos/responses/RetailerHierarchyResponse';
+import { Retailer } from '../../../../../src/retailOrg/dtos/Retailer';
+import { RetailerTypeEnum } from '../../../../../src/retailOrg/enums/RetailerTypeEnum';
+import { RetailerStatusEnum } from '../../../../../src/retailOrg/enums/RetailerStatusEnum';
+
+function retailer(id: string): Retailer {
+    return {
+        retailerId: id,
+        parentId: 'ROOT',
+        type: RetailerTypeEnum.CADENA,
+        name: `Retailer ${id}`,
+        legalName: `Retailer ${id} SA de CV`,
+        rfc: 'VEN123456ABC',
+        contactEmail: 'c@x.mx',
+        contactPhone: '+525512345678',
+        address: { city: 'CDMX', region: 'CDMX', zipCode: '01000' } as Retailer['address'],
+        status: RetailerStatusEnum.ACTIVE,
+        createdAt: '2026-07-14T10:00:00.000Z',
+        updatedAt: '2026-07-14T10:00:00.000Z',
+        createdBy: 'system',
+        updatedBy: 'system',
+    };
+}
+
+describe('RetailerHierarchyResponse', () => {
+    it('modela un árbol recursivo (retailer + children)', () => {
+        const tree: RetailerHierarchyResponse = {
+            retailer: retailer('root'),
+            children: [
+                { retailer: retailer('sub_1'), children: [] },
+                {
+                    retailer: retailer('sub_2'),
+                    children: [{ retailer: retailer('sub_2_1'), children: [] }],
+                },
+            ],
+        };
+
+        expect(tree.retailer.retailerId).toBe('root');
+        expect(tree.children).toHaveLength(2);
+        expect(tree.children[1].children[0].retailer.retailerId).toBe('sub_2_1');
+    });
+});

package/_test_/unit/retailOrg/dtos/validation/validationDtos.test.ts

@@ -0,0 +1,49 @@
+import { RetailerValidationDto } from '../../../../../src/retailOrg/dtos/validation/RetailerValidationDto';
+import { StoreValidationDto } from '../../../../../src/retailOrg/dtos/validation/StoreValidationDto';
+import { RetailUserValidationDto } from '../../../../../src/retailOrg/dtos/validation/RetailUserValidationDto';
+import { RetailerTypeEnum } from '../../../../../src/retailOrg/enums/RetailerTypeEnum';
+import { RetailerStatusEnum } from '../../../../../src/retailOrg/enums/RetailerStatusEnum';
+import { StoreStatusEnum } from '../../../../../src/retailOrg/enums/StoreStatusEnum';
+import { EmploymentTypeEnum } from '../../../../../src/retailOrg/enums/EmploymentTypeEnum';
+import { RetailUserStatusEnum } from '../../../../../src/retailOrg/enums/RetailUserStatusEnum';
+
+describe('ValidationDtos (shapes mínimos de endpoints privados)', () => {
+    it('RetailerValidationDto acepta el shape mínimo', () => {
+        const dto: RetailerValidationDto = {
+            retailerId: 'ret_001',
+            name: 'Tiendas del Centro',
+            type: RetailerTypeEnum.CADENA,
+            status: RetailerStatusEnum.ACTIVE,
+            parentId: 'ROOT',
+        };
+        expect(dto.retailerId).toBe('ret_001');
+        expect(dto.type).toBe(RetailerTypeEnum.CADENA);
+    });
+
+    it('StoreValidationDto acepta el shape mínimo (zoneId nullable)', () => {
+        const dto: StoreValidationDto = {
+            storeId: 'store_001',
+            retailerId: 'ret_001',
+            zoneId: null,
+            code: 'MTY-001',
+            name: 'Sucursal Centro',
+            status: StoreStatusEnum.ACTIVE,
+        };
+        expect(dto.zoneId).toBeNull();
+        expect(dto.status).toBe(StoreStatusEnum.ACTIVE);
+    });
+
+    it('RetailUserValidationDto acepta el shape mínimo', () => {
+        const dto: RetailUserValidationDto = {
+            retailUserId: 'ru_001',
+            cognitoSub: '5f7c8a90-1234-4abc-9def-0123456789ab',
+            retailerId: 'ret_001',
+            homeStoreId: 'store_001',
+            employmentType: EmploymentTypeEnum.EMPLOYEE,
+            commissionTier: 'TIER_A',
+            status: RetailUserStatusEnum.ACTIVE,
+        };
+        expect(dto.employmentType).toBe(EmploymentTypeEnum.EMPLOYEE);
+        expect(dto.commissionTier).toBe('TIER_A');
+    });
+});

package/_test_/unit/retailOrg/enums/EmploymentTypeEnum.test.ts

@@ -0,0 +1,15 @@
+import { EmploymentTypeEnum } from '../../../../src/retailOrg/enums/EmploymentTypeEnum';
+
+describe('EmploymentTypeEnum', () => {
+    it('contiene exactamente los tipos del contrato con value === key', () => {
+        expect(EmploymentTypeEnum.EMPLOYEE).toBe('EMPLOYEE');
+        expect(EmploymentTypeEnum.CONTRACTOR).toBe('CONTRACTOR');
+        expect(EmploymentTypeEnum.FRANCHISEE_STAFF).toBe('FRANCHISEE_STAFF');
+    });
+
+    it('no tiene valores de más', () => {
+        expect(Object.values(EmploymentTypeEnum).sort()).toEqual(
+            ['CONTRACTOR', 'EMPLOYEE', 'FRANCHISEE_STAFF'],
+        );
+    });
+});

package/_test_/unit/retailOrg/enums/RetailUserStatusEnum.test.ts

@@ -0,0 +1,15 @@
+import { RetailUserStatusEnum } from '../../../../src/retailOrg/enums/RetailUserStatusEnum';
+
+describe('RetailUserStatusEnum', () => {
+    it('contiene exactamente los estados del contrato con value === key', () => {
+        expect(RetailUserStatusEnum.ACTIVE).toBe('ACTIVE');
+        expect(RetailUserStatusEnum.SUSPENDED).toBe('SUSPENDED');
+        expect(RetailUserStatusEnum.INACTIVE).toBe('INACTIVE');
+    });
+
+    it('no tiene estados de más', () => {
+        expect(Object.values(RetailUserStatusEnum).sort()).toEqual(
+            ['ACTIVE', 'INACTIVE', 'SUSPENDED'],
+        );
+    });
+});

package/_test_/unit/retailOrg/enums/RetailerStatusEnum.test.ts

@@ -0,0 +1,15 @@
+import { RetailerStatusEnum } from '../../../../src/retailOrg/enums/RetailerStatusEnum';
+
+describe('RetailerStatusEnum', () => {
+    it('contiene exactamente los estados del contrato con value === key', () => {
+        expect(RetailerStatusEnum.ACTIVE).toBe('ACTIVE');
+        expect(RetailerStatusEnum.SUSPENDED).toBe('SUSPENDED');
+        expect(RetailerStatusEnum.INACTIVE).toBe('INACTIVE');
+    });
+
+    it('no tiene estados de más', () => {
+        expect(Object.values(RetailerStatusEnum).sort()).toEqual(
+            ['ACTIVE', 'INACTIVE', 'SUSPENDED'],
+        );
+    });
+});

package/_test_/unit/retailOrg/enums/RetailerTypeEnum.test.ts

@@ -0,0 +1,15 @@
+import { RetailerTypeEnum } from '../../../../src/retailOrg/enums/RetailerTypeEnum';
+
+describe('RetailerTypeEnum', () => {
+    it('contiene exactamente los tipos del contrato con value === key', () => {
+        expect(RetailerTypeEnum.CADENA).toBe('CADENA');
+        expect(RetailerTypeEnum.SUBDISTRIBUIDOR).toBe('SUBDISTRIBUIDOR');
+        expect(RetailerTypeEnum.FRANQUICIA).toBe('FRANQUICIA');
+    });
+
+    it('no tiene valores de más', () => {
+        expect(Object.values(RetailerTypeEnum).sort()).toEqual(
+            ['CADENA', 'FRANQUICIA', 'SUBDISTRIBUIDOR'],
+        );
+    });
+});

package/_test_/unit/retailOrg/enums/StoreStatusEnum.test.ts

@@ -0,0 +1,15 @@
+import { StoreStatusEnum } from '../../../../src/retailOrg/enums/StoreStatusEnum';
+
+describe('StoreStatusEnum', () => {
+    it('contiene exactamente los estados del contrato con value === key', () => {
+        expect(StoreStatusEnum.ACTIVE).toBe('ACTIVE');
+        expect(StoreStatusEnum.SUSPENDED).toBe('SUSPENDED');
+        expect(StoreStatusEnum.INACTIVE).toBe('INACTIVE');
+    });
+
+    it('no tiene estados de más', () => {
+        expect(Object.values(StoreStatusEnum).sort()).toEqual(
+            ['ACTIVE', 'INACTIVE', 'SUSPENDED'],
+        );
+    });
+});

package/_test_/unit/retailOrg/enums/ZoneStatusEnum.test.ts

@@ -0,0 +1,14 @@
+import { ZoneStatusEnum } from '../../../../src/retailOrg/enums/ZoneStatusEnum';
+
+describe('ZoneStatusEnum', () => {
+    it('contiene exactamente los estados del contrato con value === key', () => {
+        expect(ZoneStatusEnum.ACTIVE).toBe('ACTIVE');
+        expect(ZoneStatusEnum.INACTIVE).toBe('INACTIVE');
+    });
+
+    it('no tiene estados de más', () => {
+        expect(Object.values(ZoneStatusEnum).sort()).toEqual(
+            ['ACTIVE', 'INACTIVE'],
+        );
+    });
+});

package/bin/benefitCenter/dtos/BenefitCreateRequest.d.ts

@@ -1,4 +1,3 @@
-import { BenefitFlowEnum } from "../enums/BenefitFlowEnum";
 import { BenefitModuleConfigRequest } from "./BenefitModuleConfigRequest";
 /** Mirror enum-like de BenefitCatalogStatus en el type-kit (para validación). */
 export declare enum BenefitCatalogStatusEnum {
@@ -13,7 +12,7 @@ export declare class BenefitCreateRequest {
     status: BenefitCatalogStatusEnum;
     sortOrder: number;
     icon?: string;
-    flow: BenefitFlowEnum;
+    flow: string;
     translationKey?: string;
     moduleConfig: BenefitModuleConfigRequest;
     /**

package/bin/benefitCenter/dtos/BenefitCreateRequest.js

@@ -12,7 +12,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BenefitCreateRequest = exports.BenefitCatalogStatusEnum = void 0;
 const class_validator_1 = require("class-validator");
 const class_transformer_1 = require("class-transformer");
-const BenefitFlowEnum_1 = require("../enums/BenefitFlowEnum");
 const BenefitModuleConfigRequest_1 = require("./BenefitModuleConfigRequest");
 /** Mirror enum-like de BenefitCatalogStatus en el type-kit (para validación). */
 var BenefitCatalogStatusEnum;
@@ -54,7 +53,8 @@ __decorate([
     __metadata("design:type", String)
 ], BenefitCreateRequest.prototype, "icon", void 0);
 __decorate([
-    (0, class_validator_1.IsEnum)(BenefitFlowEnum_1.BenefitFlowEnum),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
     __metadata("design:type", String)
 ], BenefitCreateRequest.prototype, "flow", void 0);
 __decorate([

package/bin/benefitCenter/dtos/BenefitItem.d.ts

@@ -1,10 +1,9 @@
-import { BenefitFlowEnum } from "../enums/BenefitFlowEnum";
 export declare class BenefitItem {
     id: string;
     name: string;
     description: string;
     icon: string;
-    flow: BenefitFlowEnum;
+    flow: string;
     translationKey: string;
     sortOrder: number;
 }

package/bin/benefitCenter/dtos/BenefitSummary.d.ts

@@ -1,7 +1,6 @@
-import { BenefitFlowEnum } from "../enums/BenefitFlowEnum";
 export declare class BenefitSummary {
     id: string;
     name: string;
-    flow: BenefitFlowEnum;
+    flow: string;
     version: string;
 }

package/bin/benefitCenter/dtos/BenefitUpdateRequest.d.ts

@@ -1,4 +1,3 @@
-import { BenefitFlowEnum } from "../enums/BenefitFlowEnum";
 import { BenefitCatalogStatusEnum } from "./BenefitCreateRequest";
 import { BenefitModuleConfigRequest } from "./BenefitModuleConfigRequest";
 export declare class BenefitUpdateRequest {
@@ -7,7 +6,7 @@ export declare class BenefitUpdateRequest {
     status?: BenefitCatalogStatusEnum;
     sortOrder?: number;
     icon?: string;
-    flow?: BenefitFlowEnum;
+    flow?: string;
     translationKey?: string;
     moduleConfig?: BenefitModuleConfigRequest;
     /**