@open-mercato/core 0.6.7 → 0.6.8-develop.6874.1.982d6097d8

package/dist/modules/dashboards/lib/exactDecimal.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/dashboards/lib/exactDecimal.ts"],
+  "sourcesContent": ["/**\n * Minimal exact decimal arithmetic for application-side aggregation of PostgreSQL `numeric`\n * columns. The SQL path sums money in `numeric` and converts once, so the application path must\n * not accumulate in binary floating point \u2014 `0.1 + 0.2` would drift the totals of encrypted group\n * sources away from the plaintext ones (#4622).\n *\n * A value is stored as scaled integer `units` plus a decimal `scale`, so `12.34` is\n * `{ units: 1234n, scale: 2 }`. Conversion to `number` happens only at the response boundary.\n */\n\nexport type ExactDecimal = {\n  units: bigint\n  scale: number\n}\n\nconst DECIMAL_PATTERN = /^([+-]?)(\\d*)(?:\\.(\\d*))?(?:[eE]([+-]?\\d+))?$/\n\nexport const EXACT_DECIMAL_ZERO: ExactDecimal = { units: 0n, scale: 0 }\n\nfunction pow10(exponent: number): bigint {\n  return 10n ** BigInt(exponent)\n}\n\n/**\n * Parses a `numeric` column value. The PostgreSQL driver hands these over as strings to preserve\n * precision, so the string form is authoritative; numbers and bigints are accepted for callers that\n * already hold a JavaScript value. Returns `null` for anything that is not a finite decimal.\n */\nexport function parseExactDecimal(raw: unknown): ExactDecimal | null {\n  if (raw === null || raw === undefined) return null\n  if (typeof raw === 'bigint') return { units: raw, scale: 0 }\n\n  let text: string\n  if (typeof raw === 'number') {\n    if (!Number.isFinite(raw)) return null\n    text = String(raw)\n  } else if (typeof raw === 'string') {\n    text = raw.trim()\n  } else {\n    return null\n  }\n\n  if (!text) return null\n\n  const match = DECIMAL_PATTERN.exec(text)\n  if (!match) return null\n\n  const [, sign, intPart = '', fracPart = '', exponentPart] = match\n  if (!intPart && !fracPart) return null\n\n  const digits = `${intPart}${fracPart}`\n  let units = BigInt(digits)\n  let scale = fracPart.length\n\n  if (exponentPart) {\n    scale -= Number(exponentPart)\n    if (scale < 0) {\n      units *= pow10(-scale)\n      scale = 0\n    }\n  }\n\n  if (sign === '-') units = -units\n  return { units, scale }\n}\n\nfunction rescale(value: ExactDecimal, scale: number): bigint {\n  return scale === value.scale ? value.units : value.units * pow10(scale - value.scale)\n}\n\nexport function addExactDecimal(left: ExactDecimal, right: ExactDecimal): ExactDecimal {\n  const scale = Math.max(left.scale, right.scale)\n  return { units: rescale(left, scale) + rescale(right, scale), scale }\n}\n\nexport function compareExactDecimal(left: ExactDecimal, right: ExactDecimal): number {\n  const scale = Math.max(left.scale, right.scale)\n  const leftUnits = rescale(left, scale)\n  const rightUnits = rescale(right, scale)\n  if (leftUnits === rightUnits) return 0\n  return leftUnits < rightUnits ? -1 : 1\n}\n\nexport function exactDecimalToString(value: ExactDecimal): string {\n  const negative = value.units < 0n\n  const digits = (negative ? -value.units : value.units).toString().padStart(value.scale + 1, '0')\n  const boundary = digits.length - value.scale\n  const integerPart = digits.slice(0, boundary)\n  const fractionPart = value.scale > 0 ? digits.slice(boundary) : ''\n  return `${negative ? '-' : ''}${integerPart}${fractionPart ? `.${fractionPart}` : ''}`\n}\n\n/** Response-boundary conversion: the only place where the exact value becomes a binary float. */\nexport function exactDecimalToNumber(value: ExactDecimal): number {\n  return Number(exactDecimalToString(value))\n}\n"],
+  "mappings": "AAeA,MAAM,kBAAkB;AAEjB,MAAM,qBAAmC,EAAE,OAAO,IAAI,OAAO,EAAE;AAEtE,SAAS,MAAM,UAA0B;AACvC,SAAO,OAAO,OAAO,QAAQ;AAC/B;AAOO,SAAS,kBAAkB,KAAmC;AACnE,MAAI,QAAQ,QAAQ,QAAQ,OAAW,QAAO;AAC9C,MAAI,OAAO,QAAQ,SAAU,QAAO,EAAE,OAAO,KAAK,OAAO,EAAE;AAE3D,MAAI;AACJ,MAAI,OAAO,QAAQ,UAAU;AAC3B,QAAI,CAAC,OAAO,SAAS,GAAG,EAAG,QAAO;AAClC,WAAO,OAAO,GAAG;AAAA,EACnB,WAAW,OAAO,QAAQ,UAAU;AAClC,WAAO,IAAI,KAAK;AAAA,EAClB,OAAO;AACL,WAAO;AAAA,EACT;AAEA,MAAI,CAAC,KAAM,QAAO;AAElB,QAAM,QAAQ,gBAAgB,KAAK,IAAI;AACvC,MAAI,CAAC,MAAO,QAAO;AAEnB,QAAM,CAAC,EAAE,MAAM,UAAU,IAAI,WAAW,IAAI,YAAY,IAAI;AAC5D,MAAI,CAAC,WAAW,CAAC,SAAU,QAAO;AAElC,QAAM,SAAS,GAAG,OAAO,GAAG,QAAQ;AACpC,MAAI,QAAQ,OAAO,MAAM;AACzB,MAAI,QAAQ,SAAS;AAErB,MAAI,cAAc;AAChB,aAAS,OAAO,YAAY;AAC5B,QAAI,QAAQ,GAAG;AACb,eAAS,MAAM,CAAC,KAAK;AACrB,cAAQ;AAAA,IACV;AAAA,EACF;AAEA,MAAI,SAAS,IAAK,SAAQ,CAAC;AAC3B,SAAO,EAAE,OAAO,MAAM;AACxB;AAEA,SAAS,QAAQ,OAAqB,OAAuB;AAC3D,SAAO,UAAU,MAAM,QAAQ,MAAM,QAAQ,MAAM,QAAQ,MAAM,QAAQ,MAAM,KAAK;AACtF;AAEO,SAAS,gBAAgB,MAAoB,OAAmC;AACrF,QAAM,QAAQ,KAAK,IAAI,KAAK,OAAO,MAAM,KAAK;AAC9C,SAAO,EAAE,OAAO,QAAQ,MAAM,KAAK,IAAI,QAAQ,OAAO,KAAK,GAAG,MAAM;AACtE;AAEO,SAAS,oBAAoB,MAAoB,OAA6B;AACnF,QAAM,QAAQ,KAAK,IAAI,KAAK,OAAO,MAAM,KAAK;AAC9C,QAAM,YAAY,QAAQ,MAAM,KAAK;AACrC,QAAM,aAAa,QAAQ,OAAO,KAAK;AACvC,MAAI,cAAc,WAAY,QAAO;AACrC,SAAO,YAAY,aAAa,KAAK;AACvC;AAEO,SAAS,qBAAqB,OAA6B;AAChE,QAAM,WAAW,MAAM,QAAQ;AAC/B,QAAM,UAAU,WAAW,CAAC,MAAM,QAAQ,MAAM,OAAO,SAAS,EAAE,SAAS,MAAM,QAAQ,GAAG,GAAG;AAC/F,QAAM,WAAW,OAAO,SAAS,MAAM;AACvC,QAAM,cAAc,OAAO,MAAM,GAAG,QAAQ;AAC5C,QAAM,eAAe,MAAM,QAAQ,IAAI,OAAO,MAAM,QAAQ,IAAI;AAChE,SAAO,GAAG,WAAW,MAAM,EAAE,GAAG,WAAW,GAAG,eAAe,IAAI,YAAY,KAAK,EAAE;AACtF;AAGO,SAAS,qBAAqB,OAA6B;AAChE,SAAO,OAAO,qBAAqB,KAAK,CAAC;AAC3C;",
+  "names": []
+}

package/dist/modules/dashboards/lib/formatters.js

@@ -1,31 +1,104 @@
-function formatCurrency(value, options = {}) {
-  const { currency = "USD", minimumFractionDigits = 0, maximumFractionDigits = 0 } = options;
-  return new Intl.NumberFormat(void 0, {
-    style: "currency",
-    currency,
+const CURRENCY_CODE_PATTERN = /^[A-Za-z]{3}$/;
+const NUMBER_FORMATTER_CACHE_LIMIT = 128;
+const numberFormatterCache = /* @__PURE__ */ new Map();
+function normalizeCurrencyCode(currency) {
+  if (typeof currency !== "string") return null;
+  const trimmed = currency.trim();
+  if (!CURRENCY_CODE_PATTERN.test(trimmed)) return null;
+  return trimmed.toUpperCase();
+}
+function getNumberFormatter(locale, options) {
+  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, minimumFractionDigits, maximumFractionDigits, locale) {
+  return getNumberFormatter(locale, {
+    style: "decimal",
     minimumFractionDigits,
     maximumFractionDigits
   }).format(value);
 }
+function formatCurrency(value, options = {}) {
+  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}`;
+  }
+}
 function formatCurrencyWithDecimals(value, options = {}) {
   return formatCurrency(value, { minimumFractionDigits: 2, maximumFractionDigits: 2, ...options });
 }
-function formatCurrencyCompact(value, currencySymbol = "$") {
+function formatWithLiteralSymbol(value, symbol) {
   if (Math.abs(value) >= 1e6) {
-    return `${currencySymbol}${(value / 1e6).toFixed(1)}M`;
+    return `${symbol}${(value / 1e6).toFixed(1)}M`;
   }
   if (Math.abs(value) >= 1e3) {
-    return `${currencySymbol}${(value / 1e3).toFixed(1)}K`;
+    return `${symbol}${(value / 1e3).toFixed(1)}K`;
   }
-  return `${currencySymbol}${value.toFixed(0)}`;
+  return `${symbol}${value.toFixed(0)}`;
 }
-function formatCurrencySafe(value, fallback = "--") {
+function formatCurrencyCompact(value, currencyOrOptions = {}) {
+  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) >= 1e3;
+  const formatOptions = {
+    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;
+  }
+}
+function formatCurrencySafe(value, fallback = "--", options = {}) {
   if (value === null || value === void 0) return fallback;
   const num = Number(value);
   if (!Number.isFinite(num)) return fallback;
-  return formatCurrency(num);
+  return formatCurrency(num, options);
+}
+function createCurrencyFormatters(currency, fallback = "--", locale) {
+  const code = normalizeCurrencyCode(currency);
+  return {
+    currency: code,
+    format: (value) => formatCurrency(value, { currency: code, locale }),
+    formatWithDecimals: (value) => formatCurrencyWithDecimals(value, { currency: code, locale }),
+    formatCompact: (value) => formatCurrencyCompact(value, { currency: code, locale }),
+    formatSafe: (value) => formatCurrencySafe(value, fallback, { currency: code, locale })
+  };
 }
 export {
+  createCurrencyFormatters,
   formatCurrency,
   formatCurrencyCompact,
   formatCurrencySafe,

package/dist/modules/dashboards/lib/formatters.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/modules/dashboards/lib/formatters.ts"],
-  "sourcesContent": ["export type FormatCurrencyOptions = {\n  currency?: string\n  minimumFractionDigits?: number\n  maximumFractionDigits?: number\n}\n\nexport function formatCurrency(value: number, options: FormatCurrencyOptions = {}): string {\n  const { currency = 'USD', minimumFractionDigits = 0, maximumFractionDigits = 0 } = options\n  return new Intl.NumberFormat(undefined, {\n    style: 'currency',\n    currency,\n    minimumFractionDigits,\n    maximumFractionDigits,\n  }).format(value)\n}\n\nexport function formatCurrencyWithDecimals(value: number, options: FormatCurrencyOptions = {}): string {\n  return formatCurrency(value, { minimumFractionDigits: 2, maximumFractionDigits: 2, ...options })\n}\n\nexport function formatCurrencyCompact(value: number, currencySymbol = '$'): string {\n  if (Math.abs(value) >= 1_000_000) {\n    return `${currencySymbol}${(value / 1_000_000).toFixed(1)}M`\n  }\n  if (Math.abs(value) >= 1_000) {\n    return `${currencySymbol}${(value / 1_000).toFixed(1)}K`\n  }\n  return `${currencySymbol}${value.toFixed(0)}`\n}\n\nexport function formatCurrencySafe(value: unknown, fallback = '--'): string {\n  if (value === null || value === undefined) return fallback\n  const num = Number(value)\n  if (!Number.isFinite(num)) return fallback\n  return formatCurrency(num)\n}\n"],
-  "mappings": "AAMO,SAAS,eAAe,OAAe,UAAiC,CAAC,GAAW;AACzF,QAAM,EAAE,WAAW,OAAO,wBAAwB,GAAG,wBAAwB,EAAE,IAAI;AACnF,SAAO,IAAI,KAAK,aAAa,QAAW;AAAA,IACtC,OAAO;AAAA,IACP;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC,EAAE,OAAO,KAAK;AACjB;AAEO,SAAS,2BAA2B,OAAe,UAAiC,CAAC,GAAW;AACrG,SAAO,eAAe,OAAO,EAAE,uBAAuB,GAAG,uBAAuB,GAAG,GAAG,QAAQ,CAAC;AACjG;AAEO,SAAS,sBAAsB,OAAe,iBAAiB,KAAa;AACjF,MAAI,KAAK,IAAI,KAAK,KAAK,KAAW;AAChC,WAAO,GAAG,cAAc,IAAI,QAAQ,KAAW,QAAQ,CAAC,CAAC;AAAA,EAC3D;AACA,MAAI,KAAK,IAAI,KAAK,KAAK,KAAO;AAC5B,WAAO,GAAG,cAAc,IAAI,QAAQ,KAAO,QAAQ,CAAC,CAAC;AAAA,EACvD;AACA,SAAO,GAAG,cAAc,GAAG,MAAM,QAAQ,CAAC,CAAC;AAC7C;AAEO,SAAS,mBAAmB,OAAgB,WAAW,MAAc;AAC1E,MAAI,UAAU,QAAQ,UAAU,OAAW,QAAO;AAClD,QAAM,MAAM,OAAO,KAAK;AACxB,MAAI,CAAC,OAAO,SAAS,GAAG,EAAG,QAAO;AAClC,SAAO,eAAe,GAAG;AAC3B;",
+  "sourcesContent": ["export type FormatCurrencyOptions = {\n  currency?: string | null\n  locale?: string\n  minimumFractionDigits?: number\n  maximumFractionDigits?: number\n}\n\nexport type FormatCurrencyCompactOptions = {\n  currency?: string | null\n  locale?: string\n}\n\nconst CURRENCY_CODE_PATTERN = /^[A-Za-z]{3}$/\nconst NUMBER_FORMATTER_CACHE_LIMIT = 128\nconst numberFormatterCache = new Map<string, Intl.NumberFormat>()\n\nfunction normalizeCurrencyCode(currency?: string | null): string | null {\n  if (typeof currency !== 'string') return null\n  const trimmed = currency.trim()\n  if (!CURRENCY_CODE_PATTERN.test(trimmed)) return null\n  return trimmed.toUpperCase()\n}\n\nfunction getNumberFormatter(\n  locale: string | undefined,\n  options: Intl.NumberFormatOptions,\n): Intl.NumberFormat {\n  const key = `${locale ?? ''}:${JSON.stringify(options)}`\n  const cached = numberFormatterCache.get(key)\n  if (cached) return cached\n  const formatter = new Intl.NumberFormat(locale, options)\n  if (numberFormatterCache.size >= NUMBER_FORMATTER_CACHE_LIMIT) {\n    const oldest = numberFormatterCache.keys().next().value\n    if (oldest) numberFormatterCache.delete(oldest)\n  }\n  numberFormatterCache.set(key, formatter)\n  return formatter\n}\n\nfunction formatDecimal(\n  value: number,\n  minimumFractionDigits: number,\n  maximumFractionDigits: number,\n  locale?: string,\n): string {\n  return getNumberFormatter(locale, {\n    style: 'decimal',\n    minimumFractionDigits,\n    maximumFractionDigits,\n  }).format(value)\n}\n\n/**\n * Formats a monetary amount. Without a currency code the amount renders as a plain\n * number: analytics values carry no currency of their own, and labelling them with a\n * guessed one (see #4620) is worse than leaving them unlabelled.\n */\nexport function formatCurrency(value: number, options: FormatCurrencyOptions = {}): string {\n  const { currency, locale, minimumFractionDigits = 0, maximumFractionDigits = 0 } = options\n  const code = normalizeCurrencyCode(currency)\n  if (!code) return formatDecimal(value, minimumFractionDigits, maximumFractionDigits, locale)\n  try {\n    return getNumberFormatter(locale, {\n      style: 'currency',\n      currency: code,\n      minimumFractionDigits,\n      maximumFractionDigits,\n    }).format(value)\n  } catch {\n    return `${formatDecimal(value, minimumFractionDigits, maximumFractionDigits, locale)} ${code}`\n  }\n}\n\nexport function formatCurrencyWithDecimals(value: number, options: FormatCurrencyOptions = {}): string {\n  return formatCurrency(value, { minimumFractionDigits: 2, maximumFractionDigits: 2, ...options })\n}\n\nfunction formatWithLiteralSymbol(value: number, symbol: string): string {\n  if (Math.abs(value) >= 1_000_000) {\n    return `${symbol}${(value / 1_000_000).toFixed(1)}M`\n  }\n  if (Math.abs(value) >= 1_000) {\n    return `${symbol}${(value / 1_000).toFixed(1)}K`\n  }\n  return `${symbol}${value.toFixed(0)}`\n}\n\nexport function formatCurrencyCompact(\n  value: number,\n  currencyOrOptions: string | null | FormatCurrencyCompactOptions = {},\n): string {\n  if (typeof currencyOrOptions === 'string' && !normalizeCurrencyCode(currencyOrOptions)) {\n    return formatWithLiteralSymbol(value, currencyOrOptions)\n  }\n\n  const options = typeof currencyOrOptions === 'string'\n    ? { currency: currencyOrOptions }\n    : (currencyOrOptions ?? {})\n  const code = normalizeCurrencyCode(options.currency)\n  const compact = Math.abs(value) >= 1_000\n  const formatOptions: Intl.NumberFormatOptions = {\n    style: code ? 'currency' : 'decimal',\n    notation: compact ? 'compact' : 'standard',\n    compactDisplay: 'short',\n    minimumFractionDigits: compact ? 1 : 0,\n    maximumFractionDigits: compact ? 1 : 0,\n  }\n  if (code) formatOptions.currency = code\n\n  try {\n    return getNumberFormatter(options.locale, formatOptions).format(value)\n  } catch {\n    const formatted = getNumberFormatter(options.locale, {\n      style: 'decimal',\n      notation: compact ? 'compact' : 'standard',\n      compactDisplay: 'short',\n      minimumFractionDigits: compact ? 1 : 0,\n      maximumFractionDigits: compact ? 1 : 0,\n    }).format(value)\n    return code ? `${formatted} ${code}` : formatted\n  }\n}\n\nexport function formatCurrencySafe(\n  value: unknown,\n  fallback = '--',\n  options: FormatCurrencyOptions = {},\n): string {\n  if (value === null || value === undefined) return fallback\n  const num = Number(value)\n  if (!Number.isFinite(num)) return fallback\n  return formatCurrency(num, options)\n}\n\nexport type CurrencyFormatters = {\n  currency: string | null\n  format: (value: number) => string\n  formatWithDecimals: (value: number) => string\n  formatCompact: (value: number) => string\n  formatSafe: (value: unknown) => string\n}\n\n/**\n * Binds the resolved currency once so widgets can hand chart and KPI components a\n * stable single-argument formatter \u2014 passing `formatCurrency` by reference is what\n * made its currency option unreachable in the first place (#4620).\n */\nexport function createCurrencyFormatters(\n  currency?: string | null,\n  fallback = '--',\n  locale?: string,\n): CurrencyFormatters {\n  const code = normalizeCurrencyCode(currency)\n  return {\n    currency: code,\n    format: (value: number) => formatCurrency(value, { currency: code, locale }),\n    formatWithDecimals: (value: number) => formatCurrencyWithDecimals(value, { currency: code, locale }),\n    formatCompact: (value: number) => formatCurrencyCompact(value, { currency: code, locale }),\n    formatSafe: (value: unknown) => formatCurrencySafe(value, fallback, { currency: code, locale }),\n  }\n}\n"],
+  "mappings": "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",
   "names": []
 }

package/dist/modules/dashboards/lib/optionalBaseCurrency.js

@@ -0,0 +1,11 @@
+function resolveOptionalBaseCurrencyResolver(container) {
+  try {
+    return container.resolve("baseCurrencyService");
+  } catch {
+    return void 0;
+  }
+}
+export {
+  resolveOptionalBaseCurrencyResolver
+};
+//# sourceMappingURL=optionalBaseCurrency.js.map

package/dist/modules/dashboards/lib/optionalBaseCurrency.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/dashboards/lib/optionalBaseCurrency.ts"],
+  "sourcesContent": ["import type { AppContainer } from '@open-mercato/shared/lib/di/container'\n\nexport type BaseCurrencyResolution =\n  | { status: 'resolved'; code: string }\n  | { status: 'missing' | 'ambiguous' | 'unavailable' }\n\nexport type BaseCurrencyResolver = {\n  resolveBaseCurrency(scope: {\n    tenantId: string\n    organizationIds: string[]\n  }): Promise<BaseCurrencyResolution>\n}\n\nexport function resolveOptionalBaseCurrencyResolver(\n  container: AppContainer,\n): BaseCurrencyResolver | undefined {\n  try {\n    return container.resolve<BaseCurrencyResolver>('baseCurrencyService')\n  } catch {\n    return undefined\n  }\n}\n"],
+  "mappings": "AAaO,SAAS,oCACd,WACkC;AAClC,MAAI;AACF,WAAO,UAAU,QAA8B,qBAAqB;AAAA,EACtE,QAAQ;AACN,WAAO;AAAA,EACT;AACF;",
+  "names": []
+}

package/dist/modules/dashboards/services/widgetDataService.js

@@ -3,6 +3,7 @@ import { decryptWithAesGcm } from "@open-mercato/shared/lib/encryption/aes";
 import { resolveTenantEncryptionService } from "@open-mercato/shared/lib/encryption/customFieldValues";
 import { resolveEntityIdFromMetadata } from "@open-mercato/shared/lib/encryption/entityIds";
 import { findWithDecryption } from "@open-mercato/shared/lib/encryption/find";
+import { listEntityMetadata } from "@open-mercato/shared/lib/db/entityMetadata";
 import {
   resolveDateRange,
   getPreviousPeriod,
@@ -10,12 +11,27 @@ import {
   determineChangeDirection,
   isValidDateRangePreset
 } from "@open-mercato/ui/backend/date-range";
+import { parseDecryptedFieldValue } from "@open-mercato/shared/lib/encryption/tenantDataEncryptionService";
+import { createLogger } from "@open-mercato/shared/lib/logger";
+import { isTenantDataEncryptionEnabled } from "@open-mercato/shared/lib/encryption/toggles";
 import {
-  buildAggregationQuery
+  buildAggregationQuery,
+  buildDistinctCurrencyQuery,
+  buildGroupSourceRowsQuery,
+  resolveGroupExpression
 } from "../lib/aggregations.js";
+import {
+  EXACT_DECIMAL_ZERO,
+  addExactDecimal,
+  compareExactDecimal,
+  exactDecimalToNumber,
+  parseExactDecimal
+} from "../lib/exactDecimal.js";
+const logger = createLogger("dashboards").child({ component: "widget-data-service" });
 const WIDGET_DATA_CACHE_TTL = 12e4;
 const WIDGET_DATA_SEGMENT_TTL = 864e5;
 const WIDGET_DATA_SEGMENT_KEY = "widget-data:__segment__";
+const ENCRYPTED_GROUP_SCAN_LIMIT = 2e4;
 const SAFE_IDENTIFIER_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
 class WidgetDataValidationError extends Error {
   constructor(message) {
@@ -23,17 +39,73 @@ class WidgetDataValidationError extends Error {
     this.name = "WidgetDataValidationError";
   }
 }
+class WidgetDataScanLimitError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WidgetDataScanLimitError";
+  }
+}
+class WidgetDataEncryptionUnavailableError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WidgetDataEncryptionUnavailableError";
+  }
+}
 function assertSafeIdentifier(value, name) {
   if (!SAFE_IDENTIFIER_PATTERN.test(value)) {
     throw new Error(`Invalid ${name}: ${value}`);
   }
 }
+function matchesColumn(fieldName, dbColumn) {
+  const normalize = (value) => value.replace(/_/g, "").toLowerCase();
+  return normalize(fieldName) === normalize(dbColumn);
+}
+function readJsonPath(value, path) {
+  let current = value;
+  for (const part of path.split(".")) {
+    if (current === null || typeof current !== "object") return null;
+    current = current[part];
+  }
+  return current;
+}
+function createGroupBucket() {
+  return { count: 0, numericCount: 0, sum: EXACT_DECIMAL_ZERO, min: null, max: null };
+}
+function foldMetricValue(bucket, value) {
+  bucket.numericCount += 1;
+  bucket.sum = addExactDecimal(bucket.sum, value);
+  if (bucket.min === null || compareExactDecimal(value, bucket.min) < 0) bucket.min = value;
+  if (bucket.max === null || compareExactDecimal(value, bucket.max) > 0) bucket.max = value;
+}
+function aggregateBucket(aggregate, bucket) {
+  switch (aggregate) {
+    case "count":
+      return bucket.count;
+    case "sum":
+      return bucket.numericCount === 0 ? 0 : exactDecimalToNumber(bucket.sum);
+    case "avg":
+      return bucket.numericCount === 0 ? 0 : exactDecimalToNumber(bucket.sum) / bucket.numericCount;
+    case "min":
+      return bucket.min === null ? null : exactDecimalToNumber(bucket.min);
+    case "max":
+      return bucket.max === null ? null : exactDecimalToNumber(bucket.max);
+    default:
+      return bucket.count;
+  }
+}
+function compareWidgetDataItemsByValueDesc(left, right) {
+  if (left.value === null && right.value === null) return 0;
+  if (left.value === null) return 1;
+  if (right.value === null) return -1;
+  return right.value - left.value;
+}
 class WidgetDataService {
   constructor(options) {
     this.em = options.em;
     this.scope = options.scope;
     this.registry = options.registry;
     this.cache = options.cache;
+    this.baseCurrencyResolver = options.baseCurrencyResolver;
   }
   buildCacheKey(request) {
     const hash = createHash("sha256");
@@ -65,16 +137,19 @@ class WidgetDataService {
       }
     }
     const shouldFetchComparison = Boolean(comparisonRange && request.dateRange);
-    const [mainResult, comparisonResult] = await Promise.all([
+    const aggregatedRanges = shouldFetchComparison && comparisonRange ? [dateRangeResolved, comparisonRange] : [dateRangeResolved];
+    const [mainResult, comparisonResult, currency] = await Promise.all([
       this.executeQuery(request, dateRangeResolved),
-      shouldFetchComparison && comparisonRange ? this.executeQuery(request, comparisonRange) : Promise.resolve(void 0)
+      shouldFetchComparison && comparisonRange ? this.executeQuery(request, comparisonRange) : Promise.resolve(void 0),
+      this.resolveCurrencyLabel(request, aggregatedRanges)
     ]);
     const response = {
       value: mainResult.value,
       data: mainResult.data,
       metadata: {
         fetchedAt: now.toISOString(),
-        recordCount: mainResult.data.length || (mainResult.value !== null ? 1 : 0)
+        recordCount: mainResult.data.length || (mainResult.value !== null ? 1 : 0),
+        currency
       }
     };
     if (comparisonResult && mainResult.value !== null && comparisonResult.value !== null) {
@@ -99,6 +174,81 @@ class WidgetDataService {
     }
     return response;
   }
+  /**
+   * Resolves the currency the response may be labelled with. The base currency of the
+   * scope is only half the answer: it describes how the organizations are configured, not
+   * what the aggregated rows are actually denominated in. A PLN-based organization holding
+   * both PLN and EUR orders would otherwise sum them and present the total as PLN (#4676),
+   * so the base currency survives only when every aggregated row carries exactly that code.
+   *
+   * The check is deliberately conservative — anything it cannot prove resolves to `null`
+   * and the widgets render an explicitly unlabelled number, which is recoverable, while a
+   * confident wrong label is not.
+   */
+  async resolveCurrencyLabel(request, aggregatedRanges) {
+    const baseCurrency = await this.resolveBaseCurrency();
+    if (!baseCurrency) return null;
+    try {
+      for (const range of aggregatedRanges) {
+        const uniform = await this.rowsShareCurrency(request, range, baseCurrency);
+        if (!uniform) return null;
+      }
+      return baseCurrency;
+    } catch (err) {
+      logger.warn("Row-currency uniformity check failed; leaving the amount unlabelled", {
+        err,
+        entityType: request.entityType
+      });
+      return null;
+    }
+  }
+  /**
+   * Reads the distinct per-row currencies of the rows one aggregation range would sum.
+   * Entities that declare no `currencyField` carry no per-row currency to contradict the
+   * base one, so they pass. An empty range has nothing to mislabel and also passes.
+   *
+   * A missing currency cannot prove the row uses the scope's base currency, so it fails
+   * closed just like a conflicting code. An empty range has no row to mislabel and passes.
+   */
+  async rowsShareCurrency(request, dateRange, expectedCode) {
+    const query = buildDistinctCurrencyQuery({
+      entityType: request.entityType,
+      dateRange: dateRange && request.dateRange ? { field: request.dateRange.field, ...dateRange } : void 0,
+      filters: request.filters,
+      scope: this.scope,
+      registry: this.registry
+    });
+    if (!query) return true;
+    const rows = await this.em.getConnection().execute(query.sql, query.params);
+    const resultRows = Array.isArray(rows) ? rows : [];
+    const recordedCodes = /* @__PURE__ */ new Set();
+    for (const row of resultRows) {
+      const code = typeof row.code === "string" ? row.code.trim().toUpperCase() : "";
+      if (!code) return false;
+      recordedCodes.add(code);
+    }
+    if (recordedCodes.size === 0) return true;
+    if (recordedCodes.size > 1) return false;
+    return recordedCodes.has(expectedCode);
+  }
+  /**
+   * Resolves the base currency of the current scope so money widgets can label amounts
+   * with the tenant's own currency instead of a hard-coded default (#4620). The lookup
+   * is soft: a scope spanning organizations with different base currencies, a missing
+   * base currency, or an unavailable currencies module all resolve to `null`, and the
+   * widgets then render unlabelled numbers rather than a wrong currency.
+   */
+  resolveBaseCurrency() {
+    if (!this.baseCurrencyPromise) {
+      const organizationIds = [...new Set(this.scope.organizationIds ?? [])];
+      if (!this.baseCurrencyResolver || organizationIds.length === 0) {
+        this.baseCurrencyPromise = Promise.resolve(null);
+      } else {
+        this.baseCurrencyPromise = this.baseCurrencyResolver.resolveBaseCurrency({ tenantId: this.scope.tenantId, organizationIds }).then((result) => result.status === "resolved" ? result.code : null).catch(() => null);
+      }
+    }
+    return this.baseCurrencyPromise;
+  }
   validateRequest(request) {
     if (!this.registry.isValidEntityType(request.entityType)) {
       throw new WidgetDataValidationError(`Invalid entity type: ${request.entityType}`);
@@ -131,6 +281,12 @@ class WidgetDataService {
     }
   }
   async executeQuery(request, dateRange) {
+    if (request.groupBy) {
+      const encryptedSource = await this.resolveEncryptedGroupSource(request.entityType, request.groupBy);
+      if (encryptedSource) {
+        return this.executeEncryptedGroupQuery(request, encryptedSource, dateRange);
+      }
+    }
     const query = buildAggregationQuery({
       entityType: request.entityType,
       metric: request.metric,
@@ -159,13 +315,150 @@ class WidgetDataService {
     const singleValue = results[0]?.value !== void 0 ? Number(results[0].value) : null;
     return { value: singleValue, data: [] };
   }
+  /**
+   * Reports the encrypted column a groupBy field reads from, or null when the source is stored in
+   * plaintext and can be grouped by the database. Grouping over an encrypted column in SQL buckets
+   * ciphertext and renders it to the user (#4622).
+   */
+  async resolveEncryptedGroupSource(entityType, groupBy) {
+    if (!isTenantDataEncryptionEnabled()) return null;
+    const resolved = resolveGroupExpression(this.registry, entityType, groupBy);
+    if (!resolved) return null;
+    const tableName = this.registry.getEntityTypeConfig(entityType)?.tableName;
+    if (!tableName) return null;
+    const entityId = this.resolveEncryptionEntityId(tableName);
+    if (!entityId) return null;
+    const encryptionService = resolveTenantEncryptionService(this.em);
+    if (!encryptionService) {
+      throw new WidgetDataEncryptionUnavailableError(
+        `Cannot determine whether ${groupBy.field} is encrypted: encryption service unavailable`
+      );
+    }
+    const organizationId = this.resolveOrganizationId();
+    let encryptedFields;
+    try {
+      encryptedFields = await encryptionService.getEncryptedFieldNames(
+        entityId,
+        this.scope.tenantId,
+        organizationId,
+        { ignoreRuntimeHealth: true }
+      );
+    } catch (err) {
+      logger.error("Failed to resolve encrypted fields for widget grouping", { err, entityId, entityType });
+      throw new WidgetDataEncryptionUnavailableError(
+        `Cannot determine whether ${groupBy.field} is encrypted: encryption map lookup failed`
+      );
+    }
+    if (!encryptedFields.some((field) => matchesColumn(field, resolved.dbColumn))) return null;
+    if (resolved.jsonPath === null && groupBy.granularity) {
+      throw new WidgetDataValidationError(
+        `Cannot group encrypted field by granularity: ${groupBy.field}`
+      );
+    }
+    return { entityId, dbColumn: resolved.dbColumn, jsonPath: resolved.jsonPath };
+  }
+  /**
+   * Aggregates an encrypted group source in application code: rows are scanned, the group column is
+   * decrypted, and only the resulting plaintext keys are grouped. Values that cannot be decrypted
+   * collapse into the null ("Unknown") bucket so ciphertext never reaches the response.
+   */
+  async executeEncryptedGroupQuery(request, source, dateRange) {
+    const query = buildGroupSourceRowsQuery({
+      entityType: request.entityType,
+      metric: request.metric,
+      dateRange: dateRange && request.dateRange ? { field: request.dateRange.field, ...dateRange } : void 0,
+      filters: request.filters,
+      scope: this.scope,
+      registry: this.registry,
+      groupColumn: source.dbColumn,
+      rowLimit: ENCRYPTED_GROUP_SCAN_LIMIT
+    });
+    if (!query) {
+      throw new Error("Failed to build aggregation query");
+    }
+    const rows = await this.em.getConnection().execute(query.sql, query.params);
+    const results = Array.isArray(rows) ? rows : [];
+    if (results.length > ENCRYPTED_GROUP_SCAN_LIMIT) {
+      throw new WidgetDataScanLimitError(
+        `Too many rows to group encrypted field ${request.groupBy?.field} (limit ${ENCRYPTED_GROUP_SCAN_LIMIT})`
+      );
+    }
+    const encryptionService = resolveTenantEncryptionService(this.em);
+    let dek = null;
+    try {
+      dek = encryptionService ? await encryptionService.getDek(this.scope.tenantId) : null;
+    } catch (err) {
+      logger.error("Failed to resolve the tenant DEK for widget grouping", { err, entityId: source.entityId });
+      dek = null;
+    }
+    const buckets = /* @__PURE__ */ new Map();
+    let undecryptableRows = 0;
+    for (const row of results) {
+      const resolvedKey = this.resolveDecryptedGroupKey(row.group_source, source, dek?.key ?? null);
+      if (resolvedKey === void 0) undecryptableRows += 1;
+      const groupKey = resolvedKey === void 0 ? null : resolvedKey;
+      let bucket = buckets.get(groupKey);
+      if (!bucket) {
+        bucket = createGroupBucket();
+        buckets.set(groupKey, bucket);
+      }
+      const metricValue = row.metric_value;
+      if (metricValue === null || metricValue === void 0) continue;
+      bucket.count += 1;
+      const numeric = parseExactDecimal(metricValue);
+      if (numeric) foldMetricValue(bucket, numeric);
+    }
+    if (undecryptableRows > 0) {
+      if (!dek) {
+        throw new WidgetDataEncryptionUnavailableError(
+          `Cannot group encrypted field ${request.groupBy?.field}: tenant encryption key is unavailable`
+        );
+      }
+      logger.warn("Grouped rows with an undecryptable group source as unknown", {
+        entityId: source.entityId,
+        column: source.dbColumn,
+        rows: undecryptableRows
+      });
+    }
+    let data = Array.from(buckets.entries()).map(([groupKey, bucket]) => ({ groupKey, value: aggregateBucket(request.metric.aggregate, bucket) })).sort(compareWidgetDataItemsByValueDesc);
+    if (request.groupBy?.limit && request.groupBy.limit > 0) {
+      data = data.slice(0, Math.min(request.groupBy.limit, 100));
+    }
+    if (request.groupBy?.resolveLabels) {
+      data = await this.resolveGroupLabels(data, request.entityType, request.groupBy.field);
+    }
+    const totalValue = data.reduce((sum, item) => sum + (item.value ?? 0), 0);
+    return { value: totalValue, data };
+  }
+  /**
+   * Returns the plaintext group key for a scanned row, `null` for an empty/absent value, or
+   * `undefined` when the source is ciphertext that could not be decrypted.
+   */
+  resolveDecryptedGroupKey(rawValue, source, dek) {
+    if (rawValue === null || rawValue === void 0) return null;
+    let value = rawValue;
+    if (typeof value === "string" && this.isEncryptedPayload(value)) {
+      if (!dek) return void 0;
+      const decrypted = this.decryptWithDek(value, dek);
+      if (decrypted === null) return void 0;
+      value = parseDecryptedFieldValue(decrypted);
+    }
+    if (source.jsonPath !== null) {
+      value = readJsonPath(value, source.jsonPath);
+    }
+    if (value === null || value === void 0 || value === "") return null;
+    if (typeof value === "object") return null;
+    const key = String(value);
+    return this.isEncryptedPayload(key) ? void 0 : key;
+  }
   async resolveGroupLabels(data, entityType, groupByField) {
     const config = this.registry.getLabelResolverConfig(entityType, groupByField);
     if (!config) {
-      return data.map((item) => ({
-        ...item,
-        groupLabel: item.groupKey != null && item.groupKey !== "" ? String(item.groupKey) : void 0
-      }));
+      return data.map((item) => {
+        if (item.groupKey == null || item.groupKey === "") return { ...item, groupLabel: void 0 };
+        const label = String(item.groupKey);
+        return { ...item, groupLabel: this.isEncryptedPayload(label) ? void 0 : label };
+      });
     }
     const ids = data.map((item) => item.groupKey).filter((id) => {
       if (typeof id !== "string" || id.length === 0) return false;
@@ -290,10 +583,8 @@ class WidgetDataService {
     return this.scope.organizationIds[0] ?? null;
   }
   resolveEntityMetadata(tableName) {
-    const registry = this.em?.getMetadata?.();
-    if (!registry) return null;
-    const entries = typeof registry.getAll === "function" && registry.getAll() || (Array.isArray(registry.metadata) ? registry.metadata : Object.values(registry.metadata ?? {}));
-    const metas = Array.isArray(entries) ? entries : Object.values(entries ?? {});
+    const metas = listEntityMetadata(this.em);
+    if (!metas.length) return null;
     const match = metas.find((meta) => {
       const table = meta?.tableName ?? meta?.collection;
       if (typeof table !== "string") return false;
@@ -321,6 +612,15 @@ class WidgetDataService {
       return null;
     }
   }
+  /**
+   * Resolves the encryption entity id for an analytics table. A request-scoped `EntityManager` fork
+   * frequently reports an empty metadata registry, which used to make every group source look
+   * unencrypted and send the request back to the ciphertext-grouping SQL path (#4622). The table
+   * name alone is enough for the entity-id lookup, so it is the fallback.
+   */
+  resolveEncryptionEntityId(tableName) {
+    return this.resolveEntityId(this.resolveEntityMetadata(tableName)) ?? this.resolveEntityId({ tableName });
+  }
   isEncryptedPayload(value) {
     const parts = value.split(":");
     return parts.length === 4 && parts[3] === "v1";
@@ -332,10 +632,12 @@ class WidgetDataService {
     return decryptWithAesGcm(first, dek) ?? first;
   }
 }
-function createWidgetDataService(em, scope, registry, cache) {
-  return new WidgetDataService({ em, scope, registry, cache });
+function createWidgetDataService(em, scope, registry, cache, baseCurrencyResolver) {
+  return new WidgetDataService({ em, scope, registry, cache, baseCurrencyResolver });
 }
 export {
+  WidgetDataEncryptionUnavailableError,
+  WidgetDataScanLimitError,
   WidgetDataService,
   WidgetDataValidationError,
   createWidgetDataService