@shipfox/client-runners 5.0.0 → 6.0.1

package/src/hooks/api/provisioner-tokens.ts

@@ -1,12 +1,29 @@
-import type {
-  CreateProvisionerTokenBodyDto,
-  CreateProvisionerTokenResponseDto,
-  ListActiveProvisionersResponseDto,
-  ListProvisionerTokensResponseDto,
-  RevokeProvisionerTokenResponseDto,
+import {
+  createProvisionerTokenResponseSchema,
+  listActiveProvisionersResponseSchema,
+  listProvisionerTokensResponseSchema,
+  revokeProvisionerTokenResponseSchema,
 } from '@shipfox/api-runners-dto';
-import {apiRequest} from '@shipfox/client-api';
-import {useMutation, useQuery} from '@tanstack/react-query';
+import {checkedApiRequest} from '@shipfox/client-api';
+import {
+  type FetchQueryOptions,
+  queryOptions,
+  useMutation,
+  useQuery,
+  useQueryClient,
+} from '@tanstack/react-query';
+import type {
+  ActiveProvisioner,
+  CreatedProvisionerToken,
+  CreateTokenCommand,
+  ProvisionerToken,
+} from '#core/token.js';
+import {
+  toActiveProvisioner,
+  toCreatedProvisionerToken,
+  toCreateTokenBody,
+  toProvisionerToken,
+} from './token-mapper.js';
 
 const PROVISIONER_TOKEN_REFETCH_INTERVAL_MS = 30_000;
 
@@ -17,30 +34,48 @@ export const provisionerTokenQueryKeys = {
     [...provisionerTokenQueryKeys.all, 'provisioners', workspaceId] as const,
 };
 
+type ProvisionerTokensQueryOptions = FetchQueryOptions<
+  ProvisionerToken[],
+  Error,
+  ProvisionerToken[],
+  ReturnType<typeof provisionerTokenQueryKeys.list>
+>;
+
+type ActiveProvisionersQueryOptions = FetchQueryOptions<
+  ActiveProvisioner[],
+  Error,
+  ActiveProvisioner[],
+  ReturnType<typeof provisionerTokenQueryKeys.active>
+>;
+
 export async function listProvisionerTokens({
   workspaceId,
   signal,
 }: {
   workspaceId: string;
   signal?: AbortSignal;
-}) {
-  return await apiRequest<ListProvisionerTokensResponseDto>(
+}): Promise<ProvisionerToken[]> {
+  const response = await checkedApiRequest(
+    listProvisionerTokensResponseSchema,
     `/workspaces/${workspaceId}/provisioners/tokens`,
     {signal},
   );
+  return response.tokens.map(toProvisionerToken);
 }
 
 export async function createProvisionerToken({
   workspaceId,
-  body,
+  command,
 }: {
   workspaceId: string;
-  body: CreateProvisionerTokenBodyDto;
-}) {
-  return await apiRequest<CreateProvisionerTokenResponseDto>(
+  command: CreateTokenCommand;
+}): Promise<CreatedProvisionerToken> {
+  const response = await checkedApiRequest(
+    createProvisionerTokenResponseSchema,
     `/workspaces/${workspaceId}/provisioners/tokens`,
-    {method: 'POST', body},
+    {method: 'POST', body: toCreateTokenBody(command)},
   );
+  return toCreatedProvisionerToken(response);
 }
 
 export async function revokeProvisionerToken({
@@ -49,11 +84,13 @@ export async function revokeProvisionerToken({
 }: {
   workspaceId: string;
   tokenId: string;
-}) {
-  return await apiRequest<RevokeProvisionerTokenResponseDto>(
+}): Promise<ProvisionerToken> {
+  const response = await checkedApiRequest(
+    revokeProvisionerTokenResponseSchema,
     `/workspaces/${workspaceId}/provisioners/tokens/${tokenId}/revoke`,
     {method: 'POST'},
   );
+  return toProvisionerToken(response);
 }
 
 export async function listActiveProvisioners({
@@ -62,41 +99,68 @@ export async function listActiveProvisioners({
 }: {
   workspaceId: string;
   signal?: AbortSignal;
-}) {
-  return await apiRequest<ListActiveProvisionersResponseDto>(
+}): Promise<ActiveProvisioner[]> {
+  const response = await checkedApiRequest(
+    listActiveProvisionersResponseSchema,
     `/workspaces/${workspaceId}/provisioners/active`,
     {signal},
   );
+  return response.provisioners.map(toActiveProvisioner);
 }
 
-export function useProvisionerTokensQuery(workspaceId: string | undefined) {
-  return useQuery({
-    queryKey: workspaceId
-      ? provisionerTokenQueryKeys.list(workspaceId)
-      : [...provisionerTokenQueryKeys.all, 'tokens'],
-    enabled: Boolean(workspaceId),
-    queryFn: ({signal}) => listProvisionerTokens({workspaceId: workspaceId ?? '', signal}),
+export function provisionerTokensQueryOptions(workspaceId: string): ProvisionerTokensQueryOptions {
+  return queryOptions({
+    queryKey: provisionerTokenQueryKeys.list(workspaceId),
+    queryFn: ({signal}) => listProvisionerTokens({workspaceId, signal}),
     refetchInterval: PROVISIONER_TOKEN_REFETCH_INTERVAL_MS,
     refetchIntervalInBackground: false,
   });
 }
 
-export function useCreateProvisionerTokenMutation() {
-  return useMutation({mutationFn: createProvisionerToken});
+export function activeProvisionersQueryOptions(
+  workspaceId: string,
+): ActiveProvisionersQueryOptions {
+  return queryOptions({
+    queryKey: provisionerTokenQueryKeys.active(workspaceId),
+    queryFn: ({signal}) => listActiveProvisioners({workspaceId, signal}),
+    refetchInterval: PROVISIONER_TOKEN_REFETCH_INTERVAL_MS,
+    refetchIntervalInBackground: false,
+  });
 }
 
-export function useRevokeProvisionerTokenMutation() {
-  return useMutation({mutationFn: revokeProvisionerToken});
+export function useProvisionerTokensQuery(workspaceId: string | undefined) {
+  return useQuery({
+    ...provisionerTokensQueryOptions(workspaceId ?? ''),
+    enabled: Boolean(workspaceId),
+  });
 }
 
 export function useActiveProvisionersQuery(workspaceId: string | undefined) {
   return useQuery({
-    queryKey: workspaceId
-      ? provisionerTokenQueryKeys.active(workspaceId)
-      : [...provisionerTokenQueryKeys.all, 'provisioners'],
+    ...activeProvisionersQueryOptions(workspaceId ?? ''),
     enabled: Boolean(workspaceId),
-    queryFn: ({signal}) => listActiveProvisioners({workspaceId: workspaceId ?? '', signal}),
-    refetchInterval: PROVISIONER_TOKEN_REFETCH_INTERVAL_MS,
-    refetchIntervalInBackground: false,
+  });
+}
+
+export function useCreateProvisionerTokenMutation(workspaceId: string) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (command: CreateTokenCommand) => createProvisionerToken({workspaceId, command}),
+    onSuccess: async () => {
+      await queryClient.invalidateQueries(provisionerTokensQueryOptions(workspaceId));
+    },
+  });
+}
+
+export function useRevokeProvisionerTokenMutation(workspaceId: string) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (tokenId: string) => revokeProvisionerToken({workspaceId, tokenId}),
+    onSuccess: async () => {
+      await Promise.all([
+        queryClient.invalidateQueries(provisionerTokensQueryOptions(workspaceId)),
+        queryClient.invalidateQueries(activeProvisionersQueryOptions(workspaceId)),
+      ]);
+    },
   });
 }

package/src/hooks/api/token-mapper.test.ts

@@ -0,0 +1,161 @@
+import {
+  toActiveProvisioner,
+  toCreatedManualRegistrationToken,
+  toCreatedProvisionerToken,
+  toCreateTokenBody,
+  toManualRegistrationToken,
+  toProvisionerToken,
+} from './token-mapper.js';
+
+describe('toManualRegistrationToken', () => {
+  test('maps a transport token to its package-owned model', () => {
+    const result = toManualRegistrationToken({
+      id: '11111111-1111-4111-8111-111111111111',
+      workspace_id: '22222222-2222-4222-8222-222222222222',
+      prefix: 'sf_mrt_test',
+      name: null,
+      expires_at: null,
+      revoked_at: null,
+      created_at: '2026-07-22T10:00:00.000Z',
+      updated_at: '2026-07-22T10:00:00.000Z',
+    });
+
+    expect(result).toEqual({
+      id: '11111111-1111-4111-8111-111111111111',
+      workspaceId: '22222222-2222-4222-8222-222222222222',
+      prefix: 'sf_mrt_test',
+      name: null,
+      expiresAt: null,
+      revokedAt: null,
+      createdAt: '2026-07-22T10:00:00.000Z',
+      updatedAt: '2026-07-22T10:00:00.000Z',
+    });
+  });
+});
+
+describe('toProvisionerToken', () => {
+  test('maps a transport provisioner token to its package-owned model', () => {
+    const result = toProvisionerToken({
+      id: '33333333-3333-4333-8333-333333333333',
+      scope: 'workspace',
+      workspace_id: '22222222-2222-4222-8222-222222222222',
+      prefix: 'sf_pt_test',
+      name: 'Docker provisioner',
+      created_by_user_id: '44444444-4444-4444-8444-444444444444',
+      revoked_by_user_id: null,
+      expires_at: null,
+      revoked_at: null,
+      last_seen_at: '2026-07-22T09:00:00.000Z',
+      created_at: '2026-07-22T10:00:00.000Z',
+      updated_at: '2026-07-22T10:00:00.000Z',
+    });
+
+    expect(result).toEqual({
+      id: '33333333-3333-4333-8333-333333333333',
+      workspaceId: '22222222-2222-4222-8222-222222222222',
+      prefix: 'sf_pt_test',
+      name: 'Docker provisioner',
+      expiresAt: null,
+      revokedAt: null,
+      createdAt: '2026-07-22T10:00:00.000Z',
+      updatedAt: '2026-07-22T10:00:00.000Z',
+      createdByUserId: '44444444-4444-4444-8444-444444444444',
+      revokedByUserId: null,
+      lastSeenAt: '2026-07-22T09:00:00.000Z',
+    });
+  });
+});
+
+describe('toActiveProvisioner', () => {
+  test('maps a transport active provisioner to its package-owned model', () => {
+    const result = toActiveProvisioner({
+      id: '33333333-3333-4333-8333-333333333333',
+      name: 'Docker provisioner',
+      prefix: 'sf_pt_test',
+      last_seen_at: '2026-07-22T09:00:00.000Z',
+    });
+
+    expect(result).toEqual({
+      id: '33333333-3333-4333-8333-333333333333',
+      name: 'Docker provisioner',
+      prefix: 'sf_pt_test',
+      lastSeenAt: '2026-07-22T09:00:00.000Z',
+    });
+  });
+});
+
+describe('toCreatedManualRegistrationToken', () => {
+  test('maps a raw-token creation response to its package-owned model', () => {
+    const result = toCreatedManualRegistrationToken({
+      id: '77777777-7777-4777-8777-777777777777',
+      raw_token: 'sf_mrt_raw-created-token',
+      prefix: 'sf_mrt_test',
+      name: null,
+      workspace_id: '22222222-2222-4222-8222-222222222222',
+      expires_at: null,
+      created_at: '2026-07-22T10:00:00.000Z',
+    });
+
+    expect(result).toEqual({
+      token: 'sf_mrt_raw-created-token',
+      id: '77777777-7777-4777-8777-777777777777',
+      prefix: 'sf_mrt_test',
+      name: null,
+      workspaceId: '22222222-2222-4222-8222-222222222222',
+      expiresAt: null,
+      createdAt: '2026-07-22T10:00:00.000Z',
+    });
+  });
+});
+
+describe('toCreatedProvisionerToken', () => {
+  test('maps a raw-token provisioner creation response to its package-owned model', () => {
+    const result = toCreatedProvisionerToken({
+      id: '77777777-7777-4777-8777-777777777777',
+      raw_token: 'sf_pt_raw-created-token',
+      prefix: 'sf_pt_test',
+      name: 'Docker provisioner',
+      workspace_id: '22222222-2222-4222-8222-222222222222',
+      created_by_user_id: '44444444-4444-4444-8444-444444444444',
+      revoked_by_user_id: null,
+      expires_at: null,
+      revoked_at: null,
+      last_seen_at: null,
+      created_at: '2026-07-22T10:00:00.000Z',
+      updated_at: '2026-07-22T10:00:00.000Z',
+      scope: 'workspace',
+    });
+
+    expect(result).toEqual({
+      token: 'sf_pt_raw-created-token',
+      id: '77777777-7777-4777-8777-777777777777',
+      prefix: 'sf_pt_test',
+      name: 'Docker provisioner',
+      workspaceId: '22222222-2222-4222-8222-222222222222',
+      expiresAt: null,
+      createdAt: '2026-07-22T10:00:00.000Z',
+      createdByUserId: '44444444-4444-4444-8444-444444444444',
+      revokedByUserId: null,
+      revokedAt: null,
+      lastSeenAt: null,
+      updatedAt: '2026-07-22T10:00:00.000Z',
+    });
+  });
+});
+
+describe('toCreateTokenBody', () => {
+  test('omits both optional fields for an unnamed, non-expiring command', () => {
+    const result = toCreateTokenBody({expiration: {kind: 'never'}});
+
+    expect(result).toEqual({});
+  });
+
+  test('includes name and ttl_seconds for a named, expiring command', () => {
+    const result = toCreateTokenBody({
+      name: 'Local runner',
+      expiration: {kind: 'expires-after', seconds: 86_400},
+    });
+
+    expect(result).toEqual({name: 'Local runner', ttl_seconds: 86_400});
+  });
+});

package/src/hooks/api/token-mapper.ts

@@ -0,0 +1,79 @@
+import type {
+  ActiveProvisionerDto,
+  CreateManualRegistrationTokenResponseDto,
+  CreateProvisionerTokenResponseDto,
+  ManualRegistrationTokenDto,
+  ProvisionerTokenDto,
+} from '@shipfox/api-runners-dto';
+import type {
+  ActiveProvisioner,
+  CreatedManualRegistrationToken,
+  CreatedProvisionerToken,
+  CreateTokenCommand,
+  ManualRegistrationToken,
+  ProvisionerToken,
+} from '#core/token.js';
+
+export function toCreateTokenBody(command: CreateTokenCommand) {
+  return {
+    ...(command.name ? {name: command.name} : {}),
+    ...(command.expiration.kind === 'expires-after'
+      ? {ttl_seconds: command.expiration.seconds}
+      : {}),
+  };
+}
+
+export function toManualRegistrationToken(
+  dto: ManualRegistrationTokenDto,
+): ManualRegistrationToken {
+  return {
+    id: dto.id,
+    workspaceId: dto.workspace_id,
+    prefix: dto.prefix,
+    name: dto.name,
+    expiresAt: dto.expires_at,
+    revokedAt: dto.revoked_at,
+    createdAt: dto.created_at,
+    updatedAt: dto.updated_at,
+  };
+}
+
+export function toProvisionerToken(dto: ProvisionerTokenDto): ProvisionerToken {
+  return {
+    ...toManualRegistrationToken(dto),
+    createdByUserId: dto.created_by_user_id,
+    revokedByUserId: dto.revoked_by_user_id,
+    lastSeenAt: dto.last_seen_at,
+  };
+}
+
+export function toActiveProvisioner(dto: ActiveProvisionerDto): ActiveProvisioner {
+  return {id: dto.id, name: dto.name, prefix: dto.prefix, lastSeenAt: dto.last_seen_at};
+}
+
+export function toCreatedManualRegistrationToken(
+  dto: CreateManualRegistrationTokenResponseDto,
+): CreatedManualRegistrationToken {
+  return {
+    token: dto.raw_token,
+    id: dto.id,
+    prefix: dto.prefix,
+    name: dto.name,
+    workspaceId: dto.workspace_id,
+    expiresAt: dto.expires_at,
+    createdAt: dto.created_at,
+  };
+}
+
+export function toCreatedProvisionerToken(
+  dto: CreateProvisionerTokenResponseDto,
+): CreatedProvisionerToken {
+  return {
+    ...toCreatedManualRegistrationToken(dto),
+    createdByUserId: dto.created_by_user_id,
+    revokedByUserId: dto.revoked_by_user_id,
+    revokedAt: dto.revoked_at,
+    lastSeenAt: dto.last_seen_at,
+    updatedAt: dto.updated_at,
+  };
+}