orcheo-studio 0.21.1

package/src/features/workflow/pages/workflow/hooks/execution-record-updater.ts

@@ -0,0 +1,119 @@
+import type { NodeRuntimeData } from "@features/workflow/pages/workflow/hooks/execution-runtime-updates";
+import type {
+  NodeStatus,
+  WorkflowExecution,
+  WorkflowExecutionStatus,
+} from "@features/workflow/pages/workflow/helpers/types";
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+interface ExecutionRecordUpdateParams {
+  execution: WorkflowExecution;
+  executionStatus: WorkflowExecutionStatus | null;
+  nodeUpdates: Record<string, NodeStatus>;
+  runtimeUpdates: Record<string, NodeRuntimeData>;
+  logLevel: "INFO" | "DEBUG" | "ERROR" | "WARNING";
+  message: string;
+  timestamp: Date;
+  graphToWorkflow: Record<string, string>;
+}
+
+export function updateExecutionRecord({
+  execution,
+  executionStatus,
+  nodeUpdates,
+  runtimeUpdates,
+  logLevel,
+  message,
+  timestamp,
+  graphToWorkflow,
+}: ExecutionRecordUpdateParams): WorkflowExecution {
+  const updatedNodes = execution.nodes.map((node) => {
+    const nextStatus = nodeUpdates[node.id];
+    const runtime = runtimeUpdates[node.id];
+    let updatedNode = node;
+    if (nextStatus) {
+      updatedNode = { ...updatedNode, status: nextStatus };
+    } else if (
+      executionStatus &&
+      executionStatus !== "running" &&
+      node.status === "running"
+    ) {
+      const fallback: NodeStatus =
+        executionStatus === "failed"
+          ? "error"
+          : executionStatus === "partial"
+            ? "warning"
+            : "success";
+      updatedNode = { ...updatedNode, status: fallback };
+    }
+
+    if (runtime) {
+      const existingDetails =
+        node.details && isRecord(node.details)
+          ? (node.details as Record<string, unknown>)
+          : {};
+      const nextDetails: Record<string, unknown> = {
+        ...existingDetails,
+      };
+      if (runtime.inputs !== undefined) {
+        nextDetails.inputs = runtime.inputs;
+      }
+      if (runtime.outputs !== undefined) {
+        nextDetails.outputs = runtime.outputs;
+      }
+      if (runtime.messages !== undefined) {
+        nextDetails.messages = runtime.messages;
+      }
+      nextDetails.raw = runtime.raw;
+      nextDetails.updatedAt = runtime.updatedAt;
+      updatedNode = { ...updatedNode, details: nextDetails };
+    }
+
+    return updatedNode;
+  });
+
+  const logs = [
+    ...execution.logs,
+    {
+      timestamp: timestamp.toLocaleTimeString([], {
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+      }),
+      level: logLevel,
+      message,
+    },
+  ];
+
+  const duration =
+    timestamp.getTime() - new Date(execution.startTime).getTime();
+
+  const issues = logLevel === "ERROR" ? execution.issues + 1 : execution.issues;
+
+  const metadata = {
+    ...(execution.metadata ?? {}),
+    graphToWorkflow: {
+      ...(execution.metadata?.graphToWorkflow ?? {}),
+      ...graphToWorkflow,
+    },
+  };
+
+  const status = executionStatus ?? execution.status;
+  const endTime =
+    executionStatus && executionStatus !== "running"
+      ? timestamp.toISOString()
+      : execution.endTime;
+
+  return {
+    ...execution,
+    status,
+    nodes: updatedNodes,
+    logs,
+    duration,
+    issues,
+    endTime,
+    metadata,
+  };
+}

package/src/features/workflow/pages/workflow/hooks/execution-record.ts

@@ -0,0 +1,31 @@
+import type { WorkflowExecution } from "@features/workflow/pages/workflow/helpers/types";
+
+export function createExecutionRecord(
+  executionId: string,
+  graphToWorkflow: Record<string, string>,
+): WorkflowExecution {
+  const startTime = new Date();
+
+  return {
+    id: executionId,
+    runId: executionId,
+    status: "running",
+    startTime: startTime.toISOString(),
+    duration: 0,
+    issues: 0,
+    nodes: [],
+    edges: [],
+    logs: [
+      {
+        timestamp: startTime.toLocaleTimeString([], {
+          hour: "2-digit",
+          minute: "2-digit",
+          second: "2-digit",
+        }),
+        level: "INFO" as const,
+        message: "Workflow execution started",
+      },
+    ],
+    metadata: { graphToWorkflow },
+  };
+}

package/src/features/workflow/pages/workflow/hooks/execution-runtime-updates.ts

@@ -0,0 +1,96 @@
+import type { NodeStatus } from "@features/workflow/pages/workflow/helpers/types";
+
+export interface NodeRuntimeData {
+  inputs?: unknown;
+  outputs?: unknown;
+  messages?: unknown;
+  raw?: unknown;
+  updatedAt: string;
+}
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+// Kept for callers that pass node status updates alongside runtime data
+export type { NodeStatus };
+
+export function collectRuntimeUpdates(
+  payload: Record<string, unknown>,
+  graphToWorkflow: Record<string, string>,
+  updatedAt: string,
+): Record<string, NodeRuntimeData> {
+  const runtimeUpdates: Record<string, NodeRuntimeData> = {};
+  Object.entries(payload).forEach(([key, value]) => {
+    if (typeof key !== "string") {
+      return;
+    }
+    if (
+      key === "status" ||
+      key === "level" ||
+      key === "error" ||
+      key === "message" ||
+      key === "type" ||
+      key === "timestamp" ||
+      key === "step"
+    ) {
+      return;
+    }
+    const workflowNodeId = graphToWorkflow[key] ?? null;
+    if (!workflowNodeId) {
+      return;
+    }
+    if (!isRecord(value)) {
+      return;
+    }
+
+    const resultsCandidate = value["results"];
+    let candidatePayload: unknown;
+
+    if (isRecord(resultsCandidate)) {
+      candidatePayload =
+        resultsCandidate[key] ??
+        resultsCandidate[workflowNodeId] ??
+        Object.values(resultsCandidate)[0];
+    }
+
+    if (candidatePayload === undefined) {
+      const directValue =
+        typeof value[key] !== "undefined" ? value[key] : undefined;
+      if (directValue !== undefined) {
+        candidatePayload = directValue;
+      }
+    }
+
+    if (candidatePayload === undefined && value["value"] !== undefined) {
+      candidatePayload = value["value"];
+    }
+
+    if (candidatePayload === undefined) {
+      candidatePayload = value;
+    }
+
+    let inputs: unknown;
+    let outputs: unknown;
+    let messages: unknown;
+    if (isRecord(candidatePayload)) {
+      inputs =
+        candidatePayload["inputs"] !== undefined
+          ? candidatePayload["inputs"]
+          : candidatePayload["input"];
+      outputs =
+        candidatePayload["outputs"] !== undefined
+          ? candidatePayload["outputs"]
+          : (candidatePayload["output"] ?? candidatePayload["result"]);
+      messages = candidatePayload["messages"];
+    }
+
+    runtimeUpdates[workflowNodeId] = {
+      ...(inputs !== undefined ? { inputs } : {}),
+      ...(outputs !== undefined ? { outputs } : {}),
+      ...(messages !== undefined ? { messages } : {}),
+      raw: candidatePayload,
+      updatedAt,
+    };
+  });
+  return runtimeUpdates;
+}