fix(tables): migrate scalar cells when converting a column to select

Found by Cursor Bugbot. `resolveSelectOptionId` stringifies a number or
boolean before matching, so a `number` column whose values equal option NAMES
passes the compatibility gate — but `migrateCellsToSelectIds` only rewrote
JSONB `string` and `array` cells. Those cells stayed raw numbers inside a
select column, where they render as nothing and fail option membership on the
next write.

`data->>key` yields the text form for every scalar, so the existing lookup
already worked; the predicate was simply too narrow. Widened to cover
`number` and `boolean`. The outbound migration is unchanged — cells leaving a
select column are option ids, always strings or arrays.

Pre-existing on staging (both the resolver's scalar handling and the migration
SQL predate this branch), but it lives in a file this PR creates.

Tests pin the resolver behavior the predicate depends on, so narrowing either
one without the other now fails.

Author: waleedlatif1

apps/sim/lib/table/__tests__/column-conversion.test.ts

@@ -10,6 +10,7 @@ import {
   isValueCompatibleWithType,
   selectValueForConversion,
 } from '@/lib/table/columns/service'
+import { resolveSelectOptionId } from '@/lib/table/select-options'
 import type { ColumnDefinition, SelectOption } from '@/lib/table/types'
 
 const OPTIONS: SelectOption[] = [
@@ -194,3 +195,30 @@ describe('rename folded into another write', () => {
     expect(() => applyPendingRename(columns, 0, 'a'.repeat(200))).toThrow(/maximum length/)
   })
 })
+
+describe('select accepts scalar cells', () => {
+  // The resolver stringifies a scalar before matching, so a `number` or
+  // `boolean` column whose values equal option NAMES converts. The migration's
+  // JSONB predicate has to cover those types too — matching only `'string'`
+  // left the cells as raw numbers inside a select column, where they render as
+  // nothing and fail option membership on the next write.
+  const NUMERIC_OPTIONS: SelectOption[] = [
+    { id: 'opt_1', name: '123' },
+    { id: 'opt_t', name: 'true' },
+  ]
+
+  it('resolves a numeric or boolean cell to its option id', () => {
+    expect(resolveSelectOptionId(123, NUMERIC_OPTIONS)).toBe('opt_1')
+    expect(resolveSelectOptionId(true, NUMERIC_OPTIONS)).toBe('opt_t')
+  })
+
+  it('reports those cells as convertible, which is what obliges the migration', () => {
+    expect(isValueCompatibleWithType(123, 'select', NUMERIC_OPTIONS)).toBe(true)
+    expect(isValueCompatibleWithType(true, 'select', NUMERIC_OPTIONS)).toBe(true)
+    expect(isValueCompatibleWithType(999, 'select', NUMERIC_OPTIONS)).toBe(false)
+  })
+
+  it('leaves structured values unresolvable', () => {
+    expect(resolveSelectOptionId({ a: 1 } as never, NUMERIC_OPTIONS)).toBeNull()
+  })
+})

apps/sim/lib/table/column-types/registry.server.ts

@@ -111,6 +111,13 @@ export async function writeBackCoercedCells(
  * scalar id while multi filters compile to array containment, which a scalar
  * never matches. Either way the cell silently drops out until it is re-edited.
  *
+ * Scalar cells count, not just strings: `resolveSelectOptionId` stringifies a
+ * number or boolean before matching, so a `number` column whose values equal
+ * option NAMES passes the compatibility gate. Matching only `jsonb_typeof =
+ * 'string'` left those cells as raw numbers inside a select column, where they
+ * render as nothing and fail option membership on the next write. `data->>key`
+ * yields the text form for every scalar, so one widened predicate covers them.
+ *
  * The map keys ids, names, and lower-cased names — ids so re-running is a no-op,
  * lower-cased names because `resolveSelectOptionId` accepts a case-mismatched
  * name and a cell that passed that check must actually migrate. Duplicate option
@@ -162,7 +169,7 @@ async function migrateCellsToSelectIds(
                    ) d), '[]'::jsonb)
             END)
           WHERE table_id = ${tableId}
-            AND jsonb_typeof(data->${columnKey}::text) = 'string'`
+            AND jsonb_typeof(data->${columnKey}::text) IN ('string', 'number', 'boolean')`
     )
     await trx.execute(
       sql`UPDATE ${userTableRows}
@@ -186,7 +193,7 @@ async function migrateCellsToSelectIds(
                ELSE COALESCE(${idByRef}::jsonb -> (data->>${columnKey}::text), ${idByRef}::jsonb -> lower(data->>${columnKey}::text), data->${columnKey}::text)
           END)
         WHERE table_id = ${tableId}
-          AND jsonb_typeof(data->${columnKey}::text) = 'string'`
+          AND jsonb_typeof(data->${columnKey}::text) IN ('string', 'number', 'boolean')`
   )
   // Compatibility already rejected multi-valued cells for a single target, so
   // any array here holds at most one option.