orcheo-canvas 0.0.1

package/src/features/workflow/lib/graph-config/node-handlers/integrations.ts

@@ -0,0 +1,201 @@
+import {
+  isRecord,
+  toStringRecord,
+} from "@features/workflow/lib/graph-config/utils";
+
+export const applyDelayConfig = (
+  data: Record<string, unknown>,
+  nodeConfig: Record<string, unknown>,
+): void => {
+  const delayValue = data?.durationSeconds;
+  const parsed =
+    typeof delayValue === "number" ? delayValue : Number(delayValue ?? 0);
+  nodeConfig.duration_seconds = Number.isFinite(parsed) ? parsed : 0;
+};
+
+export const applyMongoConfig = (
+  data: Record<string, unknown>,
+  nodeConfig: Record<string, unknown>,
+): void => {
+  if (typeof data?.database === "string" && data.database.length > 0) {
+    nodeConfig.database = data.database;
+  }
+  if (typeof data?.collection === "string" && data.collection.length > 0) {
+    nodeConfig.collection = data.collection;
+  }
+  nodeConfig.operation =
+    typeof data?.operation === "string" && data.operation.length > 0
+      ? data.operation
+      : "find";
+  nodeConfig.query = isRecord(data?.query) ? data.query : {};
+};
+
+export const applySlackConfig = (
+  data: Record<string, unknown>,
+  nodeConfig: Record<string, unknown>,
+): void => {
+  if (typeof data?.tool_name === "string" && data.tool_name.length > 0) {
+    nodeConfig.tool_name = data.tool_name;
+  }
+  nodeConfig.kwargs = isRecord(data?.kwargs) ? data.kwargs : {};
+};
+
+export const applyTelegramConfig = (
+  data: Record<string, unknown>,
+  nodeConfig: Record<string, unknown>,
+): void => {
+  if (typeof data?.token === "string" && data.token.length > 0) {
+    nodeConfig.token = data.token;
+  }
+  if (typeof data?.chat_id === "string" && data.chat_id.length > 0) {
+    nodeConfig.chat_id = data.chat_id;
+  }
+  if (typeof data?.message === "string" && data.message.length > 0) {
+    nodeConfig.message = data.message;
+  }
+  if (typeof data?.parse_mode === "string" && data.parse_mode.length > 0) {
+    nodeConfig.parse_mode = data.parse_mode;
+  }
+};
+
+export const applyCronTriggerConfig = (
+  data: Record<string, unknown>,
+  nodeConfig: Record<string, unknown>,
+): void => {
+  nodeConfig.expression =
+    typeof data?.expression === "string" && data.expression.length > 0
+      ? data.expression
+      : "0 * * * *";
+  nodeConfig.timezone =
+    typeof data?.timezone === "string" && data.timezone.length > 0
+      ? data.timezone
+      : "UTC";
+  nodeConfig.allow_overlapping = Boolean(data?.allow_overlapping);
+  if (typeof data?.start_at === "string" && data.start_at.length > 0) {
+    nodeConfig.start_at = data.start_at;
+  }
+  if (typeof data?.end_at === "string" && data.end_at.length > 0) {
+    nodeConfig.end_at = data.end_at;
+  }
+};
+
+export const applyManualTriggerConfig = (
+  data: Record<string, unknown>,
+  nodeConfig: Record<string, unknown>,
+): void => {
+  nodeConfig.label =
+    typeof data?.label === "string" && data.label.length > 0
+      ? data.label
+      : "manual";
+  nodeConfig.allowed_actors = Array.isArray(data?.allowed_actors)
+    ? (data.allowed_actors as string[])
+    : [];
+  nodeConfig.require_comment = Boolean(data?.require_comment);
+  nodeConfig.default_payload = isRecord(data?.default_payload)
+    ? data.default_payload
+    : {};
+  const cooldownValue = data?.cooldown_seconds;
+  const parsedCooldown =
+    typeof cooldownValue === "number"
+      ? cooldownValue
+      : Number(cooldownValue ?? 0);
+  nodeConfig.cooldown_seconds = Number.isFinite(parsedCooldown)
+    ? parsedCooldown
+    : 0;
+};
+
+export const applyHttpPollingTriggerConfig = (
+  data: Record<string, unknown>,
+  nodeConfig: Record<string, unknown>,
+): void => {
+  nodeConfig.url =
+    typeof data?.url === "string" && data.url.length > 0 ? data.url : "";
+  nodeConfig.method =
+    typeof data?.method === "string" && data.method.length > 0
+      ? data.method
+      : "GET";
+  nodeConfig.headers = isRecord(data?.headers) ? data.headers : {};
+  nodeConfig.query_params = isRecord(data?.query_params)
+    ? data.query_params
+    : {};
+  if (isRecord(data?.body)) {
+    nodeConfig.body = data.body;
+  }
+  const intervalValue = data?.interval_seconds;
+  const parsedInterval =
+    typeof intervalValue === "number"
+      ? intervalValue
+      : Number(intervalValue ?? 0);
+  nodeConfig.interval_seconds = Number.isFinite(parsedInterval)
+    ? parsedInterval
+    : 300;
+  const timeoutValue = data?.timeout_seconds;
+  const parsedTimeout =
+    typeof timeoutValue === "number" ? timeoutValue : Number(timeoutValue ?? 0);
+  nodeConfig.timeout_seconds = Number.isFinite(parsedTimeout)
+    ? parsedTimeout
+    : 30;
+  nodeConfig.verify_tls = data?.verify_tls !== false;
+  nodeConfig.follow_redirects = Boolean(data?.follow_redirects);
+  if (
+    typeof data?.deduplicate_on === "string" &&
+    data.deduplicate_on.length > 0
+  ) {
+    nodeConfig.deduplicate_on = data.deduplicate_on;
+  }
+};
+
+export const applyWebhookTriggerConfig = (
+  data: Record<string, unknown>,
+  nodeConfig: Record<string, unknown>,
+): void => {
+  const allowedMethodsRaw = Array.isArray(data?.allowed_methods)
+    ? (data.allowed_methods as unknown[])
+    : [];
+  const allowedMethods = allowedMethodsRaw
+    .filter(
+      (method): method is string =>
+        typeof method === "string" && method.trim().length > 0,
+    )
+    .map((method) => method.trim().toUpperCase());
+
+  nodeConfig.allowed_methods =
+    allowedMethods.length > 0 ? allowedMethods : ["POST"];
+  nodeConfig.required_headers = toStringRecord(data?.required_headers);
+  nodeConfig.required_query_params = toStringRecord(
+    data?.required_query_params,
+  );
+
+  if (
+    typeof data?.shared_secret_header === "string" &&
+    data.shared_secret_header.length > 0
+  ) {
+    nodeConfig.shared_secret_header = data.shared_secret_header;
+  }
+
+  if (
+    typeof data?.shared_secret === "string" &&
+    data.shared_secret.length > 0
+  ) {
+    nodeConfig.shared_secret = data.shared_secret;
+  }
+
+  const rateLimitRaw = data?.rate_limit;
+  if (isRecord(rateLimitRaw)) {
+    const limitValue = rateLimitRaw.limit;
+    const intervalValue = rateLimitRaw.interval_seconds;
+    const parsedLimit =
+      typeof limitValue === "number" ? limitValue : Number(limitValue ?? NaN);
+    const parsedInterval =
+      typeof intervalValue === "number"
+        ? intervalValue
+        : Number(intervalValue ?? NaN);
+
+    if (Number.isFinite(parsedLimit) && Number.isFinite(parsedInterval)) {
+      nodeConfig.rate_limit = {
+        limit: Math.max(1, Math.trunc(parsedLimit)),
+        interval_seconds: Math.max(1, Math.trunc(parsedInterval)),
+      };
+    }
+  }
+};

package/src/features/workflow/lib/graph-config/node-handlers/set-variable.ts

@@ -0,0 +1,124 @@
+import {
+  isRecord,
+  isTemplateExpression,
+} from "@features/workflow/lib/graph-config/utils";
+import type { MaybeYieldFn } from "@features/workflow/lib/graph-config/types";
+
+export const applySetVariableConfig = async (
+  data: Record<string, unknown>,
+  nodeConfig: Record<string, unknown>,
+  warnings: string[],
+  maybeYield: MaybeYieldFn,
+): Promise<void> => {
+  const variables = Array.isArray(data?.variables)
+    ? (data.variables as Array<Record<string, unknown>>)
+    : [];
+  const variablesDict: Record<string, unknown> = {};
+
+  for (const variable of variables) {
+    if (!variable?.name) {
+      await maybeYield();
+      continue;
+    }
+
+    const variableName = String(variable.name);
+    const valueType =
+      typeof variable.valueType === "string" ? variable.valueType : "string";
+    let typedValue = variable.value ?? null;
+    const templateExpression = isTemplateExpression(typedValue);
+
+    if (typedValue !== null && typedValue !== undefined) {
+      switch (valueType) {
+        case "number":
+          if (typeof typedValue === "number" || templateExpression) {
+            break;
+          }
+          {
+            const parsedNumber = Number(typedValue);
+            if (Number.isFinite(parsedNumber)) {
+              typedValue = parsedNumber;
+            } else {
+              const message = `Variable "${variableName}" must be numeric. Keeping original value "${typedValue}".`;
+              warnings.push(message);
+              console.warn(message);
+            }
+          }
+          break;
+        case "boolean":
+          if (typeof typedValue === "boolean" || templateExpression) {
+            break;
+          }
+          if (typeof typedValue === "string") {
+            const normalised = typedValue.trim().toLowerCase();
+            typedValue = normalised === "true";
+          } else {
+            typedValue = typedValue === 1;
+          }
+          break;
+        case "object":
+          if (templateExpression) {
+            break;
+          }
+          if (typeof typedValue === "string") {
+            try {
+              const parsed = JSON.parse(typedValue);
+              if (isRecord(parsed)) {
+                typedValue = parsed;
+              } else {
+                const message = `Variable "${variableName}" must be a JSON object. Using an empty object instead.`;
+                warnings.push(message);
+                console.warn(message);
+                typedValue = {};
+              }
+            } catch (error) {
+              const message = `Variable "${variableName}" contains invalid JSON. Using an empty object instead.`;
+              warnings.push(message);
+              console.warn(message, error);
+              typedValue = {};
+            }
+          } else if (!isRecord(typedValue)) {
+            const message = `Variable "${variableName}" must be an object value. Using an empty object instead.`;
+            warnings.push(message);
+            console.warn(message);
+            typedValue = {};
+          }
+          break;
+        case "array":
+          if (templateExpression) {
+            break;
+          }
+          if (typeof typedValue === "string") {
+            try {
+              const parsed = JSON.parse(typedValue);
+              if (Array.isArray(parsed)) {
+                typedValue = parsed;
+              } else {
+                const message = `Variable "${variableName}" must be a JSON array. Using an empty array instead.`;
+                warnings.push(message);
+                console.warn(message);
+                typedValue = [];
+              }
+            } catch (error) {
+              const message = `Variable "${variableName}" contains invalid JSON. Using an empty array instead.`;
+              warnings.push(message);
+              console.warn(message, error);
+              typedValue = [];
+            }
+          } else if (!Array.isArray(typedValue)) {
+            const message = `Variable "${variableName}" must be an array value. Using an empty array instead.`;
+            warnings.push(message);
+            console.warn(message);
+            typedValue = [];
+          }
+          break;
+        default:
+          break;
+      }
+    }
+
+    variablesDict[variableName] = typedValue;
+    await maybeYield();
+  }
+
+  nodeConfig.variables = variablesDict;
+};

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

@@ -0,0 +1,163 @@
+import { DEFAULT_PYTHON_CODE } from "@features/workflow/lib/python-node";
+import {
+  applyCronTriggerConfig,
+  applyDelayConfig,
+  applyHttpPollingTriggerConfig,
+  applyManualTriggerConfig,
+  applyMongoConfig,
+  applySetVariableConfig,
+  applySlackConfig,
+  applySwitchConfig,
+  applyTelegramConfig,
+  applyWebhookTriggerConfig,
+  applyWhileConfig,
+  createDecisionEdgeNodeConfig,
+} from "@features/workflow/lib/graph-config/node-handlers";
+import {
+  DECISION_NODE_TYPES,
+  DEFAULT_NODE_CODE,
+} from "@features/workflow/lib/graph-config/constants";
+import type {
+  CanvasNode,
+  NodeProcessingArtifacts,
+  NodeProcessingContext,
+} from "@features/workflow/lib/graph-config/types";
+
+const getBackendType = (node: CanvasNode): string | undefined => {
+  const data = node.data ?? {};
+  const raw = data?.backendType;
+  if (typeof raw === "string" && raw.trim().length > 0) {
+    return raw.trim();
+  }
+  return undefined;
+};
+
+export const processNodes = async (
+  nodes: CanvasNode[],
+  context: NodeProcessingContext,
+): Promise<NodeProcessingArtifacts> => {
+  const { canvasToGraph, maybeYield, warnings } = context;
+
+  const graphNodes: Array<Record<string, unknown>> = [
+    { name: "START", type: "START" },
+  ];
+  const graphEdgeNodes: Array<Record<string, unknown>> = [];
+  const executableNodes: CanvasNode[] = [];
+  const branchPathByCanvasId: Record<string, string> = {};
+  const defaultBranchKeyByCanvasId: Record<string, string | undefined> = {};
+  const decisionNodeNameByCanvasId: Record<string, string> = {};
+  const decisionNodeTypeByCanvasId: Record<string, string> = {};
+
+  for (let index = 0; index < nodes.length; index += 1) {
+    const node = nodes[index];
+    const data = node.data ?? {};
+    const semanticTypeRaw =
+      typeof data?.type === "string" ? data.type.toLowerCase() : undefined;
+    const defaultCode =
+      semanticTypeRaw === "python" ? DEFAULT_PYTHON_CODE : DEFAULT_NODE_CODE;
+    const code =
+      typeof data?.code === "string" && data.code.length > 0
+        ? data.code
+        : defaultCode;
+
+    const backendType = getBackendType(node) ?? "PythonCode";
+    const nodeName = canvasToGraph[node.id];
+
+    const baseConfig: Record<string, unknown> = {
+      name: nodeName,
+      type: backendType,
+      display_name: node.data?.label ?? node.id ?? `Node ${index + 1}`,
+      canvas_id: node.id,
+    };
+
+    if (DECISION_NODE_TYPES.has(backendType)) {
+      decisionNodeNameByCanvasId[node.id] = nodeName;
+      decisionNodeTypeByCanvasId[node.id] = backendType;
+      const edgeNodeConfig = createDecisionEdgeNodeConfig({
+        node,
+        backendType,
+        baseConfig,
+      });
+      graphEdgeNodes.push(edgeNodeConfig);
+      await maybeYield();
+      continue;
+    }
+
+    const nodeConfig: Record<string, unknown> = { ...baseConfig };
+
+    if (backendType === "PythonCode") {
+      nodeConfig.code = code;
+    }
+
+    if (backendType === "SwitchNode") {
+      applySwitchConfig({
+        node,
+        data,
+        nodeConfig,
+        canvasToGraph,
+        branchPathByCanvasId,
+        defaultBranchKeyByCanvasId,
+      });
+    }
+
+    if (backendType === "WhileNode") {
+      applyWhileConfig({
+        node,
+        data,
+        nodeConfig,
+        canvasToGraph,
+        branchPathByCanvasId,
+      });
+    }
+
+    if (backendType === "SetVariableNode") {
+      await applySetVariableConfig(data, nodeConfig, warnings, maybeYield);
+    }
+
+    if (backendType === "DelayNode") {
+      applyDelayConfig(data, nodeConfig);
+    }
+
+    if (backendType === "MongoDBNode") {
+      applyMongoConfig(data, nodeConfig);
+    }
+
+    if (backendType === "SlackNode") {
+      applySlackConfig(data, nodeConfig);
+    }
+
+    if (backendType === "MessageTelegram") {
+      applyTelegramConfig(data, nodeConfig);
+    }
+
+    if (backendType === "CronTriggerNode") {
+      applyCronTriggerConfig(data, nodeConfig);
+    }
+
+    if (backendType === "ManualTriggerNode") {
+      applyManualTriggerConfig(data, nodeConfig);
+    }
+
+    if (backendType === "HttpPollingTriggerNode") {
+      applyHttpPollingTriggerConfig(data, nodeConfig);
+    }
+
+    if (backendType === "WebhookTriggerNode") {
+      applyWebhookTriggerConfig(data, nodeConfig);
+    }
+
+    graphNodes.push(nodeConfig);
+    executableNodes.push(node);
+    await maybeYield();
+  }
+
+  return {
+    graphNodes,
+    graphEdgeNodes,
+    executableNodes,
+    branchPathByCanvasId,
+    defaultBranchKeyByCanvasId,
+    decisionNodeNameByCanvasId,
+    decisionNodeTypeByCanvasId,
+  };
+};

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

@@ -0,0 +1,31 @@
+import type { CanvasNode } from "@features/workflow/lib/graph-config/types";
+
+const shouldSerializeNode = (node: CanvasNode): boolean => {
+  const semanticTypeRaw =
+    typeof node.data?.type === "string"
+      ? node.data.type.toLowerCase()
+      : undefined;
+  const canvasType = typeof node.type === "string" ? node.type : undefined;
+
+  if (
+    semanticTypeRaw === "annotation" ||
+    semanticTypeRaw === "start" ||
+    semanticTypeRaw === "end" ||
+    canvasType === "stickyNote"
+  ) {
+    return false;
+  }
+
+  return true;
+};
+
+export const filterSerializableNodes = (nodes: CanvasNode[]): CanvasNode[] => {
+  return nodes.filter(shouldSerializeNode);
+};
+
+export const countSerializableVariables = (nodes: CanvasNode[]): number => {
+  return nodes.reduce((count, node) => {
+    const variables = node.data?.variables;
+    return Array.isArray(variables) ? count + variables.length : count;
+  }, 0);
+};

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

@@ -0,0 +1,37 @@
+import type { TerminalConnectionParams } from "@features/workflow/lib/graph-config/types";
+
+export const ensureTerminalConnections = async ({
+  executableNodes,
+  canvasToGraph,
+  graphEdges,
+  conditionalEdges,
+  maybeYield,
+}: TerminalConnectionParams): Promise<void> => {
+  if (executableNodes.length === 0) {
+    graphEdges.push({ source: "START", target: "END" });
+    return;
+  }
+
+  const incoming = new Set(graphEdges.map((edge) => edge.target));
+  const outgoing = new Set(graphEdges.map((edge) => edge.source));
+
+  for (const entry of conditionalEdges) {
+    Object.values(entry.mapping).forEach((target) => incoming.add(target));
+    if (entry.default) {
+      incoming.add(entry.default);
+    }
+    outgoing.add(entry.source);
+    await maybeYield();
+  }
+
+  for (const node of executableNodes) {
+    const graphName = canvasToGraph[node.id];
+    if (!incoming.has(graphName)) {
+      graphEdges.push({ source: "START", target: graphName });
+    }
+    if (!outgoing.has(graphName)) {
+      graphEdges.push({ source: graphName, target: "END" });
+    }
+    await maybeYield();
+  }
+};

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

@@ -0,0 +1,84 @@
+import type { Edge, Node } from "@xyflow/react";
+
+export type NodeStatus = "idle" | "running" | "success" | "error" | "warning";
+
+export type CanvasNode = Node<{
+  label?: string;
+  type?: string;
+  status?: NodeStatus;
+  [key: string]: unknown;
+}>;
+
+export type CanvasEdge = Edge<Record<string, unknown>>;
+
+export interface GraphBuildResult {
+  config: {
+    nodes: Array<Record<string, unknown>>;
+    edges: Array<{ source: string; target: string }>;
+    edge_nodes?: Array<Record<string, unknown>>;
+    conditional_edges?: Array<{
+      source: string;
+      path: string;
+      mapping: Record<string, string>;
+      default?: string;
+    }>;
+  };
+  canvasToGraph: Record<string, string>;
+  graphToCanvas: Record<string, string>;
+  warnings: string[];
+}
+
+export type GraphEdge = { source: string; target: string };
+
+export type ConditionalEdge = {
+  source: string;
+  path: string;
+  mapping: Record<string, string>;
+  default?: string;
+};
+
+export type MaybeYieldFn = () => Promise<void>;
+
+export interface GraphNameMaps {
+  canvasToGraph: Record<string, string>;
+  graphToCanvas: Record<string, string>;
+}
+
+export interface NodeProcessingContext {
+  canvasToGraph: Record<string, string>;
+  maybeYield: MaybeYieldFn;
+  warnings: string[];
+}
+
+export interface NodeProcessingArtifacts {
+  graphNodes: Array<Record<string, unknown>>;
+  graphEdgeNodes: Array<Record<string, unknown>>;
+  executableNodes: CanvasNode[];
+  branchPathByCanvasId: Record<string, string>;
+  defaultBranchKeyByCanvasId: Record<string, string | undefined>;
+  decisionNodeNameByCanvasId: Record<string, string>;
+  decisionNodeTypeByCanvasId: Record<string, string>;
+}
+
+export interface EdgeProcessingParams {
+  edges: CanvasEdge[];
+  canvasToGraph: Record<string, string>;
+  branchPathByCanvasId: Record<string, string>;
+  defaultBranchKeyByCanvasId: Record<string, string | undefined>;
+  decisionNodeNameByCanvasId: Record<string, string>;
+  decisionNodeTypeByCanvasId: Record<string, string>;
+  maybeYield: MaybeYieldFn;
+}
+
+export interface EdgeProcessingResult {
+  graphEdges: GraphEdge[];
+  conditionalEdges: ConditionalEdge[];
+}
+
+export interface TerminalConnectionParams {
+  executableNodes: CanvasNode[];
+  canvasToGraph: Record<string, string>;
+  graphEdges: GraphEdge[];
+  conditionalEdges: ConditionalEdge[];
+  maybeYield: MaybeYieldFn;
+}

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

@@ -0,0 +1,65 @@
+export const isRecord = (value: unknown): value is Record<string, unknown> => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === null || prototype === Object.prototype;
+};
+
+export const toStringRecord = (value: unknown): Record<string, string> => {
+  if (!isRecord(value)) {
+    return {};
+  }
+
+  return Object.entries(value).reduce<Record<string, string>>(
+    (acc, [key, rawValue]) => {
+      if (typeof key !== "string") {
+        return acc;
+      }
+
+      if (typeof rawValue === "string") {
+        acc[key] = rawValue;
+        return acc;
+      }
+
+      if (typeof rawValue === "number" || typeof rawValue === "boolean") {
+        acc[key] = String(rawValue);
+        return acc;
+      }
+
+      return acc;
+    },
+    {},
+  );
+};
+
+export const slugify = (value: string, fallback: string): string => {
+  const slug = value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .replace(/-{2,}/g, "-");
+  return slug || fallback;
+};
+
+export const ensureUniqueName = (
+  candidate: string,
+  used: Set<string>,
+): string => {
+  if (!used.has(candidate)) {
+    used.add(candidate);
+    return candidate;
+  }
+  let counter = 2;
+  while (used.has(`${candidate}-${counter}`)) {
+    counter += 1;
+  }
+  const unique = `${candidate}-${counter}`;
+  used.add(unique);
+  return unique;
+};
+
+export const isTemplateExpression = (value: unknown): value is string => {
+  return typeof value === "string" && value.includes("{{");
+};