next-workflow-builder 0.1.0

package/src/plugins/loop/components/loop-fields.tsx

@@ -0,0 +1,46 @@
+import { Label } from "../../../client/components/ui/label";
+import { TemplateBadgeInput } from "../../../client/components/ui/template-badge-input";
+
+// Loop fields component
+function LoopFields({
+  config,
+  onUpdateConfig,
+  disabled,
+}: {
+  config: Record<string, unknown>;
+  onUpdateConfig: (key: string, value: string) => void;
+  disabled: boolean;
+}) {
+  return (
+    <div className="space-y-4">
+      <div className="space-y-2">
+        <Label htmlFor="items">Items to Iterate</Label>
+        <TemplateBadgeInput
+          disabled={ disabled }
+          id="items"
+          onChange={ (value) => onUpdateConfig("items", value) }
+          placeholder="e.g., {{PreviousNode.rows}}, {{DatabaseQuery.results}}"
+          value={ (config?.items as string) || "" }
+        />
+        <p className="text-muted-foreground text-xs">
+          Reference an array from a previous node. Use @ to reference outputs.
+        </p>
+      </div>
+      <div className="space-y-2">
+        <Label htmlFor="batchSize">Batch Size (optional)</Label>
+        <TemplateBadgeInput
+          disabled={ disabled }
+          id="batchSize"
+          onChange={ (value) => onUpdateConfig("batchSize", value) }
+          placeholder="1"
+          value={ (config?.batchSize as string) || "" }
+        />
+        <p className="text-muted-foreground text-xs">
+          Number of items per batch. Default is 1 (process one item at a time).
+        </p>
+      </div>
+    </div>
+  );
+}
+
+export { LoopFields };

package/src/plugins/loop/icon.tsx

@@ -0,0 +1,21 @@
+export function LoopIcon({ className }: { className?: string }) {
+  return (
+    <svg
+      aria-label="Loop icon"
+      className={className}
+      fill="none"
+      stroke="currentColor"
+      strokeLinecap="round"
+      strokeLinejoin="round"
+      strokeWidth="2"
+      viewBox="0 0 24 24"
+      xmlns="http://www.w3.org/2000/svg"
+    >
+      <title>Loop</title>
+      <path d="M17 2l4 4-4 4" />
+      <path d="M3 11v-1a4 4 0 0 1 4-4h14" />
+      <path d="M7 22l-4-4 4-4" />
+      <path d="M21 13v1a4 4 0 0 1-4 4H3" />
+    </svg>
+  );
+}

package/src/plugins/loop/index.ts

@@ -0,0 +1,57 @@
+import type { IntegrationPlugin } from "../registry";
+import { LoopIcon } from "./icon";
+
+const loopPlugin: IntegrationPlugin = {
+  type: "loop",
+  label: "Loop",
+  description: "Iterate over arrays and process items in batches",
+  icon: LoopIcon,
+  isBuiltIn: true,
+
+  formFields: [],
+
+  actions: [
+    {
+      slug: "iterate",
+      label: "Loop",
+      description: "Split data into batches and iterate over each batch",
+      category: "System",
+      stepFunction: "loopStep",
+      stepImportPath: "iterate",
+      configFields: [
+        {
+          key: "items",
+          label: "Items to Iterate",
+          type: "template-input",
+          placeholder:
+            "e.g., {{PreviousNode.rows}}, {{DatabaseQuery.results}}",
+        },
+        {
+          key: "batchSize",
+          label: "Batch Size (optional)",
+          type: "template-input",
+          placeholder: "1",
+        },
+      ],
+      outputFields: [
+        { field: "currentItem", description: "Current item being processed" },
+        { field: "currentBatch", description: "Current batch of items" },
+        {
+          field: "currentIndex",
+          description: "Current item index (0-based)",
+        },
+        {
+          field: "currentBatchIndex",
+          description: "Current batch index (0-based)",
+        },
+        { field: "hasMore", description: "Whether more batches remain" },
+        { field: "totalItems", description: "Total number of items" },
+        { field: "totalBatches", description: "Total number of batches" },
+        { field: "items", description: "All items in the array" },
+        { field: "batchSize", description: "Number of items per batch" },
+      ],
+    },
+  ],
+};
+
+export default loopPlugin;

package/src/plugins/loop/steps/iterate.ts

@@ -0,0 +1,74 @@
+/**
+ * Executable step function for Loop action
+ * Iterates over an array and executes downstream nodes for each item/batch
+ * Similar to n8n's SplitInBatches node
+ */
+import "server-only";
+import { StepInput, withStepLogging } from "../../../lib/steps/step-handler";
+
+export type LoopInput = StepInput & {
+  /** The array to iterate over */
+  items: unknown[];
+  /** Number of items per batch (default: 1) */
+  batchSize?: number;
+  /** Current batch index (set by executor) */
+  currentBatchIndex?: number;
+  /** Original items expression for logging */
+  expression?: string;
+};
+
+export type LoopResult = {
+  /** Whether there are more batches to process */
+  hasMore: boolean;
+  /** Current batch index (0-based) */
+  currentBatchIndex: number;
+  /** Current batch of items being processed */
+  currentBatch: unknown[];
+  /** Current item (first item of batch, for single-item iterations) */
+  currentItem: unknown;
+  /** Current item index in the full array */
+  currentIndex: number;
+  /** Total number of items */
+  totalItems: number;
+  /** Total number of batches */
+  totalBatches: number;
+  /** All items in the array */
+  items: unknown[];
+  /** Batch size used */
+  batchSize: number;
+};
+
+function evaluateLoop(input: LoopInput): LoopResult {
+  const items = Array.isArray(input.items) ? input.items : [];
+  const batchSize = Math.max(1, input.batchSize || 1);
+  const currentBatchIndex = input.currentBatchIndex ?? 0;
+  const totalItems = items.length;
+  const totalBatches = Math.ceil(totalItems / batchSize);
+
+  // Calculate current batch
+  const startIndex = currentBatchIndex * batchSize;
+  const endIndex = Math.min(startIndex + batchSize, totalItems);
+  const currentBatch = items.slice(startIndex, endIndex);
+  const currentItem = currentBatch[0];
+  const hasMore = currentBatchIndex < totalBatches - 1;
+
+  return {
+    hasMore,
+    currentBatchIndex,
+    currentBatch,
+    currentItem,
+    currentIndex: startIndex,
+    totalItems,
+    totalBatches,
+    items,
+    batchSize,
+  };
+}
+
+// biome-ignore lint/suspicious/useAwait: workflow "use step" requires async
+export async function loopStep(input: LoopInput): Promise<LoopResult> {
+  "use step";
+  return withStepLogging(input, () => Promise.resolve(evaluateLoop(input)));
+}
+
+loopStep.maxRetries = 0;

package/src/plugins/loop/workflow-executor.patch

@@ -0,0 +1,241 @@
+--- a/lib/workflow-executor.workflow.ts
++++ b/lib/workflow-executor.workflow.ts
+@@ -248,6 +248,70 @@
+     });
+   }
+ 
++  // Special handling for Loop action - items are passed directly, iteration handled in executeNode
++  if (actionType === "Loop" || actionType === "loop/iterate") {
++    const stepImporter = getStepImporter("loop/iterate");
++    if (!stepImporter) {
++      return { success: false, error: "Loop step not found in plugin registry" };
++    }
++    const module = await stepImporter.importer();
++    const originalExpression = stepInput.items;
++
++    console.log("[Loop] Raw items input:", typeof stepInput.items, stepInput.items);
++
++    // Items should already be resolved by processTemplates
++    let items: unknown[] = [];
++    if (Array.isArray(stepInput.items)) {
++      items = stepInput.items;
++    } else if (typeof stepInput.items === "string") {
++      const trimmed = stepInput.items.trim();
++      // Try to parse if it's a JSON string (array or object with array property)
++      if (trimmed.startsWith("[") || trimmed.startsWith("{")) {
++        try {
++          const parsed = JSON.parse(trimmed);
++          if (Array.isArray(parsed)) {
++            items = parsed;
++          } else if (parsed && typeof parsed === "object") {
++            // Check for common array properties: rows, data, items, results
++            items = parsed.rows || parsed.data || parsed.items || parsed.results || [];
++            if (!Array.isArray(items)) {
++              items = [];
++            }
++          }
++        } catch (e) {
++          console.error("[Loop] Failed to parse items JSON:", e);
++          items = [];
++        }
++      }
++    } else if (stepInput.items && typeof stepInput.items === "object") {
++      // Direct object - check for array properties
++      const obj = stepInput.items as Record<string, unknown>;
++      const possibleArray = obj.rows || obj.data || obj.items || obj.results;
++      if (Array.isArray(possibleArray)) {
++        items = possibleArray;
++      }
++    }
++
++    // Parse batch size
++    let batchSize = 1;
++    if (typeof stepInput.batchSize === "number") {
++      batchSize = stepInput.batchSize;
++    } else if (typeof stepInput.batchSize === "string") {
++      batchSize = parseInt(stepInput.batchSize, 10) || 1;
++    }
++
++    console.log("[Loop] Resolved items count:", items.length, "Batch size:", batchSize);
++
++    return await module[stepImporter.stepFunction]({
++      items,
++      batchSize,
++      currentBatchIndex: stepInput.currentBatchIndex ?? 0,
++      expression:
++        typeof originalExpression === "string" ? originalExpression : undefined,
++      _context: context,
++    });
++  }
++
+   // Check system actions first (Database Query, HTTP Request)
+   const systemAction = SYSTEM_ACTIONS[actionType];
+   if (systemAction) {
+@@ -393,10 +457,15 @@
+   // Build node and edge maps
+   const nodeMap = new Map(nodes.map((n) => [n.id, n]));
+   const edgesBySource = new Map<string, string[]>();
++  const edgesByTarget = new Map<string, string[]>();
+   for (const edge of edges) {
+     const targets = edgesBySource.get(edge.source) || [];
+     targets.push(edge.target);
+     edgesBySource.set(edge.source, targets);
++
++    const sources = edgesByTarget.get(edge.target) || [];
++    sources.push(edge.source);
++    edgesByTarget.set(edge.target, sources);
+   }
+ 
+   // Find trigger nodes
+@@ -435,7 +504,11 @@
+ 
+   // Helper to execute a single node
+   // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: Node execution requires type checking and error handling
+-  async function executeNode(nodeId: string, visited: Set<string> = new Set()) {
++  async function executeNode(
++    nodeId: string,
++    visited: Set<string> = new Set(),
++    loopContext?: { iteration: number }
++  ) {
+     console.log("[Workflow Executor] Executing node:", nodeId);
+ 
+     if (visited.has(nodeId)) {
+@@ -463,7 +536,7 @@
+ 
+       const nextNodes = edgesBySource.get(nodeId) || [];
+       await Promise.all(
+-        nextNodes.map((nextNodeId) => executeNode(nextNodeId, visited))
++        nextNodes.map((nextNodeId) => executeNode(nextNodeId, visited, loopContext))
+       );
+       return;
+     }
+@@ -560,7 +633,26 @@
+           nodeId: node.id,
+           nodeName: getNodeName(node),
+           nodeType: actionType,
++          loopIteration: loopContext?.iteration,
+         };
++
++        // Merge output data from previous (source) nodes into the step input
++        // so that plugin steps can access previous step results directly
++        const sourceNodeIds = edgesByTarget.get(nodeId) || [];
++        for (const sourceId of sourceNodeIds) {
++          const sanitizedSourceId = sourceId.replace(/[^a-zA-Z0-9]/g, "_");
++          const sourceOutput = outputs[sanitizedSourceId];
++          if (sourceOutput?.data && typeof sourceOutput.data === "object") {
++            for (const [key, value] of Object.entries(
++              sourceOutput.data as Record<string, unknown>
++            )) {
++              // Don't overwrite explicit config values
++              if (!(key in processedConfig)) {
++                processedConfig[key] = value;
++              }
++            }
++          }
++        }
+ 
+         // Execute the action step with stepHandler (logging is handled inside)
+         // IMPORTANT: We pass integrationId via config, not actual credentials
+@@ -636,6 +728,12 @@
+           node.data.type === "action" &&
+           node.data.config?.actionType === "Condition";
+ 
++        // Check if this is a loop node
++        const loopActionType = node.data.config?.actionType;
++        const isLoopNode =
++          node.data.type === "action" &&
++          (loopActionType === "Loop" || loopActionType === "loop/iterate");
++
+         if (isConditionNode) {
+           // For condition nodes, only execute next nodes if condition is true
+           const conditionResult = (result.data as { condition?: boolean })
+@@ -652,26 +750,84 @@
+               nextNodes.length,
+               "next nodes in parallel"
+             );
+-            // Execute all next nodes in parallel
++            // Execute all next nodes in parallel (preserve loop context if inside a loop)
+             await Promise.all(
+-              nextNodes.map((nextNodeId) => executeNode(nextNodeId, visited))
++              nextNodes.map((nextNodeId) => executeNode(nextNodeId, visited, loopContext))
+             );
+           } else {
+             console.log(
+               "[Workflow Executor] Condition is false, skipping next nodes"
+             );
+           }
++        } else if (isLoopNode) {
++          // For loop nodes, execute next nodes for each batch
++          const loopResult = result.data as {
++            items?: unknown[];
++            totalItems?: number;
++            totalBatches?: number;
++            batchSize?: number;
++          };
++
++          const items = loopResult?.items || [];
++          const batchSize = loopResult?.batchSize || 1;
++          const totalBatches = loopResult?.totalBatches || Math.ceil(items.length / batchSize);
++          const nextNodes = edgesBySource.get(nodeId) || [];
++
++          console.log(
++            "[Workflow Executor] Loop node:",
++            "items:", items.length,
++            "batches:", totalBatches,
++            "nextNodes:", nextNodes.length
++          );
++
++          // Execute downstream nodes for each batch sequentially
++          for (let batchIndex = 0; batchIndex < totalBatches; batchIndex++) {
++            const startIndex = batchIndex * batchSize;
++            const endIndex = Math.min(startIndex + batchSize, items.length);
++            const currentBatch = items.slice(startIndex, endIndex);
++            const currentItem = currentBatch[0];
++
++            console.log(
++              `[Workflow Executor] Loop batch ${batchIndex + 1}/${totalBatches} (items ${startIndex + 1}-${endIndex})`
++            );
++
++            // Update the loop node output with current batch context
++            const loopSanitizedId = nodeId.replace(/[^a-zA-Z0-9]/g, "_");
++            outputs[loopSanitizedId] = {
++              label: node.data.label || nodeId,
++              data: {
++                ...loopResult,
++                currentBatchIndex: batchIndex,
++                currentBatch,
++                currentItem,
++                currentIndex: startIndex,
++                hasMore: batchIndex < totalBatches - 1,
++              },
++            };
++
++            // Execute all next nodes for this batch
++            // Use a fresh visited set containing ONLY the loop node to allow re-execution
++            // of downstream nodes on each iteration
++            // Pass loop context so steps can use it (e.g., for unique idempotency keys)
++            await Promise.all(
++              nextNodes.map((nextNodeId) =>
++                executeNode(nextNodeId, new Set([nodeId]), { iteration: batchIndex })
++              )
++            );
++          }
++
++          console.log("[Workflow Executor] Loop completed all iterations");
+         } else {
+-          // For non-condition nodes, execute all next nodes in parallel
++          // For non-condition/non-loop nodes, execute all next nodes in parallel
+           const nextNodes = edgesBySource.get(nodeId) || [];
+           console.log(
+             "[Workflow Executor] Executing",
+             nextNodes.length,
+             "next nodes in parallel"
+           );
+-          // Execute all next nodes in parallel
++          // Execute all next nodes in parallel (preserve loop context if inside a loop)
+           await Promise.all(
+-            nextNodes.map((nextNodeId) => executeNode(nextNodeId, visited))
++            nextNodes.map((nextNodeId) => executeNode(nextNodeId, visited, loopContext))
+           );
+         }
+       }