@gadmin2n/schematics 0.0.144 → 0.0.146

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflow/workflow-data-edge.util.ts

@@ -2,30 +2,37 @@ interface DependencyDsl {
   nodes: Array<{
     id: string;
     type?: string;
-    config?: {
-      subjects?: Array<{
-        source?: string;
-        provider?: string;
-        inputKey?: string;
-      }>;
-    };
+    config?: Record<string, unknown>;
   }>;
   edges: Array<{
     id?: string;
     pairId?: string;
-    kind?: 'FLOW' | 'DATA' | 'CALL' | 'RETURN';
+    kind?: 'FLOW' | 'CALL' | 'RETURN';
     source: string;
     target: string;
     sourceHandle?: string;
     targetHandle?: string;
     sourcePath?: string;
+    valueType?: string;
   }>;
 }
 
 export function validateWorkflowDataEdges(dsl: DependencyDsl): void {
+  if (dsl.edges.some((edge) => edge.pairId && edge.kind === undefined))
+    throw new Error(
+      'An edge with pairId must explicitly declare kind FLOW, CALL, or RETURN',
+    );
   const nodes = new Map(dsl.nodes.map((node) => [node.id, node]));
   const calls = dsl.edges.filter((edge) => edge.kind === 'CALL');
   const returns = dsl.edges.filter((edge) => edge.kind === 'RETURN');
+  const pairedFlows = dsl.edges.filter(
+    (edge) => edge.kind === 'FLOW' && edge.pairId,
+  );
+
+  for (const flow of pairedFlows) {
+    if (calls.filter((call) => call.pairId === flow.pairId).length !== 1)
+      throw new Error('Paired FLOW edge must belong to exactly one CALL edge');
+  }
 
   for (const node of dsl.nodes) {
     if (
@@ -39,111 +46,384 @@ export function validateWorkflowDataEdges(dsl: DependencyDsl): void {
 
   for (const call of calls) {
     if (!call.pairId) throw new Error('CALL edge must have a pairId');
-    if (!call.sourceHandle?.startsWith('lookup:'))
-      throw new Error('CALL edge must start from an AP lookup OUT port');
-    if (call.targetHandle !== 'request-in')
-      throw new Error('CALL edge must target HTTP Request Request IN');
-
-    const apNode = nodes.get(call.source);
-    const httpNode = nodes.get(call.target);
-    const inputKey = call.sourceHandle.slice('lookup:'.length);
-    const subject = apNode?.config?.subjects?.find(
-      (item) => item.source === 'DYNAMIC' && item.inputKey === inputKey,
-    );
-    if (!subject)
+    const sourceNode = nodes.get(call.source);
+    if (sourceNode?.type === 'for_each')
+      validateForEachCall(dsl, call, returns, nodes);
+    else if (sourceNode?.type === 'parallel')
+      validateParallelCall(dsl, call, returns, nodes, sourceNode);
+    else
       throw new Error(
-        `CALL edge targets unknown AP lookup "${inputKey}" on node "${call.source}"`,
+        'CALL edge can only start from a For Each or Parallel node',
       );
-    if (httpNode?.type !== 'http_request')
-      throw new Error('AP lookup can only call an HTTP Request node');
+  }
 
-    const pairedReturns = returns.filter((edge) => edge.pairId === call.pairId);
-    if (pairedReturns.length !== 1)
-      throw new Error(`CALL pair "${call.pairId}" must have one RETURN edge`);
-    const result = pairedReturns[0];
+  for (const result of returns) {
     if (
-      result.target !== call.source ||
-      result.targetHandle !== `approver:${inputKey}`
+      !result.pairId ||
+      calls.filter((call) => call.pairId === result.pairId).length !== 1
     )
-      throw new Error(
-        `RETURN edge for "${inputKey}" must target its AP approver IN port`,
-      );
+      throw new Error('RETURN edge must belong to exactly one CALL edge');
+  }
 
-    const reachable = reachableCallNodes(dsl, call.target, call.pairId);
-    if (!reachable.has(result.source))
+  validateForEachConnections(dsl, calls);
+  validateParallelConnections(dsl, calls);
+  validatePairOwnership(dsl, calls, returns);
+}
+
+function validatePairOwnership(
+  dsl: DependencyDsl,
+  calls: DependencyDsl['edges'],
+  returns: DependencyDsl['edges'],
+): void {
+  const owners = new Map<string, Set<string>>();
+  for (const call of calls) {
+    if (!call.pairId) continue;
+    const bodyIds = new Set<string>([call.target]);
+    for (const edge of dsl.edges) {
+      if (edge.kind === 'FLOW' && edge.pairId === call.pairId) {
+        bodyIds.add(edge.source);
+        bodyIds.add(edge.target);
+      }
+    }
+    for (const edge of returns) {
+      if (edge.pairId === call.pairId) bodyIds.add(edge.source);
+    }
+    for (const nodeId of bodyIds) {
+      const pairIds = owners.get(nodeId) ?? new Set<string>();
+      pairIds.add(call.pairId);
+      owners.set(nodeId, pairIds);
+    }
+  }
+  for (const [nodeId, pairIds] of owners) {
+    if (pairIds.size > 1)
       throw new Error(
-        `RETURN edge for "${inputKey}" must return from the CALL chain`,
+        `Node "${nodeId}" cannot belong to more than one CALL pipeline`,
       );
-    const resultNode = nodes.get(result.source);
-    const expectedHandle =
-      resultNode?.type === 'http_request'
-        ? 'response-out'
-        : resultNode?.type === 'code'
-        ? 'result-out'
-        : undefined;
-    if (expectedHandle && result.sourceHandle !== expectedHandle)
+  }
+}
+
+const FOR_EACH_BODY_NODE_TYPES = new Set([
+  'http_request',
+  'code',
+  'db_execute',
+  'sub_workflow',
+]);
+const PARALLEL_BODY_NODE_TYPES = new Set([
+  ...FOR_EACH_BODY_NODE_TYPES,
+  'delay',
+  'if_else',
+  'switch',
+  'approval',
+  'human_approval',
+  'external_wait',
+]);
+
+function validateForEachCall(
+  dsl: DependencyDsl,
+  call: DependencyDsl['edges'][number],
+  returns: DependencyDsl['edges'],
+  nodes: Map<string, DependencyDsl['nodes'][number]>,
+): void {
+  if (call.sourceHandle !== 'start')
+    throw new Error('For Each CALL must start from START');
+  const result = requireSingleReturn(call, returns);
+  if (result.target !== call.source || result.targetHandle !== 'end')
+    throw new Error('For Each RETURN must target END');
+  if (result.valueType !== 'JSON')
+    throw new Error('For Each RETURN must use valueType JSON');
+  validatePipelineBoundaryHandles(call, result, nodes, 'For Each');
+
+  const pairFlows = dsl.edges.filter(
+    (edge) => edge.kind === 'FLOW' && edge.pairId === call.pairId,
+  );
+  const bodyNodeIds = linearPairBody(
+    call.target,
+    result.source,
+    pairFlows,
+    'For Each body',
+  );
+  for (const nodeId of bodyNodeIds) {
+    const nodeType = nodes.get(nodeId)?.type;
+    if (!nodeType || !FOR_EACH_BODY_NODE_TYPES.has(nodeType))
+      throw new Error(`Node "${nodeId}" cannot be used in a For Each body`);
+    const usedByMainFlow = dsl.edges.some(
+      (edge) =>
+        edge.kind === 'FLOW' &&
+        !edge.pairId &&
+        (edge.source === nodeId || edge.target === nodeId),
+    );
+    if (usedByMainFlow)
       throw new Error(
-        `RETURN edge for "${inputKey}" must use ${expectedHandle}`,
+        `For Each body node "${nodeId}" cannot also belong to the main flow`,
       );
   }
+}
 
-  for (const result of returns) {
+function validateParallelCall(
+  dsl: DependencyDsl,
+  call: DependencyDsl['edges'][number],
+  returns: DependencyDsl['edges'],
+  nodes: Map<string, DependencyDsl['nodes'][number]>,
+  owner: DependencyDsl['nodes'][number],
+): void {
+  const branches = parallelBranches(owner);
+  const branch = branches.find(
+    (item) => `${item.id}-start` === call.sourceHandle,
+  );
+  if (!branch)
+    throw new Error('Parallel CALL must start from a configured START port');
+  const branchReturns = returns.filter((edge) => edge.pairId === call.pairId);
+  if (branchReturns.length === 0)
+    throw new Error('Parallel branch must return every exit to END');
+  for (const result of branchReturns) {
     if (
-      !result.pairId ||
-      calls.filter((call) => call.pairId === result.pairId).length !== 1
+      result.target !== call.source ||
+      result.targetHandle !== `${branch.id}-end`
     )
-      throw new Error('RETURN edge must belong to exactly one CALL edge');
+      throw new Error('Parallel RETURN must target the matching END port');
+    if (result.valueType !== 'JSON')
+      throw new Error('Parallel RETURN must use valueType JSON');
+    validatePipelineBoundaryHandles(call, result, nodes, 'Parallel');
   }
 
-  validateRequiredApprovalInputs(dsl, calls);
+  const pairFlows = dsl.edges.filter(
+    (edge) => edge.kind === 'FLOW' && edge.pairId === call.pairId,
+  );
+  const bodyNodeIds = branchedPairBody(call, pairFlows, branchReturns, nodes);
+  validatePipelineBodyNodes(dsl, bodyNodeIds, nodes, 'Parallel branch');
 }
 
-function reachableCallNodes(
-  dsl: DependencyDsl,
-  firstNodeId: string,
-  pairId: string,
+function validatePipelineBoundaryHandles(
+  call: DependencyDsl['edges'][number],
+  result: DependencyDsl['edges'][number],
+  nodes: Map<string, DependencyDsl['nodes'][number]>,
+  label: string,
+): void {
+  const callTargetHandle = namedInputHandle(nodes.get(call.target)?.type);
+  if ((call.targetHandle ?? '') !== (callTargetHandle ?? ''))
+    throw new Error(
+      callTargetHandle
+        ? `${label} CALL target must use ${callTargetHandle}`
+        : `${label} CALL target must not use a named handle`,
+    );
+
+  const returnSourceHandles = namedOutputHandles(nodes.get(result.source));
+  if (returnSourceHandles.length === 0 && (result.sourceHandle ?? '') !== '')
+    throw new Error(`${label} RETURN source must not use a named handle`);
+  if (
+    returnSourceHandles.length > 0 &&
+    !returnSourceHandles.includes(result.sourceHandle ?? '')
+  )
+    throw new Error(
+      `${label} RETURN source must use one of ${returnSourceHandles.join(
+        ', ',
+      )}`,
+    );
+}
+
+function namedInputHandle(nodeType?: string): string | undefined {
+  if (nodeType === 'http_request') return 'request-in';
+  if (nodeType === 'code') return 'data-in';
+  return undefined;
+}
+
+function namedOutputHandles(
+  node: DependencyDsl['nodes'][number] | undefined,
+): string[] {
+  if (node?.type === 'http_request') return ['response-out'];
+  if (node?.type === 'code') return ['result-out'];
+  if (['if_else', 'approval', 'human_approval'].includes(node?.type ?? ''))
+    return ['true', 'false'];
+  if (node?.type === 'external_wait') return ['RECEIVED', 'TIMEOUT'];
+  if (node?.type === 'switch') {
+    const cases = Array.isArray(node.config?.cases) ? node.config.cases : [];
+    return [
+      ...cases
+        .map((item) =>
+          item && typeof item === 'object' ? (item as any).id : undefined,
+        )
+        .filter((id): id is string => typeof id === 'string' && id.length > 0),
+      'default',
+    ];
+  }
+  return [];
+}
+
+function branchedPairBody(
+  call: DependencyDsl['edges'][number],
+  flows: DependencyDsl['edges'],
+  returns: DependencyDsl['edges'],
+  nodes: Map<string, DependencyDsl['nodes'][number]>,
 ): Set<string> {
-  const reachable = new Set([firstNodeId]);
+  const body = new Set([call.target]);
   let changed = true;
   while (changed) {
     changed = false;
-    for (const edge of dsl.edges) {
-      if (
-        (edge.kind ?? 'FLOW') !== 'FLOW' ||
-        edge.pairId !== pairId ||
-        !reachable.has(edge.source) ||
-        reachable.has(edge.target)
-      )
-        continue;
-      reachable.add(edge.target);
+    for (const edge of flows) {
+      if (!body.has(edge.source) || body.has(edge.target)) continue;
+      body.add(edge.target);
       changed = true;
     }
   }
-  return reachable;
+  if (
+    flows.some((edge) => !body.has(edge.source) || !body.has(edge.target)) ||
+    returns.some((edge) => !body.has(edge.source))
+  )
+    throw new Error('Parallel branch contains a disconnected edge');
+
+  for (const nodeId of body) {
+    const incoming = flows.filter((edge) => edge.target === nodeId);
+    if (
+      (nodeId === call.target && incoming.length > 0) ||
+      (nodeId !== call.target && incoming.length !== 1)
+    )
+      throw new Error('Parallel branch cannot merge paths');
+
+    const outputHandles = namedOutputHandles(nodes.get(nodeId));
+    const outgoing = [
+      ...flows.filter((edge) => edge.source === nodeId),
+      ...returns.filter((edge) => edge.source === nodeId),
+    ];
+    if (outputHandles.length <= 1) {
+      if (outgoing.length !== 1)
+        throw new Error(
+          `Parallel branch node "${nodeId}" must connect to one next node or END`,
+        );
+      continue;
+    }
+    for (const handle of outputHandles) {
+      if (outgoing.filter((edge) => edge.sourceHandle === handle).length !== 1)
+        throw new Error(
+          `Parallel branch node "${nodeId}" must connect every output to a next node or END`,
+        );
+    }
+    if (outgoing.length !== outputHandles.length)
+      throw new Error(
+        `Parallel branch node "${nodeId}" has a duplicate or invalid output`,
+      );
+  }
+  return body;
+}
+
+function linearPairBody(
+  firstNodeId: string,
+  returnNodeId: string,
+  pairFlows: DependencyDsl['edges'],
+  label: string,
+): Set<string> {
+  const bodyNodeIds = new Set<string>([firstNodeId]);
+  let current = firstNodeId;
+  while (current !== returnNodeId) {
+    const next = pairFlows.filter((edge) => edge.source === current);
+    if (next.length !== 1) throw new Error(`${label} must be one linear chain`);
+    current = next[0].target;
+    if (bodyNodeIds.has(current))
+      throw new Error(`${label} must not contain a cycle`);
+    bodyNodeIds.add(current);
+  }
+  if (pairFlows.some((edge) => edge.source === returnNodeId))
+    throw new Error(`${label} must end at its RETURN edge`);
+  if (pairFlows.length !== bodyNodeIds.size - 1)
+    throw new Error(`${label} must be one linear chain`);
+  if (
+    pairFlows.some(
+      (edge) => !bodyNodeIds.has(edge.source) || !bodyNodeIds.has(edge.target),
+    )
+  )
+    throw new Error(`${label} contains a disconnected FLOW edge`);
+  if (pairFlows.some((edge) => edge.target === firstNodeId))
+    throw new Error(`${label} first node cannot have a pair predecessor`);
+  return bodyNodeIds;
+}
+
+function requireSingleReturn(
+  call: DependencyDsl['edges'][number],
+  returns: DependencyDsl['edges'],
+): DependencyDsl['edges'][number] {
+  const pairedReturns = returns.filter((edge) => edge.pairId === call.pairId);
+  if (pairedReturns.length !== 1)
+    throw new Error(`CALL pair "${call.pairId}" must have one RETURN edge`);
+  return pairedReturns[0];
 }
 
-function validateRequiredApprovalInputs(
+function validateForEachConnections(
   dsl: DependencyDsl,
   calls: DependencyDsl['edges'],
 ): void {
   for (const node of dsl.nodes) {
-    for (const subject of node.config?.subjects ?? []) {
-      if (subject.source !== 'DYNAMIC' || !subject.inputKey) continue;
-      const callCount = calls.filter(
-        (edge) =>
-          edge.source === node.id &&
-          edge.sourceHandle === `lookup:${subject.inputKey}`,
-      ).length;
-      const legacyCount = dsl.edges.filter(
-        (edge) =>
-          edge.kind === 'DATA' &&
-          edge.target === node.id &&
-          edge.targetHandle === subject.inputKey,
-      ).length;
-      if (callCount + legacyCount !== 1)
+    if (node.type !== 'for_each') continue;
+    const ownedCalls = calls.filter((call) => call.source === node.id);
+    if (ownedCalls.length !== 1)
+      throw new Error(
+        `For Each "${node.id}" must have one item processing connection`,
+      );
+  }
+}
+
+function validateParallelConnections(
+  dsl: DependencyDsl,
+  calls: DependencyDsl['edges'],
+): void {
+  for (const node of dsl.nodes) {
+    if (node.type !== 'parallel') continue;
+    const branches = parallelBranches(node);
+    if (branches.length < 2)
+      throw new Error(
+        `Parallel "${node.id}" must configure at least two branches`,
+      );
+    const ownedCalls = calls.filter((call) => call.source === node.id);
+    if (ownedCalls.length !== branches.length)
+      throw new Error(
+        `Parallel "${node.id}" must have one complete START / END pipeline per branch`,
+      );
+    for (const branch of branches) {
+      if (
+        ownedCalls.filter((call) => call.sourceHandle === `${branch.id}-start`)
+          .length !== 1
+      )
         throw new Error(
-          `Dynamic input "${subject.inputKey}" on node "${node.id}" must have exactly one lookup connection`,
+          `Parallel "${node.id}" branch "${branch.label}" must have one START pipeline`,
         );
     }
   }
 }
+
+function parallelBranches(
+  node: DependencyDsl['nodes'][number],
+): Array<{ id: string; label: string }> {
+  const branches = node.config?.branches;
+  return (Array.isArray(branches) ? branches : []).filter(
+    (item): item is { id: string; label: string } =>
+      Boolean(
+        item &&
+          typeof item === 'object' &&
+          typeof item.id === 'string' &&
+          item.id.length > 0 &&
+          typeof item.label === 'string' &&
+          item.label.length > 0,
+      ),
+  );
+}
+
+function validatePipelineBodyNodes(
+  dsl: DependencyDsl,
+  bodyNodeIds: Set<string>,
+  nodes: Map<string, DependencyDsl['nodes'][number]>,
+  label: string,
+): void {
+  for (const nodeId of bodyNodeIds) {
+    const nodeType = nodes.get(nodeId)?.type;
+    if (!nodeType || !PARALLEL_BODY_NODE_TYPES.has(nodeType))
+      throw new Error(`Node "${nodeId}" cannot be used in a ${label} body`);
+    const usedByMainFlow = dsl.edges.some(
+      (edge) =>
+        edge.kind === 'FLOW' &&
+        !edge.pairId &&
+        (edge.source === nodeId || edge.target === nodeId),
+    );
+    if (usedByMainFlow)
+      throw new Error(
+        `${label} body node "${nodeId}" cannot also belong to the main flow`,
+      );
+  }
+}