fix(tables): let a multiselect round-trip through text

Converting multiselect to text flattens cells to `Alpha, Beta`, but
converting back read that as one unknown option and rejected the change.
Both the compatibility check and the cell migration now split a comma
string the way the write path already did, through one shared helper.

Author: TheodoreSpeaks

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

@@ -68,6 +68,20 @@ describe('isValueCompatibleWithType — select cardinality', () => {
   it('rejects a value that is not a declared option', () => {
     expect(isValueCompatibleWithType('gone', 'select', OPTIONS, false)).toBe(false)
   })
+
+  it('round-trips a multiselect through text', () => {
+    // multiselect → string flattens to `Alpha, Beta`; converting back must read
+    // that the same way the write-path coercion does, not as one unknown option.
+    const flattened = selectValueForConversion(multi, ['opt_a', 'opt_b'])
+    expect(flattened).toBe('Alpha, Beta')
+    expect(isValueCompatibleWithType(flattened, 'select', OPTIONS, true)).toBe(true)
+    // A single-select target genuinely can't hold both.
+    expect(isValueCompatibleWithType(flattened, 'select', OPTIONS, false)).toBe(false)
+  })
+
+  it('still rejects a comma string holding an undeclared option', () => {
+    expect(isValueCompatibleWithType('Alpha, Gone', 'select', OPTIONS, true)).toBe(false)
+  })
 })
 
 describe('isValueCompatibleWithType — string target', () => {

apps/sim/lib/table/columns/service.ts

@@ -34,7 +34,11 @@ import type {
   UpdateColumnOptionsData,
   UpdateColumnTypeData,
 } from '@/lib/table/types'
-import { resolveSelectOptionId, validateColumnDefinition } from '@/lib/table/validation'
+import {
+  resolveSelectOptionId,
+  splitMultiSelectInput,
+  validateColumnDefinition,
+} from '@/lib/table/validation'
 import { assertValidSchema, stripGroupDeps } from '@/lib/table/workflow-columns'
 
 const logger = createLogger('TableColumnService')
@@ -881,11 +885,25 @@ async function migrateCellsToSelectIds(
   )
 
   if (multiple) {
+    // A string cell reaching a multi target is either one option name or the
+    // comma-joined form a multiselect converts to text as. Try the whole string
+    // first so an option whose own name contains a comma still wins, then split
+    // — mirroring `splitMultiSelectInput` on the write path, including its
+    // first-occurrence dedup.
     await trx.execute(
       sql`UPDATE ${userTableRows}
           SET data = jsonb_set(data, ARRAY[${columnKey}::text],
             CASE WHEN data->>${columnKey}::text = '' THEN '[]'::jsonb
-                 ELSE jsonb_build_array(COALESCE(${idByRef}::jsonb -> (data->>${columnKey}::text), ${idByRef}::jsonb -> lower(data->>${columnKey}::text), data->${columnKey}::text))
+                 WHEN COALESCE(${idByRef}::jsonb -> (data->>${columnKey}::text), ${idByRef}::jsonb -> lower(data->>${columnKey}::text)) IS NOT NULL
+                   THEN jsonb_build_array(COALESCE(${idByRef}::jsonb -> (data->>${columnKey}::text), ${idByRef}::jsonb -> lower(data->>${columnKey}::text)))
+                 ELSE COALESCE((
+                   SELECT jsonb_agg(v ORDER BY ord) FROM (
+                     SELECT COALESCE(${idByRef}::jsonb -> btrim(part), ${idByRef}::jsonb -> lower(btrim(part)), to_jsonb(btrim(part))) AS v,
+                            min(o) AS ord
+                     FROM unnest(string_to_array(data->>${columnKey}::text, ',')) WITH ORDINALITY AS u(part, o)
+                     WHERE btrim(part) <> ''
+                     GROUP BY 1
+                   ) d), '[]'::jsonb)
             END)
           WHERE table_id = ${tableId}
             AND jsonb_typeof(data->${columnKey}::text) = 'string'`
@@ -1004,7 +1022,15 @@ export function isValueCompatibleWithType(
     case 'select': {
       // A cleared select cell is written as '' — still convertible.
       if (value === '') return true
-      const parts = Array.isArray(value) ? value : [value]
+      // Read the value exactly as the write-path coercion will. A multi target
+      // splits a comma-delimited string, so a multiselect → text → multiselect
+      // round-trip (text holding this feature's own `Bug, Docs` export shape)
+      // stays convertible instead of being rejected as one unknown option.
+      const parts = targetMultiple
+        ? splitMultiSelectInput(value as JsonValue)
+        : Array.isArray(value)
+          ? value
+          : [value]
       // A single-select target can't hold several options. `updateColumnOptions`
       // blocks the same transition; without this the next coerce would silently
       // keep only the first id.

apps/sim/lib/table/validation.ts

@@ -306,6 +306,23 @@ export function resolveSelectOptionId(value: JsonValue, options: SelectOption[])
   return byName ? byName.id : null
 }
 
+/**
+ * Splits a raw value into the parts a multi-select cell should resolve. A cell
+ * may arrive as an array (canonical) or as a single comma-delimited string —
+ * the shape a multi cell exports, copies, and converts to text as — so both the
+ * write-path coercion and the column-conversion compatibility check read it
+ * through here rather than each deciding for itself. Option names that
+ * themselves contain commas are an accepted ambiguity.
+ */
+export function splitMultiSelectInput(value: JsonValue): JsonValue[] {
+  if (Array.isArray(value)) return value
+  if (typeof value !== 'string') return [value]
+  return value
+    .split(',')
+    .map((part) => part.trim())
+    .filter((part) => part !== '')
+}
+
 /**
  * Attempts to coerce a non-null value to a column's declared type. Returns the
  * coerced value when the value already matches or can be converted without
@@ -357,18 +374,7 @@ function coerceValueToColumnType(
     case 'select': {
       const options = column.options ?? []
       if (column.multiple) {
-        // A multi-select cell may arrive as an array (canonical) or a single
-        // comma-delimited string (CSV import / clipboard paste of the read
-        // format) — split the latter so each label resolves. Option names that
-        // themselves contain commas are an accepted ambiguity here.
-        const raw = Array.isArray(value)
-          ? value
-          : typeof value === 'string'
-            ? value
-                .split(',')
-                .map((part) => part.trim())
-                .filter((part) => part !== '')
-            : [value]
+        const raw = splitMultiSelectInput(value)
         const ids: string[] = []
         for (const entry of raw) {
           const id = resolveSelectOptionId(entry, options)