@fiado/type-kit 3.626.0 → 3.628.0

package/_test_/unit/collection/collectionCallbackRequests.test.ts

@@ -0,0 +1,96 @@
+import 'reflect-metadata';
+import { ClassConstructor, plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import {
+    ApplyCollectionResultRequest,
+    COLLECTION_AMOUNT_MAX,
+    hasCentPrecision,
+    ResolvePendingChargesRequest,
+} from '../../../src/collection/index';
+
+const errorProperties = async <T extends object>(dtoClass: ClassConstructor<T>, body: object): Promise<string[]> =>
+    (await validate(plainToInstance(dtoClass, body), { whitelist: true })).map((error) => error.property).sort();
+
+/** Como lo arma el motor: ids compuestos, montos en pesos. */
+const RESULT = {
+    attemptId: 'surekeep-retail#01KXPB422AFGZHQKHVM7E5YDBR#INSTALLMENT#003#1#PAGO_CONFIADO#MXN_DIRECT#1',
+    intentId: 'surekeep-retail#01KXPB422AFGZHQKHVM7E5YDBR#INSTALLMENT#003#1',
+    chargeId: '01KXPB422AFGZHQKHVM7E5YDBR#INSTALLMENT#003#1',
+    domain: 'surekeep-retail',
+    tenantId: 'surekeep',
+    result: 'FULL',
+    amountCollected: 1148.35,
+    amountReserved: 0,
+    mechanism: 'MXN_DIRECT',
+};
+
+describe('ApplyCollectionResultRequest — ids no vacíos y con tope (L-005)', () => {
+    it('acepta el resultado tal como lo manda el motor', async () => {
+        expect(await errorProperties(ApplyCollectionResultRequest, RESULT)).toEqual([]);
+    });
+
+    it('rechaza attemptId, intentId o chargeId vacíos', async () => {
+        const body = { ...RESULT, attemptId: '', intentId: '', chargeId: '' };
+        expect(await errorProperties(ApplyCollectionResultRequest, body)).toEqual(['attemptId', 'chargeId', 'intentId']);
+    });
+
+    it('acepta ids de 256 y rechaza los de 257', async () => {
+        expect(await errorProperties(ApplyCollectionResultRequest, { ...RESULT, attemptId: 'a'.repeat(256) })).toEqual([]);
+        expect(await errorProperties(ApplyCollectionResultRequest, { ...RESULT, attemptId: 'a'.repeat(257) })).toEqual(['attemptId']);
+    });
+
+    it('holdTxId es opcional, pero si viaja no va vacío', async () => {
+        expect(await errorProperties(ApplyCollectionResultRequest, { ...RESULT, holdTxId: 'TX-1' })).toEqual([]);
+        expect(await errorProperties(ApplyCollectionResultRequest, { ...RESULT, holdTxId: '' })).toEqual(['holdTxId']);
+        expect(await errorProperties(ApplyCollectionResultRequest, { ...RESULT, holdTxId: 'a'.repeat(257) })).toEqual(['holdTxId']);
+    });
+});
+
+describe('ApplyCollectionResultRequest — montos en centavos, sin negativos y con techo (L-022)', () => {
+    it('acepta el ruido de una resta en double: 648.2299999999999 es 648.23', async () => {
+        const remaining = 1148.35 - 500.12;
+        expect(remaining).not.toBe(648.23);
+        const body = { ...RESULT, amountCollected: remaining, walletAmount: 350.3 - 100.1, walletCurrency: 'MXN' };
+        expect(await errorProperties(ApplyCollectionResultRequest, body)).toEqual([]);
+    });
+
+    it('rechaza fracciones de centavo reales', async () => {
+        for (const amountCollected of [10.005, 0.001, 1148.351]) {
+            expect(await errorProperties(ApplyCollectionResultRequest, { ...RESULT, amountCollected })).toEqual(['amountCollected']);
+        }
+        expect(await errorProperties(ApplyCollectionResultRequest, { ...RESULT, walletAmount: 1.239 })).toEqual(['walletAmount']);
+    });
+
+    it('rechaza negativos, montos sobre el techo e Infinity/NaN', async () => {
+        expect(await errorProperties(ApplyCollectionResultRequest, { ...RESULT, amountReserved: -0.01 })).toEqual(['amountReserved']);
+        expect(await errorProperties(ApplyCollectionResultRequest, { ...RESULT, amountCollected: COLLECTION_AMOUNT_MAX })).toEqual([]);
+        expect(await errorProperties(ApplyCollectionResultRequest, { ...RESULT, amountCollected: COLLECTION_AMOUNT_MAX + 1 })).toEqual([
+            'amountCollected',
+        ]);
+        expect(await errorProperties(ApplyCollectionResultRequest, { ...RESULT, amountCollected: Infinity })).toEqual(['amountCollected']);
+        expect(await errorProperties(ApplyCollectionResultRequest, { ...RESULT, amountCollected: NaN })).toEqual(['amountCollected']);
+    });
+
+    it('hasCentPrecision solo acepta números finitos', () => {
+        expect(hasCentPrecision(999_999_999.99)).toBe(true);
+        expect(hasCentPrecision('10.00')).toBe(false);
+        expect(hasCentPrecision(Number.POSITIVE_INFINITY)).toBe(false);
+    });
+});
+
+describe('ResolvePendingChargesRequest — llaves no vacías y con tope (L-064)', () => {
+    const body = { domain: 'surekeep-retail', directoryId: '6f1c2a34-9b1e-4f1d-8a3e-2f4b5c6d7e8f', tenantId: 'surekeep' };
+
+    it('acepta la consulta del motor', async () => {
+        expect(await errorProperties(ResolvePendingChargesRequest, body)).toEqual([]);
+    });
+
+    it('rechaza vacíos y largos de más de 128', async () => {
+        expect(await errorProperties(ResolvePendingChargesRequest, { domain: '', directoryId: '', tenantId: '' })).toEqual([
+            'directoryId',
+            'domain',
+            'tenantId',
+        ]);
+        expect(await errorProperties(ResolvePendingChargesRequest, { ...body, directoryId: 'd'.repeat(129) })).toEqual(['directoryId']);
+    });
+});

package/_test_/unit/emailVerification/dtos/EmailSetTrustedRequest.test.ts

@@ -66,4 +66,27 @@ describe('EmailSetTrustedRequest', () => {
         const errors = await validate(dto);
         expect(errors.some(e => e.property === 'isPrincipal')).toBe(true);
     });
+
+    it('acepta dedup en true', async () => {
+        const dto = plainToInstance(EmailSetTrustedRequest, { ...valid, dedup: true });
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+        expect(dto.dedup).toBe(true);
+    });
+
+    it('acepta la ausencia de dedup', async () => {
+        const dto = plainToInstance(EmailSetTrustedRequest, valid);
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+        expect(dto.dedup).toBeUndefined();
+    });
+
+    it('falla si dedup no es booleano', async () => {
+        const dto = plainToInstance(EmailSetTrustedRequest, {
+            ...valid,
+            dedup: 'si' as unknown as boolean,
+        });
+        const errors = await validate(dto);
+        expect(errors.some(e => e.property === 'dedup')).toBe(true);
+    });
 });

package/_test_/unit/loanCollectorAssignment/collectorAssignmentRequests.test.ts

@@ -0,0 +1,65 @@
+import 'reflect-metadata';
+import { ClassConstructor, plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import {
+    AssignmentStatusEnum,
+    AutoAssignRequest,
+    ListCollectorAssignmentsRequest,
+    ReassignRequest,
+    RedistributeRequest,
+} from '../../../src/loanCollectorAssignment/index';
+
+const errorProperties = async <T extends object>(dtoClass: ClassConstructor<T>, body: object): Promise<string[]> =>
+    (await validate(plainToInstance(dtoClass, body), { whitelist: true })).map((error) => error.property).sort();
+
+const ULID = '01KXPB422AFGZHQKHVM7E5YDBR';
+
+describe('Motivos de reasignación y redistribución (L-171)', () => {
+    it.each([
+        ['ReassignRequest', ReassignRequest],
+        ['RedistributeRequest', RedistributeRequest],
+    ] as const)('%s exige un motivo no en blanco de hasta 500', async (_name, dtoClass) => {
+        expect(await errorProperties(dtoClass, { reason: 'Cobrador dado de baja' })).toEqual([]);
+        expect(await errorProperties(dtoClass, { reason: '   ' })).toEqual(['reason']);
+        expect(await errorProperties(dtoClass, { reason: '' })).toEqual(['reason']);
+        expect(await errorProperties(dtoClass, { reason: 'x'.repeat(501) })).toEqual(['reason']);
+    });
+});
+
+describe('AutoAssignRequest — ids con forma de id (L-171)', () => {
+    it('acepta los ULID de retail-org y loan-credit', async () => {
+        expect(await errorProperties(AutoAssignRequest, { retailerId: ULID, creditId: ULID, storeId: 'VL-001' })).toEqual([]);
+    });
+
+    it('rechaza ids con separadores de llave o de más de 64', async () => {
+        const body = { retailerId: 'RET#1', creditId: 'a b', storeId: 'x'.repeat(65) };
+        expect(await errorProperties(AutoAssignRequest, body)).toEqual(['creditId', 'retailerId', 'storeId']);
+    });
+});
+
+describe('ListCollectorAssignmentsRequest — filtros validados y paginación (L-161, L-170)', () => {
+    it('acepta la consulta sin filtros y con todos', async () => {
+        expect(await errorProperties(ListCollectorAssignmentsRequest, {})).toEqual([]);
+        const query = { status: 'ACTIVE', storeId: ULID, collectorUserId: ULID, limit: '50', nextToken: 'eyJwayI6IkEifQ' };
+        const dto = plainToInstance(ListCollectorAssignmentsRequest, query);
+        expect(await validate(dto, { whitelist: true })).toEqual([]);
+        expect(dto.limit).toBe(50);
+        expect(dto.status).toBe(AssignmentStatusEnum.ACTIVE);
+    });
+
+    it('rechaza un estado fuera del enum y filtros crudos', async () => {
+        expect(await errorProperties(ListCollectorAssignmentsRequest, { status: 'activo' })).toEqual(['status']);
+        expect(await errorProperties(ListCollectorAssignmentsRequest, { storeId: 'x'.repeat(65), collectorUserId: 'a,b' })).toEqual([
+            'collectorUserId',
+            'storeId',
+        ]);
+    });
+
+    it('limit de 1 a 100 y cursor no vacío de hasta 1024', async () => {
+        expect(await errorProperties(ListCollectorAssignmentsRequest, { limit: '0' })).toEqual(['limit']);
+        expect(await errorProperties(ListCollectorAssignmentsRequest, { limit: '101' })).toEqual(['limit']);
+        expect(await errorProperties(ListCollectorAssignmentsRequest, { limit: 'diez' })).toEqual(['limit']);
+        expect(await errorProperties(ListCollectorAssignmentsRequest, { nextToken: '' })).toEqual(['nextToken']);
+        expect(await errorProperties(ListCollectorAssignmentsRequest, { nextToken: 'x'.repeat(1025) })).toEqual(['nextToken']);
+    });
+});

package/_test_/unit/loanConfig/parameterWriteRequests.test.ts

@@ -0,0 +1,62 @@
+import 'reflect-metadata';
+import { ClassConstructor, plainToInstance } from 'class-transformer';
+import { ValidationError, validate } from 'class-validator';
+import {
+    BULK_GET_PARAMETERS_MAX_ITEMS,
+    BULK_UPDATE_PARAMETERS_MAX_ITEMS,
+    BulkGetParametersRequest,
+    BulkUpdateParametersRequest,
+    UpdateParameterRequest,
+} from '../../../src/loanConfig/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();
+};
+
+describe('UpdateParameterRequest — value presente y reason obligatorio (L-139, L-140)', () => {
+    it('acepta un valor con motivo, y null para dejar el parámetro pendiente', async () => {
+        expect(await errorPaths(UpdateParameterRequest, { value: '30', reason: 'Ajuste de mora' })).toEqual([]);
+        expect(await errorPaths(UpdateParameterRequest, { value: null, reason: 'Queda pendiente' })).toEqual([]);
+        expect(await errorPaths(UpdateParameterRequest, { value: '', reason: 'Vacía el texto' })).toEqual([]);
+    });
+
+    it('rechaza omitir value: antes borraba el valor y respondía 200', async () => {
+        expect(await errorPaths(UpdateParameterRequest, { reason: 'Sin valor' })).toEqual(['value']);
+        expect(await errorPaths(UpdateParameterRequest, { value: 30, reason: 'Número crudo' })).toEqual(['value']);
+    });
+
+    it('rechaza reason ausente, en blanco o de más de 500', async () => {
+        expect(await errorPaths(UpdateParameterRequest, { value: '30' })).toEqual(['reason']);
+        expect(await errorPaths(UpdateParameterRequest, { value: '30', reason: '' })).toEqual(['reason']);
+        expect(await errorPaths(UpdateParameterRequest, { value: '30', reason: '   ' })).toEqual(['reason']);
+        expect(await errorPaths(UpdateParameterRequest, { value: '30', reason: 'x'.repeat(501) })).toEqual(['reason']);
+        expect(await errorPaths(UpdateParameterRequest, { value: '30', reason: 'x'.repeat(500) })).toEqual([]);
+    });
+});
+
+describe('Lotes de parámetros (L-146, L-148, L-155)', () => {
+    const item = { paramType: 'CREDIT', key: 'grace_days', value: '3', reason: 'Ajuste' };
+    const key = { paramType: 'CREDIT', key: 'grace_days' };
+
+    it('bulk-update hasta 50, con las mismas reglas por ítem', async () => {
+        const at = Array.from({ length: BULK_UPDATE_PARAMETERS_MAX_ITEMS }, () => item);
+        expect(await errorPaths(BulkUpdateParametersRequest, { parameters: at })).toEqual([]);
+        expect(await errorPaths(BulkUpdateParametersRequest, { parameters: [...at, item] })).toEqual(['parameters']);
+        expect(await errorPaths(BulkUpdateParametersRequest, { parameters: [{ ...item, value: undefined, reason: ' ' }] })).toEqual([
+            'parameters.0.reason',
+            'parameters.0.value',
+        ]);
+        expect(await errorPaths(BulkUpdateParametersRequest, { parameters: [{ ...item, value: null }] })).toEqual([]);
+    });
+
+    it('bulk-get hasta 100 claves', async () => {
+        const at = Array.from({ length: BULK_GET_PARAMETERS_MAX_ITEMS }, () => key);
+        expect(await errorPaths(BulkGetParametersRequest, { items: at })).toEqual([]);
+        expect(await errorPaths(BulkGetParametersRequest, { items: [...at, key] })).toEqual(['items']);
+    });
+});

package/_test_/unit/loanCredit/dtos/loanCreditInputLimits.test.ts

@@ -0,0 +1,168 @@
+import 'reflect-metadata';
+import { ClassConstructor, plainToInstance } from 'class-transformer';
+import { ValidationError, validate } from 'class-validator';
+import {
+    ActivationCheckRequest,
+    BackofficeApproveRestructureRequest,
+    BackofficeProposeRestructureRequest,
+    BackofficeRejectRestructureRequest,
+    BackofficeWriteOffCreditRequest,
+    CreateCustomerPaymentRequest,
+    CreateSellerPaymentRequest,
+    LOAN_AMOUNT_MAX_CENTS,
+    LoanDeviceNotifyItem,
+    OriginateLoanCreditRequest,
+    SegmentFactsBatchRequest,
+    UpsertLoanBorrowerRequest,
+} from '../../../../src/loanCredit/index';
+
+/** Rutas que fallan, con los anidados como `beneficiary.phone`; valida como el motor (whitelist). */
+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)];
+        });
+    const dto = plainToInstance(dtoClass, body);
+    return pathsOf(await validate(dto, { whitelist: true, forbidNonWhitelisted: false }), '').sort();
+};
+
+const CREDIT_ID = '01KXPB422AFGZHQKHVM7E5YDBR';
+const ULID = '01KXPB422AFGZHQKHVM7E5YDBS';
+
+describe('LoanDeviceNotifyItem — cada ítem trae un aviso (L-023)', () => {
+    const base = { creditId: CREDIT_ID, intensity: 'BANNER' };
+
+    it('acepta noticeType, title + content o notificationCode', async () => {
+        expect(await errorPaths(LoanDeviceNotifyItem, { ...base, noticeType: 'DUE_TODAY' })).toEqual([]);
+        expect(await errorPaths(LoanDeviceNotifyItem, { ...base, title: 'Pago', content: 'Tu pago vence hoy' })).toEqual([]);
+        expect(await errorPaths(LoanDeviceNotifyItem, { ...base, notificationCode: 'DC-001' })).toEqual([]);
+    });
+
+    it('rechaza el ítem sin aviso, o con título sin cuerpo', async () => {
+        expect(await errorPaths(LoanDeviceNotifyItem, base)).toEqual(['noticeType']);
+        expect(await errorPaths(LoanDeviceNotifyItem, { ...base, title: 'Pago' })).toEqual(['noticeType']);
+        expect(await errorPaths(LoanDeviceNotifyItem, { ...base, content: 'Tu pago vence hoy' })).toEqual(['noticeType']);
+    });
+
+    it('sigue rechazando un noticeType fuera del enum aunque traiga texto legacy', async () => {
+        const body = { ...base, noticeType: 'OTRO', title: 'Pago', content: 'Tu pago vence hoy' };
+        expect(await errorPaths(LoanDeviceNotifyItem, body)).toEqual(['noticeType']);
+    });
+
+    it('el mensaje dice qué falta', async () => {
+        const [error] = await validate(plainToInstance(LoanDeviceNotifyItem, base));
+        expect(Object.values(error.constraints ?? {})).toEqual([
+            'El aviso debe traer noticeType, o title y content, o notificationCode',
+        ]);
+    });
+});
+
+describe('Reestructura y castigo (L-025, L-026)', () => {
+    const terms = { newTermWeeks: 52, newTnaAnnual: 2.8 };
+
+    it('el plazo nuevo va de 1 a 104 semanas; la TNA de la reestructura no tiene techo de plan', async () => {
+        const body = (newTermWeeks: number) => ({ justification: 'Atraso por desempleo', terms: { ...terms, newTermWeeks } });
+        expect(await errorPaths(BackofficeProposeRestructureRequest, body(104))).toEqual([]);
+        expect(await errorPaths(BackofficeProposeRestructureRequest, body(105))).toEqual(['terms.newTermWeeks']);
+    });
+
+    it('justificación y motivos hasta 500 caracteres', async () => {
+        const ok = 'x'.repeat(500);
+        const long = 'x'.repeat(501);
+        expect(await errorPaths(BackofficeProposeRestructureRequest, { justification: ok, terms })).toEqual([]);
+        expect(await errorPaths(BackofficeProposeRestructureRequest, { justification: long, terms })).toEqual(['justification']);
+        expect(await errorPaths(BackofficeApproveRestructureRequest, { reason: long })).toEqual(['reason']);
+        expect(await errorPaths(BackofficeRejectRestructureRequest, { reason: long })).toEqual(['reason']);
+        expect(await errorPaths(BackofficeWriteOffCreditRequest, { reason: long })).toEqual(['reason']);
+        expect(await errorPaths(BackofficeWriteOffCreditRequest, {})).toEqual([]);
+    });
+});
+
+describe('OriginateLoanCreditRequest — techo de montos y SKU (L-027)', () => {
+    const base = {
+        wizardSessionId: 'WS-1',
+        borrowerId: 'B-1',
+        planId: 'PLAN-1',
+        termWeeks: 12,
+        equipmentPriceCents: 500000,
+        downPaymentCents: 100000,
+        storeId: 'ST-1',
+    };
+
+    it('acepta montos hasta el techo técnico y lo rechaza por encima', async () => {
+        const atCeiling = { ...base, equipmentPriceCents: LOAN_AMOUNT_MAX_CENTS, downPaymentCents: LOAN_AMOUNT_MAX_CENTS };
+        expect(await errorPaths(OriginateLoanCreditRequest, atCeiling)).toEqual([]);
+        const over = { ...base, equipmentPriceCents: LOAN_AMOUNT_MAX_CENTS + 1, downPaymentCents: Number.MAX_SAFE_INTEGER };
+        expect(await errorPaths(OriginateLoanCreditRequest, over)).toEqual(['downPaymentCents', 'equipmentPriceCents']);
+    });
+
+    it('el SKU sigue el patrón del catálogo', async () => {
+        expect(await errorPaths(OriginateLoanCreditRequest, { ...base, productSku: 'SKU-MOTO G54 128' })).toEqual([]);
+        for (const productSku of ['', 'SKU_MOTO', 'SKU/1', ' SKU', 'A'.repeat(65)]) {
+            expect(await errorPaths(OriginateLoanCreditRequest, { ...base, productSku })).toEqual(['productSku']);
+        }
+    });
+});
+
+describe('ActivationCheckRequest — SKU e IMEI con formato (L-029)', () => {
+    it('acepta IMEI de 15 dígitos y SKU del catálogo', async () => {
+        expect(await errorPaths(ActivationCheckRequest, { imei: '351756051523999', productSku: 'SKU-MOTO-G54-128' })).toEqual([]);
+    });
+
+    it('rechaza IMEI con separadores o de otro largo, y SKU vacío o con otros caracteres', async () => {
+        for (const imei of ['35175605152399', '3517560515239990', '351756-05152399', '']) {
+            expect(await errorPaths(ActivationCheckRequest, { imei })).toEqual(['imei']);
+        }
+        for (const productSku of ['', 'SKU.1', 'A'.repeat(65)]) {
+            expect(await errorPaths(ActivationCheckRequest, { productSku })).toEqual(['productSku']);
+        }
+    });
+});
+
+describe('UpsertLoanBorrowerRequest y beneficiario (L-031)', () => {
+    it('acepta un ULID de retail-customer con beneficiario completo', async () => {
+        const body = { retailCustomerId: ULID, beneficiary: { fullName: 'Ana López', relationship: 'Hermana', phone: '5512345678' } };
+        expect(await errorPaths(UpsertLoanBorrowerRequest, body)).toEqual([]);
+        expect(await errorPaths(UpsertLoanBorrowerRequest, { ...body, beneficiary: { ...body.beneficiary, phone: '+525512345678' } })).toEqual([]);
+    });
+
+    it('rechaza un retailCustomerId con símbolos o de más de 64', async () => {
+        for (const retailCustomerId of ['RC 1', 'RC#1', 'a,b', 'A'.repeat(65), '']) {
+            expect(await errorPaths(UpsertLoanBorrowerRequest, { retailCustomerId })).toEqual(['retailCustomerId']);
+        }
+    });
+
+    it('acota el beneficiario: nombre 300, parentesco 120 y teléfono MX', async () => {
+        const beneficiary = { fullName: 'x'.repeat(301), relationship: 'x'.repeat(121), phone: '55 1234 5678' };
+        expect(await errorPaths(UpsertLoanBorrowerRequest, { retailCustomerId: ULID, beneficiary })).toEqual([
+            'beneficiary.fullName',
+            'beneficiary.phone',
+            'beneficiary.relationship',
+        ]);
+    });
+});
+
+describe('SegmentFactsBatchRequest — ids con forma de id (L-067)', () => {
+    it('acepta ULID y rechaza ids con espacios o símbolos', async () => {
+        expect(await errorPaths(SegmentFactsBatchRequest, { retailCustomerIds: [ULID, 'rc_legacy-1'] })).toEqual([]);
+        expect(await errorPaths(SegmentFactsBatchRequest, { retailCustomerIds: [ULID, 'rc 1'] })).toEqual(['retailCustomerIds']);
+        expect(await errorPaths(SegmentFactsBatchRequest, { retailCustomerIds: ['x'.repeat(65)] })).toEqual(['retailCustomerIds']);
+    });
+});
+
+describe('confirmDuplicate en los pagos (L-057, L-092)', () => {
+    const seller = { type: 'NEXT_INSTALLMENT', expectedAmountCents: 48_700, method: 'CASH', idempotencyKey: '7b0e3a52-6a0f-4f1f-9f43-6b4d5c1e2a10' };
+    const customer = { type: 'NEXT_INSTALLMENT', expectedAmountCents: 48_700, idempotencyKey: '7b0e3a52-6a0f-4f1f-9f43-6b4d5c1e2a10' };
+
+    it('es opcional y booleano, y sobrevive al whitelist', async () => {
+        expect(await errorPaths(CreateSellerPaymentRequest, seller)).toEqual([]);
+        expect(await errorPaths(CreateCustomerPaymentRequest, customer)).toEqual([]);
+        expect(await errorPaths(CreateSellerPaymentRequest, { ...seller, confirmDuplicate: 'si' })).toEqual(['confirmDuplicate']);
+        expect(await errorPaths(CreateCustomerPaymentRequest, { ...customer, confirmDuplicate: 1 })).toEqual(['confirmDuplicate']);
+
+        const dto = plainToInstance(CreateCustomerPaymentRequest, { ...customer, confirmDuplicate: true });
+        await validate(dto, { whitelist: true });
+        expect(dto.confirmDuplicate).toBe(true);
+    });
+});

package/_test_/unit/loanCredit/signLoanCreditRequest.test.ts

@@ -1,7 +1,7 @@
 import 'reflect-metadata';
 import { plainToInstance } from 'class-transformer';
 import { ValidationError, validate } from 'class-validator';
-import { SignLoanCreditRequest } from '../../../src/loanCredit/index';
+import { isContractBirthDate, SignLoanCreditRequest } from '../../../src/loanCredit/index';
 
 /** Rutas de las propiedades que fallan, con los anidados como `contractDetails.borrower.fullName`. */
 const pathsOf = (errors: ValidationError[], prefix = ''): string[] =>
@@ -71,11 +71,16 @@ describe('SignLoanCreditRequest', () => {
         expect(await errorsOf({ contractDetails: DETAILS })).toEqual([]);
     });
 
-    it('acepta la CLABE tal como la tiene la cuenta, aunque no sean 18 dígitos', async () => {
+    it('acepta la CLABE tal como la tiene la cuenta, aunque no sean 18 dígitos: D9 la aplica el dominio', async () => {
         const details = { ...DETAILS, pcfAccount: { clabe: 'dummy' } };
         expect(await errorsOf({ contractDetails: details })).toEqual([]);
     });
 
+    it('rechaza una CLABE de más de 120 caracteres', async () => {
+        const details = { ...DETAILS, pcfAccount: { clabe: '6'.repeat(121) } };
+        expect(await errorsOf({ contractDetails: details })).toEqual(['contractDetails.pcfAccount.clabe']);
+    });
+
     it('rechaza una CLABE vacía', async () => {
         const details = { ...DETAILS, pcfAccount: { clabe: '' } };
         expect(await errorsOf({ contractDetails: details })).toEqual(['contractDetails.pcfAccount.clabe']);
@@ -123,3 +128,57 @@ describe('SignLoanCreditRequest.signatureContext', () => {
         expect(await errorsOf({ signatureContext: { ...CONTEXT, termsAccepted: 'si' } })).toEqual(['signatureContext.termsAccepted']);
     });
 });
+
+describe('SignLoanCreditRequest — reglas de la auditoría (L-030, L-069)', () => {
+    const withBorrower = (borrower: Record<string, unknown>): Record<string, unknown> => ({
+        contractDetails: { ...DETAILS, borrower: { ...DETAILS.borrower, ...borrower } },
+    });
+
+    it('acepta un CURP sin el formato oficial (lo revisa el dominio) y rechaza uno de más de 120', async () => {
+        for (const curp of ['LOHM900215MMCPRR0', 'lohm900215mmcprr09', 'X'.repeat(120)]) {
+            expect(await errorsOf(withBorrower({ curp }))).toEqual([]);
+        }
+        expect(await errorsOf(withBorrower({ curp: 'X'.repeat(121) }))).toEqual(['contractDetails.borrower.curp']);
+    });
+
+    it('acepta correo válido y rechaza uno sin dominio o de más de 254', async () => {
+        expect(await errorsOf(withBorrower({ email: 'maria@example.com' }))).toEqual([]);
+        expect(await errorsOf(withBorrower({ email: 'maria@' }))).toEqual(['contractDetails.borrower.email']);
+        expect(await errorsOf(withBorrower({ email: `${'a'.repeat(250)}@b.mx` }))).toEqual(['contractDetails.borrower.email']);
+    });
+
+    it('la fecha de nacimiento solo tiene tope de largo: acepta lo que manda el wizard tal cual', async () => {
+        for (const birthDate of ['15/02/1990', '1990-02-15', '31/02/1990']) {
+            expect(await errorsOf(withBorrower({ birthDate }))).toEqual([]);
+        }
+        expect(await errorsOf(withBorrower({ birthDate: '1'.repeat(121) }))).toEqual(['contractDetails.borrower.birthDate']);
+    });
+
+    it('isContractBirthDate queda para el dominio: DD/MM/AAAA o AAAA-MM-DD que existan', () => {
+        for (const value of ['15/02/1990', '1990-02-15', '29/02/2000']) {
+            expect(isContractBirthDate(value)).toBe(true);
+        }
+        for (const value of ['31/02/1990', '29/02/1990', '1990-13-01', '15 de febrero de 1990', '1990-02-15T00:00:00Z', '', 19900215]) {
+            expect(isContractBirthDate(value)).toBe(false);
+        }
+    });
+
+    it('el RFC solo tiene tope de largo (el formato lo revisa el dominio)', async () => {
+        expect(await errorsOf(withBorrower({ rfc: 'lohm900215' }))).toEqual([]);
+    });
+
+    it('la IP solo tiene tope de largo: acepta el "desconocida" de respaldo del wizard', async () => {
+        for (const ip of ['201.141.10.20', '2806:2f0:9020::1', 'desconocida']) {
+            expect(await errorsOf({ signatureContext: { ...CONTEXT, ip } })).toEqual([]);
+        }
+        expect(await errorsOf({ signatureContext: { ...CONTEXT, ip: '1'.repeat(65) } })).toEqual(['signatureContext.ip']);
+        expect(await errorsOf({ signatureContext: { ...CONTEXT, ip: '' } })).toEqual(['signatureContext.ip']);
+    });
+
+    it('el destino del OTP va en E.164', async () => {
+        expect(await errorsOf({ otpDestination: '+525512345678' })).toEqual([]);
+        for (const otpDestination of ['5512345678', '+52 55 1234 5678', '+0525512345678', '+52551234567890123']) {
+            expect(await errorsOf({ otpDestination })).toEqual(['otpDestination']);
+        }
+    });
+});