fix(tables): stop inventing amounts from identifiers; fix the copilot retype

Adversarial pass over the final state, seven real findings.

Two destroyed data. The copilot `update_column` still used the two-transaction
pattern the HTTP routes were fixed for: `unique` was never forwarded to the
typed write, so a retype+unique committed the conversion and then failed the
constraint — the same irrecoverable half. It now rides the typed write, and the
separate constraint write only runs when no typed write did.

And the parser's three-letter strip removed ANY three letters, not an ISO code:
`SKU400` parsed as 400, `ABC1234` as 1234. Converting a column of part numbers
to currency rewrote every cell with an invented value — while the comment two
lines above claimed a SKU was exactly what it prevented. The rule is now that a
letter touching a digit means identifier, not amount; a currency marker is
always separated by a space or a symbol.

That same change fixed a class the review surfaced: the pinned currencies could
not parse their own conventional notation. `R$ 1.234,56`, `1 234,56 kr`,
`1234,56 zł`, `CHF 1’234.56` and Indian lakh grouping (`₹12,34,567.89`) all
work now — these are what Intl emits, so a paste from a spreadsheet was being
rejected.

`updateColumnConstraints` was a fourth copy of the constraint rules the shared
helper exists to unify, and had already drifted: it hardcoded `type ===
'select'` where the helper asks the registry, so a future type declaring
`supportsUnique: false` would have been ignored on that path. It now uses the
helper.

`updateColumnType`'s unchanged-type early return silently discarded every
field except the rename. Callers gate on the type changing, but from a read
taken before the lock — so a concurrent change could land there with real work
pending and answer success. It now throws.

Also: `UpdateColumnCurrencyData` was missing `required`, which only compiled
because the routes pass it through a spread; a missing column returns 404
instead of a 400 reading "of type undefined"; and the comments describing the
old two-transaction architecture are gone.

Verified NOT a bug: CSV export of a currency column writes the raw number, so
export/import round-trips losslessly.

Author: waleedlatif1

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

@@ -136,6 +136,13 @@ export const PATCH = withRouteHandler(async (request: NextRequest, context: Colu
     // The constraints write below is a separate, unconditional step, so it is
     // the last one whenever it runs — that is the write the rename rides on.
     const typeChanging = updates.type !== undefined && updates.type !== currentColumn?.type
+    if (!currentColumn) {
+      return NextResponse.json(
+        { error: `Column "${validated.columnName}" not found` },
+        { status: 404 }
+      )
+    }
+
     // 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.

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

@@ -170,6 +170,13 @@ export const PATCH = withRouteHandler(async (request: NextRequest, context: Colu
     // The constraints write below is a separate, unconditional step, so it is
     // the last one whenever it runs — that is the write the rename rides on.
     const typeChanging = updates.type !== undefined && updates.type !== currentColumn?.type
+    if (!currentColumn) {
+      return NextResponse.json(
+        { error: `Column "${validated.columnName}" not found` },
+        { status: 404 }
+      )
+    }
+
     // 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.

apps/sim/lib/copilot/tools/server/table/user-table.ts

@@ -1728,6 +1728,7 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
                 options,
                 multiple,
                 ...(currencyCode !== undefined ? { currencyCode } : {}),
+                ...(uniqFlag !== undefined ? { unique: uniqFlag } : {}),
               },
               requestId
             )
@@ -1742,7 +1743,12 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
             }
             assertNotAborted()
             result = await updateColumnCurrency(
-              { tableId: args.tableId, columnName: colName, currencyCode },
+              {
+                tableId: args.tableId,
+                columnName: colName,
+                currencyCode,
+                ...(uniqFlag !== undefined ? { unique: uniqFlag } : {}),
+              },
               requestId
             )
           } else if (options !== undefined || multiple !== undefined) {
@@ -1759,11 +1765,20 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
             }
             assertNotAborted()
             result = await updateColumnOptions(
-              { tableId: args.tableId, columnName: colName, options: nextOptions, multiple },
+              {
+                tableId: args.tableId,
+                columnName: colName,
+                options: nextOptions,
+                multiple,
+                ...(uniqFlag !== undefined ? { unique: uniqFlag } : {}),
+              },
               requestId
             )
           }
-          if (uniqFlag !== undefined) {
+          // Skipped when a typed write ran: that write already applied and
+          // validated the constraint, in one transaction with the change it
+          // accompanies. Mirrors the HTTP columns routes.
+          if (uniqFlag !== undefined && result === undefined) {
             assertNotAborted()
             result = await updateColumnConstraints(
               { tableId: args.tableId, columnName: colName, unique: uniqFlag },

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

@@ -103,14 +103,38 @@ describe('parseCurrencyInput', () => {
     expect(parseCurrencyInput('-$12.50')).toBe(-12.5)
   })
 
+  it('parses the locale formats of the currencies the picker pins', () => {
+    // These are exactly what `Intl.NumberFormat` emits, i.e. what a user pastes
+    // from a spreadsheet. Rejecting them would make the pinned currencies
+    // unusable in their own conventional notation.
+    expect(parseCurrencyInput('R$ 1.234,56')).toBe(1234.56)
+    expect(parseCurrencyInput('₹12,34,567.89')).toBe(1234567.89)
+    expect(parseCurrencyInput('1 234,56 kr')).toBe(1234.56)
+    expect(parseCurrencyInput('1.234,56 kr.')).toBe(1234.56)
+    expect(parseCurrencyInput('1234,56 zł')).toBe(1234.56)
+    expect(parseCurrencyInput('CHF 1’234.56')).toBe(1234.56)
+  })
+
+  it('rejects an identifier whose letters touch its digits', () => {
+    // The distinguishing rule: a currency marker is always separated from the
+    // number by a space or a symbol, so letters touching digits mean this is a
+    // part number, not an amount. Without it, converting a column of SKUs to
+    // currency rewrote every cell with an invented value.
+    expect(parseCurrencyInput('SKU400')).toBeNull()
+    expect(parseCurrencyInput('ABC1234')).toBeNull()
+    expect(parseCurrencyInput('A1B2')).toBeNull()
+    // A marker separated properly still parses.
+    expect(parseCurrencyInput('USD 400')).toBe(400)
+    expect(parseCurrencyInput('$400')).toBe(400)
+  })
+
   it('rejects text that merely contains digits', () => {
     // Scraping digits out of arbitrary text invents a value. A string column of
     // SKUs, phone numbers, or US-format dates converting to currency would
     // otherwise report zero incompatible rows and rewrite every cell.
     expect(parseCurrencyInput('01/02/2024')).toBeNull()
     expect(parseCurrencyInput('Room 101')).toBeNull()
     expect(parseCurrencyInput('Invoice 2024')).toBeNull()
-    expect(parseCurrencyInput('A1B2')).toBeNull()
     expect(parseCurrencyInput('1_000')).toBeNull()
   })
 
@@ -121,9 +145,10 @@ describe('parseCurrencyInput', () => {
     expect(parseCurrencyInput('1,,2')).toBeNull()
     expect(parseCurrencyInput('0.1.2')).toBeNull()
     expect(parseCurrencyInput('1,000,00')).toBeNull()
-    // Valid grouping still works.
+    // Valid grouping still works, western and Indian.
     expect(parseCurrencyInput('1.234.567')).toBe(1234567)
     expect(parseCurrencyInput('1,234,567.89')).toBe(1234567.89)
+    expect(parseCurrencyInput('12,34,567')).toBe(1234567)
   })
 
   it('rejects values carrying no amount', () => {

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

@@ -701,8 +701,23 @@ export async function updateColumnType(
 
     const column = schema.columns[columnIndex]
     if (column.type === data.newType) {
-      // The type is unchanged, but a rename folded into this same request still
-      // has to land — returning here unconditionally would drop it silently.
+      // Callers gate on the type actually changing, but they compute that from
+      // a schema read taken before this transaction took the lock — so a
+      // concurrent change can land us here with real work still to do. Only a
+      // rename can be honoured without a conversion; anything else would be
+      // silently discarded, and answering success for a change that never
+      // happened is the worst outcome available.
+      const carriesOtherWork =
+        data.required !== undefined ||
+        data.unique !== undefined ||
+        data.options !== undefined ||
+        data.multiple !== undefined ||
+        data.currencyCode !== undefined
+      if (carriesOtherWork) {
+        throw new Error(
+          `Column "${column.name}" is already type "${data.newType}"; re-issue the request without a type change.`
+        )
+      }
       const renamed = applyPendingRename(schema.columns, columnIndex, data.newName)
       if (renamed === column) return table
       return persistColumns(
@@ -925,41 +940,8 @@ export async function updateColumnConstraints(
 
     const column = schema.columns[columnIndex]
     const columnKey = getColumnId(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, data.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.type === 'select') {
-      throw new Error(
-        `Cannot set column "${column.name}" as unique: select columns compare stored option ids, which would allow only one row per option.`
-      )
-    }
-
-    if (data.unique === true && !column.unique) {
-      if (await hasDuplicateValues(trx, data.tableId, columnKey)) {
-        throw new Error(`Cannot set column "${column.name}" as unique: duplicate values exist`)
-      }
-    }
-
-    const withConstraints = schema.columns.map((c, i) =>
-      i === columnIndex
-        ? {
-            ...c,
-            ...(data.required !== undefined ? { required: data.required } : {}),
-            ...(data.unique !== undefined ? { unique: data.unique } : {}),
-          }
-        : c
-    )
+    const constrained = await applyConstraints(trx, data.tableId, column, columnKey, data)
+    const withConstraints = schema.columns.map((c, i) => (i === columnIndex ? constrained : c))
     const updatedColumns = withConstraints.map((c, i) =>
       i === columnIndex ? applyPendingRename(withConstraints, columnIndex, data.newName) : c
     )

apps/sim/lib/table/currency.ts

@@ -15,6 +15,20 @@ export const DEFAULT_CURRENCY_CODE = 'USD'
 /** A bare numeric literal in exponent form, e.g. `1e+21` or `-1.5e-3`. */
 const EXPONENT_LITERAL = /^[+-]?\d+(?:\.\d+)?[eE][+-]?\d+$/
 
+/** A letter directly adjacent to a digit: an identifier, not an amount. */
+const LETTER_TOUCHING_DIGIT = /\p{L}\d|\d\p{L}/u
+
+/**
+ * A leading currency marker: up to three letters and/or a symbol, optionally
+ * behind a sign. The sign is captured so `-$12.50` keeps it.
+ */
+const CURRENCY_MARKER_PREFIX =
+  /^[\s\u00a0\u202f]*([+-]?)[\s\u00a0\u202f]*(?:\p{Sc}\p{L}{0,3}|\p{L}{1,3}\p{Sc}?)[\s\u00a0\u202f]*/u
+
+/** The same, trailing. */
+const CURRENCY_MARKER_SUFFIX =
+  /[\s\u00a0\u202f]*(?:\p{Sc}\p{L}{0,3}|\p{L}{1,3}\p{Sc}?)\.?[\s\u00a0\u202f]*$/u
+
 /** Only digits and separators, with at least one digit. */
 const AMOUNT_SHAPE = /^[+-]?[\d.,]*\d[\d.,]*$/
 
@@ -26,7 +40,17 @@ const AMOUNT_SHAPE = /^[+-]?[\d.,]*\d[\d.,]*$/
 function hasValidGrouping(text: string, separator: string): boolean {
   const groups = text.split(separator)
   if (groups.length === 1) return true
-  return /^\d{1,3}$/.test(groups[0]) && groups.slice(1).every((group) => /^\d{3}$/.test(group))
+  if (!/^\d{1,3}$/.test(groups[0])) return false
+  const rest = groups.slice(1)
+  // Western: every later group is exactly three.
+  if (rest.every((group) => /^\d{3}$/.test(group))) return true
+  // Indian: the final group is three and the ones before it are two —
+  // `12,34,567`. Still rejects `1,000,00`, whose final group is two.
+  return (
+    rest.length > 1 &&
+    /^\d{3}$/.test(rest[rest.length - 1]) &&
+    rest.slice(0, -1).every((group) => /^\d{2}$/.test(group))
+  )
 }
 
 /** A decimal/grouping separator followed by whitespace — a list, not an amount. */
@@ -173,13 +197,21 @@ export function parseCurrencyInput(raw: unknown): number | null {
   // is what distinguishes this from the `E` inside an ISO code like `12 EUR`.
   if (INTERIOR_EXPONENT.test(body)) return null
 
-  // What remains once currency symbols, spacing, and an ISO code are removed
-  // must be ONLY digits and separators. Scraping digits out of anything else
-  // invents a value: a US-format date, a SKU, or a room number would all parse.
+  // A letter touching a digit means this is an identifier, not an amount —
+  // `SKU400`, `ABC1234`. Currency markers are always separated from the number
+  // by a space or a symbol, so this distinguishes them without a symbol list.
+  if (LETTER_TOUCHING_DIGIT.test(body)) return null
+
+  // Strip the currency marker: up to three letters (an ISO code, `kr`, `zł`)
+  // optionally joined to a symbol (`R$`, `CHF`), at either end. Bounded at
+  // three so prose does not qualify — `Revenue 5` keeps its letters and is
+  // rejected below.
   const cleaned = body
-    .replace(/\p{Sc}/gu, '')
-    .replace(/\s/g, '')
-    .replace(/^[A-Za-z]{3}|[A-Za-z]{3}$/g, '')
+    .replace(CURRENCY_MARKER_PREFIX, '$1')
+    .replace(CURRENCY_MARKER_SUFFIX, '')
+    .replace(/[\s\u00a0\u202f\u2019']/gu, '')
+  // What remains must be ONLY digits and separators. Anything else — a
+  // US-format date, leftover prose — is not an amount.
   if (!AMOUNT_SHAPE.test(cleaned)) return null
 
   const signed = /^[+-]/.test(cleaned)

apps/sim/lib/table/types.ts

@@ -800,10 +800,8 @@ export interface UpdateColumnTypeData {
    */
   unique?: boolean
   /**
-   * The `required` value the same request is about to set, when it changes type
-   * and constraints together. Those are separate transactions, so the
-   * conversion has to validate against the constraint the column will END UP
-   * with — otherwise it commits and the constraint write then fails.
+   * The `required` value the same request is about to set. Applied by this
+   * write, in the same transaction as the change it accompanies.
    */
   required?: boolean
 }
@@ -822,10 +820,8 @@ export interface UpdateColumnOptionsData {
   /** Toggle single/multi selection alongside the options update. */
   multiple?: boolean
   /**
-   * The `required` value the same request is about to set. The constraint write
-   * is a separate transaction, so the options update has to validate against
-   * the constraint the column will END UP with — otherwise it clears cells and
-   * the constraint write then fails, leaving the removal committed.
+   * The `required` value the same request is about to set. Applied by this
+   * write, in the same transaction as the options change.
    */
   required?: boolean
 }
@@ -845,6 +841,7 @@ export interface UpdateColumnCurrencyData {
   newName?: string
   /** Constraints to apply in the SAME transaction as this write. */
   unique?: boolean
+  required?: boolean
   currencyCode: string
 }