@ryanfw/prompt-orchestration-pipeline 1.3.2 → 1.3.4

package/src/ui/client/hooks/useJobListWithUpdates.ts

@@ -1,29 +1,31 @@
 import { useEffect, useRef, useState } from "react";
 
-import { adaptJobSummary } from "../adapters/job-adapter";
+import { parseSseEvent, type SseEvent } from "../../../config/sse-events.ts";
 import { useJobList } from "./useJobList";
+import { applyJobEvent } from "../reducers/job-events.ts";
 import type {
   ConnectionStatus,
   NormalizedJobSummary,
-  SseJobEvent,
   UseJobListWithUpdatesResult,
 } from "../types";
 
-const REFETCH_EVENTS = new Set(["seed:uploaded", "state:change", "state:summary"]);
+export { applyJobEvent };
+
+const REFETCH_EVENTS = new Set<SseEvent["type"]>(["seed:uploaded", "state:change", "state:summary"]);
 const RECONNECT_DELAY_MS = 2_000;
 const REFETCH_DEBOUNCE_MS = 300;
 
-function sortNormalizedJobs(jobs: NormalizedJobSummary[]): NormalizedJobSummary[] {
-  const priority: Record<string, number> = {
-    running: 4,
-    waiting: 4,
-    failed: 3,
-    pending: 2,
-    complete: 1,
-  };
+const STATUS_PRIORITY: Record<string, number> = {
+  running: 4,
+  waiting: 4,
+  failed: 3,
+  pending: 2,
+  complete: 1,
+};
 
+function sortNormalizedJobs(jobs: NormalizedJobSummary[]): NormalizedJobSummary[] {
   return jobs.slice().sort((left, right) => {
-    const statusOrder = (priority[right.status] ?? 0) - (priority[left.status] ?? 0);
+    const statusOrder = (STATUS_PRIORITY[right.status] ?? 0) - (STATUS_PRIORITY[left.status] ?? 0);
     if (statusOrder !== 0) return statusOrder;
     const leftCreated = left.createdAt ?? "";
     const rightCreated = right.createdAt ?? "";
@@ -33,67 +35,37 @@ function sortNormalizedJobs(jobs: NormalizedJobSummary[]): NormalizedJobSummary[
   });
 }
 
-function completedCountFromTasks(job: NormalizedJobSummary): number {
-  return Object.values(job.tasks).filter((task) => task.state === "done" || task.state === "skipped").length;
+export function shouldRefetchForListEvent(type: SseEvent["type"]): boolean {
+  return REFETCH_EVENTS.has(type);
 }
 
-function comparableJob(job: NormalizedJobSummary): Record<string, unknown> {
-  const comparable: Record<string, unknown> = { ...job };
-  for (const [key, value] of Object.entries(comparable)) {
-    if (value === undefined) delete comparable[key];
+export type ListMessageAction =
+  | { kind: "refetch" }
+  | { kind: "apply"; event: SseEvent };
+
+export function handleListSseMessage(
+  type: string,
+  rawData: string,
+): ListMessageAction {
+  let parsedData: unknown;
+  try {
+    parsedData = JSON.parse(rawData);
+  } catch (error) {
+    console.warn("useJobListWithUpdates: failed to parse SSE payload", error);
+    return { kind: "refetch" };
   }
-  if (comparable["completedCount"] === completedCountFromTasks(job)) {
-    delete comparable["completedCount"];
-  }
-  return comparable;
-}
 
-function jobsEqual(left: NormalizedJobSummary[], right: NormalizedJobSummary[]): boolean {
-  return JSON.stringify(left.map(comparableJob)) === JSON.stringify(right.map(comparableJob));
-}
-
-function mergeJob(current: NormalizedJobSummary, incoming: NormalizedJobSummary): NormalizedJobSummary {
-  return {
-    ...current,
-    ...incoming,
-    id: incoming.id || current.id,
-    jobId: incoming.jobId || current.jobId,
-    name: incoming.name || current.name,
-    createdAt: incoming.createdAt ?? current.createdAt,
-    updatedAt: incoming.updatedAt ?? current.updatedAt,
-    pipeline: incoming.pipeline ?? current.pipeline,
-    pipelineLabel: incoming.pipelineLabel ?? current.pipelineLabel,
-    current: incoming.current ?? current.current,
-    currentStage: incoming.currentStage ?? current.currentStage,
-  };
-}
-
-export function applyJobEvent(
-  jobs: NormalizedJobSummary[],
-  event: SseJobEvent,
-): NormalizedJobSummary[] {
-  const incoming = adaptJobSummary(event.data);
-  const key = incoming.jobId;
-
-  if (event.type === "job:removed") {
-    const next = jobs.filter((job) => job.jobId !== key);
-    return jobsEqual(next, jobs) ? jobs : sortNormalizedJobs(next);
+  const event = parseSseEvent(type, parsedData);
+  if (event === null) {
+    console.warn(`useJobListWithUpdates: dropping invalid SSE event of type "${type}"`);
+    return { kind: "refetch" };
   }
 
-  if (event.type === "job:created" || event.type === "job:updated") {
-    const existingIndex = jobs.findIndex((job) => job.jobId === key);
-    const next = existingIndex === -1
-      ? [...jobs, incoming]
-      : jobs.map((job, index) => index === existingIndex ? mergeJob(job, incoming) : job);
-    const sorted = sortNormalizedJobs(next);
-    return jobsEqual(sorted, jobs) ? jobs : sorted;
+  if (shouldRefetchForListEvent(event.type)) {
+    return { kind: "refetch" };
   }
 
-  return jobs;
-}
-
-export function shouldRefetchForListEvent(type: string): boolean {
-  return REFETCH_EVENTS.has(type);
+  return { kind: "apply", event };
 }
 
 export function useJobListWithUpdates(): UseJobListWithUpdatesResult {
@@ -102,7 +74,7 @@ export function useJobListWithUpdates(): UseJobListWithUpdatesResult {
   const [connectionStatus, setConnectionStatus] = useState<ConnectionStatus>("disconnected");
   const hydratedRef = useRef(false);
   const dataRef = useRef<NormalizedJobSummary[] | null>(null);
-  const queueRef = useRef<SseJobEvent[]>([]);
+  const queueRef = useRef<SseEvent[]>([]);
   const eventSourceRef = useRef<EventSource | null>(null);
   const reconnectTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   const refetchTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
@@ -155,27 +127,21 @@ export function useJobListWithUpdates(): UseJobListWithUpdatesResult {
       };
 
       const onMessage = (event: MessageEvent<string>) => {
-        let payload: SseJobEvent | null = null;
-        try {
-          payload = { type: event.type as SseJobEvent["type"], data: JSON.parse(event.data) as Record<string, unknown> };
-        } catch (error) {
-          console.warn("Failed to parse job list SSE payload", error);
-          return;
-        }
+        const result = handleListSseMessage(event.type, event.data);
 
-        if (shouldRefetchForListEvent(payload.type)) {
+        if (result.kind === "refetch") {
           scheduleRefetch();
           return;
         }
 
         if (!hydratedRef.current || refetchingRef.current) {
-          queueRef.current.push(payload);
+          queueRef.current.push(result.event);
           return;
         }
 
         setData((current) => {
           if (current === null) return current;
-          const next = applyJobEvent(current, payload);
+          const next = applyJobEvent(current, result.event);
           dataRef.current = next;
           return next;
         });

package/src/ui/client/load-state.ts

@@ -0,0 +1,20 @@
+import type { ApiError } from "./types";
+
+export interface LoadState<T> {
+  data: T | null;
+  error: ApiError | null;
+}
+
+export type LoadResult<T> =
+  | { ok: true; data: T }
+  | { ok: false; error: ApiError };
+
+export function nextLoadState<T>(
+  prev: LoadState<T>,
+  result: LoadResult<T>,
+): LoadState<T> {
+  if (result.ok) {
+    return { data: result.data, error: null };
+  }
+  return { data: prev.data, error: result.error };
+}