@open-mercato/core 0.6.7 → 0.6.8-develop.6875.1.871a4afc94

package/src/modules/dashboards/lib/exactDecimal.ts

@@ -0,0 +1,96 @@
+/**
+ * Minimal exact decimal arithmetic for application-side aggregation of PostgreSQL `numeric`
+ * columns. The SQL path sums money in `numeric` and converts once, so the application path must
+ * not accumulate in binary floating point — `0.1 + 0.2` would drift the totals of encrypted group
+ * sources away from the plaintext ones (#4622).
+ *
+ * A value is stored as scaled integer `units` plus a decimal `scale`, so `12.34` is
+ * `{ units: 1234n, scale: 2 }`. Conversion to `number` happens only at the response boundary.
+ */
+
+export type ExactDecimal = {
+  units: bigint
+  scale: number
+}
+
+const DECIMAL_PATTERN = /^([+-]?)(\d*)(?:\.(\d*))?(?:[eE]([+-]?\d+))?$/
+
+export const EXACT_DECIMAL_ZERO: ExactDecimal = { units: 0n, scale: 0 }
+
+function pow10(exponent: number): bigint {
+  return 10n ** BigInt(exponent)
+}
+
+/**
+ * Parses a `numeric` column value. The PostgreSQL driver hands these over as strings to preserve
+ * precision, so the string form is authoritative; numbers and bigints are accepted for callers that
+ * already hold a JavaScript value. Returns `null` for anything that is not a finite decimal.
+ */
+export function parseExactDecimal(raw: unknown): ExactDecimal | null {
+  if (raw === null || raw === undefined) return null
+  if (typeof raw === 'bigint') return { units: raw, scale: 0 }
+
+  let text: string
+  if (typeof raw === 'number') {
+    if (!Number.isFinite(raw)) return null
+    text = String(raw)
+  } else if (typeof raw === 'string') {
+    text = raw.trim()
+  } else {
+    return null
+  }
+
+  if (!text) return null
+
+  const match = DECIMAL_PATTERN.exec(text)
+  if (!match) return null
+
+  const [, sign, intPart = '', fracPart = '', exponentPart] = match
+  if (!intPart && !fracPart) return null
+
+  const digits = `${intPart}${fracPart}`
+  let units = BigInt(digits)
+  let scale = fracPart.length
+
+  if (exponentPart) {
+    scale -= Number(exponentPart)
+    if (scale < 0) {
+      units *= pow10(-scale)
+      scale = 0
+    }
+  }
+
+  if (sign === '-') units = -units
+  return { units, scale }
+}
+
+function rescale(value: ExactDecimal, scale: number): bigint {
+  return scale === value.scale ? value.units : value.units * pow10(scale - value.scale)
+}
+
+export function addExactDecimal(left: ExactDecimal, right: ExactDecimal): ExactDecimal {
+  const scale = Math.max(left.scale, right.scale)
+  return { units: rescale(left, scale) + rescale(right, scale), scale }
+}
+
+export function compareExactDecimal(left: ExactDecimal, right: ExactDecimal): number {
+  const scale = Math.max(left.scale, right.scale)
+  const leftUnits = rescale(left, scale)
+  const rightUnits = rescale(right, scale)
+  if (leftUnits === rightUnits) return 0
+  return leftUnits < rightUnits ? -1 : 1
+}
+
+export function exactDecimalToString(value: ExactDecimal): string {
+  const negative = value.units < 0n
+  const digits = (negative ? -value.units : value.units).toString().padStart(value.scale + 1, '0')
+  const boundary = digits.length - value.scale
+  const integerPart = digits.slice(0, boundary)
+  const fractionPart = value.scale > 0 ? digits.slice(boundary) : ''
+  return `${negative ? '-' : ''}${integerPart}${fractionPart ? `.${fractionPart}` : ''}`
+}
+
+/** Response-boundary conversion: the only place where the exact value becomes a binary float. */
+export function exactDecimalToNumber(value: ExactDecimal): number {
+  return Number(exactDecimalToString(value))
+}

package/src/modules/dashboards/lib/formatters.ts

@@ -1,36 +1,161 @@
 export type FormatCurrencyOptions = {
-  currency?: string
+  currency?: string | null
+  locale?: string
   minimumFractionDigits?: number
   maximumFractionDigits?: number
 }
 
-export function formatCurrency(value: number, options: FormatCurrencyOptions = {}): string {
-  const { currency = 'USD', minimumFractionDigits = 0, maximumFractionDigits = 0 } = options
-  return new Intl.NumberFormat(undefined, {
-    style: 'currency',
-    currency,
+export type FormatCurrencyCompactOptions = {
+  currency?: string | null
+  locale?: string
+}
+
+const CURRENCY_CODE_PATTERN = /^[A-Za-z]{3}$/
+const NUMBER_FORMATTER_CACHE_LIMIT = 128
+const numberFormatterCache = new Map<string, Intl.NumberFormat>()
+
+function normalizeCurrencyCode(currency?: string | null): string | null {
+  if (typeof currency !== 'string') return null
+  const trimmed = currency.trim()
+  if (!CURRENCY_CODE_PATTERN.test(trimmed)) return null
+  return trimmed.toUpperCase()
+}
+
+function getNumberFormatter(
+  locale: string | undefined,
+  options: Intl.NumberFormatOptions,
+): Intl.NumberFormat {
+  const key = `${locale ?? ''}:${JSON.stringify(options)}`
+  const cached = numberFormatterCache.get(key)
+  if (cached) return cached
+  const formatter = new Intl.NumberFormat(locale, options)
+  if (numberFormatterCache.size >= NUMBER_FORMATTER_CACHE_LIMIT) {
+    const oldest = numberFormatterCache.keys().next().value
+    if (oldest) numberFormatterCache.delete(oldest)
+  }
+  numberFormatterCache.set(key, formatter)
+  return formatter
+}
+
+function formatDecimal(
+  value: number,
+  minimumFractionDigits: number,
+  maximumFractionDigits: number,
+  locale?: string,
+): string {
+  return getNumberFormatter(locale, {
+    style: 'decimal',
     minimumFractionDigits,
     maximumFractionDigits,
   }).format(value)
 }
 
+/**
+ * Formats a monetary amount. Without a currency code the amount renders as a plain
+ * number: analytics values carry no currency of their own, and labelling them with a
+ * guessed one (see #4620) is worse than leaving them unlabelled.
+ */
+export function formatCurrency(value: number, options: FormatCurrencyOptions = {}): string {
+  const { currency, locale, minimumFractionDigits = 0, maximumFractionDigits = 0 } = options
+  const code = normalizeCurrencyCode(currency)
+  if (!code) return formatDecimal(value, minimumFractionDigits, maximumFractionDigits, locale)
+  try {
+    return getNumberFormatter(locale, {
+      style: 'currency',
+      currency: code,
+      minimumFractionDigits,
+      maximumFractionDigits,
+    }).format(value)
+  } catch {
+    return `${formatDecimal(value, minimumFractionDigits, maximumFractionDigits, locale)} ${code}`
+  }
+}
+
 export function formatCurrencyWithDecimals(value: number, options: FormatCurrencyOptions = {}): string {
   return formatCurrency(value, { minimumFractionDigits: 2, maximumFractionDigits: 2, ...options })
 }
 
-export function formatCurrencyCompact(value: number, currencySymbol = '$'): string {
+function formatWithLiteralSymbol(value: number, symbol: string): string {
   if (Math.abs(value) >= 1_000_000) {
-    return `${currencySymbol}${(value / 1_000_000).toFixed(1)}M`
+    return `${symbol}${(value / 1_000_000).toFixed(1)}M`
   }
   if (Math.abs(value) >= 1_000) {
-    return `${currencySymbol}${(value / 1_000).toFixed(1)}K`
+    return `${symbol}${(value / 1_000).toFixed(1)}K`
   }
-  return `${currencySymbol}${value.toFixed(0)}`
+  return `${symbol}${value.toFixed(0)}`
 }
 
-export function formatCurrencySafe(value: unknown, fallback = '--'): string {
+export function formatCurrencyCompact(
+  value: number,
+  currencyOrOptions: string | null | FormatCurrencyCompactOptions = {},
+): string {
+  if (typeof currencyOrOptions === 'string' && !normalizeCurrencyCode(currencyOrOptions)) {
+    return formatWithLiteralSymbol(value, currencyOrOptions)
+  }
+
+  const options = typeof currencyOrOptions === 'string'
+    ? { currency: currencyOrOptions }
+    : (currencyOrOptions ?? {})
+  const code = normalizeCurrencyCode(options.currency)
+  const compact = Math.abs(value) >= 1_000
+  const formatOptions: Intl.NumberFormatOptions = {
+    style: code ? 'currency' : 'decimal',
+    notation: compact ? 'compact' : 'standard',
+    compactDisplay: 'short',
+    minimumFractionDigits: compact ? 1 : 0,
+    maximumFractionDigits: compact ? 1 : 0,
+  }
+  if (code) formatOptions.currency = code
+
+  try {
+    return getNumberFormatter(options.locale, formatOptions).format(value)
+  } catch {
+    const formatted = getNumberFormatter(options.locale, {
+      style: 'decimal',
+      notation: compact ? 'compact' : 'standard',
+      compactDisplay: 'short',
+      minimumFractionDigits: compact ? 1 : 0,
+      maximumFractionDigits: compact ? 1 : 0,
+    }).format(value)
+    return code ? `${formatted} ${code}` : formatted
+  }
+}
+
+export function formatCurrencySafe(
+  value: unknown,
+  fallback = '--',
+  options: FormatCurrencyOptions = {},
+): string {
   if (value === null || value === undefined) return fallback
   const num = Number(value)
   if (!Number.isFinite(num)) return fallback
-  return formatCurrency(num)
+  return formatCurrency(num, options)
+}
+
+export type CurrencyFormatters = {
+  currency: string | null
+  format: (value: number) => string
+  formatWithDecimals: (value: number) => string
+  formatCompact: (value: number) => string
+  formatSafe: (value: unknown) => string
+}
+
+/**
+ * Binds the resolved currency once so widgets can hand chart and KPI components a
+ * stable single-argument formatter — passing `formatCurrency` by reference is what
+ * made its currency option unreachable in the first place (#4620).
+ */
+export function createCurrencyFormatters(
+  currency?: string | null,
+  fallback = '--',
+  locale?: string,
+): CurrencyFormatters {
+  const code = normalizeCurrencyCode(currency)
+  return {
+    currency: code,
+    format: (value: number) => formatCurrency(value, { currency: code, locale }),
+    formatWithDecimals: (value: number) => formatCurrencyWithDecimals(value, { currency: code, locale }),
+    formatCompact: (value: number) => formatCurrencyCompact(value, { currency: code, locale }),
+    formatSafe: (value: unknown) => formatCurrencySafe(value, fallback, { currency: code, locale }),
+  }
 }

package/src/modules/dashboards/lib/optionalBaseCurrency.ts

@@ -0,0 +1,22 @@
+import type { AppContainer } from '@open-mercato/shared/lib/di/container'
+
+export type BaseCurrencyResolution =
+  | { status: 'resolved'; code: string }
+  | { status: 'missing' | 'ambiguous' | 'unavailable' }
+
+export type BaseCurrencyResolver = {
+  resolveBaseCurrency(scope: {
+    tenantId: string
+    organizationIds: string[]
+  }): Promise<BaseCurrencyResolution>
+}
+
+export function resolveOptionalBaseCurrencyResolver(
+  container: AppContainer,
+): BaseCurrencyResolver | undefined {
+  try {
+    return container.resolve<BaseCurrencyResolver>('baseCurrencyService')
+  } catch {
+    return undefined
+  }
+}