refactor(table): move the grid onto the v2 predicate grammar (Track C)

The grid was the last surface authoring the legacy `$`-grammar, which forced
views to downgrade on apply and upgrade on save, and kept five wire fields
legacy-only. Its runtime state, filter bar, and every request it makes now
speak `TablePredicate`/`SortSpec`.

Wire: the five grid-carrying fields (rows GET filter+sort, find filter+sort,
delete-async, cancel-runs, columns-run) accept a dual-grammar union — strict
predicate tree first, legacy fallback — so external v1 callers are untouched.
The rows read path takes predicates NATIVELY into queryRows (no downgrade);
the job/dispatch routes downgrade via predicateToFilter at entry, which throws
on any leaf the legacy compiler would silently discard, so persisted job
payloads stay legacy and the runners are untouched.

Grid: filter state is TablePredicate, the filter bar converts rules with
filterRulesToPredicate — now select-aware (a numeric-looking option id is no
longer scalar-coerced, matching filterRulesToFilter) — and stale-operator
pruning uses a new prunePredicateForColumns that fails CLOSED to "no filter"
on malformed values instead of taking the page down. The view apply/save
boundary conversions added earlier are deleted: views and grid now share one
grammar end to end.

isTablePredicate moved from a route-local into converters as the shared
dual-wire discriminator; toLegacyFilter/toLegacySort live there too (pure
grammar code — keeping them in app/api/table/utils broke every test that
wholesale-mocks that module).

Legacy converters now have exactly one live consumer: the v1 table block,
whose tools still speak the $-wire by contract.

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

Author: TheodoreSpeaks

apps/sim/app/api/table/[tableId]/cancel-runs/route.ts

@@ -5,6 +5,7 @@ import { parseRequest } from '@/lib/api/server'
 import { checkSessionOrInternalAuth } from '@/lib/auth/hybrid'
 import { generateRequestId } from '@/lib/core/utils/request'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { toLegacyFilter } from '@/lib/table/query-builder/converters'
 import { cancelWorkflowGroupRuns } from '@/lib/table/workflow-columns'
 import { accessError, checkAccess, tableFilterError } from '@/app/api/table/utils'
 
@@ -32,7 +33,10 @@ export const POST = withRouteHandler(async (request: NextRequest, { params }: Ro
     const parsed = await parseRequest(cancelTableRunsContract, request, { params })
     if (!parsed.success) return parsed.response
     const { tableId } = parsed.data.params
-    const { workspaceId, scope, rowId, filter, excludeRowIds } = parsed.data.body
+    const { workspaceId, scope, rowId, filter: wireFilter, excludeRowIds } = parsed.data.body
+    // Dual-grammar wire: a predicate downgrades losslessly-or-throws to the
+    // legacy Filter the runners/persisted payloads still compile.
+    const filter = toLegacyFilter(wireFilter)
 
     const result = await checkAccess(tableId, authResult.userId, 'write')
     if (!result.ok) return accessError(result, requestId, tableId)

apps/sim/app/api/table/[tableId]/columns/run/route.ts

@@ -5,6 +5,7 @@ import { parseRequest } from '@/lib/api/server'
 import { checkSessionOrInternalAuth } from '@/lib/auth/hybrid'
 import { generateRequestId } from '@/lib/core/utils/request'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { toLegacyFilter } from '@/lib/table/query-builder/converters'
 import { runWorkflowColumn } from '@/lib/table/workflow-columns'
 import { accessError, checkAccess, tableFilterError } from '@/app/api/table/utils'
 
@@ -25,8 +26,18 @@ export const POST = withRouteHandler(async (request: NextRequest, { params }: Ro
     const parsed = await parseRequest(runColumnContract, request, { params })
     if (!parsed.success) return parsed.response
     const { tableId } = parsed.data.params
-    const { workspaceId, groupIds, runMode, rowIds, filter, excludeRowIds, limit } =
-      parsed.data.body
+    const {
+      workspaceId,
+      groupIds,
+      runMode,
+      rowIds,
+      filter: wireFilter,
+      excludeRowIds,
+      limit,
+    } = parsed.data.body
+    // Dual-grammar wire: downgrade a predicate to the legacy Filter the
+    // dispatcher and scheduled runs still compile.
+    const filter = toLegacyFilter(wireFilter)
     const access = await checkAccess(tableId, auth.userId, 'write')
     if (!access.ok) return accessError(access, requestId, tableId)
 

apps/sim/app/api/table/[tableId]/delete-async/route.ts

@@ -11,6 +11,7 @@ import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
 import { markTableDeleteFailed, runTableDelete } from '@/lib/table/delete-runner'
 import { markTableJobRunning, releaseJobClaim } from '@/lib/table/jobs/service'
 import { assertRowDelete } from '@/lib/table/mutation-locks'
+import { toLegacyFilter } from '@/lib/table/query-builder/converters'
 import type { TableDeleteJobPayload } from '@/lib/table/types'
 import { accessError, checkAccess, tableFilterError } from '@/app/api/table/utils'
 
@@ -43,7 +44,10 @@ export const POST = withRouteHandler(async (request: NextRequest, { params }: Ro
   const parsed = await parseRequest(deleteTableRowsAsyncContract, request, { params })
   if (!parsed.success) return parsed.response
   const { tableId } = parsed.data.params
-  const { workspaceId, filter, excludeRowIds, estimatedCount } = parsed.data.body
+  const { workspaceId, filter: wireFilter, excludeRowIds, estimatedCount } = parsed.data.body
+  // Dual-grammar wire: a predicate downgrades losslessly-or-throws to the
+  // legacy Filter the runners/persisted payloads still compile.
+  const filter = toLegacyFilter(wireFilter)
 
   const access = await checkAccess(tableId, userId, 'write')
   if (!access.ok) return accessError(access, requestId, tableId)

apps/sim/app/api/table/[tableId]/rows/find/route.ts

@@ -5,8 +5,9 @@ import { isZodError, validationErrorResponse } from '@/lib/api/server/validation
 import { checkSessionOrInternalAuth } from '@/lib/auth/hybrid'
 import { generateRequestId } from '@/lib/core/utils/request'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
-import type { Sort } from '@/lib/table'
+import type { Filter, Sort, SortSpec, TablePredicate } from '@/lib/table'
 import { TableQueryValidationError } from '@/lib/table/errors'
+import { toLegacyFilter, toLegacySort } from '@/lib/table/query-builder/converters'
 import { findRowMatches } from '@/lib/table/rows/service'
 import { accessError, checkAccess } from '@/app/api/table/utils'
 
@@ -60,7 +61,12 @@ export const GET = withRouteHandler(
 
       const { matches, truncated } = await findRowMatches(
         table,
-        { q: validated.q, filter: validated.filter, sort: validated.sort },
+        {
+          q: validated.q,
+          // Dual-grammar wire: findRowMatches compiles the legacy pair.
+          filter: toLegacyFilter(validated.filter as Filter | TablePredicate | undefined),
+          sort: toLegacySort(validated.sort as Sort | SortSpec | undefined),
+        },
         requestId
       )
 

apps/sim/app/api/table/[tableId]/rows/route.test.ts

@@ -226,6 +226,42 @@ describe('GET /api/table/[tableId]/rows', () => {
     const body = await res.json()
     expect(body.data.rows[0].data).toEqual({ col_aaa: 'Ada', col_bbb: 36 })
   })
+
+  /**
+   * The grid now speaks the v2 grammar on this route: a predicate-shaped filter
+   * takes the NATIVE predicate path into queryRows (not a downgrade), and an
+   * ordered sort spec compiles to the record the engine's sort builder takes.
+   */
+  it('routes a predicate filter + spec sort natively for session callers', async () => {
+    authAs('session')
+
+    const res = await callGet({
+      workspaceId: 'workspace-1',
+      filter: JSON.stringify({ all: [{ field: 'col_aaa', op: 'eq', value: 'Ada' }] }),
+      sort: JSON.stringify([{ field: 'col_bbb', direction: 'desc' }]),
+    })
+
+    expect(res.status).toBe(200)
+    const options = mockQueryRows.mock.calls[0][1]
+    expect(options.predicate).toEqual({ all: [{ field: 'col_aaa', op: 'eq', value: 'Ada' }] })
+    expect(options.filter).toBeUndefined()
+    expect(options.sort).toEqual({ col_bbb: 'desc' })
+  })
+
+  it('translates a name-keyed predicate for internal-JWT callers', async () => {
+    authAs('internal_jwt')
+
+    const res = await callGet({
+      workspaceId: 'workspace-1',
+      filter: JSON.stringify({ all: [{ field: 'Name', op: 'eq', value: 'Ada' }] }),
+      sort: JSON.stringify([{ field: 'Age', direction: 'asc' }]),
+    })
+
+    expect(res.status).toBe(200)
+    const options = mockQueryRows.mock.calls[0][1]
+    expect(options.predicate).toEqual({ all: [{ field: 'col_aaa', op: 'eq', value: 'Ada' }] })
+    expect(options.sort).toEqual({ col_bbb: 'asc' })
+  })
 })
 
 describe('PUT/DELETE /api/table/[tableId]/rows — predicate filters', () => {

apps/sim/app/api/table/[tableId]/rows/route.ts

@@ -13,7 +13,7 @@ import { isZodError, parseJsonBody, validationErrorResponse } from '@/lib/api/se
 import { type AuthTypeValue, checkSessionOrInternalAuth } from '@/lib/auth/hybrid'
 import { generateRequestId } from '@/lib/core/utils/request'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
-import type { Filter, RowData, Sort, TableRowsCursor, TableSchema } from '@/lib/table'
+import type { Filter, RowData, Sort, SortSpec, TableRowsCursor, TableSchema } from '@/lib/table'
 import {
   batchInsertRows,
   batchUpdateRows,
@@ -26,7 +26,7 @@ import {
   validateRowSize,
 } from '@/lib/table'
 import { TableQueryValidationError } from '@/lib/table/errors'
-import { predicateToFilter } from '@/lib/table/query-builder/converters'
+import { isTablePredicate, predicateToFilter } from '@/lib/table/query-builder/converters'
 import { validatePredicate } from '@/lib/table/query-builder/validate'
 import { queryRows } from '@/lib/table/rows/service'
 import { predicateToStorage } from '@/lib/table/select-values'
@@ -36,8 +36,15 @@ import { accessError, checkAccess, rowWriteErrorResponse } from '@/app/api/table
 
 const logger = createLogger('TableRowsAPI')
 
-function isTablePredicate(raw: TablePredicate | Filter): raw is TablePredicate {
-  return 'all' in raw || 'any' in raw
+/** Dual-grammar sort: an ordered spec (v2) or the legacy record, either keying. */
+function resolveWireSort(
+  sort: Sort | SortSpec | undefined,
+  wire: RowWireTranslators
+): Sort | undefined {
+  if (!sort) return undefined
+  if (!Array.isArray(sort)) return wire.sortIn(sort)
+  const spec = wire.sortSpecIn(sort)
+  return spec.length > 0 ? Object.fromEntries(spec.map((s) => [s.field, s.direction])) : undefined
 }
 
 /**
@@ -286,8 +293,10 @@ export const GET = withRouteHandler(
       const result = await queryRows(
         table,
         {
-          filter: validated.filter ? wire.filterIn(validated.filter as Filter) : undefined,
-          sort: validated.sort ? wire.sortIn(validated.sort) : undefined,
+          ...(validated.filter && isTablePredicate(validated.filter as Filter | TablePredicate)
+            ? { predicate: wire.predicateIn(validated.filter as TablePredicate) }
+            : { filter: validated.filter ? wire.filterIn(validated.filter as Filter) : undefined }),
+          sort: resolveWireSort(validated.sort as Sort | SortSpec | undefined, wire),
           limit: validated.limit,
           offset: validated.offset,
           after: validated.after,

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

@@ -4,15 +4,18 @@ import { memo, useCallback, useMemo, useRef, useState } from 'react'
 import { Button, ChipDropdown, ChipInput } from '@sim/emcn'
 import { Plus, X } from '@sim/emcn/icons'
 import { generateShortId } from '@sim/utils/id'
-import type { ColumnDefinition, Filter, FilterRule } from '@/lib/table'
+import type { ColumnDefinition, FilterRule, TablePredicate } from '@/lib/table'
 import { getColumnId } from '@/lib/table/column-keys'
 import {
   COMPARISON_OPERATORS,
   MULTI_SELECT_FILTER_OPERATORS,
   SINGLE_SELECT_FILTER_OPERATORS,
   VALUELESS_OPERATORS,
 } from '@/lib/table/query-builder/constants'
-import { filterRulesToFilter, filterToRules } from '@/lib/table/query-builder/converters'
+import {
+  filterRulesToPredicate,
+  predicateToFilterRules,
+} from '@/lib/table/query-builder/converters'
 
 const SINGLE_SELECT_COMPARISON_OPERATORS = COMPARISON_OPERATORS.filter((o) =>
   SINGLE_SELECT_FILTER_OPERATORS.has(o.value)
@@ -27,14 +30,14 @@ function selectFilterOperators(column: ColumnDefinition | undefined): Set<string
 
 interface TableFilterProps {
   columns: ColumnDefinition[]
-  filter: Filter | null
-  onApply: (filter: Filter | null) => void
+  filter: TablePredicate | null
+  onApply: (filter: TablePredicate | null) => void
   onClose: () => void
 }
 
 export function TableFilter({ columns, filter, onApply, onClose }: TableFilterProps) {
   const [rules, setRules] = useState<FilterRule[]>(() => {
-    const fromFilter = filterToRules(filter)
+    const fromFilter = predicateToFilterRules(filter)
     return fromFilter.length > 0 ? fromFilter : [createRule(columns)]
   })
 
@@ -112,7 +115,7 @@ export function TableFilter({ columns, filter, onApply, onClose }: TableFilterPr
     const validRules = rulesRef.current.filter(
       (r) => r.column && (r.value || VALUELESS_OPERATORS.has(r.operator))
     )
-    onApply(filterRulesToFilter(validRules, columns))
+    onApply(filterRulesToPredicate(validRules, columns))
   }, [columns, onApply])
 
   const handleClear = useCallback(() => {

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

@@ -13,9 +13,9 @@ import type { RunLimit, RunMode, TableFindMatch } from '@/lib/api/contracts/tabl
 import { captureEvent } from '@/lib/posthog/client'
 import type {
   ColumnDefinition,
-  Filter,
   TableLocks,
   TableMetadata,
+  TablePredicate,
   TableRow as TableRowType,
   WorkflowGroup,
 } from '@/lib/table'
@@ -121,7 +121,7 @@ export interface SelectionSnapshot {
     allRows: boolean
     rowCount: number
     /** Active filter when `allRows` is set — lets a filtered "select all" run only matching rows. */
-    filter?: Filter
+    filter?: TablePredicate
     /** Deselected rows when `allRows` is set — runs/stops skip them. */
     excludeRowIds?: string[]
   } | null
@@ -199,7 +199,7 @@ interface TableGridProps {
     runMode: RunMode,
     rowIds?: string[],
     limit?: RunLimit,
-    filter?: Filter,
+    filter?: TablePredicate,
     excludeRowIds?: string[]
   ) => void
   /** Fire every runnable column on a single row (per-row gutter Play). */
@@ -209,14 +209,14 @@ interface TableGridProps {
   onRunRows: (
     rowIds: string[] | undefined,
     runMode: RunMode,
-    filter?: Filter,
+    filter?: TablePredicate,
     excludeRowIds?: string[]
   ) => void
   /** Stop running workflows on `rowIds`. Per-row gutter Stop also funnels through here. */
   onStopRows: (rowIds: string[]) => void
   /** Select-all Stop: table-wide, or scoped to the active filter when one is set.
    *  `excludeRowIds` (deselected rows) keep running. */
-  onStopAllRows: (filter?: Filter, excludeRowIds?: string[]) => void
+  onStopAllRows: (filter?: TablePredicate, excludeRowIds?: string[]) => void
   /** Single-row stop for the per-row gutter button. */
   onStopRow: (rowId: string) => void
   /**

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/hooks/use-table.test.ts

@@ -218,7 +218,7 @@ describe('useTable – ensureAllRowsLoaded', () => {
   })
 
   it('encodes queryOptions.filter into the queryKey passed to getQueryData', async () => {
-    const filter = { column: 'name', operator: 'eq', value: 'Alice' } as never
+    const filter = { all: [{ field: 'name', op: 'eq' as const, value: 'Alice' }] }
     mockGetQueryData.mockReturnValue({ pages: makePages([3], 3) })
     const { ensureAllRowsLoaded } = makeHook({ filter, sort: null })
     await ensureAllRowsLoaded()

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/hooks/use-table.ts

@@ -4,13 +4,13 @@ import { useCallback, useMemo } from 'react'
 import { useQueryClient } from '@tanstack/react-query'
 import type {
   ColumnDefinition,
-  Filter,
   TableDefinition,
+  TablePredicate,
   TableRow,
   WorkflowGroup,
 } from '@/lib/table'
 import { TABLE_LIMITS } from '@/lib/table/constants'
-import { pruneFilterForColumns } from '@/lib/table/query-builder/converters'
+import { prunePredicateForColumns } from '@/lib/table/query-builder/converters'
 import type { FlattenOutputsBlockInput } from '@/lib/workflows/blocks/flatten-outputs'
 import { getBlock } from '@/blocks'
 import {
@@ -51,7 +51,7 @@ export interface UseTableReturn {
    * select-all run/stop/delete — must scope with THIS, not the raw filter, or
    * the action targets a predicate the grid isn't displaying.
    */
-  filter: Filter | null
+  filter: TablePredicate | null
   isLoadingRows: boolean
   refetchRows: () => void
   /**
@@ -98,7 +98,7 @@ export function useTable({ workspaceId, tableId, queryOptions }: UseTableParams)
   // here, above every consumer of the rows query key, so the paged helpers below
   // can't rebuild the key from the unpruned filter and drift.
   const filter = useMemo(
-    () => pruneFilterForColumns(queryOptions.filter ?? null, tableData?.schema?.columns ?? []),
+    () => prunePredicateForColumns(queryOptions.filter ?? null, tableData?.schema?.columns ?? []),
     [queryOptions.filter, tableData?.schema?.columns]
   )