fix(tables): gate the v2 filter pruner on the v2 grammar

`prunePredicateForColumns` guards a saved predicate against operators a select
column no longer accepts, but it checked the legacy UI set. The two grammars are
deliberately not 1:1 — `isNull`/`isNotNull` are meaningful on a select column
and have no `$` equivalent — so a saved v2 predicate using either was stripped
client-side before the rows query ran, silently widening the filter rather than
narrowing it.

It now asks `predicateOperatorsFor`, the same registry answer the SQL leaf uses,
so the pruner and the query can no longer disagree about what is allowed. Its
legacy sibling stays on the UI set, which is correctly aligned with the `$`
grammar's own allowlist.

Author: waleedlatif1

apps/sim/lib/table/__tests__/column-types-contact.test.ts

@@ -21,7 +21,7 @@ import {
   pickMetadata,
 } from '@/lib/table/column-types'
 import { coerceValue } from '@/lib/table/import'
-import { filterRulesToFilter } from '@/lib/table/query-builder/converters'
+import { filterRulesToFilter, prunePredicateForColumns } from '@/lib/table/query-builder/converters'
 import type { ColumnDefinition } from '@/lib/table/types'
 
 const column = (type: ColumnDefinition['type'], extra: Partial<ColumnDefinition> = {}) =>
@@ -296,6 +296,31 @@ describe('review-round-2 regressions', () => {
   })
 })
 
+describe('review-round-4 regressions', () => {
+  const selectColumn: ColumnDefinition = {
+    id: 'c',
+    name: 'c',
+    type: 'select',
+    options: [{ id: 'opt_1', name: 'One' }],
+  }
+
+  it('keeps isNull/isNotNull on a select column through the v2 pruner', () => {
+    // The v2 SQL leaf accepts them (they are meaningful on any column and have
+    // no `$` equivalent); gating the pruner on the legacy set stripped them
+    // client-side before the query ran, silently widening the filter.
+    for (const op of ['isNull', 'isNotNull'] as const) {
+      const predicate = { all: [{ field: 'c', op }] } as const
+      expect(prunePredicateForColumns(predicate, [selectColumn]), op).toEqual(predicate)
+    }
+  })
+
+  it('still prunes an operator the select grammar genuinely strands', () => {
+    // A `contains` left behind by a multi -> single toggle must still go.
+    const predicate = { all: [{ field: 'c', op: 'contains' as const, value: 'opt_1' }] }
+    expect(prunePredicateForColumns(predicate, [selectColumn])).toBeNull()
+  })
+})
+
 describe('date includeTime', () => {
   it('truncates to a calendar day only when includeTime is explicitly false', () => {
     const dateOnly = column('date', { includeTime: false })

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

@@ -5,7 +5,7 @@
 import { generateShortId } from '@sim/utils/id'
 import { isRecordLike } from '@sim/utils/object'
 import { columnMatchesRef } from '@/lib/table/column-keys'
-import { columnTypeOf, storesMultipleValues } from '@/lib/table/column-types'
+import { columnTypeOf, predicateOperatorsFor, storesMultipleValues } from '@/lib/table/column-types'
 import { TableQueryValidationError } from '@/lib/table/errors'
 import {
   MULTI_SELECT_FILTER_OPERATORS,
@@ -125,6 +125,12 @@ export function pruneFilterForColumns(
  * Predicate-grammar sibling of {@link pruneFilterForColumns}: drops conditions a
  * `select` column no longer accepts (operator stranded by a type/`multiple`
  * change), so a stale applied filter can't fail every subsequent rows query.
+ *
+ * Gated on `predicateOperatorsFor` — the **v2** allowlist — not on the UI sets
+ * its legacy sibling uses. The two grammars are deliberately not 1:1:
+ * `isNull`/`isNotNull` are meaningful on a select column and have no `$`
+ * equivalent, so gating this on the legacy set stripped a saved predicate that
+ * the rows query would have accepted, silently widening the filter.
  */
 export function prunePredicateForColumns(
   predicate: TablePredicate | null,
@@ -138,11 +144,9 @@ export function prunePredicateForColumns(
   const rules = predicateToFilterRules(predicate)
   const kept = rules.filter((rule) => {
     const column = columns.find((c) => columnMatchesRef(c, rule.column))
-    if (!column || !columnTypeOf(column).storesOpaqueIds) return true
-    const allowed = storesMultipleValues(column)
-      ? MULTI_SELECT_FILTER_OPERATORS
-      : SINGLE_SELECT_FILTER_OPERATORS
-    return allowed.has(rule.operator)
+    if (!column) return true
+    const allowed = predicateOperatorsFor(column)
+    return allowed === null || allowed.has(rule.operator)
   })
 
   if (kept.length === rules.length) return predicate