orcheo-canvas 0.0.1

package/src/features/workflow/data/templates/slack-broadcast.ts

@@ -0,0 +1,58 @@
+import { Workflow } from "../workflow-types";
+import { TEMPLATE_OWNER } from "./template-owner";
+
+export const SLACK_BROADCAST_WORKFLOW: Workflow = {
+  id: "workflow-slack-broadcast",
+  name: "Slack Channel Broadcast",
+  description: "Posts an announcement to a Slack channel.",
+  createdAt: "2024-02-01T13:20:00Z",
+  updatedAt: "2024-03-02T18:40:00Z",
+  sourceExample: "examples/slack.py",
+  owner: TEMPLATE_OWNER,
+  tags: ["template", "slack", "messaging"],
+  nodes: [
+    {
+      id: "slack-start",
+      type: "start",
+      position: { x: 0, y: 0 },
+      data: {
+        label: "Start",
+        type: "start",
+        description: "Begin the Slack announcement workflow.",
+      },
+    },
+    {
+      id: "send-slack-message",
+      type: "api",
+      position: { x: 260, y: 0 },
+      data: {
+        label: "Send Slack message",
+        type: "api",
+        description: "Slack node posts the message to the configured channel.",
+        examplePath: "examples/slack.py",
+      },
+    },
+    {
+      id: "slack-end",
+      type: "end",
+      position: { x: 520, y: 0 },
+      data: {
+        label: "Finish",
+        type: "end",
+        description: "Slack announcement has been delivered.",
+      },
+    },
+  ],
+  edges: [
+    {
+      id: "edge-slack-start-send",
+      source: "slack-start",
+      target: "send-slack-message",
+    },
+    {
+      id: "edge-slack-end",
+      source: "send-slack-message",
+      target: "slack-end",
+    },
+  ],
+};

package/src/features/workflow/data/templates/telegram-broadcast.ts

@@ -0,0 +1,76 @@
+import { Workflow } from "../workflow-types";
+import { TEMPLATE_OWNER } from "./template-owner";
+
+export const TELEGRAM_BROADCAST_WORKFLOW: Workflow = {
+  id: "workflow-telegram-broadcast",
+  name: "Python to Telegram Broadcast",
+  description: "Generates a message in Python and forwards it to Telegram.",
+  createdAt: "2024-02-24T21:00:00Z",
+  updatedAt: "2024-03-08T09:30:00Z",
+  sourceExample: "examples/telegram_example.py",
+  owner: TEMPLATE_OWNER,
+  tags: ["template", "telegram", "python"],
+  nodes: [
+    {
+      id: "telegram-start",
+      type: "start",
+      position: { x: 0, y: 0 },
+      data: {
+        label: "Start",
+        type: "start",
+        description: "Entry point for the Telegram broadcast.",
+      },
+    },
+    {
+      id: "compose-telegram-message",
+      type: "function",
+      position: { x: 220, y: 0 },
+      data: {
+        label: "Compose message with Python",
+        type: "function",
+        description:
+          "PythonCode node prepares the message payload for Telegram.",
+        examplePath: "examples/telegram_example.py",
+      },
+    },
+    {
+      id: "send-telegram-message",
+      type: "api",
+      position: { x: 440, y: 0 },
+      data: {
+        label: "Send Telegram message",
+        type: "api",
+        description:
+          "MessageTelegram node sends the composed message to the target chat.",
+        examplePath: "examples/telegram_example.py",
+      },
+    },
+    {
+      id: "telegram-end",
+      type: "end",
+      position: { x: 660, y: 0 },
+      data: {
+        label: "Finish",
+        type: "end",
+        description: "Broadcast completed successfully.",
+      },
+    },
+  ],
+  edges: [
+    {
+      id: "edge-telegram-start-compose",
+      source: "telegram-start",
+      target: "compose-telegram-message",
+    },
+    {
+      id: "edge-telegram-compose-send",
+      source: "compose-telegram-message",
+      target: "send-telegram-message",
+    },
+    {
+      id: "edge-telegram-send-end",
+      source: "send-telegram-message",
+      target: "telegram-end",
+    },
+  ],
+};

package/src/features/workflow/data/templates/template-owner.ts

@@ -0,0 +1,7 @@
+import { Workflow } from "../workflow-types";
+
+export const TEMPLATE_OWNER: Workflow["owner"] = {
+  id: "team-templates",
+  name: "Orcheo Templates",
+  avatar: "https://avatar.vercel.sh/templates",
+};

package/src/features/workflow/data/workflow-data.ts

@@ -0,0 +1,13 @@
+export type { Workflow, WorkflowEdge, WorkflowNode } from "./workflow-types";
+export { NODE_TYPES } from "./node-types";
+export {
+  TEMPLATE_OWNER,
+  SAMPLE_WORKFLOWS,
+  QUICKSTART_WELCOME_WORKFLOW,
+  SIMPLE_PYTHON_WORKFLOW,
+  FEEDLY_DIGEST_WORKFLOW,
+  SLACK_BROADCAST_WORKFLOW,
+  RSS_MONITOR_WORKFLOW,
+  MONGODB_SESSION_WORKFLOW,
+  TELEGRAM_BROADCAST_WORKFLOW,
+} from "./templates";

package/src/features/workflow/data/workflow-types.ts

@@ -0,0 +1,47 @@
+export interface WorkflowNode {
+  id: string;
+  type: string;
+  position: { x: number; y: number };
+  data: {
+    label: string;
+    description?: string;
+    status?: "idle" | "running" | "success" | "error";
+    isDisabled?: boolean;
+    backendType?: string;
+    [key: string]: unknown;
+  };
+}
+
+export interface WorkflowEdge {
+  id: string;
+  source: string;
+  target: string;
+  sourceHandle?: string | null;
+  targetHandle?: string | null;
+  label?: string;
+  type?: string;
+  animated?: boolean;
+  style?: Record<string, unknown>;
+}
+
+export interface Workflow {
+  id: string;
+  name: string;
+  description?: string;
+  createdAt: string;
+  updatedAt: string;
+  sourceExample?: string;
+  owner: {
+    id: string;
+    name: string;
+    avatar: string;
+  };
+  tags: string[];
+  lastRun?: {
+    status: "success" | "error" | "running" | "idle";
+    timestamp: string;
+    duration: number;
+  };
+  nodes: WorkflowNode[];
+  edges: WorkflowEdge[];
+}

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

@@ -0,0 +1,7 @@
+export const DEFAULT_NODE_CODE = "return state";
+
+export const LARGE_DATASET_THRESHOLD = 200;
+
+export const YIELD_BATCH_SIZE = 50;
+
+export const DECISION_NODE_TYPES = new Set(["IfElseNode"]);

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

@@ -0,0 +1,147 @@
+import type {
+  ConditionalEdge,
+  EdgeProcessingParams,
+  EdgeProcessingResult,
+  GraphEdge,
+} from "@features/workflow/lib/graph-config/types";
+
+export const processEdges = async ({
+  edges,
+  canvasToGraph,
+  branchPathByCanvasId,
+  defaultBranchKeyByCanvasId,
+  decisionNodeNameByCanvasId,
+  decisionNodeTypeByCanvasId,
+  maybeYield,
+}: EdgeProcessingParams): Promise<EdgeProcessingResult> => {
+  const graphEdges: GraphEdge[] = [];
+  const conditionalEdges: ConditionalEdge[] = [];
+  const conditionalEdgesMap: Record<
+    string,
+    { path: string; mapping: Record<string, string>; defaultTarget?: string }
+  > = {};
+  const decisionSourcesByCanvasId: Record<string, Set<string>> = {};
+  const decisionOutgoingByCanvasId: Record<
+    string,
+    { mapping: Record<string, string>; defaultTarget?: string }
+  > = {};
+
+  for (const edge of edges) {
+    const sourceId = edge.source;
+    const targetId = edge.target;
+    const source = canvasToGraph[sourceId];
+    const target = canvasToGraph[targetId];
+    if (!source || !target) {
+      await maybeYield();
+      continue;
+    }
+
+    if (decisionNodeNameByCanvasId[targetId]) {
+      const sources = decisionSourcesByCanvasId[targetId] ?? new Set<string>();
+      sources.add(source);
+      decisionSourcesByCanvasId[targetId] = sources;
+      await maybeYield();
+      continue;
+    }
+
+    const rawHandle =
+      typeof edge.sourceHandle === "string" && edge.sourceHandle.length > 0
+        ? edge.sourceHandle.trim()
+        : undefined;
+
+    if (decisionNodeNameByCanvasId[sourceId]) {
+      const entry = decisionOutgoingByCanvasId[sourceId] ?? {
+        mapping: {},
+        defaultTarget: undefined,
+      };
+      const decisionType = decisionNodeTypeByCanvasId[sourceId];
+      const normalisedHandle =
+        rawHandle && decisionType === "IfElseNode"
+          ? rawHandle.toLowerCase()
+          : rawHandle;
+
+      if (normalisedHandle) {
+        entry.mapping[normalisedHandle] = target;
+      } else if (!entry.defaultTarget) {
+        entry.defaultTarget = target;
+      }
+
+      decisionOutgoingByCanvasId[sourceId] = entry;
+      await maybeYield();
+      continue;
+    }
+
+    const branchPath = branchPathByCanvasId[sourceId];
+    const defaultBranchKey = defaultBranchKeyByCanvasId[sourceId];
+
+    if (branchPath) {
+      const entry = conditionalEdgesMap[source] ?? {
+        path: branchPath,
+        mapping: {},
+        defaultTarget: undefined,
+      };
+
+      if (rawHandle && defaultBranchKey && rawHandle === defaultBranchKey) {
+        entry.defaultTarget = target;
+      } else if (rawHandle) {
+        entry.mapping[rawHandle] = target;
+      } else if (!rawHandle && defaultBranchKey) {
+        entry.defaultTarget = target;
+      }
+
+      conditionalEdgesMap[source] = entry;
+      await maybeYield();
+      continue;
+    }
+
+    graphEdges.push({ source, target });
+    await maybeYield();
+  }
+
+  for (const [source, entry] of Object.entries(conditionalEdgesMap)) {
+    if (Object.keys(entry.mapping).length === 0 && !entry.defaultTarget) {
+      await maybeYield();
+      continue;
+    }
+    const payload: ConditionalEdge = {
+      source,
+      path: entry.path,
+      mapping: entry.mapping,
+    };
+    if (entry.defaultTarget) {
+      payload.default = entry.defaultTarget;
+    }
+    conditionalEdges.push(payload);
+    await maybeYield();
+  }
+
+  for (const [decisionId, sources] of Object.entries(
+    decisionSourcesByCanvasId,
+  )) {
+    const decisionName = decisionNodeNameByCanvasId[decisionId];
+    const outgoing = decisionOutgoingByCanvasId[decisionId];
+    if (!decisionName || !outgoing) {
+      await maybeYield();
+      continue;
+    }
+    if (Object.keys(outgoing.mapping).length === 0 && !outgoing.defaultTarget) {
+      await maybeYield();
+      continue;
+    }
+    const sourceList = sources.size > 0 ? Array.from(sources) : [decisionName];
+    for (const source of sourceList) {
+      const payload: ConditionalEdge = {
+        source,
+        path: decisionName,
+        mapping: { ...outgoing.mapping },
+      };
+      if (outgoing.defaultTarget) {
+        payload.default = outgoing.defaultTarget;
+      }
+      conditionalEdges.push(payload);
+      await maybeYield();
+    }
+  }
+
+  return { graphEdges, conditionalEdges };
+};

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

@@ -0,0 +1,30 @@
+import {
+  ensureUniqueName,
+  slugify,
+} from "@features/workflow/lib/graph-config/utils";
+import type {
+  CanvasNode,
+  GraphNameMaps,
+  MaybeYieldFn,
+} from "@features/workflow/lib/graph-config/types";
+
+export const buildGraphNameMaps = async (
+  nodes: CanvasNode[],
+  maybeYield: MaybeYieldFn,
+): Promise<GraphNameMaps> => {
+  const canvasToGraph: Record<string, string> = {};
+  const graphToCanvas: Record<string, string> = {};
+  const usedNames = new Set<string>();
+
+  for (let index = 0; index < nodes.length; index += 1) {
+    const node = nodes[index];
+    const label = String(node.data?.label ?? node.id ?? `node-${index + 1}`);
+    const base = slugify(label, `node-${index + 1}`);
+    const unique = ensureUniqueName(base, usedNames);
+    canvasToGraph[node.id] = unique;
+    graphToCanvas[unique] = node.id;
+    await maybeYield();
+  }
+
+  return { canvasToGraph, graphToCanvas };
+};

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

@@ -0,0 +1,171 @@
+import type { CanvasNode } from "@features/workflow/lib/graph-config/types";
+
+interface BranchingContext {
+  node: CanvasNode;
+  data: Record<string, unknown>;
+  nodeConfig: Record<string, unknown>;
+  canvasToGraph: Record<string, string>;
+  branchPathByCanvasId: Record<string, string>;
+  defaultBranchKeyByCanvasId: Record<string, string | undefined>;
+}
+
+interface DecisionNodeParams {
+  node: CanvasNode;
+  backendType: string;
+  baseConfig: Record<string, unknown>;
+}
+
+export const createDecisionEdgeNodeConfig = ({
+  node,
+  backendType,
+  baseConfig,
+}: DecisionNodeParams): Record<string, unknown> => {
+  const data = node.data ?? {};
+  const edgeNodeConfig: Record<string, unknown> = { ...baseConfig };
+
+  if (backendType === "IfElseNode") {
+    const conditionsRaw = Array.isArray(data?.conditions)
+      ? (data.conditions as Array<Record<string, unknown>>)
+      : [];
+    const normalisedConditions =
+      conditionsRaw.length > 0
+        ? conditionsRaw
+        : [
+            {
+              left: null,
+              operator: "equals",
+              right: null,
+              caseSensitive: true,
+            },
+          ];
+
+    edgeNodeConfig.conditions = normalisedConditions.map(
+      (condition, conditionIndex) => ({
+        left: condition?.left ?? null,
+        operator:
+          typeof condition?.operator === "string"
+            ? (condition.operator as string)
+            : "equals",
+        right: condition?.right ?? null,
+        case_sensitive:
+          typeof condition?.caseSensitive === "boolean"
+            ? (condition.caseSensitive as boolean)
+            : true,
+        id:
+          typeof condition?.id === "string"
+            ? condition.id
+            : `condition-${conditionIndex + 1}`,
+      }),
+    );
+    edgeNodeConfig.condition_logic =
+      typeof data?.conditionLogic === "string" ? data.conditionLogic : "and";
+  }
+
+  return edgeNodeConfig;
+};
+
+export const applySwitchConfig = ({
+  node,
+  data,
+  nodeConfig,
+  canvasToGraph,
+  branchPathByCanvasId,
+  defaultBranchKeyByCanvasId,
+}: BranchingContext): void => {
+  const casesRaw = Array.isArray(data?.cases)
+    ? (data.cases as Array<Record<string, unknown>>)
+    : [];
+  const normalisedCases =
+    casesRaw.length > 0
+      ? casesRaw
+      : [
+          {
+            label: "Case 1",
+            match: null,
+            branchKey: "case_1",
+          },
+        ];
+
+  nodeConfig.value = data?.value ?? null;
+  nodeConfig.case_sensitive = data?.caseSensitive ?? true;
+  nodeConfig.cases = normalisedCases.map((caseEntry, caseIndex) => {
+    const rawBranchKey =
+      typeof caseEntry?.branchKey === "string" &&
+      caseEntry.branchKey.trim().length > 0
+        ? (caseEntry.branchKey as string).trim()
+        : `case_${caseIndex + 1}`;
+    return {
+      label:
+        typeof caseEntry?.label === "string"
+          ? (caseEntry.label as string)
+          : undefined,
+      match: caseEntry?.match ?? null,
+      branch_key: rawBranchKey,
+      case_sensitive:
+        typeof caseEntry?.caseSensitive === "boolean"
+          ? (caseEntry.caseSensitive as boolean)
+          : undefined,
+    };
+  });
+
+  const defaultBranchKey =
+    typeof data?.defaultBranchKey === "string" &&
+    data.defaultBranchKey.trim().length > 0
+      ? (data.defaultBranchKey as string).trim()
+      : "default";
+  nodeConfig.default_branch_key = defaultBranchKey;
+  defaultBranchKeyByCanvasId[node.id] = defaultBranchKey;
+  branchPathByCanvasId[node.id] = `results.${canvasToGraph[node.id]}.branch`;
+};
+
+export const applyWhileConfig = ({
+  node,
+  data,
+  nodeConfig,
+  canvasToGraph,
+  branchPathByCanvasId,
+}: Omit<BranchingContext, "defaultBranchKeyByCanvasId">): void => {
+  const conditionsRaw = Array.isArray(data?.conditions)
+    ? (data.conditions as Array<Record<string, unknown>>)
+    : [];
+  const normalisedConditions =
+    conditionsRaw.length > 0
+      ? conditionsRaw
+      : [
+          {
+            left: null,
+            operator: "less_than",
+            right: null,
+            caseSensitive: true,
+          },
+        ];
+
+  nodeConfig.conditions = normalisedConditions.map(
+    (condition, conditionIndex) => ({
+      left: condition?.left ?? null,
+      operator:
+        typeof condition?.operator === "string"
+          ? (condition.operator as string)
+          : "less_than",
+      right: condition?.right ?? null,
+      case_sensitive:
+        typeof condition?.caseSensitive === "boolean"
+          ? (condition.caseSensitive as boolean)
+          : true,
+      id:
+        typeof condition?.id === "string"
+          ? condition.id
+          : `condition-${conditionIndex + 1}`,
+    }),
+  );
+  nodeConfig.condition_logic =
+    typeof data?.conditionLogic === "string" ? data.conditionLogic : "and";
+  if (
+    typeof data?.maxIterations === "number" &&
+    Number.isFinite(data.maxIterations)
+  ) {
+    nodeConfig.max_iterations = data.maxIterations;
+  }
+
+  branchPathByCanvasId[node.id] = `results.${canvasToGraph[node.id]}.branch`;
+};

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

@@ -0,0 +1,16 @@
+export {
+  applySwitchConfig,
+  applyWhileConfig,
+  createDecisionEdgeNodeConfig,
+} from "@features/workflow/lib/graph-config/node-handlers/branching";
+export { applySetVariableConfig } from "@features/workflow/lib/graph-config/node-handlers/set-variable";
+export {
+  applyCronTriggerConfig,
+  applyDelayConfig,
+  applyHttpPollingTriggerConfig,
+  applyManualTriggerConfig,
+  applyMongoConfig,
+  applySlackConfig,
+  applyTelegramConfig,
+  applyWebhookTriggerConfig,
+} from "@features/workflow/lib/graph-config/node-handlers/integrations";