Skip to content

The Postgres development platform. Supabase gives you a dedicated Postgres database to build your web, mobile, and AI applications.

[FE-4483] fix(studio): disable network bans for v3 projects (#50997)

Alaister Young995f6f65c776
diff --git a/apps/studio/components/interfaces/Settings/Database/BannedIPs.test.tsx b/apps/studio/components/interfaces/Settings/Database/BannedIPs.test.tsx
new file mode 100644
index 00000000000..5026bb02d25
--- /dev/null
+++ b/apps/studio/components/interfaces/Settings/Database/BannedIPs.test.tsx
@@ -0,0 +1,134 @@
+import { QueryClient } from '@tanstack/react-query'
+import { fireEvent, screen, waitFor } from '@testing-library/react'
+import { mockAnimationsApi } from 'jsdom-testing-mocks'
+import { HttpResponse } from 'msw'
+import { beforeEach, expect, test, vi } from 'vitest'
+
+import { BannedIPs } from './BannedIPs'
+import type { deleteBannedIPs } from '@/data/banned-ips/banned-ips-delete-mutations'
+import type { IPData } from '@/data/banned-ips/banned-ips-query'
+import type { ProjectDetail } from '@/data/projects/project-detail-query'
+import { customRender } from '@/tests/lib/custom-render'
+import { addAPIMock, type APIErrorBody } from '@/tests/lib/msw'
+
+mockAnimationsApi()
+
+const routeParams = vi.hoisted(() => ({ ref: 'default' }))
+beforeEach(() => {
+ routeParams.ref = 'default'
+})
+
+vi.mock('common', async (importOriginal) => ({
+ ...(await importOriginal<typeof import('common')>()),
+ IS_PLATFORM: true,
+ useParams: () => routeParams,
+}))
+
+vi.mock('@/lib/constants', async (importOriginal) => ({
+ ...(await importOriginal<typeof import('@/lib/constants')>()),
+ IS_PLATFORM: true,
+}))
+
+vi.mock('@/hooks/misc/useCheckPermissions', () => ({
+ useAsyncCheckPermissions: () => ({ can: true }),
+}))
+
+vi.mock('@/lib/telemetry/track', () => ({ useTrack: () => vi.fn() }))
+
+test('shows a project-details error instead of leaving Network bans loading', async () => {
+ addAPIMock({
+ method: 'get',
+ path: '/platform/projects/:ref',
+ response: () =>
+ HttpResponse.json<APIErrorBody>({ message: 'Project unavailable' }, { status: 500 }),
+ })
+
+ customRender(<BannedIPs />)
+
+ expect(await screen.findByText('Failed to retrieve project details')).toBeVisible()
+ expect(screen.getByText('Error: Project unavailable')).toBeVisible()
+ expect(screen.getByRole('link', { name: 'Contact support' })).toHaveAttribute(
+ 'href',
+ expect.stringContaining('projectRef=default')
+ )
+ expect(screen.queryByRole('button', { name: 'Unban IP' })).not.toBeInTheDocument()
+ expect(
+ screen.queryByText('There are no banned IP addresses for your project')
+ ).not.toBeInTheDocument()
+})
+
+const PROJECT: ProjectDetail = {
+ cloud_provider: 'AWS',
+ connectionString: 'postgresql://postgres:[email protected]:5432/postgres',
+ db_host: 'db.default.supabase.co',
+ dbVersion: 'supabase-postgres-15.1.0',
+ high_availability: false,
+ id: 1,
+ infra_compute_size: 'micro',
+ inserted_at: '2026-01-01T00:00:00.000Z',
+ integration_source: null,
+ is_branch_enabled: false,
+ is_physical_backups_enabled: false,
+ name: 'Test project',
+ organization_id: 1,
+ ref: 'default',
+ region: 'us-east-1',
+ restUrl: 'https://default.supabase.co',
+ status: 'ACTIVE_HEALTHY',
+ subscription_id: 'subscription-1',
+ updated_at: '2026-01-01T00:00:00.000Z',
+}
+
+test.each([
+ { name: 'v3', cloud_provider: 'AWS_K8S', high_availability: false },
+ { name: 'HA', cloud_provider: 'AWS', high_availability: true },
+])('clears an open unban confirmation when navigating to $name', async (unsupported) => {
+ let bannedIPs: IPData = { banned_ipv4_addresses: ['203.0.113.10'] }
+ const unbanRequests: unknown[] = []
+ addAPIMock({
+ method: 'get',
+ path: '/platform/projects/:ref',
+ response: ({ params }) =>
+ HttpResponse.json<ProjectDetail>(
+ params.ref === 'default' ? PROJECT : { ...PROJECT, ...unsupported, ref: String(params.ref) }
+ ),
+ })
+ addAPIMock({
+ method: 'post',
+ path: '/v1/projects/:ref/network-bans/retrieve',
+ response: () => HttpResponse.json<IPData>(bannedIPs),
+ })
+ addAPIMock({
+ method: 'delete',
+ path: '/v1/projects/:ref/network-bans',
+ response: async ({ request }) => {
+ unbanRequests.push(await request.json())
+ bannedIPs = { banned_ipv4_addresses: [] }
+ return HttpResponse.json<Awaited<ReturnType<typeof deleteBannedIPs>>>(null)
+ },
+ })
+ const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+ const { rerender } = customRender(<BannedIPs />, { queryClient })
+
+ fireEvent.click(await screen.findByRole('button', { name: 'Unban IP' }))
+ expect(await screen.findByRole('dialog', { name: 'Confirm Unban IP' })).toBeVisible()
+
+ routeParams.ref = 'unsupported'
+ rerender(<BannedIPs />)
+
+ await waitFor(() => expect(screen.queryByRole('dialog')).not.toBeInTheDocument())
+ expect(screen.queryByRole('button', { name: 'Unban IP' })).not.toBeInTheDocument()
+ expect(unbanRequests).toEqual([])
+
+ routeParams.ref = 'default'
+ rerender(<BannedIPs />)
+
+ const unbanButton = await screen.findByRole('button', { name: 'Unban IP' })
+ expect(screen.queryByRole('dialog')).not.toBeInTheDocument()
+ expect(unbanRequests).toEqual([])
+
+ fireEvent.click(unbanButton)
+ fireEvent.click(await screen.findByRole('button', { name: 'Confirm Unban' }))
+ expect(await screen.findByText('There are no banned IP addresses for your project')).toBeVisible()
+ expect(unbanRequests).toEqual([{ ipv4_addresses: ['203.0.113.10'] }])
+})
diff --git a/apps/studio/components/interfaces/Settings/Database/BannedIPs.tsx b/apps/studio/components/interfaces/Settings/Database/BannedIPs.tsx
index 1a8fd206b02..ed01b76b1ec 100644
--- a/apps/studio/components/interfaces/Settings/Database/BannedIPs.tsx
+++ b/apps/studio/components/interfaces/Settings/Database/BannedIPs.tsx
@@ -1,9 +1,10 @@
import { PermissionAction } from '@supabase/shared-types/out/constants'
import { useParams } from 'common'
import { Globe } from 'lucide-react'
-import { useState } from 'react'
+import { useMemo, useState } from 'react'
import { toast } from 'sonner'
import { Badge, Card, CardContent, Skeleton } from 'ui'
+import { Admonition } from 'ui-patterns/Admonition'
import ConfirmationModal from 'ui-patterns/Dialogs/ConfirmationModal'
import {
PageSection,
@@ -23,52 +24,56 @@ import { useBannedIPsQuery } from '@/data/banned-ips/banned-ips-query'
import { useUserIPAddressQuery } from '@/data/misc/user-ip-address-query'
import { useAsyncCheckPermissions } from '@/hooks/misc/useCheckPermissions'
import { useHighAvailability } from '@/hooks/misc/useHighAvailability'
-import { useSelectedProjectQuery } from '@/hooks/misc/useSelectedProject'
+import { useIsAwsK8sCloudProvider, useSelectedProjectQuery } from '@/hooks/misc/useSelectedProject'
import { DOCS_URL } from '@/lib/constants'
const HA_DISABLED_TITLE = 'Network bans unavailable on High Availability projects'
const HA_DISABLED_DESCRIPTION =
"We're working to bring network bans to High Availability projects. Contact support if this is blocking your work."
+const V3_DISABLED_TITLE = 'Network bans unavailable on v3 projects'
export const BannedIPs = () => {
const { ref } = useParams()
- const { data: project } = useSelectedProjectQuery()
+ const { data: project, error: projectError } = useSelectedProjectQuery()
const { isHighAvailability } = useHighAvailability()
+ const isAwsK8s = useIsAwsK8sCloudProvider()
- const [selectedIPToUnban, setSelectedIPToUnban] = useState<string | null>(null) // Track the selected IP for unban
+ const [selectedIPToUnban, setSelectedIPToUnban] = useState<string | null>(null)
const {
isPending: isLoadingIPList,
isFetching: isFetchingIPList,
data: ipList,
error: ipListError,
- } = useBannedIPsQuery({
- projectRef: ref,
- })
+ } = useBannedIPsQuery({ projectRef: ref })
const { data: userIPAddress } = useUserIPAddressQuery()
+ const hasProjectError = !project && !!projectError
const ipListLoading = isLoadingIPList || isFetchingIPList
- const [showUnban, setShowUnban] = useState(false)
- const [confirmingIP, setConfirmingIP] = useState<string | null>(null) // Track the IP being confirmed for unban
-
const { can: canUnbanNetworks } = useAsyncCheckPermissions(PermissionAction.UPDATE, 'projects', {
resource: {
project_id: project?.id,
},
})
- const isSectionDisabled = isHighAvailability || !canUnbanNetworks
- const sectionDisabledReason = isHighAvailability
- ? HA_DISABLED_TITLE
- : 'You need additional permissions to unban networks'
+ const isSectionDisabled = isHighAvailability || isAwsK8s || !canUnbanNetworks
+
+ if (isSectionDisabled && selectedIPToUnban !== null) {
+ setSelectedIPToUnban(null)
+ }
+
+ const sectionDisabledReason = useMemo(() => {
+ if (isHighAvailability) return HA_DISABLED_TITLE
+ if (isAwsK8s) return V3_DISABLED_TITLE
+ return 'You need additional permissions to unban networks'
+ }, [isHighAvailability, isAwsK8s])
const { mutate: unbanIPs, isPending: isUnbanning } = useBannedIPsDeleteMutation({
onSuccess: () => {
toast.success('IP address successfully unbanned')
- setSelectedIPToUnban(null) // Reset the selected IP for unban
- setShowUnban(false)
+ setSelectedIPToUnban(null)
},
onError: (error) => {
toast.error(`Failed to unban IP: ${error?.message}`)
@@ -76,19 +81,13 @@ export const BannedIPs = () => {
})
const onConfirmUnbanIP = () => {
- if (confirmingIP == null || !ref) return
+ if (selectedIPToUnban === null || !ref || isSectionDisabled) return
unbanIPs({
projectRef: ref,
- ips: [confirmingIP], // Pass the IP as an array
+ ips: [selectedIPToUnban], // Pass the IP as an array
})
}
- const openConfirmationModal = (ip: string) => {
- setSelectedIPToUnban(ip) // Set the selected IP for unban
- setConfirmingIP(ip) // Set the IP being confirmed for unban
- setShowUnban(true)
- }
-
return (
<>
<PageSection id="banned-ips">
@@ -102,6 +101,13 @@ export const BannedIPs = () => {
<DocsButton href={`${DOCS_URL}/reference/cli/supabase-network-bans`} />
</PageSectionMeta>
<PageSectionContent>
+ {hasProjectError && (
+ <AlertError
+ error={projectError}
+ subject="Failed to retrieve project details"
+ projectRef={ref}
+ />
+ )}
{isHighAvailability && (
<div className="mb-4">
<HighAvailabilityDisabledSectionNotice
@@ -110,47 +116,63 @@ export const BannedIPs = () => {
/>
</div>
)}
- {!isHighAvailability &&
- (ipListLoading ? (
- <Card>
- <CardContent className="space-y-4">
- <Skeleton className="h-4 w-full" />
- <Skeleton className="h-4 w-full" />
- </CardContent>
- </Card>
- ) : ipListError ? (
- <AlertError error={ipListError} subject="Failed to retrieve banned IP addresses" />
- ) : ipList.banned_ipv4_addresses.length > 0 ? (
- <Card>
- {ipList.banned_ipv4_addresses.map((ip) => (
- <CardContent key={ip} className="flex items-center justify-between">
- <div className="flex items-center space-x-5">
- <Globe size={16} className="text-foreground-lighter" />
- <p className="text-sm font-mono">{ip}</p>
- {ip === userIPAddress && <Badge>Your IP address</Badge>}
- </div>
- <ButtonTooltip
- disabled={isSectionDisabled}
- onClick={() => openConfirmationModal(ip)}
- tooltip={{
- content: {
- side: 'bottom',
- text: isSectionDisabled ? sectionDisabledReason : undefined,
- },
- }}
- >
- Unban IP
- </ButtonTooltip>
+ {!isHighAvailability && isAwsK8s && (
+ <Admonition
+ type="default"
+ title={V3_DISABLED_TITLE}
+ description="Fail2Ban is not supported on v3 projects."
+ />
+ )}
+ {!hasProjectError && !isHighAvailability && !isAwsK8s && (
+ <>
+ {ipListError && (
+ <AlertError
+ error={ipListError}
+ subject="Failed to retrieve banned IP addresses"
+ projectRef={ref}
+ />
+ )}
+ {!ipListError && ipListLoading && (
+ <Card>
+ <CardContent className="space-y-4">
+ <Skeleton className="h-4 w-full" />
+ <Skeleton className="h-4 w-full" />
</CardContent>
- ))}
- </Card>
- ) : (
- <Card>
- <CardContent className="text-foreground text-sm">
- There are no banned IP addresses for your project
- </CardContent>
- </Card>
- ))}
+ </Card>
+ )}
+ {!ipListError && !ipListLoading && ipList && (
+ <Card>
+ {ipList.banned_ipv4_addresses.length > 0 ? (
+ ipList.banned_ipv4_addresses.map((ip) => (
+ <CardContent key={ip} className="flex items-center justify-between">
+ <div className="flex items-center space-x-5">
+ <Globe size={16} className="text-foreground-lighter" />
+ <p className="text-sm font-mono">{ip}</p>
+ {ip === userIPAddress && <Badge>Your IP address</Badge>}
+ </div>
+ <ButtonTooltip
+ disabled={isSectionDisabled}
+ onClick={() => setSelectedIPToUnban(ip)}
+ tooltip={{
+ content: {
+ side: 'bottom',
+ text: isSectionDisabled ? sectionDisabledReason : undefined,
+ },
+ }}
+ >
+ Unban IP
+ </ButtonTooltip>
+ </CardContent>
+ ))
+ ) : (
+ <CardContent className="text-foreground text-sm">
+ There are no banned IP addresses for your project
+ </CardContent>
+ )}
+ </Card>
+ )}
+ </>
+ )}
</PageSectionContent>
</PageSection>
@@ -158,11 +180,11 @@ export const BannedIPs = () => {
variant="destructive"
size="medium"
loading={isUnbanning}
- visible={showUnban}
+ visible={selectedIPToUnban !== null && !isSectionDisabled}
title="Confirm Unban IP"
confirmLabel="Confirm Unban"
confirmLabelLoading="Unbanning..."
- onCancel={() => setShowUnban(false)}
+ onCancel={() => setSelectedIPToUnban(null)}
onConfirm={onConfirmUnbanIP}
alert={{
title: 'This action cannot be undone',
diff --git a/apps/studio/data/banned-ips/banned-ips-query.test.tsx b/apps/studio/data/banned-ips/banned-ips-query.test.tsx
new file mode 100644
index 00000000000..1622cd0d11d
--- /dev/null
+++ b/apps/studio/data/banned-ips/banned-ips-query.test.tsx
@@ -0,0 +1,233 @@
+import { QueryClient } from '@tanstack/react-query'
+import { act, waitFor } from '@testing-library/react'
+import { HttpResponse } from 'msw'
+import { describe, expect, test, vi } from 'vitest'
+
+import { useBannedIPsQuery, type IPData } from './banned-ips-query'
+import { useAdvisorSignals } from '@/components/ui/AdvisorPanel/useAdvisorSignals'
+import { useProjectDetailQuery, type ProjectDetail } from '@/data/projects/project-detail-query'
+import { customRenderHook } from '@/tests/lib/custom-render'
+import { addAPIMock, type APIErrorBody } from '@/tests/lib/msw'
+
+vi.mock('common', async (importOriginal) => ({
+ ...(await importOriginal<typeof import('common')>()),
+ IS_PLATFORM: true,
+}))
+
+const PROJECT: ProjectDetail = {
+ cloud_provider: 'AWS',
+ connectionString: 'postgresql://postgres:[email protected]:5432/postgres',
+ db_host: 'db.default.supabase.co',
+ dbVersion: 'supabase-postgres-15.1.0',
+ high_availability: false,
+ id: 1,
+ infra_compute_size: 'micro',
+ inserted_at: '2026-01-01T00:00:00.000Z',
+ integration_source: null,
+ is_branch_enabled: false,
+ is_physical_backups_enabled: false,
+ name: 'Test project',
+ organization_id: 1,
+ ref: 'default',
+ region: 'us-east-1',
+ restUrl: 'https://default.supabase.co',
+ status: 'ACTIVE_HEALTHY',
+ subscription_id: 'subscription-1',
+ updated_at: '2026-01-01T00:00:00.000Z',
+}
+
+const BANNED_IPS: IPData = { banned_ipv4_addresses: ['203.0.113.10'] }
+
+const mockBannedIPs = () => {
+ const requests: string[] = []
+ addAPIMock({
+ method: 'post',
+ path: '/v1/projects/:ref/network-bans/retrieve',
+ response: ({ request }) => {
+ requests.push(request.url)
+ return HttpResponse.json<IPData>(BANNED_IPS)
+ },
+ })
+ return requests
+}
+
+describe('useBannedIPsQuery', () => {
+ test.each([
+ { name: 'v3', cloud_provider: 'AWS_K8S', high_availability: false },
+ { name: 'HA', cloud_provider: 'AWS', high_availability: true },
+ { name: 'v3 HA', cloud_provider: 'AWS_K8S', high_availability: true },
+ ])('does not retrieve bans for $name with Settings and Advisor enabled', async (project) => {
+ addAPIMock({
+ method: 'get',
+ path: '/platform/projects/:ref',
+ response: () => HttpResponse.json<ProjectDetail>({ ...PROJECT, ...project }),
+ })
+ const requests = mockBannedIPs()
+ const { result } = customRenderHook(() => ({
+ project: useProjectDetailQuery({ ref: 'default' }),
+ settings: useBannedIPsQuery({ projectRef: 'default' }),
+ advisor: useAdvisorSignals({ projectRef: 'default' }),
+ }))
+
+ await waitFor(() => expect(result.current.project.isSuccess).toBe(true))
+ expect(result.current.settings.fetchStatus).toBe('idle')
+ expect(result.current.advisor.data).toEqual([])
+ expect(requests).toEqual([])
+
+ const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {})
+ try {
+ await act(async () => {
+ await expect(result.current.settings.refetch({ throwOnError: true })).rejects.toThrow()
+ })
+ expect(requests).toEqual([])
+ } finally {
+ consoleError.mockRestore()
+ }
+ })
+
+ test('shares banned IPs with Advisor on a supported project', async () => {
+ addAPIMock({
+ method: 'get',
+ path: '/platform/projects/:ref',
+ response: () => HttpResponse.json<ProjectDetail>(PROJECT),
+ })
+ const requests = mockBannedIPs()
+ const { result } = customRenderHook(() => ({
+ settings: useBannedIPsQuery({ projectRef: 'default' }),
+ advisor: useAdvisorSignals({ projectRef: 'default' }),
+ }))
+
+ await waitFor(() => expect(result.current.advisor.data).toHaveLength(1))
+ expect(result.current.settings.data).toEqual(BANNED_IPS)
+ expect(requests).toHaveLength(1)
+ })
+
+ test('waits for project details before retrieving bans', async () => {
+ const { promise, resolve } = Promise.withResolvers<void>()
+ let hasRequestedProject = false
+ addAPIMock({
+ method: 'get',
+ path: '/platform/projects/:ref',
+ response: async () => {
+ hasRequestedProject = true
+ await promise
+ return HttpResponse.json<ProjectDetail>(PROJECT)
+ },
+ })
+ const requests = mockBannedIPs()
+ const { result } = customRenderHook(() => useBannedIPsQuery({ projectRef: 'default' }))
+
+ try {
+ await waitFor(() => expect(hasRequestedProject).toBe(true))
+ expect(result.current.fetchStatus).toBe('idle')
+ expect(requests).toEqual([])
+ } finally {
+ resolve()
+ }
+
+ await waitFor(() => expect(result.current.isSuccess).toBe(true))
+ expect(requests).toHaveLength(1)
+ })
+
+ test('waits for project details to recover before retrieving bans', async () => {
+ addAPIMock({
+ method: 'get',
+ path: '/platform/projects/:ref',
+ response: () =>
+ HttpResponse.json<APIErrorBody>({ message: 'Project unavailable' }, { status: 500 }),
+ })
+ const requests = mockBannedIPs()
+ const { result } = customRenderHook(() => ({
+ project: useProjectDetailQuery({ ref: 'default' }),
+ bans: useBannedIPsQuery({ projectRef: 'default' }),
+ }))
+
+ await waitFor(() => expect(result.current.project.isError).toBe(true))
+ expect(result.current.bans.fetchStatus).toBe('idle')
+ expect(requests).toEqual([])
+
+ addAPIMock({
+ method: 'get',
+ path: '/platform/projects/:ref',
+ response: () => HttpResponse.json<ProjectDetail>(PROJECT),
+ })
+ await act(() => result.current.project.refetch())
+
+ await waitFor(() => expect(result.current.bans.isSuccess).toBe(true))
+ expect(result.current.bans.data).toEqual(BANNED_IPS)
+ expect(requests).toHaveLength(1)
+ })
+
+ test('keeps bans visible when project details fail to refresh with cached supported data', async () => {
+ addAPIMock({
+ method: 'get',
+ path: '/platform/projects/:ref',
+ response: () => HttpResponse.json<ProjectDetail>(PROJECT),
+ })
+ mockBannedIPs()
+ const { result } = customRenderHook(() => ({
+ project: useProjectDetailQuery({ ref: 'default' }),
+ bans: useBannedIPsQuery({ projectRef: 'default' }),
+ advisor: useAdvisorSignals({ projectRef: 'default' }),
+ }))
+
+ await waitFor(() => expect(result.current.advisor.data).toHaveLength(1))
+ addAPIMock({
+ method: 'get',
+ path: '/platform/projects/:ref',
+ response: () =>
+ HttpResponse.json<APIErrorBody>({ message: 'Project unavailable' }, { status: 500 }),
+ })
+ await act(async () => {
+ const projectResult = await result.current.project.refetch()
+ expect(projectResult.isError).toBe(true)
+ })
+ expect(result.current.bans.data).toEqual(BANNED_IPS)
+ expect(result.current.advisor.data).toHaveLength(1)
+ })
+
+ test.each([
+ { projectRef: 'default', enabled: false },
+ { projectRef: undefined, enabled: true },
+ ])('does not fetch with $projectRef and enabled=$enabled', ({ projectRef, enabled }) => {
+ const { result } = customRenderHook(() => useBannedIPsQuery({ projectRef }, { enabled }))
+
+ expect(result.current.fetchStatus).toBe('idle')
+ })
+
+ test('checks the requested project when navigating from supported to v3', async () => {
+ addAPIMock({
+ method: 'get',
+ path: '/platform/projects/:ref',
+ response: ({ params }) =>
+ HttpResponse.json<ProjectDetail>({
+ ...PROJECT,
+ ref: String(params.ref),
+ cloud_provider: params.ref === 'v3' ? 'AWS_K8S' : 'AWS',
+ }),
+ })
+ const requests = mockBannedIPs()
+ const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+ let projectRef = 'default'
+ const { result, rerender } = customRenderHook(
+ () => ({
+ project: useProjectDetailQuery({ ref: projectRef }),
+ bans: useBannedIPsQuery({ projectRef }),
+ advisor: useAdvisorSignals({ projectRef }),
+ }),
+ { queryClient }
+ )
+
+ await waitFor(() => expect(result.current.bans.isSuccess).toBe(true))
+ act(() => {
+ projectRef = 'v3'
+ rerender()
+ })
+
+ await waitFor(() => expect(result.current.project.data?.ref).toBe('v3'))
+ expect(result.current.bans.fetchStatus).toBe('idle')
+ expect(result.current.advisor.data).toEqual([])
+ expect(requests).toHaveLength(1)
+ expect(requests[0]).toContain('/projects/default/network-bans/retrieve')
+ })
+})
diff --git a/apps/studio/data/banned-ips/banned-ips-query.ts b/apps/studio/data/banned-ips/banned-ips-query.ts
index 13a9f5dbcfc..370dfe83009 100644
--- a/apps/studio/data/banned-ips/banned-ips-query.ts
+++ b/apps/studio/data/banned-ips/banned-ips-query.ts
@@ -1,8 +1,10 @@
-import { useQuery } from '@tanstack/react-query'
+import { skipToken, useQuery } from '@tanstack/react-query'
import { IS_PLATFORM } from 'common'
import { BannedIPKeys } from './keys'
import { handleError, post } from '@/data/fetchers'
+import { useProjectDetailQuery } from '@/data/projects/project-detail-query'
+import { PROVIDERS } from '@/lib/constants'
import type { ResponseError, UseCustomQueryOptions } from '@/types'
type BannedIPVariables = { projectRef?: string }
@@ -25,13 +27,21 @@ export type IPError = ResponseError
export const useBannedIPsQuery = <TData = IPData>(
{ projectRef }: BannedIPVariables,
{ enabled = true, ...options }: UseCustomQueryOptions<IPData, IPError, TData> = {}
-) =>
- useQuery<IPData, IPError, TData>({
+) => {
+ const { data: project } = useProjectDetailQuery(
+ { ref: projectRef },
+ { enabled: enabled && IS_PLATFORM }
+ )
+ const isSupported =
+ !!project && !project.high_availability && project.cloud_provider !== PROVIDERS.AWS_K8S.id
+
+ return useQuery<IPData, IPError, TData>({
queryKey: BannedIPKeys.list(projectRef),
- queryFn: ({ signal }) => getBannedIPs({ projectRef }, signal),
- enabled: enabled && IS_PLATFORM && typeof projectRef !== 'undefined',
+ queryFn: isSupported ? ({ signal }) => getBannedIPs({ projectRef }, signal) : skipToken,
+ enabled: enabled && IS_PLATFORM && typeof projectRef !== 'undefined' && isSupported,
retry: false,
refetchOnWindowFocus: false,
staleTime: 60_000,
...options,
})
+}