feat: Dynamic currency

superset-frontend/packages/superset-ui-chart-controls/src/shared-controls/sharedControls.tsx

@@ -325,6 +325,9 @@ const currency_format: SharedControlConfig<'CurrencyControl'> = {
   type: 'CurrencyControl',
   label: t('Currency format'),
   renderTrigger: true,
+  description: t(
+    "Format metrics or columns with currency symbols as prefixes or suffixes. Choose a symbol manually or use 'Auto-detect' to apply the correct symbol based on the dataset's currency code column. When multiple currencies are present, formatting falls back to neutral numbers.",
+  ),
 };
 
 const x_axis_time_format: SharedControlConfig<

superset-frontend/packages/superset-ui-chart-controls/src/types.ts

@@ -72,6 +72,7 @@ export interface Dataset {
   currency_formats?: Record<string, Currency>;
   verbose_map: Record<string, string>;
   main_dttm_col: string;
+  currency_code_column?: string;
   // eg. ['["ds", true]', 'ds [asc]']
   order_by_choices?: [string, string][] | null;
   time_grain_sqla?: [string, string][];

superset-frontend/packages/superset-ui-core/src/currency-format/CurrencyFormats.ts

@@ -0,0 +1,22 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+export const AUTO_CURRENCY_SYMBOL = 'AUTO';
+
+export const ISO_4217_REGEX = /^[A-Z]{3}$/;

superset-frontend/packages/superset-ui-core/src/currency-format/CurrencyFormatter.ts

@@ -20,6 +20,8 @@
 import { ExtensibleFunction } from '../models';
 import { getNumberFormatter, NumberFormats } from '../number-format';
 import { Currency } from '../query';
+import { RowData, RowDataValue } from './types';
+import { AUTO_CURRENCY_SYMBOL, ISO_4217_REGEX } from './CurrencyFormats';
 
 /* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
 
@@ -30,7 +32,11 @@ interface CurrencyFormatterConfig {
 }
 
 interface CurrencyFormatter {
-  (value: number | null | undefined): string;
+  (
+    value: number | null | undefined,
+    rowData?: RowData,
+    currencyColumn?: string,
+  ): string;
 }
 
 export const getCurrencySymbol = (currency: Partial<Currency>) =>
@@ -41,6 +47,32 @@ export const getCurrencySymbol = (currency: Partial<Currency>) =>
     .formatToParts(1)
     .find(x => x.type === 'currency')?.value;
 
+export function normalizeCurrency(value: RowDataValue): string | null {
+  if (value === null || value === undefined) return null;
+  if (typeof value !== 'string') return null;
+
+  const normalized = value.trim().toUpperCase();
+
+  return ISO_4217_REGEX.test(normalized) ? normalized : null;
+}
+
+export function hasMixedCurrencies(currencies: RowDataValue[]): boolean {
+  let first: string | null = null;
+
+  for (const c of currencies) {
+    const normalized = normalizeCurrency(c);
+    if (normalized === null) continue;
+
+    if (first === null) {
+      first = normalized;
+    } else if (normalized !== first) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 class CurrencyFormatter extends ExtensibleFunction {
   d3Format: string;
 
@@ -49,7 +81,9 @@ class CurrencyFormatter extends ExtensibleFunction {
   currency: Currency;
 
   constructor(config: CurrencyFormatterConfig) {
-    super((value: number) => this.format(value));
+    super((value: number, rowData?: RowData, currencyColumn?: string) =>
+      this.format(value, rowData, currencyColumn),
+    );
     this.d3Format = config.d3Format || NumberFormats.SMART_NUMBER;
     this.currency = config.currency;
     this.locale = config.locale || 'en-US';
@@ -67,19 +101,59 @@ class CurrencyFormatter extends ExtensibleFunction {
     return value.replace(/%/g, '');
   }
 
-  format(value: number) {
+  format(value: number, rowData?: RowData, currencyColumn?: string): string {
     const formattedValue = getNumberFormatter(this.getNormalizedD3Format())(
       value,
     );
-    if (!this.hasValidCurrency()) {
+
+    const isAutoMode = this.currency?.symbol === AUTO_CURRENCY_SYMBOL;
+
+    if (!this.hasValidCurrency() && !isAutoMode) {
       return formattedValue as string;
     }
 
+    // Remove % signs from formatted value for currency display
     const normalizedValue = this.normalizeForCurrency(formattedValue);
-    if (this.currency.symbolPosition === 'prefix') {
-      return `${getCurrencySymbol(this.currency)} ${normalizedValue}`;
+
+    if (isAutoMode) {
+      if (rowData && currencyColumn && rowData[currencyColumn]) {
+        const rawCurrency = rowData[currencyColumn];
+        const normalizedCurrency = normalizeCurrency(rawCurrency);
+
+        if (normalizedCurrency) {
+          try {
+            const symbol = getCurrencySymbol({ symbol: normalizedCurrency });
+            if (symbol) {
+              if (this.currency.symbolPosition === 'prefix') {
+                return `${symbol} ${normalizedValue}`;
+              } else if (this.currency.symbolPosition === 'suffix') {
+                return `${normalizedValue} ${symbol}`;
+              }
+              // Unknown symbolPosition - default to suffix
+              return `${normalizedValue} ${symbol}`;
+            }
+          } catch {
+            // Invalid currency code - return value without currency symbol
+            return formattedValue;
+          }
+        }
+      }
+      return formattedValue;
+    }
+
+    try {
+      const symbol = getCurrencySymbol(this.currency);
+      if (this.currency.symbolPosition === 'prefix') {
+        return `${symbol} ${normalizedValue}`;
+      } else if (this.currency.symbolPosition === 'suffix') {
+        return `${normalizedValue} ${symbol}`;
+      }
+      // Unknown symbolPosition - default to suffix
+      return `${normalizedValue} ${symbol}`;
+    } catch {
+      // Invalid currency code - return value without currency symbol
+      return formattedValue;
     }
-    return `${normalizedValue} ${getCurrencySymbol(this.currency)}`;
   }
 }
 

superset-frontend/packages/superset-ui-core/src/currency-format/index.ts

@@ -1,4 +1,4 @@
-/*
+/**
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
@@ -18,5 +18,11 @@
  */
 
 export { default as CurrencyFormatter } from './CurrencyFormatter';
-export * from './CurrencyFormatter';
+export {
+  getCurrencySymbol,
+  normalizeCurrency,
+  hasMixedCurrencies,
+} from './CurrencyFormatter';
+export { AUTO_CURRENCY_SYMBOL, ISO_4217_REGEX } from './CurrencyFormats';
+export * from './types';
 export * from './utils';

superset-frontend/packages/superset-ui-core/src/currency-format/types.ts

@@ -0,0 +1,29 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+export type RowDataValue =
+  | string
+  | number
+  | boolean
+  | Date
+  | bigint
+  | null
+  | undefined;
+
+export type RowData = Record<string, RowDataValue>;

superset-frontend/packages/superset-ui-core/src/currency-format/utils.ts

@@ -25,21 +25,104 @@ import {
   QueryFormMetric,
   ValueFormatter,
 } from '@superset-ui/core';
+import { normalizeCurrency, hasMixedCurrencies } from './CurrencyFormatter';
+import { RowData, RowDataValue } from './types';
+import { AUTO_CURRENCY_SYMBOL } from './CurrencyFormats';
+
+export const analyzeCurrencyInData = (
+  data: RowData[],
+  currencyColumn: string | undefined,
+): string | null => {
+  if (!currencyColumn || !data || data.length === 0) {
+    return null;
+  }
+
+  const currencies: RowDataValue[] = data
+    .map(row => row[currencyColumn])
+    .filter(val => val !== null && val !== undefined);
+
+  if (currencies.length === 0) {
+    return null;
+  }
+
+  if (hasMixedCurrencies(currencies)) {
+    return null;
+  }
+
+  return normalizeCurrency(currencies[0]);
+};
+
+export const resolveAutoCurrency = (
+  currencyFormat: Currency | undefined,
+  backendDetected: string | null | undefined,
+  data?: RowData[],
+  currencyCodeColumn?: string,
+): Currency | undefined | null => {
+  if (currencyFormat?.symbol !== AUTO_CURRENCY_SYMBOL) return currencyFormat;
+
+  const detectedCurrency =
+    backendDetected ??
+    (data && currencyCodeColumn
+      ? analyzeCurrencyInData(data, currencyCodeColumn)
+      : null);
+
+  if (detectedCurrency) {
+    return {
+      symbol: detectedCurrency,
+      symbolPosition: currencyFormat.symbolPosition,
+    };
+  }
+  return null; // Mixed currencies
+};
+
+const getEffectiveCurrencyFormat = (
+  resolvedCurrencyFormat: Currency | undefined | null,
+  savedFormat: Currency | undefined,
+): Currency | undefined => {
+  if (resolvedCurrencyFormat === null) {
+    return undefined;
+  }
+  if (resolvedCurrencyFormat?.symbol) {
+    return resolvedCurrencyFormat;
+  }
+  return savedFormat;
+};
 
 export const buildCustomFormatters = (
   metrics: QueryFormMetric | QueryFormMetric[] | undefined,
   savedCurrencyFormats: Record<string, Currency>,
   savedColumnFormats: Record<string, string>,
   d3Format: string | undefined,
-  currencyFormat: Currency | undefined,
+  currencyFormat: Currency | undefined | null,
+  data?: RowData[],
+  currencyCodeColumn?: string,
 ) => {
   const metricsArray = ensureIsArray(metrics);
+
+  let resolvedCurrencyFormat = currencyFormat;
+  if (
+    currencyFormat?.symbol === AUTO_CURRENCY_SYMBOL &&
+    data &&
+    currencyCodeColumn
+  ) {
+    const detectedCurrency = analyzeCurrencyInData(data, currencyCodeColumn);
+    if (detectedCurrency) {
+      resolvedCurrencyFormat = {
+        symbol: detectedCurrency,
+        symbolPosition: currencyFormat.symbolPosition,
+      };
+    } else {
+      resolvedCurrencyFormat = null;
+    }
+  }
+
   return metricsArray.reduce((acc, metric) => {
     if (isSavedMetric(metric)) {
       const actualD3Format = d3Format ?? savedColumnFormats[metric];
-      const actualCurrencyFormat = currencyFormat?.symbol
-        ? currencyFormat
-        : savedCurrencyFormats[metric];
+      const actualCurrencyFormat = getEffectiveCurrencyFormat(
+        resolvedCurrencyFormat,
+        savedCurrencyFormats[metric],
+      );
       return actualCurrencyFormat?.symbol
         ? {
             ...acc,
@@ -76,14 +159,40 @@ export const getValueFormatter = (
   d3Format: string | undefined,
   currencyFormat: Currency | undefined,
   key?: string,
+  data?: RowData[],
+  currencyCodeColumn?: string,
+  detectedCurrency?: string | null,
 ) => {
+  let resolvedCurrencyFormat: Currency | undefined | null = currencyFormat;
+  if (currencyFormat?.symbol === AUTO_CURRENCY_SYMBOL) {
+    // Use backend-detected currency, or fallback to frontend analysis
+    if (detectedCurrency !== undefined) {
+      resolvedCurrencyFormat = detectedCurrency
+        ? {
+            symbol: detectedCurrency,
+            symbolPosition: currencyFormat.symbolPosition,
+          }
+        : null;
+    } else if (data && currencyCodeColumn) {
+      const frontendDetected = analyzeCurrencyInData(data, currencyCodeColumn);
+      resolvedCurrencyFormat = frontendDetected
+        ? {
+            symbol: frontendDetected,
+            symbolPosition: currencyFormat.symbolPosition,
+          }
+        : null;
+    } else {
+      resolvedCurrencyFormat = null;
+    }
+  }
+
   const customFormatter = getCustomFormatter(
     buildCustomFormatters(
       metrics,
       savedCurrencyFormats,
       savedColumnFormats,
       d3Format,
-      currencyFormat,
+      resolvedCurrencyFormat,
     ),
     metrics,
     key,
@@ -92,8 +201,14 @@ export const getValueFormatter = (
   if (customFormatter) {
     return customFormatter;
   }
-  if (currencyFormat?.symbol) {
-    return new CurrencyFormatter({ currency: currencyFormat, d3Format });
+  if (resolvedCurrencyFormat === null) {
+    return getNumberFormatter(d3Format);
+  }
+  if (resolvedCurrencyFormat?.symbol) {
+    return new CurrencyFormatter({
+      currency: resolvedCurrencyFormat,
+      d3Format,
+    });
   }
   return getNumberFormatter(d3Format);
 };

superset-frontend/packages/superset-ui-core/src/query/types/Datasource.ts

@@ -53,6 +53,7 @@ export interface Datasource {
   verboseMap?: {
     [key: string]: string;
   };
+  currencyCodeColumn?: string;
 }
 
 export const DEFAULT_METRICS: Metric[] = [