@shipfox/client-workflows 0.2.0

package/src/feature.ts

@@ -0,0 +1,26 @@
+import {defineClientFeature} from '@shipfox/client-shell';
+
+export const workflowsFeature = defineClientFeature({
+  id: 'shipfox.workflows',
+  routes: [
+    {
+      path: '/workspaces/$wid/projects/$pid/runs',
+      parent: 'projectLayout',
+      impl: '@shipfox/client-workflows/routes/runs',
+    },
+    {
+      path: '/workspaces/$wid/projects/$pid/runs/$workflowRunId',
+      parent: 'projectLayout',
+      impl: '@shipfox/client-workflows/routes/run-detail',
+    },
+  ],
+  navigation: [
+    {
+      id: 'nav.runs',
+      scope: 'project',
+      label: 'Runs',
+      to: '/workspaces/$wid/projects/$pid/runs',
+      order: 100,
+    },
+  ],
+});

package/src/hooks/api/workflow-runs.test.tsx

@@ -0,0 +1,410 @@
+import type {
+  WorkflowRunDetailResponseDto,
+  WorkflowRunListResponseDto,
+} from '@shipfox/api-workflows-dto';
+import {configureApiClient} from '@shipfox/client-api';
+import {type InfiniteData, QueryClient, QueryClientProvider} from '@tanstack/react-query';
+import {act, cleanup, renderHook, waitFor} from '@testing-library/react';
+import type {ReactNode} from 'react';
+import {toWorkflowRun} from '#core/workflow-run.js';
+import {
+  runAttemptsResponseDto,
+  workflowJobDto,
+  workflowRunAttemptDto,
+  workflowRunDetailDto,
+  workflowRunDto,
+  workflowRunListResponseDto,
+} from '#test/fixtures/workflow-run.js';
+import {
+  fireManualWorkflow,
+  useCancelWorkflowRunMutation,
+  useFireManualWorkflowMutation,
+  useRerunWorkflowRunMutation,
+  useWorkflowRunAttemptsQuery,
+  useWorkflowRunQuery,
+  useWorkflowRunsInfiniteQuery,
+  workflowRunsQueryKeys,
+} from './workflow-runs.js';
+
+const PROJECT_ID = '44444444-4444-4444-8444-444444444444';
+const DEFINITION_ID = '55555555-5555-4555-8555-555555555555';
+const RUN_ID = '66666666-6666-4666-8666-666666666666';
+const ROOT_RUN_ID = '77777777-7777-4777-8777-777777777777';
+const TEMP_RUN_ID_PATTERN = /^temp-/;
+
+function jsonResponse(body: unknown, init: ResponseInit = {}): Response {
+  return new Response(JSON.stringify(body), {
+    headers: {'content-type': 'application/json'},
+    status: 200,
+    ...init,
+  });
+}
+
+function renderWithQueryClient<T>(callback: () => T) {
+  const queryClient = new QueryClient({defaultOptions: {queries: {retry: false}}});
+  const wrapper = ({children}: {children: ReactNode}) => (
+    <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+  );
+
+  return {queryClient, ...renderHook(callback, {wrapper})};
+}
+
+describe('workflow run API hooks', () => {
+  afterEach(() => {
+    cleanup();
+    configureApiClient({baseUrl: '', fetchImpl: undefined});
+  });
+
+  test('maps list DTO pages to workflow run models while keeping the cache DTO-shaped', async () => {
+    const body = workflowRunListResponseDto({
+      runs: [
+        workflowRunDto({
+          id: RUN_ID,
+          trigger_provider: 'github',
+          trigger_source: 'github_acme',
+          trigger_event: 'push',
+          updated_at: '2026-05-07T01:02:00.000Z',
+        }),
+      ],
+      next_cursor: 'cursor-2',
+      filtered_total_count: 8,
+    });
+    const fetchImpl = vi.fn(async () => jsonResponse(body));
+    configureApiClient({baseUrl: 'https://api.example.test', fetchImpl});
+
+    const {result, queryClient} = renderWithQueryClient(() =>
+      useWorkflowRunsInfiniteQuery(PROJECT_ID, {}),
+    );
+
+    await waitFor(() =>
+      expect(result.current.data?.pages[0]?.runs[0]?.triggerSource).toBe('github_acme'),
+    );
+    expect(result.current.data?.pages[0]?.runs[0]).toMatchObject({
+      id: RUN_ID,
+      triggerProvider: 'github',
+      triggerSource: 'github_acme',
+      triggerEvent: 'push',
+      triggerDisplayLabel: 'push',
+      triggerLabel: 'github_acme · push',
+      updatedAt: '2026-05-07T01:02:00.000Z',
+      isTemporary: false,
+    });
+    expect(result.current.data?.pages[0]?.nextCursor).toBe('cursor-2');
+    expect(result.current.data?.pages[0]?.filteredTotalCount).toBe(8);
+
+    const cached = queryClient.getQueryData<
+      InfiniteData<WorkflowRunListResponseDto, string | undefined>
+    >(workflowRunsQueryKeys.list(PROJECT_ID, {}));
+    expect(cached?.pages[0]?.runs[0]).toMatchObject({
+      trigger_provider: 'github',
+      trigger_source: 'github_acme',
+      trigger_event: 'push',
+      updated_at: '2026-05-07T01:02:00.000Z',
+    });
+    expect(cached?.pages[0]).not.toHaveProperty('nextCursor');
+  });
+
+  test('maps detail DTOs to nested workflow run detail models while keeping the cache DTO-shaped', async () => {
+    const body = workflowRunDetailDto({
+      id: RUN_ID,
+      trigger_source: 'manual',
+      trigger_event: 'fire',
+      jobs: [workflowJobDto({run_attempt_id: RUN_ID, name: 'build'})],
+    });
+    const fetchImpl = vi.fn(async () => jsonResponse(body));
+    configureApiClient({baseUrl: 'https://api.example.test', fetchImpl});
+
+    const {result, queryClient} = renderWithQueryClient(() => useWorkflowRunQuery(RUN_ID));
+
+    await waitFor(() => expect(result.current.data?.triggerSource).toBe('manual'));
+    expect(result.current.data).toMatchObject({
+      id: RUN_ID,
+      triggerSource: 'manual',
+      triggerEvent: 'fire',
+      triggerDisplayLabel: 'fire',
+      triggerLabel: 'manual · fire',
+      jobs: [{name: 'build', runAttemptId: RUN_ID}],
+    });
+
+    const cached = queryClient.getQueryData<WorkflowRunDetailResponseDto>(
+      workflowRunsQueryKeys.detail(RUN_ID),
+    );
+    expect(cached).toMatchObject({
+      id: RUN_ID,
+      trigger_source: 'manual',
+      trigger_event: 'fire',
+      jobs: [{name: 'build', run_attempt_id: RUN_ID}],
+    });
+    expect(cached).not.toHaveProperty('triggerSource');
+  });
+
+  test('maps run attempts and caches them by workflow run id', async () => {
+    const body = runAttemptsResponseDto({
+      attempts: [
+        workflowRunAttemptDto({
+          id: ROOT_RUN_ID,
+          attempt: 1,
+          status: 'succeeded',
+          created_at: '2026-05-07T01:00:00.000Z',
+        }),
+        workflowRunAttemptDto({
+          id: RUN_ID,
+          attempt: 2,
+          status: 'failed',
+          created_at: '2026-05-07T01:02:00.000Z',
+          rerun_mode: 'all',
+        }),
+      ],
+    });
+    const fetchImpl = vi.fn(async () => jsonResponse(body));
+    configureApiClient({baseUrl: 'https://api.example.test', fetchImpl});
+
+    const {result, queryClient} = renderWithQueryClient(() =>
+      useWorkflowRunAttemptsQuery({workflowRunId: RUN_ID, enabled: true}),
+    );
+
+    await waitFor(() => expect(result.current.data?.[1]?.attempt).toBe(2));
+    expect(result.current.data?.[1]).toMatchObject({
+      id: RUN_ID,
+      status: 'failed',
+      createdAt: '2026-05-07T01:02:00.000Z',
+      rerunMode: 'all',
+    });
+    expect(firstRequest(fetchImpl).url).toBe(
+      `https://api.example.test/workflows/runs/${RUN_ID}/attempts`,
+    );
+    expect(queryClient.getQueryData(workflowRunsQueryKeys.attempts(RUN_ID))).toEqual(body);
+  });
+
+  test('posts manual fire requests with and without inputs', async () => {
+    const postBodies: unknown[] = [];
+    const fetchImpl = vi.fn(async (input: RequestInfo | URL) => {
+      postBodies.push(await (input as Request).clone().json());
+      return jsonResponse({workflow_run_id: RUN_ID}, {status: 201});
+    });
+    configureApiClient({baseUrl: 'https://api.example.test', fetchImpl});
+
+    const withoutInputs = await fireManualWorkflow({definitionId: DEFINITION_ID});
+    const withInputs = await fireManualWorkflow({
+      definitionId: DEFINITION_ID,
+      inputs: {env: 'production'},
+    });
+
+    expect(withoutInputs.workflow_run_id).toBe(RUN_ID);
+    expect(withInputs.workflow_run_id).toBe(RUN_ID);
+    expect(postBodies).toEqual([{}, {inputs: {env: 'production'}}]);
+    expect(firstRequest(fetchImpl).url).toBe(
+      `https://api.example.test/workflow-definitions/${DEFINITION_ID}/fire-manual`,
+    );
+    expect(firstRequest(fetchImpl).method).toBe('POST');
+  });
+
+  test('optimistically inserts manual runs into the same list cache prefix read by the rail', async () => {
+    let resolveFire: ((response: Response) => void) | undefined;
+    const fetchImpl = vi.fn(
+      () =>
+        new Promise<Response>((resolve) => {
+          resolveFire = resolve;
+        }),
+    );
+    configureApiClient({baseUrl: 'https://api.example.test', fetchImpl});
+    const {result, queryClient} = renderWithQueryClient(() => useFireManualWorkflowMutation());
+    const listKey = workflowRunsQueryKeys.list(PROJECT_ID, {});
+    queryClient.setQueryData<InfiniteData<WorkflowRunListResponseDto, string | undefined>>(
+      listKey,
+      {
+        pages: [workflowRunListResponseDto({runs: [], filtered_total_count: 0})],
+        pageParams: [undefined],
+      },
+    );
+
+    const railListEntries = queryClient.getQueriesData({
+      queryKey: workflowRunsQueryKeys.lists(PROJECT_ID),
+    });
+    expect(railListEntries.map(([queryKey]) => queryKey)).toContainEqual(listKey);
+
+    act(() => {
+      result.current.mutate({projectId: PROJECT_ID, definitionId: DEFINITION_ID});
+    });
+
+    await waitFor(() => {
+      const cached =
+        queryClient.getQueryData<InfiniteData<WorkflowRunListResponseDto, string | undefined>>(
+          listKey,
+        );
+      expect(cached?.pages[0]?.runs[0]).toMatchObject({
+        project_id: PROJECT_ID,
+        definition_id: DEFINITION_ID,
+        status: 'pending',
+        trigger_source: 'manual',
+        trigger_provider: null,
+      });
+      expect(cached?.pages[0]?.runs[0]?.id).toMatch(TEMP_RUN_ID_PATTERN);
+      expect(cached?.pages[0]?.filtered_total_count).toBe(1);
+    });
+
+    if (!resolveFire) throw new Error('Expected manual fire request');
+    const completeFire = resolveFire;
+    act(() => {
+      completeFire(jsonResponse({workflow_run_id: RUN_ID}, {status: 201}));
+    });
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+  });
+
+  test('does not remove newer optimistic manual runs when an older manual fire fails', async () => {
+    const fireRequests: Array<{resolve: (response: Response) => void}> = [];
+    const fetchImpl = vi.fn(
+      () =>
+        new Promise<Response>((resolve) => {
+          fireRequests.push({resolve});
+        }),
+    );
+    configureApiClient({baseUrl: 'https://api.example.test', fetchImpl});
+    const {result, queryClient} = renderWithQueryClient(() => useFireManualWorkflowMutation());
+    const listKey = workflowRunsQueryKeys.list(PROJECT_ID, {});
+    queryClient.setQueryData<InfiniteData<WorkflowRunListResponseDto, string | undefined>>(
+      listKey,
+      {
+        pages: [workflowRunListResponseDto({runs: [], filtered_total_count: 0})],
+        pageParams: [undefined],
+      },
+    );
+
+    act(() => {
+      result.current.mutate({projectId: PROJECT_ID, definitionId: DEFINITION_ID});
+    });
+    await waitFor(() => expect(fireRequests).toHaveLength(1));
+    const firstFire = fireRequests[0];
+    if (!firstFire) throw new Error('Expected first manual fire request');
+
+    await waitFor(() => {
+      const cached =
+        queryClient.getQueryData<InfiniteData<WorkflowRunListResponseDto, string | undefined>>(
+          listKey,
+        );
+      expect(cached?.pages[0]?.runs).toHaveLength(1);
+      expect(cached?.pages[0]?.filtered_total_count).toBe(1);
+    });
+
+    act(() => {
+      result.current.mutate({projectId: PROJECT_ID, definitionId: DEFINITION_ID});
+    });
+    await waitFor(() => expect(fireRequests).toHaveLength(2));
+    const secondFire = fireRequests[1];
+    if (!secondFire) throw new Error('Expected second manual fire request');
+
+    let secondTempWorkflowRunId: string | undefined;
+    await waitFor(() => {
+      const cached =
+        queryClient.getQueryData<InfiniteData<WorkflowRunListResponseDto, string | undefined>>(
+          listKey,
+        );
+      expect(cached?.pages[0]?.runs).toHaveLength(2);
+      expect(cached?.pages[0]?.filtered_total_count).toBe(2);
+      secondTempWorkflowRunId = cached?.pages[0]?.runs[0]?.id;
+      expect(secondTempWorkflowRunId).toMatch(TEMP_RUN_ID_PATTERN);
+    });
+
+    act(() => {
+      firstFire.resolve(jsonResponse({code: 'server-error'}, {status: 500}));
+    });
+
+    await waitFor(() => {
+      const cached =
+        queryClient.getQueryData<InfiniteData<WorkflowRunListResponseDto, string | undefined>>(
+          listKey,
+        );
+      expect(cached?.pages[0]?.runs.map((run) => run.id)).toEqual([secondTempWorkflowRunId]);
+      expect(cached?.pages[0]?.filtered_total_count).toBe(1);
+    });
+
+    act(() => {
+      secondFire.resolve(jsonResponse({workflow_run_id: RUN_ID}, {status: 201}));
+    });
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+  });
+
+  test('does not fetch run attempts while disabled', () => {
+    const fetchImpl = vi.fn(async () => jsonResponse(runAttemptsResponseDto()));
+    configureApiClient({baseUrl: 'https://api.example.test', fetchImpl});
+
+    renderWithQueryClient(() =>
+      useWorkflowRunAttemptsQuery({workflowRunId: RUN_ID, enabled: false}),
+    );
+
+    expect(fetchImpl).not.toHaveBeenCalled();
+  });
+
+  test('cancels a workflow run and invalidates detail and list queries', async () => {
+    const body = workflowRunDto({id: RUN_ID, project_id: PROJECT_ID, status: 'cancelled'});
+    const fetchImpl = vi.fn(async () => jsonResponse(body));
+    configureApiClient({baseUrl: 'https://api.example.test', fetchImpl});
+    const run = workflowRunDto({id: RUN_ID, project_id: PROJECT_ID, status: 'running'});
+    const {result, queryClient} = renderWithQueryClient(() =>
+      useCancelWorkflowRunMutation(toWorkflowRun(run)),
+    );
+    const invalidateSpy = vi.spyOn(queryClient, 'invalidateQueries');
+
+    let cancelled: Awaited<ReturnType<typeof result.current.mutateAsync>> | undefined;
+    await act(async () => {
+      cancelled = await result.current.mutateAsync();
+    });
+
+    const calls = fetchImpl.mock.calls as unknown as Array<[Request]>;
+    const request = calls[0]?.[0];
+    if (!request) throw new Error('Expected cancel request');
+    expect(request.url).toBe(
+      'https://api.example.test/workflows/runs/66666666-6666-4666-8666-666666666666/cancel',
+    );
+    expect(request.method).toBe('POST');
+    expect(cancelled?.status).toBe('cancelled');
+    expect(invalidateSpy).toHaveBeenCalledWith({queryKey: workflowRunsQueryKeys.detail(RUN_ID)});
+    expect(invalidateSpy).toHaveBeenCalledWith({queryKey: workflowRunsQueryKeys.lists(PROJECT_ID)});
+  });
+
+  test('posts rerun mode and invalidates project run lists and attempt lineage', async () => {
+    const postBodies: unknown[] = [];
+    const fetchImpl = vi.fn(async (input: RequestInfo | URL) => {
+      const request = input as Request;
+      postBodies.push(await request.clone().json());
+      return jsonResponse(
+        workflowRunDto({
+          id: '77777777-7777-4777-8777-777777777777',
+          current_attempt: 2,
+          latest_attempt: 2,
+          status: 'pending',
+        }),
+      );
+    });
+    configureApiClient({baseUrl: 'https://api.example.test', fetchImpl});
+
+    const {result, queryClient} = renderWithQueryClient(() =>
+      useRerunWorkflowRunMutation(PROJECT_ID),
+    );
+    const invalidateSpy = vi.spyOn(queryClient, 'invalidateQueries');
+
+    await act(async () => {
+      await result.current.mutateAsync({workflowRunId: RUN_ID, mode: 'failed'});
+    });
+
+    const request = firstRequest(fetchImpl);
+    expect(request.url).toBe(`https://api.example.test/workflows/runs/${RUN_ID}/rerun`);
+    expect(request.method).toBe('POST');
+    expect(postBodies).toEqual([{mode: 'failed'}]);
+    expect(invalidateSpy).toHaveBeenCalledWith({
+      queryKey: workflowRunsQueryKeys.lists(PROJECT_ID),
+    });
+    expect(invalidateSpy).toHaveBeenCalledWith({
+      queryKey: workflowRunsQueryKeys.detail(RUN_ID),
+    });
+    expect(invalidateSpy).toHaveBeenCalledWith({
+      queryKey: workflowRunsQueryKeys.attempts(RUN_ID),
+    });
+  });
+});
+
+function firstRequest(fetchImpl: ReturnType<typeof vi.fn>): Request {
+  const input = (fetchImpl.mock.calls as unknown[][])[0]?.[0];
+  if (!(input instanceof Request)) throw new Error('Expected fetch to receive a Request');
+  return input;
+}