@flowuent-org/diagramming-core 1.4.1 → 1.4.3

package/packages/diagrams/src/lib/utils/validateAutomationLoopNode.ts

@@ -0,0 +1,104 @@
+import { Edge, Node } from '@xyflow/react';
+import { AutomationLoopNodeForm } from '../types/automation-node-data-types';
+
+export interface LoopNodeValidationResult {
+  valid: boolean;
+  errors: string[];
+}
+
+function getFormData(node: Node): Partial<AutomationLoopNodeForm> {
+  return (node.data?.formData ?? node.data ?? {}) as Partial<AutomationLoopNodeForm>;
+}
+
+function getOutgoingEdges(nodeId: string, edges: Edge[], sourceHandle?: string): Edge[] {
+  return edges.filter(
+    (edge) =>
+      edge.source === nodeId &&
+      (sourceHandle === undefined || edge.sourceHandle === sourceHandle),
+  );
+}
+
+function getReachableBodyNodeIds(
+  startNodeId: string,
+  loopNodeId: string,
+  edges: Edge[],
+): Set<string> {
+  const reachable = new Set<string>();
+  const queue = [startNodeId];
+
+  while (queue.length > 0) {
+    const currentId = queue.shift()!;
+    if (currentId === loopNodeId || reachable.has(currentId)) {
+      continue;
+    }
+    reachable.add(currentId);
+
+    const outgoing = edges.filter((edge) => edge.source === currentId);
+    for (const edge of outgoing) {
+      if (edge.target !== loopNodeId && !reachable.has(edge.target)) {
+        queue.push(edge.target);
+      }
+    }
+  }
+
+  return reachable;
+}
+
+export function validateAutomationLoopNode(
+  node: Node,
+  edges: Edge[],
+): LoopNodeValidationResult {
+  const errors: string[] = [];
+  const formData = getFormData(node);
+  const nodeId = node.id;
+
+  if (!formData.arraySource?.type) {
+    errors.push('Array data source is not configured');
+  } else if (
+    formData.arraySource.type === 'variable' &&
+    !formData.arraySource.variableName?.trim()
+  ) {
+    errors.push('Variable name is required when array source type is "variable"');
+  }
+
+  const loopEdges = getOutgoingEdges(nodeId, edges, 'loop');
+  const doneEdges = getOutgoingEdges(nodeId, edges, 'done');
+
+  if (loopEdges.length === 0) {
+    errors.push('Loop node must have exactly one outgoing edge on the "loop" handle');
+  } else if (loopEdges.length > 1) {
+    errors.push('Loop node must have only one outgoing edge on the "loop" handle');
+  }
+
+  if (doneEdges.length === 0) {
+    errors.push('Loop node must have exactly one outgoing edge on the "done" handle');
+  } else if (doneEdges.length > 1) {
+    errors.push('Loop node must have only one outgoing edge on the "done" handle');
+  }
+
+  if (loopEdges.length === 1) {
+    const bodyStartId = loopEdges[0].target;
+    const bodyNodeIds = getReachableBodyNodeIds(bodyStartId, nodeId, edges);
+    const hasBackEdge = edges.some(
+      (edge) => edge.target === nodeId && bodyNodeIds.has(edge.source),
+    );
+
+    if (!hasBackEdge) {
+      errors.push(
+        'Loop body must connect back to the Loop node to advance iterations',
+      );
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+  };
+}
+
+export function assertAutomationLoopNodeValid(node: Node, edges: Edge[]): void {
+  const result = validateAutomationLoopNode(node, edges);
+  if (!result.valid) {
+    throw new Error(result.errors.join('; '));
+  }
+}