improvement(tables): warn about referenced tables instead of blocking deletes

Author: j15z

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/cells/cell-render.tsx

@@ -151,15 +151,14 @@ export function resolveCellRender({
   // (keyed on kind alone) no longer has. Renders as plain text — a currency
   // cell is a number cell with a symbol, so it stays left-aligned like one.
   if (column.type === 'currency') {
-    return { kind: 'text', text: columnTypeOf(column).formatForDisplay(value, column) }
+    return { kind: 'text', text: typeDefinition.formatForDisplay(value, column) }
   }
   if (column.type === 'json') return { kind: 'json', text: JSON.stringify(value) }
-  const definition = columnTypeOf(column)
-  if (definition.editor === 'date') {
+  if (typeDefinition.editor === 'date') {
     if (timezoneStatus !== undefined && timezoneStatus !== 'ready') {
       return { kind: 'date', text: stringifyValue(value), raw: true }
     }
-    return { kind: 'date', text: definition.formatForInput(value, column) }
+    return { kind: 'date', text: typeDefinition.formatForInput(value, column) }
   }
   if (column.type === 'string') {
     const text = stringifyValue(value)

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/reference-row-preview.test.tsx

@@ -50,7 +50,7 @@ import {
 let container: HTMLDivElement
 let root: Root
 let previewTable: ReturnType<typeof createTableDefinition> | undefined
-let previewStatus: 'loading' | 'error' | 'ready'
+let previewStatus: 'loading' | 'error' | 'missing' | 'ready'
 const REFERENCE_TABLE_NAMES = new Map([
   ['table-accounts', 'Accounts'],
   ['table-owners', 'Owners'],
@@ -403,6 +403,19 @@ describe('ReferenceRowPreview', () => {
     expect(container.querySelector('[data-testid="reference-preview-loader"]')).toBeNull()
   })
 
+  it('shows a not-found state when the referenced table no longer exists', () => {
+    previewStatus = 'missing'
+    previewTable = undefined
+    previewQuery.data = undefined
+
+    renderPreview()
+
+    expect(container.textContent).toContain('Table not found')
+    expect(container.textContent).not.toContain("Couldn't load reference")
+    expect(container.querySelector('[role="table"]')).toBeNull()
+    expect(container.querySelector('a[aria-label="Go to table"]')).toBeNull()
+  })
+
   it('shows an empty-schema state when the referenced table has no columns', () => {
     if (!previewTable) throw new Error('Expected the referenced table fixture')
     previewTable.schema.columns = []

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/reference-row-preview.tsx

@@ -33,7 +33,7 @@ interface ReferenceRowPreviewBaseProps {
 
 type ReferenceRowPreviewProps = ReferenceRowPreviewBaseProps &
   (
-    | { status: 'loading' | 'error' }
+    | { status: 'loading' | 'error' | 'missing' }
     | {
         status: 'ready'
         table: TableDefinition
@@ -207,9 +207,9 @@ export const ReferenceRowPreview = memo(function ReferenceRowPreview(
               <div className='flex h-full items-center justify-center'>
                 <Loader animate className='size-[14px] text-[var(--text-muted)]' />
               </div>
-            ) : status === 'error' ? (
+            ) : status === 'error' || status === 'missing' ? (
               <div className='flex h-full items-center justify-center text-[var(--text-muted)] text-small'>
-                Couldn&apos;t load reference
+                {status === 'missing' ? 'Table not found' : "Couldn't load reference"}
               </div>
             ) : (
               <>

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/table-grid.tsx

@@ -970,11 +970,13 @@ export function TableGrid({
     ? ({ status: 'error' } as const)
     : referencePreviewQuery.isFetching || !referencePreviewQuery.data
       ? ({ status: 'loading' } as const)
-      : ({
-          status: 'ready',
-          table: referencePreviewQuery.data.table,
-          row: referencePreviewQuery.data.row,
-        } as const)
+      : referencePreviewQuery.data.table === null
+        ? ({ status: 'missing' } as const)
+        : ({
+            status: 'ready',
+            table: referencePreviewQuery.data.table,
+            row: referencePreviewQuery.data.row,
+          } as const)
   const expandedSourceRowId = activeReferenceTarget?.sourceRowId ?? null
 
   const rowVirtualizer = useVirtualizer({

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/table.tsx

@@ -52,6 +52,7 @@ import {
 } from '@/app/workspace/[workspaceId]/tables/[tableId]/view-state'
 import { ImportCsvDialog } from '@/app/workspace/[workspaceId]/tables/components/import-csv-dialog'
 import { ImportProgressMenu } from '@/app/workspace/[workspaceId]/tables/components/import-progress-menu'
+import { useReferencedByWarning } from '@/app/workspace/[workspaceId]/tables/hooks/use-referenced-by-warning'
 import { useWorkspaceTablesRoom } from '@/app/workspace/[workspaceId]/tables/hooks/use-workspace-tables-room'
 import { useLogByExecutionId } from '@/hooks/queries/logs'
 import {
@@ -1462,6 +1463,8 @@ export function Table({
         : 0
 
   const deleteTableMutation = useDeleteTable(workspaceId)
+  const pendingDeleteTableIds = showDeleteTableConfirm ? [tableId] : []
+  const referencedByWarning = useReferencedByWarning(workspaceId, pendingDeleteTableIds)
   const deleteRowsAsyncMutation = useDeleteTableRowsAsync({ workspaceId, tableId })
   const exportTableAsync = useExportTable({ workspaceId, tableId })
   const handleDeleteTable = async () => {
@@ -1892,6 +1895,7 @@ export function Table({
             { text: tableData?.name ?? 'this table', bold: true },
             '? ',
             { text: `All ${tableData?.rowCount ?? 0} rows will be removed.`, error: true },
+            ...referencedByWarning,
             ' You can restore it from Recently Deleted in Settings.',
           ]}
           confirm={{

apps/sim/app/workspace/[workspaceId]/tables/hooks/use-referenced-by-warning.test.ts

@@ -0,0 +1,38 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it, vi } from 'vitest'
+
+vi.mock('@/hooks/queries/tables', () => ({
+  useTablesList: vi.fn(),
+}))
+
+vi.mock('@/app/workspace/[workspaceId]/providers/workspace-host-provider', () => ({
+  useOptionalWorkspaceHostContext: vi.fn(),
+}))
+
+import { referencedByWarningText } from '@/app/workspace/[workspaceId]/tables/hooks/use-referenced-by-warning'
+
+describe('referencedByWarningText', () => {
+  it('adds nothing when no surviving table references the deletion', () => {
+    expect(referencedByWarningText([])).toEqual([])
+  })
+
+  it('names a single referencing table', () => {
+    expect(referencedByWarningText(['Orders'])).toEqual([
+      ' Referenced by Orders. Those references will show as not found.',
+    ])
+  })
+
+  it('joins referencing tables as a readable list', () => {
+    expect(referencedByWarningText(['Invoices', 'Orders'])).toEqual([
+      ' Referenced by Invoices and Orders. Those references will show as not found.',
+    ])
+  })
+
+  it('lists the first three names and summarizes the rest', () => {
+    expect(referencedByWarningText(['Accounts', 'Invoices', 'Leads', 'Orders', 'Quotes'])).toEqual([
+      ' Referenced by Accounts, Invoices, Leads, and 2 more. Those references will show as not found.',
+    ])
+  })
+})

apps/sim/app/workspace/[workspaceId]/tables/hooks/use-referenced-by-warning.ts

@@ -0,0 +1,45 @@
+'use client'
+
+import type { ChipConfirmTextSegment } from '@sim/emcn'
+import { findReferencingTables } from '@/lib/table/reference-columns/referrers'
+import { useOptionalWorkspaceHostContext } from '@/app/workspace/[workspaceId]/providers/workspace-host-provider'
+import { useTablesList } from '@/hooks/queries/tables'
+
+const MAX_LISTED_REFERRERS = 3
+const NAME_LIST_FORMAT = new Intl.ListFormat('en', { style: 'long', type: 'conjunction' })
+const NO_SEGMENTS: readonly ChipConfirmTextSegment[] = []
+
+/**
+ * Confirmation copy naming the surviving tables that reference a pending deletion. Deletion is
+ * not blocked; the copy warns that those references will stop resolving.
+ */
+export function referencedByWarningText(
+  referrerNames: readonly string[]
+): readonly ChipConfirmTextSegment[] {
+  if (referrerNames.length === 0) return NO_SEGMENTS
+
+  const listed = referrerNames.slice(0, MAX_LISTED_REFERRERS)
+  const remaining = referrerNames.length - listed.length
+  const names = remaining > 0 ? [...listed, `${remaining} more`] : listed
+
+  return [
+    ` Referenced by ${NAME_LIST_FORMAT.format(names)}. Those references will show as not found.`,
+  ]
+}
+
+/**
+ * Warning copy for the tables a delete confirmation would archive. Empty while Reference
+ * columns are disabled, nothing is pending, or no surviving table references the deletion.
+ */
+export function useReferencedByWarning(
+  workspaceId: string,
+  deletedTableIds: readonly string[]
+): readonly ChipConfirmTextSegment[] {
+  const hostContext = useOptionalWorkspaceHostContext()
+  const enabled = (hostContext?.features?.referenceColumns ?? false) && deletedTableIds.length > 0
+  const { data: tables } = useTablesList(workspaceId, 'active', { enabled })
+
+  if (!enabled || !tables) return NO_SEGMENTS
+  const referrers = findReferencingTables(tables, new Set(deletedTableIds))
+  return referencedByWarningText(referrers.map((table) => table.name))
+}

apps/sim/app/workspace/[workspaceId]/tables/hooks/use-workspace-tables-room.ts

@@ -7,13 +7,9 @@ import { folderKeys } from '@/hooks/queries/utils/folder-keys'
 import { tableKeys } from '@/hooks/queries/utils/table-keys'
 
 /**
- * Keeps the tables browser live: joins the workspace-tables room so a `workspace-tables-changed`
- * broadcast (fanned out by the table + table-folder mutation services) invalidates table lists,
- * names, reference previews, AND table folders so every viewer refetches without waiting for
- * staleness. A created/renamed/
- * moved/deleted/restored table changes the list result (including folder placement); a folder
- * create/rename/delete/restore changes the folder tree — the page renders both, so both are
- * invalidated. Thin binding over {@link useWorkspaceInvalidationRoom}.
+ * Table and table-folder mutations share this room because the browser renders both the table
+ * list and folder tree. Broadcast invalidation keeps every viewer current without waiting for
+ * query staleness.
  */
 export function useWorkspaceTablesRoom(workspaceId: string): void {
   const queryClient = useQueryClient()

apps/sim/app/workspace/[workspaceId]/tables/tables.tsx

@@ -71,6 +71,7 @@ import {
   TablesListContextMenu,
 } from '@/app/workspace/[workspaceId]/tables/components'
 import { TableContextMenu } from '@/app/workspace/[workspaceId]/tables/components/table-context-menu'
+import { useReferencedByWarning } from '@/app/workspace/[workspaceId]/tables/hooks/use-referenced-by-warning'
 import { useWorkspaceTablesRoom } from '@/app/workspace/[workspaceId]/tables/hooks/use-workspace-tables-room'
 import TablesLoading from '@/app/workspace/[workspaceId]/tables/loading'
 import {
@@ -127,6 +128,21 @@ const ROOT_LABEL = FOLDERED_RESOURCE_HEADERS.table.rootLabel
 
 const EMPTY_TABLES: TableDefinition[] = []
 
+/** Tables inside `folderIds` or any folder nested beneath them. */
+function tableIdsInFolderSubtrees(
+  tables: readonly TableDefinition[],
+  folderIds: readonly string[],
+  descendantFolderIds: ReadonlyMap<string, ReadonlySet<string>>
+): string[] {
+  if (folderIds.length === 0) return []
+  const coveredFolderIds = new Set(
+    folderIds.flatMap((folderId) => [folderId, ...(descendantFolderIds.get(folderId) ?? [])])
+  )
+  return tables.flatMap((table) =>
+    table.folderId && coveredFolderIds.has(table.folderId) ? [table.id] : []
+  )
+}
+
 /** A list row (and the right-clicked row), resolved to the entity it refers to. */
 type TableResourceItem =
   | { kind: 'table'; table: TableDefinition }
@@ -595,6 +611,23 @@ export function Tables() {
     return selectionLabel(count, firstName)
   }, [selectedTableIds, selectedFolderIds, tables, folderById])
 
+  const deleteFolderIds =
+    isDeleteFolderDialogOpen && activeFolder
+      ? [activeFolder.id]
+      : isBulkDeleteDialogOpen
+        ? selectedFolderIds
+        : []
+  /** Tables the open delete confirmation would archive, including every table inside a folder. */
+  const pendingDeleteTableIds = isDeleteDialogOpen
+    ? activeTable
+      ? [activeTable.id]
+      : []
+    : [
+        ...(isBulkDeleteDialogOpen ? selectedTableIds : []),
+        ...tableIdsInFolderSubtrees(tables, deleteFolderIds, descendantFolderIds),
+      ]
+  const referencedByWarning = useReferencedByWarning(workspaceId, pendingDeleteTableIds)
+
   const currentFolderActions: DropdownOption[] | undefined = useMemo(() => {
     if (!currentFolderId) return undefined
     const folder = folderById.get(currentFolderId)
@@ -1480,6 +1513,7 @@ export function Tables() {
           { text: activeTable?.name ?? 'this table', bold: true },
           '? ',
           { text: `All ${activeTable?.rowCount ?? 0} rows will be removed.`, error: true },
+          ...referencedByWarning,
           ' You can restore it from Recently Deleted in Settings.',
         ]}
         confirm={{
@@ -1503,6 +1537,7 @@ export function Tables() {
           { text: activeFolder?.name ?? 'this folder', bold: true },
           '? ',
           { text: 'Every table and subfolder inside it will be deleted too.', error: true },
+          ...referencedByWarning,
           ' You can restore those tables from Recently Deleted in Settings.',
         ]}
         confirm={{
@@ -1529,6 +1564,7 @@ export function Tables() {
                 : 'All of their rows will be removed.',
             error: true,
           },
+          ...referencedByWarning,
           ' You can restore those tables from Recently Deleted in Settings.',
         ]}
         confirm={{

apps/sim/ee/workspace-forking/lib/copy/copy-resources.test.ts

@@ -1546,7 +1546,7 @@ describe('copyForkResourceContainers table views', () => {
     expect(insert).not.toHaveBeenCalled()
   })
 
-  it('rejects an unavailable referenced-table dependency before inserting copies', async () => {
+  it('copies a table whose referenced table was deleted and keeps the original target', async () => {
     const now = new Date('2026-08-19T00:00:00.000Z')
     const selectedDefinition = {
       id: 'table-orders',
@@ -1577,37 +1577,53 @@ describe('copyForkResourceContainers table views', () => {
       createdAt: now,
       updatedAt: now,
     }
-    const insert = vi.fn()
+    const inserted = new Map<unknown, Array<Record<string, unknown>>>()
     let definitionRead = 0
     const tx = {
       select: () => ({
-        from: () => ({
-          where: () => Promise.resolve(definitionRead++ === 0 ? [selectedDefinition] : []),
+        from: (table: unknown) => ({
+          where: () => {
+            if (table !== userTableDefinitions) return Promise.resolve([])
+            return Promise.resolve(definitionRead++ === 0 ? [selectedDefinition] : [])
+          },
         }),
       }),
-      insert,
+      insert: (table: unknown) => ({
+        values: (values: Array<Record<string, unknown>>) => {
+          inserted.set(table, values)
+          return Promise.resolve()
+        },
+      }),
     }
 
-    await expect(
-      copyForkResourceContainers({
-        tx: tx as unknown as DbOrTx,
-        sourceWorkspaceId: 'src-ws',
-        childWorkspaceId: 'child-ws',
-        userId: 'user-1',
-        now,
-        selection: {
-          customTools: [],
-          skills: [],
-          mcpServers: [],
-          workflowMcpServers: [],
-          tables: ['table-orders'],
-          knowledgeBases: [],
-        },
-        workflowIdMap: new Map(),
-        documentMappingContext: { edgeChildWorkspaceId: 'child-ws', sourceIsParent: true },
-      })
-    ).rejects.toThrow('Referenced table table-accounts is unavailable for copy')
-    expect(insert).not.toHaveBeenCalled()
+    const result = await copyForkResourceContainers({
+      tx: tx as unknown as DbOrTx,
+      sourceWorkspaceId: 'src-ws',
+      childWorkspaceId: 'child-ws',
+      userId: 'user-1',
+      now,
+      selection: {
+        customTools: [],
+        skills: [],
+        mcpServers: [],
+        workflowMcpServers: [],
+        tables: ['table-orders'],
+        knowledgeBases: [],
+      },
+      workflowIdMap: new Map(),
+      documentMappingContext: { edgeChildWorkspaceId: 'child-ws', sourceIsParent: true },
+    })
+
+    const tableMap = result.idMap.get('table')
+    expect(tableMap?.size).toBe(1)
+    expect(result.contentPlan.tables).toEqual([
+      { sourceId: 'table-orders', childId: tableMap?.get('table-orders') },
+    ])
+    const copiedDefinitions = inserted.get(userTableDefinitions)
+    expect(copiedDefinitions).toHaveLength(1)
+    expect(copiedDefinitions?.[0]?.schema).toMatchObject({
+      columns: [{ referenceTableId: 'table-accounts' }],
+    })
   })
 
   it('bounds the expanded referenced-table dependency set', async () => {