fix(config): Hook up to new prevent ai config apis

suejung-sentry · suejung-sentry · commit e10ca7fe1d37 · 2025-11-01T17:24:10.000-07:00
diff --git a/static/app/types/organization.tsx b/static/app/types/organization.tsx
@@ -9,7 +9,6 @@ import type {WidgetType} from 'sentry/views/dashboards/types';
 import type {Actor, Avatar, ObjectStatus, Scope} from './core';
 import type {ExternalTeam} from './integrations';
 import type {OnboardingTaskStatus} from './onboarding';
-import type {PreventAIConfig} from './prevent';
 import type {Project} from './project';
 import type {Relay} from './relay';
 import type {User} from './user';
@@ -114,7 +113,6 @@ export interface Organization extends OrganizationSummary {
   };
   orgRole?: string;
   planSampleRate?: number | null;
-  preventAiConfigGithub?: PreventAIConfig;
 }
 
 export interface Team {
diff --git a/static/app/types/prevent.tsx b/static/app/types/prevent.tsx
@@ -17,13 +17,8 @@ export interface PreventAIFeatureConfigsByName {
   vanilla: PreventAIFeatureConfig; // "vanilla" basic ai pr review
 }
 
-export interface PreventAIOrgConfig {
+export interface PreventAIConfig {
   org_defaults: PreventAIFeatureConfigsByName;
   repo_overrides: Record<string, PreventAIFeatureConfigsByName>;
-}
-
-export interface PreventAIConfig {
-  default_org_config: PreventAIOrgConfig;
-  github_organizations: Record<string, PreventAIOrgConfig>;
   schema_version: string;
 }
diff --git a/static/app/views/prevent/preventAI/hooks/usePreventAIConfig.spec.tsx b/static/app/views/prevent/preventAI/hooks/usePreventAIConfig.spec.tsx
@@ -0,0 +1,108 @@
+import {OrganizationFixture} from 'sentry-fixture/organization';
+
+import {renderHookWithProviders, waitFor} from 'sentry-test/reactTestingLibrary';
+
+import {usePreventAIGitHubConfig} from './usePreventAIConfig';
+
+describe('usePreventAIGitHubConfig', () => {
+  const org = OrganizationFixture({slug: 'test-org'});
+  const gitOrgName = 'octo-corp';
+
+  beforeEach(() => {
+    MockApiClient.clearMockResponses();
+  });
+
+  it('fetches config from API correctly', async () => {
+    const configResponse = {
+      default_org_config: {
+        org_defaults: {
+          vanilla: {enabled: true, sensitivity: 'medium'},
+          test_generation: {enabled: false, sensitivity: 'low'},
+          bug_prediction: {enabled: false, sensitivity: 'high'},
+        },
+        repo_overrides: {
+          'repo-123': {
+            vanilla: {enabled: false, sensitivity: 'high'},
+            test_generation: {enabled: true, sensitivity: 'critical'},
+            bug_prediction: {enabled: false, sensitivity: 'medium'},
+          },
+        },
+        schema_version: 'v1',
+      },
+      organization: {
+        'octo-corp': {
+          org_defaults: {
+            vanilla: {enabled: false, sensitivity: 'low'},
+            test_generation: {enabled: true, sensitivity: 'medium'},
+            bug_prediction: {enabled: true, sensitivity: 'high'},
+          },
+          repo_overrides: {},
+          schema_version: 'v1',
+        },
+      },
+      schema_version: 'v1',
+    };
+
+    MockApiClient.addMockResponse({
+      url: `/organizations/${org.slug}/prevent/ai/github/config/${gitOrgName}/`,
+      body: configResponse,
+    });
+
+    const {result} = renderHookWithProviders(
+      () => usePreventAIGitHubConfig({gitOrgName}),
+      {
+        organization: org,
+      }
+    );
+
+    await waitFor(() => {
+      expect(result.current.isPending).toBe(false);
+    });
+
+    expect(result.current.data).toMatchObject(configResponse);
+    expect(result.current.isError).toBeFalsy();
+  });
+
+  it('sets isError when API fails', async () => {
+    MockApiClient.addMockResponse({
+      url: `/organizations/${org.slug}/prevent/ai/github/config/${gitOrgName}/`,
+      statusCode: 500,
+    });
+
+    const {result} = renderHookWithProviders(
+      () => usePreventAIGitHubConfig({gitOrgName}),
+      {
+        organization: org,
+      }
+    );
+
+    await waitFor(() => {
+      expect(result.current.isPending).toBe(false);
+    });
+
+    expect(result.current.isError).toBe(true);
+    expect(result.current.data).toBeUndefined();
+  });
+
+  it('uses correct API URL for different org', async () => {
+    const diffOrg = OrganizationFixture({slug: 'diff-org'});
+
+    MockApiClient.addMockResponse({
+      url: `/organizations/diff-org/prevent/ai/github/config/${gitOrgName}/`,
+      body: {},
+    });
+
+    const {result} = renderHookWithProviders(
+      () => usePreventAIGitHubConfig({gitOrgName}),
+      {
+        organization: diffOrg,
+      }
+    );
+
+    await waitFor(() => {
+      expect(result.current.isPending).toBe(false);
+    });
+
+    expect(result.current.isError).toBeFalsy();
+  });
+});
diff --git a/static/app/views/prevent/preventAI/hooks/usePreventAIConfig.tsx b/static/app/views/prevent/preventAI/hooks/usePreventAIConfig.tsx
@@ -0,0 +1,19 @@
+import type {PreventAIConfig} from 'sentry/types/prevent';
+import {useApiQuery} from 'sentry/utils/queryClient';
+import useOrganization from 'sentry/utils/useOrganization';
+
+interface UsePreventAIGitHubConfigOptions {
+  gitOrgName: string;
+}
+
+export function usePreventAIGitHubConfig({gitOrgName}: UsePreventAIGitHubConfigOptions) {
+  const organization = useOrganization();
+
+  return useApiQuery<{
+    default_org_config: PreventAIConfig;
+    organization: Record<string, PreventAIConfig>;
+    schema_version: string;
+  }>([`/organizations/${organization.slug}/prevent/ai/github/config/${gitOrgName}/`], {
+    staleTime: 30000,
+  });
+}
diff --git a/static/app/views/prevent/preventAI/hooks/usePreventAIOrgRepos.spec.tsx b/static/app/views/prevent/preventAI/hooks/usePreventAIOrgRepos.spec.tsx
@@ -1,6 +1,5 @@
 import {OrganizationFixture} from 'sentry-fixture/organization';
 import {OrganizationIntegrationsFixture} from 'sentry-fixture/organizationIntegrations';
-import {PreventAIConfigFixture} from 'sentry-fixture/prevent';
 
 import {renderHookWithProviders, waitFor} from 'sentry-test/reactTestingLibrary';
 
@@ -9,9 +8,7 @@ import type {OrganizationIntegration} from 'sentry/types/integrations';
 import {usePreventAIOrgs} from './usePreventAIOrgRepos';
 
 describe('usePreventAIOrgRepos', () => {
-  const mockOrg = OrganizationFixture({
-    preventAiConfigGithub: PreventAIConfigFixture(),
-  });
+  const mockOrg = OrganizationFixture();
 
   const mockResponse: OrganizationIntegration[] = [
     OrganizationIntegrationsFixture({
diff --git a/static/app/views/prevent/preventAI/hooks/useUpdatePreventAIFeature.tsx b/static/app/views/prevent/preventAI/hooks/useUpdatePreventAIFeature.tsx
@@ -1,18 +1,17 @@
-import {updateOrganization} from 'sentry/actionCreators/organizations';
-import type {Organization} from 'sentry/types/organization';
 import type {
   PreventAIConfig,
   PreventAIFeatureTriggers,
   Sensitivity,
 } from 'sentry/types/prevent';
-import {fetchMutation, useMutation} from 'sentry/utils/queryClient';
+import {fetchMutation, useMutation, useQueryClient} from 'sentry/utils/queryClient';
 import useOrganization from 'sentry/utils/useOrganization';
 
 interface UpdatePreventAIFeatureParams {
   enabled: boolean;
   // 'use_org_defaults' is a special case that will remove the entire repo override
   feature: 'vanilla' | 'test_generation' | 'bug_prediction' | 'use_org_defaults';
-  orgId: string;
+  gitOrgName: string;
+  originalConfig: PreventAIConfig;
   // if repo is provided, edit repo_overrides for that repo, otherwise edit org_defaults
   repoId?: string;
   sensitivity?: Sensitivity;
@@ -21,20 +20,28 @@ interface UpdatePreventAIFeatureParams {
 
 export function useUpdatePreventAIFeature() {
   const organization = useOrganization();
+  const queryClient = useQueryClient();
+
   const {mutateAsync, isPending, error} = useMutation({
     mutationFn: async (params: UpdatePreventAIFeatureParams) => {
-      if (!organization.preventAiConfigGithub) {
-        throw new Error('Organization has no AI Code Review config');
-      }
-      const newConfig = makePreventAIConfig(organization.preventAiConfigGithub, params);
+      const newOrgConfig = makePreventAIOrgConfig(params.originalConfig, params);
 
-      return fetchMutation<Partial<Organization>>({
+      return fetchMutation<{
+        default_org_config: PreventAIConfig;
+        organization: Record<string, PreventAIConfig>;
+      }>({
         method: 'PUT',
-        url: `/organizations/${organization.slug}/`,
-        data: {preventAiConfigGithub: newConfig},
+        url: `/organizations/${organization.slug}/prevent/ai/github/config/${params.gitOrgName}/`,
+        data: newOrgConfig as unknown as Record<string, PreventAIConfig>,
+      });
+    },
+    onSuccess: (_data, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: [
+          `/organizations/${organization.slug}/prevent/ai/github/config/${variables.gitOrgName}/`,
+        ],
       });
     },
-    onSuccess: updateOrganization,
   });
 
   return {
@@ -45,46 +52,49 @@ export function useUpdatePreventAIFeature() {
 }
 
 /**
- * Makes a new PreventAIConfig object with feature settings applied for the specified org and/or repo
+ * Makes a new PreventAIOrgConfig object with feature settings applied for the specified repo or org defaults
  * 1. Deep clones the original config to prevent mutation
- * 2. Get the org config for the specified org or create it from default_org_config template if not exists
- * 3. If editing repo, get the repo override for the specified repo or create it from org_defaults template if not exists
- * 4. Modifies the specified feature's settings, preserves any unspecified settings.
- * 5. Special case: 'use_org_defaults' feature type will remove the entire repo override
+ * 2. If editing repo, get the repo override for the specified repo or create it from org_defaults template if not exists
+ * 3. Modifies the specified feature's settings, preserves any unspecified settings.
+ * 4. Special case: 'use_org_defaults' feature type will remove the entire repo override
  *
- * @param originalConfig Original PreventAIConfig object (will not be mutated)
+ * @param originalConfig Original PreventAIOrgConfig object (will not be mutated)
  * @param params Parameters to update
- * @returns New (copy of) PreventAIConfig object with updates applied
+ * @returns New (copy of) PreventAIOrgConfig object with updates applied
  */
-export function makePreventAIConfig(
+export function makePreventAIOrgConfig(
   originalConfig: PreventAIConfig,
   params: UpdatePreventAIFeatureParams
-) {
-  const updatedConfig = structuredClone(originalConfig);
+): PreventAIConfig {
+  const updatedOrgConfig = structuredClone(originalConfig);
+  if (!updatedOrgConfig.schema_version) {
+    updatedOrgConfig.schema_version = 'v1';
+  }
 
-  const orgConfig =
-    updatedConfig.github_organizations[params.orgId] ??
-    structuredClone(updatedConfig.default_org_config);
-  updatedConfig.github_organizations[params.orgId] = orgConfig;
+  if (!updatedOrgConfig.repo_overrides) {
+    updatedOrgConfig.repo_overrides = {};
+  }
 
   if (params.feature === 'use_org_defaults') {
     if (!params.repoId) {
       throw new Error('Repo name is required when feature is use_org_defaults');
     }
     if (params.enabled) {
-      delete orgConfig.repo_overrides[params.repoId];
+      delete updatedOrgConfig.repo_overrides[params.repoId];
     } else {
-      orgConfig.repo_overrides[params.repoId] = structuredClone(orgConfig.org_defaults);
+      updatedOrgConfig.repo_overrides[params.repoId] = structuredClone(
+        updatedOrgConfig.org_defaults
+      );
     }
-    return updatedConfig;
+    return updatedOrgConfig;
   }
 
-  let featureConfig = orgConfig.org_defaults;
+  let featureConfig = updatedOrgConfig.org_defaults;
   if (params.repoId) {
-    let repoOverride = orgConfig.repo_overrides[params.repoId];
+    let repoOverride = updatedOrgConfig.repo_overrides[params.repoId];
     if (!repoOverride) {
-      repoOverride = structuredClone(orgConfig.org_defaults);
-      orgConfig.repo_overrides[params.repoId] = repoOverride;
+      repoOverride = structuredClone(updatedOrgConfig.org_defaults);
+      updatedOrgConfig.repo_overrides[params.repoId] = repoOverride;
     }
     featureConfig = repoOverride;
   }
@@ -95,5 +105,5 @@ export function makePreventAIConfig(
     sensitivity: params.sensitivity ?? featureConfig[params.feature].sensitivity,
   };
 
-  return updatedConfig;
+  return updatedOrgConfig;
 }
diff --git a/static/app/views/prevent/preventAI/manageRepos.spec.tsx b/static/app/views/prevent/preventAI/manageRepos.spec.tsx
@@ -1,6 +1,5 @@
 import {OrganizationFixture} from 'sentry-fixture/organization';
 import {OrganizationIntegrationsFixture} from 'sentry-fixture/organizationIntegrations';
-import {PreventAIConfigFixture} from 'sentry-fixture/prevent';
 
 import {render, screen, userEvent} from 'sentry-test/reactTestingLibrary';
 
@@ -24,9 +23,7 @@ describe('PreventAIManageRepos', () => {
     }),
   ];
 
-  const organization = OrganizationFixture({
-    preventAiConfigGithub: PreventAIConfigFixture(),
-  });
+  const organization = OrganizationFixture();
 
   beforeEach(() => {
     MockApiClient.addMockResponse({
diff --git a/static/app/views/prevent/preventAI/manageReposPanel.tsx b/static/app/views/prevent/preventAI/manageReposPanel.tsx
diff --git a/tests/js/fixtures/prevent.ts b/tests/js/fixtures/prevent.ts

Original file line number	Diff line number	Diff line change
`@@ -17,13 +17,8 @@ export interface PreventAIFeatureConfigsByName {`
`17`	`17`	`vanilla: PreventAIFeatureConfig; // "vanilla" basic ai pr review`
`18`	`18`	`}`
`19`	`19`
`20`		`-export interface PreventAIOrgConfig {`
	`20`	`+export interface PreventAIConfig {`
`21`	`21`	`org_defaults: PreventAIFeatureConfigsByName;`
`22`	`22`	`repo_overrides: Record<string, PreventAIFeatureConfigsByName>;`
`23`		`-}`
`24`		`-`
`25`		`-export interface PreventAIConfig {`
`26`		`- default_org_config: PreventAIOrgConfig;`
`27`		`- github_organizations: Record<string, PreventAIOrgConfig>;`
`28`	`23`	`schema_version: string;`
`29`	`24`	`}`