@workflow/web-shared 4.0.1-beta.24 → 4.0.1-beta.26

package/dist/api/workflow-api-client.js

@@ -1,16 +1,16 @@
 'use client';
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { getPaginationDisplay } from '../lib/utils';
-import { cancelRun as cancelRunServerAction, fetchEvents, fetchEventsByCorrelationId, fetchHook, fetchHooks, fetchRun, fetchRuns, fetchStep, fetchSteps, readStreamServerAction, recreateRun as recreateRunServerAction, } from './workflow-server-actions';
+import { cancelRun as cancelRunServerAction, fetchEvents, fetchEventsByCorrelationId, fetchHook, fetchHooks, fetchRun, fetchRuns, fetchStep, fetchSteps, fetchStreams, readStreamServerAction, recreateRun as recreateRunServerAction, } from './workflow-server-actions';
 const MAX_ITEMS = 1000;
 const LIVE_POLL_LIMIT = 10;
 const LIVE_STEP_UPDATE_INTERVAL_MS = 2000;
 const LIVE_UPDATE_INTERVAL_MS = 5000;
 /**
- * Helper to convert ServerActionError to WorkflowAPIError
+ * Helper to convert ServerActionError to WorkflowWebAPIError
  */
 function createWorkflowAPIError(serverError) {
-    return new WorkflowAPIError(serverError.message, {
+    return new WorkflowWebAPIError(serverError.message, {
         cause: serverError.cause,
         request: serverError.request,
         layer: serverError.layer,
@@ -18,31 +18,50 @@ function createWorkflowAPIError(serverError) {
 }
 /**
  * Gets a user-facing error message from an error object.
- * Handles both WorkflowAPIError and regular Error instances.
+ * Handles both WorkflowWebAPIError and regular Error instances.
  */
 export const getErrorMessage = (error) => {
     if ('layer' in error && error.layer) {
-        if (error instanceof WorkflowAPIError) {
+        if (error instanceof WorkflowWebAPIError) {
             if (error.request?.status === 403) {
                 return 'Your current Vercel account does not have access to this data. Please use `vercel login` to log in, or use `vercel switch` to ensure you can access the correct team.';
             }
         }
-        // WorkflowAPIError already has user-facing messages
+        // WorkflowWebAPIError already has user-facing messages
         return error.message;
     }
     return error instanceof Error ? error.message : 'An error occurred';
 };
 /**
- * Helper to handle server action results and throw WorkflowAPIError on failure
+ * Helper to handle server action results and throw WorkflowWebAPIError on failure
  */
-function unwrapServerActionResult(result) {
+export async function unwrapServerActionResult(promise) {
+    let result;
+    try {
+        result = await promise;
+    }
+    catch (error) {
+        result = {
+            success: false,
+            error: error,
+        };
+    }
     if (!result.success) {
+        console.error('[web-api-client] error', result.error);
         if (!result.error) {
-            throw new WorkflowAPIError('Unknown error occurred', { layer: 'client' });
-        }
-        throw createWorkflowAPIError(result.error);
+            return {
+                error: new WorkflowWebAPIError('Unknown error occurred', {
+                    layer: 'client',
+                }),
+                result: null,
+            };
+        }
+        return {
+            error: createWorkflowAPIError(result.error),
+            result: null,
+        };
     }
-    return result.data;
+    return { error: null, result: result.data };
 }
 /**
  *  Error instance for API and server-side errors.
@@ -58,12 +77,12 @@ function unwrapServerActionResult(result) {
  *  calling the server action, these fields will be populated:
  *  - `error.layer` will be 'server'
  */
-export class WorkflowAPIError extends Error {
+export class WorkflowWebAPIError extends Error {
     request;
     layer;
     constructor(message, options) {
         super(message, { cause: options?.cause });
-        this.name = 'WorkflowAPIError';
+        this.name = 'WorkflowWebAPIError';
         this.request = options?.request;
         this.layer = options?.layer;
         if (options?.cause instanceof Error) {
@@ -117,42 +136,14 @@ export function useWorkflowRuns(env, params) {
                 return;
             }
         }
-        try {
-            const serverResult = await fetchRuns(env, {
-                cursor: pageCursor,
-                sortOrder,
-                limit: limit,
-                workflowName,
-                status,
-            });
-            const result = unwrapServerActionResult(serverResult);
-            // Cache the result
-            pageCache.current.set(cacheKey, {
-                data: result.data,
-                cursor: result.cursor,
-                hasMore: result.hasMore,
-            });
-            setAllPageResults((prev) => {
-                const newMap = new Map(prev);
-                newMap.set(pageIndex, {
-                    data: result.data,
-                    isLoading: false,
-                    error: null,
-                });
-                return newMap;
-            });
-            setCursor(result.cursor);
-            setHasMore(result.hasMore);
-        }
-        catch (err) {
-            const error = err instanceof WorkflowAPIError
-                ? err
-                : err instanceof Error
-                    ? new WorkflowAPIError(err.message, {
-                        cause: err,
-                        layer: 'client',
-                    })
-                    : new WorkflowAPIError(String(err), { layer: 'client' });
+        const { error, result } = await unwrapServerActionResult(fetchRuns(env, {
+            cursor: pageCursor,
+            sortOrder,
+            limit: limit,
+            workflowName,
+            status,
+        }));
+        if (error) {
             setAllPageResults((prev) => {
                 const newMap = new Map(prev);
                 newMap.set(pageIndex, {
@@ -162,7 +153,25 @@ export function useWorkflowRuns(env, params) {
                 });
                 return newMap;
             });
+            return;
         }
+        // Cache the result
+        pageCache.current.set(cacheKey, {
+            data: result.data,
+            cursor: result.cursor,
+            hasMore: result.hasMore,
+        });
+        setAllPageResults((prev) => {
+            const newMap = new Map(prev);
+            newMap.set(pageIndex, {
+                data: result.data,
+                isLoading: false,
+                error: null,
+            });
+            return newMap;
+        });
+        setCursor(result.cursor);
+        setHasMore(result.hasMore);
     }, [env, workflowName, limit, sortOrder, status]);
     // Initial load
     // biome-ignore lint/correctness/useExhaustiveDependencies: Want to refetch first page on param change
@@ -281,41 +290,13 @@ export function useWorkflowHooks(env, params) {
                 return;
             }
         }
-        try {
-            const serverResult = await fetchHooks(env, {
-                runId,
-                cursor: pageCursor,
-                sortOrder,
-                limit: limit,
-            });
-            const result = unwrapServerActionResult(serverResult);
-            // Cache the result
-            pageCache.current.set(cacheKey, {
-                data: result.data,
-                cursor: result.cursor,
-                hasMore: result.hasMore,
-            });
-            setAllPageResults((prev) => {
-                const newMap = new Map(prev);
-                newMap.set(pageIndex, {
-                    data: result.data,
-                    isLoading: false,
-                    error: null,
-                });
-                return newMap;
-            });
-            setCursor(result.cursor);
-            setHasMore(result.hasMore);
-        }
-        catch (err) {
-            const error = err instanceof WorkflowAPIError
-                ? err
-                : err instanceof Error
-                    ? new WorkflowAPIError(err.message, {
-                        cause: err,
-                        layer: 'client',
-                    })
-                    : new WorkflowAPIError(String(err), { layer: 'client' });
+        const { error, result } = await unwrapServerActionResult(fetchHooks(env, {
+            runId,
+            cursor: pageCursor,
+            sortOrder,
+            limit: limit,
+        }));
+        if (error) {
             setAllPageResults((prev) => {
                 const newMap = new Map(prev);
                 newMap.set(pageIndex, {
@@ -325,7 +306,25 @@ export function useWorkflowHooks(env, params) {
                 });
                 return newMap;
             });
+            return;
         }
+        // Cache the result
+        pageCache.current.set(cacheKey, {
+            data: result.data,
+            cursor: result.cursor,
+            hasMore: result.hasMore,
+        });
+        setAllPageResults((prev) => {
+            const newMap = new Map(prev);
+            newMap.set(pageIndex, {
+                data: result.data,
+                isLoading: false,
+                error: null,
+            });
+            return newMap;
+        });
+        setCursor(result.cursor);
+        setHasMore(result.hasMore);
     }, [env, runId, limit, sortOrder]);
     // Initial load
     useEffect(() => {
@@ -402,12 +401,15 @@ async function fetchAllSteps(env, runId) {
     let stepsData = [];
     let stepsCursor;
     while (true) {
-        const serverResult = await fetchSteps(env, runId, {
+        const { error, result } = await unwrapServerActionResult(fetchSteps(env, runId, {
             cursor: stepsCursor,
             sortOrder: 'asc',
             limit: 100,
-        });
-        const result = unwrapServerActionResult(serverResult);
+        }));
+        // TODO: We're not handling errors well for infinite fetches
+        if (error) {
+            break;
+        }
         stepsData = [...stepsData, ...result.data];
         if (!result.hasMore || !result.cursor || stepsData.length >= MAX_ITEMS) {
             break;
@@ -421,13 +423,15 @@ async function fetchAllHooks(env, runId) {
     let hooksData = [];
     let hooksCursor;
     while (true) {
-        const serverResult = await fetchHooks(env, {
+        const { error, result } = await unwrapServerActionResult(fetchHooks(env, {
             runId,
             cursor: hooksCursor,
             sortOrder: 'asc',
             limit: 100,
-        });
-        const result = unwrapServerActionResult(serverResult);
+        }));
+        if (error) {
+            break;
+        }
         hooksData = [...hooksData, ...result.data];
         if (!result.hasMore || !result.cursor || hooksData.length >= MAX_ITEMS) {
             break;
@@ -441,12 +445,14 @@ async function fetchAllEvents(env, runId) {
     let eventsData = [];
     let eventsCursor;
     while (true) {
-        const serverResult = await fetchEvents(env, runId, {
+        const { error, result } = await unwrapServerActionResult(fetchEvents(env, runId, {
             cursor: eventsCursor,
             sortOrder: 'asc',
             limit: 1000,
-        });
-        const result = unwrapServerActionResult(serverResult);
+        }));
+        if (error) {
+            break;
+        }
         eventsData = [...eventsData, ...result.data];
         if (!result.hasMore || !result.cursor || eventsData.length >= MAX_ITEMS) {
             break;
@@ -483,11 +489,13 @@ export function useWorkflowTraceViewerData(env, runId, options = {}) {
         setAuxiliaryDataLoading(true);
         setError(null);
         const promises = [
-            fetchRun(env, runId).then((result) => {
-                // The run is the most visible part - so we can start showing UI
-                // as soon as we have the run
-                setLoading(false);
-                setRun(unwrapServerActionResult(result));
+            unwrapServerActionResult(fetchRun(env, runId)).then(({ error, result }) => {
+                if (error) {
+                    setError(error);
+                    return;
+                }
+                setRun(result);
+                return result;
             }),
             fetchAllSteps(env, runId).then((result) => {
                 setSteps(result.data);
@@ -502,23 +510,17 @@ export function useWorkflowTraceViewerData(env, runId, options = {}) {
                 setEventsCursor(result.cursor);
             }),
         ];
-        try {
-            // Fetch run
-            await Promise.all(promises);
-        }
-        catch (err) {
-            const error = err instanceof WorkflowAPIError
-                ? err
-                : err instanceof Error
-                    ? new WorkflowAPIError(err.message, { cause: err, layer: 'client' })
-                    : new WorkflowAPIError(String(err), { layer: 'client' });
+        const results = await Promise.allSettled(promises);
+        setLoading(false);
+        setAuxiliaryDataLoading(false);
+        setInitialLoadCompleted(true);
+        isFetchingRef.current = false;
+        // Just doing the first error, but would be nice to show multiple
+        const error = results.find((result) => result.status === 'rejected')
+            ?.reason;
+        if (error) {
             setError(error);
-        }
-        finally {
-            setLoading(false);
-            setAuxiliaryDataLoading(false);
-            isFetchingRef.current = false;
-            setInitialLoadCompleted(true);
+            return;
         }
     }, [env, runId]);
     // Helper to merge steps by ID
@@ -543,19 +545,25 @@ export function useWorkflowTraceViewerData(env, runId, options = {}) {
         if (run?.completedAt) {
             return false;
         }
-        const serverResult = await fetchRun(env, runId);
-        const result = unwrapServerActionResult(serverResult);
+        const { error, result } = await unwrapServerActionResult(fetchRun(env, runId));
+        if (error) {
+            setError(error);
+            return false;
+        }
         setRun(result);
         return true;
     }, [env, runId, run?.completedAt]);
     // Poll for new steps
     const pollSteps = useCallback(async () => {
-        const serverResult = await fetchSteps(env, runId, {
+        const { error, result } = await unwrapServerActionResult(fetchSteps(env, runId, {
             cursor: stepsCursor,
             sortOrder: 'asc',
             limit: LIVE_POLL_LIMIT,
-        });
-        const result = unwrapServerActionResult(serverResult);
+        }));
+        if (error) {
+            setError(error);
+            return false;
+        }
         if (result.data.length > 0) {
             setSteps((prev) => mergeSteps(prev, result.data));
             if (result.cursor) {
@@ -567,13 +575,16 @@ export function useWorkflowTraceViewerData(env, runId, options = {}) {
     }, [env, runId, stepsCursor, mergeSteps]);
     // Poll for new hooks
     const pollHooks = useCallback(async () => {
-        const serverResult = await fetchHooks(env, {
+        const { error, result } = await unwrapServerActionResult(fetchHooks(env, {
             runId,
             cursor: hooksCursor,
             sortOrder: 'asc',
             limit: LIVE_POLL_LIMIT,
-        });
-        const result = unwrapServerActionResult(serverResult);
+        }));
+        if (error) {
+            setError(error);
+            return false;
+        }
         if (result.data.length > 0) {
             setHooks((prev) => mergeHooks(prev, result.data));
             if (result.cursor) {
@@ -585,12 +596,15 @@ export function useWorkflowTraceViewerData(env, runId, options = {}) {
     }, [env, runId, hooksCursor, mergeHooks]);
     // Poll for new events
     const pollEvents = useCallback(async () => {
-        const serverResult = await fetchEvents(env, runId, {
+        const { error, result } = await unwrapServerActionResult(fetchEvents(env, runId, {
             cursor: eventsCursor,
             sortOrder: 'asc',
             limit: LIVE_POLL_LIMIT,
-        });
-        const result = unwrapServerActionResult(serverResult);
+        }));
+        if (error) {
+            setError(error);
+            return false;
+        }
         if (result.data.length > 0) {
             setEvents((prev) => mergeEvents(prev, result.data));
             if (result.cursor) {
@@ -657,28 +671,37 @@ async function fetchResourceWithCorrelationId(env, resource, resourceId, options
     let correlationId;
     const resolveData = options.resolveData ?? 'all';
     if (resource === 'run') {
-        const serverResult = await fetchRun(env, resourceId, resolveData);
-        resourceData = unwrapServerActionResult(serverResult);
+        const { error, result } = await unwrapServerActionResult(fetchRun(env, resourceId, resolveData));
+        if (error) {
+            throw error;
+        }
+        resourceData = result;
         correlationId = resourceData.runId;
     }
     else if (resource === 'step') {
         const { runId } = options;
         if (!runId) {
-            throw new WorkflowAPIError('runId is required for step resource', {
+            throw new WorkflowWebAPIError('runId is required for step resource', {
                 layer: 'client',
             });
         }
-        const serverResult = await fetchStep(env, runId, resourceId, resolveData);
-        resourceData = unwrapServerActionResult(serverResult);
+        const { error, result } = await unwrapServerActionResult(fetchStep(env, runId, resourceId, resolveData));
+        if (error) {
+            throw error;
+        }
+        resourceData = result;
         correlationId = resourceData.stepId;
     }
     else if (resource === 'hook') {
-        const serverResult = await fetchHook(env, resourceId, resolveData);
-        resourceData = unwrapServerActionResult(serverResult);
+        const { error, result } = await unwrapServerActionResult(fetchHook(env, resourceId, resolveData));
+        if (error) {
+            throw error;
+        }
+        resourceData = result;
         correlationId = resourceData.hookId;
     }
     else {
-        throw new WorkflowAPIError(`Unknown resource type: ${resource}`, {
+        throw new WorkflowWebAPIError(`Unknown resource type: ${resource}`, {
             layer: 'client',
         });
     }
@@ -698,52 +721,53 @@ export function useWorkflowResourceData(env, resource, resourceId, options = {})
         setLoading(true);
         setData(null);
         setError(null);
-        try {
-            if (resource === 'sleep') {
-                const events = await fetchEventsByCorrelationId(env, resourceId, {
-                    sortOrder: 'asc',
-                    limit: 100,
-                    withData: true,
-                });
-                const eventsData = unwrapServerActionResult(events);
-                const waitStartEvent = eventsData.data.find((event) => event.eventType === 'wait_created');
-                if (waitStartEvent) {
-                    setData({
-                        waitId: waitStartEvent.correlationId,
-                        runId: waitStartEvent.runId,
-                        createdAt: waitStartEvent.createdAt,
-                        resumeAt: waitStartEvent.eventData.resumeAt,
-                    });
-                }
+        if (resource === 'sleep') {
+            const { error, result } = await unwrapServerActionResult(fetchEventsByCorrelationId(env, resourceId, {
+                sortOrder: 'asc',
+                limit: 100,
+                withData: true,
+            }));
+            if (error) {
+                setError(error);
                 return;
             }
-            // Fetch resource with full data
+            const eventsData = result;
+            const waitStartEvent = eventsData.data.find((event) => event.eventType === 'wait_created');
+            if (waitStartEvent) {
+                setData({
+                    waitId: waitStartEvent.correlationId,
+                    runId: waitStartEvent.runId,
+                    createdAt: waitStartEvent.createdAt,
+                    resumeAt: waitStartEvent.eventData.resumeAt,
+                });
+            }
+            return;
+        }
+        // Fetch resource with full data
+        try {
             const { data: resourceData } = await fetchResourceWithCorrelationId(env, resource, resourceId, {
                 runId,
             });
             setData(resourceData);
-            if (resource === 'run') {
-                setLoading(false);
-                return;
-            }
-            // // Fetch events by correlation ID
-            // const eventsData = await fetchAllEventsByCorrelationId(
-            //   env,
-            //   correlationId
-            // );
-            // setEvents(eventsData);
         }
-        catch (err) {
-            const error = err instanceof WorkflowAPIError
-                ? err
-                : err instanceof Error
-                    ? new WorkflowAPIError(err.message, { cause: err, layer: 'client' })
-                    : new WorkflowAPIError(String(err), { layer: 'client' });
-            setError(error);
+        catch (error) {
+            if (error instanceof Error) {
+                setError(error);
+            }
+            else {
+                setError(new Error(String(error)));
+            }
+            return;
         }
         finally {
             setLoading(false);
         }
+        // // Fetch events by correlation ID
+        // const eventsData = await fetchAllEventsByCorrelationId(
+        //   env,
+        //   correlationId
+        // );
+        // setEvents(eventsData);
     }, [env, resource, resourceId, runId]);
     // Initial load
     useEffect(() => {
@@ -769,45 +793,105 @@ export function useWorkflowResourceData(env, resource, resourceId, options = {})
  * Cancel a workflow run
  */
 export async function cancelRun(env, runId) {
-    try {
-        const result = await cancelRunServerAction(env, runId);
-        unwrapServerActionResult(result);
-    }
-    catch (err) {
-        console.error('Error canceling run:', err);
-        if (err instanceof WorkflowAPIError) {
-            throw err;
-        }
-        throw new WorkflowAPIError(err instanceof Error ? err.message : 'Failed to cancel run', { cause: err, layer: 'client' });
+    const { error } = await unwrapServerActionResult(cancelRunServerAction(env, runId));
+    if (error) {
+        throw error;
     }
 }
 /**
  * Start a new workflow run
  */
 export async function recreateRun(env, runId) {
-    try {
-        const result = await recreateRunServerAction(env, runId);
-        return unwrapServerActionResult(result);
-    }
-    catch (err) {
-        console.error('Error starting run:', err);
-        if (err instanceof WorkflowAPIError) {
-            throw err;
-        }
-        throw new WorkflowAPIError(err instanceof Error ? err.message : 'Failed to start run', { cause: err, layer: 'client' });
+    const { error, result: resultData } = await unwrapServerActionResult(recreateRunServerAction(env, runId));
+    if (error) {
+        throw error;
     }
+    return resultData;
+}
+function isServerActionError(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'message' in value &&
+        'layer' in value &&
+        'cause' in value &&
+        'request' in value);
 }
 export async function readStream(env, streamId, startIndex) {
     try {
-        const result = await readStreamServerAction(env, streamId, startIndex);
-        return unwrapServerActionResult(result);
+        const stream = await readStreamServerAction(env, streamId, startIndex);
+        if (!stream) {
+            throw new WorkflowWebAPIError('Failed to read stream', {
+                layer: 'client',
+            });
+        }
+        if (isServerActionError(stream)) {
+            throw new WorkflowWebAPIError(stream.message, {
+                layer: 'client',
+                cause: stream.cause,
+                request: stream.request,
+            });
+        }
+        return stream;
     }
-    catch (err) {
-        console.error('Error reading stream:', err);
-        if (err instanceof WorkflowAPIError) {
-            throw err;
+    catch (error) {
+        if (error instanceof WorkflowWebAPIError) {
+            throw error;
         }
-        throw new WorkflowAPIError(err instanceof Error ? err.message : 'Failed to read stream', { cause: err, layer: 'client' });
+        throw new WorkflowWebAPIError('Failed to read stream', {
+            layer: 'client',
+            cause: error,
+        });
+    }
+}
+/**
+ * List all stream IDs for a run
+ */
+export async function listStreams(env, runId) {
+    const { error, result } = await unwrapServerActionResult(fetchStreams(env, runId));
+    if (error) {
+        throw error;
     }
+    return result;
+}
+const STREAMS_REFRESH_INTERVAL_MS = 10000;
+/**
+ * Hook to fetch and manage stream list for a run
+ */
+export function useWorkflowStreams(env, runId, refreshInterval = STREAMS_REFRESH_INTERVAL_MS) {
+    const [streams, setStreams] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const fetchData = useCallback(async () => {
+        setLoading(true);
+        setError(null);
+        try {
+            const result = await listStreams(env, runId);
+            setStreams(result);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err : new Error(String(err)));
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [env, runId]);
+    // Initial load
+    useEffect(() => {
+        fetchData();
+    }, [fetchData]);
+    // Auto-refresh interval
+    useEffect(() => {
+        if (!refreshInterval || refreshInterval <= 0) {
+            return;
+        }
+        const interval = setInterval(fetchData, refreshInterval);
+        return () => clearInterval(interval);
+    }, [refreshInterval, fetchData]);
+    return {
+        streams,
+        loading,
+        error,
+        refresh: fetchData,
+    };
 }
 //# sourceMappingURL=workflow-api-client.js.map