fix(tables): block required blank conversions; sort multiselect by option name

`required` only rejects null/undefined on a write, so a required string column
legitimately holds ''. Converting it to a required select stored null (or []
for a multi), and every later update of that row then failed its own required
check. Reject a blank source value when the target select is required.

Multiselect sort compared the raw id-array text, since `["opt_b","opt_a"]`
matches no single-id CASE branch. It now resolves elements to names and joins
them in stored order — the same text the grid renders and an export writes.

Author: TheodoreSpeaks

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

@@ -79,6 +79,17 @@ describe('isValueCompatibleWithType — select cardinality', () => {
     expect(isValueCompatibleWithType(flattened, 'select', OPTIONS, false)).toBe(false)
   })
 
+  it('rejects a blank source value when the target select is required', () => {
+    // `required` only rejects null/undefined on a write, so a required string
+    // column legitimately holds ''. Converting it stores null (or [] for a
+    // multi), which would then fail that column's own required check on the
+    // next update of the row.
+    expect(isValueCompatibleWithType('', 'select', OPTIONS, false, true)).toBe(false)
+    expect(isValueCompatibleWithType('', 'select', OPTIONS, true, true)).toBe(false)
+    // Optional target is unchanged — a cleared cell stays convertible.
+    expect(isValueCompatibleWithType('', 'select', OPTIONS, false, false)).toBe(true)
+  })
+
   it('still rejects a comma string holding an undeclared option', () => {
     expect(isValueCompatibleWithType('Alpha, Gone', 'select', OPTIONS, true)).toBe(false)
   })

apps/sim/lib/table/__tests__/sql.test.ts

@@ -516,6 +516,18 @@ describe('SQL Builder', () => {
       expect(out).toContain("WHEN 'opt_closed' THEN 'Closed'")
       expect(out.trim().endsWith('ASC NULLS LAST')).toBe(true)
     })
+
+    it('sorts a multiselect by its option names, not the raw id array', () => {
+      // A multi cell extracts as `["opt_b","opt_a"]`, which matches no single-id
+      // CASE branch — without the array arm it would order on that opaque text.
+      const out = render(buildSortClause({ tags: 'asc' }, TABLE, [tagsCol]))
+      expect(out).toContain('jsonb_array_elements_text')
+      expect(out).toContain('string_agg')
+      expect(out).toContain('ORDER BY e.ord')
+      // The scalar arm survives for values left over from a single→multi toggle.
+      expect(out).toContain('CASE')
+      expect(out.trim().endsWith('ASC NULLS LAST')).toBe(true)
+    })
   })
 
   describe('Field name validation', () => {

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

@@ -541,7 +541,15 @@ export async function updateColumnType(
 
       const effective = convertingAwayFromSelect ? selectValueForConversion(column, value) : value
 
-      if (!isValueCompatibleWithType(effective, data.newType, targetOptions, !!targetMultiple)) {
+      if (
+        !isValueCompatibleWithType(
+          effective,
+          data.newType,
+          targetOptions,
+          !!targetMultiple,
+          !!column.required
+        )
+      ) {
         incompatibleCount++
       }
     }
@@ -1015,7 +1023,8 @@ export function isValueCompatibleWithType(
   value: unknown,
   targetType: (typeof COLUMN_TYPES)[number],
   targetOptions: SelectOption[] = [],
-  targetMultiple = false
+  targetMultiple = false,
+  targetRequired = false
 ): boolean {
   if (value === null || value === undefined) return true
 
@@ -1026,8 +1035,12 @@ export function isValueCompatibleWithType(
       // this check, so anything still structured here is genuinely lossy.
       return typeof value !== 'object'
     case 'select': {
-      // A cleared select cell is written as '' — still convertible.
-      if (value === '') return true
+      // A cleared select cell is written as '' — still convertible, unless the
+      // target is required. Required only rejects null/undefined on a write, so
+      // a required string column legitimately holds ''; the migration turns that
+      // into null (or [] for a multi), and every later update of that row would
+      // then fail its own required check.
+      if (value === '') return !targetRequired
       // 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)

apps/sim/lib/table/sql.ts

@@ -662,10 +662,13 @@ function buildSortFieldClause(
 
   // Select cells store opaque option ids; sort by the option **name** so ordering
   // is alphabetical by the label the user sees, not by the internal id. A stored
-  // id with no matching option (deleted) falls back to the raw text. Multiselect
-  // renders as a JSON array text, which won't match any id and sorts by that text.
+  // id with no matching option (deleted) falls back to the raw text.
   if (column?.type === 'select') {
-    const orderExpr = buildSelectNameOrderExpr(jsonbExtract, column)
+    const orderExpr = buildSelectNameOrderExpr(
+      jsonbExtract,
+      `${tableName}.data->'${escapedField}'`,
+      column
+    )
     return sql.raw(`${orderExpr} ${directionSql} NULLS LAST`)
   }
 
@@ -685,12 +688,30 @@ function buildSortFieldClause(
  * text extract) to its option name, so an ORDER BY sorts alphabetically by label.
  * Ids and names are SQL-escaped and embedded literally (options are trusted schema
  * data, not caller input); an unmapped id falls through to the raw extract.
+ *
+ * A multiselect cell is an array of ids, which matches no single-id branch — it
+ * sorts on its elements resolved to names and joined in stored order, the same
+ * text the grid renders and an export writes. A scalar left over from before a
+ * single→multi toggle still takes the single-id branch.
  */
-function buildSelectNameOrderExpr(jsonbExtract: string, column: ColumnDefinition): string {
+function buildSelectNameOrderExpr(
+  jsonbExtract: string,
+  jsonbValue: string,
+  column: ColumnDefinition
+): string {
   const options = column.options ?? []
   if (options.length === 0) return jsonbExtract
   const whens = options
     .map((o) => `WHEN '${o.id.replace(/'/g, "''")}' THEN '${o.name.replace(/'/g, "''")}'`)
     .join(' ')
-  return `CASE ${jsonbExtract} ${whens} ELSE ${jsonbExtract} END`
+  const singleExpr = `CASE ${jsonbExtract} ${whens} ELSE ${jsonbExtract} END`
+  if (!column.multiple) return singleExpr
+
+  const nameById = JSON.stringify(
+    Object.fromEntries(new Map(options.map((o) => [o.id, o.name])))
+  ).replace(/'/g, "''")
+  return `CASE WHEN jsonb_typeof(${jsonbValue}) = 'array' THEN (
+    SELECT string_agg(COALESCE('${nameById}'::jsonb ->> e.v, e.v), ', ' ORDER BY e.ord)
+    FROM jsonb_array_elements_text(${jsonbValue}) WITH ORDINALITY AS e(v, ord)
+  ) ELSE ${singleExpr} END`
 }