The Postgres development platform. Supabase gives you a dedicated Postgres database to build your web, mobile, and AI applications.
TypeScript aialternativeauthdatabasedenoembeddingsexamplefirebasenextjsoauth2pgvectorpostgispostgrespostgresqlpostgrestrealtimesupabasevectorswebsockets
fix(telemetry): give warehouse_disabled the same schema and table counts as warehouse_enabled (#50643)
claude[bot]5bdfb8743ce4
diff --git a/apps/studio/components/interfaces/Integrations/Warehouse/OverviewTab.test.tsx b/apps/studio/components/interfaces/Integrations/Warehouse/OverviewTab.test.tsxindex 4cfac24067c..041580125ce 100644--- a/apps/studio/components/interfaces/Integrations/Warehouse/OverviewTab.test.tsx+++ b/apps/studio/components/interfaces/Integrations/Warehouse/OverviewTab.test.tsx@@ -9,9 +9,15 @@ import { toast } from 'sonner'import { beforeEach, describe, expect, test, vi } from 'vitest'import { WarehouseOverviewTab } from './OverviewTab'+import type { SchemasData } from '@/data/database/schemas-query'+import type { ProjectDetail } from '@/data/projects/project-detail-query'+import type { TablesData } from '@/data/tables/tables-query'import { customRender } from '@/tests/lib/custom-render'import { addAPIMock, type APIErrorBody } from '@/tests/lib/msw'+type PublicationDetailsResponse = components['schemas']['PublicationDetailsResponse_Output']+type ReplicationSourcesResponse = components['schemas']['SourcesResponse_Output']+type RunQueryBody = components['schemas']['RunQueryBody']type WarehouseSetupStatusResponse = components['schemas']['WarehouseSetupStatusResponse_Output']type WarehouseSetupBody = components['schemas']['WarehouseSetupBody']type WarehouseSetupResponse = components['schemas']['WarehouseSetupResponse_Output']@@ -101,6 +107,120 @@ const mockProject = () =>},})+const REPLICATION_PROJECT: ProjectDetail = {+ cloud_provider: 'AWS',+ connectionString: 'postgresql://postgres@localhost:5432/postgres',+ db_host: 'db.default.supabase.co',+ high_availability: false,+ id: 1,+ inserted_at: '2026-01-01T00:00:00.000Z',+ integration_source: null,+ is_branch_enabled: false,+ is_hibernating: false,+ is_physical_backups_enabled: false,+ name: 'Test project',+ organization_id: 1,+ ref: 'default',+ region: 'us-east-1',+ restUrl: 'https://default.supabase.co/rest/v1',+ status: 'ACTIVE_HEALTHY',+ subscription_id: 'subscription-1',+ updated_at: '2026-01-01T00:00:00.000Z',+}++const SCHEMAS: SchemasData = [+ { id: 1, name: 'public', owner: 'postgres', comment: null },+ { id: 2, name: 'analytics', owner: 'postgres', comment: null },+]++const createTable = (id: number, schema: string, name: string): TablesData[number] => ({+ id,+ schema,+ name,+ rls_enabled: false,+ rls_forced: false,+ replica_identity: 'DEFAULT',+ bytes: 1024,+ size: '1024 bytes',+ live_rows_estimate: 10,+ dead_rows_estimate: 0,+ comment: null,+ primary_keys: [],+ relationships: [],+})++const TABLES: TablesData = [+ createTable(1, 'public', 'orders'),+ createTable(2, 'public', 'customers'),+ createTable(3, 'analytics', 'events'),+ createTable(4, 'analytics', 'sessions'),+]++const SOURCES: ReplicationSourcesResponse = {+ sources: [+ {+ id: 1,+ name: 'default',+ tenant_id: 'tenant',+ config: { host: 'db.internal', name: 'main-db', port: 5432, username: 'etl_user' },+ },+ ],+}++// Every table of `public` plus one table of `analytics`: one schema target, one table target.+const PUBLICATION_TABLES: PublicationDetailsResponse['tables'] = [+ { id: 1, schema: 'public', name: 'orders', kind: 'table', partition_parent_id: null },+ { id: 2, schema: 'public', name: 'customers', kind: 'table', partition_parent_id: null },+ { id: 3, schema: 'analytics', name: 'events', kind: 'table', partition_parent_id: null },+]++// The disable card reads what is currently replicated from these four queries.+const mockReplicatedTableQueries = () => {+ const publicationRequests: string[] = []+ addAPIMock({ method: 'get', path: '/platform/projects/:ref', response: REPLICATION_PROJECT })+ addAPIMock({+ method: 'post',+ path: '/platform/pg-meta/:ref/query',+ response: async ({ request }) => {+ const body = (await request.json()) as RunQueryBody+ const result = body.query.includes("obj_description(n.oid, 'pg_namespace')")+ ? SCHEMAS+ : TABLES+ return HttpResponse.json<SchemasData | TablesData>(result)+ },+ })+ addAPIMock({+ method: 'get',+ path: '/platform/replication/:ref/sources',+ response: () => HttpResponse.json<ReplicationSourcesResponse>(SOURCES),+ })+ addAPIMock({+ method: 'get',+ path: '/platform/replication/v2/:ref/sources/:source_id/publications/:publication_name',+ response: ({ params }) => {+ publicationRequests.push(String(params.publication_name))+ return HttpResponse.json<PublicationDetailsResponse>({+ name: 'supabase_warehouse',+ config: {+ type: 'tables',+ tables: PUBLICATION_TABLES.map(({ id, schema, name }) => ({+ id,+ schema,+ name,+ columns: null,+ row_filter: null,+ })),+ operations: ['insert', 'update', 'delete', 'truncate'],+ publish_via_partition_root: false,+ },+ tables: PUBLICATION_TABLES,+ })+ },+ })++ return { publicationRequests }+}+describe('WarehouseOverviewTab', () => {beforeEach(() => {mockIsMarketplaceEnabled.mockReturnValue(true)@@ -212,6 +332,7 @@ describe('WarehouseOverviewTab', () => {{ schema: 'analytics', name: 'events', copy_name: 'analytics.events', state: 'error' },],})+ mockReplicatedTableQueries()customRender(<WarehouseOverviewTab />)@@ -254,6 +375,7 @@ describe('WarehouseOverviewTab', () => {test('does not track an edited table selection as enablement', async () => {mockSetupStatus({ setup_status: 'complete' })+ mockReplicatedTableQueries()addAPIMock({method: 'post',path: '/platform/warehouse/:ref/setup',@@ -269,6 +391,7 @@ describe('WarehouseOverviewTab', () => {test('disables Warehouse with an empty target list after confirmation', async () => {mockSetupStatus({ setup_status: 'complete' })+ mockReplicatedTableQueries()const setupRequests: WarehouseSetupBody[] = []addAPIMock({method: 'post',@@ -293,8 +416,34 @@ describe('WarehouseOverviewTab', () => {await waitFor(() => expect(setupRequests).toEqual([{ targets: [] }]))})+ test('tracks how much was being replicated when Warehouse is disabled', async () => {+ mockSetupStatus({ setup_status: 'complete' })+ const { publicationRequests } = mockReplicatedTableQueries()+ addAPIMock({+ method: 'post',+ path: '/platform/warehouse/:ref/setup',+ response: () => HttpResponse.json<WarehouseSetupResponse>({ pipeline_id: 1, tables: [] }),+ })++ customRender(<WarehouseOverviewTab />)++ await userEvent.click(await screen.findByRole('button', { name: 'Disable Warehouse' }))+ const dialog = await screen.findByRole('alertdialog')+ await waitFor(() => expect(publicationRequests).toEqual(['supabase_warehouse']))++ fireEvent.click(within(dialog).getByRole('button', { name: 'Disable Warehouse' }))++ await waitFor(() =>+ expect(mockTrack).toHaveBeenCalledWith('warehouse_disabled', {+ schemaTargetCount: 1,+ tableTargetCount: 1,+ })+ )+ })+test('shows a disable error and allows retrying from the open confirmation', async () => {mockSetupStatus({ setup_status: 'complete' })+ mockReplicatedTableQueries()let attempts = 0addAPIMock({method: 'post',diff --git a/apps/studio/components/interfaces/Integrations/Warehouse/Warehouse.utils.test.ts b/apps/studio/components/interfaces/Integrations/Warehouse/Warehouse.utils.test.tsindex 1a3d2cd9bc9..199ebf879bb 100644--- a/apps/studio/components/interfaces/Integrations/Warehouse/Warehouse.utils.test.ts+++ b/apps/studio/components/interfaces/Integrations/Warehouse/Warehouse.utils.test.ts@@ -1,6 +1,7 @@import { describe, expect, test } from 'vitest'import {+ buildSchemasWithTables,buildSelectionFromPublicationTables,buildWarehouseSetupTargets,getSchemaCheckedState,@@ -246,3 +247,56 @@ describe('WarehouseModePanel.utils:buildWarehouseSetupTargets', () => {])})})++describe('WarehouseModePanel.utils:buildSchemasWithTables', () => {+ test('returns an empty array when there are no schemas', () => {+ expect(buildSchemasWithTables([], [{ schema: 'public', name: 'orders' }])).toEqual([])+ })++ test('groups each schema with only its own tables', () => {+ const schemas = [{ name: 'public' }, { name: 'analytics' }]+ const tables = [+ { schema: 'public', name: 'orders' },+ { schema: 'analytics', name: 'events' },+ { schema: 'public', name: 'customers' },+ ]+ expect(buildSchemasWithTables(schemas, tables)).toEqual([+ { schema: 'analytics', tables: ['events'] },+ { schema: 'public', tables: ['orders', 'customers'] },+ ])+ })++ test('keeps schemas that have no tables', () => {+ expect(buildSchemasWithTables([{ name: 'public' }], [])).toEqual([+ { schema: 'public', tables: [] },+ ])+ })++ test('excludes schemas that cannot be replicated', () => {+ const schemas = [+ { name: 'public' },+ { name: 'vault' },+ { name: 'pg_catalog' },+ { name: WAREHOUSE_METADATA_SCHEMA },+ { name: 'auth' },+ ]+ const tables = [+ { schema: 'public', name: 'orders' },+ { schema: 'vault', name: 'secrets' },+ { schema: 'auth', name: 'users' },+ ]+ expect(buildSchemasWithTables(schemas, tables)).toEqual([+ { schema: 'auth', tables: ['users'] },+ { schema: 'public', tables: ['orders'] },+ ])+ })++ test('sorts schemas by name', () => {+ const schemas = [{ name: 'zebra' }, { name: 'public' }, { name: 'analytics' }]+ expect(buildSchemasWithTables(schemas, []).map(({ schema }) => schema)).toEqual([+ 'analytics',+ 'public',+ 'zebra',+ ])+ })+})diff --git a/apps/studio/components/interfaces/Integrations/Warehouse/Warehouse.utils.ts b/apps/studio/components/interfaces/Integrations/Warehouse/Warehouse.utils.tsindex 196e2e2098c..650620573d7 100644--- a/apps/studio/components/interfaces/Integrations/Warehouse/Warehouse.utils.ts+++ b/apps/studio/components/interfaces/Integrations/Warehouse/Warehouse.utils.ts@@ -55,6 +55,22 @@ export function isSelectableWarehouseSchema(schemaName: string): boolean {)}+/**+ * Groups the project's tables under the schemas Warehouse can replicate, sorted by schema name.+ */+export function buildSchemasWithTables(+ schemas: { name: string }[],+ tables: { schema: string; name: string }[]+): SchemaWithTables[] {+ return schemas+ .filter((schema) => isSelectableWarehouseSchema(schema.name))+ .map((schema) => ({+ schema: schema.name,+ tables: tables.filter((table) => table.schema === schema.name).map((table) => table.name),+ }))+ .sort((a, b) => a.schema.localeCompare(b.schema))+}+export function getSelectedTableCount(selection: SchemaTableSelection): number {return Object.values(selection).filter(Boolean).length}diff --git a/apps/studio/components/interfaces/Integrations/Warehouse/WarehouseDisableCard.tsx b/apps/studio/components/interfaces/Integrations/Warehouse/WarehouseDisableCard.tsxindex 037d9434304..50fab771006 100644--- a/apps/studio/components/interfaces/Integrations/Warehouse/WarehouseDisableCard.tsx+++ b/apps/studio/components/interfaces/Integrations/Warehouse/WarehouseDisableCard.tsx@@ -1,6 +1,6 @@import { useQueryClient } from '@tanstack/react-query'import { useParams } from 'common'-import { useState } from 'react'+import { useRef, useState } from 'react'import { toast } from 'sonner'import {AlertDialog,@@ -25,6 +25,8 @@ import {PageSectionTitle,} from 'ui-patterns/PageSection'+import { useWarehouseReplicatedTargets } from './useWarehouseReplicatedTargets'+import { type WarehouseSetupTarget } from './Warehouse.utils'import { warehouseKeys } from '@/data/warehouse/keys'import { useWarehouseSetupMutation } from '@/data/warehouse/warehouse-setup-mutation'import { useTrack } from '@/lib/telemetry/track'@@ -35,9 +37,22 @@ export const WarehouseDisableCard = () => {const track = useTrack()const [isConfirming, setIsConfirming] = useState(false)+ const replicatedTargets = useWarehouseReplicatedTargets({ projectRef })+ // Snapshotted when the user confirms: the mutation's own onSuccess awaits the post-disable+ // refetches, after which nothing reads as replicated.+ const targetsAtConfirm = useRef<WarehouseSetupTarget[] | undefined>(undefined)+const setupMutation = useWarehouseSetupMutation({onSuccess: async () => {- track('warehouse_disabled', {})+ // Tracked from the mutation's onSuccess, not mutateAsync's: the status refetch swaps this+ // card out of the panel, and mutate-level callbacks are skipped once it has unmounted.+ const targets = targetsAtConfirm.current+ track('warehouse_disabled', {+ ...(targets !== undefined && {+ schemaTargetCount: targets.filter((target) => target.type === 'schema').length,+ tableTargetCount: targets.filter((target) => target.type === 'table').length,+ }),+ })// Disabling also turns off catalog access server-side, which the setup mutation doesn't know// to invalidate on its own.await queryClient.invalidateQueries({ queryKey: warehouseKeys.catalog(projectRef) })@@ -47,6 +62,13 @@ export const WarehouseDisableCard = () => {onError: (error) => toast.error(`Failed to disable Warehouse: ${error.message}`),})+ const handleDisable = () => {+ if (!projectRef) return undefined+ targetsAtConfirm.current = replicatedTargets+ // Returned so the dialog stays open on failure and closes once the disable succeeds.+ return setupMutation.mutateAsync({ projectRef, body: { targets: [] } })+ }+return (<PageSection className="pt-5!"><PageSectionMeta>@@ -92,11 +114,7 @@ export const WarehouseDisableCard = () => {variant="danger"loading={setupMutation.isPending}disabled={!projectRef}- onClick={() =>- projectRef- ? setupMutation.mutateAsync({ projectRef, body: { targets: [] } })- : undefined- }+ onClick={handleDisable}>Disable Warehouse</AlertDialogAction>diff --git a/apps/studio/components/interfaces/Integrations/Warehouse/WarehouseSchemaTablePicker.tsx b/apps/studio/components/interfaces/Integrations/Warehouse/WarehouseSchemaTablePicker.tsxindex e35e6ff6353..9a81f3788ad 100644--- a/apps/studio/components/interfaces/Integrations/Warehouse/WarehouseSchemaTablePicker.tsx+++ b/apps/studio/components/interfaces/Integrations/Warehouse/WarehouseSchemaTablePicker.tsx@@ -14,12 +14,12 @@ import {import { GenericSkeletonLoader } from 'ui-patterns/ShimmeringLoader'import {+ buildSchemasWithTables,buildSelectionFromPublicationTables,buildWarehouseSetupTargets,getSchemaTableKey,getSelectedTableCount,hasSelectionChanged,- isSelectableWarehouseSchema,type SchemaTableSelection,type SchemaWithTables,type WarehouseSetupTarget,@@ -108,13 +108,7 @@ export const WarehouseSchemaTablePicker = ({const schemasWithTables: SchemaWithTables[] = useMemo(() => {if (!schemas || !tables) return []- return schemas- .filter((schema) => isSelectableWarehouseSchema(schema.name))- .map((schema) => ({- schema: schema.name,- tables: tables.filter((table) => table.schema === schema.name).map((table) => table.name),- }))- .sort((a, b) => a.schema.localeCompare(b.schema))+ return buildSchemasWithTables(schemas, tables)}, [schemas, tables])const tableKeys = schemasWithTables.flatMap(({ schema, tables }) =>diff --git a/apps/studio/components/interfaces/Integrations/Warehouse/useWarehouseReplicatedTargets.ts b/apps/studio/components/interfaces/Integrations/Warehouse/useWarehouseReplicatedTargets.tsnew file mode 100644index 00000000000..c8be900689a--- /dev/null+++ b/apps/studio/components/interfaces/Integrations/Warehouse/useWarehouseReplicatedTargets.ts@@ -0,0 +1,53 @@+import { useMemo } from 'react'++import {+ buildSchemasWithTables,+ buildSelectionFromPublicationTables,+ buildWarehouseSetupTargets,+ type WarehouseSetupTarget,+} from './Warehouse.utils'+import { useSchemasQuery } from '@/data/database/schemas-query'+import { useReplicationPublicationQuery } from '@/data/replication/publication-query'+import { useReplicationSourcesQuery } from '@/data/replication/sources-query'+import { useTablesQuery } from '@/data/tables/tables-query'+import { useSelectedProjectQuery } from '@/hooks/misc/useSelectedProject'+import { WAREHOUSE_PUBLICATION_NAME } from '@/lib/warehouse'++/**+ * What's currently replicated, expressed in the same target shape enabling Warehouse submits.+ * `undefined` until every input has resolved, so callers can tell "not known yet" apart from+ * "nothing replicated".+ */+export function useWarehouseReplicatedTargets({+ projectRef,+}: {+ projectRef?: string+}): WarehouseSetupTarget[] | undefined {+ const { data: project } = useSelectedProjectQuery()++ const { data: schemas } = useSchemasQuery({+ projectRef,+ connectionString: project?.connectionString,+ })+ const { data: tables } = useTablesQuery({+ projectRef,+ connectionString: project?.connectionString,+ })++ const { data: sourcesData } = useReplicationSourcesQuery({ projectRef })+ const sourceId = sourcesData?.sources.find((source) => source.name === projectRef)?.id++ const { data: publication } = useReplicationPublicationQuery({+ projectRef,+ sourceId,+ publicationName: WAREHOUSE_PUBLICATION_NAME,+ })++ return useMemo(() => {+ if (!schemas || !tables || !publication) return undefined+ return buildWarehouseSetupTargets(+ buildSelectionFromPublicationTables(publication.tables),+ buildSchemasWithTables(schemas, tables)+ )+ }, [schemas, tables, publication])+}diff --git a/packages/common/telemetry-constants.ts b/packages/common/telemetry-constants.tsindex a97bf198f03..9eb2fcf31db 100644--- a/packages/common/telemetry-constants.ts+++ b/packages/common/telemetry-constants.ts@@ -3938,7 +3938,12 @@ export interface WarehouseEnabledEvent {*/export interface WarehouseDisabledEvent {action: 'warehouse_disabled'- properties: {}+ properties: {+ /** Number of schemas that were replicated in full. Omitted when the replicated tables have not resolved. */+ schemaTargetCount?: number+ /** Number of tables that were replicated individually. Omitted when the replicated tables have not resolved. */+ tableTargetCount?: number+ }groups: TelemetryGroups}