Skip to content

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

fix(studio): stale table metadata cache invalidation after table edits (#47541)

Aaditya Bhusalb9d22fa23776
diff --git a/apps/studio/components/interfaces/TableGridEditor/SidePanelEditor/SidePanelEditor.tsx b/apps/studio/components/interfaces/TableGridEditor/SidePanelEditor/SidePanelEditor.tsx
index 6e5fa333474..e9b6de95b4d 100644
--- a/apps/studio/components/interfaces/TableGridEditor/SidePanelEditor/SidePanelEditor.tsx
+++ b/apps/studio/components/interfaces/TableGridEditor/SidePanelEditor/SidePanelEditor.tsx
@@ -44,17 +44,14 @@ import { useDatabasePublicationsQuery } from '@/data/database-publications/datab
import { useDatabasePublicationUpdateMutation } from '@/data/database-publications/database-publications-update-mutation'
import type { Constraint } from '@/data/database/constraints-query'
import type { ForeignKeyConstraint } from '@/data/database/foreign-key-constraints-query'
-import { databaseKeys } from '@/data/database/keys'
import { ENTITY_TYPE } from '@/data/entity-types/entity-type-constants'
-import { entityTypeKeys } from '@/data/entity-types/keys'
-import { lintKeys } from '@/data/lint/keys'
import { privilegeKeys } from '@/data/privileges/keys'
import { useTableApiAccessPrivilegesMutation } from '@/data/privileges/table-api-access-mutation'
-import { tableEditorKeys } from '@/data/table-editor/keys'
import { PG_META_SCOPED_INTROSPECTION_FLAG } from '@/data/table-editor/table-editor-query'
import { isTableLike, type Entity } from '@/data/table-editor/table-editor-types'
import { tableRowKeys } from '@/data/table-rows/keys'
import { tableKeys } from '@/data/tables/keys'
+import { invalidateTableMetadata } from '@/data/tables/table-metadata-invalidation'
import { RetrieveTableResult } from '@/data/tables/table-retrieve-query'
import { getTables } from '@/data/tables/tables-query'
import { useSelectedProjectQuery } from '@/hooks/misc/useSelectedProject'
@@ -426,34 +423,13 @@ export const SidePanelEditor = ({
reAddRenamedColumnSortAndFilter(selectedColumnToEdit.name, payload.name)
}
- await Promise.all([
- queryClient.invalidateQueries({
- queryKey: tableEditorKeys.tableEditor(project?.ref, selectedTable?.id),
- }),
- queryClient.invalidateQueries({
- queryKey: databaseKeys.foreignKeyConstraints(project?.ref, selectedTable?.schema),
- }),
- queryClient.invalidateQueries({
- queryKey: databaseKeys.tableDefinition(project?.ref, selectedTable?.id),
- }),
- queryClient.invalidateQueries({ queryKey: entityTypeKeys.list(project?.ref) }),
- queryClient.invalidateQueries({
- queryKey: tableKeys.list(project?.ref, selectedTable?.schema, { includeColumns }),
- }),
- queryClient.invalidateQueries({
- queryKey: tableKeys.infiniteListPrefix(project?.ref, selectedTable?.schema),
- }),
- // useTableQuery (FK selectors/formatters) has a 5min staleTime -- without this,
- // an edited column can serve stale data to any FK target cell pointing at this table.
- queryClient.invalidateQueries({
- queryKey: tableKeys.retrieve(project?.ref, selectedTable?.name, selectedTable?.schema),
- }),
- ])
-
- // We need to invalidate tableRowsAndCount after tableEditor
- // to ensure the query sent is correct
- await queryClient.invalidateQueries({
- queryKey: tableRowKeys.tableRowsAndCount(project?.ref, selectedTable?.id),
+ await invalidateTableMetadata(queryClient, {
+ projectRef: project?.ref,
+ schema: selectedTable?.schema,
+ tableId: selectedTable?.id,
+ tableName: selectedTable?.name,
+ includeRows: true,
+ includeLint: true,
})
setIsEdited(false)
@@ -708,14 +684,11 @@ export const SidePanelEditor = ({
{ name: 'create_table.cache_invalidation', op: 'cache.invalidate' },
async () => {
await Promise.all([
- queryClient.invalidateQueries({
- queryKey: tableKeys.list(project?.ref, table.schema, { includeColumns }),
- }),
- queryClient.invalidateQueries({
- queryKey: tableKeys.infiniteListPrefix(project?.ref, table.schema),
- }),
- queryClient.invalidateQueries({
- queryKey: entityTypeKeys.list(project?.ref),
+ invalidateTableMetadata(queryClient, {
+ projectRef: project?.ref,
+ schema: table.schema,
+ tableName: table.name,
+ includeLint: true,
}),
queryClient.invalidateQueries({
queryKey: databasePoliciesKeys.list(project?.ref),
@@ -723,7 +696,6 @@ export const SidePanelEditor = ({
queryClient.invalidateQueries({
queryKey: privilegeKeys.tablePrivilegesList(project?.ref),
}),
- queryClient.invalidateQueries({ queryKey: lintKeys.lint(project?.ref) }),
])
}
)
@@ -761,17 +733,16 @@ export const SidePanelEditor = ({
}
await Promise.all([
- queryClient.invalidateQueries({
- queryKey: tableKeys.list(project?.ref, table.schema, { includeColumns }),
- }),
- queryClient.invalidateQueries({
- queryKey: tableKeys.infiniteListPrefix(project?.ref, table.schema),
+ invalidateTableMetadata(queryClient, {
+ projectRef: project?.ref,
+ schema: table.schema,
+ tableId: table.id,
+ tableName: table.name,
+ includeLint: true,
}),
- queryClient.invalidateQueries({ queryKey: entityTypeKeys.list(project?.ref) }),
queryClient.invalidateQueries({
queryKey: privilegeKeys.tablePrivilegesList(project?.ref),
}),
- queryClient.invalidateQueries({ queryKey: lintKeys.lint(project?.ref) }),
])
toast.success(
diff --git a/apps/studio/components/interfaces/TableGridEditor/SidePanelEditor/SidePanelEditor.utils.tsx b/apps/studio/components/interfaces/TableGridEditor/SidePanelEditor/SidePanelEditor.utils.tsx
index 66b6b9a3243..a23576628b5 100644
--- a/apps/studio/components/interfaces/TableGridEditor/SidePanelEditor/SidePanelEditor.utils.tsx
+++ b/apps/studio/components/interfaces/TableGridEditor/SidePanelEditor/SidePanelEditor.utils.tsx
@@ -32,17 +32,13 @@ import { deleteDatabaseColumn } from '@/data/database-columns/database-column-de
import { updateDatabaseColumn } from '@/data/database-columns/database-column-update-mutation'
import type { Constraint } from '@/data/database/constraints-query'
import { ForeignKeyConstraint } from '@/data/database/foreign-key-constraints-query'
-import { databaseKeys } from '@/data/database/keys'
-import { entityTypeKeys } from '@/data/entity-types/keys'
-import { lintKeys } from '@/data/lint/keys'
import { prefetchEditorTablePage } from '@/data/prefetchers/project.$ref.editor.$id'
import { getQueryClient } from '@/data/query-client'
import { executeSql } from '@/data/sql/execute-sql-mutation'
-import { tableEditorKeys } from '@/data/table-editor/keys'
import { prefetchTableEditor } from '@/data/table-editor/table-editor-query'
-import { tableRowKeys } from '@/data/table-rows/keys'
import { executeWithRetry } from '@/data/table-rows/table-rows-query'
import { tableKeys } from '@/data/tables/keys'
+import { invalidateTableMetadata } from '@/data/tables/table-metadata-invalidation'
import { getTable, getTableQuery, RetrieveTableResult } from '@/data/tables/table-retrieve-query'
import {
UpdateTableBody,
@@ -859,36 +855,15 @@ export const updateTable = async ({
existingForeignKeyRelations,
})
- await Promise.all([
- queryClient.invalidateQueries({ queryKey: tableEditorKeys.tableEditor(projectRef, table.id) }),
- queryClient.invalidateQueries({
- queryKey: databaseKeys.foreignKeyConstraints(projectRef, table.schema),
- }),
- queryClient.invalidateQueries({ queryKey: databaseKeys.tableDefinition(projectRef, table.id) }),
- queryClient.invalidateQueries({ queryKey: entityTypeKeys.list(projectRef) }),
- queryClient.invalidateQueries({
- queryKey: tableKeys.list(projectRef, table.schema, { includeColumns: true }),
- }),
- queryClient.invalidateQueries({ queryKey: lintKeys.lint(projectRef) }),
- // useTableQuery (FK selectors/formatters) has a 5min staleTime, and the columns/FKs
- // above were only just applied after `updatedTable` was fetched -- refresh its identity,
- // plus the pre-rename one too, so nothing serves stale/deleted columns until then.
- queryClient.invalidateQueries({
- queryKey: tableKeys.retrieve(projectRef, updatedTable.name, updatedTable.schema),
- }),
- ...(updatedTable.name !== table.name || updatedTable.schema !== table.schema
- ? [
- queryClient.invalidateQueries({
- queryKey: tableKeys.retrieve(projectRef, table.name, table.schema),
- }),
- ]
- : []),
- ])
-
- // We need to invalidate tableRowsAndCount after tableEditor
- // to ensure the query sent is correct
- await queryClient.invalidateQueries({
- queryKey: tableRowKeys.tableRowsAndCount(projectRef, table.id),
+ await invalidateTableMetadata(queryClient, {
+ projectRef,
+ schema: table.schema,
+ tableId: table.id,
+ tableName: table.name,
+ newSchema: updatedTable.schema,
+ newTableName: updatedTable.name,
+ includeRows: true,
+ includeLint: true,
})
return {
diff --git a/apps/studio/data/database-columns/database-column-delete-mutation.ts b/apps/studio/data/database-columns/database-column-delete-mutation.ts
index 2ad154eb8ba..acb94a0b7fe 100644
--- a/apps/studio/data/database-columns/database-column-delete-mutation.ts
+++ b/apps/studio/data/database-columns/database-column-delete-mutation.ts
@@ -3,12 +3,8 @@ import { PGColumn } from '@supabase/pg-meta/src/pg-meta-columns'
import { useMutation, useQueryClient } from '@tanstack/react-query'
import { toast } from 'sonner'
-import { databaseKeys } from '@/data/database/keys'
-import { entityTypeKeys } from '@/data/entity-types/keys'
import { executeSql } from '@/data/sql/execute-sql-mutation'
-import { tableEditorKeys } from '@/data/table-editor/keys'
-import { tableRowKeys } from '@/data/table-rows/keys'
-import { tableKeys } from '@/data/tables/keys'
+import { invalidateTableMetadata } from '@/data/tables/table-metadata-invalidation'
import { viewKeys } from '@/data/views/keys'
import type { ResponseError, UseCustomMutationOptions } from '@/types'
@@ -54,34 +50,21 @@ export const useDatabaseColumnDeleteMutation = ({
const { projectRef, column } = variables
await Promise.all([
// refetch all entities in the sidebar because deleting a column may regenerate a view (and change its id)
- queryClient.invalidateQueries({ queryKey: entityTypeKeys.list(projectRef) }),
- queryClient.invalidateQueries({
- queryKey: databaseKeys.foreignKeyConstraints(projectRef, column.schema),
- }),
- queryClient.invalidateQueries({
- queryKey: tableEditorKeys.tableEditor(projectRef, column.table_id),
- }),
- queryClient.invalidateQueries({
- queryKey: databaseKeys.tableDefinition(projectRef, column.table_id),
+ invalidateTableMetadata(queryClient, {
+ projectRef,
+ schema: column.schema,
+ tableId: column.table_id,
+ tableName: column.table,
+ includeRows: true,
+ includeLint: true,
}),
// invalidate all views from this schema, not sure if this is needed since you can't actually delete a column
// which has a view dependent on it
queryClient.invalidateQueries({
queryKey: viewKeys.listBySchema(projectRef, [column.schema]),
}),
- // useTableQuery (FK selectors/formatters) has a 5min staleTime -- without this,
- // it can keep serving the deleted column to any FK target cell pointing at this table.
- queryClient.invalidateQueries({
- queryKey: tableKeys.retrieve(projectRef, column.table, column.schema),
- }),
])
- // We need to invalidate tableRowsAndCount after tableEditor
- // to ensure the query sent is correct
- await queryClient.invalidateQueries({
- queryKey: tableRowKeys.tableRowsAndCount(projectRef, column.table_id),
- })
-
await onSuccess?.(data, variables, context)
},
async onError(data, variables, context) {
diff --git a/apps/studio/data/database-queues/database-queues-create-mutation.ts b/apps/studio/data/database-queues/database-queues-create-mutation.ts
index da4673b0985..bbcf0f4b577 100644
--- a/apps/studio/data/database-queues/database-queues-create-mutation.ts
+++ b/apps/studio/data/database-queues/database-queues-create-mutation.ts
@@ -8,7 +8,7 @@ import {
pgmqQueueTable,
} from '@/components/interfaces/Integrations/Queues/Queues.utils'
import { executeSql } from '@/data/sql/execute-sql-mutation'
-import { tableKeys } from '@/data/tables/keys'
+import { invalidateTableMetadata } from '@/data/tables/table-metadata-invalidation'
import type { ResponseError, UseCustomMutationOptions } from '@/types'
export type DatabaseQueueCreateVariables = {
@@ -75,9 +75,15 @@ export const useDatabaseQueueCreateMutation = ({
return useMutation<DatabaseQueueCreateData, ResponseError, DatabaseQueueCreateVariables>({
mutationFn: (vars) => createDatabaseQueue(vars),
async onSuccess(data, variables, context) {
- const { projectRef } = variables
- await queryClient.invalidateQueries({ queryKey: databaseQueuesKeys.list(projectRef) })
- queryClient.invalidateQueries({ queryKey: tableKeys.list(projectRef, 'pgmq') })
+ const { projectRef, name } = variables
+ await Promise.all([
+ queryClient.invalidateQueries({ queryKey: databaseQueuesKeys.list(projectRef) }),
+ invalidateTableMetadata(queryClient, {
+ projectRef,
+ schema: 'pgmq',
+ tableName: pgmqQueueTable(name),
+ }),
+ ])
await onSuccess?.(data, variables, context)
},
async onError(data, variables, context) {
diff --git a/apps/studio/data/database/keys.ts b/apps/studio/data/database/keys.ts
index b020ef61788..82b825ce91b 100644
--- a/apps/studio/data/database/keys.ts
+++ b/apps/studio/data/database/keys.ts
@@ -9,6 +9,8 @@ export const databaseKeys = {
schema: string | undefined,
table: string | undefined
) => ['projects', projectRef, 'table-columns', schema, table] as const,
+ tableColumnsPrefix: (projectRef: string | undefined) =>
+ ['projects', projectRef, 'table-columns'] as const,
databaseFunctions: (projectRef: string | undefined, schema?: string) =>
['projects', projectRef, 'database-functions', schema].filter(Boolean),
entityDefinition: (projectRef: string | undefined, id?: number) =>
@@ -43,6 +45,10 @@ export const databaseKeys = {
},
tableConstraints: (projectRef: string | undefined, id?: number) =>
['projects', projectRef, 'table-constraints', id] as const,
+ foreignKeyConstraintsPrefix: (projectRef: string | undefined, schema?: string) =>
+ schema === undefined
+ ? (['projects', projectRef, 'foreign-key-constraints'] as const)
+ : (['projects', projectRef, 'foreign-key-constraints', schema] as const),
foreignKeyConstraints: (projectRef: string | undefined, schema?: string, options = {}) =>
['projects', projectRef, 'foreign-key-constraints', schema, options] as const,
databaseSize: (projectRef: string | undefined) =>
diff --git a/apps/studio/data/tables/table-create-mutation.ts b/apps/studio/data/tables/table-create-mutation.ts
index ffe9dab4693..605b80e1872 100644
--- a/apps/studio/data/tables/table-create-mutation.ts
+++ b/apps/studio/data/tables/table-create-mutation.ts
@@ -2,9 +2,9 @@ import pgMeta from '@supabase/pg-meta'
import { useMutation, useQueryClient } from '@tanstack/react-query'
import { toast } from 'sonner'
-import { tableKeys } from './keys'
import { privilegeKeys } from '@/data/privileges/keys'
import { executeSql } from '@/data/sql/execute-sql-mutation'
+import { invalidateTableMetadata } from '@/data/tables/table-metadata-invalidation'
import type { ResponseError, UseCustomMutationOptions } from '@/types'
export type CreateTableBody = {
@@ -51,11 +51,11 @@ export const useTableCreateMutation = ({
const { projectRef, payload } = variables
await Promise.all([
- queryClient.invalidateQueries({
- queryKey: tableKeys.list(projectRef, payload.schema, { includeColumns: true }),
- }),
- queryClient.invalidateQueries({
- queryKey: tableKeys.list(projectRef, payload.schema, { includeColumns: false }),
+ invalidateTableMetadata(queryClient, {
+ projectRef,
+ schema: payload.schema,
+ tableName: payload.name,
+ includeLint: true,
}),
queryClient.invalidateQueries({
queryKey: privilegeKeys.tablePrivilegesList(projectRef),
diff --git a/apps/studio/data/tables/table-delete-mutation.ts b/apps/studio/data/tables/table-delete-mutation.ts
index 5620886d02f..980a1d254fa 100644
--- a/apps/studio/data/tables/table-delete-mutation.ts
+++ b/apps/studio/data/tables/table-delete-mutation.ts
@@ -2,10 +2,8 @@ import pgMeta from '@supabase/pg-meta'
import { useMutation, useQueryClient } from '@tanstack/react-query'
import { toast } from 'sonner'
-import { tableKeys } from './keys'
-import { entityTypeKeys } from '@/data/entity-types/keys'
import { executeSql } from '@/data/sql/execute-sql-mutation'
-import { tableEditorKeys } from '@/data/table-editor/keys'
+import { invalidateTableMetadata } from '@/data/tables/table-metadata-invalidation'
import { viewKeys } from '@/data/views/keys'
import type { ResponseError, UseCustomMutationOptions } from '@/types'
@@ -53,14 +51,15 @@ export const useTableDeleteMutation = ({
return useMutation<TableDeleteData, ResponseError, TableDeleteVariables>({
mutationFn: (vars) => deleteTable(vars),
async onSuccess(data, variables, context) {
- const { id, projectRef, schema } = variables
+ const { id, projectRef, schema, name } = variables
await Promise.all([
- queryClient.invalidateQueries({ queryKey: tableEditorKeys.tableEditor(projectRef, id) }),
- queryClient.invalidateQueries({ queryKey: tableKeys.list(projectRef, schema) }),
- queryClient.invalidateQueries({
- queryKey: tableKeys.infiniteListPrefix(projectRef, schema),
+ invalidateTableMetadata(queryClient, {
+ projectRef,
+ schema,
+ tableId: id,
+ tableName: name,
+ includeLint: true,
}),
- queryClient.invalidateQueries({ queryKey: entityTypeKeys.list(projectRef) }),
// invalidate all views from this schema
queryClient.invalidateQueries({ queryKey: viewKeys.listBySchema(projectRef, [schema]) }),
])
diff --git a/apps/studio/data/tables/table-metadata-invalidation.ts b/apps/studio/data/tables/table-metadata-invalidation.ts
new file mode 100644
index 00000000000..7fd0d1434f1
--- /dev/null
+++ b/apps/studio/data/tables/table-metadata-invalidation.ts
@@ -0,0 +1,87 @@
+import type { QueryClient } from '@tanstack/react-query'
+
+import { databaseKeys } from '@/data/database/keys'
+import { entityTypeKeys } from '@/data/entity-types/keys'
+import { lintKeys } from '@/data/lint/keys'
+import { tableEditorKeys } from '@/data/table-editor/keys'
+import { tableRowKeys } from '@/data/table-rows/keys'
+import { tableKeys } from '@/data/tables/keys'
+
+type InvalidateTableMetadataVariables = {
+ projectRef: string | undefined
+ schema: string | undefined
+ tableId?: number
+ tableName?: string
+ newSchema?: string
+ newTableName?: string
+ includeRows?: boolean
+ includeLint?: boolean
+}
+
+export const invalidateTableMetadata = async (
+ queryClient: QueryClient,
+ {
+ projectRef,
+ schema,
+ tableId,
+ tableName,
+ newSchema,
+ newTableName,
+ includeRows = false,
+ includeLint = false,
+ }: InvalidateTableMetadataVariables
+) => {
+ const schemas = Array.from(new Set([schema, newSchema].filter(Boolean))) as string[]
+ const tables = [
+ { schema, name: tableName },
+ { schema: newSchema ?? schema, name: newTableName ?? tableName },
+ ].filter((table): table is { schema: string; name: string } => {
+ return table.schema !== undefined && table.name !== undefined
+ })
+ const uniqueTables = tables.filter((table, index) => {
+ return (
+ tables.findIndex((item) => item.schema === table.schema && item.name === table.name) === index
+ )
+ })
+
+ await Promise.all([
+ queryClient.invalidateQueries({ queryKey: tableKeys.names(projectRef) }),
+ queryClient.invalidateQueries({ queryKey: entityTypeKeys.list(projectRef) }),
+ queryClient.invalidateQueries({ queryKey: databaseKeys.tableColumnsPrefix(projectRef) }),
+ ...(includeLint
+ ? [queryClient.invalidateQueries({ queryKey: lintKeys.lint(projectRef) })]
+ : []),
+ ...(tableId === undefined
+ ? []
+ : [
+ queryClient.invalidateQueries({
+ queryKey: tableEditorKeys.tableEditor(projectRef, tableId),
+ }),
+ queryClient.invalidateQueries({
+ queryKey: databaseKeys.tableDefinition(projectRef, tableId),
+ }),
+ queryClient.invalidateQueries({
+ queryKey: databaseKeys.tableConstraints(projectRef, tableId),
+ }),
+ ]),
+ ...schemas.flatMap((currentSchema) => [
+ queryClient.invalidateQueries({ queryKey: tableKeys.list(projectRef, currentSchema) }),
+ queryClient.invalidateQueries({
+ queryKey: tableKeys.infiniteListPrefix(projectRef, currentSchema),
+ }),
+ queryClient.invalidateQueries({
+ queryKey: databaseKeys.foreignKeyConstraintsPrefix(projectRef, currentSchema),
+ }),
+ ]),
+ ...uniqueTables.flatMap(({ schema, name }) => [
+ queryClient.invalidateQueries({ queryKey: tableKeys.retrieve(projectRef, name, schema) }),
+ ]),
+ ])
+
+ // Invalidate tableRowsAndCount after tableEditor because row queries use it to build their SQL.
+ if (includeRows && tableId !== undefined) {
+ await queryClient.invalidateQueries({
+ queryKey: tableRowKeys.tableRowsAndCount(projectRef, tableId),
+ })
+ }
+}
diff --git a/apps/studio/data/tables/table-update-mutation.ts b/apps/studio/data/tables/table-update-mutation.ts
index 074f8a2f79a..ea24910376f 100644
--- a/apps/studio/data/tables/table-update-mutation.ts
+++ b/apps/studio/data/tables/table-update-mutation.ts
@@ -2,11 +2,9 @@ import pgMeta from '@supabase/pg-meta'
import { useMutation, useQueryClient } from '@tanstack/react-query'
import { toast } from 'sonner'
-import { tableKeys } from './keys'
import { CreateTableBody } from './table-create-mutation'
-import { lintKeys } from '@/data/lint/keys'
import { executeSql } from '@/data/sql/execute-sql-mutation'
-import { tableEditorKeys } from '@/data/table-editor/keys'
+import { invalidateTableMetadata } from '@/data/tables/table-metadata-invalidation'
import type { ResponseError, UseCustomMutationOptions } from '@/types'
export type UpdateTableBody = Partial<CreateTableBody> & {
@@ -61,12 +59,17 @@ export const useTableUpdateMutation = ({
return useMutation<TableUpdateData, ResponseError, TableUpdateVariables>({
mutationFn: (vars) => updateTable(vars),
async onSuccess(data, variables, context) {
- const { projectRef, schema, id } = variables
- await Promise.all([
- queryClient.invalidateQueries({ queryKey: tableEditorKeys.tableEditor(projectRef, id) }),
- queryClient.invalidateQueries({ queryKey: tableKeys.list(projectRef, schema) }),
- queryClient.invalidateQueries({ queryKey: lintKeys.lint(projectRef) }),
- ])
+ const { projectRef, schema, id, name, payload } = variables
+ await invalidateTableMetadata(queryClient, {
+ projectRef,
+ schema,
+ tableId: id,
+ tableName: name,
+ newSchema: payload.schema,
+ newTableName: payload.name,
+ includeRows: true,
+ includeLint: true,
+ })
await onSuccess?.(data, variables, context)
},
async onError(data, variables, context) {
diff --git a/apps/studio/tests/data/tables/table-metadata-invalidation.test.ts b/apps/studio/tests/data/tables/table-metadata-invalidation.test.ts
new file mode 100644
index 00000000000..05914e2f676
--- /dev/null
+++ b/apps/studio/tests/data/tables/table-metadata-invalidation.test.ts
@@ -0,0 +1,105 @@
+import type { QueryClient } from '@tanstack/react-query'
+import { describe, expect, test, vi } from 'vitest'
+
+import { databaseKeys } from '@/data/database/keys'
+import { entityTypeKeys } from '@/data/entity-types/keys'
+import { lintKeys } from '@/data/lint/keys'
+import { tableEditorKeys } from '@/data/table-editor/keys'
+import { tableRowKeys } from '@/data/table-rows/keys'
+import { tableKeys } from '@/data/tables/keys'
+import { invalidateTableMetadata } from '@/data/tables/table-metadata-invalidation'
+
+const createQueryClient = () => {
+ return {
+ invalidateQueries: vi.fn().mockResolvedValue(undefined),
+ } as unknown as QueryClient
+}
+
+const getInvalidatedQueryKeys = (queryClient: QueryClient) => {
+ return vi.mocked(queryClient.invalidateQueries).mock.calls.map(([filters]) => filters?.queryKey)
+}
+
+describe('invalidateTableMetadata', () => {
+ test('invalidates table metadata query variants for the current table', async () => {
+ const queryClient = createQueryClient()
+
+ await invalidateTableMetadata(queryClient, {
+ projectRef: 'project-ref',
+ schema: 'public',
+ tableId: 1,
+ tableName: 'todos',
+ })
+
+ const queryKeys = getInvalidatedQueryKeys(queryClient)
+
+ expect(queryKeys).toEqual(
+ expect.arrayContaining([
+ tableKeys.names('project-ref'),
+ entityTypeKeys.list('project-ref'),
+ databaseKeys.tableColumnsPrefix('project-ref'),
+ tableEditorKeys.tableEditor('project-ref', 1),
+ databaseKeys.tableDefinition('project-ref', 1),
+ databaseKeys.tableConstraints('project-ref', 1),
+ tableKeys.list('project-ref', 'public'),
+ tableKeys.infiniteListPrefix('project-ref', 'public'),
+ databaseKeys.foreignKeyConstraintsPrefix('project-ref', 'public'),
+ tableKeys.retrieve('project-ref', 'todos', 'public'),
+ ])
+ )
+ expect(queryKeys).not.toContainEqual(lintKeys.lint('project-ref'))
+ expect(queryKeys).not.toContainEqual(tableRowKeys.tableRowsAndCount('project-ref', 1))
+ })
+
+ test('invalidates old and new schema and table keys when a table is moved or renamed', async () => {
+ const queryClient = createQueryClient()
+
+ await invalidateTableMetadata(queryClient, {
+ projectRef: 'project-ref',
+ schema: 'public',
+ tableId: 1,
+ tableName: 'todos',
+ newSchema: 'private',
+ newTableName: 'tasks',
+ includeRows: true,
+ includeLint: true,
+ })
+
+ const queryKeys = getInvalidatedQueryKeys(queryClient)
+
+ expect(queryKeys).toEqual(
+ expect.arrayContaining([
+ tableKeys.list('project-ref', 'public'),
+ tableKeys.infiniteListPrefix('project-ref', 'public'),
+ databaseKeys.foreignKeyConstraintsPrefix('project-ref', 'public'),
+ tableKeys.list('project-ref', 'private'),
+ tableKeys.infiniteListPrefix('project-ref', 'private'),
+ databaseKeys.foreignKeyConstraintsPrefix('project-ref', 'private'),
+ tableKeys.retrieve('project-ref', 'todos', 'public'),
+ tableKeys.retrieve('project-ref', 'tasks', 'private'),
+ lintKeys.lint('project-ref'),
+ tableRowKeys.tableRowsAndCount('project-ref', 1),
+ ])
+ )
+ expect(queryKeys[queryKeys.length - 1]).toEqual(
+ tableRowKeys.tableRowsAndCount('project-ref', 1)
+ )
+ })
+
+ test('does not invalidate id-based keys when a table id is unavailable', async () => {
+ const queryClient = createQueryClient()
+
+ await invalidateTableMetadata(queryClient, {
+ projectRef: 'project-ref',
+ schema: 'public',
+ tableName: 'todos',
+ includeRows: true,
+ })
+
+ const queryKeys = getInvalidatedQueryKeys(queryClient)
+
+ expect(queryKeys).not.toContainEqual(tableEditorKeys.tableEditor('project-ref', 1))
+ expect(queryKeys).not.toContainEqual(databaseKeys.tableDefinition('project-ref', 1))
+ expect(queryKeys).not.toContainEqual(databaseKeys.tableConstraints('project-ref', 1))
+ expect(queryKeys).not.toContainEqual(tableRowKeys.tableRowsAndCount('project-ref', 1))
+ })
+})