fix(tables): reject a flattened list as an amount; fold constraints into every typed write

Two findings from round 11.

Multi-select converted to nonsense amounts. `selectValueForConversion`
flattens a multi cell to its comma-joined option names, and the parser read
that as a formatted number: options 12 and 34 became 12.34, and 100 and 200
became 100200. No real amount puts whitespace after a separator, but a
delimited list does — so a separator followed by whitespace is now refused.
Every legitimate form still parses, including space-grouped locales.

Combined options-or-currency + constraints could still commit partially. Those
two writes now carry constraints the same way the retype does, through one
shared `applyConstraints` that validates (workflow-output, empty cells for
required, supportsUnique and duplicates for unique) and applies them. The
separate constraint write now runs only when no typed write does. Three copies
of those rules is the drift that produced the original required-check bug, so
they live in one place.

Author: waleedlatif1

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

@@ -139,8 +139,13 @@ export const PATCH = withRouteHandler(async (request: NextRequest, context: Colu
     // A retype applies and validates the constraints itself, so the separate
     // constraint write only runs when the type is unchanged. The rename rides
     // whichever write actually runs last.
+    const typedWriteRuns =
+      typeChanging ||
+      updates.currencyCode !== undefined ||
+      updates.options !== undefined ||
+      updates.multiple !== undefined
     const constraintsWriteRuns =
-      !typeChanging && (updates.required !== undefined || updates.unique !== undefined)
+      !typedWriteRuns && (updates.required !== undefined || updates.unique !== undefined)
     const renameWithTypedWrite =
       updates.name && !constraintsWriteRuns ? { newName: updates.name } : {}
 
@@ -230,6 +235,8 @@ export const PATCH = withRouteHandler(async (request: NextRequest, context: Colu
           tableId,
           columnName: columnRef,
           currencyCode: updates.currencyCode,
+          ...(updates.required !== undefined ? { required: updates.required } : {}),
+          ...(updates.unique !== undefined ? { unique: updates.unique } : {}),
           ...renameWithTypedWrite,
         },
         requestId
@@ -244,15 +251,16 @@ export const PATCH = withRouteHandler(async (request: NextRequest, context: Colu
           // 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 } : {}),
+          ...(updates.unique !== undefined ? { unique: updates.unique } : {}),
           ...renameWithTypedWrite,
         },
         requestId
       )
     }
 
-    // Skipped when the type changed: that write already applied and validated
-    // these, in one transaction with the conversion.
-    if (!typeChanging && (updates.required !== undefined || updates.unique !== undefined)) {
+    // Skipped whenever a typed write ran: that write already applied and
+    // validated these, in one transaction with the change they accompany.
+    if (constraintsWriteRuns) {
       updatedTable = await updateColumnConstraints(
         {
           tableId,

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

@@ -173,8 +173,13 @@ export const PATCH = withRouteHandler(async (request: NextRequest, context: Colu
     // A retype applies and validates the constraints itself, so the separate
     // constraint write only runs when the type is unchanged. The rename rides
     // whichever write actually runs last.
+    const typedWriteRuns =
+      typeChanging ||
+      updates.currencyCode !== undefined ||
+      updates.options !== undefined ||
+      updates.multiple !== undefined
     const constraintsWriteRuns =
-      !typeChanging && (updates.required !== undefined || updates.unique !== undefined)
+      !typedWriteRuns && (updates.required !== undefined || updates.unique !== undefined)
     const renameWithTypedWrite =
       updates.name && !constraintsWriteRuns ? { newName: updates.name } : {}
 
@@ -264,6 +269,8 @@ export const PATCH = withRouteHandler(async (request: NextRequest, context: Colu
           tableId,
           columnName: columnRef,
           currencyCode: updates.currencyCode,
+          ...(updates.required !== undefined ? { required: updates.required } : {}),
+          ...(updates.unique !== undefined ? { unique: updates.unique } : {}),
           ...renameWithTypedWrite,
         },
         requestId
@@ -278,15 +285,16 @@ export const PATCH = withRouteHandler(async (request: NextRequest, context: Colu
           // 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 } : {}),
+          ...(updates.unique !== undefined ? { unique: updates.unique } : {}),
           ...renameWithTypedWrite,
         },
         requestId
       )
     }
 
-    // Skipped when the type changed: that write already applied and validated
-    // these, in one transaction with the conversion.
-    if (!typeChanging && (updates.required !== undefined || updates.unique !== undefined)) {
+    // Skipped whenever a typed write ran: that write already applied and
+    // validated these, in one transaction with the change they accompany.
+    if (constraintsWriteRuns) {
       updatedTable = await updateColumnConstraints(
         {
           tableId,

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

@@ -17,6 +17,7 @@ import { and, count, eq, sql } from 'drizzle-orm'
 import { columnMatchesRef, generateColumnId, getColumnId } from '@/lib/table/column-keys'
 import {
   columnTypeById,
+  columnTypeOf,
   isValueCompatible,
   TYPE_SPECIFIC_COLUMN_KEYS,
 } from '@/lib/table/column-types'
@@ -485,6 +486,55 @@ export async function deleteColumns(
   return def
 }
 
+/**
+ * Validates a constraint change against the column's stored data, and returns
+ * the column with those constraints applied.
+ *
+ * Shared by every write that can carry constraints, for the reason the
+ * duplicate scan and {@link countEmptyCells} are shared: three copies of these
+ * rules is the drift that produced the original required-check bug. Applying
+ * them in the same write as the change they accompany is what stops a combined
+ * request from committing one half and then failing on the other.
+ */
+async function applyConstraints(
+  trx: DbTransaction,
+  tableId: string,
+  column: ColumnDefinition,
+  columnKey: string,
+  data: { required?: boolean; unique?: boolean }
+): Promise<ColumnDefinition> {
+  if (data.required === undefined && data.unique === undefined) return column
+
+  if (column.workflowGroupId) {
+    throw new Error(
+      `Cannot change constraints on workflow-output column "${column.name}". Constraints aren't applicable to columns whose values come from workflow execution.`
+    )
+  }
+  if (data.required === true && !column.required) {
+    const emptyCount = await countEmptyCells(trx, tableId, columnKey)
+    if (emptyCount > 0) {
+      throw new Error(
+        `Cannot set column "${column.name}" as required: ${emptyCount} row(s) have null, missing, or empty values`
+      )
+    }
+  }
+  if (data.unique === true && !column.unique) {
+    if (!columnTypeOf(column).supportsUnique) {
+      throw new Error(
+        `Cannot set column "${column.name}" as unique: ${column.type} columns compare stored values that would allow only one row per value.`
+      )
+    }
+    if (await hasDuplicateValues(trx, tableId, columnKey)) {
+      throw new Error(`Cannot set column "${column.name}" as unique: duplicate values exist`)
+    }
+  }
+  return {
+    ...column,
+    ...(data.required !== undefined ? { required: data.required } : {}),
+    ...(data.unique !== undefined ? { unique: data.unique } : {}),
+  }
+}
+
 /** Persists a column list as the table's schema and returns the updated definition. */
 async function persistColumns(
   trx: DbTransaction,
@@ -964,7 +1014,14 @@ export async function updateColumnOptions(
       throw new Error(`Invalid column: ${columnValidation.errors.join('; ')}`)
     }
 
-    const withOptions = schema.columns.map((c, i) => (i === columnIndex ? updatedColumn : c))
+    const constrainedColumn = await applyConstraints(
+      trx,
+      data.tableId,
+      updatedColumn,
+      columnKey,
+      data
+    )
+    const withOptions = schema.columns.map((c, i) => (i === columnIndex ? constrainedColumn : c))
     const updatedColumns = withOptions.map((c, i) =>
       i === columnIndex ? applyPendingRename(withOptions, columnIndex, data.newName) : c
     )
@@ -1129,13 +1186,25 @@ export async function updateColumnCurrency(
       throw new Error(`Invalid column: ${columnValidation.errors.join('; ')}`)
     }
 
-    // Only a no-op when the currency is unchanged AND no rename is riding along.
+    const constrained = await applyConstraints(
+      trx,
+      data.tableId,
+      updatedColumn,
+      getColumnId(column),
+      data
+    )
+
+    // Only a no-op when nothing at all changed — currency, constraints, name.
     const renamePending = data.newName !== undefined && data.newName !== column.name
-    if (updatedColumn.currencyCode === column.currencyCode && !renamePending) {
+    if (
+      constrained === updatedColumn &&
+      updatedColumn.currencyCode === column.currencyCode &&
+      !renamePending
+    ) {
       return table
     }
 
-    const withCurrency = schema.columns.map((c, i) => (i === columnIndex ? updatedColumn : c))
+    const withCurrency = schema.columns.map((c, i) => (i === columnIndex ? constrained : c))
     const updatedColumns = withCurrency.map((c, i) =>
       i === columnIndex ? applyPendingRename(withCurrency, columnIndex, data.newName) : c
     )

apps/sim/lib/table/currency.ts

@@ -29,6 +29,9 @@ function hasValidGrouping(text: string, separator: string): boolean {
   return /^\d{1,3}$/.test(groups[0]) && groups.slice(1).every((group) => /^\d{3}$/.test(group))
 }
 
+/** A decimal/grouping separator followed by whitespace — a list, not an amount. */
+const SEPARATOR_THEN_SPACE = /[.,]\s/
+
 /** An `e` with a digit on both sides — an exponent marker, however spaced. */
 const INTERIOR_EXPONENT = /\d\s*[eE][+-]?\s*\d/
 
@@ -148,6 +151,12 @@ export function parseCurrencyInput(raw: unknown): number | null {
   const parenthesized = /^\((.*)\)$/.exec(trimmed)
   const body = parenthesized ? parenthesized[1] : trimmed
 
+  // No real amount puts whitespace after a separator, but a delimited LIST
+  // does — and a multi-select column flattens to exactly that when it converts.
+  // Without this, `12, 34` reads as 12.34 and `100, 200` as 100200, so a
+  // multi-select column of numeric option names would convert to nonsense.
+  if (SEPARATOR_THEN_SPACE.test(body)) return null
+
   // Exponent form is taken at face value. `String()` emits it for any magnitude
   // past 1e21, so a stored amount round-trips through the editor as `1e+21` —
   // and stripping the `e` as decoration would read that back as 121, silently

apps/sim/lib/table/types.ts

@@ -816,6 +816,8 @@ export interface UpdateColumnOptionsData {
    * what stops a combined request from committing one half and then failing.
    */
   newName?: string
+  /** Constraints to apply in the SAME transaction as this write. */
+  unique?: boolean
   options: SelectOption[]
   /** Toggle single/multi selection alongside the options update. */
   multiple?: boolean
@@ -841,6 +843,8 @@ export interface UpdateColumnCurrencyData {
    * what stops a combined request from committing one half and then failing.
    */
   newName?: string
+  /** Constraints to apply in the SAME transaction as this write. */
+  unique?: boolean
   currencyCode: string
 }