refactor(table): store saved views in the v2 predicate grammar

Views shipped (#5961) storing the legacy `$`-object filter and `{col: dir}`
sort record — a brand-new persistent store of the grammar this branch is
retiring, created days before the wire moved to predicates. The feature is
still dark (`table-views` is UI-only and off), so the stored shape can change
now without a data migration; once the flag flips, it cannot.

`TableViewConfig` now carries `TablePredicate` + `SortSpec`. The wire contract
uses `predicateSchema`/`sortSpecSchema`, which also brings the strict-object
node shapes and depth/size bounds to the view routes — previously a view's
filter was accepted as an arbitrary domain object.

The grid still runs on the legacy pair internally; translation happens at the
view boundary. Apply: `predicateToFilter` (total here — stored predicates are
builder-authored). Save: `filterToRules ∘ filterRulesToPredicate`, the
builder round-trip. SortSpec keeps priority order the record never could.

Dev-era rows written before the switch are normalized on read: legacy filters
convert through the builder round-trip and are dropped if the result's leaf
fields fail the column-name pattern — the rule converters accept garbage
(`{$bogus: …}` becomes a rule on a column literally named `$bogus`), so the
conversion is validated rather than trusted.

Also folds `sortQuery`'s single-entry record out of the save path in favour of
the sort params directly, so a saved view records the same thing the URL says.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_011M563cbFy2S74GvSDf2C3R

Author: TheodoreSpeaks

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

@@ -22,6 +22,11 @@ import type {
 } from '@/lib/table'
 import { getColumnId } from '@/lib/table/column-keys'
 import { TABLE_LIMITS } from '@/lib/table/constants'
+import {
+  filterRulesToPredicate,
+  filterToRules,
+  predicateToFilter,
+} from '@/lib/table/query-builder/converters'
 import {
   type BreadcrumbItem,
   type ColumnOption,
@@ -423,13 +428,17 @@ export function Table({
       config: TableViewConfig | null,
       keep?: { sort?: boolean; filter?: boolean; hiddenColumns?: boolean }
     ) => {
-      if (!keep?.filter) setFilter(config?.filter ?? null)
+      // Stored views speak the v2 grammar; the grid's runtime state is still the
+      // legacy Filter/Sort pair, so translate at this boundary. A stored predicate
+      // is always builder-authored (the save path converts from builder output),
+      // so the legacy projection is total here.
+      if (!keep?.filter) setFilter(config?.filter ? predicateToFilter(config.filter) : null)
       if (!keep?.hiddenColumns) setHiddenColumns(config?.hiddenColumns ?? [])
       if (keep?.sort) return
-      const sortEntry = config?.sort ? Object.entries(config.sort)[0] : undefined
+      const sortEntry = config?.sort?.[0]
       setTableParams({
-        sort: sortEntry ? sortEntry[0] : null,
-        dir: sortEntry ? (sortEntry[1] as SortDirection) : null,
+        sort: sortEntry ? sortEntry.field : null,
+        dir: sortEntry ? (sortEntry.direction as SortDirection) : null,
       })
     },
     [setTableParams]
@@ -651,11 +660,20 @@ export function Table({
   const currentViewConfig = useMemo<TableViewConfig>(
     () => ({
       ...(activeView?.config ?? tableData?.metadata),
-      filter: effectiveFilter,
-      sort: sortQuery,
+      // Views store the v2 grammar; the grid runs on the legacy pair. The filter
+      // is builder-authored, so the rule round-trip is lossless here.
+      filter: effectiveFilter ? filterRulesToPredicate(filterToRules(effectiveFilter)) : null,
+      sort: sortColumn ? [{ field: sortColumn, direction: sortDirection }] : null,
       hiddenColumns: effectiveHiddenColumns,
     }),
-    [activeView, tableData?.metadata, effectiveFilter, sortQuery, effectiveHiddenColumns]
+    [
+      activeView,
+      tableData?.metadata,
+      effectiveFilter,
+      sortColumn,
+      sortDirection,
+      effectiveHiddenColumns,
+    ]
   )
 
   /**

apps/sim/lib/api/contracts/tables.ts

@@ -1717,8 +1717,11 @@ export const tableEventStreamContract = defineRouteContract({
  * never invalidates a view.
  */
 export const tableViewConfigSchema = tableMetadataSchema.extend({
-  filter: filterSchema.nullable().optional(),
-  sort: domainObjectSchema<Sort>().nullable().optional(),
+  // The v2 predicate/sort grammar — same wire as the query routes, so a saved
+  // view gets the same strictness and depth bounds as a live filter, and its
+  // config can later feed the v2 surfaces without conversion.
+  filter: predicateSchema.nullable().optional(),
+  sort: sortSpecSchema.nullable().optional(),
 }) satisfies z.ZodType<TableViewConfig>
 
 export const tableViewSchema = z.object({

apps/sim/lib/table/types.ts

@@ -286,8 +286,8 @@ export interface TableMetadata {
  * user resizes, reorders, pins, or hides columns.
  */
 export interface TableViewConfig extends TableMetadata {
-  filter?: Filter | null
-  sort?: Sort | null
+  filter?: TablePredicate | null
+  sort?: SortSpec | null
 }
 
 /** Async background-job lifecycle state for a table. NULL/undefined = idle (no job). */

apps/sim/lib/table/views/service.test.ts

@@ -3,7 +3,7 @@
  */
 import { describe, expect, it } from 'vitest'
 import type { ColumnDefinition, TableViewConfig } from '@/lib/table/types'
-import { pruneViewConfig } from '@/lib/table/views/service'
+import { normalizeStoredViewConfig, pruneViewConfig } from '@/lib/table/views/service'
 
 const columns: ColumnDefinition[] = [
   { id: 'col_a', name: 'Name', type: 'text' },
@@ -28,14 +28,18 @@ describe('pruneViewConfig', () => {
   })
 
   it('drops a sort on a deleted column and collapses to null when none remain', () => {
-    expect(pruneViewConfig({ sort: { col_gone: 'asc' } }, columns).sort).toBeNull()
-    expect(pruneViewConfig({ sort: { col_a: 'desc' } }, columns).sort).toEqual({ col_a: 'desc' })
+    expect(
+      pruneViewConfig({ sort: [{ field: 'col_gone', direction: 'asc' }] }, columns).sort
+    ).toBeNull()
+    expect(
+      pruneViewConfig({ sort: [{ field: 'col_a', direction: 'desc' }] }, columns).sort
+    ).toEqual([{ field: 'col_a', direction: 'desc' }])
   })
 
   it('leaves the filter untouched even when it references a deleted column', () => {
     // Pruning a predicate would silently widen the view's row set — surfacing a
     // stale condition the user can see and remove is the safer failure.
-    const filter = { col_gone: { $eq: 'x' } }
+    const filter = { all: [{ field: 'col_gone', op: 'eq' as const, value: 'x' }] }
     expect(pruneViewConfig({ filter }, columns).filter).toEqual(filter)
   })
 
@@ -50,3 +54,33 @@ describe('pruneViewConfig', () => {
     ])
   })
 })
+
+/**
+ * Reads written before the grammar switch: the feature never released, so
+ * legacy-shaped configs exist only from pre-refactor testing — but they must
+ * come back as v2, not render broken.
+ */
+describe('normalizeStoredViewConfig', () => {
+  it('converts a legacy $-object filter to a predicate tree', () => {
+    const out = normalizeStoredViewConfig({ filter: { col_a: { $eq: 'x' } } })
+    expect(out.filter).toEqual({ all: [{ field: 'col_a', op: 'eq', value: 'x' }] })
+  })
+
+  it('converts a legacy {col: dir} sort record to an ordered spec', () => {
+    const out = normalizeStoredViewConfig({ sort: { col_a: 'desc' } })
+    expect(out.sort).toEqual([{ field: 'col_a', direction: 'desc' }])
+  })
+
+  it('passes v2-shaped configs through untouched', () => {
+    const config = {
+      filter: { all: [{ field: 'col_a', op: 'eq', value: 'x' }] },
+      sort: [{ field: 'col_a', direction: 'asc' }],
+    }
+    expect(normalizeStoredViewConfig(config)).toEqual(config)
+  })
+
+  it('drops an unconvertible legacy filter rather than surfacing it broken', () => {
+    const out = normalizeStoredViewConfig({ filter: { $bogus: [{ nested: true }] } })
+    expect(out.filter).toBeNull()
+  })
+})

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

@@ -15,7 +15,15 @@ import { createLogger } from '@sim/logger'
 import { generateId } from '@sim/utils/id'
 import { and, asc, eq, ne, sql } from 'drizzle-orm'
 import { getColumnId } from '@/lib/table/column-keys'
-import type { ColumnDefinition, TableViewConfig } from '@/lib/table/types'
+import { NAME_PATTERN } from '@/lib/table/constants'
+import { filterRulesToPredicate, filterToRules } from '@/lib/table/query-builder/converters'
+import type {
+  ColumnDefinition,
+  Filter,
+  Predicate,
+  PredicateNode,
+  TableViewConfig,
+} from '@/lib/table/types'
 
 const logger = createLogger('TableViewsService')
 
@@ -69,22 +77,58 @@ export function pruneViewConfig(
     pruned.columnWidths = widths
   }
   if (config.sort) {
-    const sort: Record<string, 'asc' | 'desc'> = {}
-    for (const [id, direction] of Object.entries(config.sort)) {
-      if (live.has(id)) sort[id] = direction
-    }
-    pruned.sort = Object.keys(sort).length > 0 ? sort : null
+    const sort = config.sort.filter((s) => live.has(s.field))
+    pruned.sort = sort.length > 0 ? sort : null
   }
 
   return pruned
 }
 
+/**
+ * Migrates a config stored before the grammar switch. The feature never
+ * released, so legacy-shaped rows exist only from pre-refactor testing: a
+ * `$`-object filter converts through the builder-rule round-trip (its exact
+ * authoring domain), and a `{col: dir}` sort record becomes an ordered spec.
+ * Anything unconvertible is dropped rather than surfaced broken.
+ */
+
+/** Every leaf field in the tree is a plausible column id. */
+function predicateFieldsAreValid(node: PredicateNode): boolean {
+  if ('all' in node) return node.all.every(predicateFieldsAreValid)
+  if ('any' in node) return node.any.every(predicateFieldsAreValid)
+  return NAME_PATTERN.test((node as Predicate).field)
+}
+
+export function normalizeStoredViewConfig(raw: Record<string, unknown>): TableViewConfig {
+  const config = { ...raw } as TableViewConfig
+  const filter = raw.filter as Record<string, unknown> | null | undefined
+  if (filter && !('all' in filter) && !('any' in filter)) {
+    try {
+      const converted = filterRulesToPredicate(filterToRules(filter as Filter))
+      // The rule converters don't reject garbage — an unknown `$op` becomes a
+      // rule on a column literally named `$op`. A converted leaf whose field
+      // fails the column-name pattern proves the input wasn't builder-authored.
+      config.filter = converted && predicateFieldsAreValid(converted) ? converted : null
+    } catch {
+      config.filter = null
+    }
+  }
+  const sort = raw.sort as Record<string, 'asc' | 'desc'> | unknown[] | null | undefined
+  if (sort && !Array.isArray(sort)) {
+    config.sort = Object.entries(sort).map(([field, direction]) => ({ field, direction }))
+  }
+  return config
+}
+
 function toTableView(row: typeof tableViews.$inferSelect, columns: ColumnDefinition[]): TableView {
   return {
     id: row.id,
     tableId: row.tableId,
     name: row.name,
-    config: pruneViewConfig((row.config ?? {}) as TableViewConfig, columns),
+    config: pruneViewConfig(
+      normalizeStoredViewConfig((row.config ?? {}) as Record<string, unknown>),
+      columns
+    ),
     isDefault: row.isDefault,
     createdBy: row.createdBy,
     createdAt: row.createdAt,