@shipfox/client-workflows 5.0.0 → 6.0.2

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

@@ -1,12 +1,8 @@
-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 type {WorkflowRunListPage} from '#core/workflow-run.js';
 import {
   runAttemptsResponseDto,
   workflowJobDto,
@@ -15,6 +11,7 @@ import {
   workflowRunDto,
   workflowRunListResponseDto,
 } from '#test/fixtures/workflow-run.js';
+import {toWorkflowRun, toWorkflowRunListPage} from './workflow-run-mapper.js';
 import {
   fireManualWorkflow,
   useCancelWorkflowRunMutation,
@@ -55,7 +52,7 @@ describe('workflow run API hooks', () => {
     configureApiClient({baseUrl: '', fetchImpl: undefined});
   });
 
-  test('maps list DTO pages to workflow run models while keeping the cache DTO-shaped', async () => {
+  test('maps list DTO pages to workflow run models before caching', async () => {
     const body = workflowRunListResponseDto({
       runs: [
         workflowRunDto({
@@ -92,19 +89,19 @@ describe('workflow run API hooks', () => {
     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, {}));
+    const cached = queryClient.getQueryData<InfiniteData<WorkflowRunListPage, 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',
+      triggerProvider: 'github',
+      triggerSource: 'github_acme',
+      triggerEvent: 'push',
+      updatedAt: '2026-05-07T01:02:00.000Z',
     });
-    expect(cached?.pages[0]).not.toHaveProperty('nextCursor');
+    expect(cached?.pages[0]).toHaveProperty('nextCursor', 'cursor-2');
   });
 
-  test('maps detail DTOs to nested workflow run detail models while keeping the cache DTO-shaped', async () => {
+  test('maps detail DTOs to nested workflow run detail models before caching', async () => {
     const body = workflowRunDetailDto({
       id: RUN_ID,
       trigger_source: 'manual',
@@ -126,16 +123,25 @@ describe('workflow run API hooks', () => {
       jobs: [{name: 'build', runAttemptId: RUN_ID}],
     });
 
-    const cached = queryClient.getQueryData<WorkflowRunDetailResponseDto>(
-      workflowRunsQueryKeys.detail(RUN_ID),
-    );
+    const cached = queryClient.getQueryData(workflowRunsQueryKeys.detail(RUN_ID));
     expect(cached).toMatchObject({
       id: RUN_ID,
-      trigger_source: 'manual',
-      trigger_event: 'fire',
-      jobs: [{name: 'build', run_attempt_id: RUN_ID}],
+      triggerSource: 'manual',
+      triggerEvent: 'fire',
+      jobs: [{name: 'build', runAttemptId: RUN_ID}],
     });
-    expect(cached).not.toHaveProperty('triggerSource');
+    expect(cached).toHaveProperty('triggerSource', 'manual');
+  });
+
+  test('rejects malformed detail responses before they reach the query cache', async () => {
+    const fetchImpl = vi.fn(async () => jsonResponse({id: RUN_ID, trigger_source: 'manual'}));
+    configureApiClient({baseUrl: 'https://api.example.test', fetchImpl});
+
+    const {result, queryClient} = renderWithQueryClient(() => useWorkflowRunQuery(RUN_ID));
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    expect(result.current.error).toMatchObject({code: 'invalid-response'});
+    expect(queryClient.getQueryData(workflowRunsQueryKeys.detail(RUN_ID))).toBeUndefined();
   });
 
   test('maps run attempts and caches them by workflow run id', async () => {
@@ -173,7 +179,9 @@ describe('workflow run API hooks', () => {
     expect(firstRequest(fetchImpl).url).toBe(
       `https://api.example.test/workflows/runs/${RUN_ID}/attempts`,
     );
-    expect(queryClient.getQueryData(workflowRunsQueryKeys.attempts(RUN_ID))).toEqual(body);
+    expect(queryClient.getQueryData(workflowRunsQueryKeys.attempts(RUN_ID))).toEqual(
+      result.current.data,
+    );
   });
 
   test('posts manual fire requests with and without inputs', async () => {
@@ -190,8 +198,8 @@ describe('workflow run API hooks', () => {
       inputs: {env: 'production'},
     });
 
-    expect(withoutInputs.workflow_run_id).toBe(RUN_ID);
-    expect(withInputs.workflow_run_id).toBe(RUN_ID);
+    expect(withoutInputs.workflowRunId).toBe(RUN_ID);
+    expect(withInputs.workflowRunId).toBe(RUN_ID);
     expect(postBodies).toEqual([{}, {inputs: {env: 'production'}}]);
     expect(firstRequest(fetchImpl).url).toBe(
       `https://api.example.test/workflow-definitions/${DEFINITION_ID}/fire-manual`,
@@ -210,13 +218,12 @@ describe('workflow run API hooks', () => {
     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],
-      },
-    );
+    queryClient.setQueryData<InfiniteData<WorkflowRunListPage, string | undefined>>(listKey, {
+      pages: [
+        toWorkflowRunListPage(workflowRunListResponseDto({runs: [], filtered_total_count: 0})),
+      ],
+      pageParams: [undefined],
+    });
 
     const railListEntries = queryClient.getQueriesData({
       queryKey: workflowRunsQueryKeys.lists(PROJECT_ID),
@@ -229,18 +236,16 @@ describe('workflow run API hooks', () => {
 
     await waitFor(() => {
       const cached =
-        queryClient.getQueryData<InfiniteData<WorkflowRunListResponseDto, string | undefined>>(
-          listKey,
-        );
+        queryClient.getQueryData<InfiniteData<WorkflowRunListPage, string | undefined>>(listKey);
       expect(cached?.pages[0]?.runs[0]).toMatchObject({
-        project_id: PROJECT_ID,
-        definition_id: DEFINITION_ID,
+        projectId: PROJECT_ID,
+        definitionId: DEFINITION_ID,
         status: 'pending',
-        trigger_source: 'manual',
-        trigger_provider: null,
+        triggerSource: 'manual',
+        triggerProvider: null,
       });
       expect(cached?.pages[0]?.runs[0]?.id).toMatch(TEMP_RUN_ID_PATTERN);
-      expect(cached?.pages[0]?.filtered_total_count).toBe(1);
+      expect(cached?.pages[0]?.filteredTotalCount).toBe(1);
     });
 
     if (!resolveFire) throw new Error('Expected manual fire request');
@@ -262,13 +267,12 @@ describe('workflow run API hooks', () => {
     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],
-      },
-    );
+    queryClient.setQueryData<InfiniteData<WorkflowRunListPage, string | undefined>>(listKey, {
+      pages: [
+        toWorkflowRunListPage(workflowRunListResponseDto({runs: [], filtered_total_count: 0})),
+      ],
+      pageParams: [undefined],
+    });
 
     act(() => {
       result.current.mutate({projectId: PROJECT_ID, definitionId: DEFINITION_ID});
@@ -279,11 +283,9 @@ describe('workflow run API hooks', () => {
 
     await waitFor(() => {
       const cached =
-        queryClient.getQueryData<InfiniteData<WorkflowRunListResponseDto, string | undefined>>(
-          listKey,
-        );
+        queryClient.getQueryData<InfiniteData<WorkflowRunListPage, string | undefined>>(listKey);
       expect(cached?.pages[0]?.runs).toHaveLength(1);
-      expect(cached?.pages[0]?.filtered_total_count).toBe(1);
+      expect(cached?.pages[0]?.filteredTotalCount).toBe(1);
     });
 
     act(() => {
@@ -296,11 +298,9 @@ describe('workflow run API hooks', () => {
     let secondTempWorkflowRunId: string | undefined;
     await waitFor(() => {
       const cached =
-        queryClient.getQueryData<InfiniteData<WorkflowRunListResponseDto, string | undefined>>(
-          listKey,
-        );
+        queryClient.getQueryData<InfiniteData<WorkflowRunListPage, string | undefined>>(listKey);
       expect(cached?.pages[0]?.runs).toHaveLength(2);
-      expect(cached?.pages[0]?.filtered_total_count).toBe(2);
+      expect(cached?.pages[0]?.filteredTotalCount).toBe(2);
       secondTempWorkflowRunId = cached?.pages[0]?.runs[0]?.id;
       expect(secondTempWorkflowRunId).toMatch(TEMP_RUN_ID_PATTERN);
     });
@@ -311,11 +311,9 @@ describe('workflow run API hooks', () => {
 
     await waitFor(() => {
       const cached =
-        queryClient.getQueryData<InfiniteData<WorkflowRunListResponseDto, string | undefined>>(
-          listKey,
-        );
+        queryClient.getQueryData<InfiniteData<WorkflowRunListPage, string | undefined>>(listKey);
       expect(cached?.pages[0]?.runs.map((run) => run.id)).toEqual([secondTempWorkflowRunId]);
-      expect(cached?.pages[0]?.filtered_total_count).toBe(1);
+      expect(cached?.pages[0]?.filteredTotalCount).toBe(1);
     });
 
     act(() => {

package/src/hooks/api/workflow-runs.ts

@@ -1,16 +1,20 @@
-import type {
-  RerunWorkflowRunBodyDto,
-  WorkflowRunAttemptsResponseDto,
-  WorkflowRunDetailResponseDto,
-  WorkflowRunDto,
-  WorkflowRunListResponseDto,
-  WorkflowRunRerunModeDto,
-  WorkflowRunResponseDto,
+import {
+  type RerunWorkflowRunBodyDto,
+  type WorkflowRunRerunModeDto,
+  workflowRunAttemptsResponseSchema,
+  workflowRunDetailResponseSchema,
+  workflowRunDtoSchema,
+  workflowRunListResponseSchema,
+  workflowRunResponseSchema,
 } from '@shipfox/api-workflows-dto';
-import {apiRequest} from '@shipfox/client-api';
+import {checkedApiRequest, type StandardSchema} from '@shipfox/client-api';
 import {
   type InfiniteData,
+  infiniteQueryOptions,
   keepPreviousData,
+  queryOptions,
+  type UseInfiniteQueryOptions,
+  type UseQueryOptions,
   useInfiniteQuery,
   useMutation,
   useQuery,
@@ -18,16 +22,21 @@ import {
 } from '@tanstack/react-query';
 import {
   isWorkflowRunTerminal,
-  toWorkflowRunAttempt,
-  toWorkflowRunDetail,
-  toWorkflowRunListItem,
-  toWorkflowRunListPage,
+  type ManualWorkflowLaunch,
   type WorkflowRun,
   type WorkflowRunAttempt,
+  WorkflowRunAttemptSummary,
   type WorkflowRunDetail,
+  type WorkflowRunListItem,
   type WorkflowRunListPage,
   type WorkflowRunStatus,
 } from '#core/workflow-run.js';
+import {
+  toWorkflowRunAttempt,
+  toWorkflowRunDetail,
+  toWorkflowRunListItem,
+  toWorkflowRunListPage,
+} from './workflow-run-mapper.js';
 
 export interface WorkflowRunFilters {
   status?: WorkflowRunStatus | undefined;
@@ -48,6 +57,35 @@ export const workflowRunsQueryKeys = {
     [...workflowRunsQueryKeys.all, 'attempts', workflowRunId] as const,
 };
 
+type WorkflowRunsListQueryKey =
+  | ReturnType<typeof workflowRunsQueryKeys.list>
+  | readonly ['workflow-runs', 'list'];
+type WorkflowRunDetailQueryKey =
+  | ReturnType<typeof workflowRunsQueryKeys.detail>
+  | readonly ['workflow-runs', 'detail'];
+type WorkflowRunAttemptsQueryKey =
+  | ReturnType<typeof workflowRunsQueryKeys.attempts>
+  | readonly ['workflow-runs', 'attempts'];
+type WorkflowRunsInfiniteQueryOptions = UseInfiniteQueryOptions<
+  WorkflowRunListPage,
+  Error,
+  InfiniteData<WorkflowRunListPage, string | undefined>,
+  WorkflowRunsListQueryKey,
+  string | undefined
+>;
+type WorkflowRunDetailQueryOptions = UseQueryOptions<
+  WorkflowRunDetail,
+  Error,
+  WorkflowRunDetail,
+  WorkflowRunDetailQueryKey
+>;
+type WorkflowRunAttemptsQueryOptions = UseQueryOptions<
+  WorkflowRunAttempt[],
+  Error,
+  WorkflowRunAttempt[],
+  WorkflowRunAttemptsQueryKey
+>;
+
 function normalizeFilters(filters: WorkflowRunFilters) {
   return {
     status: filters.status ?? null,
@@ -66,7 +104,7 @@ function appendFilters(params: URLSearchParams, filters: WorkflowRunFilters) {
   if (filters.createdTo) params.set('created_to', filters.createdTo);
 }
 
-async function listWorkflowRunsDto({
+async function listWorkflowRuns({
   projectId,
   filters,
   limit = 50,
@@ -78,13 +116,16 @@ async function listWorkflowRunsDto({
   limit?: number;
   cursor?: string | undefined;
   signal?: AbortSignal;
-}) {
+}): Promise<WorkflowRunListPage> {
   const params = new URLSearchParams({project_id: projectId, limit: String(limit)});
   if (cursor) params.set('cursor', cursor);
   appendFilters(params, filters);
-  return await apiRequest<WorkflowRunListResponseDto>(`/workflows/runs?${params.toString()}`, {
-    signal,
-  });
+  const response = await checkedApiRequest(
+    workflowRunListResponseSchema,
+    `/workflows/runs?${params.toString()}`,
+    {signal},
+  );
+  return toWorkflowRunListPage(response);
 }
 
 /**
@@ -100,35 +141,36 @@ export async function fireManualWorkflow({
 }: {
   definitionId: string;
   inputs?: Record<string, unknown>;
-}) {
-  return await apiRequest<{workflow_run_id: string}>(
+}): Promise<ManualWorkflowLaunch> {
+  const response = await checkedApiRequest(
+    manualWorkflowResponseSchema,
     `/workflow-definitions/${definitionId}/fire-manual`,
     {
       method: 'POST',
       body: inputs ? {inputs} : {},
     },
   );
+  return {workflowRunId: response.workflow_run_id};
 }
 
 const ACTIVE_POLL_MS = 4_000;
 const IDLE_POLL_MS = 30_000;
 
-type RunListInfinite = InfiniteData<WorkflowRunListResponseDto, string | undefined>;
-
-function toWorkflowRunInfiniteData(
-  data: InfiniteData<WorkflowRunListResponseDto, string | undefined>,
-): InfiniteData<WorkflowRunListPage, string | undefined> {
-  return {
-    ...data,
-    pages: data.pages.map(toWorkflowRunListPage),
-  };
-}
+type RunListInfinite = InfiniteData<WorkflowRunListPage, string | undefined>;
 
 export function useWorkflowRunsInfiniteQuery(
   projectId: string | undefined,
   filters: WorkflowRunFilters,
   limit = 50,
 ) {
+  return useInfiniteQuery(workflowRunsInfiniteQueryOptions(projectId, filters, limit));
+}
+
+export function workflowRunsInfiniteQueryOptions(
+  projectId: string | undefined,
+  filters: WorkflowRunFilters,
+  limit = 50,
+): WorkflowRunsInfiniteQueryOptions {
   // Polling is owned by react-query, not the page. Polling fast (4s) while
   // any non-terminal run is visible covers state transitions; polling slow
   // (30s) when idle covers brand-new external runs (webhook/schedule
@@ -140,16 +182,15 @@ export function useWorkflowRunsInfiniteQuery(
   // of rows can drop into a between-pages gap. Users who scrolled into
   // history opted into "reading mode": pause until they refocus, filter,
   // or scroll back.
-  return useInfiniteQuery({
+  return infiniteQueryOptions({
     queryKey: projectId
       ? workflowRunsQueryKeys.list(projectId, filters)
-      : [...workflowRunsQueryKeys.all, 'list'],
+      : ([...workflowRunsQueryKeys.all, 'list'] as const),
     enabled: Boolean(projectId),
     initialPageParam: undefined as string | undefined,
     queryFn: ({pageParam, signal}) =>
-      listWorkflowRunsDto({projectId: projectId ?? '', filters, limit, cursor: pageParam, signal}),
-    getNextPageParam: (lastPage) => lastPage.next_cursor ?? undefined,
-    select: toWorkflowRunInfiniteData,
+      listWorkflowRuns({projectId: projectId ?? '', filters, limit, cursor: pageParam, signal}),
+    getNextPageParam: (lastPage) => lastPage.nextCursor ?? undefined,
     placeholderData: keepPreviousData,
     staleTime: 2_000,
     refetchOnWindowFocus: true,
@@ -165,7 +206,7 @@ export function useWorkflowRunsInfiniteQuery(
   });
 }
 
-async function getWorkflowRunDto({
+async function getWorkflowRun({
   workflowRunId,
   runAttempt,
   signal,
@@ -173,37 +214,48 @@ async function getWorkflowRunDto({
   workflowRunId: string;
   runAttempt?: number | undefined;
   signal?: AbortSignal;
-}) {
+}): Promise<WorkflowRunDetail> {
   const params = new URLSearchParams();
   if (runAttempt) params.set('attempt', String(runAttempt));
   const query = params.size > 0 ? `?${params.toString()}` : '';
-  return await apiRequest<WorkflowRunDetailResponseDto>(
-    `/workflows/runs/${workflowRunId}${query}`,
-    {
-      signal,
-    },
+  return toWorkflowRunDetail(
+    await checkedApiRequest(
+      workflowRunDetailResponseSchema,
+      `/workflows/runs/${workflowRunId}${query}`,
+      {
+        signal,
+      },
+    ),
   );
 }
 
-async function getWorkflowRunAttemptsDto({
+async function getWorkflowRunAttempts({
   workflowRunId,
   signal,
 }: {
   workflowRunId: string;
   signal?: AbortSignal;
-}) {
-  return await apiRequest<WorkflowRunAttemptsResponseDto>(
+}): Promise<WorkflowRunAttempt[]> {
+  const response = await checkedApiRequest(
+    workflowRunAttemptsResponseSchema,
     `/workflows/runs/${workflowRunId}/attempts`,
     {
       signal,
     },
   );
+  return response.attempts.map(toWorkflowRunAttempt);
 }
 
-async function cancelWorkflowRunDto({workflowRunId}: {workflowRunId: string}) {
-  return await apiRequest<WorkflowRunDto>(`/workflows/runs/${workflowRunId}/cancel`, {
-    method: 'POST',
-  });
+async function cancelWorkflowRun({
+  workflowRunId,
+}: {
+  workflowRunId: string;
+}): Promise<WorkflowRunListItem> {
+  return toWorkflowRunListItem(
+    await checkedApiRequest(workflowRunDtoSchema, `/workflows/runs/${workflowRunId}/cancel`, {
+      method: 'POST',
+    }),
+  );
 }
 
 export async function rerunWorkflowRun({
@@ -212,13 +264,32 @@ export async function rerunWorkflowRun({
 }: {
   workflowRunId: string;
   mode: WorkflowRunRerunModeDto;
-}) {
-  return await apiRequest<WorkflowRunResponseDto>(`/workflows/runs/${workflowRunId}/rerun`, {
-    method: 'POST',
-    body: {mode} satisfies RerunWorkflowRunBodyDto,
-  });
+}): Promise<WorkflowRunListItem> {
+  return toWorkflowRunListItem(
+    await checkedApiRequest(workflowRunResponseSchema, `/workflows/runs/${workflowRunId}/rerun`, {
+      method: 'POST',
+      body: {mode} satisfies RerunWorkflowRunBodyDto,
+    }),
+  );
 }
 
+const manualWorkflowResponseSchema: StandardSchema<unknown, {workflow_run_id: string}> = {
+  '~standard': {
+    version: 1,
+    vendor: 'client-workflows',
+    validate: (value) => {
+      if (
+        typeof value === 'object' &&
+        value !== null &&
+        'workflow_run_id' in value &&
+        typeof value.workflow_run_id === 'string'
+      )
+        return {value: {workflow_run_id: value.workflow_run_id}};
+      return {issues: [{message: 'Expected workflow_run_id.'}]};
+    },
+  },
+};
+
 export function useRerunWorkflowRunMutation(projectId: string) {
   const queryClient = useQueryClient();
 
@@ -261,25 +332,36 @@ function buildTempRun({
   definitionId: string;
   name: string;
   createdAt: string;
-}): WorkflowRunDto {
+}): WorkflowRunListItem {
+  const id = `temp-${cryptoRandomId()}`;
   return {
-    id: `temp-${cryptoRandomId()}`,
-    project_id: projectId,
-    definition_id: definitionId,
+    id,
+    projectId,
+    definitionId,
     name,
     status: 'pending',
-    current_attempt: 1,
-    latest_attempt: 1,
-    trigger_provider: null,
-    trigger_source: 'manual',
-    trigger_event: 'fire',
-    trigger_payload: {source: 'manual', event: 'fire'},
+    currentAttempt: 1,
+    latestAttempt: 1,
+    triggerProvider: null,
+    triggerSource: 'manual',
+    triggerEvent: 'fire',
+    triggerPayload: {source: 'manual', event: 'fire'},
+    triggerDisplayLabel: 'fire',
+    triggerLabel: 'manual · fire',
     inputs: null,
-    source_snapshot: null,
-    created_at: createdAt,
-    updated_at: createdAt,
-    started_at: null,
-    finished_at: null,
+    sourceSnapshot: null,
+    createdAt,
+    updatedAt: createdAt,
+    shortId: id.slice(0, 8),
+    isTemporary: true,
+    runAttempt: new WorkflowRunAttemptSummary({
+      workflowRunId: id,
+      attempt: 1,
+      status: 'pending',
+      createdAt,
+      startedAt: null,
+      finishedAt: null,
+    }),
   };
 }
 
@@ -334,11 +416,11 @@ export function useFireManualWorkflowMutation() {
           if (!current || current.pages.length === 0) return current;
           const firstPage = current.pages[0];
           if (!firstPage) return current;
-          const nextFirstPage: WorkflowRunListResponseDto = {
+          const nextFirstPage: WorkflowRunListPage = {
             ...firstPage,
             runs: [tempRun, ...firstPage.runs],
-            filtered_total_count:
-              firstPage.filtered_total_count != null ? firstPage.filtered_total_count + 1 : null,
+            filteredTotalCount:
+              firstPage.filteredTotalCount != null ? firstPage.filteredTotalCount + 1 : null,
           };
           return {...current, pages: [nextFirstPage, ...current.pages.slice(1)]};
         });
@@ -362,9 +444,9 @@ export function useFireManualWorkflowMutation() {
             return {
               ...page,
               runs,
-              filtered_total_count:
-                page.filtered_total_count != null
-                  ? Math.max(0, page.filtered_total_count - removedCount)
+              filteredTotalCount:
+                page.filteredTotalCount != null
+                  ? Math.max(0, page.filteredTotalCount - removedCount)
                   : null,
             };
           });
@@ -401,7 +483,7 @@ function lookupDefinitionName(
   definitionId: string,
 ): string | undefined {
   const entries = queryClient.getQueriesData<
-    InfiniteData<{definitions: Array<{id: string; project_id: string; name: string}>}>
+    InfiniteData<{definitions: Array<{id: string; name: string}>}>
   >({queryKey: ['definitions', 'list', projectId]});
   for (const [, data] of entries) {
     if (!data) continue;
@@ -424,21 +506,29 @@ export function useWorkflowRunAttemptQuery({
   workflowRunId: string | undefined;
   runAttempt?: number | undefined;
 }) {
+  return useQuery(workflowRunQueryOptions({workflowRunId, runAttempt}));
+}
+
+export function workflowRunQueryOptions({
+  workflowRunId,
+  runAttempt,
+}: {
+  workflowRunId: string | undefined;
+  runAttempt?: number | undefined;
+}): WorkflowRunDetailQueryOptions {
   // Poll a non-terminal run so the open run detail stays live (same cadence as the run
   // list); stop once the run is terminal.
-  return useQuery({
+  return queryOptions({
     queryKey: workflowRunId
       ? workflowRunsQueryKeys.detail(workflowRunId, runAttempt)
-      : [...workflowRunsQueryKeys.all, 'detail'],
+      : ([...workflowRunsQueryKeys.all, 'detail'] as const),
     enabled: Boolean(workflowRunId),
-    queryFn: ({signal}) =>
-      getWorkflowRunDto({workflowRunId: workflowRunId ?? '', runAttempt, signal}),
-    select: toWorkflowRunDetail,
+    queryFn: ({signal}) => getWorkflowRun({workflowRunId: workflowRunId ?? '', runAttempt, signal}),
     staleTime: 2_000,
     refetchOnWindowFocus: true,
     refetchInterval: (query) => {
       const status: WorkflowRunDetail['runAttempt']['status'] | undefined =
-        query.state.data?.run_attempt.status;
+        query.state.data?.runAttempt.status;
       if (!status) return false;
       return isWorkflowRunTerminal(status) ? false : ACTIVE_POLL_MS;
     },
@@ -453,13 +543,22 @@ export function useWorkflowRunAttemptsQuery({
   workflowRunId: string | undefined;
   enabled: boolean;
 }) {
-  return useQuery({
+  return useQuery(workflowRunAttemptsQueryOptions({workflowRunId, enabled}));
+}
+
+export function workflowRunAttemptsQueryOptions({
+  workflowRunId,
+  enabled,
+}: {
+  workflowRunId: string | undefined;
+  enabled: boolean;
+}): WorkflowRunAttemptsQueryOptions {
+  return queryOptions({
     queryKey: workflowRunId
       ? workflowRunsQueryKeys.attempts(workflowRunId)
-      : [...workflowRunsQueryKeys.all, 'attempts'],
+      : ([...workflowRunsQueryKeys.all, 'attempts'] as const),
     enabled: Boolean(workflowRunId) && enabled,
-    queryFn: ({signal}) => getWorkflowRunAttemptsDto({workflowRunId: workflowRunId ?? '', signal}),
-    select: (dto): WorkflowRunAttempt[] => dto.attempts.map(toWorkflowRunAttempt),
+    queryFn: ({signal}) => getWorkflowRunAttempts({workflowRunId: workflowRunId ?? '', signal}),
     staleTime: 0,
     refetchOnMount: true,
     refetchOnWindowFocus: false,
@@ -469,9 +568,9 @@ export function useWorkflowRunAttemptsQuery({
 export function useCancelWorkflowRunMutation(run: WorkflowRun | undefined) {
   const queryClient = useQueryClient();
   return useMutation({
-    mutationFn: async () => {
+    mutationFn: async (): Promise<WorkflowRunListItem> => {
       if (!run) throw new Error('Workflow run is not loaded');
-      return toWorkflowRunListItem(await cancelWorkflowRunDto({workflowRunId: run.id}));
+      return await cancelWorkflowRun({workflowRunId: run.id});
     },
     onSuccess: async () => {
       if (!run) return;