@fiado/type-kit 3.471.0 → 3.473.0

package/_test_/unit/retailPromotions/salePromotionRequests.test.ts

@@ -0,0 +1,151 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import {
+  ChangeSalePromotionStatusRequest,
+  CreateSalePromotionRequest,
+  DiscountTypeEnum,
+  ListSalePromotionLogQuery,
+  ListSalePromotionsQuery,
+  PromotionAppliesToEnum,
+  SalePromotionTransitionEnum,
+  UpdateSalePromotionRequest,
+} from '../../../src/retailPromotions/index';
+
+type Dto = new () => object;
+
+/** Rutas de propiedad con error, incluidas las anidadas (`levers.gift.skus`). */
+const errorPaths = async (dtoClass: Dto, raw: Record<string, unknown>): Promise<string[]> => {
+  const instance = plainToInstance(dtoClass, raw);
+  const errors = await validate(instance as object);
+  const walk = (list: typeof errors, prefix: string): string[] =>
+    list.flatMap((e) => {
+      const path = prefix ? `${prefix}.${e.property}` : e.property;
+      return e.children && e.children.length > 0 ? walk(e.children, path) : [path];
+    });
+  return walk(errors, '');
+};
+
+const base = {
+  name: 'Regalo de audífonos',
+  customerText: 'Llévate unos audífonos gratis',
+  levers: { deviceDiscount: { type: 'AMOUNT', amountCents: 50000 } },
+};
+
+describe('CreateSalePromotionRequest', () => {
+  it('valida el alta mínima y deja appliesTo ausente para que el lambda ponga el default', async () => {
+    const dto = plainToInstance(CreateSalePromotionRequest, base);
+    expect(await validate(dto as object)).toHaveLength(0);
+    expect(dto.appliesTo).toBeUndefined();
+    expect(dto.levers.deviceDiscount?.type).toBe(DiscountTypeEnum.AMOUNT);
+  });
+
+  it('exige nombre no vacío y palancas', async () => {
+    const paths = await errorPaths(CreateSalePromotionRequest, { customerText: 'x', name: '' });
+    expect(paths).toEqual(expect.arrayContaining(['name', 'levers']));
+  });
+
+  it('rechaza porcentaje en puntos base con decimales', async () => {
+    const paths = await errorPaths(CreateSalePromotionRequest, {
+      ...base,
+      levers: { deviceDiscount: { type: 'PERCENTAGE', percentBps: 12.5 } },
+    });
+    expect(paths).toContain('levers.deviceDiscount.percentBps');
+  });
+
+  it('pide el campo que corresponde al tipo de descuento', async () => {
+    const amount = await errorPaths(CreateSalePromotionRequest, {
+      ...base,
+      levers: { deviceDiscount: { type: 'AMOUNT', percentBps: 1000 } },
+    });
+    expect(amount).toContain('levers.deviceDiscount.amountCents');
+    const percent = await errorPaths(CreateSalePromotionRequest, {
+      ...base,
+      levers: { deviceDiscount: { type: 'PERCENTAGE', percentBps: 1000 } },
+    });
+    expect(percent).toHaveLength(0);
+  });
+
+  it('regalo por lista exige SKUs; por gama exige categoría y precio máximo', async () => {
+    const list = await errorPaths(CreateSalePromotionRequest, {
+      ...base,
+      levers: { gift: { mode: 'LIST', chooseCount: 1 } },
+    });
+    expect(list).toContain('levers.gift.skus');
+    const range = await errorPaths(CreateSalePromotionRequest, {
+      ...base,
+      levers: { gift: { mode: 'RANGE', chooseCount: 1 } },
+    });
+    expect(range).toEqual(expect.arrayContaining(['levers.gift.category', 'levers.gift.maxPriceCents']));
+    const ok = await errorPaths(CreateSalePromotionRequest, {
+      ...base,
+      levers: { gift: { mode: 'RANGE', category: 'AUDIO', maxPriceCents: 30000, chooseCount: 1 } },
+    });
+    expect(ok).toHaveLength(0);
+  });
+
+  it('valida las 7 palancas juntas', async () => {
+    const paths = await errorPaths(CreateSalePromotionRequest, {
+      ...base,
+      levers: {
+        deviceDiscount: { type: 'PERCENTAGE', percentBps: 1000 },
+        accessoryDiscount: { percentBps: 2000, maxAmountCents: null },
+        gift: { mode: 'LIST', skus: ['SKU-1'], chooseCount: 1 },
+        coupon: { type: 'AMOUNT', amountCents: 20000, validityDays: 30, scope: 'CHAIN' },
+        airtime: { rechargeCount: 3, rechargeAmountCents: 10000 },
+        extendedWarranty: { extraMonths: 6, costCents: 45000 },
+        walletBonus: { amountCents: 15000 },
+      },
+      appliesTo: 'ANY_FINANCIER',
+      scope: { tiers: ['HIGH'], productCategories: ['PHONE'], skus: null, storeIds: ['S1'] },
+      segmentation: { segmentIds: ['SEG_GOLD'], requiresActiveSurekeepCredit: true },
+      budgetMaxCents: null,
+      validFrom: '2026-10-01',
+      validUntil: null,
+      oncePerCustomer: true,
+    });
+    expect(paths).toHaveLength(0);
+  });
+
+  it('rechaza cupón sin alcance válido, appliesTo desconocido y fecha no ISO', async () => {
+    const paths = await errorPaths(CreateSalePromotionRequest, {
+      ...base,
+      levers: { coupon: { type: 'AMOUNT', amountCents: 100, validityDays: 30, scope: 'WORLD' } },
+      appliesTo: 'ANY',
+      validUntil: 'el viernes',
+      scope: { tiers: ['GIGANTE'] },
+    });
+    expect(paths).toEqual(
+      expect.arrayContaining(['levers.coupon.scope', 'appliesTo', 'validUntil', 'scope.tiers']),
+    );
+  });
+});
+
+describe('UpdateSalePromotionRequest', () => {
+  it('el parche vacío es válido y un campo mal tipado no', async () => {
+    expect(await errorPaths(UpdateSalePromotionRequest, {})).toHaveLength(0);
+    expect(await errorPaths(UpdateSalePromotionRequest, { appliesTo: PromotionAppliesToEnum.SUREKEEP_ONLY })).toHaveLength(0);
+    expect(await errorPaths(UpdateSalePromotionRequest, { budgetMaxCents: 10.5 })).toContain('budgetMaxCents');
+  });
+});
+
+describe('ChangeSalePromotionStatusRequest', () => {
+  it('acepta una transición del enum y rechaza un estado', async () => {
+    expect(await errorPaths(ChangeSalePromotionStatusRequest, { transition: SalePromotionTransitionEnum.PAUSE, reason: 'fin de stock' })).toHaveLength(0);
+    expect(await errorPaths(ChangeSalePromotionStatusRequest, { transition: 'ACTIVE' })).toContain('transition');
+  });
+});
+
+describe('queries paginadas', () => {
+  it('convierte limit del query string y lo acota', async () => {
+    const dto = plainToInstance(ListSalePromotionsQuery, { limit: '25', status: 'ARCHIVED' });
+    expect(await validate(dto as object)).toHaveLength(0);
+    expect(dto.limit).toBe(25);
+    expect(await errorPaths(ListSalePromotionsQuery, { limit: '500' })).toContain('limit');
+  });
+
+  it('el log acepta formato CSV y rechaza otro', async () => {
+    expect(await errorPaths(ListSalePromotionLogQuery, { format: 'CSV', promotionId: 'p1' })).toHaveLength(0);
+    expect(await errorPaths(ListSalePromotionLogQuery, { format: 'XLSX' })).toContain('format');
+  });
+});

package/_test_/unit/retailWizard/promotionM2mRequests.test.ts

@@ -0,0 +1,189 @@
+import 'reflect-metadata';
+import { plainToInstance, type ClassConstructor } from 'class-transformer';
+import { validateSync, type ValidationError } from 'class-validator';
+import {
+  ApplyLinePromotionRequest,
+  ApplySalePromotionRequest,
+  LinePaymentTypeEnum,
+  PaymentMethodEnum,
+  SalePaymentMethodEnum,
+  WizardLineRoleEnum,
+  WizardLineStatusEnum,
+  WizardStateEnum,
+  WizardStepEnum,
+  SetAnchorGiftsRequest,
+  type SetAnchorGiftsResponse,
+  type WizardGiftLine,
+  type PrivateWizardSessionResponse,
+  type WizardReservedLine,
+} from '../../../src/retailWizard';
+
+function paths(errors: ValidationError[], prefix = ''): string[] {
+  return errors.flatMap((e) => {
+    const p = prefix ? `${prefix}.${e.property}` : e.property;
+    return e.children && e.children.length > 0 ? paths(e.children, p) : [p];
+  });
+}
+
+function errorsOf<T extends object>(cls: ClassConstructor<T>, payload: object): string[] {
+  return paths(validateSync(plainToInstance(cls, payload) as object));
+}
+
+describe('ApplyLinePromotionRequest', () => {
+  const ok = {
+    promotionId: 'promo-1',
+    promotionVersion: 2,
+    discountCode: 'VERANO',
+    discountCents: 50000,
+    originalPriceCents: 349900,
+  };
+
+  it('acepta los campos de promo de la línea', () => expect(errorsOf(ApplyLinePromotionRequest, ok)).toEqual([]));
+  it('acepta un cuerpo vacío (la línea queda sin promo)', () =>
+    expect(errorsOf(ApplyLinePromotionRequest, {})).toEqual([]));
+  it('acepta solo el código con descuento 0 (pendiente de revalidar)', () =>
+    expect(errorsOf(ApplyLinePromotionRequest, { discountCode: 'VERANO', discountCents: 0 })).toEqual([]));
+  it('exige la versión si viene la promo', () =>
+    expect(errorsOf(ApplyLinePromotionRequest, { promotionId: 'promo-1' })).toContain('promotionVersion'));
+  it('exige la promo si viene la versión', () =>
+    expect(errorsOf(ApplyLinePromotionRequest, { promotionVersion: 1 })).toContain('promotionId'));
+  it('rechaza la versión 0', () =>
+    expect(errorsOf(ApplyLinePromotionRequest, { ...ok, promotionVersion: 0 })).toContain('promotionVersion'));
+  it('acepta la versión 1', () =>
+    expect(errorsOf(ApplyLinePromotionRequest, { ...ok, promotionVersion: 1 })).toEqual([]));
+  it('rechaza promotionId vacío', () =>
+    expect(errorsOf(ApplyLinePromotionRequest, { ...ok, promotionId: '' })).toContain('promotionId'));
+  it('rechaza discountCode vacío', () =>
+    expect(errorsOf(ApplyLinePromotionRequest, { ...ok, discountCode: '' })).toContain('discountCode'));
+  it('rechaza montos negativos o no enteros', () =>
+    expect(errorsOf(ApplyLinePromotionRequest, { ...ok, discountCents: -1, originalPriceCents: 1.5 })).toEqual(
+      expect.arrayContaining(['discountCents', 'originalPriceCents']),
+    ));
+});
+
+describe('SetAnchorGiftsRequest', () => {
+  const ok = { promotionId: 'promo-1', promotionVersion: 1, items: [{ sku: 'CASE-1' }] };
+
+  it('acepta un regalo con su promo', () => expect(errorsOf(SetAnchorGiftsRequest, ok)).toEqual([]));
+  it('acepta dos regalos', () =>
+    expect(errorsOf(SetAnchorGiftsRequest, { ...ok, items: [{ sku: 'CASE-1' }, { sku: 'MICA-1' }] })).toEqual([]));
+  it('acepta items vacío con promo y versión en null (suelta todos)', () =>
+    expect(errorsOf(SetAnchorGiftsRequest, { promotionId: null, promotionVersion: null, items: [] })).toEqual([]));
+  it('exige promotionId si hay regalos', () =>
+    expect(errorsOf(SetAnchorGiftsRequest, { ...ok, promotionId: null })).toContain('promotionId'));
+  it('exige promotionVersion si hay regalos', () =>
+    expect(errorsOf(SetAnchorGiftsRequest, { ...ok, promotionVersion: null })).toContain('promotionVersion'));
+  it('rechaza la versión 0', () =>
+    expect(errorsOf(SetAnchorGiftsRequest, { ...ok, promotionVersion: 0 })).toContain('promotionVersion'));
+  it('rechaza promotionId vacío', () =>
+    expect(errorsOf(SetAnchorGiftsRequest, { ...ok, promotionId: '' })).toContain('promotionId'));
+  it('rechaza sku vacío', () =>
+    expect(errorsOf(SetAnchorGiftsRequest, { ...ok, items: [{ sku: '' }] })).toContain('items.0.sku'));
+  it('exige items como arreglo', () =>
+    expect(errorsOf(SetAnchorGiftsRequest, { promotionId: null, promotionVersion: null })).toContain('items'));
+});
+
+describe('ApplySalePromotionRequest', () => {
+  it('acepta la promo de venta', () =>
+    expect(errorsOf(ApplySalePromotionRequest, { salePromotionId: 'sp-1', salePromotionVersion: 1 })).toEqual([]));
+  it('acepta «Ninguna» con ambos en null', () =>
+    expect(errorsOf(ApplySalePromotionRequest, { salePromotionId: null, salePromotionVersion: null })).toEqual([]));
+  it('exige salePromotionId explícito (null o valor)', () =>
+    expect(errorsOf(ApplySalePromotionRequest, {})).toContain('salePromotionId'));
+  it('exige la versión si viene la promo', () =>
+    expect(errorsOf(ApplySalePromotionRequest, { salePromotionId: 'sp-1', salePromotionVersion: null })).toContain(
+      'salePromotionVersion',
+    ));
+  it('rechaza versión sin promo', () =>
+    expect(errorsOf(ApplySalePromotionRequest, { salePromotionId: null, salePromotionVersion: 3 })).toContain(
+      'salePromotionId',
+    ));
+  it('rechaza la versión 0', () =>
+    expect(errorsOf(ApplySalePromotionRequest, { salePromotionId: 'sp-1', salePromotionVersion: 0 })).toContain(
+      'salePromotionVersion',
+    ));
+  it('rechaza salePromotionId vacío', () =>
+    expect(errorsOf(ApplySalePromotionRequest, { salePromotionId: '', salePromotionVersion: 1 })).toContain(
+      'salePromotionId',
+    ));
+});
+
+describe('respuestas de los M2M de Promociones', () => {
+  const gift: WizardGiftLine = {
+    lineId: 'L2',
+    sku: 'CASE-1',
+    qty: 1,
+    status: WizardLineStatusEnum.PENDING,
+    reservationId: 'r-2',
+    expiresAt: '2026-09-28T20:30:00.000Z',
+    basePriceCents: 0,
+    listPriceCents: 35000,
+    priceSk: null,
+    eligibleFinanciers: [],
+    financeable: false,
+    paymentType: LinePaymentTypeEnum.CASH,
+    sellItemCost: null,
+    role: WizardLineRoleEnum.GIFT,
+    linkedLineId: 'L1',
+    promotionId: 'promo-1',
+    promotionVersion: 1,
+    originalPriceCents: 35000,
+  };
+
+  it('setAnchorGifts devuelve las líneas GIFT del ancla', () => {
+    const res: SetAnchorGiftsResponse = { lines: [gift, { ...gift, lineId: 'L3', sku: 'MICA-1' }] };
+    expect(res.lines.map((l) => l.linkedLineId)).toEqual(['L1', 'L1']);
+  });
+
+  it('una línea GIFT exige role GIFT, ancla y precio original', () => {
+    const { linkedLineId: _l, ...sinAncla } = gift;
+    const { originalPriceCents: _o, ...sinPrecio } = gift;
+    const { role: _r, ...sinRole } = gift;
+    // @ts-expect-error linkedLineId es obligatorio en un GIFT
+    const a: WizardGiftLine = sinAncla;
+    // @ts-expect-error originalPriceCents es obligatorio en un GIFT
+    const b: WizardGiftLine = sinPrecio;
+    // @ts-expect-error role GIFT es obligatorio
+    const c: WizardGiftLine = sinRole;
+    const line: WizardReservedLine = gift;
+    expect([a, b, c, line]).toHaveLength(4);
+  });
+
+  it('la lectura privada trae líneas, ancla, crédito, paso y promo de venta', () => {
+    const view: PrivateWizardSessionResponse = {
+      sessionId: 'ses-1',
+      retailerId: 'ret',
+      storeId: 'st',
+      retailCustomerId: null,
+      state: WizardStateEnum.ACTIVE,
+      currentStep: WizardStepEnum.S06,
+      creditId: null,
+      anchorLineId: 'L1',
+      salePromotionId: null,
+      salePromotionVersion: null,
+      lines: [{ ...gift, financedCents: 0 }],
+    };
+    expect(view.lines[0].financedCents).toBe(0);
+  });
+
+  it('la lectura privada expone directorio, folio, cobro de contado y forma de pago', () => {
+    const view: PrivateWizardSessionResponse = {
+      sessionId: 'ses-1',
+      retailerId: 'ret',
+      storeId: 'st',
+      retailCustomerId: 'rc-1',
+      state: WizardStateEnum.ACTIVE,
+      currentStep: WizardStepEnum.S06,
+      creditId: null,
+      anchorLineId: 'L1',
+      salePromotionId: null,
+      salePromotionVersion: null,
+      lines: [],
+      fiadoDirectoryId: 'dir-1',
+      folio: 'F-001',
+      paymentMethod: PaymentMethodEnum.CASH_SALE,
+      payment: { method: SalePaymentMethodEnum.CASH, amountCents: 349900, paidAt: '2026-09-28T20:00:00.000Z' },
+    };
+    expect(view.payment?.paidAt).toBe('2026-09-28T20:00:00.000Z');
+  });
+});

package/_test_/unit/retailWizard/ventaSagaMessages.test.ts

@@ -0,0 +1,163 @@
+import 'reflect-metadata';
+import { plainToInstance, type ClassConstructor } from 'class-transformer';
+import { validateSync, type ValidationError } from 'class-validator';
+import {
+  RetailCommissionInboundMessage,
+  RetailPromotionInboundMessage,
+  RetailPromotionInboundMessageTypeEnum,
+  WizardLineRoleEnum,
+} from '../../../src/retailWizard';
+import { ItemTypeEnum } from '../../../src/retailCatalog';
+
+function paths(errors: ValidationError[], prefix = ''): string[] {
+  return errors.flatMap((e) => {
+    const p = prefix ? `${prefix}.${e.property}` : e.property;
+    return e.children && e.children.length > 0 ? paths(e.children, p) : [p];
+  });
+}
+
+function errorsOf<T extends object>(cls: ClassConstructor<T>, payload: object): string[] {
+  return paths(validateSync(plainToInstance(cls, payload) as object));
+}
+
+describe('RetailPromotionInboundMessageTypeEnum', () => {
+  it('distingue confirmación y cancelación', () => {
+    expect(Object.values(RetailPromotionInboundMessageTypeEnum)).toEqual(['SALE_CONFIRMED', 'SALE_CANCELLED']);
+  });
+});
+
+describe('RetailPromotionInboundMessage', () => {
+  const anchor = {
+    lineId: 'L1',
+    sku: 'PHONE-1',
+    qty: 1,
+    promotionId: 'promo-1',
+    promotionVersion: 2,
+    discountCode: 'VERANO',
+    discountCents: 50000,
+    originalPriceCents: 349900,
+    identifiers: ['356938035643809'],
+  };
+  const gift = {
+    lineId: 'L2',
+    sku: 'CASE-1',
+    qty: 1,
+    role: WizardLineRoleEnum.GIFT,
+    linkedLineId: 'L1',
+    originalPriceCents: 35000,
+    identifiers: [],
+  };
+  const ok = {
+    type: RetailPromotionInboundMessageTypeEnum.SALE_CONFIRMED,
+    tenantId: 't',
+    retailerId: 'ret',
+    storeId: 'st',
+    saleId: 'sale-1',
+    sessionId: 'ses-1',
+    customerId: 'cus-1',
+    soldAt: '2026-09-28T20:00:00.000Z',
+    occurredAt: '2026-09-28T20:00:00.000Z',
+    lines: [anchor, gift],
+  };
+
+  it('acepta una confirmación de contado', () => expect(errorsOf(RetailPromotionInboundMessage, ok)).toEqual([]));
+
+  it('acepta crédito, directorio y promo de venta', () =>
+    expect(
+      errorsOf(RetailPromotionInboundMessage, {
+        ...ok,
+        creditId: 'cr-1',
+        fiadoDirectoryId: 'dir-1',
+        salePromotionId: 'sp-1',
+        salePromotionVersion: 1,
+      }),
+    ).toEqual([]));
+
+  it('acepta una cancelación con returned por línea', () =>
+    expect(
+      errorsOf(RetailPromotionInboundMessage, {
+        ...ok,
+        type: RetailPromotionInboundMessageTypeEnum.SALE_CANCELLED,
+        lines: [{ ...anchor, returned: true }],
+      }),
+    ).toEqual([]));
+
+  it('exige la identidad de la venta', () => {
+    const { tenantId: _t, saleId: _s, sessionId: _se, customerId: _c, occurredAt: _o, ...rest } = ok;
+    expect(errorsOf(RetailPromotionInboundMessage, rest)).toEqual(
+      expect.arrayContaining(['tenantId', 'saleId', 'sessionId', 'customerId', 'occurredAt']),
+    );
+  });
+
+  it('rechaza un type fuera del enum', () =>
+    expect(errorsOf(RetailPromotionInboundMessage, { ...ok, type: 'SALE_APPLIED' })).toContain('type'));
+
+  it('exige originalPriceCents e identifiers por línea', () => {
+    const { originalPriceCents: _o, identifiers: _i, ...line } = anchor;
+    expect(errorsOf(RetailPromotionInboundMessage, { ...ok, lines: [line] })).toEqual(
+      expect.arrayContaining(['lines.0.originalPriceCents', 'lines.0.identifiers']),
+    );
+  });
+
+  it('rechaza un role fuera del enum', () =>
+    expect(errorsOf(RetailPromotionInboundMessage, { ...ok, lines: [{ ...gift, role: 'ANCHOR' }] })).toContain(
+      'lines.0.role',
+    ));
+
+  it('rechaza la versión 0 de la promo de línea y acepta la 1', () => {
+    expect(errorsOf(RetailPromotionInboundMessage, { ...ok, lines: [{ ...anchor, promotionVersion: 0 }] })).toContain(
+      'lines.0.promotionVersion',
+    );
+    expect(errorsOf(RetailPromotionInboundMessage, { ...ok, lines: [{ ...anchor, promotionVersion: 1 }] })).toEqual([]);
+  });
+
+  it('rechaza la versión 0 de la promo de venta y acepta la 1', () => {
+    const sale = { ...ok, salePromotionId: 'sp-1' };
+    expect(errorsOf(RetailPromotionInboundMessage, { ...sale, salePromotionVersion: 0 })).toContain('salePromotionVersion');
+    expect(errorsOf(RetailPromotionInboundMessage, { ...sale, salePromotionVersion: 1 })).toEqual([]);
+  });
+
+  it.each(['promotionId', 'discountCode', 'linkedLineId'])('rechaza %s vacío en la línea', (field) =>
+    expect(errorsOf(RetailPromotionInboundMessage, { ...ok, lines: [{ ...anchor, [field]: '' }] })).toContain(
+      `lines.0.${field}`,
+    ));
+
+  it('rechaza salePromotionId vacío y acepta null', () => {
+    expect(errorsOf(RetailPromotionInboundMessage, { ...ok, salePromotionId: '' })).toContain('salePromotionId');
+    expect(errorsOf(RetailPromotionInboundMessage, { ...ok, salePromotionId: null })).toEqual([]);
+  });
+
+  it('no lleva paymentMethod: el crédito se reconoce por creditId', () => {
+    const msg = plainToInstance(RetailPromotionInboundMessage, ok);
+    expect('paymentMethod' in msg).toBe(false);
+  });
+});
+
+describe('RetailCommissionInboundMessage', () => {
+  const ok = {
+    tenantId: 't',
+    retailerId: 'ret',
+    storeId: 'st',
+    saleId: 'sale-1',
+    sessionId: 'ses-1',
+    soldAt: '2026-09-28T20:00:00.000Z',
+    lines: [
+      { sku: 'PHONE-1', qty: 1, netCents: 299900, itemType: ItemTypeEnum.PRODUCT },
+      { sku: 'SVC-1', qty: 1, netCents: 9900, itemType: ItemTypeEnum.SERVICE },
+    ],
+  };
+
+  it('acepta la venta con sus líneas', () => expect(errorsOf(RetailCommissionInboundMessage, ok)).toEqual([]));
+
+  it('exige la identidad de la venta', () => {
+    const { saleId: _s, soldAt: _so, ...rest } = ok;
+    expect(errorsOf(RetailCommissionInboundMessage, rest)).toEqual(expect.arrayContaining(['saleId', 'soldAt']));
+  });
+
+  it('rechaza sin líneas', () => expect(errorsOf(RetailCommissionInboundMessage, { ...ok, lines: [] })).toContain('lines'));
+
+  it('valida cada línea', () =>
+    expect(
+      errorsOf(RetailCommissionInboundMessage, { ...ok, lines: [{ sku: 'X', qty: 0, netCents: -1, itemType: 'KIT' }] }),
+    ).toEqual(expect.arrayContaining(['lines.0.qty', 'lines.0.netCents', 'lines.0.itemType'])));
+});

package/_test_/unit/retailWizard/ventaSagaRequests.test.ts

@@ -0,0 +1,59 @@
+import 'reflect-metadata';
+import { plainToInstance, type ClassConstructor } from 'class-transformer';
+import { validateSync, type ValidationError } from 'class-validator';
+import { AddProductRequest, PinSessionPiecesRequest, QuoteRequest } from '../../../src/retailWizard';
+
+function paths(errors: ValidationError[], prefix = ''): string[] {
+  return errors.flatMap((e) => {
+    const p = prefix ? `${prefix}.${e.property}` : e.property;
+    return e.children && e.children.length > 0 ? paths(e.children, p) : [p];
+  });
+}
+
+function errorsOf<T extends object>(cls: ClassConstructor<T>, payload: object): string[] {
+  return paths(validateSync(plainToInstance(cls, payload) as object));
+}
+
+describe('AddProductRequest.replacesLineId', () => {
+  it('es opcional', () => expect(errorsOf(AddProductRequest, { sku: 'KIT-1' })).toEqual([]));
+  it('acepta la línea a reemplazar', () =>
+    expect(errorsOf(AddProductRequest, { sku: 'KIT-1', replacesLineId: 'L1' })).toEqual([]));
+  it('rechaza vacío', () =>
+    expect(errorsOf(AddProductRequest, { sku: 'KIT-1', replacesLineId: '' })).toContain('replacesLineId'));
+});
+
+describe('QuoteRequest.financedLineId', () => {
+  it('sigue siendo opcional', () => expect(errorsOf(QuoteRequest, { downPaymentCents: 0, termWeeks: 26 })).toEqual([]));
+  it('se sigue aceptando del front viejo', () =>
+    expect(errorsOf(QuoteRequest, { downPaymentCents: 0, termWeeks: 26, financedLineId: 'L1' })).toEqual([]));
+});
+
+describe('PinSessionPiecesRequest', () => {
+  const ok = {
+    lines: [
+      {
+        lineId: 'L1',
+        components: [
+          { sku: 'PHONE-1', identifiers: ['356938035643809'] },
+          { sku: 'SIM-1', identifiers: ['8952140'] },
+        ],
+      },
+    ],
+  };
+  it('acepta líneas con sus componentes', () => expect(errorsOf(PinSessionPiecesRequest, ok)).toEqual([]));
+  it('rechaza sin líneas', () => expect(errorsOf(PinSessionPiecesRequest, { lines: [] })).toContain('lines'));
+  it('exige lineId', () =>
+    expect(errorsOf(PinSessionPiecesRequest, { lines: [{ components: ok.lines[0].components }] })).toContain(
+      'lines.0.lineId',
+    ));
+  it('rechaza una línea sin componentes', () =>
+    expect(errorsOf(PinSessionPiecesRequest, { lines: [{ lineId: 'L1', components: [] }] })).toContain(
+      'lines.0.components',
+    ));
+  it('valida sku e identificadores de cada componente', () => {
+    const bad = { lines: [{ lineId: 'L1', components: [{ identifiers: [3] }] }] };
+    expect(errorsOf(PinSessionPiecesRequest, bad)).toEqual(
+      expect.arrayContaining(['lines.0.components.0.sku', 'lines.0.components.0.identifiers']),
+    );
+  });
+});

package/_test_/unit/retailWizard/ventaSagaShapes.test.ts

@@ -0,0 +1,99 @@
+import 'reflect-metadata';
+import {
+  LinePaymentTypeEnum,
+  WizardLineRoleEnum,
+  WizardLineStatusEnum,
+  type Sale,
+  type SaleLine,
+  type WizardFinancingPreview,
+  type WizardLinePromotionFields,
+  type WizardReservedLine,
+  type WizardSession,
+} from '../../../src/retailWizard';
+
+const promoFields: WizardLinePromotionFields = {
+  role: WizardLineRoleEnum.GIFT,
+  promotionId: 'promo-1',
+  promotionVersion: 3,
+  linkedLineId: 'L1',
+  discountCode: 'VERANO',
+  discountCents: 50000,
+  originalPriceCents: 35000,
+};
+
+describe('WizardLineRoleEnum', () => {
+  it('solo trae GIFT; sin role es una línea normal', () => {
+    expect(Object.values(WizardLineRoleEnum)).toEqual(['GIFT']);
+  });
+});
+
+describe('línea de sesión con reparto y campos de Promociones', () => {
+  it('acepta financedCents y los 7 campos opcionales', () => {
+    const line: WizardReservedLine = {
+      lineId: 'L2',
+      sku: 'CASE-1',
+      qty: 1,
+      status: WizardLineStatusEnum.RESERVED,
+      reservationId: 'r-2',
+      expiresAt: '2026-09-28T20:30:00.000Z',
+      basePriceCents: 0,
+      listPriceCents: 35000,
+      priceSk: 'p',
+      eligibleFinanciers: [],
+      financeable: false,
+      paymentType: LinePaymentTypeEnum.CASH,
+      sellItemCost: 1,
+      financedCents: 0,
+      ...promoFields,
+    };
+    expect(line.role).toBe('GIFT');
+    expect(line.financedCents).toBe(0);
+  });
+});
+
+describe('línea de venta con reparto y campos de Promociones', () => {
+  it('acepta financedCents y los 7 campos opcionales', () => {
+    const line: SaleLine = {
+      lineId: 'L1',
+      sku: 'PHONE-1',
+      qty: 1,
+      basePriceCents: 349900,
+      listPriceCents: 349900,
+      priceSk: 'p',
+      paymentType: LinePaymentTypeEnum.CREDIT,
+      components: [{ sku: 'PHONE-1', qty: 1, identifiers: ['356938035643809'] }],
+      financedCents: 299900,
+      ...promoFields,
+      role: undefined,
+    };
+    expect(line.discountCents).toBe(50000);
+  });
+});
+
+describe('sesión de la saga', () => {
+  it('acepta piecesHeldAt, financingPreview, promo de venta y refundPendingCents', () => {
+    const preview: WizardFinancingPreview = { capCents: 89970, lines: [{ lineId: 'L2', financedCents: 35000 }] };
+    const session: Pick<
+      WizardSession,
+      'piecesHeldAt' | 'financingPreview' | 'salePromotionId' | 'salePromotionVersion' | 'refundPendingCents'
+    > = {
+      piecesHeldAt: '2026-09-28T20:00:00.000Z',
+      financingPreview: preview,
+      salePromotionId: null,
+      salePromotionVersion: null,
+      refundPendingCents: 150000,
+    };
+    expect(session.financingPreview?.lines[0].financedCents).toBe(35000);
+  });
+});
+
+describe('venta de la saga', () => {
+  it('acepta promo de venta e inventoryViaQueue', () => {
+    const sale: Pick<Sale, 'salePromotionId' | 'salePromotionVersion' | 'inventoryViaQueue'> = {
+      salePromotionId: 'sp-1',
+      salePromotionVersion: 2,
+      inventoryViaQueue: true,
+    };
+    expect(sale.inventoryViaQueue).toBe(true);
+  });
+});

package/bin/common/index.d.ts

@@ -1,4 +1,5 @@
 export * from './decorators/Trim';
+export * from './validators/IsStringValueRecord';
 export * from './dtos/ProcessValidationResultDto';
 export * from './enums/ProcessValidationEnum';
 export * from './enums/ProcessResultEnum';

package/bin/common/index.js

@@ -16,6 +16,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 //decorators
 __exportStar(require("./decorators/Trim"), exports);
+//validators
+__exportStar(require("./validators/IsStringValueRecord"), exports);
 //dtos
 __exportStar(require("./dtos/ProcessValidationResultDto"), exports);
 //Enums