@fiado/type-kit 3.595.0 → 3.597.0

package/src/rules/dtos/ValidateRulesResponse.ts

@@ -1,6 +1,31 @@
+import { RulesNodeErrorCodeEnum } from '../enums/RulesNodeErrorCodeEnum';
+import { RulesValueTypeEnum } from '../enums/RulesValueTypeEnum';
+
+/** Error de validación de un nodo del árbol de la regla (bloque de relación o condición). */
+export class RulesNodeValidationErrorResponse {
+    /** Ruta del nodo dentro de la regla (para pintar el error en el editor). */
+    path: string;
+    code: RulesNodeErrorCodeEnum;
+    message: string;
+}
+
+/** Campo devuelto que expone un bloque de relación con `exposeAs`. */
+export class RulesExposedFieldResponse {
+    /** `relación:exposeAs` (ver `relationReturnFieldId`); cumple `RETURN_FIELD_ID_PATTERN`. */
+    id: string;
+    relation: string;
+    exposeAs: string;
+    /** Siempre `NUMBER` (conteo de relacionados). */
+    valueType: RulesValueTypeEnum;
+}
+
 /** Resultado de `POST /validate`. */
 export class ValidateRulesResponse {
     valid: boolean;
     /** Mensajes de `validateRule`, tal cual (vacío si `valid`). */
     errors: string[];
+    /** Errores por nodo de relación (vacío si no hay). */
+    nodeErrors: RulesNodeValidationErrorResponse[];
+    /** Campos que la regla puede devolver vía `exposeAs` (vacío si no hay). */
+    exposedFields: RulesExposedFieldResponse[];
 }

package/src/rules/dtos/population/SegmentGroup.ts

@@ -4,8 +4,9 @@ import { SegmentConditionKindEnum } from '../../enums/SegmentConditionKindEnum';
 import { SegmentMatchEnum } from '../../enums/SegmentMatchEnum';
 import { SegmentAggregateCondition } from './SegmentAggregateCondition';
 import { SegmentColumnCondition } from './SegmentColumnCondition';
+import { SegmentRelationCondition } from './SegmentRelationCondition';
 
-export type SegmentCondition = SegmentColumnCondition | SegmentAggregateCondition;
+export type SegmentCondition = SegmentColumnCondition | SegmentAggregateCondition | SegmentRelationCondition;
 
 export class SegmentGroup {
     @Expose() @IsEnum(SegmentMatchEnum) match: SegmentMatchEnum;
@@ -20,6 +21,7 @@ export class SegmentGroup {
             subTypes: [
                 { value: SegmentColumnCondition, name: SegmentConditionKindEnum.COLUMN },
                 { value: SegmentAggregateCondition, name: SegmentConditionKindEnum.AGGREGATE },
+                { value: SegmentRelationCondition, name: SegmentConditionKindEnum.RELATION },
             ],
         },
     })

package/src/rules/dtos/population/SegmentRelationCondition.ts

@@ -0,0 +1,25 @@
+import { Expose, Type } from 'class-transformer';
+import { ArrayMaxSize, Equals, IsArray, IsEnum, IsNumber, IsOptional, Matches, ValidateIf, ValidateNested } from 'class-validator';
+import { RULES_RELATION_NAME_PATTERN } from '../../constants/RulesRelationLimits';
+import { SegmentConditionKindEnum } from '../../enums/SegmentConditionKindEnum';
+import { SegmentOperatorEnum } from '../../enums/SegmentOperatorEnum';
+import { SegmentRelationQuantifierKindEnum } from '../../enums/SegmentRelationQuantifierKindEnum';
+import { SegmentColumnCondition } from './SegmentColumnCondition';
+
+/** Cuantificador de una relacion 1:N. COUNT exige `op` y `value`; ANY/ALL no los llevan. */
+export class SegmentRelationQuantifier {
+    @Expose() @IsEnum(SegmentRelationQuantifierKindEnum) kind: SegmentRelationQuantifierKindEnum;
+    @Expose() @ValidateIf((q: SegmentRelationQuantifier) => q.kind === SegmentRelationQuantifierKindEnum.COUNT || q.op !== undefined)
+    @IsEnum(SegmentOperatorEnum) op?: SegmentOperatorEnum;
+    @Expose() @ValidateIf((q: SegmentRelationQuantifier) => q.kind === SegmentRelationQuantifierKindEnum.COUNT || q.value !== undefined)
+    @IsNumber() value?: number;
+}
+
+/** (c) Condicion sobre los relacionados de la persona (referidor / referidos). `filters` se aplica a cada relacionado. */
+export class SegmentRelationCondition {
+    @Expose() @Equals(SegmentConditionKindEnum.RELATION) kind: SegmentConditionKindEnum.RELATION;
+    @Expose() @Matches(RULES_RELATION_NAME_PATTERN) relation: string;
+    /** MANY: obligatorio; ONE: ausente (lo valida el compilador, no el DTO). */
+    @Expose() @IsOptional() @ValidateNested() @Type(() => SegmentRelationQuantifier) quantifier?: SegmentRelationQuantifier;
+    @Expose() @IsArray() @ArrayMaxSize(10) @ValidateNested({ each: true }) @Type(() => SegmentColumnCondition) filters: SegmentColumnCondition[];
+}

package/src/rules/enums/RulesNodeErrorCodeEnum.ts

@@ -0,0 +1,21 @@
+/**
+ * Códigos de error de validación de nodos de relación en `POST /validate`.
+ * Mismos strings que `RelationIssueCode` de `@fiado/rules-engine`.
+ */
+export enum RulesNodeErrorCodeEnum {
+    UNKNOWN_RELATION = 'UNKNOWN_RELATION',
+    INVALID_RELATION_NODE = 'INVALID_RELATION_NODE',
+    QUANTIFIER_REQUIRED = 'QUANTIFIER_REQUIRED',
+    QUANTIFIER_NOT_ALLOWED = 'QUANTIFIER_NOT_ALLOWED',
+    INVALID_QUANTIFIER = 'INVALID_QUANTIFIER',
+    SUBJECT_IN_RELATION = 'SUBJECT_IN_RELATION',
+    EXPOSE_AS_NOT_ALLOWED = 'EXPOSE_AS_NOT_ALLOWED',
+    INVALID_EXPOSE_AS = 'INVALID_EXPOSE_AS',
+    DUPLICATE_EXPOSE_AS = 'DUPLICATE_EXPOSE_AS',
+    MAX_DEPTH_EXCEEDED = 'MAX_DEPTH_EXCEEDED',
+    MAX_BLOCKS_EXCEEDED = 'MAX_BLOCKS_EXCEEDED',
+    /** LIVE rechaza una sub-regla 1:N con fuentes que no consultan por lote. */
+    RELATION_SOURCE_NOT_BATCH_CAPABLE = 'RELATION_SOURCE_NOT_BATCH_CAPABLE',
+    /** Runtime: un sujeto excede `maxRelated`. */
+    MAX_RELATED_EXCEEDED = 'MAX_RELATED_EXCEEDED',
+}

package/src/rules/enums/RulesRelationCardinalityEnum.ts

@@ -0,0 +1,5 @@
+/** Cardinalidad de una relación del catálogo de reglas: un relacionado (1:1) o varios (1:N). */
+export enum RulesRelationCardinalityEnum {
+    ONE = 'ONE',
+    MANY = 'MANY',
+}

package/src/rules/enums/RulesRelationTargetEnum.ts

@@ -0,0 +1,5 @@
+/** A qué apunta una relación: otra persona (`PERSON`) o registros propios con campos (`RECORD`, ej. créditos). */
+export enum RulesRelationTargetEnum {
+    PERSON = 'PERSON',
+    RECORD = 'RECORD',
+}

package/src/rules/enums/SegmentConditionKindEnum.ts

@@ -1,4 +1,5 @@
 export enum SegmentConditionKindEnum {
     COLUMN = 'COLUMN',
     AGGREGATE = 'AGGREGATE',
+    RELATION = 'RELATION',
 }

package/src/rules/enums/SegmentRelationQuantifierKindEnum.ts

@@ -0,0 +1,5 @@
+export enum SegmentRelationQuantifierKindEnum {
+    ANY = 'ANY',
+    ALL = 'ALL',
+    COUNT = 'COUNT',
+}

package/src/rules/index.ts

@@ -4,9 +4,13 @@ export * from './enums/RulesGenerationStatusEnum';
 export * from './enums/RulesChatRoleEnum';
 export * from './enums/RulesValueTypeEnum';
 export * from './enums/RulesErrorCodeEnum';
+export * from './enums/RulesRelationCardinalityEnum';
+export * from './enums/RulesRelationTargetEnum';
+export * from './enums/RulesNodeErrorCodeEnum';
 
 //Constants
 export * from './constants/RulesLimits';
+export * from './constants/RulesRelationLimits';
 
 //DTOs
 export * from './dtos/RulesCatalogResponse';
@@ -23,6 +27,7 @@ export * from './dtos/EvaluateRulesResponse';
 export * from './enums/SegmentMatchEnum';
 export * from './enums/SegmentOutputEnum';
 export * from './enums/SegmentConditionKindEnum';
+export * from './enums/SegmentRelationQuantifierKindEnum';
 export * from './enums/SegmentAggregateFnEnum';
 export * from './enums/SegmentOperatorEnum';
 export * from './enums/SegmentParamTypeEnum';
@@ -31,6 +36,7 @@ export * from './constants/SegmentLimits';
 export * from './dtos/population/SegmentWindow';
 export * from './dtos/population/SegmentColumnCondition';
 export * from './dtos/population/SegmentAggregateCondition';
+export * from './dtos/population/SegmentRelationCondition';
 export * from './dtos/population/SegmentGroup';
 export * from './dtos/population/PopulationSegmentDefinition';
 export * from './dtos/population/SegmentParam';