fix(tables): restore virtual table read-only behavior

Author: kerrylu

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

@@ -20,6 +20,7 @@ import type {
   TableViewConfig,
   WorkflowGroup,
 } from '@/lib/table'
+import { canMutateTable, canRenameTable } from '@/lib/table/capabilities'
 import { getColumnId } from '@/lib/table/column-keys'
 import { TABLE_LIMITS } from '@/lib/table/constants'
 import {
@@ -1001,7 +1002,7 @@ export function Table({
 
   const handleStartTableRename = useCallback(() => {
     const data = tableDataRef.current
-    if (data) tableHeaderRename.startRename(tableId, data.name)
+    if (data && canRenameTable(data)) tableHeaderRename.startRename(tableId, data.name)
   }, [tableHeaderRename.startRename, tableId])
 
   const handleAddColumnOfType = (type: ColumnDefinition['type']) => {
@@ -1088,11 +1089,15 @@ export function Table({
                 }
               : undefined,
             dropdownItems: [
-              {
-                label: 'Rename',
-                icon: Pencil,
-                onClick: handleStartTableRename,
-              },
+              ...(canRenameTable(tableData)
+                ? [
+                    {
+                      label: 'Rename',
+                      icon: Pencil,
+                      onClick: handleStartTableRename,
+                    },
+                  ]
+                : []),
               // Reachable with the flag off when something is locked, so an
               // admin can always clear locks (the route allows clearing).
               ...(!tableData.isVirtual &&
@@ -1106,12 +1111,16 @@ export function Table({
                     },
                   ]
                 : []),
-              {
-                label: 'Delete',
-                icon: Trash,
-                onClick: onRequestDeleteTable,
-                disabled: userPermissions.canEdit !== true || tableData.locks.deleteLocked,
-              },
+              ...(canMutateTable(tableData)
+                ? [
+                    {
+                      label: 'Delete',
+                      icon: Trash,
+                      onClick: onRequestDeleteTable,
+                      disabled: userPermissions.canEdit !== true || tableData.locks.deleteLocked,
+                    },
+                  ]
+                : []),
             ],
           }
         : { label: '…', terminal: true },

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

@@ -10,6 +10,7 @@ import { generateId } from '@sim/utils/id'
 import { useParams, useRouter } from 'next/navigation'
 import { useQueryStates } from 'nuqs'
 import type { TableDefinition } from '@/lib/table'
+import { canMutateTable, canRenameTable } from '@/lib/table/capabilities'
 import { CSV_ASYNC_IMPORT_THRESHOLD_BYTES, generateUniqueTableName } from '@/lib/table/constants'
 import { SEARCH_DEBOUNCE_MS } from '@/lib/url-state'
 import type {
@@ -1119,11 +1120,17 @@ export function Tables() {
         onCopyId={() => {
           if (activeTable) navigator.clipboard.writeText(activeTable.id)
         }}
-        onDelete={() => setIsDeleteDialogOpen(true)}
-        onRename={() => {
-          if (activeTable) listRename.startRename(activeTable.id, activeTable.name)
-        }}
-        onImportCsv={() => setIsImportDialogOpen(true)}
+        onDelete={
+          activeTable && canMutateTable(activeTable) ? () => setIsDeleteDialogOpen(true) : undefined
+        }
+        onRename={
+          activeTable && canRenameTable(activeTable)
+            ? () => listRename.startRename(activeTable.id, activeTable.name)
+            : undefined
+        }
+        onImportCsv={
+          activeTable && canMutateTable(activeTable) ? () => setIsImportDialogOpen(true) : undefined
+        }
         onExportCsv={async () => {
           if (!activeTable) return
           try {
@@ -1135,8 +1142,10 @@ export function Tables() {
         }}
         onTogglePin={handleTogglePin}
         pinned={activeTable ? pinnedTableIds.has(activeTable.id) : false}
-        onMove={canEdit ? handleMoveTable : undefined}
-        moveOptions={canEdit ? tableMoveOptions : undefined}
+        onMove={canEdit && activeTable && canMutateTable(activeTable) ? handleMoveTable : undefined}
+        moveOptions={
+          canEdit && activeTable && canMutateTable(activeTable) ? tableMoveOptions : undefined
+        }
         disableDelete={!canEdit}
         disableRename={!canEdit}
         disableImport={!canEdit}

apps/sim/lib/table/__tests__/service-filter-threading.test.ts

@@ -15,18 +15,21 @@ import { decodeCursor } from '@/lib/table/rows/cursor'
 import { buildFilterClause, buildSortClause } from '@/lib/table/sql'
 import type { ColumnDefinition, TableDefinition } from '@/lib/table/types'
 
-const { mockQueryVirtualTableRows } = vi.hoisted(() => ({
+const { mockFindVirtualTableRowMatches, mockQueryVirtualTableRows } = vi.hoisted(() => ({
+  mockFindVirtualTableRowMatches: vi.fn(),
   mockQueryVirtualTableRows: vi.fn(),
 }))
 
 vi.mock('@/lib/virtual-tables/service.server', () => ({
+  findVirtualTableRowMatches: mockFindVirtualTableRowMatches,
   queryVirtualTableRows: mockQueryVirtualTableRows,
 }))
 
 vi.mock('@/lib/table/sql', () => ({
   buildFilterClause: vi.fn(() => sql`true`),
   buildSortClause: vi.fn(() => sql`true`),
   buildPredicateClause: vi.fn(() => sql`true`),
+  escapeLikePattern: vi.fn((value: string) => value),
   TableQueryValidationError: class TableQueryValidationError extends Error {},
 }))
 
@@ -53,7 +56,12 @@ vi.mock('@/lib/table/validation', () => ({
   checkBatchUniqueConstraintsDb: vi.fn(async () => ({ valid: true, errors: [] })),
 }))
 
-import { deleteRowsByFilter, queryRows, updateRowsByFilter } from '@/lib/table/rows/service'
+import {
+  deleteRowsByFilter,
+  findRowMatches,
+  queryRows,
+  updateRowsByFilter,
+} from '@/lib/table/rows/service'
 
 const COLUMNS: ColumnDefinition[] = [
   { name: 'name', type: 'string' },
@@ -175,6 +183,31 @@ describe('queryRows storage dispatch', () => {
   })
 })
 
+describe('findRowMatches storage dispatch', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    resetDbChainMock()
+  })
+
+  it('searches only virtual storage for a virtual table', async () => {
+    const virtualResult = {
+      matches: [{ ordinal: 0, rowId: 'memory-1', column: 'transcript' }],
+      truncated: false,
+    }
+    mockFindVirtualTableRowMatches.mockResolvedValueOnce(virtualResult)
+
+    await expect(
+      findRowMatches({ ...TABLE, isVirtual: true }, { q: 'hello' }, 'req-1')
+    ).resolves.toBe(virtualResult)
+
+    expect(mockFindVirtualTableRowMatches).toHaveBeenCalledWith(
+      expect.objectContaining({ id: TABLE.id, isVirtual: true }),
+      { q: 'hello' }
+    )
+    expect(dbChainMockFns.transaction).not.toHaveBeenCalled()
+  })
+})
+
 describe('bulk update/delete limited-subset ordering', () => {
   beforeEach(() => {
     vi.clearAllMocks()

apps/sim/lib/table/capabilities.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest'
+import { canMutateTable, canRenameTable } from '@/lib/table/capabilities'
+
+describe('canMutateTable', () => {
+  it('prevents persisted-table actions for virtual tables', () => {
+    expect(canMutateTable({ isVirtual: true })).toBe(false)
+  })
+
+  it('allows persisted-table actions for stored tables', () => {
+    expect(canMutateTable({ isVirtual: false })).toBe(true)
+    expect(canMutateTable({})).toBe(true)
+  })
+})
+
+describe('canRenameTable', () => {
+  it('prevents renaming virtual tables such as Memory', () => {
+    expect(canRenameTable({ isVirtual: true })).toBe(false)
+  })
+
+  it('allows renaming persisted tables', () => {
+    expect(canRenameTable({ isVirtual: false })).toBe(true)
+    expect(canRenameTable({})).toBe(true)
+  })
+})

apps/sim/lib/table/capabilities.ts

@@ -0,0 +1,11 @@
+import type { TableDefinition } from '@/lib/table/types'
+
+/** Returns whether a table supports persisted mutation and management actions. */
+export function canMutateTable(table: Pick<TableDefinition, 'isVirtual'>): boolean {
+  return table.isVirtual !== true
+}
+
+/** Returns whether a table supports changing its persisted display name. */
+export function canRenameTable(table: Pick<TableDefinition, 'isVirtual'>): boolean {
+  return canMutateTable(table)
+}

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

@@ -102,7 +102,10 @@ import {
   validateRowSize,
 } from '@/lib/table/validation'
 import { cancelWorkflowGroupRuns, runWorkflowColumn } from '@/lib/table/workflow-columns'
-import { queryVirtualTableRows } from '@/lib/virtual-tables/service.server'
+import {
+  findVirtualTableRowMatches,
+  queryVirtualTableRows,
+} from '@/lib/virtual-tables/service.server'
 
 const logger = createLogger('TableRowsService')
 
@@ -866,6 +869,8 @@ export async function findRowMatches(
   options: { q: string; filter?: Filter; sort?: Sort },
   requestId: string
 ): Promise<{ matches: FindRowMatch[]; truncated: boolean }> {
+  if (table.isVirtual) return findVirtualTableRowMatches(table, options)
+
   const tableName = USER_TABLE_ROWS_SQL_NAME
   const columns = table.schema.columns
   // Row data is keyed by stable column id, so scan/return JSONB keys as ids.

apps/sim/lib/virtual-tables/memory-virtual-table.server.test.ts

@@ -11,16 +11,23 @@ import {
 import { sql as drizzleSql } from 'drizzle-orm'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
-const { mockBuildFilterClause, mockBuildPredicateClause, mockBuildSortClause } = vi.hoisted(() => ({
+const {
+  mockBuildFilterClause,
+  mockBuildPredicateClause,
+  mockBuildSortClause,
+  mockEscapeLikePattern,
+} = vi.hoisted(() => ({
   mockBuildFilterClause: vi.fn(() => ({ type: 'filter' })),
   mockBuildPredicateClause: vi.fn(() => ({ type: 'predicate' })),
   mockBuildSortClause: vi.fn(() => ({ type: 'sort' })),
+  mockEscapeLikePattern: vi.fn((value: string) => value),
 }))
 
 vi.mock('@/lib/table/sql', () => ({
   buildFilterClause: mockBuildFilterClause,
   buildPredicateClause: mockBuildPredicateClause,
   buildSortClause: mockBuildSortClause,
+  escapeLikePattern: mockEscapeLikePattern,
 }))
 
 vi.mock('drizzle-orm', () => {
@@ -47,6 +54,7 @@ vi.mock('drizzle-orm', () => {
 })
 
 import {
+  findMemoryTableRowMatches,
   getMemoryTableDefinition,
   queryMemoryTableRows,
 } from '@/lib/virtual-tables/memory-virtual-table.server'
@@ -258,6 +266,60 @@ describe('Memory virtual table', () => {
     )
   })
 
+  it('finds matching cells in one storage query and preserves filtered sort ordinals', async () => {
+    dbChainMockFns.execute.mockResolvedValueOnce([
+      { ordinal: '4', id: 'memory-1', column_name: 'transcript' },
+      { ordinal: 7, id: 'memory-2', column_name: 'conversation_id' },
+    ])
+
+    await expect(
+      findMemoryTableRowMatches({
+        workspaceId: 'workspace-1',
+        q: '50%_off',
+        filter: { conversation_id: { $contains: 'customer' } },
+        sort: { updated_at: 'asc' },
+      })
+    ).resolves.toEqual({
+      matches: [
+        { ordinal: 4, rowId: 'memory-1', column: 'transcript' },
+        { ordinal: 7, rowId: 'memory-2', column: 'conversation_id' },
+      ],
+      truncated: false,
+    })
+
+    expect(dbChainMockFns.execute).toHaveBeenCalledTimes(1)
+    expect(mockEscapeLikePattern).toHaveBeenCalledWith('50%_off')
+    expect(mockBuildFilterClause).toHaveBeenCalledWith(
+      { conversation_id: { $contains: 'customer' } },
+      'memory_rows',
+      expect.any(Array)
+    )
+    expect(mockBuildSortClause).toHaveBeenCalledWith(
+      { updated_at: 'asc' },
+      'memory_rows',
+      expect.any(Array)
+    )
+    const findSqlCall = vi
+      .mocked(drizzleSql)
+      .mock.calls.find(([strings]) => Array.from(strings).join('').includes('jsonb_each_text'))
+    expect(findSqlCall).toBeDefined()
+  })
+
+  it('caps storage matches and reports truncation', async () => {
+    dbChainMockFns.execute.mockResolvedValueOnce(
+      Array.from({ length: 1001 }, (_, index) => ({
+        ordinal: index,
+        id: `memory-${index}`,
+        column_name: 'transcript',
+      }))
+    )
+
+    const result = await findMemoryTableRowMatches({ workspaceId: 'workspace-1', q: 'hello' })
+
+    expect(result).toMatchObject({ truncated: true })
+    expect(result.matches).toHaveLength(1000)
+  })
+
   it('returns an empty page', async () => {
     queueTableRows(schemaMock.memory, [])