@shipfox/client-projects 0.2.0

package/src/pages/create-project-page.stories.tsx

@@ -0,0 +1,344 @@
+import type {IntegrationConnectionDto, RepositoryDto} from '@shipfox/api-integration-core-dto';
+import {configureApiClient} from '@shipfox/client-api';
+import {type AuthState, authStateAtom} from '@shipfox/client-auth';
+import {Toaster} from '@shipfox/react-ui/toast';
+import type {Meta, StoryObj} from '@storybook/react';
+import {QueryClient, QueryClientProvider} from '@tanstack/react-query';
+import {
+  createMemoryHistory,
+  createRootRoute,
+  createRoute,
+  createRouter,
+  Outlet,
+  RouterProvider,
+} from '@tanstack/react-router';
+import {createStore, Provider as JotaiProvider} from 'jotai';
+import {useMemo} from 'react';
+import {CreateProjectPage} from './create-project-page.js';
+
+const WORKSPACE_ID = '11111111-1111-4111-8111-111111111111';
+const WORKSPACE_PATH = `/workspaces/${WORKSPACE_ID}/projects/new`;
+const GITHUB_CONNECTION_ID = '33333333-3333-4333-8333-333333333333';
+const GITEA_CONNECTION_ID = '44444444-4444-4444-8444-444444444444';
+
+type Scenario =
+  | 'playground'
+  | 'long-names'
+  | 'repository-loading'
+  | 'empty-repositories'
+  | 'connections-error';
+
+interface CreateProjectPageStoryProps {
+  scenario: Scenario;
+}
+
+const authState: AuthState = {
+  status: 'authenticated',
+  token: 'token',
+  user: {
+    id: '22222222-2222-4222-8222-222222222222',
+    email: 'platform@example.com',
+    name: 'Platform Engineer',
+    email_verified_at: '2026-01-01T00:00:00.000Z',
+    status: 'active',
+    created_at: '2026-01-01T00:00:00.000Z',
+    updated_at: '2026-01-01T00:00:00.000Z',
+  },
+  workspaces: [{id: WORKSPACE_ID, name: 'Acme', membershipId: 'membership-1'}],
+};
+
+function CreateProjectPageStory({scenario}: CreateProjectPageStoryProps) {
+  configureApiClient({
+    baseUrl: 'https://api.example.test',
+    fetchImpl: fetchForScenario(scenario),
+  });
+
+  const queryClient = useMemo(
+    () => new QueryClient({defaultOptions: {queries: {retry: false}}}),
+    [],
+  );
+  const store = useMemo(() => {
+    const nextStore = createStore();
+    nextStore.set(authStateAtom, authState);
+    return nextStore;
+  }, []);
+  const router = useMemo(() => createStoryRouter(), []);
+
+  return (
+    <QueryClientProvider client={queryClient}>
+      <JotaiProvider store={store}>
+        <div className="min-h-screen bg-background-neutral-background px-24 py-32">
+          <div className="mx-auto w-full max-w-[1120px]">
+            <RouterProvider router={router} />
+          </div>
+        </div>
+        <Toaster />
+      </JotaiProvider>
+    </QueryClientProvider>
+  );
+}
+
+const meta = {
+  title: 'Projects/CreateProjectPage',
+  component: CreateProjectPageStory,
+  parameters: {layout: 'fullscreen'},
+  args: {scenario: 'playground'},
+} satisfies Meta<typeof CreateProjectPageStory>;
+
+export default meta;
+type Story = StoryObj<typeof meta>;
+
+export const Playground: Story = {};
+
+export const LongNames: Story = {
+  args: {scenario: 'long-names'},
+};
+
+export const RepositoryLoading: Story = {
+  args: {scenario: 'repository-loading'},
+};
+
+export const EmptyRepositories: Story = {
+  args: {scenario: 'empty-repositories'},
+};
+
+export const ConnectionsError: Story = {
+  args: {scenario: 'connections-error'},
+};
+
+function createStoryRouter() {
+  const rootRoute = createRootRoute({component: Outlet});
+  const workspaceRoute = createRoute({
+    getParentRoute: () => rootRoute,
+    path: '/workspaces/$wid',
+    component: Outlet,
+  });
+  const createProjectRoute = createRoute({
+    getParentRoute: () => workspaceRoute,
+    path: 'projects/new',
+    component: CreateProjectPage,
+  });
+  const integrationsRoute = createRoute({
+    getParentRoute: () => workspaceRoute,
+    path: 'integrations',
+    component: () => <div />,
+  });
+  const modelProvidersRoute = createRoute({
+    getParentRoute: () => workspaceRoute,
+    path: 'settings/agents',
+    component: () => <div />,
+  });
+  const projectRoute = createRoute({
+    getParentRoute: () => workspaceRoute,
+    path: 'projects/$pid',
+    component: () => <div />,
+  });
+
+  return createRouter({
+    history: createMemoryHistory({initialEntries: [WORKSPACE_PATH]}),
+    routeTree: rootRoute.addChildren([
+      workspaceRoute.addChildren([
+        createProjectRoute,
+        integrationsRoute,
+        modelProvidersRoute,
+        projectRoute,
+      ]),
+    ]),
+  });
+}
+
+function fetchForScenario(scenario: Scenario): typeof fetch {
+  return (input, init) => {
+    const url = requestUrl(input);
+    const method = input instanceof Request ? input.method : (init?.method ?? 'GET');
+    if (url.pathname === `/workspaces/${WORKSPACE_ID}/agent/model-providers`) {
+      return Promise.resolve(
+        jsonResponse({configs: [modelProviderConfig()], default_provider_id: 'openai'}),
+      );
+    }
+    if (url.pathname === '/integration-connections') {
+      if (scenario === 'connections-error') return Promise.resolve(errorResponse());
+      return Promise.resolve(jsonResponse({connections: connectionsForScenario(scenario)}));
+    }
+    if (
+      url.pathname.startsWith('/integration-connections/') &&
+      url.pathname.endsWith('/repositories')
+    ) {
+      if (scenario === 'repository-loading') return new Promise<Response>(() => undefined);
+      return Promise.resolve(
+        jsonResponse({repositories: repositoriesForScenario(scenario), next_cursor: null}),
+      );
+    }
+    if (url.pathname === '/projects' && method === 'POST') {
+      return Promise.resolve(
+        jsonResponse({
+          id: '99999999-9999-4999-8999-999999999999',
+          workspace_id: WORKSPACE_ID,
+          name: 'Platform',
+          source: {
+            connection_id: GITHUB_CONNECTION_ID,
+            external_repository_id: 'platform',
+          },
+          created_at: '2026-01-01T00:00:00.000Z',
+          updated_at: '2026-01-01T00:00:00.000Z',
+        }),
+      );
+    }
+    return Promise.resolve(jsonResponse({}, {status: 404}));
+  };
+}
+
+function connectionsForScenario(scenario: Scenario): IntegrationConnectionDto[] {
+  if (scenario === 'long-names') {
+    return [
+      connection({
+        id: GITHUB_CONNECTION_ID,
+        provider: 'github',
+        display_name: 'acme-platform-engineering-production',
+        external_account_id: 'acme-platform-engineering-production',
+      }),
+      connection({
+        id: GITEA_CONNECTION_ID,
+        provider: 'gitea',
+        display_name: 'git.internal.acme.example/platform-tools',
+        external_account_id: 'git.internal.acme.example/platform-tools',
+      }),
+    ];
+  }
+
+  return [
+    connection({
+      id: GITHUB_CONNECTION_ID,
+      provider: 'github',
+      display_name: 'acme',
+      external_account_id: 'acme',
+    }),
+    connection({
+      id: GITEA_CONNECTION_ID,
+      provider: 'gitea',
+      display_name: 'git.acme.internal',
+      external_account_id: 'git.acme.internal',
+    }),
+  ];
+}
+
+function repositoriesForScenario(scenario: Scenario): RepositoryDto[] {
+  if (scenario === 'empty-repositories') return [];
+  if (scenario === 'long-names') {
+    return [
+      repository({
+        external_repository_id: 'acme-platform-infrastructure-control-plane',
+        name: 'acme-platform-infrastructure-control-plane',
+        full_name: 'acme-engineering/acme-platform-infrastructure-control-plane',
+        default_branch: 'production',
+      }),
+      repository({
+        external_repository_id: 'workflow-automation-and-runner-orchestration',
+        name: 'workflow-automation-and-runner-orchestration',
+        full_name: 'acme-engineering/workflow-automation-and-runner-orchestration',
+        default_branch: 'main',
+      }),
+      repository({
+        external_repository_id: 'customer-deployment-pipelines',
+        name: 'customer-deployment-pipelines',
+        full_name: 'acme-solutions/customer-deployment-pipelines',
+        default_branch: 'release',
+      }),
+    ];
+  }
+
+  return [
+    repository({
+      external_repository_id: 'platform',
+      name: 'platform',
+      full_name: 'acme/platform',
+      default_branch: 'main',
+    }),
+    repository({
+      external_repository_id: 'api',
+      name: 'api',
+      full_name: 'acme/api',
+      default_branch: 'main',
+    }),
+    repository({
+      external_repository_id: 'client',
+      name: 'client',
+      full_name: 'acme/client',
+      default_branch: 'main',
+    }),
+    repository({
+      external_repository_id: 'runners',
+      name: 'runners',
+      full_name: 'acme/runners',
+      default_branch: 'main',
+    }),
+    repository({
+      external_repository_id: 'workflows',
+      name: 'workflows',
+      full_name: 'acme/workflows',
+      default_branch: 'develop',
+    }),
+  ];
+}
+
+function connection(
+  overrides: Partial<IntegrationConnectionDto> & Pick<IntegrationConnectionDto, 'id'>,
+): IntegrationConnectionDto {
+  return {
+    workspace_id: WORKSPACE_ID,
+    provider: 'github',
+    external_account_id: 'acme',
+    slug: 'github_acme',
+    display_name: 'GitHub',
+    lifecycle_status: 'active',
+    capabilities: ['source_control'],
+    created_at: '2026-01-01T00:00:00.000Z',
+    updated_at: '2026-01-01T00:00:00.000Z',
+    ...overrides,
+  };
+}
+
+function repository(overrides: Partial<RepositoryDto>): RepositoryDto {
+  return {
+    connection_id: GITHUB_CONNECTION_ID,
+    external_repository_id: 'platform',
+    owner: 'acme',
+    name: 'platform',
+    full_name: 'acme/platform',
+    default_branch: 'main',
+    visibility: 'private',
+    clone_url: 'https://github.example.test/acme/platform.git',
+    html_url: 'https://github.example.test/acme/platform',
+    ...overrides,
+  };
+}
+
+function modelProviderConfig() {
+  return {
+    workspace_id: WORKSPACE_ID,
+    provider_id: 'openai',
+    default_model: 'gpt-5.5-pro',
+    credential_fields: ['api_key'],
+    lifecycle_status: 'active',
+    created_at: '2026-01-01T00:00:00.000Z',
+    updated_at: '2026-01-01T00:00:00.000Z',
+  };
+}
+
+function requestUrl(input: RequestInfo | URL): URL {
+  if (input instanceof Request) return new URL(input.url);
+  if (input instanceof URL) return input;
+  return new URL(input, 'https://api.example.test');
+}
+
+function jsonResponse(body: unknown, init: ResponseInit = {}) {
+  return new Response(JSON.stringify(body), {
+    status: 200,
+    headers: {'content-type': 'application/json'},
+    ...init,
+  });
+}
+
+function errorResponse() {
+  return jsonResponse({code: 'server-error'}, {status: 500});
+}

package/src/pages/create-project-page.test.tsx

@@ -0,0 +1,317 @@
+import {configureApiClient} from '@shipfox/client-api';
+import {fireEvent, screen, waitFor} from '@testing-library/react';
+import {jsonResponse, PROJECT_TEST_WID, renderProjectPage} from '#test/pages.js';
+import {CreateProjectPage} from './create-project-page.js';
+
+const CONNECTION_ID = '33333333-3333-4333-8333-333333333333';
+const SECOND_CONNECTION_ID = '66666666-6666-4666-8666-666666666666';
+const REPOSITORY_NOT_FOUND_RE = /Repository not found/;
+const GITEA_RADIO_LABEL_RE = /^Gitea Source$/;
+
+describe('CreateProjectPage', () => {
+  beforeEach(() => {
+    window.sessionStorage.clear();
+  });
+
+  test('with a single connection: pre-selects, renders repos, creates a project', async () => {
+    let createProjectBody: unknown;
+    const fetchImpl = vi.fn(async (input: RequestInfo | URL) => {
+      const request = input as Request;
+      if (request.url.includes('/integration-connections?')) {
+        return jsonResponse({connections: [connectionDto()]});
+      }
+      if (request.url.includes(`/integration-connections/${CONNECTION_ID}/repositories`)) {
+        return jsonResponse({repositories: [repositoryDto()], next_cursor: null});
+      }
+      if (request.url.endsWith('/projects') && request.method === 'POST') {
+        createProjectBody = await request.json();
+        return jsonResponse(projectDto({id: '44444444-4444-4444-8444-444444444444'}));
+      }
+      return jsonResponse(projectDto({id: '44444444-4444-4444-8444-444444444444'}));
+    });
+    configureApiClient({fetchImpl});
+
+    renderProjectPage(`/workspaces/${PROJECT_TEST_WID}/projects/new`, <CreateProjectPage />);
+    const nameInput = await screen.findByLabelText('Project name');
+    await waitFor(() => expect(nameInput).toHaveValue('Platform'));
+    expect(screen.getByRole('radio', {name: GITEA_RADIO_LABEL_RE})).toBeChecked();
+    expect(screen.getAllByText('gitea-owner/platform').length).toBeGreaterThan(0);
+    fireEvent.change(nameInput, {
+      target: {value: '  Launch Pad  '},
+    });
+    fireEvent.click(screen.getByRole('button', {name: 'Create project'}));
+
+    expect(await screen.findByRole('heading', {name: 'Runs'})).toBeInTheDocument();
+    expect(createProjectBody).toEqual({
+      workspace_id: PROJECT_TEST_WID,
+      name: 'Launch Pad',
+      source: {
+        connection_id: CONNECTION_ID,
+        external_repository_id: 'platform',
+      },
+    });
+  }, 10_000);
+
+  test('uses the current repository-derived name when submitted before touching the field', async () => {
+    let createProjectBody: unknown;
+    const fetchImpl = vi.fn(async (input: RequestInfo | URL) => {
+      const request = input as Request;
+      if (request.url.includes('/integration-connections?')) {
+        return jsonResponse({connections: [connectionDto()]});
+      }
+      if (request.url.includes(`/integration-connections/${CONNECTION_ID}/repositories`)) {
+        return jsonResponse({repositories: [repositoryDto()], next_cursor: null});
+      }
+      if (request.url.endsWith('/projects') && request.method === 'POST') {
+        createProjectBody = await request.json();
+        return jsonResponse(projectDto({id: '44444444-4444-4444-8444-444444444444'}));
+      }
+      return jsonResponse(projectDto({id: '44444444-4444-4444-8444-444444444444'}));
+    });
+    configureApiClient({fetchImpl});
+
+    renderProjectPage(`/workspaces/${PROJECT_TEST_WID}/projects/new`, <CreateProjectPage />);
+    expect((await screen.findAllByText('gitea-owner/platform')).length).toBeGreaterThan(0);
+    fireEvent.click(screen.getByRole('button', {name: 'Create project'}));
+
+    expect(await screen.findByRole('heading', {name: 'Runs'})).toBeInTheDocument();
+    expect(createProjectBody).toEqual({
+      workspace_id: PROJECT_TEST_WID,
+      name: 'Platform',
+      source: {
+        connection_id: CONNECTION_ID,
+        external_repository_id: 'platform',
+      },
+    });
+  });
+
+  test('with multiple connections: hides repo picker until a connection is selected', async () => {
+    const fetchImpl = vi.fn((input: RequestInfo | URL) => {
+      const request = input as Request;
+      if (request.url.includes('/integration-connections?')) {
+        return Promise.resolve(
+          jsonResponse({connections: [connectionDto(), secondConnectionDto()]}),
+        );
+      }
+      if (request.url.includes(`/integration-connections/${CONNECTION_ID}/repositories`)) {
+        return Promise.resolve(jsonResponse({repositories: [repositoryDto()], next_cursor: null}));
+      }
+      return Promise.resolve(jsonResponse({}));
+    });
+    configureApiClient({fetchImpl});
+
+    renderProjectPage(`/workspaces/${PROJECT_TEST_WID}/projects/new`, <CreateProjectPage />);
+    expect((await screen.findAllByText('Gitea Source')).length).toBeGreaterThan(0);
+    expect(await screen.findByText('Other Gitea Source')).toBeInTheDocument();
+    expect(screen.queryByText('gitea-owner/platform')).not.toBeInTheDocument();
+
+    fireEvent.click(screen.getByRole('radio', {name: GITEA_RADIO_LABEL_RE}));
+
+    expect((await screen.findAllByText('gitea-owner/platform')).length).toBeGreaterThan(0);
+  });
+
+  test('rejects invalid custom project names locally', async () => {
+    const fetchImpl = vi.fn((input: RequestInfo | URL) => {
+      const request = input as Request;
+      if (request.url.includes('/integration-connections?')) {
+        return Promise.resolve(jsonResponse({connections: [connectionDto()]}));
+      }
+      if (request.url.includes(`/integration-connections/${CONNECTION_ID}/repositories`)) {
+        return Promise.resolve(jsonResponse({repositories: [repositoryDto()], next_cursor: null}));
+      }
+      return Promise.resolve(jsonResponse({}));
+    });
+    configureApiClient({fetchImpl});
+
+    renderProjectPage(`/workspaces/${PROJECT_TEST_WID}/projects/new`, <CreateProjectPage />);
+    expect((await screen.findAllByText('gitea-owner/platform')).length).toBeGreaterThan(0);
+    fireEvent.change(await screen.findByLabelText('Project name'), {
+      target: {value: 'Bad\u202eName'},
+    });
+    fireEvent.click(screen.getByRole('button', {name: 'Create project'}));
+
+    expect(
+      await screen.findByText(
+        'Project name cannot include line breaks, tabs, or hidden formatting characters.',
+      ),
+    ).toBeInTheDocument();
+    expect(projectPostCount(fetchImpl)).toBe(0);
+  });
+
+  test('with a single connection: shows workspace-scoped "Add another integration" link', async () => {
+    configureApiClient({
+      fetchImpl: vi.fn((input: RequestInfo | URL) => {
+        const request = input as Request;
+        if (request.url.includes('/integration-connections?')) {
+          return Promise.resolve(jsonResponse({connections: [connectionDto()]}));
+        }
+        if (request.url.includes(`/integration-connections/${CONNECTION_ID}/repositories`)) {
+          return Promise.resolve(
+            jsonResponse({repositories: [repositoryDto()], next_cursor: null}),
+          );
+        }
+        return Promise.resolve(jsonResponse({}));
+      }),
+    });
+
+    renderProjectPage(`/workspaces/${PROJECT_TEST_WID}/projects/new`, <CreateProjectPage />);
+    const link = await screen.findByRole('link', {name: 'Add another integration'});
+    expect(link).toHaveAttribute('href', `/workspaces/${PROJECT_TEST_WID}/integrations`);
+  });
+
+  test('shows the model provider reminder on project creation when no provider is configured', async () => {
+    const fetchImpl = vi.fn((input: RequestInfo | URL) => {
+      const request = input as Request;
+      if (request.url.endsWith('/agent/model-providers')) {
+        return Promise.resolve(jsonResponse({configs: [], default_provider_id: null}));
+      }
+      if (request.url.includes('/integration-connections?')) {
+        return Promise.resolve(jsonResponse({connections: [connectionDto()]}));
+      }
+      if (request.url.includes(`/integration-connections/${CONNECTION_ID}/repositories`)) {
+        return Promise.resolve(jsonResponse({repositories: [repositoryDto()], next_cursor: null}));
+      }
+      return Promise.resolve(jsonResponse({}));
+    });
+    configureApiClient({fetchImpl});
+
+    renderProjectPage(`/workspaces/${PROJECT_TEST_WID}/projects/new`, <CreateProjectPage />);
+
+    expect(await screen.findByText('Finish setting up a model provider')).toBeInTheDocument();
+    expect(screen.getByRole('link', {name: 'Agents'})).toHaveAttribute(
+      'href',
+      `/workspaces/${PROJECT_TEST_WID}/settings/agents`,
+    );
+  });
+
+  test('navigates to the existing project for duplicate recovery', async () => {
+    const fetchImpl = vi.fn((input: RequestInfo | URL) => {
+      const request = input as Request;
+      if (request.url.includes('/integration-connections?')) {
+        return Promise.resolve(jsonResponse({connections: [connectionDto()]}));
+      }
+      if (request.url.includes(`/integration-connections/${CONNECTION_ID}/repositories`)) {
+        return Promise.resolve(jsonResponse({repositories: [repositoryDto()], next_cursor: null}));
+      }
+      if (request.url.endsWith('/projects')) {
+        return Promise.resolve(
+          jsonResponse(
+            {
+              code: 'project-already-exists',
+              details: {existing_project_id: '55555555-5555-4555-8555-555555555555'},
+            },
+            {status: 409},
+          ),
+        );
+      }
+      if (request.url.includes('/projects?')) {
+        return Promise.resolve(
+          jsonResponse({
+            projects: [projectDto({id: '55555555-5555-4555-8555-555555555555'})],
+            next_cursor: null,
+          }),
+        );
+      }
+      if (request.url.includes('/definitions?')) {
+        return Promise.resolve(jsonResponse({definitions: [], next_cursor: null, sync: null}));
+      }
+      return Promise.resolve(
+        jsonResponse(projectDto({id: '55555555-5555-4555-8555-555555555555'})),
+      );
+    });
+    configureApiClient({fetchImpl});
+
+    renderProjectPage(`/workspaces/${PROJECT_TEST_WID}/projects/new`, <CreateProjectPage />);
+    expect((await screen.findAllByText('gitea-owner/platform')).length).toBeGreaterThan(0);
+    fireEvent.click(screen.getByRole('button', {name: 'Create project'}));
+
+    // After duplicate recovery, navigation lands on the workspace-scoped project
+    // URL. Production redirects that URL to the Runs tab.
+    expect(await screen.findByRole('heading', {name: 'Runs'})).toBeInTheDocument();
+  });
+
+  test('shows provider-specific submit errors', async () => {
+    const fetchImpl = vi.fn((input: RequestInfo | URL) => {
+      const request = input as Request;
+      if (request.url.includes('/integration-connections?')) {
+        return Promise.resolve(jsonResponse({connections: [connectionDto()]}));
+      }
+      if (request.url.includes(`/integration-connections/${CONNECTION_ID}/repositories`)) {
+        return Promise.resolve(jsonResponse({repositories: [repositoryDto()], next_cursor: null}));
+      }
+      return Promise.resolve(jsonResponse({code: 'repository-not-found'}, {status: 422}));
+    });
+    configureApiClient({fetchImpl});
+
+    renderProjectPage(`/workspaces/${PROJECT_TEST_WID}/projects/new`, <CreateProjectPage />);
+    expect((await screen.findAllByText('gitea-owner/platform')).length).toBeGreaterThan(0);
+    fireEvent.click(screen.getByRole('button', {name: 'Create project'}));
+
+    expect(await screen.findByText(REPOSITORY_NOT_FOUND_RE)).toBeInTheDocument();
+  });
+});
+
+function connectionDto() {
+  return {
+    id: CONNECTION_ID,
+    workspace_id: '11111111-1111-4111-8111-111111111111',
+    provider: 'gitea',
+    external_account_id: 'gitea-owner',
+    slug: 'gitea_owner',
+    display_name: 'Gitea Source',
+    lifecycle_status: 'active',
+    capabilities: ['source_control'],
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+  };
+}
+
+function secondConnectionDto() {
+  return {
+    id: SECOND_CONNECTION_ID,
+    workspace_id: '11111111-1111-4111-8111-111111111111',
+    provider: 'gitea',
+    external_account_id: 'gitea-owner-2',
+    slug: 'gitea_owner_2',
+    display_name: 'Other Gitea Source',
+    lifecycle_status: 'active',
+    capabilities: ['source_control'],
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+  };
+}
+
+function repositoryDto() {
+  return {
+    connection_id: CONNECTION_ID,
+    external_repository_id: 'platform',
+    owner: 'gitea-owner',
+    name: 'platform',
+    full_name: 'gitea-owner/platform',
+    default_branch: 'main',
+    visibility: 'private',
+    clone_url: 'https://gitea.local/gitea-owner/platform.git',
+    html_url: 'https://gitea.local/gitea-owner/platform',
+  };
+}
+
+function projectDto({id}: {id: string}) {
+  return {
+    id,
+    workspace_id: '11111111-1111-4111-8111-111111111111',
+    name: 'Project Detail',
+    source: {
+      connection_id: CONNECTION_ID,
+      external_repository_id: 'platform',
+    },
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+  };
+}
+
+function projectPostCount(fetchImpl: ReturnType<typeof vi.fn>): number {
+  return fetchImpl.mock.calls.filter(([input]) => {
+    const request = input as Request;
+    return request.url.endsWith('/projects') && request.method === 'POST';
+  }).length;
+}