orcheo-canvas 0.0.1

package/src/features/workflow/lib/graph-config/workload.ts

@@ -0,0 +1,29 @@
+import {
+  LARGE_DATASET_THRESHOLD,
+  YIELD_BATCH_SIZE,
+} from "@features/workflow/lib/graph-config/constants";
+import type { MaybeYieldFn } from "@features/workflow/lib/graph-config/types";
+
+const yieldToMainThread = async () =>
+  new Promise<void>((resolve) => {
+    setTimeout(resolve, 0);
+  });
+
+export const createYieldController = (
+  totalWorkItems: number,
+): { maybeYield: MaybeYieldFn } => {
+  const shouldYieldProcessing = totalWorkItems > LARGE_DATASET_THRESHOLD;
+  let processedItems = 0;
+
+  const maybeYield: MaybeYieldFn = async () => {
+    if (!shouldYieldProcessing) {
+      return;
+    }
+    processedItems += 1;
+    if (processedItems % YIELD_BATCH_SIZE === 0) {
+      await yieldToMainThread();
+    }
+  };
+
+  return { maybeYield };
+};

package/src/features/workflow/lib/graph-config.integration.logic.test.ts

@@ -0,0 +1,168 @@
+import type { Edge, Node } from "@xyflow/react";
+import { describe, expect, it } from "vitest";
+
+import { buildGraphConfigFromCanvas } from "./graph-config";
+
+describe("buildGraphConfigFromCanvas integration - logic and utility nodes", () => {
+  it("serializes logic and utility nodes for backend consumption", async () => {
+    const nodes: Node[] = [
+      {
+        id: "prep-1",
+        type: "utility",
+        position: { x: -1, y: 0 },
+        data: {
+          label: "Prepare score",
+          backendType: "SetVariableNode",
+          variables: [
+            { name: "state.user.score", valueType: "number", value: "8" },
+          ],
+        },
+      } as Node,
+      {
+        id: "if-1",
+        type: "logic",
+        position: { x: 0, y: 0 },
+        data: {
+          label: "Decision",
+          backendType: "IfElseNode",
+          conditions: [
+            {
+              id: "cond-1",
+              left: "{{ state.user.score }}",
+              operator: "greater_than",
+              right: 5,
+              caseSensitive: false,
+            },
+            {
+              id: "cond-2",
+              left: true,
+              operator: "is_truthy",
+              right: null,
+              caseSensitive: true,
+            },
+          ],
+          conditionLogic: "and",
+        },
+      } as Node,
+      {
+        id: "set-1",
+        type: "utility",
+        position: { x: 1, y: 0 },
+        data: {
+          label: "Assign",
+          backendType: "SetVariableNode",
+          variables: [
+            { name: "profile.name", valueType: "string", value: "Ada" },
+            { name: "profile.score", valueType: "number", value: "42" },
+            {
+              name: "preferences",
+              valueType: "object",
+              value: { theme: "dark" },
+            },
+            {
+              name: "flags",
+              valueType: "array",
+              value: ["beta", "ops"],
+            },
+            { name: "isActive", valueType: "boolean", value: "true" },
+          ],
+        },
+      } as Node,
+      {
+        id: "delay-1",
+        type: "utility",
+        position: { x: 2, y: 0 },
+        data: {
+          label: "Delay",
+          backendType: "DelayNode",
+          durationSeconds: "2.5",
+        },
+      } as Node,
+    ];
+
+    const edges: Edge[] = [
+      { id: "prep-to-if", source: "prep-1", target: "if-1" } as Edge,
+      {
+        id: "if-to-set",
+        source: "if-1",
+        target: "set-1",
+        sourceHandle: "true",
+      } as Edge,
+      {
+        id: "if-to-delay",
+        source: "if-1",
+        target: "delay-1",
+        sourceHandle: "false",
+      } as Edge,
+      { id: "set-to-delay", source: "set-1", target: "delay-1" } as Edge,
+    ];
+
+    const { config, canvasToGraph, graphToCanvas, warnings } =
+      await buildGraphConfigFromCanvas(nodes, edges);
+
+    expect(warnings).toHaveLength(0);
+
+    const prepName = canvasToGraph["prep-1"];
+    const ifElseName = canvasToGraph["if-1"];
+    const setVariableName = canvasToGraph["set-1"];
+    const delayName = canvasToGraph["delay-1"];
+
+    expect(prepName).toBeDefined();
+    expect(ifElseName).toBeDefined();
+    expect(graphToCanvas[ifElseName]).toBe("if-1");
+
+    expect(config.nodes.some((node) => node.name === ifElseName)).toBe(false);
+    expect(config.edge_nodes).toBeDefined();
+
+    const ifElseNode = config.edge_nodes?.find(
+      (node) => node.name === ifElseName,
+    );
+    expect(ifElseNode).toBeDefined();
+    expect(ifElseNode).toMatchObject({
+      type: "IfElseNode",
+      condition_logic: "and",
+    });
+    expect(ifElseNode?.conditions).toEqual([
+      expect.objectContaining({
+        left: "{{ state.user.score }}",
+        operator: "greater_than",
+        right: 5,
+        case_sensitive: false,
+      }),
+      expect.objectContaining({
+        left: true,
+        operator: "is_truthy",
+        case_sensitive: true,
+      }),
+    ]);
+
+    const setVariableNode = config.nodes.find(
+      (node) => node.name === setVariableName,
+    );
+    expect(setVariableNode).toBeDefined();
+    expect(setVariableNode?.variables).toEqual({
+      "profile.name": "Ada",
+      "profile.score": 42,
+      preferences: { theme: "dark" },
+      flags: ["beta", "ops"],
+      isActive: true,
+    });
+
+    const delayNode = config.nodes.find((node) => node.name === delayName);
+    expect(delayNode).toMatchObject({
+      type: "DelayNode",
+      duration_seconds: 2.5,
+    });
+
+    expect(config.conditional_edges).toContainEqual({
+      source: prepName,
+      path: ifElseName,
+      mapping: { true: setVariableName, false: delayName },
+    });
+
+    expect(config.edges).toContainEqual({
+      source: setVariableName,
+      target: delayName,
+    });
+  });
+});

package/src/features/workflow/lib/graph-config.integration.start-end.test.ts

@@ -0,0 +1,68 @@
+import type { Edge, Node } from "@xyflow/react";
+import { describe, expect, it } from "vitest";
+
+import { buildGraphConfigFromCanvas } from "./graph-config";
+
+describe("buildGraphConfigFromCanvas integration - start/end filtering", () => {
+  it("filters out canvas start and end nodes from serialization", async () => {
+    const nodes: Node[] = [
+      {
+        id: "start-node",
+        type: "start",
+        position: { x: 0, y: 0 },
+        data: { label: "Workflow Start", type: "start" },
+      } as Node,
+      {
+        id: "set-var",
+        type: "function",
+        position: { x: 100, y: 0 },
+        data: {
+          label: "Set Variable",
+          backendType: "SetVariableNode",
+          variables: [
+            { name: "my_variable", valueType: "string", value: "sample" },
+            { name: "num", valueType: "number", value: 2 },
+          ],
+        },
+      } as Node,
+      {
+        id: "end-node",
+        type: "end",
+        position: { x: 200, y: 0 },
+        data: { label: "Workflow End", type: "end" },
+      } as Node,
+    ];
+
+    const edges: Edge[] = [
+      { id: "start-to-set", source: "start-node", target: "set-var" } as Edge,
+      { id: "set-to-end", source: "set-var", target: "end-node" } as Edge,
+    ];
+
+    const { config, canvasToGraph, warnings } =
+      await buildGraphConfigFromCanvas(nodes, edges);
+
+    expect(warnings).toHaveLength(0);
+    expect(canvasToGraph["start-node"]).toBeUndefined();
+    expect(canvasToGraph["end-node"]).toBeUndefined();
+
+    expect(canvasToGraph["set-var"]).toBeDefined();
+    const setVarName = canvasToGraph["set-var"];
+
+    expect(config.nodes).toHaveLength(3);
+    expect(config.nodes[0]).toMatchObject({ name: "START", type: "START" });
+    expect(config.nodes[1]).toMatchObject({
+      name: setVarName,
+      type: "SetVariableNode",
+    });
+    expect(config.nodes[2]).toMatchObject({ name: "END", type: "END" });
+
+    expect(config.edges).toContainEqual({
+      source: "START",
+      target: setVarName,
+    });
+    expect(config.edges).toContainEqual({
+      source: setVarName,
+      target: "END",
+    });
+  });
+});

package/src/features/workflow/lib/graph-config.integration.variables.test.ts

@@ -0,0 +1,67 @@
+import type { Edge, Node } from "@xyflow/react";
+import { describe, expect, it } from "vitest";
+
+import { buildGraphConfigFromCanvas } from "./graph-config";
+
+describe("buildGraphConfigFromCanvas integration - variable preservation", () => {
+  it("preserves template expressions for typed variables", async () => {
+    const nodes: Node[] = [
+      {
+        id: "producer",
+        type: "function",
+        position: { x: 0, y: 0 },
+        data: {
+          label: "Producer",
+          backendType: "SetVariableNode",
+          variables: [{ name: "value", valueType: "number", value: 10 }],
+        },
+      } as Node,
+      {
+        id: "consumer",
+        type: "function",
+        position: { x: 1, y: 0 },
+        data: {
+          label: "Consumer",
+          backendType: "SetVariableNode",
+          variables: [
+            {
+              name: "from_template",
+              valueType: "number",
+              value: "{{ results.producer.value }}",
+            },
+          ],
+        },
+      } as Node,
+    ];
+
+    const edges: Edge[] = [
+      {
+        id: "producer-to-consumer",
+        source: "producer",
+        target: "consumer",
+      } as Edge,
+    ];
+
+    const { config, canvasToGraph } = await buildGraphConfigFromCanvas(
+      nodes,
+      edges,
+    );
+
+    const consumerName = canvasToGraph["consumer"];
+    expect(consumerName).toBeDefined();
+
+    const consumerNode = config.nodes.find(
+      (node) => node.name === consumerName,
+    );
+
+    expect(consumerNode).toBeDefined();
+    const consumerVariables = (consumerNode?.variables ?? {}) as Record<
+      string,
+      unknown
+    >;
+
+    expect(consumerVariables).toMatchObject({
+      from_template: "{{ results.producer.value }}",
+    });
+  });
+});

package/src/features/workflow/lib/graph-config.ts

@@ -0,0 +1,80 @@
+import type {
+  CanvasEdge,
+  CanvasNode,
+  GraphBuildResult,
+} from "@features/workflow/lib/graph-config/types";
+import { buildGraphNameMaps } from "@features/workflow/lib/graph-config/name-mapping";
+import { createYieldController } from "@features/workflow/lib/graph-config/workload";
+import {
+  countSerializableVariables,
+  filterSerializableNodes,
+} from "@features/workflow/lib/graph-config/serialization";
+import { processNodes } from "@features/workflow/lib/graph-config/node-processing";
+import { processEdges } from "@features/workflow/lib/graph-config/edge-processing";
+import { ensureTerminalConnections } from "@features/workflow/lib/graph-config/terminal-connections";
+
+export type { GraphBuildResult } from "@features/workflow/lib/graph-config/types";
+
+export const buildGraphConfigFromCanvas = async (
+  nodes: CanvasNode[],
+  edges: CanvasEdge[],
+): Promise<GraphBuildResult> => {
+  const serializableNodes = filterSerializableNodes(nodes);
+  const totalVariableCount = countSerializableVariables(serializableNodes);
+  const totalWorkItems =
+    serializableNodes.length * 3 + edges.length + totalVariableCount;
+
+  const { maybeYield } = createYieldController(totalWorkItems);
+  const warnings: string[] = [];
+
+  const { canvasToGraph, graphToCanvas } = await buildGraphNameMaps(
+    serializableNodes,
+    maybeYield,
+  );
+
+  const nodeArtifacts = await processNodes(serializableNodes, {
+    canvasToGraph,
+    maybeYield,
+    warnings,
+  });
+
+  nodeArtifacts.graphNodes.push({ name: "END", type: "END" });
+
+  const { graphEdges, conditionalEdges } = await processEdges({
+    edges,
+    canvasToGraph,
+    branchPathByCanvasId: nodeArtifacts.branchPathByCanvasId,
+    defaultBranchKeyByCanvasId: nodeArtifacts.defaultBranchKeyByCanvasId,
+    decisionNodeNameByCanvasId: nodeArtifacts.decisionNodeNameByCanvasId,
+    decisionNodeTypeByCanvasId: nodeArtifacts.decisionNodeTypeByCanvasId,
+    maybeYield,
+  });
+
+  await ensureTerminalConnections({
+    executableNodes: nodeArtifacts.executableNodes,
+    canvasToGraph,
+    graphEdges,
+    conditionalEdges,
+    maybeYield,
+  });
+
+  const config: GraphBuildResult["config"] = {
+    nodes: nodeArtifacts.graphNodes,
+    edges: graphEdges,
+  };
+
+  if (nodeArtifacts.graphEdgeNodes.length > 0) {
+    config.edge_nodes = nodeArtifacts.graphEdgeNodes;
+  }
+
+  if (conditionalEdges.length > 0) {
+    config.conditional_edges = conditionalEdges;
+  }
+
+  return {
+    config,
+    canvasToGraph,
+    graphToCanvas,
+    warnings,
+  };
+};

package/src/features/workflow/lib/graph-utils.ts

@@ -0,0 +1,193 @@
+import type { Node, Edge } from "@xyflow/react";
+
+/**
+ * Find all upstream (previous) nodes that connect to the target node.
+ * Returns nodes in topological order (closest dependencies first).
+ *
+ * @param targetNodeId - The ID of the node to find upstream nodes for
+ * @param nodes - All nodes in the workflow
+ * @param edges - All edges in the workflow
+ * @returns Array of upstream nodes in topological order
+ */
+export function findUpstreamNodes(
+  targetNodeId: string,
+  nodes: Node[],
+  edges: Edge[],
+): Node[] {
+  const upstreamIds = new Set<string>();
+  const visited = new Set<string>();
+  const queue: string[] = [targetNodeId];
+
+  // BFS to find all upstream nodes
+  while (queue.length > 0) {
+    const currentId = queue.shift()!;
+    if (visited.has(currentId)) continue;
+    visited.add(currentId);
+
+    // Find all edges that point to this node
+    const incomingEdges = edges.filter((edge) => edge.target === currentId);
+
+    for (const edge of incomingEdges) {
+      if (edge.source !== targetNodeId) {
+        upstreamIds.add(edge.source);
+      }
+      queue.push(edge.source);
+    }
+  }
+
+  // Convert IDs to nodes
+  const upstreamNodes = nodes.filter((node) => upstreamIds.has(node.id));
+
+  // Sort in topological order (nodes with no incoming edges first)
+  return topologicalSort(upstreamNodes, edges);
+}
+
+/**
+ * Check if a node has any incoming connections.
+ *
+ * @param nodeId - The ID of the node to check
+ * @param edges - All edges in the workflow
+ * @returns True if the node has incoming connections
+ */
+export function hasIncomingConnections(nodeId: string, edges: Edge[]): boolean {
+  return edges.some((edge) => edge.target === nodeId);
+}
+
+/**
+ * Collect outputs from all upstream nodes.
+ * Returns a merged object with all outputs keyed by node ID.
+ *
+ * @param upstreamNodes - Array of upstream nodes
+ * @returns Object with outputs keyed by node ID
+ */
+export type RuntimeSummary = {
+  outputs?: unknown;
+  messages?: unknown;
+  raw?: unknown;
+  updatedAt?: string;
+} & Record<string, unknown>;
+
+function parseUpdatedAt(timestamp?: string): number | null {
+  if (!timestamp) {
+    return null;
+  }
+
+  const parsed = new Date(timestamp).getTime();
+  return Number.isNaN(parsed) ? null : parsed;
+}
+
+export function mergeRuntimeSummaries(
+  runtimeFromNode?: RuntimeSummary,
+  cachedRuntime?: RuntimeSummary,
+): RuntimeSummary | undefined {
+  if (!runtimeFromNode && !cachedRuntime) {
+    return undefined;
+  }
+
+  if (!runtimeFromNode) {
+    return cachedRuntime;
+  }
+
+  if (!cachedRuntime) {
+    return runtimeFromNode;
+  }
+
+  const nodeTimestamp = parseUpdatedAt(runtimeFromNode.updatedAt);
+  const cacheTimestamp = parseUpdatedAt(cachedRuntime.updatedAt);
+
+  if (nodeTimestamp !== null && cacheTimestamp !== null) {
+    if (nodeTimestamp >= cacheTimestamp) {
+      return { ...cachedRuntime, ...runtimeFromNode };
+    }
+
+    return { ...runtimeFromNode, ...cachedRuntime };
+  }
+
+  // Fall back to preferring the live runtime when timestamps are missing or invalid.
+  return { ...cachedRuntime, ...runtimeFromNode };
+}
+
+export function collectUpstreamOutputs(
+  upstreamNodes: Node[],
+  runtimeCache?: Record<string, RuntimeSummary>,
+): Record<string, unknown> {
+  const outputs: Record<string, unknown> = {};
+
+  for (const node of upstreamNodes) {
+    // Extract runtime outputs from node data
+    const runtimeFromNode = node.data?.runtime as RuntimeSummary | undefined;
+    const cachedRuntime = runtimeCache?.[node.id];
+
+    const mergedRuntime = mergeRuntimeSummaries(runtimeFromNode, cachedRuntime);
+
+    if (mergedRuntime) {
+      // Prioritize outputs, then messages, then raw
+      const nodeOutput =
+        mergedRuntime.outputs ?? mergedRuntime.messages ?? mergedRuntime.raw;
+
+      if (nodeOutput !== undefined) {
+        outputs[node.id] = nodeOutput;
+      }
+    }
+  }
+
+  return outputs;
+}
+
+/**
+ * Sort nodes in topological order based on edges.
+ * Nodes with no dependencies come first.
+ *
+ * @param nodes - Nodes to sort
+ * @param edges - Edges defining dependencies
+ * @returns Sorted array of nodes
+ */
+function topologicalSort(nodes: Node[], edges: Edge[]): Node[] {
+  const nodeMap = new Map(nodes.map((node) => [node.id, node]));
+  const inDegree = new Map<string, number>();
+  const adjacency = new Map<string, string[]>();
+
+  // Initialize
+  for (const node of nodes) {
+    inDegree.set(node.id, 0);
+    adjacency.set(node.id, []);
+  }
+
+  // Build adjacency list and in-degree count
+  for (const edge of edges) {
+    if (nodeMap.has(edge.source) && nodeMap.has(edge.target)) {
+      adjacency.get(edge.source)!.push(edge.target);
+      inDegree.set(edge.target, (inDegree.get(edge.target) || 0) + 1);
+    }
+  }
+
+  // Kahn's algorithm
+  const queue: string[] = [];
+  const result: Node[] = [];
+
+  // Start with nodes that have no incoming edges
+  for (const [nodeId, degree] of inDegree.entries()) {
+    if (degree === 0) {
+      queue.push(nodeId);
+    }
+  }
+
+  while (queue.length > 0) {
+    const nodeId = queue.shift()!;
+    const node = nodeMap.get(nodeId);
+    if (node) {
+      result.push(node);
+    }
+
+    // Reduce in-degree for neighbors
+    for (const neighbor of adjacency.get(nodeId) || []) {
+      const newDegree = (inDegree.get(neighbor) || 0) - 1;
+      inDegree.set(neighbor, newDegree);
+      if (newDegree === 0) {
+        queue.push(neighbor);
+      }
+    }
+  }
+
+  return result;
+}