@coji/durably-react 0.9.0 → 0.11.0

package/dist/client.js

@@ -1,629 +0,0 @@
-import {
-  isJobDefinition,
-  useSubscription
-} from "./chunk-XRJEZWAV.js";
-
-// src/client/use-job.ts
-import { useCallback, useEffect, useRef, useState } from "react";
-
-// src/client/use-sse-subscription.ts
-import { useMemo } from "react";
-
-// src/shared/sse-event-subscriber.ts
-function createSSEEventSubscriber(apiBaseUrl) {
-  return {
-    subscribe(runId, onEvent) {
-      const url = `${apiBaseUrl}/subscribe?runId=${encodeURIComponent(runId)}`;
-      const eventSource = new EventSource(url);
-      eventSource.onmessage = (messageEvent) => {
-        try {
-          const data = JSON.parse(messageEvent.data);
-          if (data.runId !== runId) return;
-          switch (data.type) {
-            case "run:start":
-              onEvent({ type: "run:start" });
-              break;
-            case "run:complete":
-              onEvent({
-                type: "run:complete",
-                output: data.output
-              });
-              break;
-            case "run:fail":
-              onEvent({ type: "run:fail", error: data.error });
-              break;
-            case "run:cancel":
-              onEvent({ type: "run:cancel" });
-              break;
-            case "run:retry":
-              onEvent({ type: "run:retry" });
-              break;
-            case "run:progress":
-              onEvent({ type: "run:progress", progress: data.progress });
-              break;
-            case "log:write":
-              onEvent({
-                type: "log:write",
-                runId: data.runId,
-                stepName: null,
-                level: data.level,
-                message: data.message,
-                data: data.data
-              });
-              break;
-          }
-        } catch {
-        }
-      };
-      eventSource.onerror = () => {
-        onEvent({ type: "connection_error", error: "Connection failed" });
-        eventSource.close();
-      };
-      return () => {
-        eventSource.close();
-      };
-    }
-  };
-}
-
-// src/client/use-sse-subscription.ts
-function useSSESubscription(api, runId, options) {
-  const subscriber = useMemo(
-    () => api ? createSSEEventSubscriber(api) : null,
-    [api]
-  );
-  return useSubscription(subscriber, runId, options);
-}
-
-// src/client/use-job.ts
-function useJob(options) {
-  const {
-    api,
-    jobName,
-    initialRunId,
-    autoResume = true,
-    followLatest = true
-  } = options;
-  const [currentRunId, setCurrentRunId] = useState(
-    initialRunId ?? null
-  );
-  const [isPending, setIsPending] = useState(false);
-  const hasUserTriggered = useRef(false);
-  const subscription = useSSESubscription(api, currentRunId);
-  useEffect(() => {
-    if (!autoResume) return;
-    if (initialRunId) return;
-    const abortController = new AbortController();
-    const findActiveRun = async () => {
-      const runningParams = new URLSearchParams({
-        jobName,
-        status: "running",
-        limit: "1"
-      });
-      const runningRes = await fetch(`${api}/runs?${runningParams}`, {
-        signal: abortController.signal
-      });
-      if (runningRes.ok) {
-        const runs = await runningRes.json();
-        if (runs.length > 0) {
-          if (hasUserTriggered.current) return;
-          setCurrentRunId(runs[0].id);
-          return;
-        }
-      }
-      const pendingParams = new URLSearchParams({
-        jobName,
-        status: "pending",
-        limit: "1"
-      });
-      const pendingRes = await fetch(`${api}/runs?${pendingParams}`, {
-        signal: abortController.signal
-      });
-      if (pendingRes.ok) {
-        const runs = await pendingRes.json();
-        if (runs.length > 0) {
-          if (hasUserTriggered.current) return;
-          setCurrentRunId(runs[0].id);
-        }
-      }
-    };
-    findActiveRun().catch((err) => {
-      if (err.name !== "AbortError") {
-        console.error("autoResume error:", err);
-      }
-    });
-    return () => {
-      abortController.abort();
-    };
-  }, [api, jobName, autoResume, initialRunId]);
-  useEffect(() => {
-    if (!followLatest) return;
-    const params = new URLSearchParams({ jobName });
-    const eventSource = new EventSource(`${api}/runs/subscribe?${params}`);
-    eventSource.onmessage = (event) => {
-      try {
-        const data = JSON.parse(event.data);
-        if ((data.type === "run:trigger" || data.type === "run:start") && data.runId) {
-          setCurrentRunId(data.runId);
-        }
-      } catch {
-      }
-    };
-    eventSource.onerror = () => {
-    };
-    return () => {
-      eventSource.close();
-    };
-  }, [api, jobName, followLatest]);
-  const trigger = useCallback(
-    async (input) => {
-      hasUserTriggered.current = true;
-      subscription.reset();
-      setIsPending(true);
-      const response = await fetch(`${api}/trigger`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({ jobName, input })
-      });
-      if (!response.ok) {
-        setIsPending(false);
-        const errorText = await response.text();
-        throw new Error(errorText || `HTTP ${response.status}`);
-      }
-      const { runId } = await response.json();
-      setCurrentRunId(runId);
-      return { runId };
-    },
-    [api, jobName, subscription.reset]
-  );
-  const triggerAndWait = useCallback(
-    async (input) => {
-      const { runId } = await trigger(input);
-      return new Promise((resolve, reject) => {
-        const checkInterval = setInterval(() => {
-          if (subscription.status === "completed" && subscription.output) {
-            clearInterval(checkInterval);
-            resolve({ runId, output: subscription.output });
-          } else if (subscription.status === "failed") {
-            clearInterval(checkInterval);
-            reject(new Error(subscription.error ?? "Job failed"));
-          } else if (subscription.status === "cancelled") {
-            clearInterval(checkInterval);
-            reject(new Error("Job cancelled"));
-          }
-        }, 50);
-      });
-    },
-    [trigger, subscription.status, subscription.output, subscription.error]
-  );
-  const reset = useCallback(() => {
-    subscription.reset();
-    setCurrentRunId(null);
-    setIsPending(false);
-  }, [subscription.reset]);
-  const effectiveStatus = subscription.status ?? (isPending ? "pending" : null);
-  useEffect(() => {
-    if (subscription.status && isPending) {
-      setIsPending(false);
-    }
-  }, [subscription.status, isPending]);
-  return {
-    trigger,
-    triggerAndWait,
-    status: effectiveStatus,
-    output: subscription.output,
-    error: subscription.error,
-    logs: subscription.logs,
-    progress: subscription.progress,
-    isRunning: effectiveStatus === "running",
-    isPending: effectiveStatus === "pending",
-    isCompleted: effectiveStatus === "completed",
-    isFailed: effectiveStatus === "failed",
-    isCancelled: effectiveStatus === "cancelled",
-    currentRunId,
-    reset
-  };
-}
-
-// src/client/use-job-logs.ts
-function useJobLogs(options) {
-  const { api, runId, maxLogs } = options;
-  const subscription = useSSESubscription(api, runId, { maxLogs });
-  return {
-    logs: subscription.logs,
-    clearLogs: subscription.clearLogs
-  };
-}
-
-// src/client/use-job-run.ts
-import { useEffect as useEffect2, useRef as useRef2 } from "react";
-function useJobRun(options) {
-  const { api, runId, onStart, onComplete, onFail } = options;
-  const subscription = useSSESubscription(api, runId);
-  const effectiveStatus = subscription.status ?? (runId ? "pending" : null);
-  const isCompleted = effectiveStatus === "completed";
-  const isFailed = effectiveStatus === "failed";
-  const isPending = effectiveStatus === "pending";
-  const isRunning = effectiveStatus === "running";
-  const isCancelled = effectiveStatus === "cancelled";
-  const prevStatusRef = useRef2(null);
-  useEffect2(() => {
-    const prevStatus = prevStatusRef.current;
-    prevStatusRef.current = effectiveStatus;
-    if (prevStatus !== effectiveStatus) {
-      if (prevStatus === null && (isPending || isRunning) && onStart) {
-        onStart();
-      }
-      if (isCompleted && onComplete) {
-        onComplete();
-      }
-      if (isFailed && onFail) {
-        onFail();
-      }
-    }
-  }, [
-    effectiveStatus,
-    isPending,
-    isRunning,
-    isCompleted,
-    isFailed,
-    onStart,
-    onComplete,
-    onFail
-  ]);
-  return {
-    status: effectiveStatus,
-    output: subscription.output,
-    error: subscription.error,
-    logs: subscription.logs,
-    progress: subscription.progress,
-    isRunning,
-    isPending,
-    isCompleted,
-    isFailed,
-    isCancelled
-  };
-}
-
-// src/client/create-durably-client.ts
-function createDurablyClient(options) {
-  const { api } = options;
-  return new Proxy({}, {
-    get(_target, jobKey) {
-      return {
-        useJob: () => {
-          return useJob({ api, jobName: jobKey });
-        },
-        useRun: (runId) => {
-          return useJobRun({ api, runId });
-        },
-        useLogs: (runId, logsOptions) => {
-          return useJobLogs({ api, runId, maxLogs: logsOptions?.maxLogs });
-        }
-      };
-    }
-  });
-}
-
-// src/client/create-job-hooks.ts
-function createJobHooks(options) {
-  const { api, jobName } = options;
-  return {
-    useJob: () => {
-      return useJob({ api, jobName });
-    },
-    useRun: (runId) => {
-      return useJobRun({ api, runId });
-    },
-    useLogs: (runId, logsOptions) => {
-      return useJobLogs({ api, runId, maxLogs: logsOptions?.maxLogs });
-    }
-  };
-}
-
-// src/client/use-runs.ts
-import { useCallback as useCallback2, useEffect as useEffect3, useMemo as useMemo2, useRef as useRef3, useState as useState2 } from "react";
-function useRuns(jobDefinitionOrOptions, optionsArg) {
-  const isJob = isJobDefinition(jobDefinitionOrOptions);
-  const jobName = isJob ? jobDefinitionOrOptions.name : jobDefinitionOrOptions.jobName;
-  const options = isJob ? optionsArg : jobDefinitionOrOptions;
-  const { api, status, labels, pageSize = 10, realtime = true } = options;
-  const labelsKey = labels ? JSON.stringify(labels) : void 0;
-  const stableLabels = useMemo2(
-    () => labelsKey ? JSON.parse(labelsKey) : void 0,
-    [labelsKey]
-  );
-  const [runs, setRuns] = useState2([]);
-  const [page, setPage] = useState2(0);
-  const [hasMore, setHasMore] = useState2(false);
-  const [isLoading, setIsLoading] = useState2(true);
-  const [error, setError] = useState2(null);
-  const isMountedRef = useRef3(true);
-  const eventSourceRef = useRef3(null);
-  const refresh = useCallback2(async () => {
-    setIsLoading(true);
-    setError(null);
-    try {
-      const params = new URLSearchParams();
-      if (jobName) params.set("jobName", jobName);
-      if (status) params.set("status", status);
-      appendLabelsToParams(params, stableLabels);
-      params.set("limit", String(pageSize + 1));
-      params.set("offset", String(page * pageSize));
-      const url = `${api}/runs?${params.toString()}`;
-      const response = await fetch(url);
-      if (!response.ok) {
-        throw new Error(`Failed to fetch runs: ${response.statusText}`);
-      }
-      const data = await response.json();
-      if (isMountedRef.current) {
-        setHasMore(data.length > pageSize);
-        setRuns(data.slice(0, pageSize));
-      }
-    } catch (err) {
-      if (isMountedRef.current) {
-        setError(err instanceof Error ? err.message : "Unknown error");
-      }
-    } finally {
-      if (isMountedRef.current) {
-        setIsLoading(false);
-      }
-    }
-  }, [api, jobName, status, stableLabels, pageSize, page]);
-  useEffect3(() => {
-    isMountedRef.current = true;
-    refresh();
-    return () => {
-      isMountedRef.current = false;
-    };
-  }, [refresh]);
-  useEffect3(() => {
-    if (!realtime || page !== 0) {
-      if (eventSourceRef.current) {
-        eventSourceRef.current.close();
-        eventSourceRef.current = null;
-      }
-      return;
-    }
-    const params = new URLSearchParams();
-    if (jobName) params.set("jobName", jobName);
-    appendLabelsToParams(params, stableLabels);
-    const sseUrl = `${api}/runs/subscribe${params.toString() ? `?${params.toString()}` : ""}`;
-    const eventSource = new EventSource(sseUrl);
-    eventSourceRef.current = eventSource;
-    eventSource.onmessage = (event) => {
-      try {
-        const data = JSON.parse(event.data);
-        if (data.type === "run:trigger" || data.type === "run:start" || data.type === "run:complete" || data.type === "run:fail" || data.type === "run:cancel" || data.type === "run:delete" || data.type === "run:retry") {
-          refresh();
-        }
-        if (data.type === "run:progress") {
-          setRuns(
-            (prev) => prev.map(
-              (run) => run.id === data.runId ? { ...run, progress: data.progress } : run
-            )
-          );
-        }
-        if (data.type === "step:complete") {
-          setRuns(
-            (prev) => prev.map(
-              (run) => run.id === data.runId ? { ...run, currentStepIndex: data.stepIndex + 1 } : run
-            )
-          );
-        }
-        if (data.type === "step:start" || data.type === "step:fail" || data.type === "step:cancel") {
-          refresh();
-        }
-      } catch {
-      }
-    };
-    eventSource.onerror = () => {
-    };
-    return () => {
-      eventSource.close();
-      eventSourceRef.current = null;
-    };
-  }, [api, jobName, stableLabels, page, realtime, refresh]);
-  const nextPage = useCallback2(() => {
-    if (hasMore) {
-      setPage((p) => p + 1);
-    }
-  }, [hasMore]);
-  const prevPage = useCallback2(() => {
-    setPage((p) => Math.max(0, p - 1));
-  }, []);
-  const goToPage = useCallback2((newPage) => {
-    setPage(Math.max(0, newPage));
-  }, []);
-  return {
-    runs,
-    page,
-    hasMore,
-    isLoading,
-    error,
-    nextPage,
-    prevPage,
-    goToPage,
-    refresh
-  };
-}
-function appendLabelsToParams(params, labels) {
-  if (!labels) return;
-  for (const [key, value] of Object.entries(labels)) {
-    params.set(`label.${key}`, value);
-  }
-}
-
-// src/client/use-run-actions.ts
-import { useCallback as useCallback3, useState as useState3 } from "react";
-function useRunActions(options) {
-  const { api } = options;
-  const [isLoading, setIsLoading] = useState3(false);
-  const [error, setError] = useState3(null);
-  const retry = useCallback3(
-    async (runId) => {
-      setIsLoading(true);
-      setError(null);
-      try {
-        const url = `${api}/retry?runId=${encodeURIComponent(runId)}`;
-        const response = await fetch(url, { method: "POST" });
-        if (!response.ok) {
-          let errorMessage = `Failed to retry: ${response.statusText}`;
-          try {
-            const data = await response.json();
-            if (data.error) {
-              errorMessage = data.error;
-            }
-          } catch {
-          }
-          throw new Error(errorMessage);
-        }
-      } catch (err) {
-        const message = err instanceof Error ? err.message : "Unknown error";
-        setError(message);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [api]
-  );
-  const cancel = useCallback3(
-    async (runId) => {
-      setIsLoading(true);
-      setError(null);
-      try {
-        const url = `${api}/cancel?runId=${encodeURIComponent(runId)}`;
-        const response = await fetch(url, { method: "POST" });
-        if (!response.ok) {
-          let errorMessage = `Failed to cancel: ${response.statusText}`;
-          try {
-            const data = await response.json();
-            if (data.error) {
-              errorMessage = data.error;
-            }
-          } catch {
-          }
-          throw new Error(errorMessage);
-        }
-      } catch (err) {
-        const message = err instanceof Error ? err.message : "Unknown error";
-        setError(message);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [api]
-  );
-  const deleteRun = useCallback3(
-    async (runId) => {
-      setIsLoading(true);
-      setError(null);
-      try {
-        const url = `${api}/run?runId=${encodeURIComponent(runId)}`;
-        const response = await fetch(url, { method: "DELETE" });
-        if (!response.ok) {
-          let errorMessage = `Failed to delete: ${response.statusText}`;
-          try {
-            const data = await response.json();
-            if (data.error) {
-              errorMessage = data.error;
-            }
-          } catch {
-          }
-          throw new Error(errorMessage);
-        }
-      } catch (err) {
-        const message = err instanceof Error ? err.message : "Unknown error";
-        setError(message);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [api]
-  );
-  const getRun = useCallback3(
-    async (runId) => {
-      setIsLoading(true);
-      setError(null);
-      try {
-        const url = `${api}/run?runId=${encodeURIComponent(runId)}`;
-        const response = await fetch(url);
-        if (response.status === 404) {
-          return null;
-        }
-        if (!response.ok) {
-          let errorMessage = `Failed to get run: ${response.statusText}`;
-          try {
-            const data = await response.json();
-            if (data.error) {
-              errorMessage = data.error;
-            }
-          } catch {
-          }
-          throw new Error(errorMessage);
-        }
-        return await response.json();
-      } catch (err) {
-        const message = err instanceof Error ? err.message : "Unknown error";
-        setError(message);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [api]
-  );
-  const getSteps = useCallback3(
-    async (runId) => {
-      setIsLoading(true);
-      setError(null);
-      try {
-        const url = `${api}/steps?runId=${encodeURIComponent(runId)}`;
-        const response = await fetch(url);
-        if (!response.ok) {
-          let errorMessage = `Failed to get steps: ${response.statusText}`;
-          try {
-            const data = await response.json();
-            if (data.error) {
-              errorMessage = data.error;
-            }
-          } catch {
-          }
-          throw new Error(errorMessage);
-        }
-        return await response.json();
-      } catch (err) {
-        const message = err instanceof Error ? err.message : "Unknown error";
-        setError(message);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [api]
-  );
-  return {
-    retry,
-    cancel,
-    deleteRun,
-    getRun,
-    getSteps,
-    isLoading,
-    error
-  };
-}
-export {
-  createDurablyClient,
-  createJobHooks,
-  useJob,
-  useJobLogs,
-  useJobRun,
-  useRunActions,
-  useRuns
-};
-//# sourceMappingURL=client.js.map