feat(tables): add select & multi-select column types

apps/sim/app/api/table/[tableId]/columns/route.ts

@@ -15,8 +15,10 @@ import {
   deleteColumn,
   renameColumn,
   updateColumnConstraints,
+  updateColumnOptions,
   updateColumnType,
 } from '@/lib/table'
+import { columnMatchesRef } from '@/lib/table/column-keys'
 import { accessError, checkAccess, normalizeColumn, rootErrorMessage } from '@/app/api/table/utils'
 
 const logger = createLogger('TableColumnsAPI')
@@ -68,7 +70,8 @@ export const POST = withRouteHandler(async (request: NextRequest, context: Colum
       msg.includes('already exists') ||
       msg.includes('maximum column') ||
       msg.includes('Invalid column') ||
-      msg.includes('exceeds maximum')
+      msg.includes('exceeds maximum') ||
+      msg.includes('option')
     ) {
       return NextResponse.json({ error: msg }, { status: 400 })
     }
@@ -116,9 +119,50 @@ export const PATCH = withRouteHandler(async (request: NextRequest, context: Colu
       )
     }
 
-    if (updates.type) {
+    // A payload that repeats the current type must not go through
+    // `updateColumnType` — it early-returns on an unchanged type and would drop
+    // any `options` alongside it. Only a real type change routes there; an
+    // unchanged type with options routes to the options-only update.
+    const currentColumn = table.schema.columns.find((c) =>
+      columnMatchesRef(c, validated.columnName)
+    )
+    const typeChanging = updates.type !== undefined && updates.type !== currentColumn?.type
+
+    // Every write below is its own locked transaction, so any of them paired
+    // with a constraint write that is going to fail commits and then errors.
+    // Gate on the type the column ENDS UP with, not on whether the type is
+    // changing: an options-only update on an existing select column carries the
+    // same hazard as a conversion does.
+    const resultingType = updates.type ?? currentColumn?.type
+    if (updates.unique === true && resultingType === 'select') {
+      return NextResponse.json({ error: 'Cannot set a select column as unique' }, { status: 400 })
+    }
+
+    if (typeChanging) {
       updatedTable = await updateColumnType(
-        { tableId, columnName: updates.name ?? validated.columnName, newType: updates.type },
+        {
+          tableId,
+          columnName: updates.name ?? validated.columnName,
+          newType: updates.type as NonNullable<typeof updates.type>,
+          ...(updates.options !== undefined ? { options: updates.options } : {}),
+          ...(updates.multiple !== undefined ? { multiple: updates.multiple } : {}),
+          // Forwarded so the conversion validates against the constraint this
+          // same request is about to set, not the column's current one.
+          ...(updates.required !== undefined ? { required: updates.required } : {}),
+        },
+        requestId
+      )
+    } else if (updates.options !== undefined || updates.multiple !== undefined) {
+      updatedTable = await updateColumnOptions(
+        {
+          tableId,
+          columnName: updates.name ?? validated.columnName,
+          options: updates.options ?? currentColumn?.options ?? [],
+          ...(updates.multiple !== undefined ? { multiple: updates.multiple } : {}),
+          // Forwarded so the removal guard validates against the constraint this
+          // same request is about to set, not the column's current one.
+          ...(updates.required !== undefined ? { required: updates.required } : {}),
+        },
         requestId
       )
     }
@@ -162,7 +206,8 @@ export const PATCH = withRouteHandler(async (request: NextRequest, context: Colu
       msg.includes('Invalid column') ||
       msg.includes('exceeds maximum') ||
       msg.includes('incompatible') ||
-      msg.includes('duplicate')
+      msg.includes('duplicate') ||
+      msg.includes('option')
     ) {
       return NextResponse.json({ error: msg }, { status: 400 })
     }

apps/sim/app/api/table/[tableId]/export/route.ts

@@ -8,7 +8,9 @@ import { neutralizeCsvFormula } from '@/lib/core/utils/csv'
 import { generateRequestId } from '@/lib/core/utils/request'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
 import { captureServerEvent } from '@/lib/posthog/server'
-import { buildNameById, getColumnId, rowDataIdToName } from '@/lib/table/column-keys'
+import { namedRowMapper } from '@/lib/table/cell-format'
+import { getColumnId } from '@/lib/table/column-keys'
+import { formatCsvCell } from '@/lib/table/export-format'
 import { queryRows } from '@/lib/table/rows/service'
 import { accessError, checkAccess } from '@/app/api/table/utils'
 
@@ -52,7 +54,7 @@ export const GET = withRouteHandler(async (request: NextRequest, { params }: Rou
   const columns = table.schema.columns
   // Stored row data is id-keyed; CSV headers and JSON keys are display names, so
   // translate id → name on the way out (export is a name-friendly boundary).
-  const nameById = buildNameById(table.schema)
+  const toNamedRow = namedRowMapper(columns)
   const safeName = sanitizeFilename(table.name)
   const filename = `${safeName}.${format}`
 
@@ -100,14 +102,12 @@ export const GET = withRouteHandler(async (request: NextRequest, { params }: Rou
 
           for (const row of result.rows) {
             if (format === 'csv') {
-              const values = columns.map((c) => formatCsvValue(row.data[getColumnId(c)]))
+              const values = columns.map((c) => formatCsvCell(c, row.data[getColumnId(c)]))
               controller.enqueue(encoder.encode(`${toCsvRow(values)}\n`))
             } else {
               const prefix = firstJsonRow ? '' : ','
               firstJsonRow = false
-              controller.enqueue(
-                encoder.encode(prefix + JSON.stringify(rowDataIdToName(row.data, nameById)))
-              )
+              controller.enqueue(encoder.encode(prefix + JSON.stringify(toNamedRow(row.data))))
             }
           }
 
@@ -144,18 +144,6 @@ function sanitizeFilename(name: string): string {
   return cleaned || 'table'
 }
 
-/**
- * Serializes a cell for CSV. Only string cells are formula-neutralized; numbers,
- * booleans, dates, and JSON objects can never form a trigger and pass through verbatim.
- */
-function formatCsvValue(value: unknown): string {
-  if (value === null || value === undefined) return ''
-  if (value instanceof Date) return value.toISOString()
-  if (typeof value === 'object') return JSON.stringify(value)
-  if (typeof value === 'string') return neutralizeCsvFormula(value)
-  return String(value)
-}
-
 function toCsvRow(values: string[]): string {
   return values.map(escapeCsvField).join(',')
 }

apps/sim/app/api/table/row-wire.ts

@@ -1,13 +1,13 @@
 import { AuthType, type AuthTypeValue } from '@/lib/auth/hybrid'
 import type { Filter, RowData, Sort, TableSchema } from '@/lib/table'
+import { namedRowMapper } from '@/lib/table/cell-format'
 import {
   buildIdByName,
-  buildNameById,
   filterNamesToIds,
-  rowDataIdToName,
   rowDataNameToId,
   sortNamesToIds,
-} from '@/lib/table'
+} from '@/lib/table/column-keys'
+import { resolveFilterSelectValues } from '@/lib/table/select-values'
 
 export interface RowWireTranslators {
   /** Inbound row data: wire keys → storage column ids. */
@@ -36,11 +36,12 @@ export function rowWireTranslators(
     return { dataIn: identity, dataOut: identity, filterIn: identity, sortIn: identity }
   }
   const idByName = buildIdByName(schema)
-  const nameById = buildNameById(schema)
   return {
+    dataOut: namedRowMapper(schema.columns),
     dataIn: (data) => rowDataNameToId(data, idByName),
-    dataOut: (data) => rowDataIdToName(data, nameById),
-    filterIn: (filter) => filterNamesToIds(filter, idByName),
+    // Rekey field refs name → id, then resolve select operand names → ids.
+    filterIn: (filter) =>
+      resolveFilterSelectValues(filterNamesToIds(filter, idByName), schema.columns),
     sortIn: (sort) => sortNamesToIds(sort, idByName),
   }
 }

apps/sim/app/api/table/utils.ts

@@ -279,5 +279,7 @@ export function normalizeColumn(col: ColumnDefinition): ColumnDefinition {
     required: col.required ?? false,
     unique: col.unique ?? false,
     ...(col.workflowGroupId ? { workflowGroupId: col.workflowGroupId } : {}),
+    ...(col.options ? { options: col.options } : {}),
+    ...(col.multiple ? { multiple: true } : {}),
   }
 }

apps/sim/app/api/v1/tables/[tableId]/columns/route.ts

@@ -14,8 +14,10 @@ import {
   deleteColumn,
   renameColumn,
   updateColumnConstraints,
+  updateColumnOptions,
   updateColumnType,
 } from '@/lib/table'
+import { columnMatchesRef } from '@/lib/table/column-keys'
 import { accessError, checkAccess, normalizeColumn } from '@/app/api/table/utils'
 import {
   checkRateLimit,
@@ -86,7 +88,15 @@ export const POST = withRouteHandler(async (request: NextRequest, context: Colum
     if (validationResponse) return validationResponse
 
     if (error instanceof Error) {
-      if (error.message.includes('already exists') || error.message.includes('maximum column')) {
+      // Same caller-error set the internal columns route maps — an invalid
+      // select option set is a bad request, not a server fault.
+      if (
+        error.message.includes('already exists') ||
+        error.message.includes('maximum column') ||
+        error.message.includes('Invalid column') ||
+        error.message.includes('exceeds maximum') ||
+        error.message.includes('option')
+      ) {
         return NextResponse.json({ error: error.message }, { status: 400 })
       }
       if (error.message === 'Table not found') {
@@ -138,9 +148,50 @@ export const PATCH = withRouteHandler(async (request: NextRequest, context: Colu
       )
     }
 
-    if (updates.type) {
+    // A payload that repeats the current type must not go through
+    // `updateColumnType` — it early-returns on an unchanged type and would drop
+    // any `options` alongside it. Only a real type change routes there; an
+    // unchanged type with options routes to the options-only update.
+    const currentColumn = table.schema.columns.find((c) =>
+      columnMatchesRef(c, validated.columnName)
+    )
+    const typeChanging = updates.type !== undefined && updates.type !== currentColumn?.type
+
+    // Every write below is its own locked transaction, so any of them paired
+    // with a constraint write that is going to fail commits and then errors.
+    // Gate on the type the column ENDS UP with, not on whether the type is
+    // changing: an options-only update on an existing select column carries the
+    // same hazard as a conversion does.
+    const resultingType = updates.type ?? currentColumn?.type
+    if (updates.unique === true && resultingType === 'select') {
+      return NextResponse.json({ error: 'Cannot set a select column as unique' }, { status: 400 })
+    }
+
+    if (typeChanging) {
       updatedTable = await updateColumnType(
-        { tableId, columnName: updates.name ?? validated.columnName, newType: updates.type },
+        {
+          tableId,
+          columnName: updates.name ?? validated.columnName,
+          newType: updates.type as NonNullable<typeof updates.type>,
+          ...(updates.options !== undefined ? { options: updates.options } : {}),
+          ...(updates.multiple !== undefined ? { multiple: updates.multiple } : {}),
+          // Forwarded so the conversion validates against the constraint this
+          // same request is about to set, not the column's current one.
+          ...(updates.required !== undefined ? { required: updates.required } : {}),
+        },
+        requestId
+      )
+    } else if (updates.options !== undefined || updates.multiple !== undefined) {
+      updatedTable = await updateColumnOptions(
+        {
+          tableId,
+          columnName: updates.name ?? validated.columnName,
+          options: updates.options ?? currentColumn?.options ?? [],
+          ...(updates.multiple !== undefined ? { multiple: updates.multiple } : {}),
+          // Forwarded so the removal guard validates against the constraint this
+          // same request is about to set, not the column's current one.
+          ...(updates.required !== undefined ? { required: updates.required } : {}),
+        },
         requestId
       )
     }
@@ -195,7 +246,8 @@ export const PATCH = withRouteHandler(async (request: NextRequest, context: Colu
         msg.includes('Invalid column') ||
         msg.includes('exceeds maximum') ||
         msg.includes('incompatible') ||
-        msg.includes('duplicate')
+        msg.includes('duplicate') ||
+        msg.includes('option')
       ) {
         return NextResponse.json({ error: msg }, { status: 400 })
       }

apps/sim/app/api/v1/tables/[tableId]/rows/[rowId]/route.ts

@@ -13,13 +13,9 @@ import { parseRequest, validationErrorResponseFromError } from '@/lib/api/server
 import { generateRequestId } from '@/lib/core/utils/request'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
 import type { RowData, TableSchema } from '@/lib/table'
-import {
-  buildIdByName,
-  buildNameById,
-  rowDataIdToName,
-  rowDataNameToId,
-  updateRow,
-} from '@/lib/table'
+import { updateRow } from '@/lib/table'
+import { namedRowMapper } from '@/lib/table/cell-format'
+import { buildIdByName, rowDataNameToId } from '@/lib/table/column-keys'
 import { accessError, checkAccess } from '@/app/api/table/utils'
 import {
   checkRateLimit,
@@ -88,13 +84,13 @@ export const GET = withRouteHandler(async (request: NextRequest, context: RowRou
       return NextResponse.json({ error: 'Row not found' }, { status: 404 })
     }
 
-    const nameById = buildNameById(result.table.schema as TableSchema)
+    const toNamedRow = namedRowMapper((result.table.schema as TableSchema).columns)
     return NextResponse.json({
       success: true,
       data: {
         row: {
           id: row.id,
-          data: rowDataIdToName(row.data as RowData, nameById),
+          data: toNamedRow(row.data as RowData),
           position: row.position,
           createdAt:
             row.createdAt instanceof Date ? row.createdAt.toISOString() : String(row.createdAt),
@@ -142,7 +138,7 @@ export const PATCH = withRouteHandler(async (request: NextRequest, context: RowR
     }
 
     const idByName = buildIdByName(table.schema as TableSchema)
-    const nameById = buildNameById(table.schema as TableSchema)
+    const toNamedRow = namedRowMapper((table.schema as TableSchema).columns)
     const updatedRow = await updateRow(
       {
         tableId,
@@ -168,7 +164,7 @@ export const PATCH = withRouteHandler(async (request: NextRequest, context: RowR
       data: {
         row: {
           id: updatedRow.id,
-          data: rowDataIdToName(updatedRow.data, nameById),
+          data: toNamedRow(updatedRow.data),
           position: updatedRow.position,
           createdAt:
             updatedRow.createdAt instanceof Date