fix(table): resolve select operands for contains/ncontains on multi-select

Caught by driving mothership at a real multi-select table. It sent a correctly
formed predicate — {field:'Color', op:'contains', value:'Teal'} — and got zero
rows with success, against a table where 15 rows hold Teal.

resolvePredicateSelectValues only resolved eq/ne/in/nin. I excluded
contains/ncontains as 'pattern ops that match the raw stored cell', which holds
for a string column but not for a multi-select: there the cell is an array of
option ids and those two ops express MEMBERSHIP, so their operand is an option
name that has to become an option id. It is the primary way to filter a
multi-select, so the one op that mattered most was the one left out.

The $-grammar sibling resolveFilterSelectValues has always handled
$contains/$ncontains for this exact reason; the omission was mine, porting it.

The remaining pattern ops (like/startsWith/...) never reach here — fieldPredicate's
select allowlist rejects them on select columns first.

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

Author: TheodoreSpeaks

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

@@ -0,0 +1,128 @@
+/**
+ * @vitest-environment node
+ *
+ * Select-column operand resolution. A select cell stores option IDs, so a filter
+ * written with the option NAME must be rewritten before it reaches SQL —
+ * otherwise it compares a name against an id and matches nothing while reporting
+ * success. Both wire grammars have to do this identically.
+ */
+import { describe, expect, it } from 'vitest'
+import { resolveFilterSelectValues, resolvePredicateSelectValues } from '@/lib/table/select-values'
+import type { ColumnDefinition } from '@/lib/table/types'
+
+const MULTI: ColumnDefinition = {
+  id: 'col_color',
+  name: 'Color',
+  type: 'select',
+  multiple: true,
+  options: [
+    { id: 'opt_teal', name: 'Teal' },
+    { id: 'opt_green', name: 'Green' },
+  ],
+}
+const SINGLE: ColumnDefinition = {
+  id: 'col_status',
+  name: 'Status',
+  type: 'select',
+  options: [{ id: 'opt_open', name: 'Open' }],
+}
+const PLAIN: ColumnDefinition = { id: 'col_name', name: 'name', type: 'string' }
+const COLS = [MULTI, SINGLE, PLAIN]
+
+const leaf = (p: unknown) => (p as { all: Array<{ value: unknown }> }).all[0]
+
+describe('resolvePredicateSelectValues', () => {
+  /**
+   * Regression: `contains`/`ncontains` were excluded as "pattern ops". On a
+   * multi-select they are not pattern ops — the cell is an array of ids and they
+   * express membership. Mothership sent exactly this and silently got zero rows.
+   */
+  it('resolves contains / ncontains on a MULTI-select (membership, not pattern)', () => {
+    for (const op of ['contains', 'ncontains'] as const) {
+      const out = resolvePredicateSelectValues(
+        { all: [{ field: 'col_color', op, value: 'Teal' }] },
+        COLS
+      )
+      expect(leaf(out).value).toBe('opt_teal')
+    }
+  })
+
+  it('resolves eq / ne / in / nin on a single select', () => {
+    expect(
+      leaf(
+        resolvePredicateSelectValues(
+          { all: [{ field: 'col_status', op: 'eq', value: 'Open' }] },
+          COLS
+        )
+      ).value
+    ).toBe('opt_open')
+    expect(
+      leaf(
+        resolvePredicateSelectValues(
+          { all: [{ field: 'col_status', op: 'in', value: ['Open'] }] },
+          COLS
+        )
+      ).value
+    ).toEqual(['opt_open'])
+  })
+
+  it('matches option names case-insensitively and passes ids through', () => {
+    expect(
+      leaf(
+        resolvePredicateSelectValues(
+          { all: [{ field: 'col_color', op: 'contains', value: 'teal' }] },
+          COLS
+        )
+      ).value
+    ).toBe('opt_teal')
+    expect(
+      leaf(
+        resolvePredicateSelectValues(
+          { all: [{ field: 'col_color', op: 'contains', value: 'opt_teal' }] },
+          COLS
+        )
+      ).value
+    ).toBe('opt_teal')
+  })
+
+  it('leaves non-select columns and unknown option names alone', () => {
+    expect(
+      leaf(
+        resolvePredicateSelectValues(
+          { all: [{ field: 'col_name', op: 'contains', value: 'Teal' }] },
+          COLS
+        )
+      ).value
+    ).toBe('Teal')
+    expect(
+      leaf(
+        resolvePredicateSelectValues(
+          { all: [{ field: 'col_color', op: 'contains', value: 'Nope' }] },
+          COLS
+        )
+      ).value
+    ).toBe('Nope')
+  })
+
+  it('recurses through nested groups', () => {
+    const out = resolvePredicateSelectValues(
+      { any: [{ all: [{ field: 'col_color', op: 'contains', value: 'Green' }] }] },
+      COLS
+    ) as { any: Array<{ all: Array<{ value: unknown }> }> }
+    expect(out.any[0].all[0].value).toBe('opt_green')
+  })
+
+  /** The two grammars must resolve the same operand set, or they drift. */
+  it('agrees with the $-grammar sibling on the same filter', () => {
+    const legacy = resolveFilterSelectValues({ col_color: { $contains: 'Teal' } }, COLS)
+    expect((legacy.col_color as { $contains: unknown }).$contains).toBe('opt_teal')
+    expect(
+      leaf(
+        resolvePredicateSelectValues(
+          { all: [{ field: 'col_color', op: 'contains', value: 'Teal' }] },
+          COLS
+        )
+      ).value
+    ).toBe('opt_teal')
+  })
+})

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

@@ -116,10 +116,14 @@ export function resolveFilterSelectValues(filter: Filter, columns: ColumnDefinit
  * op:'eq', value:'Open'}`) compares the option NAME against the stored option
  * ID and silently matches nothing.
  *
- * Only value-carrying comparison ops are resolved. Pattern ops (`contains`,
- * `like`, …) are deliberately left alone: they match against the raw stored
- * cell, and rewriting their operand to an id would change what the user asked
- * for. The valueless ops carry nothing to resolve.
+ * Mirrors the `$`-grammar set exactly: equality/membership on a single select
+ * (`eq`/`ne`/`in`/`nin`) AND `contains`/`ncontains`, which on a MULTI-select are
+ * not pattern matches at all — the cell is an array of option ids, so those ops
+ * express membership and their operand is an option, not a substring. Leaving
+ * them out is what made a correctly-formed multi-select filter match nothing.
+ * The remaining pattern ops (`like`, `startsWith`, …) are rejected on select
+ * columns by `fieldPredicate`'s allowlist, so they never reach here. The
+ * valueless ops carry nothing to resolve.
  */
 export function resolvePredicateSelectValues(
   predicate: TablePredicate,
@@ -130,7 +134,7 @@ export function resolvePredicateSelectValues(
   )
   if (selectById.size === 0) return predicate
 
-  const RESOLVED_OPS = new Set<FilterOp>(['eq', 'ne', 'in', 'nin'])
+  const RESOLVED_OPS = new Set<FilterOp>(['eq', 'ne', 'in', 'nin', 'contains', 'ncontains'])
 
   const walk = (node: PredicateNode): PredicateNode => {
     if ('all' in node) return { all: node.all.map(walk) }