@coji/durably-react 0.6.0 → 0.6.1

package/dist/index.js

@@ -1,3 +1,9 @@
+import {
+  initialSubscriptionState,
+  subscriptionReducer,
+  useSubscription
+} from "./chunk-M3YA2EA4.js";
+
 // src/context.tsx
 import { Suspense, createContext, use, useContext } from "react";
 import { jsx } from "react/jsx-runtime";
@@ -29,176 +35,228 @@ function useDurably() {
 }
 
 // src/hooks/use-job.ts
-import { useCallback, useEffect, useRef, useState } from "react";
-function useJob(jobDefinition, options) {
-  const { durably } = useDurably();
-  const [status, setStatus] = useState(null);
-  const [output, setOutput] = useState(null);
-  const [error, setError] = useState(null);
-  const [logs, setLogs] = useState([]);
-  const [progress, setProgress] = useState(null);
-  const [currentRunId, setCurrentRunId] = useState(
-    options?.initialRunId ?? null
-  );
-  const jobHandleRef = useRef(null);
-  const currentRunIdRef = useRef(currentRunId);
-  currentRunIdRef.current = currentRunId;
+import { useCallback as useCallback2, useEffect as useEffect3, useMemo, useRef as useRef2 } from "react";
+
+// src/hooks/use-auto-resume.ts
+import { useEffect } from "react";
+function useAutoResume(jobHandle, options, callbacks) {
+  const enabled = options.enabled !== false;
+  const skipIfInitialRunId = options.skipIfInitialRunId !== false;
+  const initialRunId = options.initialRunId;
   useEffect(() => {
+    if (!jobHandle) return;
+    if (!enabled) return;
+    if (skipIfInitialRunId && initialRunId) return;
+    let cancelled = false;
+    const findActiveRun = async () => {
+      const runningRuns = await jobHandle.getRuns({ status: "running" });
+      if (cancelled) return;
+      if (runningRuns.length > 0) {
+        const run = runningRuns[0];
+        callbacks.onRunFound(run.id, run.status);
+        return;
+      }
+      const pendingRuns = await jobHandle.getRuns({ status: "pending" });
+      if (cancelled) return;
+      if (pendingRuns.length > 0) {
+        const run = pendingRuns[0];
+        callbacks.onRunFound(run.id, run.status);
+      }
+    };
+    findActiveRun();
+    return () => {
+      cancelled = true;
+    };
+  }, [jobHandle, enabled, skipIfInitialRunId, initialRunId, callbacks]);
+}
+
+// src/hooks/use-job-subscription.ts
+import { useCallback, useEffect as useEffect2, useReducer, useRef } from "react";
+function jobSubscriptionReducer(state, action) {
+  switch (action.type) {
+    case "set_run_id":
+      return { ...state, currentRunId: action.runId };
+    case "switch_to_run":
+      return {
+        ...initialSubscriptionState,
+        currentRunId: action.runId,
+        status: "running"
+      };
+    case "reset":
+      return {
+        ...initialSubscriptionState,
+        currentRunId: null
+      };
+    default:
+      return {
+        ...subscriptionReducer(state, action),
+        currentRunId: state.currentRunId
+      };
+  }
+}
+function useJobSubscription(durably, jobName, options) {
+  const initialState = {
+    ...initialSubscriptionState,
+    currentRunId: null
+  };
+  const [state, dispatch] = useReducer(
+    jobSubscriptionReducer,
+    initialState
+  );
+  const currentRunIdRef = useRef(null);
+  currentRunIdRef.current = state.currentRunId;
+  const followLatest = options?.followLatest !== false;
+  const maxLogs = options?.maxLogs ?? 0;
+  useEffect2(() => {
     if (!durably) return;
-    const d = durably.register({
-      _job: jobDefinition
-    });
-    const jobHandle = d.jobs._job;
-    jobHandleRef.current = jobHandle;
     const unsubscribes = [];
     unsubscribes.push(
       durably.on("run:start", (event) => {
-        if (event.jobName !== jobDefinition.name) return;
-        if (options?.followLatest === false) {
+        if (event.jobName !== jobName) return;
+        if (followLatest) {
+          dispatch({ type: "switch_to_run", runId: event.runId });
+          currentRunIdRef.current = event.runId;
+        } else {
           if (event.runId !== currentRunIdRef.current) return;
-          setStatus("running");
-          return;
+          dispatch({ type: "run:start" });
         }
-        setCurrentRunId(event.runId);
-        currentRunIdRef.current = event.runId;
-        setStatus("running");
-        setOutput(null);
-        setError(null);
-        setLogs([]);
-        setProgress(null);
       })
     );
     unsubscribes.push(
       durably.on("run:complete", (event) => {
         if (event.runId !== currentRunIdRef.current) return;
-        setStatus("completed");
-        setOutput(event.output);
+        dispatch({ type: "run:complete", output: event.output });
       })
     );
     unsubscribes.push(
       durably.on("run:fail", (event) => {
         if (event.runId !== currentRunIdRef.current) return;
-        setStatus("failed");
-        setError(event.error);
+        dispatch({ type: "run:fail", error: event.error });
+      })
+    );
+    unsubscribes.push(
+      durably.on("run:cancel", (event) => {
+        if (event.runId !== currentRunIdRef.current) return;
+        dispatch({ type: "run:cancel" });
+      })
+    );
+    unsubscribes.push(
+      durably.on("run:retry", (event) => {
+        if (event.runId !== currentRunIdRef.current) return;
+        dispatch({ type: "run:retry" });
       })
     );
     unsubscribes.push(
       durably.on("run:progress", (event) => {
         if (event.runId !== currentRunIdRef.current) return;
-        setProgress(event.progress);
+        dispatch({ type: "run:progress", progress: event.progress });
       })
     );
     unsubscribes.push(
       durably.on("log:write", (event) => {
         if (event.runId !== currentRunIdRef.current) return;
-        setLogs((prev) => [
-          ...prev,
-          {
-            id: crypto.randomUUID(),
-            runId: event.runId,
-            stepName: event.stepName,
-            level: event.level,
-            message: event.message,
-            data: event.data,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          }
-        ]);
+        dispatch({
+          type: "log:write",
+          runId: event.runId,
+          stepName: event.stepName,
+          level: event.level,
+          message: event.message,
+          data: event.data,
+          maxLogs
+        });
       })
     );
-    if (options?.initialRunId && currentRunIdRef.current) {
-      jobHandle.getRun(currentRunIdRef.current).then((run) => {
-        if (run) {
-          setStatus(run.status);
-          if (run.status === "completed" && run.output) {
-            setOutput(run.output);
-          }
-          if (run.status === "failed" && run.error) {
-            setError(run.error);
-          }
-        }
-      });
-    }
-    if (options?.autoResume !== false && !options?.initialRunId) {
-      ;
-      (async () => {
-        const runningRuns = await jobHandle.getRuns({ status: "running" });
-        if (runningRuns.length > 0) {
-          const run = runningRuns[0];
-          setCurrentRunId(run.id);
-          currentRunIdRef.current = run.id;
-          setStatus(run.status);
-          return;
-        }
-        const pendingRuns = await jobHandle.getRuns({ status: "pending" });
-        if (pendingRuns.length > 0) {
-          const run = pendingRuns[0];
-          setCurrentRunId(run.id);
-          currentRunIdRef.current = run.id;
-          setStatus(run.status);
-        }
-      })();
-    }
     return () => {
       for (const unsubscribe of unsubscribes) {
         unsubscribe();
       }
     };
-  }, [
+  }, [durably, jobName, followLatest, maxLogs]);
+  const setCurrentRunId = useCallback((runId) => {
+    dispatch({ type: "set_run_id", runId });
+    currentRunIdRef.current = runId;
+  }, []);
+  const clearLogs = useCallback(() => {
+    dispatch({ type: "clear_logs" });
+  }, []);
+  const reset = useCallback(() => {
+    dispatch({ type: "reset" });
+    currentRunIdRef.current = null;
+  }, []);
+  return {
+    ...state,
+    setCurrentRunId,
+    clearLogs,
+    reset
+  };
+}
+
+// src/hooks/use-job.ts
+function useJob(jobDefinition, options) {
+  const { durably } = useDurably();
+  const jobHandleRef = useRef2(null);
+  useEffect3(() => {
+    if (!durably) return;
+    const d = durably.register({
+      _job: jobDefinition
+    });
+    jobHandleRef.current = d.jobs._job;
+  }, [durably, jobDefinition]);
+  const subscription = useJobSubscription(
     durably,
-    jobDefinition,
-    options?.initialRunId,
-    options?.autoResume,
-    options?.followLatest
-  ]);
-  useEffect(() => {
-    if (!durably || !currentRunId) return;
-    const jobHandle = jobHandleRef.current;
-    if (jobHandle && options?.initialRunId) {
-      jobHandle.getRun(currentRunId).then((run) => {
-        if (run) {
-          setStatus(run.status);
-          if (run.status === "completed" && run.output) {
-            setOutput(run.output);
-          }
-          if (run.status === "failed" && run.error) {
-            setError(run.error);
-          }
-        }
-      });
+    jobDefinition.name,
+    {
+      followLatest: options?.followLatest
     }
-  }, [durably, currentRunId, options?.initialRunId]);
-  const trigger = useCallback(
+  );
+  const autoResumeCallbacks = useMemo(
+    () => ({
+      onRunFound: (runId, _status) => {
+        subscription.setCurrentRunId(runId);
+      }
+    }),
+    [subscription.setCurrentRunId]
+  );
+  useAutoResume(
+    jobHandleRef.current,
+    {
+      enabled: options?.autoResume,
+      initialRunId: options?.initialRunId
+    },
+    autoResumeCallbacks
+  );
+  useEffect3(() => {
+    if (!durably || !options?.initialRunId) return;
+    const jobHandle = jobHandleRef.current;
+    if (!jobHandle) return;
+    subscription.setCurrentRunId(options.initialRunId);
+    jobHandle.getRun(options.initialRunId).then((run) => {
+      if (run) {
+      }
+    });
+  }, [durably, options?.initialRunId, subscription.setCurrentRunId]);
+  const trigger = useCallback2(
     async (input) => {
       const jobHandle = jobHandleRef.current;
       if (!jobHandle) {
         throw new Error("Job not ready");
       }
-      setOutput(null);
-      setError(null);
-      setLogs([]);
-      setProgress(null);
+      subscription.reset();
       const run = await jobHandle.trigger(input);
-      setCurrentRunId(run.id);
-      currentRunIdRef.current = run.id;
-      setStatus("pending");
+      subscription.setCurrentRunId(run.id);
       return { runId: run.id };
     },
-    []
+    [subscription]
   );
-  const triggerAndWait = useCallback(
+  const triggerAndWait = useCallback2(
     async (input) => {
       const jobHandle = jobHandleRef.current;
       if (!jobHandle || !durably) {
         throw new Error("Job not ready");
       }
-      setOutput(null);
-      setError(null);
-      setLogs([]);
-      setProgress(null);
+      subscription.reset();
       const run = await jobHandle.trigger(input);
-      setCurrentRunId(run.id);
-      currentRunIdRef.current = run.id;
-      setStatus("pending");
+      subscription.setCurrentRunId(run.id);
       return new Promise((resolve, reject) => {
         const checkCompletion = async () => {
           const updatedRun = await jobHandle.getRun(run.id);
@@ -219,135 +277,101 @@ function useJob(jobDefinition, options) {
         checkCompletion();
       });
     },
-    [durably]
+    [durably, subscription]
   );
-  const reset = useCallback(() => {
-    setStatus(null);
-    setOutput(null);
-    setError(null);
-    setLogs([]);
-    setProgress(null);
-    setCurrentRunId(null);
-  }, []);
   return {
     trigger,
     triggerAndWait,
-    status,
-    output,
-    error,
-    logs,
-    progress,
-    isRunning: status === "running",
-    isPending: status === "pending",
-    isCompleted: status === "completed",
-    isFailed: status === "failed",
-    isCancelled: status === "cancelled",
-    currentRunId,
-    reset
+    status: subscription.status,
+    output: subscription.output,
+    error: subscription.error,
+    logs: subscription.logs,
+    progress: subscription.progress,
+    isRunning: subscription.status === "running",
+    isPending: subscription.status === "pending",
+    isCompleted: subscription.status === "completed",
+    isFailed: subscription.status === "failed",
+    isCancelled: subscription.status === "cancelled",
+    currentRunId: subscription.currentRunId,
+    reset: subscription.reset
   };
 }
 
 // src/hooks/use-run-subscription.ts
-import { useEffect as useEffect2, useRef as useRef2, useState as useState2 } from "react";
-function useRunSubscription(durably, runId, options) {
-  const [status, setStatus] = useState2(null);
-  const [output, setOutput] = useState2(null);
-  const [error, setError] = useState2(null);
-  const [logs, setLogs] = useState2([]);
-  const [progress, setProgress] = useState2(null);
-  const runIdRef = useRef2(runId);
-  runIdRef.current = runId;
-  const maxLogs = options?.maxLogs ?? 0;
-  useEffect2(() => {
-    if (!durably || !runId) return;
-    const unsubscribes = [];
-    unsubscribes.push(
-      durably.on("run:start", (event) => {
-        if (event.runId !== runIdRef.current) return;
-        setStatus("running");
-      })
-    );
-    unsubscribes.push(
-      durably.on("run:complete", (event) => {
-        if (event.runId !== runIdRef.current) return;
-        setStatus("completed");
-        setOutput(event.output);
-      })
-    );
-    unsubscribes.push(
-      durably.on("run:fail", (event) => {
-        if (event.runId !== runIdRef.current) return;
-        setStatus("failed");
-        setError(event.error);
-      })
-    );
-    unsubscribes.push(
-      durably.on("run:cancel", (event) => {
-        if (event.runId !== runIdRef.current) return;
-        setStatus("cancelled");
-      })
-    );
-    unsubscribes.push(
-      durably.on("run:retry", (event) => {
-        if (event.runId !== runIdRef.current) return;
-        setStatus("pending");
-        setError(null);
-      })
-    );
-    unsubscribes.push(
-      durably.on("run:progress", (event) => {
-        if (event.runId !== runIdRef.current) return;
-        setProgress(event.progress);
-      })
-    );
-    unsubscribes.push(
-      durably.on("log:write", (event) => {
-        if (event.runId !== runIdRef.current) return;
-        setLogs((prev) => {
-          const newLog = {
-            id: crypto.randomUUID(),
+import { useMemo as useMemo2 } from "react";
+
+// src/shared/durably-event-subscriber.ts
+function createDurablyEventSubscriber(durably) {
+  return {
+    subscribe(runId, onEvent) {
+      const unsubscribes = [];
+      unsubscribes.push(
+        durably.on("run:start", (event) => {
+          if (event.runId !== runId) return;
+          onEvent({ type: "run:start" });
+        })
+      );
+      unsubscribes.push(
+        durably.on("run:complete", (event) => {
+          if (event.runId !== runId) return;
+          onEvent({ type: "run:complete", output: event.output });
+        })
+      );
+      unsubscribes.push(
+        durably.on("run:fail", (event) => {
+          if (event.runId !== runId) return;
+          onEvent({ type: "run:fail", error: event.error });
+        })
+      );
+      unsubscribes.push(
+        durably.on("run:cancel", (event) => {
+          if (event.runId !== runId) return;
+          onEvent({ type: "run:cancel" });
+        })
+      );
+      unsubscribes.push(
+        durably.on("run:retry", (event) => {
+          if (event.runId !== runId) return;
+          onEvent({ type: "run:retry" });
+        })
+      );
+      unsubscribes.push(
+        durably.on("run:progress", (event) => {
+          if (event.runId !== runId) return;
+          onEvent({ type: "run:progress", progress: event.progress });
+        })
+      );
+      unsubscribes.push(
+        durably.on("log:write", (event) => {
+          if (event.runId !== runId) return;
+          onEvent({
+            type: "log:write",
             runId: event.runId,
             stepName: event.stepName,
             level: event.level,
             message: event.message,
-            data: event.data,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          };
-          const newLogs = [...prev, newLog];
-          if (maxLogs > 0 && newLogs.length > maxLogs) {
-            return newLogs.slice(-maxLogs);
-          }
-          return newLogs;
-        });
-      })
-    );
-    return () => {
-      for (const unsubscribe of unsubscribes) {
-        unsubscribe();
-      }
-    };
-  }, [durably, runId, maxLogs]);
-  const clearLogs = () => {
-    setLogs([]);
-  };
-  const reset = () => {
-    setStatus(null);
-    setOutput(null);
-    setError(null);
-    setLogs([]);
-    setProgress(null);
-  };
-  return {
-    status,
-    output,
-    error,
-    logs,
-    progress,
-    clearLogs,
-    reset
+            data: event.data
+          });
+        })
+      );
+      return () => {
+        for (const unsubscribe of unsubscribes) {
+          unsubscribe();
+        }
+      };
+    }
   };
 }
 
+// src/hooks/use-run-subscription.ts
+function useRunSubscription(durably, runId, options) {
+  const subscriber = useMemo2(
+    () => durably ? createDurablyEventSubscriber(durably) : null,
+    [durably]
+  );
+  return useSubscription(subscriber, runId, options);
+}
+
 // src/hooks/use-job-logs.ts
 function useJobLogs(options) {
   const { durably } = useDurably();
@@ -360,13 +384,13 @@ function useJobLogs(options) {
 }
 
 // src/hooks/use-job-run.ts
-import { useEffect as useEffect3, useRef as useRef3 } from "react";
+import { useEffect as useEffect4, useRef as useRef3 } from "react";
 function useJobRun(options) {
   const { durably } = useDurably();
   const { runId } = options;
   const subscription = useRunSubscription(durably, runId);
   const fetchedRef = useRef3(/* @__PURE__ */ new Set());
-  useEffect3(() => {
+  useEffect4(() => {
     if (!durably || !runId || fetchedRef.current.has(runId)) return;
     fetchedRef.current.add(runId);
   }, [durably, runId]);
@@ -385,16 +409,16 @@ function useJobRun(options) {
 }
 
 // src/hooks/use-runs.ts
-import { useCallback as useCallback2, useEffect as useEffect4, useState as useState3 } from "react";
+import { useCallback as useCallback3, useEffect as useEffect5, useState } from "react";
 function useRuns(options) {
   const { durably } = useDurably();
   const pageSize = options?.pageSize ?? 10;
   const realtime = options?.realtime ?? true;
-  const [runs, setRuns] = useState3([]);
-  const [page, setPage] = useState3(0);
-  const [hasMore, setHasMore] = useState3(false);
-  const [isLoading, setIsLoading] = useState3(false);
-  const refresh = useCallback2(async () => {
+  const [runs, setRuns] = useState([]);
+  const [page, setPage] = useState(0);
+  const [hasMore, setHasMore] = useState(false);
+  const [isLoading, setIsLoading] = useState(false);
+  const refresh = useCallback3(async () => {
     if (!durably) return;
     setIsLoading(true);
     try {
@@ -410,7 +434,7 @@ function useRuns(options) {
       setIsLoading(false);
     }
   }, [durably, options?.jobName, options?.status, pageSize, page]);
-  useEffect4(() => {
+  useEffect5(() => {
     if (!durably) return;
     refresh();
     if (!realtime) return;
@@ -431,15 +455,15 @@ function useRuns(options) {
       }
     };
   }, [durably, refresh, realtime]);
-  const nextPage = useCallback2(() => {
+  const nextPage = useCallback3(() => {
     if (hasMore) {
       setPage((p) => p + 1);
     }
   }, [hasMore]);
-  const prevPage = useCallback2(() => {
+  const prevPage = useCallback3(() => {
     setPage((p) => Math.max(0, p - 1));
   }, []);
-  const goToPage = useCallback2((newPage) => {
+  const goToPage = useCallback3((newPage) => {
     setPage(Math.max(0, newPage));
   }, []);
   return {