fix(table): storage-validate async-route filters, reject dual-group nodes, resolve coerced select names

Bugbot round 3 on PR #6067, all three verified:

Async routes (Medium). delete-async / cancel-runs / columns/run validated only
the toLegacyFilter downgrade, which compiles a typo'd field into a clause that
silently matches nothing — a filtered delete/run/stop no-ops where the sync
bulk routes 400. tableFilterError is now grammar-aware and takes the WIRE
filter: predicates go through validateStoragePredicate (same keying the sync
routes enforce), legacy filters keep the buildFilterClause check.

Dual all/any node (High). {all:[...], any:[...]} fails both strictObject
branches, survives the legacy union, and every group-first traversal reads
`all` and silently DROPS `any` — half the conditions vanish, widening a bulk
delete/update. validateNode (covering every boundary and the copilot tool's
validatePredicate) and predicateToFilter (lossless-or-throw) both reject it;
nesting expresses the same intent unambiguously.

Coerced select names (Medium). The block builder serializes without schema
access, so an option NAME that looks numeric/boolean ("123") arrives
scalar-coerced and resolveSelectOptionId bailed on non-strings — the filter
compared 123 against the stored option id and matched nothing.
Stringify scalar operands before matching, fixing every name-keyed caller
(v1 and v2 blocks) at the resolution seam instead of per-surface.

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

@@ -47,7 +47,7 @@ export const POST = withRouteHandler(async (request: NextRequest, { params }: Ro
       return NextResponse.json({ error: 'Invalid workspace ID' }, { status: 400 })
     }
 
-    const filterError = tableFilterError(filter, table.schema.columns)
+    const filterError = tableFilterError(wireFilter, table.schema.columns)
     if (filterError) return filterError
 
     const cancelled = await cancelWorkflowGroupRuns(tableId, scope === 'row' ? rowId : undefined, {

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

@@ -43,7 +43,7 @@ export const POST = withRouteHandler(async (request: NextRequest, { params }: Ro
     if (!access.ok) return accessError(access, requestId, tableId)
 
     // Validate the filter up front (the dispatcher reuses it) so a bad field fails fast.
-    const filterError = tableFilterError(filter, access.table.schema.columns)
+    const filterError = tableFilterError(wireFilter, access.table.schema.columns)
     if (filterError) return filterError
 
     const { dispatchId } = await runWorkflowColumn({

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

@@ -78,7 +78,7 @@ export const POST = withRouteHandler(async (request: NextRequest, { params }: Ro
   assertRowDelete(table)
 
   // Validate the filter up front so the caller gets immediate feedback (the worker reuses it).
-  const filterError = tableFilterError(filter, table.schema.columns)
+  const filterError = tableFilterError(wireFilter, table.schema.columns)
   if (filterError) return filterError
 
   // Rows inserted after this instant are spared (created_at <= cutoff in the worker).

apps/sim/app/api/table/utils.test.ts

@@ -3,7 +3,8 @@
  */
 import { describe, expect, it } from 'vitest'
 import { TableRowLimitError } from '@/lib/table/billing'
-import { rootErrorMessage, rowWriteErrorResponse } from '@/app/api/table/utils'
+import type { ColumnDefinition } from '@/lib/table/types'
+import { rootErrorMessage, rowWriteErrorResponse, tableFilterError } from '@/app/api/table/utils'
 
 /** Mimics drizzle's DrizzleQueryError: message is the failed SQL, real error on `cause`. */
 function wrapLikeDrizzle(cause: Error): Error {
@@ -53,3 +54,50 @@ describe('rowWriteErrorResponse', () => {
     expect(rowWriteErrorResponse(wrapLikeDrizzle(new Error('deadlock detected')))).toBeNull()
   })
 })
+
+/**
+ * The async destructive routes (delete-async, cancel-runs, columns/run)
+ * validate the WIRE filter here. The predicate branch must reject unknown
+ * storage keys the way the sync bulk routes do — the `toLegacyFilter`
+ * downgrade compiles a typo'd field into a clause that silently matches
+ * nothing, turning a scoped delete/run into a no-op.
+ */
+describe('tableFilterError', () => {
+  const columns: ColumnDefinition[] = [{ id: 'col_status', name: 'status', type: 'string' }]
+
+  it('returns null for an absent filter and a valid id-keyed predicate', () => {
+    expect(tableFilterError(undefined, columns)).toBeNull()
+    expect(
+      tableFilterError({ all: [{ field: 'col_status', op: 'eq', value: 'x' }] }, columns)
+    ).toBeNull()
+    expect(tableFilterError({ all: [{ field: 'createdAt', op: 'isNotNull' }] }, columns)).toBeNull()
+  })
+
+  it('400s a predicate naming an unknown storage key', async () => {
+    const response = tableFilterError(
+      { all: [{ field: 'statuss', op: 'eq', value: 'x' }] },
+      columns
+    )
+    expect(response?.status).toBe(400)
+    const body = await response?.json()
+    expect(body.error).toMatch(/Unknown filter column "statuss"/)
+  })
+
+  it('400s a structurally invalid predicate (empty group, dual group keys)', () => {
+    expect(tableFilterError({ all: [] } as never, columns)?.status).toBe(400)
+    expect(
+      tableFilterError(
+        {
+          all: [{ field: 'col_status', op: 'eq', value: 'a' }],
+          any: [{ field: 'col_status', op: 'eq', value: 'b' }],
+        } as never,
+        columns
+      )?.status
+    ).toBe(400)
+  })
+
+  it('still validates the legacy grammar through buildFilterClause', () => {
+    expect(tableFilterError({ col_status: 'x' }, columns)).toBeNull()
+    expect(tableFilterError({ col_status: { $regex: 'x' } } as never, columns)?.status).toBe(400)
+  })
+})

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

@@ -9,10 +9,12 @@ import {
 } from '@/lib/api/contracts/tables'
 import { isFeatureEnabled } from '@/lib/core/config/feature-flags'
 import type { MultipartError } from '@/lib/core/utils/multipart'
-import type { ColumnDefinition, Filter, TableDefinition } from '@/lib/table'
+import type { ColumnDefinition, Filter, TableDefinition, TablePredicate } from '@/lib/table'
 import { buildFilterClause, getTableById, TableQueryValidationError } from '@/lib/table'
 import { USER_TABLE_ROWS_SQL_NAME } from '@/lib/table/constants'
 import { TableLockedError } from '@/lib/table/mutation-locks'
+import { isTablePredicate } from '@/lib/table/query-builder/converters'
+import { validateStoragePredicate } from '@/lib/table/query-builder/validate'
 import { getUserEntityPermissions } from '@/lib/workspaces/permissions/utils'
 import { getWorkspaceOrganizationId } from '@/lib/workspaces/utils'
 
@@ -54,17 +56,30 @@ export function tableLockErrorResponse(error: unknown): NextResponse | null {
 }
 
 /**
- * Validates a `filter` against the table's column schema, returning a 400 response on a bad field
- * (or `null` when the filter is valid or absent). Shared by the routes that accept a filter
- * (`delete-async`, `columns/run`) so a bad field fails fast with a clear message.
+ * Validates a wire `filter` (either grammar) against the table's column schema,
+ * returning a 400 response on a bad field (or `null` when the filter is valid or
+ * absent). Shared by the routes that accept a filter (`delete-async`,
+ * `cancel-runs`, `columns/run`) so a bad field fails fast with a clear message.
+ *
+ * Pass the WIRE filter, not the `toLegacyFilter` downgrade: the downgrade
+ * compiles cleanly through `buildFilterClause` even when a predicate leaf names
+ * a column that doesn't exist, so validating only the downgraded form lets a
+ * typo'd field become a clause that silently matches nothing — a no-op where
+ * the sync bulk routes 400.
  */
 export function tableFilterError(
-  filter: Filter | undefined,
+  filter: Filter | TablePredicate | undefined,
   columns: ColumnDefinition[]
 ): NextResponse | null {
   if (!filter) return null
   try {
-    buildFilterClause(filter, USER_TABLE_ROWS_SQL_NAME, columns)
+    if (isTablePredicate(filter)) {
+      // These routes speak storage keys (session grid uses column ids; system
+      // columns keep their names) — same keying the sync bulk routes validate.
+      validateStoragePredicate(filter, columns)
+    } else {
+      buildFilterClause(filter, USER_TABLE_ROWS_SQL_NAME, columns)
+    }
     return null
   } catch (error) {
     if (error instanceof TableQueryValidationError) {

apps/sim/lib/table/query-builder/__tests__/converters.test.ts

@@ -468,6 +468,15 @@ describe('toLegacyFilter / predicateToFilter hybrid safety', () => {
     expect(() => predicateToFilter(hybrid)).toThrow(/not both/)
   })
 
+  it('throws on a node with both group keys instead of dropping the "any" half', () => {
+    const dual = {
+      all: [{ field: 'tenant_id', op: 'eq', value: 'acme' }],
+      any: [{ field: 'status', op: 'eq', value: 'archived' }],
+    } as never
+    expect(() => predicateToFilter(dual)).toThrow(/either "all" or "any"/)
+    expect(() => toLegacyFilter(dual)).toThrow(/either "all" or "any"/)
+  })
+
   it('toLegacyFilter shape-validates before converting', () => {
     expect(() => toLegacyFilter(hybrid)).toThrow(/not both/)
     // malformed group value is also caught, not crashed on

apps/sim/lib/table/query-builder/__tests__/validate.test.ts

@@ -143,6 +143,20 @@ describe('validatePredicate — leaves that would silently widen a bulk write',
     ).toThrow(/not both/)
   })
 
+  it('rejects a node carrying both group keys instead of dropping the "any" half', () => {
+    // Every group-first traversal reads `all` and drops `any` — half the
+    // caller's conditions would vanish, widening a bulk delete/update.
+    expect(() =>
+      validatePredicate(
+        {
+          all: [{ field: 'status', op: 'eq', value: 'archived' }],
+          any: [{ field: 'status', op: 'eq', value: 'stale' }],
+        } as never,
+        COLS
+      )
+    ).toThrow(/either "all" or "any"/)
+  })
+
   it('caps in/nin list length', () => {
     const huge = Array.from({ length: 1001 }, (_, i) => `v${i}`)
     expect(() =>

apps/sim/lib/table/query-builder/converters.ts

@@ -475,6 +475,14 @@ export function predicateToFilter(predicate: TablePredicate): Filter {
         'INVALID_FILTER'
       )
     }
+    // A node with BOTH group keys would convert `all` and silently drop `any`
+    // — same widening failure as the hybrid above. Lossless-or-throw.
+    if ('all' in node && 'any' in node) {
+      throw new TableQueryValidationError(
+        'A filter group must use either "all" or "any", not both — nest one group inside the other instead.',
+        'INVALID_FILTER'
+      )
+    }
     // Group-first, matching isPredicateGroup/validateNode/buildPredicateNode. A
     // leaf-first test would execute a different predicate than the one validated.
     if ('all' in node) return { $and: node.all.map(nodeToFilter) }

apps/sim/lib/table/query-builder/validate.ts

@@ -137,6 +137,17 @@ function validateNode(node: PredicateNode, typeByName: Map<string, ColumnType> |
       'INVALID_FILTER'
     )
   }
+  // Same ambiguity with BOTH group keys: every group-first traversal
+  // (`predicateNamesToIds`, `predicateToFilter`, `buildPredicateNode`) reads
+  // `all` and silently DROPS `any`, so half the caller's conditions vanish —
+  // on a bulk delete/update that widens the matched set. Reject rather than
+  // pick a winner; nesting expresses the intent unambiguously.
+  if ('all' in node && 'any' in node) {
+    throw new TableQueryValidationError(
+      'A filter group must use either "all" or "any", not both — nest one group inside the other instead.',
+      'INVALID_FILTER'
+    )
+  }
   if ('all' in node || 'any' in node) {
     const members = 'all' in node ? node.all : node.any
     if (!Array.isArray(members)) {

apps/sim/lib/table/select-values.test.ts

@@ -2,7 +2,11 @@
  * @vitest-environment node
  */
 import { describe, expect, it } from 'vitest'
-import { resolveFilterSelectValues, selectValueToNames } from '@/lib/table/select-values'
+import {
+  resolveFilterSelectValues,
+  resolvePredicateSelectValues,
+  selectValueToNames,
+} from '@/lib/table/select-values'
 import type { ColumnDefinition } from '@/lib/table/types'
 
 const status: ColumnDefinition = {
@@ -100,3 +104,49 @@ describe('resolveFilterSelectValues', () => {
     ).toEqual({ $or: [{ col_status: 'opt_open' }, { col_title: 'x' }] })
   })
 })
+
+/**
+ * The block builder serializes without schema access, so an option NAME that
+ * looks numeric or boolean arrives scalar-coerced ("123" → 123). Resolution
+ * must still find the option, or a correctly-authored builder filter compares
+ * a number against the stored id string and matches nothing.
+ */
+describe('resolvePredicateSelectValues — scalar-coerced option names', () => {
+  const numericStatus: ColumnDefinition = {
+    id: 'col_code',
+    name: 'code',
+    type: 'select',
+    options: [
+      { id: 'opt_123', name: '123' },
+      { id: 'opt_true', name: 'true' },
+    ],
+  }
+  const columns = [numericStatus]
+
+  it('resolves a coerced numeric name to its option id', () => {
+    expect(
+      resolvePredicateSelectValues({ all: [{ field: 'col_code', op: 'eq', value: 123 }] }, columns)
+    ).toEqual({ all: [{ field: 'col_code', op: 'eq', value: 'opt_123' }] })
+  })
+
+  it('resolves a coerced boolean name, including inside in/contains', () => {
+    expect(
+      resolvePredicateSelectValues(
+        { any: [{ field: 'col_code', op: 'in', value: [true, 123] }] },
+        columns
+      )
+    ).toEqual({ any: [{ field: 'col_code', op: 'in', value: ['opt_true', 'opt_123'] }] })
+    expect(
+      resolvePredicateSelectValues(
+        { all: [{ field: 'col_code', op: 'contains', value: 123 }] },
+        columns
+      )
+    ).toEqual({ all: [{ field: 'col_code', op: 'contains', value: 'opt_123' }] })
+  })
+
+  it('leaves a scalar with no matching option name as-is', () => {
+    expect(
+      resolvePredicateSelectValues({ all: [{ field: 'col_code', op: 'eq', value: 999 }] }, columns)
+    ).toEqual({ all: [{ field: 'col_code', op: 'eq', value: 999 }] })
+  })
+})