fix(tables): close persisted view lifecycle gaps

Author: j15z

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/views-menu/views-menu.test.tsx

@@ -1,6 +1,3 @@
-/**
- * @vitest-environment jsdom
- */
 import { renderToStaticMarkup } from 'react-dom/server'
 import { describe, expect, it, vi } from 'vitest'
 import type { TableViewWire } from '@/lib/api/contracts/tables'

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

@@ -1109,7 +1109,9 @@ export function Table({
    * user no way to see what was applied.
    */
   const handleFilterByCellValue = (conditions: readonly Predicate[]) => {
-    replaceFilter(withCellValueFilter(effectiveFilter, conditions))
+    const next = withCellValueFilter(effectiveFilter, conditions)
+    replaceFilter(next)
+    persistActiveViewConfig({ filter: next })
     setFilterOpen(true)
   }
 
@@ -1355,8 +1357,8 @@ export function Table({
       />
     ) : null
 
-  /** Right-aligned slot. Left `undefined` when both are absent so the options bar
-   *  doesn't render an empty flex row — a fragment would always read as truthy. */
+  /** Right-aligned slot. Left `undefined` when absent so the options bar
+   *  doesn't render an empty flex row. */
   const optionsTrailing = runStatus || undefined
 
   return (
@@ -1395,8 +1397,8 @@ export function Table({
         />
       )}
       {/* Sort + filter render in both modes. In embedded (mothership) mode there's no
-          Resource.Header, so the run/stop control rides in the options bar — pinned
-          right, opposite the menu cluster, next to Save. */}
+            Resource.Header, so the run/stop control rides in the options bar — pinned
+            right, opposite the menu cluster. */}
       <Resource.Options
         sort={sortConfig}
         filter={filterConfig}

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

@@ -2,7 +2,7 @@
  * @vitest-environment node
  */
 
-import { folder as folderTable } from '@sim/db/schema'
+import { folder as folderTable, tableViews, userTableDefinitions } from '@sim/db/schema'
 import { sha256Hex } from '@sim/security/hash'
 import {
   dbChainMockFns,
@@ -1211,6 +1211,127 @@ describe('copyForkResourceContent', () => {
   })
 })
 
+describe('copyForkResourceContainers table views', () => {
+  it('copies saved views and seeds a default for a legacy table', async () => {
+    const now = new Date('2026-08-19T00:00:00.000Z')
+    const definitions = [
+      {
+        id: 'table-with-view',
+        workspaceId: 'src-ws',
+        folderId: null,
+        name: 'Configured table',
+        description: null,
+        schema: { columns: [{ id: 'col-name', name: 'Name', type: 'string' }] },
+        metadata: { columnOrder: ['col-name'] },
+        maxRows: 10000,
+        rowCount: 1,
+        rowsVersion: 1,
+        schemaLocked: false,
+        insertLocked: false,
+        updateLocked: false,
+        deleteLocked: false,
+        archivedAt: null,
+        createdBy: 'source-user',
+        createdAt: now,
+        updatedAt: now,
+      },
+      {
+        id: 'legacy-table',
+        workspaceId: 'src-ws',
+        folderId: null,
+        name: 'Legacy table',
+        description: null,
+        schema: { columns: [{ id: 'col-email', name: 'Email', type: 'string' }] },
+        metadata: { columnOrder: ['col-email'] },
+        maxRows: 10000,
+        rowCount: 0,
+        rowsVersion: 0,
+        schemaLocked: false,
+        insertLocked: false,
+        updateLocked: false,
+        deleteLocked: false,
+        archivedAt: null,
+        createdBy: 'source-user',
+        createdAt: now,
+        updatedAt: now,
+      },
+    ]
+    const sourceViews = [
+      {
+        id: 'source-view',
+        tableId: 'table-with-view',
+        workspaceId: 'src-ws',
+        name: 'My view',
+        config: { hiddenColumns: ['col-name'] },
+        isDefault: true,
+        createdBy: 'source-user',
+        createdAt: now,
+        updatedAt: now,
+      },
+    ]
+    const inserted = new Map<unknown, Array<Record<string, unknown>>>()
+    const tx = {
+      select: () => ({
+        from: (table: unknown) => ({
+          where: () =>
+            Promise.resolve(
+              table === userTableDefinitions ? definitions : table === tableViews ? sourceViews : []
+            ),
+        }),
+      }),
+      insert: (table: unknown) => ({
+        values: (values: Array<Record<string, unknown>>) => {
+          inserted.set(table, values)
+          return Promise.resolve()
+        },
+      }),
+    }
+
+    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: definitions.map((definition) => definition.id),
+        knowledgeBases: [],
+      },
+      workflowIdMap: new Map(),
+      documentMappingContext: { edgeChildWorkspaceId: 'child-ws', sourceIsParent: true },
+    })
+
+    const copiedTableId = result.idMap.get('table')?.get('table-with-view')
+    const legacyTableId = result.idMap.get('table')?.get('legacy-table')
+    const copiedViews = inserted.get(tableViews)
+    expect(copiedViews).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          tableId: copiedTableId,
+          workspaceId: 'child-ws',
+          name: 'My view',
+          config: { hiddenColumns: ['col-name'] },
+          isDefault: true,
+          createdBy: 'user-1',
+        }),
+        expect.objectContaining({
+          tableId: legacyTableId,
+          workspaceId: 'child-ws',
+          name: 'Default',
+          config: { columnOrder: ['col-email'] },
+          isDefault: true,
+          createdBy: 'user-1',
+        }),
+      ])
+    )
+    expect(copiedViews?.find((view) => view.name === 'My view')?.id).not.toBe('source-view')
+  })
+})
+
 describe('copyForkResourceContainers custom-tool code env rewrite', () => {
   function makeContainerTx(rows: Array<Record<string, unknown>>) {
     const inserted: Array<Record<string, unknown>> = []

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

@@ -10,6 +10,7 @@ import {
   permissions,
   skill,
   skillMember,
+  tableViews,
   userTableDefinitions,
   userTableRowSecretProvenance,
   userTableRows,
@@ -54,6 +55,7 @@ import {
   rebindKnowledgeDocumentSecretProvenance,
   replaceKnowledgeDocumentSecretProvenanceInTx,
 } from '@/lib/knowledge/secret-provenance'
+import { DEFAULT_TABLE_VIEW_NAME } from '@/lib/table/constants'
 import { nKeysBetween } from '@/lib/table/order-key'
 import {
   classifyTableRowSecretProvenanceForCopy,
@@ -635,6 +637,27 @@ export async function copyForkResourceContainers(
           isNull(userTableDefinitions.archivedAt)
         )
       )
+    const sourceViews =
+      definitions.length > 0
+        ? await tx
+            .select()
+            .from(tableViews)
+            .where(
+              and(
+                inArray(
+                  tableViews.tableId,
+                  definitions.map((definition) => definition.id)
+                ),
+                eq(tableViews.workspaceId, sourceWorkspaceId)
+              )
+            )
+        : []
+    const sourceViewsByTable = new Map<string, typeof sourceViews>()
+    for (const view of sourceViews) {
+      const views = sourceViewsByTable.get(view.tableId) ?? []
+      views.push(view)
+      sourceViewsByTable.set(view.tableId, views)
+    }
     const tableFolderIdMap = await resolveForkFolderMapping({
       tx,
       sourceWorkspaceId,
@@ -647,6 +670,7 @@ export async function copyForkResourceContainers(
     for (const [source, target] of tableFolderIdMap) folderIdMap.set(source, target)
 
     const inserts: (typeof userTableDefinitions.$inferInsert)[] = []
+    const viewInserts: (typeof tableViews.$inferInsert)[] = []
     for (const definition of definitions) {
       const childTableId = generateId()
       const remappedSchema = remapForkTableWorkflowGroups(
@@ -684,11 +708,37 @@ export async function copyForkResourceContainers(
         createdAt: now,
         updatedAt: now,
       })
+      const views = sourceViewsByTable.get(definition.id) ?? []
+      for (const view of views) {
+        viewInserts.push({
+          ...view,
+          id: generateId(),
+          tableId: childTableId,
+          workspaceId: childWorkspaceId,
+          createdBy: userId,
+          createdAt: now,
+          updatedAt: now,
+        })
+      }
+      if (!views.some((view) => view.isDefault)) {
+        viewInserts.push({
+          id: generateId(),
+          tableId: childTableId,
+          workspaceId: childWorkspaceId,
+          name: DEFAULT_TABLE_VIEW_NAME,
+          config: definition.metadata ?? {},
+          isDefault: true,
+          createdBy: userId,
+          createdAt: now,
+          updatedAt: now,
+        })
+      }
       record('table', definition.id, childTableId)
       contentPlan.tables.push({ sourceId: definition.id, childId: childTableId })
       names.tables.push(definition.name)
     }
     if (inserts.length > 0) await tx.insert(userTableDefinitions).values(inserts)
+    if (viewInserts.length > 0) await tx.insert(tableViews).values(viewInserts)
   }
 
   if (selection.knowledgeBases.length > 0) {