wip

Author: suejung-sentry

static/app/views/prevent/preventAI/hooks/useInfiniteRepositories.tsx

@@ -0,0 +1,79 @@
+import type {ApiResult} from 'sentry/api';
+import type {Repository} from 'sentry/types/integrations';
+import parseLinkHeader from 'sentry/utils/parseLinkHeader';
+import {
+  fetchDataQuery,
+  useInfiniteQuery,
+  type InfiniteData,
+  type QueryKeyEndpointOptions,
+} from 'sentry/utils/queryClient';
+import useOrganization from 'sentry/utils/useOrganization';
+
+type QueryKey = [url: string, endpointOptions: QueryKeyEndpointOptions];
+
+export type UseInfiniteRepositoriesOptions = {
+  integrationId: string;
+  searchTerm?: string;
+};
+
+export function useInfiniteRepositories({
+  integrationId,
+  searchTerm,
+}: UseInfiniteRepositoriesOptions) {
+  const organization = useOrganization();
+
+  return useInfiniteQuery<
+    ApiResult<Repository[]>,
+    Error,
+    InfiniteData<ApiResult<Repository[]>>,
+    QueryKey
+  >({
+    queryKey: [
+      `/organizations/${organization.slug}/repos/`,
+      {
+        query: {
+          integration_id: integrationId || undefined,
+          status: 'active',
+          query: searchTerm || undefined,
+        },
+      },
+    ],
+    queryFn: async ({
+      queryKey: [url, {query}],
+      pageParam,
+      client,
+      signal,
+      meta,
+    }): Promise<ApiResult<Repository[]>> => {
+      return fetchDataQuery({
+        queryKey: [
+          url,
+          {
+            query: {
+              ...query,
+              cursor: pageParam ?? undefined,
+            },
+          },
+        ],
+        client,
+        signal,
+        meta,
+      });
+    },
+    getNextPageParam: _lastPage => {
+      const [, , responseMeta] = _lastPage;
+      const linkHeader = responseMeta?.getResponseHeader('Link') ?? null;
+      const links = parseLinkHeader(linkHeader);
+      return links.next?.results ? links.next.cursor : undefined;
+    },
+    getPreviousPageParam: _lastPage => {
+      const [, , responseMeta] = _lastPage;
+      const linkHeader = responseMeta?.getResponseHeader('Link') ?? null;
+      const links = parseLinkHeader(linkHeader);
+      return links.previous?.results ? links.previous.cursor : undefined;
+    },
+    initialPageParam: undefined,
+    enabled: Boolean(integrationId),
+    staleTime: 0,
+  });
+}

static/app/views/prevent/preventAI/hooks/usePreventAIInfiniteRepositories.spec.tsx

@@ -0,0 +1,96 @@
+import {OrganizationFixture} from 'sentry-fixture/organization';
+import {PreventAIConfigFixture} from 'sentry-fixture/prevent';
+
+import {renderHookWithProviders, waitFor} from 'sentry-test/reactTestingLibrary';
+
+import {usePreventAIOrgRepos, type PreventAIOrgReposResponse} from './usePreventAIOrgs';
+
+describe('usePreventAIOrgRepos', () => {
+  const mockOrg = OrganizationFixture({
+    preventAiConfigGithub: PreventAIConfigFixture(),
+  });
+
+  const mockResponse: PreventAIOrgReposResponse = {
+    integratedOrgs: [
+      {
+        githubOrganizationId: '1',
+        name: 'repo1',
+        provider: 'github',
+        repos: [{id: '1', name: 'repo1', fullName: 'org-1/repo1'}],
+      },
+      {
+        githubOrganizationId: '2',
+        name: 'repo2',
+        provider: 'github',
+        repos: [{id: '2', name: 'repo2', fullName: 'org-2/repo2'}],
+      },
+    ],
+  };
+
+  beforeEach(() => {
+    MockApiClient.clearMockResponses();
+  });
+
+  it('returns data on success', async () => {
+    MockApiClient.addMockResponse({
+      url: `/organizations/${mockOrg.slug}/prevent/github/repos/`,
+      body: mockResponse,
+    });
+
+    const {result} = renderHookWithProviders(() => usePreventAIOrgRepos(), {
+      organization: mockOrg,
+    });
+
+    await waitFor(() => expect(result.current.data).toEqual(mockResponse));
+    expect(result.current.isError).toBe(false);
+    expect(result.current.isPending).toBe(false);
+  });
+
+  it('returns error on failure', async () => {
+    MockApiClient.addMockResponse({
+      url: `/organizations/${mockOrg.slug}/prevent/github/repos/`,
+      statusCode: 500,
+      body: {error: 'Internal Server Error'},
+    });
+
+    const {result} = renderHookWithProviders(() => usePreventAIOrgRepos(), {
+      organization: mockOrg,
+    });
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+  });
+
+  it('refetches data', async () => {
+    MockApiClient.addMockResponse({
+      url: `/organizations/${mockOrg.slug}/prevent/github/repos/`,
+      body: mockResponse,
+    });
+
+    const {result} = renderHookWithProviders(() => usePreventAIOrgRepos(), {
+      organization: mockOrg,
+    });
+
+    await waitFor(() => expect(result.current.data).toEqual(mockResponse));
+
+    const newResponse: PreventAIOrgReposResponse = {
+      integratedOrgs: [
+        {
+          githubOrganizationId: '3',
+          name: 'repo3',
+          provider: 'github',
+          repos: [{id: '3', name: 'repo3', fullName: 'org-3/repo3'}],
+        },
+      ],
+    };
+    MockApiClient.addMockResponse({
+      url: `/organizations/${mockOrg.slug}/prevent/github/repos/`,
+      body: newResponse,
+    });
+
+    result.current.refetch();
+    await waitFor(() =>
+      expect(result.current.data?.integratedOrgs?.[0]?.name).toBe('repo3')
+    );
+    expect(result.current.data).toEqual(newResponse);
+  });
+});

static/app/views/prevent/preventAI/hooks/usePreventAIInfiniteRepositories.tsx

@@ -0,0 +1,22 @@
+import type {OrganizationIntegration} from 'sentry/types/integrations';
+import {useApiQuery, type UseApiQueryResult} from 'sentry/utils/queryClient';
+import type RequestError from 'sentry/utils/requestError/requestError';
+import useOrganization from 'sentry/utils/useOrganization';
+
+export function usePreventAIOrgRepos(): UseApiQueryResult<
+  OrganizationIntegration[],
+  RequestError
+> {
+  const organization = useOrganization();
+
+  return useApiQuery<OrganizationIntegration[]>(
+    [
+      `/organizations/${organization.slug}/integrations/`,
+      {query: {includeConfig: 0, provider_key: 'github'}},
+    ],
+    {
+      staleTime: 0,
+      retry: false,
+    }
+  );
+}

static/app/views/prevent/preventAI/hooks/usePreventAIOrgs.spec.tsx

@@ -2,29 +2,14 @@ import Feature from 'sentry/components/acl/feature';
 import LoadingError from 'sentry/components/loadingError';
 import LoadingIndicator from 'sentry/components/loadingIndicator';
 import {t} from 'sentry/locale';
-import type {OrganizationIntegration} from 'sentry/types/integrations';
-import {useApiQuery} from 'sentry/utils/queryClient';
-import useOrganization from 'sentry/utils/useOrganization';
 import PreventAIManageRepos from 'sentry/views/prevent/preventAI/manageRepos';
 import PreventAIOnboarding from 'sentry/views/prevent/preventAI/onboarding';
 
-function PreventAIContent() {
-  const organization = useOrganization();
+import {usePreventAIOrgRepos} from './hooks/usePreventAIOrgs';
 
-  // Check if there are any GitHub integrations installed
-  const {
-    data: githubIntegrations = [],
-    isPending,
-    isError,
-  } = useApiQuery<OrganizationIntegration[]>(
-    [
-      `/organizations/${organization.slug}/integrations/`,
-      {query: {includeConfig: 0, provider_key: 'github'}},
-    ],
-    {
-      staleTime: 0,
-    }
-  );
+function PreventAIContent() {
+  const {data, isPending, isError} = usePreventAIOrgRepos();
+  const integratedOrgs = data ?? [];
 
   if (isPending) {
     return <LoadingIndicator />;
@@ -37,8 +22,8 @@ function PreventAIContent() {
       />
     );
   }
-  if (githubIntegrations.length > 0) {
-    return <PreventAIManageRepos installedOrgs={[]} />;
+  if (integratedOrgs.length > 0) {
+    return <PreventAIManageRepos integratedOrgs={integratedOrgs} />;
   }
   return <PreventAIOnboarding />;
 }