fix(tables): give the tables prefetch the same wire shape the route returns

GET /api/table does not return listTables rows: it drops metadata, runs every
column through normalizeColumn, serializes the three dates, and defaults the
job fields. The prefetch called listTables directly, so a hydrated entry held
un-normalized columns plus a field the client never sees, and swapped them out
on the first refetch.

Extracts listTablesForWorkspace so the route and the prefetch produce one
shape, matching what files, knowledge and pinned items already do here.

Author: waleedlatif1

apps/sim/app/api/table/route.ts

@@ -11,10 +11,10 @@ import { captureServerEvent } from '@/lib/posthog/server'
 import {
   createTable,
   getWorkspaceTableLimits,
-  listTables,
   type TableSchema,
   type TableScope,
 } from '@/lib/table'
+import { listTablesForWorkspace } from '@/lib/table/queries'
 import { getUserEntityPermissions } from '@/lib/workspaces/permissions/utils'
 import { normalizeColumn } from '@/app/api/table/utils'
 
@@ -204,46 +204,20 @@ export const GET = withRouteHandler(async (request: NextRequest) => {
       return NextResponse.json({ error: 'Access denied' }, { status: 403 })
     }
 
-    const tables = await listTables(params.workspaceId, { scope: params.scope as TableScope })
-
-    logger.info(`[${requestId}] Listed ${tables.length} tables in workspace ${params.workspaceId}`)
+    const responseTables = await listTablesForWorkspace(
+      params.workspaceId,
+      params.scope as TableScope
+    )
 
-    const responseTables = tables.map((t) => {
-      const schemaData = t.schema as TableSchema
-      return {
-        id: t.id,
-        name: t.name,
-        description: t.description,
-        schema: {
-          columns: schemaData.columns.map(normalizeColumn),
-        },
-        rowCount: t.rowCount,
-        maxRows: t.maxRows,
-        locks: t.locks,
-        workspaceId: t.workspaceId,
-        folderId: t.folderId ?? null,
-        createdBy: t.createdBy,
-        createdAt: t.createdAt instanceof Date ? t.createdAt.toISOString() : String(t.createdAt),
-        updatedAt: t.updatedAt instanceof Date ? t.updatedAt.toISOString() : String(t.updatedAt),
-        archivedAt:
-          t.archivedAt instanceof Date
-            ? t.archivedAt.toISOString()
-            : t.archivedAt
-              ? String(t.archivedAt)
-              : null,
-        jobStatus: t.jobStatus ?? null,
-        jobId: t.jobId ?? null,
-        jobType: t.jobType ?? null,
-        jobError: t.jobError ?? null,
-        jobRowsProcessed: t.jobRowsProcessed ?? 0,
-      }
-    })
+    logger.info(
+      `[${requestId}] Listed ${responseTables.length} tables in workspace ${params.workspaceId}`
+    )
 
     return NextResponse.json({
       success: true,
       data: {
         tables: responseTables,
-        totalCount: tables.length,
+        totalCount: responseTables.length,
       },
     })
   } catch (error) {

apps/sim/app/workspace/[workspaceId]/lib/prefetch.test.ts

@@ -10,7 +10,7 @@ const {
   mockGetWorkspaceMemberProfiles,
   mockListFoldersForWorkspace,
   mockListPinnedItemsForViewer,
-  mockListTables,
+  mockListTablesForWorkspace,
   mockListWorkspaceFileFolders,
   mockListWorkspaceFilesWithShares,
 } = vi.hoisted(() => ({
@@ -19,7 +19,7 @@ const {
   mockGetWorkspaceMemberProfiles: vi.fn(),
   mockListFoldersForWorkspace: vi.fn(),
   mockListPinnedItemsForViewer: vi.fn(),
-  mockListTables: vi.fn(),
+  mockListTablesForWorkspace: vi.fn(),
   mockListWorkspaceFileFolders: vi.fn(),
   mockListWorkspaceFilesWithShares: vi.fn(),
 }))
@@ -38,7 +38,7 @@ vi.mock('@/lib/workspace-files/queries', () => ({
 vi.mock('@/lib/uploads/contexts/workspace', () => ({
   listWorkspaceFileFolders: mockListWorkspaceFileFolders,
 }))
-vi.mock('@/lib/table', () => ({ listTables: mockListTables }))
+vi.mock('@/lib/table/queries', () => ({ listTablesForWorkspace: mockListTablesForWorkspace }))
 vi.mock('@/lib/knowledge/queries', () => ({
   listKnowledgeBasesForViewer: mockListKnowledgeBasesForViewer,
 }))
@@ -75,7 +75,7 @@ describe('workspace list prefetches', () => {
     mockListFoldersForWorkspace.mockResolvedValue([])
     mockListWorkspaceFilesWithShares.mockResolvedValue([])
     mockListWorkspaceFileFolders.mockResolvedValue([])
-    mockListTables.mockResolvedValue([])
+    mockListTablesForWorkspace.mockResolvedValue([])
     mockListKnowledgeBasesForViewer.mockResolvedValue([])
   })
 
@@ -95,12 +95,12 @@ describe('workspace list prefetches', () => {
   describe('prefetchTables', () => {
     it('primes the exact key useTablesList reads', async () => {
       const tables = [{ id: 't-1' }]
-      mockListTables.mockResolvedValue(tables)
+      mockListTablesForWorkspace.mockResolvedValue(tables)
       const client = makeClient()
 
       await prefetchTables(client, WORKSPACE_ID, USER_ID)
 
-      expect(mockListTables).toHaveBeenCalledWith(WORKSPACE_ID, { scope: 'active' })
+      expect(mockListTablesForWorkspace).toHaveBeenCalledWith(WORKSPACE_ID, 'active')
       expect(client.getQueryData(tableKeys.list(WORKSPACE_ID, 'active'))).toEqual(tables)
     })
   })
@@ -177,7 +177,7 @@ describe('workspace list prefetches', () => {
 
         expect(client.getQueryCache().getAll()).toHaveLength(0)
         expect(mockListWorkspaceFilesWithShares).not.toHaveBeenCalled()
-        expect(mockListTables).not.toHaveBeenCalled()
+        expect(mockListTablesForWorkspace).not.toHaveBeenCalled()
         expect(mockListKnowledgeBasesForViewer).not.toHaveBeenCalled()
         expect(mockListPinnedItemsForViewer).not.toHaveBeenCalled()
       })

apps/sim/app/workspace/[workspaceId]/tables/prefetch.ts

@@ -1,6 +1,6 @@
 import type { QueryClient } from '@tanstack/react-query'
 import { listFoldersForWorkspace } from '@/lib/folders/queries'
-import { listTables } from '@/lib/table'
+import { listTablesForWorkspace } from '@/lib/table/queries'
 import { getUserEntityPermissions } from '@/lib/workspaces/permissions/utils'
 import { prefetchResourceListChrome } from '@/app/workspace/[workspaceId]/lib/prefetch-resource-list-chrome'
 import { FOLDER_LIST_STALE_TIME, folderKeys, mapFolder } from '@/hooks/queries/utils/folder-keys'
@@ -14,8 +14,9 @@ import { TABLE_LIST_STALE_TIME, tableKeys } from '@/hooks/queries/utils/table-ke
  * only placed correctly relative to the folder rows it sits beside, so
  * prefetching one without the other still flashes an ungrouped list.
  *
- * Folders are mapped with the same `mapFolder` the hook applies so the hydrated entry
- * matches a client fetch exactly.
+ * `listTablesForWorkspace` returns the same wire shape `GET /api/table` does, and folders
+ * are mapped with the same `mapFolder` the hook applies — so both hydrated entries match a
+ * client fetch exactly.
  */
 export async function prefetchTables(
   queryClient: QueryClient,
@@ -28,7 +29,7 @@ export async function prefetchTables(
   await Promise.all([
     queryClient.prefetchQuery({
       queryKey: tableKeys.list(workspaceId, 'active'),
-      queryFn: () => listTables(workspaceId, { scope: 'active' }),
+      queryFn: () => listTablesForWorkspace(workspaceId, 'active'),
       staleTime: TABLE_LIST_STALE_TIME,
     }),
     queryClient.prefetchQuery({

apps/sim/lib/table/queries.ts

@@ -0,0 +1,45 @@
+import { listTables, type TableScope } from '@/lib/table/service'
+import type { TableDefinition, TableSchema } from '@/lib/table/types'
+import { normalizeColumn } from '@/app/api/table/utils'
+
+/** Serializes a stored date to the ISO string the wire carries. */
+function toWireDate(value: Date | string): string {
+  return value instanceof Date ? value.toISOString() : String(value)
+}
+
+/**
+ * Lists a workspace's tables in the wire shape `GET /api/table` returns.
+ *
+ * Shared by that route and the Tables page's server prefetch so a hydrated cache entry and a
+ * client fetch cannot disagree. The shaping is not incidental: the route drops `metadata`,
+ * runs every column through {@link normalizeColumn}, serializes the three dates, and defaults
+ * the job fields — so caching raw `listTables` rows would hydrate un-normalized columns and a
+ * field the client never sees, then swap them out on the first refetch.
+ */
+export async function listTablesForWorkspace(
+  workspaceId: string,
+  scope: TableScope = 'active'
+): Promise<TableDefinition[]> {
+  const tables = await listTables(workspaceId, { scope })
+
+  return tables.map((table) => ({
+    id: table.id,
+    name: table.name,
+    description: table.description,
+    schema: { columns: (table.schema as TableSchema).columns.map(normalizeColumn) },
+    rowCount: table.rowCount,
+    maxRows: table.maxRows,
+    locks: table.locks,
+    workspaceId: table.workspaceId,
+    folderId: table.folderId ?? null,
+    createdBy: table.createdBy,
+    createdAt: toWireDate(table.createdAt),
+    updatedAt: toWireDate(table.updatedAt),
+    archivedAt: table.archivedAt ? toWireDate(table.archivedAt) : null,
+    jobStatus: table.jobStatus ?? null,
+    jobId: table.jobId ?? null,
+    jobType: table.jobType ?? null,
+    jobError: table.jobError ?? null,
+    jobRowsProcessed: table.jobRowsProcessed ?? 0,
+  }))
+}