fix(tables): guard view autosave against echo remounts and stale responses

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: j15z

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

@@ -266,8 +266,8 @@ export function Table({
   const [{ sort: sortColumn, dir: sortDirection, view: activeViewId }, setTableParams] =
     useQueryStates(tableDetailParsers, tableDetailUrlKeys)
 
-  // Read-only mirrors for the resolve effect: it must know whether the user has
-  // already applied a filter / hidden columns without re-running when they change.
+  // Read-only mirrors for the resolve effect and replaceFilter's echo check:
+  // both must read the current values without re-running when they change.
   const filterRef = useRef(filter)
   filterRef.current = filter
   const hiddenColumnsRef = useRef(hiddenColumns)
@@ -428,9 +428,13 @@ export function Table({
    * this an open panel keeps showing the rules of the filter it replaced.
    *
    * The remount discards an unapplied draft, which is the point — the rules on
-   * screen must be the rules in effect.
+   * screen must be the rules in effect. An incoming filter identical to the
+   * current one is skipped entirely: the resolve effect re-applies the config
+   * after this client's own autosave settles, and letting that echo remount an
+   * open panel would wipe keystrokes typed since the flush and steal focus.
    */
   const replaceFilter = useCallback((next: TablePredicate | null) => {
+    if (JSON.stringify(next) === JSON.stringify(filterRef.current)) return
     setFilter(next)
     setFilterSeed((seed) => seed + 1)
   }, [])
@@ -1208,7 +1212,9 @@ export function Table({
    * "Filter by cell value" from the grid's cell context menu. Narrows the
    * PRUNED filter, so a condition the current schema already invalidated is not
    * resurrected, and opens the panel — a silently narrowed table would leave the
-   * user no way to see what was applied.
+   * user no way to see what was applied. Persists explicitly: the reseeded
+   * panel starts signature-matched to this filter, so its debounce alone would
+   * never save it.
    */
   const handleFilterByCellValue = (conditions: readonly Predicate[]) => {
     const next = withCellValueFilter(effectiveFilter, conditions)
@@ -1434,8 +1440,9 @@ export function Table({
   // a one-line query forward.
   const { data: executionLog } = useLogByExecutionId(workspaceId, executionId)
 
-  // Stable identity so the memoized Resource.Options can bail — an inline
-  // object literal (with an inline arrow) would defeat its memo every render.
+  // Identity only changes with filterOpen (the flush targets the open panel),
+  // so unrelated parent re-renders still let the memoized Resource.Options
+  // bail; filterConfig below re-memoizes on filterOpen anyway.
   const handleToggleFilter = useCallback(() => {
     if (filterOpen) tableFilterRef.current?.flush()
     setFilterOpen(!filterOpen)

apps/sim/hooks/queries/tables.test.ts

@@ -137,6 +137,44 @@ describe('useUpdateTableView autosave ordering', () => {
       promoted,
     ])
   })
+
+  it('ignores a stale promotion response instead of demoting the newer default', () => {
+    const newerDefault: TableViewWire = {
+      id: 'view-newer-default',
+      tableId: TABLE_ID,
+      name: 'Newer default',
+      config: {},
+      isDefault: true,
+      createdBy: 'user-1',
+      createdAt: new Date('2026-08-15T01:00:00.000Z'),
+      updatedAt: new Date('2026-08-15T03:00:00.000Z'),
+    }
+    const stalePromotion: TableViewWire = {
+      ...newerDefault,
+      id: 'view-stale',
+      name: 'Stale view',
+      updatedAt: new Date('2026-08-15T01:00:00.000Z'),
+    }
+    const cachedStaleRow: TableViewWire = {
+      ...stalePromotion,
+      isDefault: false,
+      updatedAt: new Date('2026-08-15T02:00:00.000Z'),
+    }
+    setCache(tableKeys.views(TABLE_ID), [newerDefault, cachedStaleRow])
+
+    const hook = useUpdateTableView({ workspaceId: WORKSPACE_ID, tableId: TABLE_ID })
+    hook.onSuccess?.(
+      stalePromotion,
+      { viewId: stalePromotion.id, isDefault: true },
+      undefined,
+      undefined
+    )
+
+    expect(getCache<TableViewWire[]>(tableKeys.views(TABLE_ID))).toEqual([
+      newerDefault,
+      cachedStaleRow,
+    ])
+  })
 })
 
 describe('useDeleteColumn optimistic update', () => {

apps/sim/hooks/queries/tables.ts

@@ -1579,19 +1579,24 @@ export function useUpdateTableView({ workspaceId, tableId }: RowMutationContext)
     // Keep the active view's server baseline current immediately; the refetch
     // remains the authoritative reconciliation for concurrent collaborators.
     onSuccess: (view) => {
-      queryClient.setQueryData<TableViewWire[]>(tableKeys.views(tableId), (prev) =>
-        prev?.map((existing) => {
+      queryClient.setQueryData<TableViewWire[]>(tableKeys.views(tableId), (prev) => {
+        if (!prev) return prev
+        // Layout and view controls auto-save concurrently, and their
+        // responses can arrive out of order. The DB merge is authoritative, so
+        // only let a response at least as new as the cached row win — for
+        // installing the row AND for demoting the previous default. A stale
+        // response applies nothing; otherwise it would rewind the cache (or
+        // strip isDefault from a newer default, leaving none) until the
+        // refetch lands.
+        const cached = prev.find((existing) => existing.id === view.id)
+        if (cached && new Date(view.updatedAt) < new Date(cached.updatedAt)) return prev
+        return prev.map((existing) => {
           if (view.isDefault && existing.id !== view.id && existing.isDefault) {
             return { ...existing, isDefault: false }
           }
-          if (existing.id !== view.id) return existing
-          // Layout and view controls auto-save concurrently, and their
-          // responses can arrive out of order. The DB merge is authoritative, so
-          // only let a row at least as new as the cached one win — otherwise a
-          // slower response rewinds the cache until the refetch lands.
-          return new Date(view.updatedAt) >= new Date(existing.updatedAt) ? view : existing
+          return existing.id === view.id ? view : existing
         })
-      )
+      })
     },
     onSettled: () => {
       // A scoped mutation only needs the database write ahead of the next