@duraton/react 0.1.0-beta.7

package/src/index.ts

@@ -0,0 +1,111 @@
+export { DuratonProvider, useDuratonClient } from "./provider";
+export { ACTIVE_STATUSES, TERMINAL_STATUSES } from "./run-status";
+export { useRuns } from "./hooks/use-runs";
+export { useRunStats } from "./hooks/use-run-stats";
+export { useRunsStream } from "./hooks/use-runs-stream";
+export { useRun, useRunSteps } from "./hooks/use-run";
+export { useRunStream } from "./hooks/use-run-stream";
+export { useWorkflows } from "./hooks/use-workflows";
+export {
+  useCancelRun,
+  usePauseRun,
+  useResumeRun,
+  useReplayRun,
+  useRetryFromStep,
+  useBulkReplay,
+} from "./hooks/use-run-controls";
+export { useControlActions } from "./hooks/use-control-actions";
+export { useRunTimeSeries } from "./hooks/use-run-timeseries";
+export { useFlowState } from "./hooks/use-flow-state";
+export { useRunners } from "./hooks/use-runners";
+export { useApps } from "./hooks/use-apps";
+export type { AppInfo, AppStatus, AppWorkflow } from "./hooks/use-apps";
+export { useEvents, useTriggerEvent } from "./hooks/use-events";
+export {
+  useDeliveries,
+  useDelivery,
+  useEndpoints,
+  useReceivers,
+  useEndpointStats,
+} from "./hooks/use-deliveries";
+export {
+  useCreateEndpoint,
+  useUpdateEndpoint,
+  useDeleteEndpoint,
+  useCreateReceiver,
+  useUpdateReceiver,
+  useDeleteReceiver,
+  useRedeliverDelivery,
+} from "./hooks/use-webhook-config";
+
+export {
+  createClient,
+  RUN_STATUSES,
+  STEP_STATUSES,
+  CONTROL_ACTION_KINDS,
+  DELIVERY_STATUSES,
+  DELIVERY_EVENT_KINDS,
+  SUBSCRIBABLE_EVENT_KINDS,
+  ATTEMPT_OUTCOMES,
+  SIGNING_SCHEMES,
+} from "@duraton/sdk/client";
+export type {
+  ClientOptions,
+  DuratonClient,
+  Run,
+  Step,
+  StepErrorInfo,
+  RunStatus,
+  StepStatus,
+  LogLevel,
+  TriggerKind,
+  RunStats,
+  RunStatsOptions,
+  ListRunsOptions,
+  RunsPage,
+  LogFrame,
+  TimelineFrame,
+  RunStatusFrame,
+  StepStatusFrame,
+  WorkflowDef,
+  WorkflowSchedule,
+  WorkflowTrigger,
+  Runner,
+  EventSource,
+  EventLogRecord,
+  TriggeredOutcome,
+  SendEventInput,
+  SendEventResult,
+  FlowControl,
+  RunSeries,
+  RunSeriesBucket,
+  RunTimeSeriesOptions,
+  FlowState,
+  FlowStateOptions,
+  DebounceBacklog,
+  BatchBacklog,
+  ControlAction,
+  ControlActionKind,
+  ListControlActionsOptions,
+  BulkReplayFilter,
+  BulkReplayResult,
+  DeliveryStatus,
+  DeliveryEventKind,
+  SubscribableEventKind,
+  AttemptOutcome,
+  SigningScheme,
+  WebhookDelivery,
+  WebhookDeliveryAttempt,
+  WebhookDeliveryDetail,
+  WebhookEndpoint,
+  WebhookReceiver,
+  WebhookEndpointStats,
+  WebhookEndpointWithSecret,
+  WebhookReceiverWithSecret,
+  EndpointInput,
+  EndpointPatch,
+  ReceiverInput,
+  ReceiverPatch,
+  ListWebhookDeliveriesOptions,
+  WebhookDeliveriesPage,
+} from "@duraton/sdk/client";

package/src/lib/stream.ts

@@ -0,0 +1,18 @@
+// Backoff before reconnecting a dropped (non-terminal) SSE stream.
+export const RECONNECT_MS = 1000;
+
+// Resolves after ms, or immediately when the signal aborts (clearing its timer
+// either way). Used by the SSE reconnect loops.
+export function abortableDelay(ms: number, signal: AbortSignal): Promise<void> {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    signal.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        resolve();
+      },
+      { once: true },
+    );
+  });
+}

package/src/provider.tsx

@@ -0,0 +1,22 @@
+import { createContext, useContext, type ReactNode } from "react";
+import type { DuratonClient } from "@duraton/sdk/client";
+
+const ClientContext = createContext<DuratonClient | null>(null);
+
+export function DuratonProvider({
+  client,
+  children,
+}: {
+  client: DuratonClient;
+  children: ReactNode;
+}) {
+  return <ClientContext.Provider value={client}>{children}</ClientContext.Provider>;
+}
+
+export function useDuratonClient(): DuratonClient {
+  const client = useContext(ClientContext);
+  if (!client) {
+    throw new Error("useDuratonClient must be used within a DuratonProvider");
+  }
+  return client;
+}

package/src/run-controls.test.tsx

@@ -0,0 +1,76 @@
+import type { ReactNode } from "react";
+import { describe, expect, it, vi } from "vitest";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { renderHook, waitFor } from "@testing-library/react";
+import type { DuratonClient, Run } from "@duraton/sdk/client";
+import { DuratonProvider } from "./provider";
+import { useControlActions } from "./hooks/use-control-actions";
+import { useBulkReplay, useCancelRun, useReplayRun } from "./hooks/use-run-controls";
+import { fakeClient, makeControlAction, makeRun } from "./test-utils";
+
+function harness(client: DuratonClient) {
+  const qc = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+  const wrapper = ({ children }: { children: ReactNode }) => (
+    <QueryClientProvider client={qc}>
+      <DuratonProvider client={client}>{children}</DuratonProvider>
+    </QueryClientProvider>
+  );
+  return { qc, wrapper };
+}
+
+describe("useControlActions", () => {
+  it("returns a run's control-action history", async () => {
+    const client = fakeClient({ controlActions: [makeControlAction({ id: "a1" })] });
+    const { wrapper } = harness(client);
+    const { result } = renderHook(() => useControlActions({ runId: "run_1" }), { wrapper });
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data?.[0]?.id).toBe("a1");
+  });
+});
+
+describe("useCancelRun", () => {
+  it("writes the updated run into the cache and invalidates the list", async () => {
+    const cancel = vi.fn(async () => makeRun({ id: "run_1", status: "cancelled" }));
+    const { qc, wrapper } = harness(fakeClient({ cancel }));
+    qc.setQueryData(["runs"], { runs: [], nextCursor: null });
+    const { result } = renderHook(() => useCancelRun(), { wrapper });
+
+    await result.current.mutateAsync("run_1");
+
+    expect(cancel).toHaveBeenCalledWith("run_1");
+    expect((qc.getQueryData(["run", "run_1"]) as Run).status).toBe("cancelled");
+    expect(qc.getQueryState(["runs"])?.isInvalidated).toBe(true);
+  });
+});
+
+describe("useReplayRun", () => {
+  it("forks with the optional edited input", async () => {
+    const replay = vi.fn(async () => makeRun({ id: "run_fork" }));
+    const { wrapper } = harness(fakeClient({ replay }));
+    const { result } = renderHook(() => useReplayRun(), { wrapper });
+
+    const forked = await result.current.mutateAsync({ runId: "run_1", input: { a: 1 } });
+
+    expect(replay).toHaveBeenCalledWith("run_1", { a: 1 });
+    expect(forked.id).toBe("run_fork");
+  });
+});
+
+describe("useBulkReplay", () => {
+  it("replays the filter and returns the outcome counts", async () => {
+    const bulkReplay = vi.fn(async () => ({
+      matched: 4,
+      replayed: 4,
+      skipped: 0,
+      failed: 0,
+      capped: false,
+    }));
+    const { wrapper } = harness(fakeClient({ bulkReplay }));
+    const { result } = renderHook(() => useBulkReplay(), { wrapper });
+
+    const res = await result.current.mutateAsync({ app: "default" });
+
+    expect(bulkReplay).toHaveBeenCalledWith({ app: "default" });
+    expect(res.replayed).toBe(4);
+  });
+});

package/src/run-status.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest";
+import { ACTIVE_STATUSES, TERMINAL_STATUSES } from "./run-status";
+
+describe("run status sets", () => {
+  it("treats queued/running/waiting as active, not terminal", () => {
+    for (const s of ["queued", "running", "waiting"] as const) {
+      expect(ACTIVE_STATUSES.has(s)).toBe(true);
+      expect(TERMINAL_STATUSES.has(s)).toBe(false);
+    }
+  });
+
+  it("treats succeeded/failed/cancelled as terminal, not active", () => {
+    for (const s of ["succeeded", "failed", "cancelled"] as const) {
+      expect(TERMINAL_STATUSES.has(s)).toBe(true);
+      expect(ACTIVE_STATUSES.has(s)).toBe(false);
+    }
+  });
+
+  it("treats paused as neither active nor terminal", () => {
+    expect(ACTIVE_STATUSES.has("paused")).toBe(false);
+    expect(TERMINAL_STATUSES.has("paused")).toBe(false);
+  });
+});

package/src/run-status.ts

@@ -0,0 +1,8 @@
+import type { RunStatus } from "@duraton/sdk/client";
+
+export const ACTIVE_STATUSES: ReadonlySet<RunStatus> = new Set(["queued", "running", "waiting"]);
+export const TERMINAL_STATUSES: ReadonlySet<RunStatus> = new Set([
+  "succeeded",
+  "failed",
+  "cancelled",
+]);

package/src/test-utils.tsx

@@ -0,0 +1,105 @@
+import type { ReactNode } from "react";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import type {
+  BulkReplayResult,
+  ControlAction,
+  DuratonClient,
+  Run,
+  RunStats,
+  Step,
+  TimelineFrame,
+  WorkflowDef,
+} from "@duraton/sdk/client";
+import { DuratonProvider } from "./provider";
+
+export function makeRun(overrides: Partial<Run> = {}): Run {
+  return {
+    id: "run_1",
+    workflowName: "sendEmail",
+    app: "default",
+    status: "succeeded",
+    errorCount: 0,
+    attempt: 1,
+    triggerKind: "event",
+    stepCount: 0,
+    currentStepIndex: -1,
+    startedAt: "2026-07-01T00:00:00.000Z",
+    ...overrides,
+  };
+}
+
+export function makeStats(overrides: Partial<RunStats> = {}): RunStats {
+  return {
+    total: 0,
+    active: 0,
+    queued: 0,
+    running: 0,
+    succeeded: 0,
+    failed: 0,
+    successRate: 0,
+    ...overrides,
+  };
+}
+
+async function* framesOf(frames: TimelineFrame[]): AsyncGenerator<TimelineFrame> {
+  for (const f of frames) yield f;
+}
+
+export function makeControlAction(overrides: Partial<ControlAction> = {}): ControlAction {
+  return { id: "act_1", action: "replay", createdAt: "2026-07-01T00:00:00.000Z", ...overrides };
+}
+
+const DEFAULT_BULK: BulkReplayResult = {
+  matched: 0,
+  replayed: 0,
+  skipped: 0,
+  failed: 0,
+  capped: false,
+};
+
+export interface FakeClientOptions {
+  runs?: Run[];
+  run?: Run;
+  steps?: Step[];
+  stats?: RunStats;
+  workflows?: WorkflowDef[];
+  frames?: TimelineFrame[];
+  controlActions?: ControlAction[];
+  cancel?: (id: string) => Promise<Run>;
+  pause?: (id: string) => Promise<Run>;
+  resume?: (id: string) => Promise<Run>;
+  replay?: (id: string, input?: unknown) => Promise<Run>;
+  retryFromStep?: (id: string, step: string) => Promise<Run>;
+  bulkReplay?: (filter: unknown) => Promise<BulkReplayResult>;
+}
+
+export function fakeClient(opts: FakeClientOptions = {}): DuratonClient {
+  const run = async () => opts.run ?? makeRun();
+  return {
+    runs: {
+      list: async () => ({ runs: opts.runs ?? [], nextCursor: null }),
+      get: async () => opts.run ?? makeRun(),
+      steps: async () => opts.steps ?? [],
+      stats: async () => opts.stats ?? makeStats(),
+      watch: () => framesOf(opts.frames ?? []),
+      watchAll: () => framesOf(opts.frames ?? []),
+      cancel: opts.cancel ?? run,
+      pause: opts.pause ?? run,
+      resume: opts.resume ?? run,
+      replay: opts.replay ?? run,
+      retryFromStep: opts.retryFromStep ?? run,
+      bulkReplay: opts.bulkReplay ?? (async () => DEFAULT_BULK),
+      controlActions: async () => opts.controlActions ?? [],
+    },
+    workflows: { list: async () => opts.workflows ?? [] },
+  } as unknown as DuratonClient;
+}
+
+export function wrapper(client: DuratonClient) {
+  const qc = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+  return ({ children }: { children: ReactNode }) => (
+    <QueryClientProvider client={qc}>
+      <DuratonProvider client={client}>{children}</DuratonProvider>
+    </QueryClientProvider>
+  );
+}