fix(tables): validate reference targets

Author: j15z

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/headers/workflow-group-meta-cell.test.tsx

@@ -46,7 +46,6 @@ vi.mock('@/lib/table/column-types', () => ({
   columnTypeOf: (column: ColumnDefinition) => ({
     icon: () => null,
     label: column.type === 'reference' ? 'Reference' : 'Text',
-    hasConfiguration: column.type === 'reference',
   }),
 }))
 

apps/sim/lib/table/__tests__/column-type-registry.test.ts

@@ -48,8 +48,6 @@ describe('registry shape', () => {
 
     expect(definition.label).toBe('Reference')
     expect(definition.icon).toBe(TableIcon)
-    expect(definition.requiresConfigurationOnCreate).toBe(true)
-    expect(definition.hasConfiguration).toBe(true)
     expect(definition.ownedMetadata).toEqual(['referenceTableId'])
     expect(definition.jsonbCast).toBeNull()
   })

apps/sim/lib/table/column-types/reference.ts

@@ -10,8 +10,6 @@ export const referenceColumnType: ColumnTypeDefinition = {
   jsonbCast: null,
   storesOpaqueIds: false,
   supportsUnique: true,
-  requiresConfigurationOnCreate: true,
-  hasConfiguration: true,
   sampleValue: 'row_123',
   ownedMetadata: ['referenceTableId'],
   workflowInputType: 'string',

apps/sim/lib/table/column-types/registry.server.test.ts

@@ -0,0 +1,103 @@
+/**
+ * @vitest-environment node
+ */
+
+import { hasMockCondition, schemaMock } from '@sim/testing'
+import { describe, expect, it, vi } from 'vitest'
+import { assertColumnReferencesInWorkspace } from '@/lib/table/column-types/registry.server'
+import type { DbTransaction } from '@/lib/table/planner'
+
+function transactionWithTargets(targetIds: string[]) {
+  const where = vi.fn().mockResolvedValue(targetIds.map((id) => ({ id })))
+  const from = vi.fn(() => ({ where }))
+  const select = vi.fn(() => ({ from }))
+  return {
+    trx: { select } as unknown as DbTransaction,
+    select,
+    where,
+  }
+}
+
+describe('assertColumnReferencesInWorkspace', () => {
+  it('skips the database when no column type references a table', async () => {
+    const { trx, select } = transactionWithTargets([])
+
+    await assertColumnReferencesInWorkspace(trx, 'ws_1', [
+      { id: 'col_name', name: 'Name', type: 'string' },
+    ])
+
+    expect(select).not.toHaveBeenCalled()
+  })
+
+  it('accepts active Reference targets returned for the workspace', async () => {
+    const { trx, select, where } = transactionWithTargets(['tbl_accounts', 'tbl_companies'])
+
+    await assertColumnReferencesInWorkspace(trx, 'ws_1', [
+      {
+        id: 'col_account',
+        name: 'Account',
+        type: 'reference',
+        referenceTableId: 'tbl_accounts',
+      },
+      {
+        id: 'col_company',
+        name: 'Company',
+        type: 'reference',
+        referenceTableId: 'tbl_companies',
+      },
+      {
+        id: 'col_duplicate',
+        name: 'Duplicate',
+        type: 'reference',
+        referenceTableId: 'tbl_accounts',
+      },
+    ])
+
+    expect(select).toHaveBeenCalledOnce()
+    const condition = where.mock.calls[0][0]
+    expect(hasMockCondition(condition, (node) => node.type === 'eq' && node.right === 'ws_1')).toBe(
+      true
+    )
+    expect(
+      hasMockCondition(
+        condition,
+        (node) =>
+          node.type === 'inArray' &&
+          node.column === schemaMock.userTableDefinitions.id &&
+          Array.isArray(node.values) &&
+          node.values.length === 2
+      )
+    ).toBe(true)
+    expect(
+      hasMockCondition(
+        condition,
+        (node) =>
+          node.type === 'isNull' && node.column === schemaMock.userTableDefinitions.archivedAt
+      )
+    ).toBe(true)
+  })
+
+  it('conceals missing, archived, and cross-workspace targets as not found', async () => {
+    const { trx } = transactionWithTargets(['tbl_accounts'])
+
+    await expect(
+      assertColumnReferencesInWorkspace(trx, 'ws_1', [
+        {
+          id: 'col_account',
+          name: 'Account',
+          type: 'reference',
+          referenceTableId: 'tbl_accounts',
+        },
+        {
+          id: 'col_company',
+          name: 'Company',
+          type: 'reference',
+          referenceTableId: 'tbl_unavailable',
+        },
+      ])
+    ).rejects.toMatchObject({
+      code: 'not_found',
+      message: 'Reference table "tbl_unavailable" not found in this workspace',
+    })
+  })
+})

apps/sim/lib/table/column-types/registry.server.ts

@@ -11,8 +11,9 @@
  * under any other type. `currency` needs only the inbound one.
  */
 
-import { userTableRows } from '@sim/db/schema'
-import { and, eq, sql } from 'drizzle-orm'
+import { userTableDefinitions, userTableRows } from '@sim/db/schema'
+import { and, eq, inArray, isNull, sql } from 'drizzle-orm'
+import { OrchestrationError } from '@/lib/core/orchestration/types'
 import { COLUMN_TYPE_REGISTRY } from '@/lib/table/column-types/registry'
 import type { ColumnType } from '@/lib/table/column-types/types'
 import type {
@@ -21,7 +22,7 @@ import type {
 } from '@/lib/table/column-types/types.server'
 import type { DbTransaction } from '@/lib/table/planner'
 import { updateTableRowsWithDerivedSecretProvenance } from '@/lib/table/rows/secret-provenance'
-import type { JsonValue, SelectOption } from '@/lib/table/types'
+import type { ColumnDefinition, JsonValue, SelectOption } from '@/lib/table/types'
 
 /**
  * Rewrites a column's cells from stored option **ids** to option **names**, for
@@ -289,7 +290,51 @@ export const COLUMN_TYPE_SERVER_REGISTRY: Record<ColumnType, ColumnTypeServerEnt
       migrateSelectCellsToNames(trx, tableId, workspaceId, columnKey, previous.options ?? []),
   },
   currency: COLUMN_TYPE_REGISTRY.currency,
-  reference: COLUMN_TYPE_REGISTRY.reference,
+  reference: {
+    ...COLUMN_TYPE_REGISTRY.reference,
+    referencedTableIds: (column) =>
+      typeof column.referenceTableId === 'string' ? [column.referenceTableId] : [],
+  },
+}
+
+/**
+ * Validates every table ID referenced by column metadata in one query.
+ *
+ * This intentionally validates only the target table. Cell values remain
+ * opaque row-ID strings and are never checked for existence.
+ */
+export async function assertColumnReferencesInWorkspace(
+  trx: DbTransaction,
+  workspaceId: string,
+  columns: readonly ColumnDefinition[]
+): Promise<void> {
+  const referencedTableIds = [
+    ...new Set(
+      columns.flatMap(
+        (column) => COLUMN_TYPE_SERVER_REGISTRY[column.type].referencedTableIds?.(column) ?? []
+      )
+    ),
+  ]
+  if (referencedTableIds.length === 0) return
+
+  const targets = await trx
+    .select({ id: userTableDefinitions.id })
+    .from(userTableDefinitions)
+    .where(
+      and(
+        eq(userTableDefinitions.workspaceId, workspaceId),
+        inArray(userTableDefinitions.id, referencedTableIds),
+        isNull(userTableDefinitions.archivedAt)
+      )
+    )
+  const foundIds = new Set(targets.map((target) => target.id))
+  const missingId = referencedTableIds.find((id) => !foundIds.has(id))
+  if (missingId) {
+    throw new OrchestrationError(
+      'not_found',
+      `Reference table "${missingId}" not found in this workspace`
+    )
+  }
 }
 
 /** The inbound migration for a target type, if it has one. */

apps/sim/lib/table/column-types/types.server.ts

@@ -1,9 +1,9 @@
 /**
- * The server-only half of a column type: rewriting stored cells when a column
- * is converted into or out of this type.
+ * The server-only half of a column type: database-backed definition checks and
+ * stored-cell rewrites for conversion into or out of the type.
  *
  * Separate from `types.ts` so the client-safe definition never references a
- * drizzle transaction type. Mirrors `connectors/`'s `ConnectorMeta` /
+ * Drizzle transaction type. Mirrors `connectors/`'s `ConnectorMeta` /
  * `ConnectorConfig` split.
  */
 
@@ -31,6 +31,12 @@ export interface ColumnCellMigrationContext {
 export type ColumnCellMigration = (context: ColumnCellMigrationContext) => Promise<void>
 
 export interface ColumnTypeServerDefinition {
+  /**
+   * Table IDs named by this column's type-specific metadata. The server
+   * registry uses this to validate cross-table references in one batch before
+   * a schema is persisted. Omitted by types that do not reference tables.
+   */
+  readonly referencedTableIds?: (column: ColumnDefinition) => readonly string[]
   /**
    * Rewrites cells into this type's canonical storage shape when a column is
    * converted **to** it. Omitted when the stored bytes are already correct.

apps/sim/lib/table/column-types/types.ts

@@ -12,8 +12,8 @@
  *   `scripts/check-client-boundary-imports.ts` only forbids calling a
  *   `'use client'` export from a server surface). It must NOT reach `@sim/db`,
  *   `drizzle-orm`, or `next/server` — the tables grid imports it directly.
- * - `ColumnTypeServerDefinition` (in `types.server.ts`) adds the one genuinely
- *   server-only concern: rewriting stored cells inside a transaction.
+ * - `ColumnTypeServerDefinition` (in `types.server.ts`) adds database-backed
+ *   definition checks and stored-cell rewrites inside a transaction.
  *
  * This mirrors `connectors/types.ts`'s `ConnectorMeta` / `ConnectorConfig`
  * split and its `registry.ts` / `registry.server.ts` pair.

apps/sim/lib/table/columns/reference-metadata.test.ts

@@ -8,11 +8,21 @@ import type { TableDefinition } from '@/lib/table/types'
 
 const mocks = vi.hoisted(() => ({
   withLockedTable: vi.fn(),
+  assertColumnReferencesInWorkspace: vi.fn(),
+  migrationFrom: vi.fn(),
+  migrationTo: vi.fn(),
+  writeBackCoercedCells: vi.fn(),
   set: vi.fn(),
   where: vi.fn(),
 }))
 
 vi.mock('@/lib/table/service', () => ({ withLockedTable: mocks.withLockedTable }))
+vi.mock('@/lib/table/column-types/registry.server', () => ({
+  assertColumnReferencesInWorkspace: mocks.assertColumnReferencesInWorkspace,
+  migrationFrom: mocks.migrationFrom,
+  migrationTo: mocks.migrationTo,
+  writeBackCoercedCells: mocks.writeBackCoercedCells,
+}))
 
 import {
   addTableColumn,
@@ -50,6 +60,10 @@ function tableWithReference(referenceTableId = 'tbl_accounts'): TableDefinition
 describe('reference column metadata persistence', () => {
   beforeEach(() => {
     vi.clearAllMocks()
+    mocks.assertColumnReferencesInWorkspace.mockResolvedValue(undefined)
+    mocks.migrationFrom.mockReturnValue(undefined)
+    mocks.migrationTo.mockReturnValue(undefined)
+    mocks.writeBackCoercedCells.mockResolvedValue(undefined)
     mocks.where.mockResolvedValue(undefined)
     mocks.set.mockReturnValue({ where: mocks.where })
   })
@@ -87,6 +101,11 @@ describe('reference column metadata persistence', () => {
       type: 'reference',
       referenceTableId: 'tbl_accounts',
     })
+    expect(mocks.assertColumnReferencesInWorkspace).toHaveBeenCalledWith(
+      expect.anything(),
+      'ws_1',
+      [expect.objectContaining({ referenceTableId: 'tbl_accounts' })]
+    )
   })
 
   it('retains the supplied target when converting a column to reference', async () => {
@@ -107,6 +126,11 @@ describe('reference column metadata persistence', () => {
       type: 'reference',
       referenceTableId: 'tbl_accounts',
     })
+    expect(mocks.assertColumnReferencesInWorkspace).toHaveBeenCalledWith(
+      expect.anything(),
+      'ws_1',
+      [expect.objectContaining({ referenceTableId: 'tbl_accounts' })]
+    )
   })
 
   it('changes a reference target without reading or rewriting rows', async () => {
@@ -122,6 +146,11 @@ describe('reference column metadata persistence', () => {
     )
 
     expect(updated.schema.columns[0]).toMatchObject({ referenceTableId: 'tbl_companies' })
+    expect(mocks.assertColumnReferencesInWorkspace).toHaveBeenCalledWith(
+      expect.anything(),
+      'ws_1',
+      [expect.objectContaining({ referenceTableId: 'tbl_companies' })]
+    )
     expect(trx.select).not.toHaveBeenCalled()
     expect(trx.execute).not.toHaveBeenCalled()
     expect(trx.update).toHaveBeenCalledOnce()
@@ -144,6 +173,24 @@ describe('reference column metadata persistence', () => {
     expect(trx.update).not.toHaveBeenCalled()
   })
 
+  it('leaves the source schema unchanged when the target table is unavailable', async () => {
+    const trx = useTable(tableWithReference())
+    mocks.assertColumnReferencesInWorkspace.mockRejectedValueOnce({ code: 'not_found' })
+
+    await expect(
+      updateColumnReference(
+        {
+          tableId: 'tbl_people',
+          columnName: 'col_account',
+          referenceTableId: 'tbl_missing',
+        },
+        'req_1'
+      )
+    ).rejects.toMatchObject({ code: 'not_found' })
+
+    expect(trx.update).not.toHaveBeenCalled()
+  })
+
   it('returns the locked table unchanged when the target is already set', async () => {
     const table = tableWithReference()
     const trx = useTable(table)

apps/sim/lib/table/columns/service.ts

@@ -29,6 +29,7 @@ import {
   TYPE_SPECIFIC_COLUMN_KEYS,
 } from '@/lib/table/column-types'
 import {
+  assertColumnReferencesInWorkspace,
   migrationFrom,
   migrationTo,
   writeBackCoercedCells,
@@ -192,6 +193,7 @@ export async function addTableColumn(
           `Invalid column: ${columnValidation.errors.join('; ')}`
         )
       }
+      await assertColumnReferencesInWorkspace(trx, table.workspaceId, [newColumn])
 
       const newColumnId = getColumnId(newColumn)
 
@@ -950,6 +952,7 @@ export async function updateColumnType(
         isSelectType,
         targetMultiple: !!targetMultiple,
       })
+      await assertColumnReferencesInWorkspace(trx, table.workspaceId, [convertedColumn])
 
       let incompatibleCount = 0
       let blankCount = 0
@@ -1465,8 +1468,8 @@ export async function updateColumnCurrency(
  * Changes the table targeted by a `reference` column.
  *
  * Cells already store plain row-ID strings, so changing the target updates only
- * the column schema. The target is deliberately not loaded or validated here;
- * dangling table and row IDs are valid reference values for now.
+ * the column schema. The target must be an active table in the same workspace;
+ * stored row IDs remain opaque strings and are not checked for existence.
  */
 export async function updateColumnReference(
   data: UpdateColumnReferenceData,
@@ -1505,6 +1508,7 @@ export async function updateColumnReference(
           `Invalid column: ${columnValidation.errors.join('; ')}`
         )
       }
+      await assertColumnReferencesInWorkspace(trx, table.workspaceId, [updatedColumn])
 
       const constrained = await applyConstraints(
         trx,