@fiado/type-kit 3.574.0 → 3.575.0

package/_test_/unit/rewardsEligibility/evaluationStrategyDtos.test.ts

@@ -0,0 +1,93 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import { EvaluationStrategyEnum } from '../../../src/rules';
+import {
+    CreateRunRequest,
+    EVALUATE_BATCH_MAX_SUBJECTS,
+    EvaluateBatchMessage,
+    EvaluationRequest,
+    EvaluationResponse,
+    RewardInputRef,
+    SimulateRequest,
+} from '../../../src/rewardsEligibility';
+import { InputFieldTypeEnum } from '../../../src/dynamicForm/enums/InputFieldTypeEnum';
+
+const parse = <T extends object>(cls: new () => T, value: object): T => plainToInstance(cls, value, { excludeExtraneousValues: true });
+
+const evaluation = {
+    id: 'eval-1',
+    campaignId: 'camp-1',
+    name: 'Eval',
+    description: '',
+    inputs: [],
+    rules: {},
+    beneficiaryInput: 'user',
+    reward: {},
+    grantPolicy: {},
+    triggers: [{}],
+};
+
+describe('EvaluationRequest.evaluationStrategy', () => {
+    it('ausente valida igual que hoy', async () => {
+        expect(await validate(parse(EvaluationRequest, evaluation))).toEqual([]);
+    });
+    it('acepta LIVE y DATALAKE; rechaza otro', async () => {
+        const ok = parse(EvaluationRequest, { ...evaluation, evaluationStrategy: 'DATALAKE' });
+        expect(await validate(ok)).toEqual([]);
+        expect(ok.evaluationStrategy).toBe(EvaluationStrategyEnum.DATALAKE);
+        expect((await validate(parse(EvaluationRequest, { ...evaluation, evaluationStrategy: 'X' }))).length).toBe(1);
+    });
+    it('EvaluationResponse lleva evaluationStrategy opcional', () => {
+        const r: Pick<EvaluationResponse, 'evaluationStrategy'> = { evaluationStrategy: EvaluationStrategyEnum.LIVE };
+        expect(r.evaluationStrategy).toBe('LIVE');
+    });
+});
+
+describe('RewardInputRef', () => {
+    it('admite const, input y field con fallback y as', () => {
+        const refs: RewardInputRef[] = [
+            { const: 'x' },
+            { input: 'email' },
+            { field: 'directory:email' },
+            { field: 'credit-activity:overdueCount', fallback: 0, as: InputFieldTypeEnum.NUMBER },
+        ];
+        expect(refs).toHaveLength(4);
+    });
+});
+
+describe('EvaluateBatchMessage', () => {
+    const msg = (n: number) => ({
+        messageType: 'EVALUATE_BATCH',
+        runId: 'r',
+        batchId: 'b',
+        subjects: Array.from({ length: n }, (_v, i) => ({ subjectKey: `s-${i}`, inputs: {} })),
+    });
+    it('constante 1000', () => expect(EVALUATE_BATCH_MAX_SUBJECTS).toBe(1000));
+    it('1000 sujetos ok, 1001 error', async () => {
+        expect(await validate(parse(EvaluateBatchMessage, msg(1000)))).toEqual([]);
+        expect((await validate(parse(EvaluateBatchMessage, msg(1001)))).length).toBe(1);
+    });
+});
+
+describe.each([
+    ['CreateRunRequest', () => ({ requestId: 'req-12345678', mode: 'LIVE', inputs: {} }), CreateRunRequest],
+    ['SimulateRequest', () => ({ evaluationId: 'eval-1', inputs: {} }), SimulateRequest],
+] as const)('%s.rewardInputs', (_name, make, cls) => {
+    it('sin rewardInputs valida igual', async () => {
+        expect(await validate(parse(cls as new () => object, make()))).toEqual([]);
+    });
+    it('acepta dos niveles item → clave → valor', async () => {
+        const r = parse(cls as new () => object, { ...make(), rewardInputs: { item: { key: 'v', n: 3, b: true, d: { from: '1d', to: '2d' } } } });
+        expect(await validate(r)).toEqual([]);
+    });
+    it.each([
+        ['valor anidado', { item: { key: { a: { b: 1 } } } }],
+        ['un solo nivel', { item: 'v' }],
+        ['array', [1]],
+        ['nivel interno array', { item: ['x'] }],
+    ])('rechaza: %s', async (_n, value) => {
+        const r = parse(cls as new () => object, { ...make(), rewardInputs: value });
+        expect((await validate(r)).length).toBeGreaterThan(0);
+    });
+});

package/_test_/unit/rewardsEligibility/segmentMessagesAndRunDtos.test.ts

@@ -17,12 +17,12 @@ describe('mensajes de la cola de elegibilidad', () => {
         expect(await ok(ReleaseTrancheMessage, { messageType: T.RELEASE_TRANCHE, seq: 3 })).toBe(true);
         expect(await ok(ReleaseTrancheMessage, { messageType: T.RELEASE_TRANCHE, seq: -1 })).toBe(false);
     });
-    it('EVALUATE_BATCH: <= 100 sujetos, sin prefetchedFacts', async () => {
+    it('EVALUATE_BATCH: <= 1000 sujetos, sin prefetchedFacts', async () => {
         const subject = { subjectKey: 'd-1', inputs: { directoryId: 'd-1' } };
         const base = { messageType: T.EVALUATE_BATCH, runId: 'r-1', batchId: 'r-1#p0#b0' };
         expect(await ok(EvaluateBatchMessage, { ...base, subjects: [subject] })).toBe(true);
         expect(await ok(EvaluateBatchMessage, { ...base, subjects: [] })).toBe(false);
-        expect(await ok(EvaluateBatchMessage, { ...base, subjects: Array.from({ length: 101 }, () => subject) })).toBe(false);
+        expect(await ok(EvaluateBatchMessage, { ...base, subjects: Array.from({ length: 1001 }, () => subject) })).toBe(false);
         const parsed = plainToInstance(EvaluateBatchMessage, { ...base, subjects: [{ ...subject, prefetchedFacts: { a: 1 } }] }, { excludeExtraneousValues: true });
         expect('prefetchedFacts' in parsed.subjects[0]).toBe(false);
     });

package/_test_/unit/rules/evaluationDatalakeDtos.test.ts

@@ -0,0 +1,144 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import {
+    EvaluateRulesRequest,
+    EvaluationExecutionRequest,
+    EvaluationExecutionResponse,
+    EvaluationExecutionResultsResponse,
+    EvaluationResultsRequest,
+    EvaluationStrategyEnum,
+    PopulationExecutionStatusEnum,
+    RETURN_FIELD_ID_PATTERN,
+    RULES_MAX_RETURN_FIELDS,
+    RULES_MAX_SUBJECTS_PER_DATALAKE_CALL,
+    ReturnFieldsCatalogResponse,
+    RulesErrorCodeEnum,
+    RulesValueTypeEnum,
+    SegmentColumnSchemaResponse,
+    ValidateRulesRequest,
+} from '../../../src/rules';
+
+const parse = <T extends object>(cls: new () => T, value: object): T => plainToInstance(cls, value, { excludeExtraneousValues: true });
+const KEY = 'k'.repeat(32);
+const base = { items: ['directory:email'], subjects: [{ directoryId: 'd-1' }], rules: [{ id: 'r1', rule: { match: 'ALL', groups: [] } }] };
+const validReturn = ['credit-activity:overdueCount', 'directoryuser.email', 'surekeeploanscievaluation.offer.termsweeks'];
+
+describe('constantes y enums', () => {
+    it('exporta los valores del contrato', () => {
+        expect(EvaluationStrategyEnum).toEqual({ LIVE: 'LIVE', DATALAKE: 'DATALAKE' });
+        expect(RULES_MAX_SUBJECTS_PER_DATALAKE_CALL).toBe(1000);
+        expect(RULES_MAX_RETURN_FIELDS).toBe(20);
+        expect(RulesErrorCodeEnum.RULE_NOT_DATALAKE_COMPATIBLE).toBe('RULE_NOT_DATALAKE_COMPATIBLE');
+        expect(RulesErrorCodeEnum.DATALAKE_UNAVAILABLE).toBe('DATALAKE_UNAVAILABLE');
+        expect(RulesErrorCodeEnum.DATALAKE_EVALUATION_FAILED).toBe('DATALAKE_EVALUATION_FAILED');
+        expect(RulesErrorCodeEnum.DATALAKE_EVALUATION_TIMEOUT).toBe('DATALAKE_EVALUATION_TIMEOUT');
+        expect(RulesErrorCodeEnum.UNKNOWN_RETURN_FIELD).toBe('UNKNOWN_RETURN_FIELD');
+    });
+    it('RETURN_FIELD_ID_PATTERN', () => {
+        validReturn.forEach((id) => expect(RETURN_FIELD_ID_PATTERN.test(id)).toBe(true));
+        ['Credit:x', 'a', 'tabla.', 'x y', 'a:1x'].forEach((id) => expect(RETURN_FIELD_ID_PATTERN.test(id)).toBe(false));
+    });
+});
+
+describe('EvaluateRulesRequest / ValidateRulesRequest', () => {
+    it('sin campos nuevos sigue válido (compatibilidad)', async () => {
+        expect(await validate(parse(EvaluateRulesRequest, base))).toEqual([]);
+    });
+    it('acepta estrategia, returnFields válidos e inputContract', async () => {
+        const r = parse(EvaluateRulesRequest, { ...base, evaluationStrategy: 'DATALAKE', returnFields: validReturn, inputContract: [] });
+        expect(await validate(r)).toEqual([]);
+        expect(r.evaluationStrategy).toBe(EvaluationStrategyEnum.DATALAKE);
+    });
+    it('21 returnFields → error', async () => {
+        const ids = Array.from({ length: 21 }, (_v, i) => `directoryuser.c${i}`.replace(/\d/g, 'x') + '_a');
+        expect((await validate(parse(EvaluateRulesRequest, { ...base, returnFields: ids }))).length).toBe(1);
+    });
+    it.each(['Credit:x', 'a', 'tabla.', 'x y'])('returnField inválido %s', async (id) => {
+        expect((await validate(parse(EvaluateRulesRequest, { ...base, returnFields: [id] }))).length).toBe(1);
+    });
+    it('evaluationStrategy desconocida → error', async () => {
+        expect((await validate(parse(EvaluateRulesRequest, { ...base, evaluationStrategy: 'OTRO' }))).length).toBe(1);
+    });
+    it('inputContract de 31 campos → error', async () => {
+        const contract = Array.from({ length: 31 }, () => ({}));
+        expect((await validate(parse(EvaluateRulesRequest, { ...base, inputContract: contract }))).length).toBe(1);
+    });
+    it('ValidateRulesRequest acepta estrategia y returnFields', async () => {
+        const ok = parse(ValidateRulesRequest, { items: [], rule: {}, evaluationStrategy: 'LIVE', returnFields: validReturn });
+        expect(await validate(ok)).toEqual([]);
+        const bad = parse(ValidateRulesRequest, { items: [], rule: {}, evaluationStrategy: 'X', returnFields: ['a'] });
+        expect((await validate(bad)).length).toBe(2);
+    });
+});
+
+describe('EvaluationExecutionRequest', () => {
+    const exec = { items: ['directory:email'], subjects: [{ directoryId: 'd-1' }], rules: base.rules, referenceAt: '2026-10-22T10:00:00Z', idempotencyKey: KEY };
+    it('válido', async () => {
+        expect(await validate(parse(EvaluationExecutionRequest, exec))).toEqual([]);
+    });
+    it('idempotencyKey: 31 chars error, 32 ok, 129 error', async () => {
+        expect((await validate(parse(EvaluationExecutionRequest, { ...exec, idempotencyKey: 'k'.repeat(31) }))).length).toBe(1);
+        expect(await validate(parse(EvaluationExecutionRequest, { ...exec, idempotencyKey: KEY }))).toEqual([]);
+        expect((await validate(parse(EvaluationExecutionRequest, { ...exec, idempotencyKey: 'k'.repeat(129) }))).length).toBe(1);
+    });
+    it('referenceAt sin hora → error', async () => {
+        expect((await validate(parse(EvaluationExecutionRequest, { ...exec, referenceAt: '2026-10-22' }))).length).toBe(1);
+    });
+    it('sin rules y sin returnFields: el DTO lo acepta (la regla "rules o returnFields" la valida A10)', async () => {
+        const { rules: _rules, ...noRules } = exec;
+        expect(await validate(parse(EvaluationExecutionRequest, noRules))).toEqual([]);
+    });
+    it('modo solo campos con returnFields', async () => {
+        const { rules: _rules, ...noRules } = exec;
+        expect(await validate(parse(EvaluationExecutionRequest, { ...noRules, returnFields: validReturn }))).toEqual([]);
+    });
+    it('rules: 0 o más de 10 → error', async () => {
+        expect((await validate(parse(EvaluationExecutionRequest, { ...exec, rules: [] }))).length).toBe(1);
+        const eleven = Array.from({ length: 11 }, (_v, i) => ({ id: `r${i}`, rule: {} }));
+        expect((await validate(parse(EvaluationExecutionRequest, { ...exec, rules: eleven }))).length).toBe(1);
+    });
+    it('inputContract de 31 campos → error', async () => {
+        expect((await validate(parse(EvaluationExecutionRequest, { ...exec, inputContract: Array.from({ length: 31 }, () => ({})) }))).length).toBe(1);
+    });
+    it('sin sujetos o más de 1000 → error', async () => {
+        expect((await validate(parse(EvaluationExecutionRequest, { ...exec, subjects: [] }))).length).toBe(1);
+        const many = Array.from({ length: 1001 }, (_v, i) => ({ directoryId: `d-${i}` }));
+        expect((await validate(parse(EvaluationExecutionRequest, { ...exec, subjects: many }))).length).toBe(1);
+        const max = Array.from({ length: 1000 }, (_v, i) => ({ directoryId: `d-${i}` }));
+        expect(await validate(parse(EvaluationExecutionRequest, { ...exec, subjects: max }))).toEqual([]);
+    });
+});
+
+describe('EvaluationResultsRequest y respuestas', () => {
+    it('results request: nextToken y returnFields opcionales', async () => {
+        const r = parse(EvaluationResultsRequest, { items: [], rules: base.rules, returnFields: validReturn, nextToken: 't' });
+        expect(await validate(r)).toEqual([]);
+        expect((await validate(parse(EvaluationResultsRequest, { items: [], returnFields: ['a'] }))).length).toBe(1);
+    });
+    it('formas de respuesta (tipado)', () => {
+        const run: EvaluationExecutionResponse = { executionId: 'e', status: PopulationExecutionStatusEnum.RUNNING };
+        const res: EvaluationExecutionResultsResponse = {
+            executionId: 'e',
+            status: PopulationExecutionStatusEnum.FAILED,
+            results: [],
+            reason: RulesErrorCodeEnum.DATALAKE_EVALUATION_TIMEOUT,
+        };
+        const cat: ReturnFieldsCatalogResponse = {
+            available: true,
+            fields: [{ id: 'directory:email', source: 'directory', field: 'email', label: 'Correo', description: '', valueType: RulesValueTypeEnum.STRING, datalakeCompatible: true }],
+        };
+        expect(run.status).toBe('RUNNING');
+        expect(res.reason).toBe('DATALAKE_EVALUATION_TIMEOUT');
+        expect(cat.fields[0].id).toBe('directory:email');
+    });
+});
+
+describe('SegmentColumnSchemaResponse', () => {
+    it('inArray es opcional', () => {
+        const a: SegmentColumnSchemaResponse = { name: 'x', type: 'string', isDate: false, operators: [] };
+        const b: SegmentColumnSchemaResponse = { ...a, inArray: true };
+        expect(a.inArray).toBeUndefined();
+        expect(b.inArray).toBe(true);
+    });
+});

package/bin/rewardsEligibility/constants/BatchLimits.d.ts

@@ -0,0 +1,2 @@
+/** Máximo de sujetos de un `EvaluateBatchMessage` (lote de una evaluación DATALAKE). */
+export declare const EVALUATE_BATCH_MAX_SUBJECTS = 1000;

package/bin/rewardsEligibility/constants/BatchLimits.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVALUATE_BATCH_MAX_SUBJECTS = void 0;
+/** Máximo de sujetos de un `EvaluateBatchMessage` (lote de una evaluación DATALAKE). */
+exports.EVALUATE_BATCH_MAX_SUBJECTS = 1000;

package/bin/rewardsEligibility/dtos/backoffice/CreateRunRequest.d.ts

@@ -8,4 +8,6 @@ export declare class CreateRunRequest {
     mode: RunModeEnum;
     inputs?: Record<string, DynamicFormValue>;
     population?: PopulationRunRequest;
+    /** Valores escritos por el operador para ESTA corrida: itemKey → inputKey → valor. */
+    rewardInputs?: Record<string, Record<string, DynamicFormValue>>;
 }

package/bin/rewardsEligibility/dtos/backoffice/CreateRunRequest.js

@@ -13,6 +13,7 @@ exports.CreateRunRequest = void 0;
 const class_transformer_1 = require("class-transformer");
 const class_validator_1 = require("class-validator");
 const IsDynamicFormValues_1 = require("../../../dynamicForm/validators/IsDynamicFormValues");
+const IsRewardInputs_1 = require("../../validators/IsRewardInputs");
 const BackofficeLimits_1 = require("../../constants/BackofficeLimits");
 const RunModeEnum_1 = require("../../enums/RunModeEnum");
 const PopulationRunRequest_1 = require("./PopulationRunRequest");
@@ -45,3 +46,9 @@ __decorate([
     (0, class_transformer_1.Type)(() => PopulationRunRequest_1.PopulationRunRequest),
     __metadata("design:type", PopulationRunRequest_1.PopulationRunRequest)
 ], CreateRunRequest.prototype, "population", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.Validate)(IsRewardInputs_1.IsRewardInputs),
+    __metadata("design:type", Object)
+], CreateRunRequest.prototype, "rewardInputs", void 0);

package/bin/rewardsEligibility/dtos/backoffice/EvaluationRequest.d.ts

@@ -1,4 +1,5 @@
 import { JsonValue } from '../../../common';
+import { EvaluationStrategyEnum } from '../../../rules/enums/EvaluationStrategyEnum';
 import { InputField } from '../../../dynamicForm/dtos/InputField';
 import { EvaluationReward } from '../EvaluationReward';
 import { EvaluationTrigger } from '../EvaluationTrigger';
@@ -28,4 +29,6 @@ export declare class EvaluationRequest {
     populationSegmentId?: string;
     /** Llave del input `DIRECTORY` que recibe el `directoryid` de cada persona del segmento. */
     populationInputKey?: string;
+    /** Estrategia de evaluación de las corridas masivas; ausente = `LIVE`. */
+    evaluationStrategy?: EvaluationStrategyEnum;
 }

package/bin/rewardsEligibility/dtos/backoffice/EvaluationRequest.js

@@ -12,6 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EvaluationRequest = void 0;
 const class_transformer_1 = require("class-transformer");
 const class_validator_1 = require("class-validator");
+const EvaluationStrategyEnum_1 = require("../../../rules/enums/EvaluationStrategyEnum");
 const BackofficeLimits_1 = require("../../constants/BackofficeLimits");
 const EvaluationReward_1 = require("../EvaluationReward");
 const GrantPolicy_1 = require("../GrantPolicy");
@@ -98,3 +99,9 @@ __decorate([
     (0, class_validator_1.Matches)(BackofficeLimits_1.INPUT_KEY_PATTERN),
     __metadata("design:type", String)
 ], EvaluationRequest.prototype, "populationInputKey", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsEnum)(EvaluationStrategyEnum_1.EvaluationStrategyEnum),
+    __metadata("design:type", String)
+], EvaluationRequest.prototype, "evaluationStrategy", void 0);

package/bin/rewardsEligibility/dtos/backoffice/EvaluationResponse.d.ts

@@ -1,4 +1,5 @@
 import { JsonValue } from '../../../common';
+import { EvaluationStrategyEnum } from '../../../rules/enums/EvaluationStrategyEnum';
 import { InputField } from '../../../dynamicForm/dtos/InputField';
 import { EvaluationStatusEnum } from '../../enums/EvaluationStatusEnum';
 import { EvaluationReward } from '../EvaluationReward';
@@ -22,6 +23,8 @@ export declare class EvaluationResponse {
     triggers: EvaluationTrigger[];
     populationSegmentId?: string;
     populationInputKey?: string;
+    /** Ausente = `LIVE`. */
+    evaluationStrategy?: EvaluationStrategyEnum;
     createdAt: number;
     updatedAt: number;
     updatedBy: string;

package/bin/rewardsEligibility/dtos/backoffice/SimulateRequest.d.ts

@@ -5,4 +5,6 @@ export declare class SimulateRequest {
     evaluationId?: string;
     evaluation?: EvaluationRequest;
     inputs: Record<string, DynamicFormValue>;
+    /** Valores escritos por el operador para ESTA corrida: itemKey → inputKey → valor. */
+    rewardInputs?: Record<string, Record<string, DynamicFormValue>>;
 }

package/bin/rewardsEligibility/dtos/backoffice/SimulateRequest.js

@@ -13,6 +13,7 @@ exports.SimulateRequest = void 0;
 const class_transformer_1 = require("class-transformer");
 const class_validator_1 = require("class-validator");
 const IsDynamicFormValues_1 = require("../../../dynamicForm/validators/IsDynamicFormValues");
+const IsRewardInputs_1 = require("../../validators/IsRewardInputs");
 const BackofficeLimits_1 = require("../../constants/BackofficeLimits");
 const EvaluationRequest_1 = require("./EvaluationRequest");
 /** `POST /evaluations/simulate`: una evaluación GUARDADA (`evaluationId`) o un BORRADOR sin guardar (`evaluation`), más los inputs del sujeto. No persiste nada. Exactamente uno de los dos lo valida el lambda. */
@@ -38,3 +39,9 @@ __decorate([
     (0, class_validator_1.Validate)(IsDynamicFormValues_1.IsDynamicFormValues),
     __metadata("design:type", Object)
 ], SimulateRequest.prototype, "inputs", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.Validate)(IsRewardInputs_1.IsRewardInputs),
+    __metadata("design:type", Object)
+], SimulateRequest.prototype, "rewardInputs", void 0);

package/bin/rewardsEligibility/dtos/messages/EvaluateBatchMessage.d.ts

@@ -5,7 +5,7 @@ export declare class EvaluateBatchSubject {
     subjectKey: string;
     inputs: Record<string, DynamicFormValue>;
 }
-/** Lote de hasta 100 sujetos a evaluar en una corrida masiva. */
+/** Lote de hasta 1000 sujetos a evaluar en una corrida masiva. */
 export declare class EvaluateBatchMessage {
     messageType: EligibilityMessageTypeEnum.EVALUATE_BATCH;
     runId: string;

package/bin/rewardsEligibility/dtos/messages/EvaluateBatchMessage.js

@@ -13,6 +13,7 @@ exports.EvaluateBatchMessage = exports.EvaluateBatchSubject = void 0;
 const class_transformer_1 = require("class-transformer");
 const class_validator_1 = require("class-validator");
 const IsDynamicFormValues_1 = require("../../../dynamicForm/validators/IsDynamicFormValues");
+const BatchLimits_1 = require("../../constants/BatchLimits");
 const EligibilityMessageTypeEnum_1 = require("../../enums/EligibilityMessageTypeEnum");
 /** Un sujeto del lote. No lleva hechos precargados: la evaluacion siempre es en vivo. */
 class EvaluateBatchSubject {
@@ -29,7 +30,7 @@ __decorate([
     (0, class_validator_1.Validate)(IsDynamicFormValues_1.IsDynamicFormValues),
     __metadata("design:type", Object)
 ], EvaluateBatchSubject.prototype, "inputs", void 0);
-/** Lote de hasta 100 sujetos a evaluar en una corrida masiva. */
+/** Lote de hasta 1000 sujetos a evaluar en una corrida masiva. */
 class EvaluateBatchMessage {
 }
 exports.EvaluateBatchMessage = EvaluateBatchMessage;
@@ -54,7 +55,7 @@ __decorate([
     (0, class_transformer_1.Expose)(),
     (0, class_validator_1.IsArray)(),
     (0, class_validator_1.ArrayMinSize)(1),
-    (0, class_validator_1.ArrayMaxSize)(100),
+    (0, class_validator_1.ArrayMaxSize)(BatchLimits_1.EVALUATE_BATCH_MAX_SUBJECTS),
     (0, class_validator_1.ValidateNested)({ each: true }),
     (0, class_transformer_1.Type)(() => EvaluateBatchSubject),
     __metadata("design:type", Array)

package/bin/rewardsEligibility/index.d.ts

@@ -32,6 +32,8 @@ export * from './enums/MetricsDimensionEnum';
 export * from './enums/RuleValueTypeEnum';
 export * from './enums/RulesChatRoleEnum';
 export * from './constants/BackofficeLimits';
+export * from './constants/BatchLimits';
+export * from './validators/IsRewardInputs';
 export * from './dtos/backoffice/CampaignRequest';
 export * from './dtos/backoffice/CampaignStatusRequest';
 export * from './dtos/backoffice/CampaignResponse';

package/bin/rewardsEligibility/index.js

@@ -54,6 +54,8 @@ __exportStar(require("./enums/MetricsDimensionEnum"), exports);
 __exportStar(require("./enums/RuleValueTypeEnum"), exports);
 __exportStar(require("./enums/RulesChatRoleEnum"), exports);
 __exportStar(require("./constants/BackofficeLimits"), exports);
+__exportStar(require("./constants/BatchLimits"), exports);
+__exportStar(require("./validators/IsRewardInputs"), exports);
 __exportStar(require("./dtos/backoffice/CampaignRequest"), exports);
 __exportStar(require("./dtos/backoffice/CampaignStatusRequest"), exports);
 __exportStar(require("./dtos/backoffice/CampaignResponse"), exports);

package/bin/rewardsEligibility/types/RewardInputRef.d.ts

@@ -1,7 +1,15 @@
+import { InputFieldTypeEnum } from '../../dynamicForm/enums/InputFieldTypeEnum';
 import { DynamicFormValue } from '../../dynamicForm/types/DynamicFormValue';
-/** Valor de un input de `reward.inputs`: constante o tomado de un input de la evaluacion (spec B 5.1). */
+/**
+ * Valor de un input de `reward.inputs`: constante, tomado de un input de la evaluacion (spec B 5.1)
+ * o de un campo del usuario leído del datalake (`field`). `as` lo fija el backend al guardar (tipo de la dependencia destino).
+ */
 export type RewardInputRef = {
     const: DynamicFormValue;
 } | {
     input: string;
+} | {
+    field: string;
+    fallback?: DynamicFormValue;
+    as?: InputFieldTypeEnum;
 };

package/bin/rewardsEligibility/validators/IsRewardInputs.d.ts

@@ -0,0 +1,7 @@
+import { ValidationArguments, ValidatorConstraintInterface } from 'class-validator';
+import { JsonValue } from '../../common/types/JsonValue';
+/** Valida `itemKey → inputKey → DynamicFormValue` (dos niveles exactos). */
+export declare class IsRewardInputs implements ValidatorConstraintInterface {
+    validate(value: JsonValue, _args: ValidationArguments): boolean;
+    defaultMessage(_args: ValidationArguments): string;
+}

package/bin/rewardsEligibility/validators/IsRewardInputs.js

@@ -0,0 +1,26 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsRewardInputs = void 0;
+const class_validator_1 = require("class-validator");
+const isDynamicFormValue_1 = require("../../dynamicForm/helpers/isDynamicFormValue");
+/** Valida `itemKey → inputKey → DynamicFormValue` (dos niveles exactos). */
+let IsRewardInputs = class IsRewardInputs {
+    validate(value, _args) {
+        if (!(0, isDynamicFormValue_1.isPlainObject)(value))
+            return false;
+        return Object.values(value).every((inner) => (0, isDynamicFormValue_1.isPlainObject)(inner) && Object.values(inner).every(isDynamicFormValue_1.isDynamicFormValue));
+    }
+    defaultMessage(_args) {
+        return 'rewardInputs debe ser un mapa itemKey → inputKey → string | number | boolean | {from, to}';
+    }
+};
+exports.IsRewardInputs = IsRewardInputs;
+exports.IsRewardInputs = IsRewardInputs = __decorate([
+    (0, class_validator_1.ValidatorConstraint)({ name: 'IsRewardInputs', async: false })
+], IsRewardInputs);

package/bin/rules/constants/RulesLimits.d.ts

@@ -6,3 +6,9 @@ export declare const RULES_INPUT_SOURCE = "input";
 export declare const RULES_MAX_INPUT_CONTRACT = 30;
 /** Largo máximo (caracteres) del contenido de un turno del chat de `POST /generate`. */
 export declare const RULES_CHAT_TURN_MAX_LENGTH = 4000;
+/** Máximo de sujetos por query asíncrona de evaluación DATALAKE (`POST /evaluate/executions`). */
+export declare const RULES_MAX_SUBJECTS_PER_DATALAKE_CALL = 1000;
+/** Máximo de `returnFields` por llamada. */
+export declare const RULES_MAX_RETURN_FIELDS = 20;
+/** Id de campo devuelto: `fuente:campo` (campo del catálogo) o `tabla.ruta.hoja` (hoja del esquema aplanado de Glue). */
+export declare const RETURN_FIELD_ID_PATTERN: RegExp;

package/bin/rules/constants/RulesLimits.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RULES_CHAT_TURN_MAX_LENGTH = exports.RULES_MAX_INPUT_CONTRACT = exports.RULES_INPUT_SOURCE = exports.RULES_MAX_SUBJECTS_PER_CALL = void 0;
+exports.RETURN_FIELD_ID_PATTERN = exports.RULES_MAX_RETURN_FIELDS = exports.RULES_MAX_SUBJECTS_PER_DATALAKE_CALL = exports.RULES_CHAT_TURN_MAX_LENGTH = exports.RULES_MAX_INPUT_CONTRACT = exports.RULES_INPUT_SOURCE = exports.RULES_MAX_SUBJECTS_PER_CALL = void 0;
 /** Máximo de sujetos por llamada a `POST /evaluate` (si no, 400 `TOO_MANY_SUBJECTS`). */
 exports.RULES_MAX_SUBJECTS_PER_CALL = 100;
 /** Fuente especial: datos que el llamador manda en la llamada, no se resuelven ni se piden en `items`. */
@@ -9,3 +9,9 @@ exports.RULES_INPUT_SOURCE = 'input';
 exports.RULES_MAX_INPUT_CONTRACT = 30;
 /** Largo máximo (caracteres) del contenido de un turno del chat de `POST /generate`. */
 exports.RULES_CHAT_TURN_MAX_LENGTH = 4000;
+/** Máximo de sujetos por query asíncrona de evaluación DATALAKE (`POST /evaluate/executions`). */
+exports.RULES_MAX_SUBJECTS_PER_DATALAKE_CALL = 1000;
+/** Máximo de `returnFields` por llamada. */
+exports.RULES_MAX_RETURN_FIELDS = 20;
+/** Id de campo devuelto: `fuente:campo` (campo del catálogo) o `tabla.ruta.hoja` (hoja del esquema aplanado de Glue). */
+exports.RETURN_FIELD_ID_PATTERN = /^(?:[a-z][a-z0-9-]*:[A-Za-z][A-Za-z0-9_]*|[a-z_][a-z0-9_]*(?:\.[a-z_][a-z0-9_]*){1,8})$/;

package/bin/rules/dtos/EvaluateRulesRequest.d.ts

@@ -1,5 +1,7 @@
 import { JsonValue } from '../../common';
+import { InputField } from '../../dynamicForm/dtos/InputField';
 import { DynamicFormValue } from '../../dynamicForm/types/DynamicFormValue';
+import { EvaluationStrategyEnum } from '../enums/EvaluationStrategyEnum';
 /** A quién se le evalúa la regla. */
 export declare class RulesEvaluationSubject {
     directoryId: string;
@@ -27,4 +29,10 @@ export declare class EvaluateRulesRequest {
     subjects: RulesEvaluationSubject[];
     /** Fecha ISO 8601; por defecto, el momento de la llamada. */
     referenceAt?: string;
+    /** Estrategia de evaluación; ausente = `LIVE`. */
+    evaluationStrategy?: EvaluationStrategyEnum;
+    /** Campos a devolver por sujeto (`fuente:campo` o `tabla.ruta.hoja`); máx. 20. Se leen del datalake. */
+    returnFields?: string[];
+    /** Contrato de la fuente `input` (tipos de las columnas `i_<llave>` en DATALAKE). */
+    inputContract?: InputField[];
 }

package/bin/rules/dtos/EvaluateRulesRequest.js

@@ -12,6 +12,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EvaluateRulesRequest = exports.RuleToEvaluate = exports.RulesEvaluationSubject = void 0;
 const class_transformer_1 = require("class-transformer");
 const class_validator_1 = require("class-validator");
+const RulesLimits_1 = require("../constants/RulesLimits");
+const EvaluationStrategyEnum_1 = require("../enums/EvaluationStrategyEnum");
 /** A quién se le evalúa la regla. */
 class RulesEvaluationSubject {
 }
@@ -82,3 +84,25 @@ __decorate([
     (0, class_validator_1.IsISO8601)(),
     __metadata("design:type", String)
 ], EvaluateRulesRequest.prototype, "referenceAt", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsEnum)(EvaluationStrategyEnum_1.EvaluationStrategyEnum),
+    __metadata("design:type", String)
+], EvaluateRulesRequest.prototype, "evaluationStrategy", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsArray)(),
+    (0, class_validator_1.ArrayMaxSize)(RulesLimits_1.RULES_MAX_RETURN_FIELDS),
+    (0, class_validator_1.Matches)(RulesLimits_1.RETURN_FIELD_ID_PATTERN, { each: true }),
+    __metadata("design:type", Array)
+], EvaluateRulesRequest.prototype, "returnFields", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsArray)(),
+    (0, class_validator_1.ArrayMaxSize)(RulesLimits_1.RULES_MAX_INPUT_CONTRACT),
+    (0, class_validator_1.IsObject)({ each: true }),
+    __metadata("design:type", Array)
+], EvaluateRulesRequest.prototype, "inputContract", void 0);

package/bin/rules/dtos/EvaluateRulesResponse.d.ts

@@ -1,3 +1,4 @@
+import { JsonValue } from '../../common';
 import { RulesOutcomeEnum } from '../enums/RulesOutcomeEnum';
 import { RulesTraceResponse } from './RulesTraceResponse';
 /** Resultado de una regla para un sujeto. */
@@ -10,6 +11,8 @@ export declare class RuleEvaluationResult {
     trace?: RulesTraceResponse;
     /** Solo si `outcome` es `ERROR`. */
     errorMessage?: string;
+    /** Campos devueltos pedidos en `returnFields`: clave = id del campo; `null` = sin dato. */
+    returned?: Record<string, JsonValue>;
 }
 /** `POST /evaluate`: ordenado por regla y, dentro de cada regla, por `subjectIndex`. */
 export declare class EvaluateRulesResponse {

package/bin/rules/dtos/ValidateRulesRequest.d.ts

@@ -1,5 +1,6 @@
 import { JsonValue } from '../../common';
 import { InputField } from '../../dynamicForm/dtos/InputField';
+import { EvaluationStrategyEnum } from '../enums/EvaluationStrategyEnum';
 /** `POST /validate`: valida una regla guardada contra el catálogo de los ítems indicados y el contrato de `input`. */
 export declare class ValidateRulesRequest {
     /** Quién llama (solo logs y métricas). */
@@ -12,4 +13,8 @@ export declare class ValidateRulesRequest {
     };
     /** Contrato de la fuente `input` (`InputField[]`, dominio `dynamicForm`). */
     inputContract?: InputField[];
+    /** Estrategia contra la que se valida; ausente = `LIVE`. */
+    evaluationStrategy?: EvaluationStrategyEnum;
+    /** Campos devueltos a validar (`fuente:campo` o `tabla.ruta.hoja`); máx. 20. */
+    returnFields?: string[];
 }

package/bin/rules/dtos/ValidateRulesRequest.js

@@ -13,6 +13,7 @@ exports.ValidateRulesRequest = void 0;
 const class_transformer_1 = require("class-transformer");
 const class_validator_1 = require("class-validator");
 const RulesLimits_1 = require("../constants/RulesLimits");
+const EvaluationStrategyEnum_1 = require("../enums/EvaluationStrategyEnum");
 /** `POST /validate`: valida una regla guardada contra el catálogo de los ítems indicados y el contrato de `input`. */
 class ValidateRulesRequest {
 }
@@ -42,3 +43,17 @@ __decorate([
     (0, class_validator_1.IsObject)({ each: true }),
     __metadata("design:type", Array)
 ], ValidateRulesRequest.prototype, "inputContract", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsEnum)(EvaluationStrategyEnum_1.EvaluationStrategyEnum),
+    __metadata("design:type", String)
+], ValidateRulesRequest.prototype, "evaluationStrategy", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsArray)(),
+    (0, class_validator_1.ArrayMaxSize)(RulesLimits_1.RULES_MAX_RETURN_FIELDS),
+    (0, class_validator_1.Matches)(RulesLimits_1.RETURN_FIELD_ID_PATTERN, { each: true }),
+    __metadata("design:type", Array)
+], ValidateRulesRequest.prototype, "returnFields", void 0);