@open-mercato/core 0.6.7-develop.6863.1.61001cf9a8 → 0.6.7

package/src/modules/dashboards/api/widgets/data/schema.ts

@@ -18,54 +18,17 @@ export const dateRangePresetSchema = z.enum([
   'last_90_days',
 ])
 
-const comparisonFilterOperators = ['eq', 'neq', 'gt', 'gte', 'lt', 'lte'] as const
-const setFilterOperators = ['in', 'not_in'] as const
-const nullFilterOperators = ['is_null', 'is_not_null'] as const
-const scalarFilterOperators = [...comparisonFilterOperators, ...nullFilterOperators] as const
-
-const scalarFilterOperatorSchema = z.enum(scalarFilterOperators)
-const setFilterOperatorSchema = z.enum(setFilterOperators)
-
 export const filterOperatorSchema = z.enum([
-  ...comparisonFilterOperators,
-  ...setFilterOperators,
-  ...nullFilterOperators,
-])
-
-/**
- * Upper bound on how many members an `in` / `not_in` widget-data filter may carry (#4852).
- *
- * Every member becomes one placeholder plus one bound parameter in the aggregation's WHERE
- * clause, so the cost of a set filter is proportional to its length. The bound lives here
- * rather than in the SQL builder because `buildWhereClause` can only truncate the list —
- * silently returning an answer to a different question than the caller asked — or throw from
- * deep inside query construction; validating here yields a 400 that names the offending
- * filter and is published in the route's OpenAPI schema.
- *
- * 200 is deliberately generous for a dashboard filter: the widest grouping a widget can render
- * is capped at 100 buckets (`groupBy.limit`), and a batch carries at most 50 requests, so even
- * a fully saturated batch stays an order of magnitude below PostgreSQL's per-statement limit
- * of 65535 bound parameters. Raising it later is a one-line change to this constant.
- */
-export const MAX_SET_FILTER_VALUES = 200
-
-// `IN` / `NOT IN` compare against literals; a null member never matches either way, which is
-// what the dedicated `is_null` / `is_not_null` operators are for.
-const setFilterMemberSchema = z.union([z.string(), z.number(), z.boolean()])
-
-const setFilterValueSchema = z.array(setFilterMemberSchema).max(MAX_SET_FILTER_VALUES)
-
-const widgetDataFilterSchema = z.discriminatedUnion('operator', [
-  z.object({
-    field: z.string().min(1),
-    operator: setFilterOperatorSchema,
-    value: setFilterValueSchema,
-  }),
-  z.object({
-    field: z.string().min(1),
-    operator: scalarFilterOperatorSchema,
-    value: z.unknown().optional(),
-  }),
+  'eq',
+  'neq',
+  'gt',
+  'gte',
+  'lt',
+  'lte',
+  'in',
+  'not_in',
+  'is_null',
+  'is_not_null',
 ])
 
 export const widgetDataRequestSchema = z.object({
@@ -82,7 +45,15 @@ export const widgetDataRequestSchema = z.object({
       resolveLabels: z.boolean().optional(),
     })
     .optional(),
-  filters: z.array(widgetDataFilterSchema).optional(),
+  filters: z
+    .array(
+      z.object({
+        field: z.string().min(1),
+        operator: filterOperatorSchema,
+        value: z.unknown().optional(),
+      }),
+    )
+    .optional(),
   dateRange: z
     .object({
       field: z.string().min(1),
@@ -115,6 +86,5 @@ export const widgetDataResponseSchema = z.object({
   metadata: z.object({
     fetchedAt: z.string(),
     recordCount: z.number(),
-    currency: z.string().nullable().optional(),
   }),
 })

package/src/modules/dashboards/i18n/de.json

@@ -15,8 +15,6 @@
   "dashboards.analytics.comparison.vsWeekBefore": "vs Woche davor",
   "dashboards.analytics.comparison.vsYearBefore": "vs Jahr davor",
   "dashboards.analytics.comparison.vsYesterday": "vs gestern",
-  "dashboards.analytics.currency.unlabelled": "Beträge ohne Währungsangabe",
-  "dashboards.analytics.currency.unlabelledHint": "Eine verlässliche Währung konnte nicht ermittelt werden, daher wird der Betrag ohne Währungsangabe angezeigt.",
   "dashboards.analytics.dateRange.last30Days": "Letzte 30 Tage",
   "dashboards.analytics.dateRange.last7Days": "Letzte 7 Tage",
   "dashboards.analytics.dateRange.last90Days": "Letzte 90 Tage",
@@ -54,9 +52,6 @@
   "dashboards.analytics.settings.chartLayout": "Diagramm-Layout",
   "dashboards.analytics.settings.chartVariant": "Diagrammstil",
   "dashboards.analytics.settings.dateRange": "Zeitraum",
-  "dashboards.analytics.settings.dealStatusScope": "Berücksichtigte Deals",
-  "dashboards.analytics.settings.dealStatusScopeAll": "Alle Deals, einschließlich gewonnener und verlorener",
-  "dashboards.analytics.settings.dealStatusScopeOpen": "Nur offene Deals",
   "dashboards.analytics.settings.granularity": "Granularität",
   "dashboards.analytics.settings.horizontal": "Horizontal",
   "dashboards.analytics.settings.limit": "Anzahl der Elemente",

package/src/modules/dashboards/i18n/en.json

@@ -15,8 +15,6 @@
   "dashboards.analytics.comparison.vsWeekBefore": "vs week before",
   "dashboards.analytics.comparison.vsYearBefore": "vs year before",
   "dashboards.analytics.comparison.vsYesterday": "vs yesterday",
-  "dashboards.analytics.currency.unlabelled": "Amounts shown without a currency",
-  "dashboards.analytics.currency.unlabelledHint": "A reliable currency could not be determined, so the amount is shown without one.",
   "dashboards.analytics.dateRange.last30Days": "Last 30 Days",
   "dashboards.analytics.dateRange.last7Days": "Last 7 Days",
   "dashboards.analytics.dateRange.last90Days": "Last 90 Days",
@@ -54,9 +52,6 @@
   "dashboards.analytics.settings.chartLayout": "Chart Layout",
   "dashboards.analytics.settings.chartVariant": "Chart Style",
   "dashboards.analytics.settings.dateRange": "Date Range",
-  "dashboards.analytics.settings.dealStatusScope": "Deals included",
-  "dashboards.analytics.settings.dealStatusScopeAll": "All deals, including won and lost",
-  "dashboards.analytics.settings.dealStatusScopeOpen": "Open deals only",
   "dashboards.analytics.settings.granularity": "Granularity",
   "dashboards.analytics.settings.horizontal": "Horizontal",
   "dashboards.analytics.settings.limit": "Number of items",

package/src/modules/dashboards/i18n/es.json

@@ -15,8 +15,6 @@
   "dashboards.analytics.comparison.vsWeekBefore": "vs semana anterior",
   "dashboards.analytics.comparison.vsYearBefore": "vs año anterior",
   "dashboards.analytics.comparison.vsYesterday": "vs ayer",
-  "dashboards.analytics.currency.unlabelled": "Importes mostrados sin moneda",
-  "dashboards.analytics.currency.unlabelledHint": "No se pudo determinar una moneda fiable, por lo que el importe se muestra sin moneda.",
   "dashboards.analytics.dateRange.last30Days": "Últimos 30 días",
   "dashboards.analytics.dateRange.last7Days": "Últimos 7 días",
   "dashboards.analytics.dateRange.last90Days": "Últimos 90 días",
@@ -54,9 +52,6 @@
   "dashboards.analytics.settings.chartLayout": "Disposición del gráfico",
   "dashboards.analytics.settings.chartVariant": "Estilo de gráfico",
   "dashboards.analytics.settings.dateRange": "Rango de fechas",
-  "dashboards.analytics.settings.dealStatusScope": "Oportunidades incluidas",
-  "dashboards.analytics.settings.dealStatusScopeAll": "Todas las oportunidades, incluidas ganadas y perdidas",
-  "dashboards.analytics.settings.dealStatusScopeOpen": "Solo oportunidades abiertas",
   "dashboards.analytics.settings.granularity": "Granularidad",
   "dashboards.analytics.settings.horizontal": "Horizontal",
   "dashboards.analytics.settings.limit": "Número de elementos",

package/src/modules/dashboards/i18n/pl.json

@@ -15,8 +15,6 @@
   "dashboards.analytics.comparison.vsWeekBefore": "vs tydzien wczesniej",
   "dashboards.analytics.comparison.vsYearBefore": "vs rok wczesniej",
   "dashboards.analytics.comparison.vsYesterday": "vs wczoraj",
-  "dashboards.analytics.currency.unlabelled": "Kwoty pokazane bez waluty",
-  "dashboards.analytics.currency.unlabelledHint": "Nie udało się wiarygodnie ustalić waluty, dlatego kwota jest wyświetlana bez jej oznaczenia.",
   "dashboards.analytics.dateRange.last30Days": "Ostatnie 30 dni",
   "dashboards.analytics.dateRange.last7Days": "Ostatnie 7 dni",
   "dashboards.analytics.dateRange.last90Days": "Ostatnie 90 dni",
@@ -54,9 +52,6 @@
   "dashboards.analytics.settings.chartLayout": "Układ wykresu",
   "dashboards.analytics.settings.chartVariant": "Styl wykresu",
   "dashboards.analytics.settings.dateRange": "Zakres dat",
-  "dashboards.analytics.settings.dealStatusScope": "Uwzględnione szanse",
-  "dashboards.analytics.settings.dealStatusScopeAll": "Wszystkie szanse, w tym wygrane i przegrane",
-  "dashboards.analytics.settings.dealStatusScopeOpen": "Tylko otwarte szanse",
   "dashboards.analytics.settings.granularity": "Szczegółowość",
   "dashboards.analytics.settings.horizontal": "Poziomy",
   "dashboards.analytics.settings.limit": "Liczba elementów",

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

@@ -1,7 +1,7 @@
 import type { EntityManager } from '@mikro-orm/postgresql'
 import { DashboardRoleWidgets, DashboardUserWidgets } from '../data/entities'
 import { UserRole } from '@open-mercato/core/modules/auth/data/entities'
-import { authorizeFeatures } from '@open-mercato/shared/security/featurePolicy'
+import { hasAllFeatures as userHasAllFeatures } from '@open-mercato/shared/security/features'
 import { findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
 
 type LoadedWidget = {
@@ -97,10 +97,8 @@ export async function resolveAllowedWidgetIds(
 
   const filtered = widgets.filter((widget) => {
     if (!baseSet.has(widget.metadata.id)) return false
-    return authorizeFeatures(widget.metadata.features ?? [], {
-      grantedFeatures: ctx.features,
-      unrestricted: ctx.isSuperAdmin,
-    })
+    if (ctx.isSuperAdmin) return true
+    return userHasAllFeatures(ctx.features, widget.metadata.features ?? [])
   })
 
   return filtered.map((widget) => widget.metadata.id)

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

@@ -97,87 +97,54 @@ export type BuildAggregationQueryOptions = {
   registry: AnalyticsRegistry
 }
 
-export type ResolvedGroupExpression = {
-  expression: string
-  /** Column the group expression reads from — the encryption map is keyed by this. */
-  dbColumn: string
-  /** JSONB path below `dbColumn`, when the groupBy field used path notation. */
-  jsonPath: string | null
-}
+export function buildAggregationQuery(options: BuildAggregationQueryOptions): AggregationQuery | null {
+  const { registry } = options
+  const config = registry.getEntityTypeConfig(options.entityType)
+  if (!config) return null
 
-/**
- * Resolves the SQL expression a groupBy field maps to, together with the underlying column so
- * callers can decide whether the source is encrypted at rest before grouping over it (#4622).
- */
-export function resolveGroupExpression(
-  registry: AnalyticsRegistry,
-  entityType: string,
-  groupBy: { field: string; granularity?: DateGranularity },
-): ResolvedGroupExpression | null {
-  const groupMapping = registry.getFieldMapping(entityType, groupBy.field)
+  const metricMapping = registry.getFieldMapping(options.entityType, options.metric.field)
+  if (!metricMapping) return null
 
-  // Handle JSONB path notation (e.g., shippingAddressSnapshot.region)
-  if (!groupMapping && groupBy.field.includes('.')) {
-    const [baseField, ...pathParts] = groupBy.field.split('.')
-    const baseMapping = registry.getFieldMapping(entityType, baseField)
-    if (baseMapping?.type !== 'jsonb') return null
-    const jsonPath = pathParts.join('.')
-    return {
-      expression: buildJsonbFieldExpression(baseMapping.dbColumn, jsonPath),
-      dbColumn: baseMapping.dbColumn,
-      jsonPath,
-    }
-  }
+  const params: unknown[] = []
+
+  const tableName = config.schema ? `"${config.schema}"."${config.tableName}"` : `"${config.tableName}"`
+  const aggregateExpr = buildAggregateExpression(options.metric.aggregate, metricMapping.dbColumn)
 
-  if (!groupMapping) return null
+  let selectClause = `SELECT ${aggregateExpr} AS value`
+  let groupByClause = ''
+  let orderByClause = ''
+  let limitClause = ''
 
-  if (groupMapping.type === 'timestamp' && groupBy.granularity) {
-    return {
-      expression: buildDateTruncExpression(groupMapping.dbColumn, groupBy.granularity),
-      dbColumn: groupMapping.dbColumn,
-      jsonPath: null,
+  if (options.groupBy) {
+    let groupMapping = registry.getFieldMapping(options.entityType, options.groupBy.field)
+    let groupExpr: string | null = null
+
+    // Handle JSONB path notation (e.g., shippingAddressSnapshot.region)
+    if (!groupMapping && options.groupBy.field.includes('.')) {
+      const [baseField, ...pathParts] = options.groupBy.field.split('.')
+      const baseMapping = registry.getFieldMapping(options.entityType, baseField)
+      if (baseMapping?.type === 'jsonb') {
+        groupExpr = buildJsonbFieldExpression(baseMapping.dbColumn, pathParts.join('.'))
+      }
+    } else if (groupMapping) {
+      if (groupMapping.type === 'timestamp' && options.groupBy.granularity) {
+        groupExpr = buildDateTruncExpression(groupMapping.dbColumn, options.groupBy.granularity)
+      } else {
+        groupExpr = groupMapping.dbColumn
+      }
     }
-  }
 
-  return { expression: groupMapping.dbColumn, dbColumn: groupMapping.dbColumn, jsonPath: null }
-}
+    if (groupExpr) {
+      selectClause = `SELECT ${groupExpr} AS group_key, ${aggregateExpr} AS value`
+      groupByClause = `GROUP BY ${groupExpr}`
+      orderByClause = `ORDER BY value DESC`
 
-/**
- * Normalizes the value of a set filter (`in` / `not_in`) into the list of members it selects.
- *
- * The list is rendered as one placeholder per member rather than as a single array parameter:
- * MikroORM does not bind parameters at the driver level — `AbstractSqlConnection.execute` calls
- * `platform.formatQuery`, which interpolates each value through `BasePostgreSqlPlatform.escape`,
- * and that renders a JavaScript array as a bare comma-separated list. The previous
- * `= ANY(?)` / `!= ALL(?)` form therefore produced `= ANY('a', 'b')`, which PostgreSQL rejects
- * for every shape of value (#4669).
- *
- * A missing value yields an empty set rather than a dropped filter, so an `in` filter the caller
- * failed to populate selects nothing instead of silently widening the result.
- *
- * A null or undefined *member* is refused instead of rendered. `column IN (NULL)` matches no row
- * and `column NOT IN ('a', NULL)` is NULL for every row, so such a member would return an empty
- * aggregation with no error — a silent zero on a reporting surface, which is worse than a loud
- * failure. Requests are already rejected at the API boundary by `widgetDataFilterSchema` in
- * `api/widgets/data/schema.ts`; this throw keeps in-process callers, whose filter values are
- * typed as `unknown`, from reaching the same silent path. Nullness is queried with the dedicated
- * `is_null` / `is_not_null` operators.
- */
-function normalizeSetFilterValues(value: unknown): unknown[] {
-  const values = Array.isArray(value) ? value : value === undefined ? [] : [value]
-  if (values.some((member) => member === null || member === undefined)) {
-    throw new Error(
-      '[internal] Set filter members must not be null or undefined — use the is_null / is_not_null operators to filter on nullness',
-    )
+      if (options.groupBy.limit && options.groupBy.limit > 0) {
+        limitClause = `LIMIT ${Math.min(options.groupBy.limit, 100)}`
+      }
+    }
   }
-  return values
-}
 
-function buildWhereClause(
-  options: Pick<BuildAggregationQueryOptions, 'entityType' | 'dateRange' | 'filters' | 'scope' | 'registry'>,
-): { clause: string; params: unknown[] } {
-  const { registry } = options
-  const params: unknown[] = []
   const whereClauses: string[] = []
 
   whereClauses.push(`tenant_id = ?`)
@@ -231,18 +198,13 @@ function buildWhereClause(
           params.push(filter.value)
           break
         case 'in':
-        case 'not_in': {
-          const values = normalizeSetFilterValues(filter.value)
-          if (values.length === 0) {
-            whereClauses.push(filter.operator === 'in' ? 'FALSE' : 'TRUE')
-            break
-          }
-          const keyword = filter.operator === 'in' ? 'IN' : 'NOT IN'
-          const placeholders = values.map(() => '?').join(', ')
-          whereClauses.push(`${filterMapping.dbColumn} ${keyword} (${placeholders})`)
-          params.push(...values)
+          whereClauses.push(`${filterMapping.dbColumn} = ANY(?)`)
+          params.push(filter.value)
+          break
+        case 'not_in':
+          whereClauses.push(`${filterMapping.dbColumn} != ALL(?)`)
+          params.push(filter.value)
           break
-        }
         case 'is_null':
           whereClauses.push(`${filterMapping.dbColumn} IS NULL`)
           break
@@ -253,123 +215,11 @@ function buildWhereClause(
     }
   }
 
-  return { clause: whereClauses.length > 0 ? `WHERE ${whereClauses.join(' AND ')}` : '', params }
-}
-
-function resolveTableName(config: EntityTypeConfig): string {
-  return config.schema ? `"${config.schema}"."${config.tableName}"` : `"${config.tableName}"`
-}
-
-export type BuildDistinctCurrencyQueryOptions = Pick<
-  BuildAggregationQueryOptions,
-  'entityType' | 'dateRange' | 'filters' | 'scope' | 'registry'
->
-
-/**
- * Builds the query that reads the distinct per-row currencies of the rows an aggregation
- * would sum, over exactly the same tenant/organization scope, date range and filters.
- * Returns `null` when the entity declares no `currencyField`, which means its amounts are
- * not per-row denominated and there is nothing to verify (#4676).
- */
-export function buildDistinctCurrencyQuery(
-  options: BuildDistinctCurrencyQueryOptions,
-): AggregationQuery | null {
-  const { registry } = options
-  const config = registry.getEntityTypeConfig(options.entityType)
-  if (!config?.currencyField) return null
-
-  const currencyMapping = registry.getFieldMapping(options.entityType, config.currencyField)
-  if (!currencyMapping || !isSafeIdentifier(currencyMapping.dbColumn)) return null
-
-  const where = buildWhereClause(options)
-  const normalizedCurrencyExpression = `UPPER(NULLIF(BTRIM(${currencyMapping.dbColumn}), ''))`
-  const sql = [
-    `SELECT DISTINCT ${normalizedCurrencyExpression} AS code`,
-    `FROM ${resolveTableName(config)}`,
-    where.clause,
-    'LIMIT 2',
-  ]
-    .filter(Boolean)
-    .join(' ')
-
-  return { sql, params: where.params }
-}
-
-export function buildAggregationQuery(options: BuildAggregationQueryOptions): AggregationQuery | null {
-  const { registry } = options
-  const config = registry.getEntityTypeConfig(options.entityType)
-  if (!config) return null
-
-  const metricMapping = registry.getFieldMapping(options.entityType, options.metric.field)
-  if (!metricMapping) return null
-
-  const tableName = resolveTableName(config)
-  const aggregateExpr = buildAggregateExpression(options.metric.aggregate, metricMapping.dbColumn)
-
-  let selectClause = `SELECT ${aggregateExpr} AS value`
-  let groupByClause = ''
-  let orderByClause = ''
-  let limitClause = ''
-
-  if (options.groupBy) {
-    const resolved = resolveGroupExpression(registry, options.entityType, options.groupBy)
-
-    if (resolved) {
-      selectClause = `SELECT ${resolved.expression} AS group_key, ${aggregateExpr} AS value`
-      groupByClause = `GROUP BY ${resolved.expression}`
-      // NULLS LAST is stated explicitly (PostgreSQL defaults DESC to NULLS FIRST) so a group limit
-      // keeps the highest-value buckets instead of the empty ones, and so the application-side
-      // encrypted path can mirror the same ordering (#4622).
-      orderByClause = `ORDER BY value DESC NULLS LAST`
-
-      if (options.groupBy.limit && options.groupBy.limit > 0) {
-        limitClause = `LIMIT ${Math.min(options.groupBy.limit, 100)}`
-      }
-    }
-  }
-
-  const where = buildWhereClause(options)
-
-  const sql = [selectClause, `FROM ${tableName}`, where.clause, groupByClause, orderByClause, limitClause]
-    .filter(Boolean)
-    .join(' ')
-
-  return { sql, params: where.params }
-}
-
-export type BuildGroupSourceRowsQueryOptions = Omit<BuildAggregationQueryOptions, 'groupBy'> & {
-  /** Column holding the (encrypted) group source, resolved via `resolveGroupExpression`. */
-  groupColumn: string
-  /** Hard cap on scanned rows; callers fetch `rowLimit + 1` to detect overflow. */
-  rowLimit: number
-}
-
-/**
- * Builds a per-row query for group sources that cannot be grouped in SQL because the column is
- * encrypted at rest. Returns the raw group source alongside the metric value so the caller can
- * decrypt, then aggregate in application code (#4622).
- */
-export function buildGroupSourceRowsQuery(options: BuildGroupSourceRowsQueryOptions): AggregationQuery | null {
-  const { registry } = options
-  const config = registry.getEntityTypeConfig(options.entityType)
-  if (!config) return null
-
-  const metricMapping = registry.getFieldMapping(options.entityType, options.metric.field)
-  if (!metricMapping) return null
-
-  if (!isSafeIdentifier(options.groupColumn)) {
-    throw new Error(`Invalid group column: ${options.groupColumn}`)
-  }
+  const whereClause = whereClauses.length > 0 ? `WHERE ${whereClauses.join(' AND ')}` : ''
 
-  const where = buildWhereClause(options)
-  const sql = [
-    `SELECT ${options.groupColumn} AS group_source, ${metricMapping.dbColumn} AS metric_value`,
-    `FROM ${resolveTableName(config)}`,
-    where.clause,
-    `LIMIT ${Math.max(1, Math.floor(options.rowLimit)) + 1}`,
-  ]
+  const sql = [selectClause, `FROM ${tableName}`, whereClause, groupByClause, orderByClause, limitClause]
     .filter(Boolean)
     .join(' ')
 
-  return { sql, params: where.params }
+  return { sql, params }
 }

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

@@ -1,161 +1,36 @@
 export type FormatCurrencyOptions = {
-  currency?: string | null
-  locale?: string
+  currency?: string
   minimumFractionDigits?: number
   maximumFractionDigits?: number
 }
 
-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',
+export function formatCurrency(value: number, options: FormatCurrencyOptions = {}): string {
+  const { currency = 'USD', minimumFractionDigits = 0, maximumFractionDigits = 0 } = options
+  return new Intl.NumberFormat(undefined, {
+    style: 'currency',
+    currency,
     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 })
 }
 
-function formatWithLiteralSymbol(value: number, symbol: string): string {
+export function formatCurrencyCompact(value: number, currencySymbol = '$'): string {
   if (Math.abs(value) >= 1_000_000) {
-    return `${symbol}${(value / 1_000_000).toFixed(1)}M`
+    return `${currencySymbol}${(value / 1_000_000).toFixed(1)}M`
   }
   if (Math.abs(value) >= 1_000) {
-    return `${symbol}${(value / 1_000).toFixed(1)}K`
+    return `${currencySymbol}${(value / 1_000).toFixed(1)}K`
   }
-  return `${symbol}${value.toFixed(0)}`
+  return `${currencySymbol}${value.toFixed(0)}`
 }
 
-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 {
+export function formatCurrencySafe(value: unknown, fallback = '--'): string {
   if (value === null || value === undefined) return fallback
   const num = Number(value)
   if (!Number.isFinite(num)) return fallback
-  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 }),
-  }
+  return formatCurrency(num)
 }