fix(tables): refuse scale suffixes and resolve the lone-separator ambiguity

A verification pass over the previous commit found that my own fix opened a new
hole of the class it closed.

Widening the currency marker to 1-3 letters made scale suffixes parse: `1.2 M`
read as 1.2, so a column of `1.2 M` / `3.4 M` — an ordinary spreadsheet paste —
converted cleanly and rewrote every cell a millionfold too small. Before the
widening those were rejected and the data was safe. Now refused explicitly,
while `kr` and `zł` still parse despite starting with the same letters.

Stripping the marker also newly routed formatted zero-decimal amounts into the
lone-separator branch, where a single dot was always decimal: `1.235 ¥` read as
1.235 rather than 1235. That is a wrong number where there used to be a
refusal, which is the worse failure. A lone separator followed by three digits
is now resolved by two signals — a marker means a formatter produced it, and
formatters group; a currency carrying three decimals (KWD, TND) reads them as
decimals. `coerce` passes the column's code, so the parser can ask. Bare typed
input keeps the decimal reading.

Also: the unchanged-type throw fell through to a 500 for every type except
currency, whose message happened to contain the word; it now maps to 400. And
the last three comments describing the removed two-transaction architecture are
gone — the previous commit claimed they were and two survived.

Documented, and failing closed rather than guessing: markers written flush
against the digits (`Rp12,00`) stay rejected, because a letter touching a digit
is the only thing distinguishing a currency marker from a part number, and
reading `SKU400` as 400 invents a value where refusing merely inconveniences.

Author: waleedlatif1

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

@@ -323,7 +323,8 @@ export const PATCH = withRouteHandler(async (request: NextRequest, context: Colu
       msg.includes('incompatible') ||
       msg.includes('duplicate') ||
       msg.includes('option') ||
-      msg.includes('currency')
+      msg.includes('currency') ||
+      msg.includes('is already type')
     ) {
       return NextResponse.json({ error: msg }, { status: 400 })
     }

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

@@ -368,7 +368,8 @@ export const PATCH = withRouteHandler(async (request: NextRequest, context: Colu
         msg.includes('incompatible') ||
         msg.includes('duplicate') ||
         msg.includes('option') ||
-        msg.includes('currency')
+        msg.includes('currency') ||
+        msg.includes('is already type')
       ) {
         return NextResponse.json({ error: msg }, { status: 400 })
       }

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

@@ -160,6 +160,29 @@ describe('parseCurrencyInput', () => {
     expect(parseCurrencyInput('CHF 1’234.56')).toBe(1234.56)
   })
 
+  it('resolves a lone separator using the marker and the currency', () => {
+    // `1.235 ¥` is 1235 yen; a typed `1.235` is one-and-a-bit. A marker means a
+    // formatter produced it, and formatters group — except for the currencies
+    // that genuinely carry three decimals.
+    expect(parseCurrencyInput('1.235 ¥', 'JPY')).toBe(1235)
+    expect(parseCurrencyInput('0,500 KWD', 'KWD')).toBe(0.5)
+    expect(parseCurrencyInput('12,000 TND', 'TND')).toBe(12)
+    // Bare input keeps the typed reading.
+    expect(parseCurrencyInput('1.234')).toBe(1.234)
+    expect(parseCurrencyInput('1,500')).toBe(1500)
+  })
+
+  it('refuses a scale suffix rather than shrinking the value', () => {
+    // `1.2 M` read as 1.2 would rewrite a column of millions a millionfold too
+    // small — the same invented-value failure as an identifier, inverted.
+    expect(parseCurrencyInput('1.2 M')).toBeNull()
+    expect(parseCurrencyInput('5 K')).toBeNull()
+    expect(parseCurrencyInput('3.4 bn')).toBeNull()
+    expect(parseCurrencyInput('10 B')).toBeNull()
+    // `kr` is a currency marker, not a scale suffix, despite starting with k.
+    expect(parseCurrencyInput('1 234,56 kr')).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

apps/sim/lib/table/column-types/currency.ts

@@ -27,11 +27,11 @@ export const currencyColumnType: ColumnTypeDefinition = {
   typeaheadPattern: /[\d.,\-\p{Sc}]/u,
   parseErrorMessage: 'Invalid amount',
 
-  coerce(value) {
+  coerce(value, column) {
     // Stored as a bare number, but accepts the formatted shapes an amount
     // arrives in — `$1,234.56`, `1 234,56 €`, `(12.00)` — so a paste, CSV
     // import, or tool write lands as a number rather than being nulled.
-    const parsed = parseCurrencyInput(value)
+    const parsed = parseCurrencyInput(value, column.currencyCode)
     return parsed === null ? { ok: false } : { ok: true, value: parsed }
   },
 

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

@@ -749,15 +749,14 @@ export async function updateColumnType(
     // once the column is text/number/etc. Check compatibility against the option
     // NAME — that's what the cell will actually become (migrated below).
     const convertingAwayFromSelect = column.type === 'select' && !isSelectType
-    // The constraint the column ends up with, which may be arriving in this same
-    // request. `updateColumnConstraints` runs as its own transaction afterwards,
-    // so validating against the column's CURRENT flag would let the conversion
-    // commit and only then fail the constraint.
+    // The constraint the column ends up with, which may be arriving in this
+    // same request — this write applies it, so the scan below has to judge
+    // against the target value rather than the current one.
     const targetRequired = !!(data.required ?? column.required)
 
     // Rows missing the key (or holding null/`[]`) are filtered out of `rows`
     // entirely, so the loop below can never see them — they have to be counted
-    // separately, through the same predicate the constraint write will use.
+    // separately, through the same predicate `applyConstraints` uses.
     if (targetRequired) {
       const emptyCount = await countEmptyCells(trx, data.tableId, columnKey)
       if (emptyCount > 0) {

apps/sim/lib/table/currency.ts

@@ -24,6 +24,12 @@ const BIDI_MARKS = /[\u200e\u200f\u061c\u202a-\u202e\u2066-\u2069]/g
 /** Minus-sign characters `Intl` emits in place of the ASCII hyphen. */
 const UNICODE_MINUS = /[\u2212\u2012\u2013\uFE63\uFF0D]/g
 
+/**
+ * A magnitude suffix (`1.2 M`, `5 K`, `3.4 bn`). Not a currency marker, and
+ * stripping it would silently shrink the value by orders of magnitude.
+ */
+const SCALE_SUFFIX = /\d\s*(?:k|m|b|t|bn|mn|tn|mm|mil|bil)\.?\s*$/i
+
 /** A letter directly adjacent to a digit: an identifier, not an amount. */
 const LETTER_TOUCHING_DIGIT = /\p{L}\d|\d\p{L}/u
 
@@ -171,15 +177,23 @@ export function getCurrencyOptions(): readonly CurrencyOption[] {
  * therefore read as fifteen hundred — a known ambiguity that resolves in favor
  * of the far more common reading.
  *
- * Reads ASCII digits only. Locales that format with their own numeral systems
- * (Arabic-Indic `١٢٣`, for instance) are rejected rather than misread —
- * supporting them is a wider decision than this type, since it would also
- * touch `number`, display, and sorting.
+ * Two input families are deliberately refused rather than guessed at, because
+ * both would otherwise be misread as an amount rather than rejected:
+ *
+ * - Markers written flush against the digits (`Rp12,00`). A letter touching a
+ *   digit is the only thing separating a currency marker from a part number,
+ *   and reading `SKU400` as 400 invents a value where refusing merely
+ *   inconveniences. Markers separated by a space or a symbol all work.
+ * - Locales formatting with their own numeral systems (Arabic-Indic `١٢٣`).
+ *   Supporting them is a wider decision than this type, since it would also
+ *   touch `number`, display, and sorting.
+ *
+ * Both fail closed — `null`, never a wrong number.
  *
  * Returns `null` when no amount can be read, so callers can distinguish
  * "unparseable" from a legitimate `0`.
  */
-export function parseCurrencyInput(raw: unknown): number | null {
+export function parseCurrencyInput(raw: unknown, currencyCode?: string): number | null {
   if (typeof raw === 'number') return Number.isFinite(raw) ? raw : null
   if (typeof raw !== 'string') return null
 
@@ -219,14 +233,23 @@ export function parseCurrencyInput(raw: unknown): number | null {
   // by a space or a symbol, so this distinguishes them without a symbol list.
   if (LETTER_TOUCHING_DIGIT.test(body)) return null
 
+  // A scale suffix is not a currency marker, and dropping it loses orders of
+  // magnitude: `1.2 M` would read as 1.2, so a column of `1.2 M` / `3.4 M`
+  // would convert cleanly and rewrite every cell a millionfold too small.
+  // Refuse rather than guess what the writer meant.
+  if (SCALE_SUFFIX.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(CURRENCY_MARKER_PREFIX, '$1')
-    .replace(CURRENCY_MARKER_SUFFIX, '')
-    .replace(/[\s\u00a0\u202f\u2019']/gu, '')
+  const withoutPrefix = body.replace(CURRENCY_MARKER_PREFIX, '$1')
+  const withoutMarkers = withoutPrefix.replace(CURRENCY_MARKER_SUFFIX, '')
+  // Whether a marker was present at all. A marked string came from a
+  // formatter; a bare one was typed by a person. That distinguishes the two
+  // readings of a lone separator followed by three digits, below.
+  const hadMarker = withoutMarkers !== body
+  const cleaned = withoutMarkers.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
@@ -246,19 +269,25 @@ export function parseCurrencyInput(raw: unknown): number | null {
     if (decimalParts.length > 1 || !hasValidGrouping(integerPart, groupSeparator)) return null
     normalized = `${integerPart.split(groupSeparator).join('')}.${decimalParts[0]}`
   } else if (lastComma !== -1) {
-    // A single comma followed by exactly three digits is grouping (`1,500`);
-    // anything else is a decimal comma (`1,50`).
-    const grouping = digitsAndSeps.indexOf(',') !== lastComma || /,\d{3}$/.test(digitsAndSeps)
+    const repeated = digitsAndSeps.indexOf(',') !== lastComma
+    const grouping =
+      repeated || loneSeparatorIsGrouping(digitsAndSeps, ',', hadMarker, currencyCode)
     if (grouping) {
       if (!hasValidGrouping(digitsAndSeps, ',')) return null
       normalized = digitsAndSeps.split(',').join('')
     } else {
       normalized = digitsAndSeps.replace(',', '.')
     }
-  } else if (lastDot !== -1 && digitsAndSeps.indexOf('.') !== lastDot) {
-    // More than one dot can only be grouping: `1.234.567`.
-    if (!hasValidGrouping(digitsAndSeps, '.')) return null
-    normalized = digitsAndSeps.split('.').join('')
+  } else if (lastDot !== -1) {
+    const repeated = digitsAndSeps.indexOf('.') !== lastDot
+    const grouping =
+      repeated || loneSeparatorIsGrouping(digitsAndSeps, '.', hadMarker, currencyCode)
+    if (grouping) {
+      if (!hasValidGrouping(digitsAndSeps, '.')) return null
+      normalized = digitsAndSeps.split('.').join('')
+    } else {
+      normalized = digitsAndSeps
+    }
   } else {
     normalized = digitsAndSeps
   }
@@ -268,6 +297,35 @@ export function parseCurrencyInput(raw: unknown): number | null {
   return negative ? -parsed : parsed
 }
 
+/**
+ * Whether a lone separator followed by exactly three digits is grouping rather
+ * than a decimal point — `1.235 ¥` is one thousand two hundred thirty-five yen,
+ * while a typed `1.235` is one and a bit.
+ *
+ * Two signals resolve it. A marker means the string came from a formatter, and
+ * formatters group; a bare string was typed by a person, who meant decimals.
+ * And a currency with three decimal places (KWD, TND) legitimately ends in
+ * three digits after its separator, so for those the reading is always decimal.
+ */
+function loneSeparatorIsGrouping(
+  digitsAndSeps: string,
+  separator: string,
+  hadMarker: boolean,
+  currencyCode: string | undefined
+): boolean {
+  if (!new RegExp(`\\${separator}\\d{3}$`).test(digitsAndSeps)) return false
+  if (separator === ',' && !hadMarker) return true
+  if (!hadMarker) return false
+  return currencyFractionDigits(currencyCode) !== 3
+}
+
+/** A currency's conventional decimal places, defaulting to 2 when unknown. */
+function currencyFractionDigits(currencyCode: string | undefined): number {
+  if (!currencyCode) return 2
+  const formatter = currencyFormatter(resolveCurrencyCode(currencyCode), undefined)
+  return formatter?.resolvedOptions().maximumFractionDigits ?? 2
+}
+
 /**
  * Formatters are cached by locale + code: a grid paints thousands of currency
  * cells per scroll, and constructing an `Intl.NumberFormat` per cell is orders