@fiado/type-kit 3.627.0 → 3.629.0

package/_test_/unit/loanOfferings/offeringsInputRules.test.ts

@@ -0,0 +1,254 @@
+import 'reflect-metadata';
+import { ClassConstructor, plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import {
+    ChangeCreditPlanStatusRequest,
+    ChangePromotionStatusRequest,
+    ComputeAmortizationScheduleRequest,
+    ConsumePromotionRequest,
+    CreateCreditPlanRequest,
+    CreateFinancierRequest,
+    CreatePromotionRequest,
+    CreateSegmentRequest,
+    CreateStorePolicyRequest,
+    ReleasePromotionRequest,
+    ReservePromotionBonusRequest,
+    SettlePromotionBonusRequest,
+    SimulateCreditPlanRequest,
+    UpdateCohortRequest,
+    UpdateCreditPlanRequest,
+    UpdateFinancierRequest,
+    UpdatePromotionRequest,
+    UpdateSegmentRequest,
+    UpdateStorePolicyRequest,
+} from '../../../src/loanOfferings/index';
+
+/** Propiedades que fallan, validando como el lambda (whitelist sin rechazar extras). */
+const errorProperties = async <T extends object>(dtoClass: ClassConstructor<T>, body: object): Promise<string[]> =>
+    (await validate(plainToInstance(dtoClass, body), { whitelist: true, forbidNonWhitelisted: false }))
+        .map((error) => error.property)
+        .sort();
+
+const ids = (count: number, prefix = 'ID'): string[] => Array.from({ length: count }, (_, i) => `${prefix}-${i}`);
+
+describe('PUT parciales: null en un campo no anulable da 400 (L-100)', () => {
+    const cases: Array<[string, ClassConstructor<object>, string[]]> = [
+        [
+            'UpdateCreditPlanRequest',
+            UpdateCreditPlanRequest,
+            [
+                'name',
+                'description',
+                'saleTypes',
+                'minDownPaymentPct',
+                'termWeeksOptions',
+                'maxFinancedAmountCents',
+                'tnaAnnual',
+                'openingCommissionPct',
+                'paymentShift',
+                'prepaymentMinimum',
+            ],
+        ],
+        ['UpdatePromotionRequest', UpdatePromotionRequest, ['name', 'description', 'effect', 'segmentId', 'targetLevels']],
+        ['UpdateStorePolicyRequest', UpdateStorePolicyRequest, ['name', 'hardening', 'easing', 'suspended']],
+        ['UpdateSegmentRequest', UpdateSegmentRequest, ['name', 'colorSlot', 'cohortIds', 'filterIds', 'memberIds']],
+        ['UpdateCohortRequest', UpdateCohortRequest, ['name', 'conditions']],
+        ['UpdateFinancierRequest', UpdateFinancierRequest, ['name', 'label']],
+    ];
+
+    it.each(cases)('%s rechaza null en cada campo no anulable', async (_name, dtoClass, fields) => {
+        for (const field of fields) {
+            expect(await errorProperties(dtoClass, { [field]: null })).toEqual([field]);
+        }
+    });
+
+    it.each(cases)('%s acepta el parche vacío: ausente deja el valor como está', async (_name, dtoClass) => {
+        expect(await errorProperties(dtoClass, {})).toEqual([]);
+    });
+
+    const nullable: Array<[string, ClassConstructor<object>, string[]]> = [
+        ['UpdateCreditPlanRequest', UpdateCreditPlanRequest, ['eligibleTiers', 'maxDownPaymentPct', 'minSciScore', 'maxSciScore', 'validFrom', 'validUntil']],
+        [
+            'UpdatePromotionRequest',
+            UpdatePromotionRequest,
+            ['productSkus', 'productCategories', 'tiers', 'retailerIds', 'storeIds', 'validFrom', 'validUntil', 'budgetMaxCents'],
+        ],
+        [
+            'UpdateStorePolicyRequest',
+            UpdateStorePolicyRequest,
+            ['description', 'allowedSkus', 'storeIds', 'targetLevels', 'segmentIds', 'targetSkus', 'validFrom', 'validUntil'],
+        ],
+        ['UpdateSegmentRequest', UpdateSegmentRequest, ['description']],
+        ['UpdateCohortRequest', UpdateCohortRequest, ['description']],
+        ['UpdateFinancierRequest', UpdateFinancierRequest, ['externalRedirectUrl', 'eligibleTiers', 'config']],
+    ];
+
+    it.each(nullable)('%s sigue aceptando null donde borra el valor', async (_name, dtoClass, fields) => {
+        expect(await errorProperties(dtoClass, Object.fromEntries(fields.map((field) => [field, null])))).toEqual([]);
+    });
+});
+
+describe('Plan de crédito (L-102, L-103, L-107, L-123)', () => {
+    const plan = {
+        code: 'PLAN-ORO',
+        name: 'Oro',
+        description: 'Plan para clientes de nivel oro',
+        level: 'GOLD',
+        saleTypes: ['NEW'],
+        minDownPaymentPct: 0.1,
+        termWeeksOptions: [12, 24],
+        maxFinancedAmountCents: 2_000_000,
+        tnaAnnual: 2.3,
+    };
+
+    it('acepta un plan válido', async () => {
+        expect(await errorProperties(CreateCreditPlanRequest, plan)).toEqual([]);
+    });
+
+    it('vigencia en ISO-8601; null sigue siendo «sin fecha»', async () => {
+        expect(await errorProperties(CreateCreditPlanRequest, { ...plan, validFrom: '2026-11-03', validUntil: null })).toEqual([]);
+        expect(await errorProperties(CreateCreditPlanRequest, { ...plan, validFrom: '03/11/2026', validUntil: '' })).toEqual([
+            'validFrom',
+            'validUntil',
+        ]);
+        expect(await errorProperties(UpdateCreditPlanRequest, { validUntil: 'mañana' })).toEqual(['validUntil']);
+    });
+
+    it('plazos de 1 a 104 semanas', async () => {
+        expect(await errorProperties(CreateCreditPlanRequest, { ...plan, termWeeksOptions: [104] })).toEqual([]);
+        expect(await errorProperties(CreateCreditPlanRequest, { ...plan, termWeeksOptions: [12, 120] })).toEqual(['termWeeksOptions']);
+        expect(await errorProperties(UpdateCreditPlanRequest, { termWeeksOptions: [105] })).toEqual(['termWeeksOptions']);
+        const tooMany = Array.from({ length: 105 }, (_, i) => (i % 104) + 1);
+        expect(await errorProperties(UpdateCreditPlanRequest, { termWeeksOptions: tooMany })).toEqual(['termWeeksOptions']);
+    });
+
+    it('code, nombre y descripción no vacíos y con tope', async () => {
+        const body = { ...plan, code: '', name: 'x'.repeat(121), description: 'x'.repeat(501) };
+        expect(await errorProperties(CreateCreditPlanRequest, body)).toEqual(['code', 'description', 'name']);
+        expect(await errorProperties(CreateCreditPlanRequest, { ...plan, code: 'C'.repeat(65) })).toEqual(['code']);
+        expect(await errorProperties(UpdateCreditPlanRequest, { name: '', description: '' })).toEqual(['description', 'name']);
+    });
+
+    it('el motivo del PUT y del cambio de estado se declara y se acota a 280', async () => {
+        const dto = plainToInstance(UpdateCreditPlanRequest, { tnaAnnual: 2.3, reason: 'Ajuste de tasa' });
+        expect(await validate(dto, { whitelist: true })).toEqual([]);
+        expect(dto.reason).toBe('Ajuste de tasa');
+        expect(await errorProperties(UpdateCreditPlanRequest, { reason: 'x'.repeat(281) })).toEqual(['reason']);
+        expect(await errorProperties(ChangeCreditPlanStatusRequest, { status: 'ACTIVE', reason: 'Fin de campaña' })).toEqual([]);
+        expect(await errorProperties(ChangeCreditPlanStatusRequest, { status: 'ACTIVE', reason: 'x'.repeat(281) })).toEqual(['reason']);
+    });
+});
+
+describe('Amortización: plazo 104 y TNA con techo técnico interino (L-103)', () => {
+    const body = { financedAmountCents: 400_000, tnaAnnual: 2.3, termWeeks: 52, ivaOnInterest: 0.16 };
+
+    it('acepta la TNA de una reestructura por encima de 2.60', async () => {
+        expect(await errorProperties(ComputeAmortizationScheduleRequest, { ...body, tnaAnnual: 3.0 })).toEqual([]);
+    });
+
+    it('rechaza una TNA absurda', async () => {
+        expect(await errorProperties(ComputeAmortizationScheduleRequest, { ...body, tnaAnnual: 5.01 })).toEqual(['tnaAnnual']);
+        expect(await errorProperties(ComputeAmortizationScheduleRequest, { ...body, termWeeks: 105 })).toEqual(['termWeeks']);
+    });
+});
+
+describe('Promociones (L-104, L-105, L-107, L-123, L-052)', () => {
+    const promotion = {
+        name: 'Enganche 5 puntos menos',
+        description: 'Baja el enganche mínimo cinco puntos',
+        effect: { downPaymentDeltaPct: -0.05 },
+        segmentId: 'SEG-1',
+        targetLevels: ['SILVER'],
+    };
+
+    it('nombre y descripción no vacíos, 120 y 500', async () => {
+        expect(await errorProperties(CreatePromotionRequest, promotion)).toEqual([]);
+        const body = { ...promotion, name: 'x'.repeat(121), description: '' };
+        expect(await errorProperties(CreatePromotionRequest, body)).toEqual(['description', 'name']);
+        expect(await errorProperties(UpdatePromotionRequest, { description: 'x'.repeat(501) })).toEqual(['description']);
+    });
+
+    it('tiendas hasta 1 000 y SKUs hasta 2 000, sin vacíos', async () => {
+        expect(await errorProperties(CreatePromotionRequest, { ...promotion, storeIds: ids(1000), productSkus: ids(2000) })).toEqual([]);
+        expect(await errorProperties(CreatePromotionRequest, { ...promotion, storeIds: ids(1001) })).toEqual(['storeIds']);
+        expect(await errorProperties(UpdatePromotionRequest, { productSkus: ids(2001) })).toEqual(['productSkus']);
+        expect(await errorProperties(UpdatePromotionRequest, { storeIds: ['ST-1', ''], productSkus: [''] })).toEqual([
+            'productSkus',
+            'storeIds',
+        ]);
+    });
+
+    it('el PUT declara el motivo, y la pausa lo acota a 280', async () => {
+        expect(await errorProperties(UpdatePromotionRequest, { reason: 'Corrige el nombre' })).toEqual([]);
+        expect(await errorProperties(UpdatePromotionRequest, { reason: 'x'.repeat(281) })).toEqual(['reason']);
+        expect(await errorProperties(ChangePromotionStatusRequest, { status: 'PAUSED', reason: 'x'.repeat(281) })).toEqual(['reason']);
+        expect(await errorProperties(ChangePromotionStatusRequest, { status: 'PAUSED', reason: null })).toEqual([]);
+    });
+
+    it('creditId y bonusId no vacíos: son la llave de idempotencia', async () => {
+        const creditId = '01KXPB422AFGZHQKHVM7E5YDBR';
+        expect(await errorProperties(ConsumePromotionRequest, { creditId })).toEqual([]);
+        expect(await errorProperties(ConsumePromotionRequest, { creditId: '' })).toEqual(['creditId']);
+        expect(await errorProperties(ReservePromotionBonusRequest, { creditId: '' })).toEqual(['creditId']);
+        expect(await errorProperties(SettlePromotionBonusRequest, { bonusId: '', status: 'SETTLED' })).toEqual(['bonusId']);
+        expect(await errorProperties(ConsumePromotionRequest, { creditId: 'x'.repeat(129) })).toEqual(['creditId']);
+    });
+
+    it('release recibe el crédito que se canceló, con las mismas reglas', async () => {
+        expect(await errorProperties(ReleasePromotionRequest, { creditId: '01KXPB422AFGZHQKHVM7E5YDBR' })).toEqual([]);
+        expect(await errorProperties(ReleasePromotionRequest, {})).toEqual(['creditId']);
+        expect(await errorProperties(ReleasePromotionRequest, { creditId: '' })).toEqual(['creditId']);
+    });
+});
+
+describe('Topes de listas (L-105, L-117, L-135)', () => {
+    it('miembros manuales del segmento hasta 5 000, sin vacíos', async () => {
+        expect(await errorProperties(CreateSegmentRequest, { name: 'VIP', memberIds: ids(5000) })).toEqual([]);
+        expect(await errorProperties(CreateSegmentRequest, { name: 'VIP', memberIds: ids(5001) })).toEqual(['memberIds']);
+        expect(await errorProperties(UpdateSegmentRequest, { memberIds: ['RC-1', ''] })).toEqual(['memberIds']);
+        expect(await errorProperties(UpdateSegmentRequest, { memberIds: [] })).toEqual([]);
+    });
+
+    it('tiendas de la política hasta 1 000, sin vacíos', async () => {
+        expect(await errorProperties(CreateStorePolicyRequest, { name: 'Centro', storeIds: ids(1000) })).toEqual([]);
+        expect(await errorProperties(CreateStorePolicyRequest, { name: 'Centro', storeIds: ids(1001) })).toEqual(['storeIds']);
+        expect(await errorProperties(UpdateStorePolicyRequest, { storeIds: [''] })).toEqual(['storeIds']);
+    });
+
+    it('segmentos del cliente en la cotización hasta 50, sin vacíos', async () => {
+        const quote = { productPriceCents: 500_000, downPaymentPct: 0.2, termWeeks: 24 };
+        expect(await errorProperties(SimulateCreditPlanRequest, { ...quote, customerSegmentIds: ids(50) })).toEqual([]);
+        expect(await errorProperties(SimulateCreditPlanRequest, { ...quote, customerSegmentIds: ids(51) })).toEqual(['customerSegmentIds']);
+        expect(await errorProperties(SimulateCreditPlanRequest, { ...quote, customerSegmentIds: [''] })).toEqual(['customerSegmentIds']);
+    });
+});
+
+describe('Financieras (L-106, L-123)', () => {
+    const financier = { code: 'PCF', name: 'Pago Confiado', type: 'INTERNAL', label: 'Sin trámites adicionales' };
+
+    it('acepta una financiera válida', async () => {
+        expect(await errorProperties(CreateFinancierRequest, financier)).toEqual([]);
+    });
+
+    it('la URL de redirección es https, con protocolo y hasta 2048', async () => {
+        const url = (externalRedirectUrl: unknown) => ({ ...financier, externalRedirectUrl });
+        expect(await errorProperties(CreateFinancierRequest, url('https://financiera.mx/solicitud?ref=sk'))).toEqual([]);
+        expect(await errorProperties(CreateFinancierRequest, url(null))).toEqual([]);
+        for (const bad of ['http://financiera.mx', 'financiera.mx', '', `https://financiera.mx/${'a'.repeat(2048)}`]) {
+            expect(await errorProperties(CreateFinancierRequest, url(bad))).toEqual(['externalRedirectUrl']);
+        }
+        expect(await errorProperties(UpdateFinancierRequest, { externalRedirectUrl: 'javascript:alert(1)' })).toEqual(['externalRedirectUrl']);
+    });
+
+    it('config (deprecado) acepta hasta 4 KB serializado', async () => {
+        expect(await errorProperties(CreateFinancierRequest, { ...financier, config: { note: 'x'.repeat(4000) } })).toEqual([]);
+        expect(await errorProperties(UpdateFinancierRequest, { config: { note: 'x'.repeat(4096) } })).toEqual(['config']);
+        expect(await errorProperties(UpdateFinancierRequest, { config: { note: 'ñ'.repeat(2045) } })).toEqual(['config']);
+    });
+
+    it('code, nombre y etiqueta no vacíos y con tope', async () => {
+        const body = { ...financier, code: 'C'.repeat(65), name: '', label: 'x'.repeat(121) };
+        expect(await errorProperties(CreateFinancierRequest, body)).toEqual(['code', 'label', 'name']);
+        expect(await errorProperties(UpdateFinancierRequest, { name: '', label: '' })).toEqual(['label', 'name']);
+    });
+});

package/_test_/unit/loanOfferings/promotionRequests.test.ts

@@ -20,7 +20,7 @@ const errorProperties = async (
   raw: Record<string, unknown>,
   dtoClass: typeof CreatePromotionRequest | typeof UpdatePromotionRequest = CreatePromotionRequest,
 ): Promise<string[]> => {
-  const instance = plainToInstance(dtoClass, raw, { excludeExtraneousValues: true });
+  const instance = plainToInstance<object, Record<string, unknown>>(dtoClass, raw, { excludeExtraneousValues: true });
   return (await validate(instance as object)).map((error) => error.property);
 };
 

package/_test_/unit/loanRetailAudit/auditInputLimits.test.ts

@@ -0,0 +1,114 @@
+import 'reflect-metadata';
+import { ClassConstructor, plainToInstance } from 'class-transformer';
+import { ValidationError, validate } from 'class-validator';
+import {
+    AUDIT_TRAIL_CHANGES_MAX_ITEMS,
+    AUDIT_TRAIL_CONTEXT_MAX_ITEMS,
+    AuditTrailActionEnum,
+    AuditTrailRecordedV1,
+    CreatePiiAccessLogRequest,
+    isIsoDateTime,
+    PII_ACCESS_FIELDS_MAX_ITEMS,
+    PiiAccessActionEnum,
+    PiiResourceTypeEnum,
+    RetailAuditEntityTypeEnum,
+} from '../../../src/loanRetailAudit/index';
+
+const errorPaths = async <T extends object>(dtoClass: ClassConstructor<T>, body: object): Promise<string[]> => {
+    const pathsOf = (errors: ValidationError[], parent: string): string[] =>
+        errors.flatMap((error) => {
+            const path = parent ? `${parent}.${error.property}` : error.property;
+            return [...(error.constraints ? [path] : []), ...pathsOf(error.children ?? [], path)];
+        });
+    return pathsOf(await validate(plainToInstance(dtoClass, body), { whitelist: true }), '').sort();
+};
+
+const EVENT = {
+    eventId: '01JABCDEF0123456789XYZABCD',
+    entityType: RetailAuditEntityTypeEnum.SALE,
+    entityId: 'sale-1',
+    action: AuditTrailActionEnum.SALE_CANCEL,
+    changes: [{ field: 'status', oldValue: 'COMPLETED', newValue: 'CANCELLED' }],
+    context: [{ key: 'saleType', value: 'CASH' }],
+    performedBy: 'user-1',
+    sourceLambda: 'retail-wizard-business',
+    occurredAt: '2026-10-19T12:00:00.000Z',
+};
+
+const PII = {
+    accessId: '01JABCDEF0123456789XYZABCE',
+    occurredAt: '2026-10-19T12:00:00.000Z',
+    correlationId: 'corr-1',
+    actorId: 'sub-1',
+    sourceLambda: 'retail-customer-business',
+    operationName: 'privateListCustomers',
+    action: PiiAccessActionEnum.READ,
+    resourceType: PiiResourceTypeEnum.RETAIL_CUSTOMER,
+    resourceId: '(list:tenant)',
+    fields: ['fullName', 'phone'],
+    resourceIds: ['01KXPB422AFGZHQKHVM7E5YDBR', 'acc-0123456789abcdef0123456789abcdef'],
+};
+
+describe('occurredAt: fecha-hora ISO completa con zona (L-188)', () => {
+    it('acepta lo que produce toISOString() y un offset', () => {
+        expect(isIsoDateTime(new Date().toISOString())).toBe(true);
+        expect(isIsoDateTime('2026-11-03T04:00:00-06:00')).toBe(true);
+    });
+
+    it('rechaza semana, día del año, año suelto, fecha sola, sin zona y fechas que no existen', () => {
+        for (const value of ['2026-W44-1', '2026-305', '2026', '2026-11-03', '2026-11-03T10:00:00', '2026-02-30T00:00:00Z', '2026-11-03T24:00:00Z', 20261103]) {
+            expect(isIsoDateTime(value)).toBe(false);
+        }
+    });
+
+    it('lo aplican el evento de auditoría y el acceso a PII', async () => {
+        expect(await errorPaths(AuditTrailRecordedV1, EVENT)).toEqual([]);
+        expect(await errorPaths(AuditTrailRecordedV1, { ...EVENT, occurredAt: '2026-W44-1' })).toEqual(['occurredAt']);
+        expect(await errorPaths(CreatePiiAccessLogRequest, PII)).toEqual([]);
+        expect(await errorPaths(CreatePiiAccessLogRequest, { ...PII, occurredAt: '2026-10-19' })).toEqual(['occurredAt']);
+    });
+});
+
+describe('Topes del evento de auditoría (L-183)', () => {
+    it('cambios hasta 100 y contexto hasta 50', async () => {
+        const changes = Array.from({ length: AUDIT_TRAIL_CHANGES_MAX_ITEMS + 1 }, () => EVENT.changes[0]);
+        const context = Array.from({ length: AUDIT_TRAIL_CONTEXT_MAX_ITEMS + 1 }, () => EVENT.context[0]);
+        expect(await errorPaths(AuditTrailRecordedV1, { ...EVENT, changes, context })).toEqual(['changes', 'context']);
+    });
+
+    it('nombres hasta 128 y valores hasta 4 KB', async () => {
+        const body = {
+            ...EVENT,
+            changes: [{ field: 'f'.repeat(129), oldValue: 'o'.repeat(4097), newValue: 'n'.repeat(4096) }],
+            context: [{ key: 'k'.repeat(129), value: 'v'.repeat(4097) }],
+        };
+        expect(await errorPaths(AuditTrailRecordedV1, body)).toEqual([
+            'changes.0.field',
+            'changes.0.oldValue',
+            'context.0.key',
+            'context.0.value',
+        ]);
+    });
+});
+
+describe('Acceso a PII: campos e ids sin vacíos y con tope (L-183, L-187)', () => {
+    it('rechaza nombres de campo o ids vacíos', async () => {
+        expect(await errorPaths(CreatePiiAccessLogRequest, { ...PII, fields: ['fullName', ''] })).toEqual(['fields']);
+        expect(await errorPaths(CreatePiiAccessLogRequest, { ...PII, resourceIds: ['01KXPB422AFGZHQKHVM7E5YDBR', ''] })).toEqual(['resourceIds']);
+    });
+
+    it('acota los campos a 50 y cada id a 128', async () => {
+        const fields = Array.from({ length: PII_ACCESS_FIELDS_MAX_ITEMS + 1 }, (_, i) => `field${i}`);
+        expect(await errorPaths(CreatePiiAccessLogRequest, { ...PII, fields })).toEqual(['fields']);
+        expect(await errorPaths(CreatePiiAccessLogRequest, { ...PII, resourceIds: ['r'.repeat(129)] })).toEqual(['resourceIds']);
+    });
+
+    it('acepta un listado grande: la cantidad de ids todavía no tiene tope', async () => {
+        const resourceIds = Array.from({ length: 5000 }, (_, i) => `01KXPB422AFGZHQKHVM7E${String(i).padStart(5, '0')}`);
+        expect(await errorPaths(CreatePiiAccessLogRequest, { ...PII, resourceIds })).toEqual([]);
+    });
+
+    it('un listado vacío sigue siendo válido', async () => {
+        expect(await errorPaths(CreatePiiAccessLogRequest, { ...PII, resourceIds: [] })).toEqual([]);
+    });
+});

package/_test_/unit/loanScoring/evaluateSciRequest.test.ts

@@ -0,0 +1,49 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import { EvaluateSciRequest } from '../../../src/loanScoring/index';
+
+const errorProperties = async (body: object): Promise<string[]> =>
+    (await validate(plainToInstance(EvaluateSciRequest, body), { whitelist: true })).map((error) => error.property).sort();
+
+/** Como lo manda el wizard: ids ULID, CURP en mayúsculas y celular de 10 dígitos. */
+const BODY = {
+    borrowerId: '01KXPB422AFGZHQKHVM7E5YDBR',
+    retailCustomerId: '01KXPB422AFGZHQKHVM7E5YDBS',
+    curp: 'LOHM900215MMCPRR09',
+    cellphone: '5512345678',
+    antiFraudPassed: true,
+};
+
+describe('EvaluateSciRequest', () => {
+    it('acepta el request del wizard, con y sin llave de idempotencia (L-173)', async () => {
+        expect(await errorProperties(BODY)).toEqual([]);
+        expect(await errorProperties({ ...BODY, idempotencyKey: 'wizard-session-01KXPB' })).toEqual([]);
+    });
+
+    it('la llave de idempotencia no va vacía ni pasa de 128', async () => {
+        expect(await errorProperties({ ...BODY, idempotencyKey: '' })).toEqual(['idempotencyKey']);
+        expect(await errorProperties({ ...BODY, idempotencyKey: 'k'.repeat(129) })).toEqual(['idempotencyKey']);
+    });
+
+    it('acepta la CURP de prueba del mock de Círculo (empieza con X)', async () => {
+        expect(await errorProperties({ ...BODY, curp: 'XOAC900101HDFRRL05' })).toEqual([]);
+    });
+
+    it('rechaza celular con +52 o separadores, y borrowerId que no es ULID (L-177)', async () => {
+        const body = { ...BODY, cellphone: '+525512345678', borrowerId: 'SMOKE-B-LSB' };
+        expect(await errorProperties(body)).toEqual(['borrowerId', 'cellphone']);
+        expect(await errorProperties({ ...BODY, cellphone: '55 1234 5678' })).toEqual(['cellphone']);
+    });
+
+    it('el CURP solo tiene tope de largo: retail-customer no valida su formato', async () => {
+        expect(await errorProperties({ ...BODY, curp: 'lohm900215mmcprr09' })).toEqual([]);
+        expect(await errorProperties({ ...BODY, curp: 'LOHM900215MMCPRR0' })).toEqual([]);
+        expect(await errorProperties({ ...BODY, curp: 'C'.repeat(65) })).toEqual(['curp']);
+        expect(await errorProperties({ ...BODY, curp: '' })).toEqual(['curp']);
+    });
+
+    it('retailCustomerId hasta 64', async () => {
+        expect(await errorProperties({ ...BODY, retailCustomerId: 'r'.repeat(65) })).toEqual(['retailCustomerId']);
+    });
+});

package/bin/collection/constants/CollectionResultLimits.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Largo máximo de los ids que el motor manda en `apply-result` (`attemptId`, `intentId`, `chargeId`,
+ * `holdTxId`). Los reales miden menos de 100: `attemptId` = `<intentId>#<proveedor>#<mecanismo>#<ciclo>`.
+ * Con 256 cabe la llave compuesta del dominio sin acercarse a los 2 KB de la pk de DynamoDB.
+ */
+export declare const COLLECTION_RESULT_ID_MAX_LENGTH = 256;
+/** Largo máximo de `domain`, `directoryId` y `tenantId` en `resolve-charges`. */
+export declare const COLLECTION_RESOLVE_FIELD_MAX_LENGTH = 128;
+/**
+ * Techo técnico de un monto del motor, en PESOS (o en la moneda de la wallet): 1 000 millones.
+ *
+ * No es política de negocio: un equipo de SureKeep cuesta decenas de miles de pesos. Hasta este techo un
+ * `double` representa el monto con resolución de ~0.00001 centavos, así que `Math.round(monto * 100)`
+ * da el centavo exacto y el resultado queda muy por debajo de `Number.MAX_SAFE_INTEGER`.
+ */
+export declare const COLLECTION_AMOUNT_MAX = 1000000000;

package/bin/collection/constants/CollectionResultLimits.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COLLECTION_AMOUNT_MAX = exports.COLLECTION_RESOLVE_FIELD_MAX_LENGTH = exports.COLLECTION_RESULT_ID_MAX_LENGTH = void 0;
+/**
+ * Largo máximo de los ids que el motor manda en `apply-result` (`attemptId`, `intentId`, `chargeId`,
+ * `holdTxId`). Los reales miden menos de 100: `attemptId` = `<intentId>#<proveedor>#<mecanismo>#<ciclo>`.
+ * Con 256 cabe la llave compuesta del dominio sin acercarse a los 2 KB de la pk de DynamoDB.
+ */
+exports.COLLECTION_RESULT_ID_MAX_LENGTH = 256;
+/** Largo máximo de `domain`, `directoryId` y `tenantId` en `resolve-charges`. */
+exports.COLLECTION_RESOLVE_FIELD_MAX_LENGTH = 128;
+/**
+ * Techo técnico de un monto del motor, en PESOS (o en la moneda de la wallet): 1 000 millones.
+ *
+ * No es política de negocio: un equipo de SureKeep cuesta decenas de miles de pesos. Hasta este techo un
+ * `double` representa el monto con resolución de ~0.00001 centavos, así que `Math.round(monto * 100)`
+ * da el centavo exacto y el resultado queda muy por debajo de `Number.MAX_SAFE_INTEGER`.
+ */
+exports.COLLECTION_AMOUNT_MAX = 1000000000;

package/bin/collection/dtos/ApplyCollectionResultRequest.d.ts

@@ -8,6 +8,9 @@ import { CurrencyId } from '../../currency/enums/CurrencyId';
  * respuesta se lee como no entregada y el mismo resultado vuelve más tarde, así que aplicarlo tiene
  * que ser idempotente: el dominio deduplica por `attemptId`, que identifica ESE intento y no el cobro
  * entero.
+ *
+ * Los ids no vacíos y con tope evitan que un `attemptId` vacío colapse la deduplicación (L-005). Los
+ * montos van en pesos, con centavos, sin negativos y bajo un techo técnico (L-022).
  */
 export declare class ApplyCollectionResultRequest {
     attemptId: string;
@@ -16,7 +19,9 @@ export declare class ApplyCollectionResultRequest {
     domain: string;
     tenantId: string;
     result: CollectionResultStatus;
+    /** Pesos cobrados (débito directo). */
     amountCollected: number;
+    /** Pesos retenidos (preautorización). */
     amountReserved: number;
     mechanism: MechanismType;
     holdTxId?: string;

package/bin/collection/dtos/ApplyCollectionResultRequest.js

@@ -11,6 +11,8 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApplyCollectionResultRequest = void 0;
 const class_validator_1 = require("class-validator");
+const CollectionResultLimits_1 = require("../constants/CollectionResultLimits");
+const IsCentPrecision_1 = require("../validators/IsCentPrecision");
 const CollectionResultStatus_1 = require("../enums/CollectionResultStatus");
 const MechanismType_1 = require("../enums/MechanismType");
 const CurrencyId_1 = require("../../currency/enums/CurrencyId");
@@ -21,20 +23,29 @@ const CurrencyId_1 = require("../../currency/enums/CurrencyId");
  * respuesta se lee como no entregada y el mismo resultado vuelve más tarde, así que aplicarlo tiene
  * que ser idempotente: el dominio deduplica por `attemptId`, que identifica ESE intento y no el cobro
  * entero.
+ *
+ * Los ids no vacíos y con tope evitan que un `attemptId` vacío colapse la deduplicación (L-005). Los
+ * montos van en pesos, con centavos, sin negativos y bajo un techo técnico (L-022).
  */
 class ApplyCollectionResultRequest {
 }
 exports.ApplyCollectionResultRequest = ApplyCollectionResultRequest;
 __decorate([
     (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.MaxLength)(CollectionResultLimits_1.COLLECTION_RESULT_ID_MAX_LENGTH),
     __metadata("design:type", String)
 ], ApplyCollectionResultRequest.prototype, "attemptId", void 0);
 __decorate([
     (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.MaxLength)(CollectionResultLimits_1.COLLECTION_RESULT_ID_MAX_LENGTH),
     __metadata("design:type", String)
 ], ApplyCollectionResultRequest.prototype, "intentId", void 0);
 __decorate([
     (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.MaxLength)(CollectionResultLimits_1.COLLECTION_RESULT_ID_MAX_LENGTH),
     __metadata("design:type", String)
 ], ApplyCollectionResultRequest.prototype, "chargeId", void 0);
 __decorate([
@@ -51,10 +62,16 @@ __decorate([
 ], ApplyCollectionResultRequest.prototype, "result", void 0);
 __decorate([
     (0, class_validator_1.IsNumber)(),
+    (0, IsCentPrecision_1.IsCentPrecision)(),
+    (0, class_validator_1.Min)(0),
+    (0, class_validator_1.Max)(CollectionResultLimits_1.COLLECTION_AMOUNT_MAX),
     __metadata("design:type", Number)
 ], ApplyCollectionResultRequest.prototype, "amountCollected", void 0);
 __decorate([
     (0, class_validator_1.IsNumber)(),
+    (0, IsCentPrecision_1.IsCentPrecision)(),
+    (0, class_validator_1.Min)(0),
+    (0, class_validator_1.Max)(CollectionResultLimits_1.COLLECTION_AMOUNT_MAX),
     __metadata("design:type", Number)
 ], ApplyCollectionResultRequest.prototype, "amountReserved", void 0);
 __decorate([
@@ -64,11 +81,16 @@ __decorate([
 __decorate([
     (0, class_validator_1.IsOptional)(),
     (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.MaxLength)(CollectionResultLimits_1.COLLECTION_RESULT_ID_MAX_LENGTH),
     __metadata("design:type", String)
 ], ApplyCollectionResultRequest.prototype, "holdTxId", void 0);
 __decorate([
     (0, class_validator_1.IsOptional)(),
     (0, class_validator_1.IsNumber)(),
+    (0, IsCentPrecision_1.IsCentPrecision)(),
+    (0, class_validator_1.Min)(0),
+    (0, class_validator_1.Max)(CollectionResultLimits_1.COLLECTION_AMOUNT_MAX),
     __metadata("design:type", Number)
 ], ApplyCollectionResultRequest.prototype, "walletAmount", void 0);
 __decorate([

package/bin/collection/dtos/ResolvePendingChargesRequest.d.ts

@@ -4,6 +4,8 @@
  * No lleva importe: el monto es justo lo que se está preguntando. Puede haber cambiado desde que el
  * cargo se dio de alta —por mora, o porque el cliente pagó por otra vía— y sólo el dominio, que es
  * quien aplica sus propias reglas, sabe cuánto queda vivo.
+ *
+ * Los tres campos son llave de búsqueda: vacíos o sin tope terminaban en 500 en el dominio (L-064).
  */
 export declare class ResolvePendingChargesRequest {
     domain: string;

package/bin/collection/dtos/ResolvePendingChargesRequest.js

@@ -11,25 +11,34 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResolvePendingChargesRequest = void 0;
 const class_validator_1 = require("class-validator");
+const CollectionResultLimits_1 = require("../constants/CollectionResultLimits");
 /**
  * El motor pregunta al dominio qué debe un titular ahora mismo.
  *
  * No lleva importe: el monto es justo lo que se está preguntando. Puede haber cambiado desde que el
  * cargo se dio de alta —por mora, o porque el cliente pagó por otra vía— y sólo el dominio, que es
  * quien aplica sus propias reglas, sabe cuánto queda vivo.
+ *
+ * Los tres campos son llave de búsqueda: vacíos o sin tope terminaban en 500 en el dominio (L-064).
  */
 class ResolvePendingChargesRequest {
 }
 exports.ResolvePendingChargesRequest = ResolvePendingChargesRequest;
 __decorate([
     (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.MaxLength)(CollectionResultLimits_1.COLLECTION_RESOLVE_FIELD_MAX_LENGTH),
     __metadata("design:type", String)
 ], ResolvePendingChargesRequest.prototype, "domain", void 0);
 __decorate([
     (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.MaxLength)(CollectionResultLimits_1.COLLECTION_RESOLVE_FIELD_MAX_LENGTH),
     __metadata("design:type", String)
 ], ResolvePendingChargesRequest.prototype, "directoryId", void 0);
 __decorate([
     (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.MaxLength)(CollectionResultLimits_1.COLLECTION_RESOLVE_FIELD_MAX_LENGTH),
     __metadata("design:type", String)
 ], ResolvePendingChargesRequest.prototype, "tenantId", void 0);

package/bin/collection/index.d.ts

@@ -11,6 +11,8 @@ export * from './enums/RetryIntentStatus';
 export * from './enums/AckIntentStatus';
 export * from './enums/RedriveOutboxStatus';
 export * from './enums/DisbursementType';
+export * from './constants/CollectionResultLimits';
+export * from './validators/IsCentPrecision';
 export * from './dtos/PendingChargeDto';
 export * from './dtos/CollectRequest';
 export * from './dtos/CollectResponse';

package/bin/collection/index.js

@@ -28,6 +28,9 @@ __exportStar(require("./enums/RetryIntentStatus"), exports);
 __exportStar(require("./enums/AckIntentStatus"), exports);
 __exportStar(require("./enums/RedriveOutboxStatus"), exports);
 __exportStar(require("./enums/DisbursementType"), exports);
+// Constantes y validadores
+__exportStar(require("./constants/CollectionResultLimits"), exports);
+__exportStar(require("./validators/IsCentPrecision"), exports);
 // DTOs
 __exportStar(require("./dtos/PendingChargeDto"), exports);
 __exportStar(require("./dtos/CollectRequest"), exports);

package/bin/collection/validators/IsCentPrecision.d.ts

@@ -0,0 +1,11 @@
+import { ValidationOptions } from 'class-validator';
+/** `true` si el número no tiene fracción de centavo, salvo ruido de punto flotante. */
+export declare const hasCentPrecision: (value: unknown) => boolean;
+/**
+ * Monto con a lo más dos decimales (centavos).
+ *
+ * No se usa `@IsNumber({ maxDecimalPlaces: 2 })` porque cuenta los dígitos del `toString()`: rechaza
+ * `648.2299999999999`, que es `648.23` con ruido de una resta. El motor de cobro deja ese ruido al
+ * restar lo cobrado de lo pendiente, y rechazar un resultado con dinero ya cobrado lo manda a la DLQ.
+ */
+export declare const IsCentPrecision: (validationOptions?: ValidationOptions) => PropertyDecorator;