The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:
TypeScript analyticsbibusiness-intelligencebusinessintelligenceclojuredashboarddatadata-analysisdata-visualizationdatabasemetabasemysqlpostgrespostgresqlreportingslacksql-editorvisualization
Allow metrics with numeric names (#71870)
Aleksandr Lesnenkoc76d1aa35dd8
diff --git a/e2e/test/scenarios/metrics/metrics-explorer.cy.spec.ts b/e2e/test/scenarios/metrics/metrics-explorer.cy.spec.tsindex 92fa64fb7b2..19921c3ca00 100644--- a/e2e/test/scenarios/metrics/metrics-explorer.cy.spec.ts+++ b/e2e/test/scenarios/metrics/metrics-explorer.cy.spec.ts@@ -412,7 +412,6 @@ describe("scenarios > metrics > explorer", () => {cy.intercept("GET", "/api/metric/*").as("getMetric");H.MetricsViewer.goToViewer();addMetric("Count of orders");- cy.wait("@getMetric");cy.wait("@dataset");});@@ -493,13 +492,19 @@ describe("scenarios > metrics > explorer", () => {"Expand formula editor and create expression with second metric instance",);cy.findByTestId("metrics-formula-input").click();- H.MetricsViewer.searchInput()- .clear()- .type("Count of orders, Count of orders + Count of products");+ H.MetricsViewer.searchInput().type(", Count of orders");+ H.MetricsViewer.searchResults().findByText("Count of orders").click();+ cy.wait("@getMetric");++ H.MetricsViewer.searchInput().type(" + Count of products");+H.MetricsViewer.searchResults().findByText("Count of products").click();cy.wait("@getMetric");H.MetricsViewer.searchInput().type(", Count of orders");+ H.MetricsViewer.searchResults().findByText("Count of orders").click();+ cy.wait("@getMetric");+cy.findByTestId("run-expression-button").click();cy.wait("@dataset");@@ -634,8 +639,8 @@ describe("scenarios > metrics > explorer", () => {cy.log("Set up: two instances of Count of orders with an expression");cy.findByTestId("metrics-formula-input").click();- H.MetricsViewer.searchInput().type(", Count of orders");- cy.findByTestId("run-expression-button").click();+ addMetric("Count of orders");+ cy.wait("@dataset");H.MetricsViewer.searchBarPills().should("have.length", 2);@@ -727,9 +732,12 @@ describe("scenarios > metrics > explorer", () => {it("should show an expression dimension pill with per-metric accordion", () => {cy.log("Create expression: Count of orders + Count of products");cy.findByTestId("metrics-formula-input").click();- H.MetricsViewer.searchInput().type(- ", Count of orders + Count of products",- );++ H.MetricsViewer.searchInput().type(", Count of orders");+ H.MetricsViewer.searchResults().findByText("Count of orders").click();+ cy.wait("@getMetric");++ H.MetricsViewer.searchInput().type(" + Count of products");H.MetricsViewer.searchResults().findByText("Count of products").click();cy.wait("@getMetric");@@ -791,8 +799,10 @@ describe("scenarios > metrics > explorer", () => {cy.log("Create expression with only expression entity: Count of orders + Count of products",);- H.MetricsViewer.searchInput().clear();- H.MetricsViewer.searchInput().type("Count of orders + Count of products");++ cy.findByTestId("metrics-formula-input").click();++ H.MetricsViewer.searchInput().type(" + Count of products");H.MetricsViewer.searchResults().findByText("Count of products").click();cy.wait("@getMetric");@@ -1674,6 +1684,60 @@ describe("scenarios > metrics > explorer", () => {H.MetricsViewer.runButton().click();assertMetricMath();});++ it("should handle metrics with numeric names in expressions", () => {+ const NUMERIC_METRIC_NAME = "123";+ H.createQuestion({+ name: NUMERIC_METRIC_NAME,+ type: "metric",+ description: "A metric with a numeric name",+ query: {+ "source-table": ORDERS_ID,+ aggregation: [["count"]],+ },+ display: "scalar",+ });++ cy.log("Add numeric metric '123' as standalone");+ cy.findByTestId("metrics-formula-input").click();+ H.MetricsViewer.searchInput().type(`, ${NUMERIC_METRIC_NAME}`);+ H.MetricsViewer.searchResults().findByText(NUMERIC_METRIC_NAME).click();+ H.MetricsViewer.runButton().click();+ cy.wait("@dataset");++ cy.log("Sum metric '123' with itself — both selected from dropdown");+ cy.findByTestId("metrics-formula-input").click();+ H.MetricsViewer.searchInput().type(`+ ${NUMERIC_METRIC_NAME}`);+ H.MetricsViewer.searchResults().findByText(NUMERIC_METRIC_NAME).click();+ H.MetricsViewer.runButton().click();+ cy.wait("@dataset");+ H.MetricsViewer.getMetricVisualization().should("exist");++ cy.log(+ "Append literal number 123 — typed without selecting from dropdown",+ );+ cy.findByTestId("metrics-formula-input").click();+ H.MetricsViewer.searchInput().type("+ 123");+ H.MetricsViewer.runButton().click();+ cy.wait("@dataset");+ H.MetricsViewer.getMetricVisualization().should("exist");++ cy.log("Append metric '123' as standalone — selected from dropdown");+ cy.findByTestId("metrics-formula-input").click();+ H.MetricsViewer.searchInput().type(`, ${NUMERIC_METRIC_NAME}`);+ H.MetricsViewer.searchResults().findByText(NUMERIC_METRIC_NAME).click();+ H.MetricsViewer.runButton().click();+ cy.wait("@dataset");+ H.MetricsViewer.getMetricVisualization().should("exist");++ cy.log("Verify final pill layout");+ H.MetricsViewer.searchBarPills().should("have.length", 3);+ H.MetricsViewer.searchBarPills()+ .eq(0)+ .should("contain", "Count of orders");+ H.MetricsViewer.searchBarPills().eq(1).should("contain", "123 + 123");+ H.MetricsViewer.searchBarPills().eq(2).should("contain", "123");+ });});});diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/MetricSearchInput.module.css b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/MetricSearchInput.module.cssindex fac66b697ff..a011bc1f4ff 100644--- a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/MetricSearchInput.module.css+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/MetricSearchInput.module.css@@ -23,6 +23,7 @@border: 1px solid var(--mb-color-border);border-radius: 0.25rem;padding: 0 0.25rem;+ line-height: 1.25rem;}.cmErrorUnderline {diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/MetricSearchInput.tsx b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/MetricSearchInput.tsxindex adc6988db02..f02e6fb8763 100644--- a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/MetricSearchInput.tsx+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/MetricSearchInput.tsx@@ -97,7 +97,6 @@ export function MetricSearchInput({onFormulaEntitiesChange,selectedMetrics,definitions,- metricNames,metricNamesRef,handleAddMetric: metricHandlers.handleAddMetric,handleRemoveMetric: metricHandlers.handleRemoveMetric,diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/metricTokenHighlight.ts b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/metricTokenHighlight.tsindex c2f34d1e8dc..742c834a8ba 100644--- a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/metricTokenHighlight.ts+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/metricTokenHighlight.ts@@ -1,9 +1,11 @@import {+ type EditorState,MapMode,RangeSet,RangeValue,StateEffect,StateField,+ type Transaction,} from "@codemirror/state";import {Decoration,@@ -15,12 +17,8 @@ import {import type { MetricDefinition } from "metabase-lib/metric";-import type {- MetricSourceId,- MetricsViewerFormulaEntity,-} from "../../../types/viewer-state";-import type { MetricIdentityEntry, MetricNameMap } from "../utils";-import { parseFullTextWithPositions, traverseMetricTokens } from "../utils";+import type { MetricSourceId } from "../../../types/viewer-state";+import type { MetricIdentityEntry } from "../utils";import S from "./MetricSearchInput.module.css";@@ -45,26 +43,12 @@ class MetricTokenWidget extends WidgetType {}}-export const setMetricNames = StateEffect.define<MetricNameMap>();--const metricNamesField = StateField.define<MetricNameMap>({- create: () => ({}),- update(entries, tr) {- for (const effect of tr.effects) {- if (effect.is(setMetricNames)) {- return effect.value;- }- }- return entries;- },-});-// ── Identity tracking ──────────────────────────────────────────────────────class MetricIdentity extends RangeValue {override mapMode = MapMode.TrackDel;- // Don't absorb text inserted at range boundaries — the identity- // must track exactly the original token span, not grow with adjacent edits.+ // Prevent the range from absorbing adjacent text insertions —+ // without this, typing right next to a metric would extend its range.override startSide = 1;override endSide = -1;@@ -88,53 +72,52 @@ class MetricIdentity extends RangeValue {export const setMetricIdentities =StateEffect.define<RangeSet<MetricIdentity>>();+export const addMetricIdentity = StateEffect.define<MetricIdentityEntry>();+export const metricIdentityField = StateField.define<RangeSet<MetricIdentity>>({create: () => RangeSet.empty,update(identities, tr) {+ // Full reset — replaces all identities. Any addMetricIdentity effects+ // in the same transaction are intentionally ignored.for (const effect of tr.effects) {if (effect.is(setMetricIdentities)) {return effect.value;}}++ let current = identities;if (tr.docChanged) {- return identities.map(tr.changes);+ current = current.map(tr.changes);}- return identities;++ for (const effect of tr.effects) {+ if (effect.is(addMetricIdentity)) {+ const { from, to, sourceId, definition, slotIndex } = effect.value;+ const newRange = new MetricIdentity(+ sourceId,+ definition,+ slotIndex,+ ).range(from, to);+ current = current.update({ add: [newRange] });+ }+ }++ return current;},});-export function buildMetricIdentities(- text: string,- metricNames: MetricNameMap,- entities: MetricsViewerFormulaEntity[],+export function identitiesFromEntries(+ entries: MetricIdentityEntry[],): RangeSet<MetricIdentity> {- const ranges: ReturnType<MetricIdentity["range"]>[] = [];- let slotCounter = 0;-- traverseMetricTokens(text, metricNames, entities, (visit) => {- const slotIndex = slotCounter++;- const sourceId =- visit.kind === "standalone" ? visit.entity.id : visit.exprToken.sourceId;- const definition =- visit.kind === "standalone"- ? visit.entity.definition- : (visit.exprToken.definition ?? null);-- ranges.push(- new MetricIdentity(sourceId, definition, slotIndex).range(- visit.positioned.from,- visit.positioned.to,- ),- );- });-+ const ranges = entries.map((entry) =>+ new MetricIdentity(entry.sourceId, entry.definition, entry.slotIndex).range(+ entry.from,+ entry.to,+ ),+ );return RangeSet.of(ranges, true);}-/**- * Reads the current metric identities from the CodeMirror state.- * Positions are already in current-document coordinates (mapped automatically).- */export function readMetricIdentities(view: EditorView): MetricIdentityEntry[] {const identities = view.state.field(metricIdentityField);const result: MetricIdentityEntry[] = [];@@ -155,30 +138,18 @@ export function readMetricIdentities(view: EditorView): MetricIdentityEntry[] {type MetricRange = { from: number; to: number; name: string };-function computeMetricTokenRanges(- docText: string,- docLength: number,- metricNames: MetricNameMap,-): MetricRange[] {- if (Object.keys(metricNames).length === 0) {- return [];- }+function computeMetricTokenRanges(state: EditorState): MetricRange[] {+ const identities = state.field(metricIdentityField);+ const docLength = state.doc.length;+ const ranges: MetricRange[] = [];++ identities.between(0, docLength, (from, to) => {+ if (from < to) {+ ranges.push({ from, to, name: state.doc.sliceString(from, to) });+ }+ });- const tokens = parseFullTextWithPositions(docText, metricNames);- return tokens- .filter(- (t) =>- t.type === "metric" &&- t.from >= 0 &&- t.to <= docLength &&- t.from < t.to,- )- .sort((a, b) => a.from - b.from)- .map((t) => ({- from: t.from,- to: t.to,- name: docText.slice(t.from, t.to),- }));+ return ranges;}function rangesToDecorations(ranges: MetricRange[]): DecorationSet {@@ -193,32 +164,30 @@ function rangesToDecorations(ranges: MetricRange[]): DecorationSet {return Decoration.set(decorations);}-/** Stores the raw metric ranges for lookup by keymap handlers. */+function identitiesChanged(tr: Transaction): boolean {+ return (+ tr.docChanged ||+ tr.effects.some((e) => e.is(setMetricIdentities) || e.is(addMetricIdentity))+ );+}+const metricTokenRangesField = StateField.define<MetricRange[]>({create: () => [],update(ranges, tr) {- const metricNames = tr.state.field(metricNamesField);- const metricNamesChanged = tr.effects.some((e) => e.is(setMetricNames));- if (tr.docChanged || metricNamesChanged) {- return computeMetricTokenRanges(- tr.newDoc.toString(),- tr.newDoc.length,- metricNames,- );+ if (!identitiesChanged(tr)) {+ return ranges;}- return ranges;+ return computeMetricTokenRanges(tr.state);},});-/** Derives replace decorations from the metric ranges field (no re-parse). */const metricDecorationsField = StateField.define<DecorationSet>({create: () => Decoration.none,- update(deco, tr) {- const metricNamesChanged = tr.effects.some((e) => e.is(setMetricNames));- if (tr.docChanged || metricNamesChanged) {- return rangesToDecorations(tr.state.field(metricTokenRangesField));+ update(decorations, tr) {+ if (!identitiesChanged(tr)) {+ return decorations;}- return deco;+ return rangesToDecorations(tr.state.field(metricTokenRangesField));},provide: (f) => EditorView.decorations.from(f),});@@ -294,7 +263,6 @@ const metricTokenKeymap = keymap.of([]);export const metricTokenHighlight = [- metricNamesField,metricIdentityField,metricTokenRangesField,metricDecorationsField,diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/useFormulaEditor.ts b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/useFormulaEditor.tsindex 7ed1f27a89e..db217d2e0db 100644--- a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/useFormulaEditor.ts+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/useFormulaEditor.ts@@ -17,9 +17,10 @@ import {createMetricSourceId,} from "../../../utils/source-ids";import {+ ENTITY_SEPARATOR,type MetricNameMap,applyTrackedDefinitions,- buildFullText,+ buildFullTextWithIdentities,cleanupParens,findInvalidRanges,getWordAtCursor,@@ -29,10 +30,10 @@ import {import { setErrorDecoration } from "./errorHighlight";import {- buildMetricIdentities,+ addMetricIdentity,+ identitiesFromEntries,readMetricIdentities,setMetricIdentities,- setMetricNames,} from "./metricTokenHighlight";type UseFormulaEditorParams = {@@ -43,7 +44,6 @@ type UseFormulaEditorParams = {) => void;selectedMetrics: SelectedMetric[];definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>;- metricNames: MetricNameMap;metricNamesRef: MutableRefObject<MetricNameMap>;handleAddMetric: (metric: SelectedMetric) => void;handleRemoveMetric: (@@ -85,7 +85,6 @@ export function useFormulaEditor({onFormulaEntitiesChange,selectedMetrics,definitions,- metricNames,metricNamesRef,handleAddMetric,handleRemoveMetric,@@ -173,10 +172,11 @@ export function useFormulaEditor({return;}isEditingSessionActiveRef.current = true;- const fullText = buildFullText(- formulaEntitiesRef.current,- metricNamesRef.current,- );+ const { text: fullText, identities: initialIdentities } =+ buildFullTextWithIdentities(+ formulaEntitiesRef.current,+ metricNamesRef.current,+ );setTextAtFocus(fullText);setIsFocused(true);setEditText(fullText);@@ -191,17 +191,10 @@ export function useFormulaEditor({const view = editorRef.current?.view;if (view) {const endPos = view.state.doc.length;- const identities = buildMetricIdentities(- fullText,- metricNamesRef.current,- formulaEntitiesRef.current,- );+ const identities = identitiesFromEntries(initialIdentities);view.dispatch({selection: EditorSelection.cursor(endPos),- effects: [- setMetricNames.of(metricNamesRef.current),- setMetricIdentities.of(identities),- ],+ effects: setMetricIdentities.of(identities),annotations: isolateHistory.of("full"),});const coords = view.coordsAtPos(endPos);@@ -215,13 +208,14 @@ export function useFormulaEditor({/** Commits the current text: parses formula entities, removes unreferenced metrics, and collapses. */const commitAndCollapse = useCallback(() => {const newText = editTextRef.current;- const parsedEntities = parseFullText(newText, metricNamesRef.current);-- // Read tracked identities from the CodeMirror StateField —- // positions are already mapped through all edits automatically.const view = editorRef.current?.view;const trackedIdentities = view ? readMetricIdentities(view) : [];+ const parsedEntities = parseFullText(+ newText,+ metricNamesRef.current,+ trackedIdentities,+ );const { entities: reconciledEntities, slotMapping } =applyTrackedDefinitions(parsedEntities,@@ -293,11 +287,12 @@ export function useFormulaEditor({return;}- // Text was modified — validate on blur but do NOT commit.- // The expression is only executed when the user explicitly clicks "Run".+ const view = editorRef.current?.view;+ const identities = view ? readMetricIdentities(view) : [];const invalidRanges = findInvalidRanges(editTextRef.current,metricNamesRef.current,+ identities,);if (invalidRanges.length > 0) {setValidationError(invalidRanges[0].message);@@ -305,7 +300,7 @@ export function useFormulaEditor({}setValidationError(null);- }, [metricNamesRef]);+ }, [editorRef, metricNamesRef]);const handleChange = useCallback((newText: string) => {@@ -351,22 +346,21 @@ export function useFormulaEditor({);const metricName = metric.name ?? "";+ if (metricName.length === 0) {+ return;+ }- // Check if we need to auto-insert a separator before this metric.const textBeforeWord = docText.slice(0, start).trimEnd();const lastChar = textBeforeWord[textBeforeWord.length - 1];const NO_COMMA_CHARS = new Set(["+", "-", "*", "/", "(", ","]);const needsComma =textBeforeWord.length > 0 && !NO_COMMA_CHARS.has(lastChar);- // Dispatch through the view (not setEditText) — the value-prop sync- // in @uiw/react-codemirror does a full doc replacement that destroys- // all RangeSet-tracked identities.let insertText: string;let replaceFrom: number;let newCursorPos: number;if (needsComma) {- insertText = ", " + metricName;+ insertText = ENTITY_SEPARATOR + metricName;replaceFrom = textBeforeWord.length;newCursorPos = replaceFrom + insertText.length;} else {@@ -375,9 +369,39 @@ export function useFormulaEditor({newCursorPos = start + metricName.length;}+ const sourceId =+ metric.sourceType === "metric"+ ? createMetricSourceId(metric.id)+ : createMeasureSourceId(metric.id);++ // Positions are in post-change document coordinates — metricIdentityField+ // processes addMetricIdentity effects after mapping existing ranges through changes.+ const metricFrom = needsComma+ ? replaceFrom + ENTITY_SEPARATOR.length+ : replaceFrom;+ const metricTo = metricFrom + metricName.length;++ const existingIdentities = readMetricIdentities(view);+ const nextSlotIndex =+ existingIdentities.length > 0+ ? Math.max(...existingIdentities.map((i) => i.slotIndex)) + 1+ : 0;++ const definition = definitionsRef.current[sourceId]?.definition ?? null;++ // Dispatch through the view (not setEditText) — the value-prop sync+ // in @uiw/react-codemirror does a full doc replacement that destroys+ // all RangeSet-tracked identities.view.dispatch({changes: { from: replaceFrom, to: end, insert: insertText },selection: EditorSelection.cursor(newCursorPos),+ effects: addMetricIdentity.of({+ from: metricFrom,+ to: metricTo,+ sourceId,+ definition,+ slotIndex: nextSlotIndex,+ }),});setIsExpressionDirty(true);@@ -528,12 +552,12 @@ export function useFormulaEditor({/** Validate the expression and either show an error or commit + run the query. */const handleRun = useCallback(() => {- // Check for unknown / invalid tokens in the raw text first, before- // parseFullText strips them. This catches trailing junk like "!!!"- // that would otherwise be silently dropped.+ const view = editorRef.current?.view;+ const identities = view ? readMetricIdentities(view) : [];const invalidRanges = findInvalidRanges(editTextRef.current,metricNamesRef.current,+ identities,);if (invalidRanges.length > 0) {setValidationError(invalidRanges[0].message);@@ -542,7 +566,7 @@ export function useFormulaEditor({setValidationError(null);commitAndCollapse();- }, [commitAndCollapse, metricNamesRef]);+ }, [commitAndCollapse, editorRef, metricNamesRef]);handleRunRef.current = handleRun;// Sync validation error into the CodeMirror decoration field@@ -551,22 +575,18 @@ export function useFormulaEditor({if (!view) {return;}+ const identities = readMetricIdentities(view);const ranges =validationError !== null- ? findInvalidRanges(editTextRef.current, metricNamesRef.current)+ ? findInvalidRanges(+ editTextRef.current,+ metricNamesRef.current,+ identities,+ ): [];view.dispatch({ effects: setErrorDecoration.of(ranges) });}, [validationError, editorRef, metricNamesRef]);- // Sync metric entries into the CodeMirror state for atomic token ranges- useEffect(() => {- const view = editorRef.current?.view;- if (!view || !isFocused) {- return;- }- view.dispatch({ effects: setMetricNames.of(metricNames) });- }, [metricNames, isFocused, editorRef]);-return {editText,isFocused,diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/utils.ts b/frontend/src/metabase/metrics-viewer/components/MetricSearch/utils.tsindex 7b1e85b39b2..6121d881005 100644--- a/frontend/src/metabase/metrics-viewer/components/MetricSearch/utils.ts+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/utils.ts@@ -1,3 +1,4 @@+import { match } from "ts-pattern";import { t } from "ttag";import type { MetricDefinition } from "metabase-lib/metric";@@ -68,21 +69,96 @@ export function buildExpressionText(.join("");}-export function buildFullText(+export const ENTITY_SEPARATOR = ", ";++export interface FullTextWithIdentities {+ text: string;+ identities: MetricIdentityEntry[];+}++/**+ * Produces the display text and metric identity entries in a single walk.+ * Identities carry the exact character offsets matching the text layout.+ */+export function buildFullTextWithIdentities(formulaEntities: MetricsViewerFormulaEntity[],metricNames: MetricNameMap,-): string {- return formulaEntities- .map((entity) => {- if (isExpressionEntry(entity)) {- return buildExpressionText(entity.tokens, metricNames);- }- if (isMetricEntry(entity)) {- return metricNames[entity.id] ?? "";+): FullTextWithIdentities {+ const identities: MetricIdentityEntry[] = [];+ const parts: string[] = [];+ let offset = 0;+ let slotIndex = 0;++ for (const entity of formulaEntities) {+ if (parts.length > 0) {+ parts.push(ENTITY_SEPARATOR);+ offset += ENTITY_SEPARATOR.length;+ }++ if (isMetricEntry(entity)) {+ const name = metricNames[entity.id] ?? "";+ identities.push({+ sourceId: entity.id,+ from: offset,+ to: offset + name.length,+ definition: entity.definition,+ slotIndex: slotIndex++,+ });+ parts.push(name);+ offset += name.length;+ continue;+ }++ if (isExpressionEntry(entity)) {+ for (+ let tokenIndex = 0;+ tokenIndex < entity.tokens.length;+ tokenIndex+++ ) {+ const token = entity.tokens[tokenIndex];+ const prev = entity.tokens[tokenIndex - 1];+ if (+ tokenIndex > 0 &&+ prev?.type !== "open-paren" &&+ token.type !== "close-paren"+ ) {+ parts.push(" ");+ offset += 1;+ }++ const fragment = getTokenFragment(token, metricNames);+ if (token.type === "metric") {+ identities.push({+ sourceId: token.sourceId,+ from: offset,+ to: offset + fragment.length,+ definition: token.definition ?? null,+ slotIndex: slotIndex++,+ });+ }+ parts.push(fragment);+ offset += fragment.length;}- return "";- })- .join(", ");+ continue;+ }++ parts.push("");+ }++ return { text: parts.join(""), identities };+}++function getTokenFragment(+ token: ExpressionSubToken,+ metricNames: MetricNameMap,+): string {+ return match(token)+ .with({ type: "metric" }, (t) => metricNames[t.sourceId] ?? "")+ .with({ type: "operator" }, (t) => t.op)+ .with({ type: "constant" }, (t) => String(t.value))+ .with({ type: "open-paren" }, () => "(")+ .with({ type: "close-paren" }, () => ")")+ .exhaustive();}const COMMA = ",";@@ -115,7 +191,7 @@ function isWordChar(ch: string): boolean {export function getWordAtCursor(text: string,cursorPos: number,- metricNames?: MetricNameMap,+ metricNames: MetricNameMap,): { word: string; start: number; end: number } {// Build a set of metric names (lowercased) for quick lookup.let metricNamesLower: Set<string> | null = null;@@ -285,8 +361,9 @@ export function traverseMetricTokens(metricNames: MetricNameMap,entities: MetricsViewerFormulaEntity[],visitor: (visit: MetricTokenVisit) => void,+ identities: MetricIdentityEntry[],): void {- const allTokens = parseFullTextWithPositions(text, metricNames);+ const allTokens = parseFullTextWithPositions(text, metricNames, identities);const separators = findSeparatorCommaPositions(text, allTokens);const segments = groupTokensBySegment(allTokens, separators);@@ -371,8 +448,9 @@ function stripPositions(token: PositionedToken): ExpressionSubToken | null {export function parseFullText(text: string,metricNames: MetricNameMap,+ identities: MetricIdentityEntry[],): MetricsViewerFormulaEntity[] {- const allTokens = parseFullTextWithPositions(text, metricNames);+ const allTokens = parseFullTextWithPositions(text, metricNames, identities);const separators = findSeparatorCommaPositions(text, allTokens);const segments = groupTokensBySegment(allTokens, separators);const result: MetricsViewerFormulaEntity[] = [];@@ -388,7 +466,6 @@ export function parseFullText(.filter((t): t is ExpressionSubToken => t !== null),);- // Single metric reference without operators → standalone metric entryconst firstToken = subTokens[0];if (subTokens.length === 1 && firstToken.type === "metric") {const name = metricNames[firstToken.sourceId];@@ -402,7 +479,6 @@ export function parseFullText(}}- // Multiple tokens or operators → expression entryconst name = buildExpressionText(subTokens, metricNames);result.push({id: `expression:${name}`,@@ -555,6 +631,7 @@ function consumeNumber(text: string, startIndex: number): number | null {export function parseFullTextWithPositions(text: string,metricNames: MetricNameMap,+ identities: MetricIdentityEntry[],): PositionedToken[] {const sortedMetrics = Object.entries(metricNames).map(([id, name]) => ({ id, name: (name ?? "").toLowerCase() }))@@ -564,11 +641,29 @@ export function parseFullTextWithPositions().sort((a, b) => b.name.length - a.name.length);+ const identityByStart = new Map<number, MetricIdentityEntry>();+ for (const identity of identities) {+ identityByStart.set(identity.from, identity);+ }+const lower = text.toLowerCase();const tokens: PositionedToken[] = [];let i = 0;while (i < text.length) {+ const identity = identityByStart.get(i);+ if (identity) {+ tokens.push({+ type: "metric",+ sourceId: identity.sourceId,+ count: 0,+ from: identity.from,+ to: identity.to,+ });+ i = identity.to;+ continue;+ }+const ch = text[i];const isWhitespace = ch === " " || ch === "\t";@@ -720,11 +815,16 @@ export type ErrorRange = { from: number; to: number; message: string };export function findInvalidRanges(text: string,metricNames: MetricNameMap,+ identities: MetricIdentityEntry[],): ErrorRange[] {- const allTokens = parseFullTextWithPositions(text, metricNames);+ const allTokens = parseFullTextWithPositions(text, metricNames, identities);const separators = findSeparatorCommaPositions(text, allTokens);const segments = groupTokensBySegment(allTokens, separators);+ const identityPositions = new Set(+ identities.map((id) => getPositionKey(id.from, id.to)),+ );+const invalid: ErrorRange[] = [];for (const itemTokens of segments) {@@ -840,6 +940,27 @@ export function findInvalidRanges(}}+ // Metric tokens matched by greedy name matching but without a tracked+ // identity (i.e. not selected from the dropdown) must be rejected —+ // they lack the definition needed for dimension assignment.+ // Skip when the identities list is completely empty — this means identity+ // tracking is unavailable (e.g. full doc replacement wiped the RangeSet).+ if (identityPositions.size > 0) {+ for (const token of itemTokens) {+ if (+ token.type === "metric" &&+ !identityPositions.has(getPositionKey(token.from, token.to))+ ) {+ const metricText = text.substring(token.from, token.to);+ itemInvalid.push({+ from: token.from,+ to: token.to,+ message: t`Unknown token: "${metricText}"`,+ });+ }+ }+ }+const hasMetric = itemTokens.some((tok) => tok.type === "metric");if (!hasMetric && itemInvalid.length === 0) {itemInvalid.push({@@ -931,36 +1052,42 @@ export function applyTrackedDefinitions(const slotMapping = new Map<number, number>();let newSlotCounter = 0;- traverseMetricTokens(text, metricNames, newEntities, (visit) => {- const newSlotIndex = newSlotCounter++;- const key = getPositionKey(visit.positioned.from, visit.positioned.to);- const tracked = identityByPosition.get(key);-- if (tracked) {- slotMapping.set(tracked.slotIndex, newSlotIndex);- }+ traverseMetricTokens(+ text,+ metricNames,+ newEntities,+ (visit) => {+ const newSlotIndex = newSlotCounter++;+ const key = getPositionKey(visit.positioned.from, visit.positioned.to);+ const tracked = identityByPosition.get(key);++ if (tracked) {+ slotMapping.set(tracked.slotIndex, newSlotIndex);+ }- if (!tracked) {- return;- }+ if (!tracked) {+ return;+ }- if (visit.kind === "standalone") {- metricOverrides.set(visit.entity, tracked.definition ?? null);- return;- }+ if (visit.kind === "standalone") {+ metricOverrides.set(visit.entity, tracked.definition ?? null);+ return;+ }- let tokenMap = exprTokenOverrides.get(visit.entity);- if (!tokenMap) {- tokenMap = new Map();- exprTokenOverrides.set(visit.entity, tokenMap);- }- // remove any existing breakouts - not supported in math expressions- const definition =- tracked.definition != null- ? stripDefinitionProjections(tracked.definition)- : undefined;- tokenMap.set(visit.exprTokenIndex, definition);- });+ let tokenMap = exprTokenOverrides.get(visit.entity);+ if (!tokenMap) {+ tokenMap = new Map();+ exprTokenOverrides.set(visit.entity, tokenMap);+ }+ // remove any existing breakouts - not supported in math expressions+ const definition =+ tracked.definition != null+ ? stripDefinitionProjections(tracked.definition)+ : undefined;+ tokenMap.set(visit.exprTokenIndex, definition);+ },+ trackedIdentities,+ );const entities = newEntities.map((entity) => {if (metricOverrides.has(entity)) {diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/utils.unit.spec.ts b/frontend/src/metabase/metrics-viewer/components/MetricSearch/utils.unit.spec.tsindex 141d5f18c16..0b01fd743fa 100644--- a/frontend/src/metabase/metrics-viewer/components/MetricSearch/utils.unit.spec.ts+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/utils.unit.spec.ts@@ -16,21 +16,49 @@ import {setupDefinitionWithBreakout,} from "../../utils/__tests__/test-helpers";-import type { MetricIdentityEntry, MetricNameMap } from "./utils";+import type {+ MetricIdentityEntry,+ MetricNameMap,+ PositionedToken,+} from "./utils";import {applyTrackedDefinitions,buildExpressionText,+ buildFullTextWithIdentities,cleanupParens,filterSearchResults,findInvalidRanges,getWordAtCursor,parseFullText,+ parseFullTextWithPositions,} from "./utils";jest.mock("../../utils/definition-builder", () => ({getDefinitionName: (def: any) => def?.["display-name"] ?? null,}));+/**+ * Builds identity entries for ALL metric tokens found in the text.+ * Useful for tests that need identities but aren't testing identity tracking.+ */+function identitiesForAllMetrics(+ text: string,+ metricNames: MetricNameMap,+): MetricIdentityEntry[] {+ let slotIdx = 0;+ return parseFullTextWithPositions(text, metricNames, [])+ .filter(+ (t): t is PositionedToken & { type: "metric" } => t.type === "metric",+ )+ .map((t) => ({+ sourceId: t.sourceId,+ from: t.from,+ to: t.to,+ definition: null,+ slotIndex: slotIdx++,+ }));+}+function makeSearchResult(id: number, model: "metric" | "measure") {return { id, model, name: `Result ${id}` };}@@ -44,7 +72,12 @@ describe("filterSearchResults", () => {];it("excludes already-selected metrics by ID", () => {- const filtered = filterSearchResults(results, new Set([1]), new Set());+ const filtered = filterSearchResults(+ results,+ new Set([1]),+ new Set(),+ undefined,+ );expect(filtered.map((r) => ({ id: r.id, model: r.model }))).toEqual([{ id: 2, model: "metric" },{ id: 10, model: "measure" },@@ -53,7 +86,12 @@ describe("filterSearchResults", () => {});it("excludes already-selected measures by ID", () => {- const filtered = filterSearchResults(results, new Set(), new Set([10, 20]));+ const filtered = filterSearchResults(+ results,+ new Set(),+ new Set([10, 20]),+ undefined,+ );expect(filtered.map((r) => ({ id: r.id, model: r.model }))).toEqual([{ id: 1, model: "metric" },{ id: 2, model: "metric" },@@ -81,7 +119,12 @@ describe("filterSearchResults", () => {});it("handles empty results", () => {- const filtered = filterSearchResults([], new Set([1]), new Set([2]));+ const filtered = filterSearchResults(+ [],+ new Set([1]),+ new Set([2]),+ undefined,+ );expect(filtered).toEqual([]);});@@ -281,7 +324,7 @@ describe("parseFullText — numeric literal parsing", () => {});it("parses a metric multiplied by a decimal constant", () => {- const result = parseFullText("Revenue * 0.85", metricNames);+ const result = parseFullText("Revenue * 0.85", metricNames, []);expect(result).toHaveLength(1);expect(result[0]).toMatchObject({type: "expression",@@ -290,7 +333,7 @@ describe("parseFullText — numeric literal parsing", () => {});it("parses a metric multiplied by an integer constant", () => {- const result = parseFullText("Revenue * 100", metricNames);+ const result = parseFullText("Revenue * 100", metricNames, []);expect(result).toHaveLength(1);expect(result[0]).toMatchObject({type: "expression",@@ -299,7 +342,7 @@ describe("parseFullText — numeric literal parsing", () => {});it("parses a constant on the left side", () => {- const result = parseFullText("0.5 * Revenue", metricNames);+ const result = parseFullText("0.5 * Revenue", metricNames, []);expect(result).toHaveLength(1);expect(result[0]).toMatchObject({type: "expression",@@ -308,7 +351,7 @@ describe("parseFullText — numeric literal parsing", () => {});it("parses a constant inside parentheses — (Revenue + Costs) * 0.85", () => {- const result = parseFullText("(Revenue + Costs) * 0.85", metricNames);+ const result = parseFullText("(Revenue + Costs) * 0.85", metricNames, []);expect(result).toHaveLength(1);expect(result[0]).toMatchObject({type: "expression",@@ -326,7 +369,11 @@ describe("parseFullText — numeric literal parsing", () => {it("parses multiple constants in one expression", () => {// 0.5 * Revenue + 0.5 * Costs- const result = parseFullText("0.5 * Revenue + 0.5 * Costs", metricNames);+ const result = parseFullText(+ "0.5 * Revenue + 0.5 * Costs",+ metricNames,+ [],+ );expect(result).toHaveLength(1);expect(result[0]).toMatchObject({type: "expression",@@ -344,7 +391,7 @@ describe("parseFullText — numeric literal parsing", () => {it("handles an integer that looks like it could start a decimal (no dot follows)", () => {// "1 + Revenue" — "1" is an integer with no fractional part- const result = parseFullText("1 + Revenue", metricNames);+ const result = parseFullText("1 + Revenue", metricNames, []);expect(result).toHaveLength(1);expect(result[0]).toMatchObject({type: "expression",@@ -353,7 +400,7 @@ describe("parseFullText — numeric literal parsing", () => {});it("parses a leading-dot decimal like .5", () => {- const result = parseFullText(".5 * Revenue", metricNames);+ const result = parseFullText(".5 * Revenue", metricNames, []);expect(result).toHaveLength(1);expect(result[0]).toMatchObject({type: "expression",@@ -362,7 +409,7 @@ describe("parseFullText — numeric literal parsing", () => {});it("parses a metric multiplied by a leading-dot decimal", () => {- const result = parseFullText("Revenue * .85", metricNames);+ const result = parseFullText("Revenue * .85", metricNames, []);expect(result).toHaveLength(1);expect(result[0]).toMatchObject({type: "expression",@@ -371,7 +418,7 @@ describe("parseFullText — numeric literal parsing", () => {});it("parses a negative leading-dot decimal", () => {- const result = parseFullText("-.5 * Revenue", metricNames);+ const result = parseFullText("-.5 * Revenue", metricNames, []);expect(result).toHaveLength(1);expect(result[0]).toMatchObject({type: "expression",@@ -382,7 +429,7 @@ describe("parseFullText — numeric literal parsing", () => {it("does not parse a trailing dot as part of the number", () => {// "1." — trailing dot with no digit after it; "1" is the constant, "." is// dropped (unknown tokens are filtered out of committed data)- const result = parseFullText("1.", metricNames);+ const result = parseFullText("1.", metricNames, []);expect(result).toHaveLength(1);expect(result[0]).toMatchObject({type: "expression",@@ -392,7 +439,7 @@ describe("parseFullText — numeric literal parsing", () => {it("parses constants and metrics as separate items separated by a comma", () => {// "Revenue * 0.85, Costs"- const result = parseFullText("Revenue * 0.85, Costs", metricNames);+ const result = parseFullText("Revenue * 0.85, Costs", metricNames, []);expect(result).toHaveLength(2);expect(result[0]).toMatchObject({type: "expression",@@ -407,7 +454,7 @@ describe("parseFullText — numeric literal parsing", () => {it("round-trips through buildExpressionText", () => {const text = "(Revenue + Costs) * 0.85";- const result = parseFullText(text, metricNames);+ const result = parseFullText(text, metricNames, []);expect(result).toHaveLength(1);const entry = result[0];if (entry.type === "expression") {@@ -446,7 +493,7 @@ describe("parseFullText — negative numbers", () => {const close: ExpressionSubToken = { type: "close-paren" };it("parses a standalone negative integer", () => {- const result = parseFullText("-50", metricNames);+ const result = parseFullText("-50", metricNames, []);expect(result).toEqual([{id: "expression:-50",@@ -458,7 +505,7 @@ describe("parseFullText — negative numbers", () => {});it("parses metric plus negative constant", () => {- const result = parseFullText("Revenue + -50", metricNames);+ const result = parseFullText("Revenue + -50", metricNames, []);expect(result).toEqual([{id: "expression:Revenue + -50",@@ -470,7 +517,7 @@ describe("parseFullText — negative numbers", () => {});it("parses metric multiplied by negative decimal", () => {- const result = parseFullText("Revenue * -0.85", metricNames);+ const result = parseFullText("Revenue * -0.85", metricNames, []);expect(result).toEqual([{id: "expression:Revenue * -0.85",@@ -482,7 +529,7 @@ describe("parseFullText — negative numbers", () => {});it("parses negative constant at the start of expression", () => {- const result = parseFullText("-50 * Revenue", metricNames);+ const result = parseFullText("-50 * Revenue", metricNames, []);expect(result).toEqual([{id: "expression:-50 * Revenue",@@ -494,7 +541,7 @@ describe("parseFullText — negative numbers", () => {});it("parses negative constant after open-paren", () => {- const result = parseFullText("(-50 + Revenue)", metricNames);+ const result = parseFullText("(-50 + Revenue)", metricNames, []);expect(result).toEqual([{id: "expression:(-50 + Revenue)",@@ -506,7 +553,7 @@ describe("parseFullText — negative numbers", () => {});it("parses subtraction of a negative constant", () => {- const result = parseFullText("Revenue - -50", metricNames);+ const result = parseFullText("Revenue - -50", metricNames, []);expect(result).toEqual([{id: "expression:Revenue - -50",@@ -519,7 +566,7 @@ describe("parseFullText — negative numbers", () => {it("round-trips negative constants through buildExpressionText", () => {const text = "Revenue + -50";- const result = parseFullText(text, metricNames);+ const result = parseFullText(text, metricNames, []);expect(result).toHaveLength(1);const entry = result[0];if (entry.type === "expression") {@@ -537,11 +584,17 @@ describe("parseFullText — negative numbers", () => {"(-50 + Revenue)","Revenue * -0.85",])("does not report validation errors for: %s", (text) => {- expect(findInvalidRanges(text, metricNames)).toEqual([]);+ expect(+ findInvalidRanges(+ text,+ metricNames,+ identitiesForAllMetrics(text, metricNames),+ ),+ ).toEqual([]);});it("parses metric minus negative constant without spaces (Revenue--50)", () => {- const result = parseFullText("Revenue--50", metricNames);+ const result = parseFullText("Revenue--50", metricNames, []);expect(result).toEqual([{id: "expression:Revenue - -50",@@ -553,7 +606,7 @@ describe("parseFullText — negative numbers", () => {});it("parses metric minus negative decimal without spaces (Revenue--0.5)", () => {- const result = parseFullText("Revenue--0.5", metricNames);+ const result = parseFullText("Revenue--0.5", metricNames, []);expect(result).toEqual([{id: "expression:Revenue - -0.5",@@ -565,11 +618,17 @@ describe("parseFullText — negative numbers", () => {});it("does not report validation errors for Revenue--50", () => {- expect(findInvalidRanges("Revenue--50", metricNames)).toEqual([]);+ expect(+ findInvalidRanges(+ "Revenue--50",+ metricNames,+ identitiesForAllMetrics("Revenue--50", metricNames),+ ),+ ).toEqual([]);});it("still treats minus as binary operator after a metric", () => {- const result = parseFullText("Revenue - 50", metricNames);+ const result = parseFullText("Revenue - 50", metricNames, []);expect(result).toEqual([{id: "expression:Revenue - 50",@@ -581,7 +640,7 @@ describe("parseFullText — negative numbers", () => {});it("still treats minus as binary operator after a constant", () => {- const result = parseFullText("100 - Revenue", metricNames);+ const result = parseFullText("100 - Revenue", metricNames, []);expect(result).toEqual([{id: "expression:100 - Revenue",@@ -617,7 +676,7 @@ describe("parseFullText — metric names with commas", () => {"metric:10": "Revenue, Total","metric:2": "Costs",};- const result = parseFullText("Revenue, Total", names);+ const result = parseFullText("Revenue, Total", names, []);expect(result).toHaveLength(1);expect(result[0]).toMatchObject({ type: "metric", id: "metric:10" });});@@ -627,7 +686,7 @@ describe("parseFullText — metric names with commas", () => {"metric:10": "Revenue, Total","metric:2": "Costs",};- const result = parseFullText("Revenue, Total, Costs", names);+ const result = parseFullText("Revenue, Total, Costs", names, []);expect(result).toHaveLength(2);expect(result[0]).toMatchObject({ type: "metric", id: "metric:10" });expect(result[1]).toMatchObject({ type: "metric", id: "metric:2" });@@ -638,7 +697,7 @@ describe("parseFullText — metric names with commas", () => {"metric:10": "Revenue, Total","metric:2": "Costs",};- const result = parseFullText("Revenue, Total + Costs", names);+ const result = parseFullText("Revenue, Total + Costs", names, []);expect(result).toHaveLength(1);expect(result[0]).toMatchObject({type: "expression",@@ -651,7 +710,7 @@ describe("parseFullText — metric names with commas", () => {"metric:10": "Revenue, Total","metric:11": "Costs, Annual",};- const result = parseFullText("Revenue, Total, Costs, Annual", names);+ const result = parseFullText("Revenue, Total, Costs, Annual", names, []);expect(result).toHaveLength(2);expect(result[0]).toMatchObject({ type: "metric", id: "metric:10" });expect(result[1]).toMatchObject({ type: "metric", id: "metric:11" });@@ -664,7 +723,7 @@ describe("parseFullText — metric names with commas", () => {"metric:1": "Revenue","metric:2": "Costs",};- const result = parseFullText("Revenue, Total, Costs", names);+ const result = parseFullText("Revenue, Total, Costs", names, []);expect(result).toHaveLength(2);expect(result[0]).toMatchObject({ type: "metric", id: "metric:10" });expect(result[1]).toMatchObject({ type: "metric", id: "metric:2" });@@ -673,7 +732,7 @@ describe("parseFullText — metric names with commas", () => {it("falls back to shorter metric when longer does not match", () => {// Only "Revenue" is known, not "Revenue, Total"const names: MetricNameMap = { "metric:1": "Revenue", "metric:2": "Costs" };- const result = parseFullText("Revenue, Costs", names);+ const result = parseFullText("Revenue, Costs", names, []);expect(result).toHaveLength(2);expect(result[0]).toMatchObject({ type: "metric", id: "metric:1" });expect(result[1]).toMatchObject({ type: "metric", id: "metric:2" });@@ -681,7 +740,7 @@ describe("parseFullText — metric names with commas", () => {it("handles metric-with-comma multiplied by a constant", () => {const names: MetricNameMap = { "metric:10": "Revenue, Total" };- const result = parseFullText("Revenue, Total * 0.85", names);+ const result = parseFullText("Revenue, Total * 0.85", names, []);expect(result).toHaveLength(1);expect(result[0]).toMatchObject({type: "expression",@@ -701,15 +760,31 @@ describe("findInvalidRanges — unknown token detection", () => {};it("returns no errors for valid expression", () => {- expect(findInvalidRanges("Revenue + Costs", metricNames)).toEqual([]);+ expect(+ findInvalidRanges(+ "Revenue + Costs",+ metricNames,+ identitiesForAllMetrics("Revenue + Costs", metricNames),+ ),+ ).toEqual([]);});it("returns no errors for valid expression with constant", () => {- expect(findInvalidRanges("Revenue * 0.85", metricNames)).toEqual([]);+ expect(+ findInvalidRanges(+ "Revenue * 0.85",+ metricNames,+ identitiesForAllMetrics("Revenue * 0.85", metricNames),+ ),+ ).toEqual([]);});it("flags a single unknown word", () => {- const errors = findInvalidRanges("Revenue + xyz", metricNames);+ const errors = findInvalidRanges(+ "Revenue + xyz",+ metricNames,+ identitiesForAllMetrics("Revenue + xyz", metricNames),+ );expect(errors).toHaveLength(1);expect(errors[0]).toMatchObject({from: 10,@@ -719,7 +794,11 @@ describe("findInvalidRanges — unknown token detection", () => {});it("flags unknown text that is not a known metric", () => {- const errors = findInvalidRanges("Foo", metricNames);+ const errors = findInvalidRanges(+ "Foo",+ metricNames,+ identitiesForAllMetrics("Foo", metricNames),+ );expect(errors).toHaveLength(1);expect(errors[0]).toMatchObject({message: expect.stringContaining("Foo"),@@ -727,12 +806,21 @@ describe("findInvalidRanges — unknown token detection", () => {});it("flags multiple unknown tokens in different segments", () => {- const errors = findInvalidRanges("abc, def", metricNames);+ const errors = findInvalidRanges(+ "abc, def",+ metricNames,+ identitiesForAllMetrics("abc, def", metricNames),+ );expect(errors.length).toBeGreaterThanOrEqual(2);});it("flags unknown token mixed with valid tokens", () => {- const errors = findInvalidRanges("Revenue + unknown + Costs", metricNames);+ const text = "Revenue + unknown + Costs";+ const errors = findInvalidRanges(+ text,+ metricNames,+ identitiesForAllMetrics(text, metricNames),+ );expect(errors).toHaveLength(1);expect(errors[0]).toMatchObject({message: expect.stringContaining("unknown"),@@ -740,21 +828,41 @@ describe("findInvalidRanges — unknown token detection", () => {});it("does not flag numbers as unknown", () => {- expect(findInvalidRanges("Revenue * 100", metricNames)).toEqual([]);+ expect(+ findInvalidRanges(+ "Revenue * 100",+ metricNames,+ identitiesForAllMetrics("Revenue * 100", metricNames),+ ),+ ).toEqual([]);});it("does not flag parentheses as unknown", () => {- expect(findInvalidRanges("(Revenue + Costs)", metricNames)).toEqual([]);+ expect(+ findInvalidRanges(+ "(Revenue + Costs)",+ metricNames,+ identitiesForAllMetrics("(Revenue + Costs)", metricNames),+ ),+ ).toEqual([]);});it("does not flag operators as unknown", () => {- expect(findInvalidRanges("Revenue + Costs - Revenue", metricNames)).toEqual(- [],- );+ expect(+ findInvalidRanges(+ "Revenue + Costs - Revenue",+ metricNames,+ identitiesForAllMetrics("Revenue + Costs - Revenue", metricNames),+ ),+ ).toEqual([]);});it("flags unknown token at the start of expression", () => {- const errors = findInvalidRanges("xyz + Revenue", metricNames);+ const errors = findInvalidRanges(+ "xyz + Revenue",+ metricNames,+ identitiesForAllMetrics("xyz + Revenue", metricNames),+ );expect(errors).toHaveLength(1);expect(errors[0]).toMatchObject({from: 0,@@ -765,7 +873,11 @@ describe("findInvalidRanges — unknown token detection", () => {it("returns both structural and unknown errors", () => {// "xyz +" has an unknown token AND a trailing operator- const errors = findInvalidRanges("xyz +", metricNames);+ const errors = findInvalidRanges(+ "xyz +",+ metricNames,+ identitiesForAllMetrics("xyz +", metricNames),+ );expect(errors.length).toBeGreaterThanOrEqual(2);const messages = errors.map((e) => e.message);expect(messages.some((m) => m.includes("xyz"))).toBe(true);@@ -774,7 +886,12 @@ describe("findInvalidRanges — unknown token detection", () => {it("flags trailing characters after a metric name with special chars", () => {const names: MetricNameMap = { "metric:99": "People Q H2 Orders, Count!" };- const errors = findInvalidRanges("People Q H2 Orders, Count!!!!", names);+ const text = "People Q H2 Orders, Count!!!!";+ const errors = findInvalidRanges(+ text,+ names,+ identitiesForAllMetrics(text, names),+ );expect(errors).toHaveLength(1);expect(errors[0]).toMatchObject({from: 26,@@ -795,7 +912,11 @@ describe("findInvalidRanges — predecessor validation", () => {};it("flags missing operator between metric and constant", () => {- const errors = findInvalidRanges("Revenue 2", metricNames);+ const errors = findInvalidRanges(+ "Revenue 2",+ metricNames,+ identitiesForAllMetrics("Revenue 2", metricNames),+ );expect(errors).toHaveLength(1);expect(errors[0]).toMatchObject({from: 8,@@ -805,7 +926,11 @@ describe("findInvalidRanges — predecessor validation", () => {});it("flags missing operator between two metrics", () => {- const errors = findInvalidRanges("Revenue Costs", metricNames);+ const errors = findInvalidRanges(+ "Revenue Costs",+ metricNames,+ identitiesForAllMetrics("Revenue Costs", metricNames),+ );expect(errors).toHaveLength(1);expect(errors[0]).toMatchObject({from: 8,@@ -815,7 +940,11 @@ describe("findInvalidRanges — predecessor validation", () => {});it("flags missing operator between constant and metric", () => {- const errors = findInvalidRanges("2 Revenue", metricNames);+ const errors = findInvalidRanges(+ "2 Revenue",+ metricNames,+ identitiesForAllMetrics("2 Revenue", metricNames),+ );expect(errors).toHaveLength(1);expect(errors[0]).toMatchObject({from: 2,@@ -825,7 +954,12 @@ describe("findInvalidRanges — predecessor validation", () => {});it("flags missing operator between close-paren and metric", () => {- const errors = findInvalidRanges("(Revenue + Costs) Revenue", metricNames);+ const text = "(Revenue + Costs) Revenue";+ const errors = findInvalidRanges(+ text,+ metricNames,+ identitiesForAllMetrics(text, metricNames),+ );expect(errors).toHaveLength(1);expect(errors[0]).toMatchObject({from: 18,@@ -835,7 +969,11 @@ describe("findInvalidRanges — predecessor validation", () => {});it("flags operator before closing parenthesis", () => {- const errors = findInvalidRanges("(Revenue +)", metricNames);+ const errors = findInvalidRanges(+ "(Revenue +)",+ metricNames,+ identitiesForAllMetrics("(Revenue +)", metricNames),+ );expect(errors).toHaveLength(1);expect(errors[0]).toMatchObject({from: 10,@@ -845,42 +983,66 @@ describe("findInvalidRanges — predecessor validation", () => {});it("flags consecutive operators", () => {- const errors = findInvalidRanges("Revenue + + Costs", metricNames);+ const errors = findInvalidRanges(+ "Revenue + + Costs",+ metricNames,+ identitiesForAllMetrics("Revenue + + Costs", metricNames),+ );expect(errors.length).toBeGreaterThanOrEqual(1);const messages = errors.map((e) => e.message);expect(messages.some((m) => m.includes("Missing operand"))).toBe(true);});it("flags operator after opening parenthesis", () => {- const errors = findInvalidRanges("(+ Revenue)", metricNames);+ const errors = findInvalidRanges(+ "(+ Revenue)",+ metricNames,+ identitiesForAllMetrics("(+ Revenue)", metricNames),+ );expect(errors.length).toBeGreaterThanOrEqual(1);const messages = errors.map((e) => e.message);expect(messages.some((m) => m.includes("Missing operand"))).toBe(true);});it("flags empty parentheses", () => {- const errors = findInvalidRanges("Revenue + ()", metricNames);+ const errors = findInvalidRanges(+ "Revenue + ()",+ metricNames,+ identitiesForAllMetrics("Revenue + ()", metricNames),+ );expect(errors.length).toBeGreaterThanOrEqual(1);const messages = errors.map((e) => e.message);expect(messages.some((m) => m.includes("Empty parentheses"))).toBe(true);});it("flags leading operator", () => {- const errors = findInvalidRanges("+ Revenue", metricNames);+ const errors = findInvalidRanges(+ "+ Revenue",+ metricNames,+ identitiesForAllMetrics("+ Revenue", metricNames),+ );expect(errors.length).toBeGreaterThanOrEqual(1);const messages = errors.map((e) => e.message);expect(messages.some((m) => m.includes("Missing operand"))).toBe(true);});it("flags trailing operator", () => {- const errors = findInvalidRanges("Revenue +", metricNames);+ const errors = findInvalidRanges(+ "Revenue +",+ metricNames,+ identitiesForAllMetrics("Revenue +", metricNames),+ );expect(errors.length).toBeGreaterThanOrEqual(1);const messages = errors.map((e) => e.message);expect(messages.some((m) => m.includes("end with an operator"))).toBe(true);});it("flags constants-only expression as missing metric", () => {- const errors = findInvalidRanges("2 + 2", metricNames);+ const errors = findInvalidRanges(+ "2 + 2",+ metricNames,+ identitiesForAllMetrics("2 + 2", metricNames),+ );expect(errors).toHaveLength(1);expect(errors[0]).toMatchObject({message: expect.stringContaining("at least one metric"),@@ -888,7 +1050,11 @@ describe("findInvalidRanges — predecessor validation", () => {});it("flags unmatched opening parenthesis", () => {- const errors = findInvalidRanges("(Revenue + Costs", metricNames);+ const errors = findInvalidRanges(+ "(Revenue + Costs",+ metricNames,+ identitiesForAllMetrics("(Revenue + Costs", metricNames),+ );expect(errors).toHaveLength(1);expect(errors[0]).toMatchObject({from: 0,@@ -898,7 +1064,11 @@ describe("findInvalidRanges — predecessor validation", () => {});it("flags unmatched closing parenthesis", () => {- const errors = findInvalidRanges("Revenue + Costs)", metricNames);+ const errors = findInvalidRanges(+ "Revenue + Costs)",+ metricNames,+ identitiesForAllMetrics("Revenue + Costs)", metricNames),+ );expect(errors).toHaveLength(1);expect(errors[0]).toMatchObject({from: 15,@@ -908,13 +1078,77 @@ describe("findInvalidRanges — predecessor validation", () => {});it("accepts valid nested parentheses", () => {- expect(findInvalidRanges("(2 * (Revenue + Costs))", metricNames)).toEqual(- [],- );+ expect(+ findInvalidRanges(+ "(2 * (Revenue + Costs))",+ metricNames,+ identitiesForAllMetrics("(2 * (Revenue + Costs))", metricNames),+ ),+ ).toEqual([]);});it("accepts close-paren followed by operator", () => {- expect(findInvalidRanges("(Revenue + Costs) * 2", metricNames)).toEqual([]);+ expect(+ findInvalidRanges(+ "(Revenue + Costs) * 2",+ metricNames,+ identitiesForAllMetrics("(Revenue + Costs) * 2", metricNames),+ ),+ ).toEqual([]);+ });+});++// ---------------------------------------------------------------------------+// findInvalidRanges — untracked metric detection+// ---------------------------------------------------------------------------++describe("findInvalidRanges — untracked metric detection", () => {+ const metricNames: MetricNameMap = {+ "metric:1": "Revenue",+ "metric:2": "Costs",+ };++ it("accepts all metrics when every metric token has a tracked identity", () => {+ const text = "Revenue + Costs";+ const ids = identitiesForAllMetrics(text, metricNames);+ expect(findInvalidRanges(text, metricNames, ids)).toEqual([]);+ });++ it("flags a metric token that has no tracked identity", () => {+ // Only "Costs" has an identity; "Revenue" was typed by hand.+ const text = "Revenue + Costs";+ const costsIdentity: MetricIdentityEntry = {+ sourceId: "metric:2",+ from: 10,+ to: 15,+ definition: null,+ slotIndex: 0,+ };+ const errors = findInvalidRanges(text, metricNames, [costsIdentity]);+ expect(errors).toHaveLength(1);+ expect(errors[0]).toMatchObject({+ from: 0,+ to: 7,+ message: 'Unknown token: "Revenue"',+ });+ });++ it("skips untracked check when no identities are provided at all", () => {+ // When the identities list is completely empty the check is skipped+ // because identity tracking may be unavailable (e.g. doc replacement).+ const text = "Revenue + Costs";+ const errors = findInvalidRanges(text, metricNames, []);+ expect(errors).toHaveLength(0);+ });++ it("does not flag non-metric tokens (constants, operators)", () => {+ // "2 + 2" has no metrics — only the "must contain at least one metric"+ // error should fire, not untracked-metric errors.+ const errors = findInvalidRanges("2 + 2", metricNames, []);+ expect(errors).toHaveLength(1);+ expect(errors[0]).toMatchObject({+ message: expect.stringContaining("at least one metric"),+ });});});@@ -924,7 +1158,7 @@ describe("getWordAtCursor — comma handling with metric entries", () => {it("without entries, comma is always a delimiter", () => {const text = "Revenue, Total";// cursor at end- const result = getWordAtCursor(text, text.length);+ const result = getWordAtCursor(text, text.length, {});expect(result.word).toBe("Total");});@@ -1028,7 +1262,7 @@ describe("applyTrackedDefinitions", () => {it("applies tracked definition to a standalone metric by position", () => {const text = "Revenue";- const parsed = parseFullText(text, metricNames);+ const parsed = parseFullText(text, metricNames, []);const tracked = [identity(sourceId(1), 0, 7, revenueBreakoutDef)];const { entities } = applyTrackedDefinitions(parsed,@@ -1044,7 +1278,7 @@ describe("applyTrackedDefinitions", () => {it("preserves null definition when tracked identity has null", () => {const text = "Revenue";- const parsed = parseFullText(text, metricNames);+ const parsed = parseFullText(text, metricNames, []);const tracked = [identity(sourceId(1), 0, 7, null)];const { entities } = applyTrackedDefinitions(parsed,@@ -1057,14 +1291,14 @@ describe("applyTrackedDefinitions", () => {it("leaves entity unchanged when no tracked identity matches its position", () => {const text = "Revenue";- const parsed = parseFullText(text, metricNames);+ const parsed = parseFullText(text, metricNames, []);const { entities } = applyTrackedDefinitions(parsed, [], text, metricNames);expect(entities).toEqual(parsed);});it("matches definitions by exact position for comma-separated metrics", () => {const text = "Revenue, Geo Revenue";- const parsed = parseFullText(text, metricNames);+ const parsed = parseFullText(text, metricNames, []);const tracked = [identity(sourceId(1), 0, 7, revenueBreakoutDef),identity(sourceId(2), 9, 20, geoBreakoutDef),@@ -1085,7 +1319,7 @@ describe("applyTrackedDefinitions", () => {it("strips breakout projections from expression token definitions", () => {const text = "Revenue + 5";- const parsed = parseFullText(text, metricNames);+ const parsed = parseFullText(text, metricNames, []);const tracked = [identity(sourceId(1), 0, 7, revenueBreakoutDef)];const { entities } = applyTrackedDefinitions(parsed,@@ -1100,7 +1334,7 @@ describe("applyTrackedDefinitions", () => {it("preserves non-breakout definitions on expression tokens", () => {const text = "Revenue + 5";- const parsed = parseFullText(text, metricNames);+ const parsed = parseFullText(text, metricNames, []);const tracked = [identity(sourceId(1), 0, 7, revenueDef)];const { entities } = applyTrackedDefinitions(parsed,@@ -1114,14 +1348,14 @@ describe("applyTrackedDefinitions", () => {it("preserves reference identity for expression entries when no tokens change", () => {const text = "Revenue + 5";- const parsed = parseFullText(text, metricNames);+ const parsed = parseFullText(text, metricNames, []);const { entities } = applyTrackedDefinitions(parsed, [], text, metricNames);expect(entities[0]).toBe(parsed[0]);});it("does not touch non-metric tokens inside expressions", () => {const text = "Revenue + 5";- const parsed = parseFullText(text, metricNames);+ const parsed = parseFullText(text, metricNames, []);const tracked = [identity(sourceId(1), 0, 7, revenueDef)];const { entities } = applyTrackedDefinitions(parsed,@@ -1137,7 +1371,7 @@ describe("applyTrackedDefinitions", () => {it("applies definition only to standalone metric, not expression token at different position", () => {const text = "Revenue, Revenue + 5";- const parsed = parseFullText(text, metricNames);+ const parsed = parseFullText(text, metricNames, []);// Only the standalone Revenue (0-7) has a tracked identityconst tracked = [identity(sourceId(1), 0, 7, revenueBreakoutDef)];const { entities } = applyTrackedDefinitions(@@ -1157,7 +1391,7 @@ describe("applyTrackedDefinitions", () => {// Tracked identity at [100,107] — token was deleted (TrackDel).// New Revenue at [0,7] is a fresh instance, gets no override.const text = "Revenue";- const parsed = parseFullText(text, metricNames);+ const parsed = parseFullText(text, metricNames, []);const tracked = [identity(sourceId(1), 100, 107, revenueDef)];const { entities } = applyTrackedDefinitions(parsed,@@ -1172,7 +1406,7 @@ describe("applyTrackedDefinitions", () => {it("newly added duplicate of same metric gets no definition from the tracked one", () => {const text = "Revenue, Revenue";- const parsed = parseFullText(text, metricNames);+ const parsed = parseFullText(text, metricNames, []);// Only one tracked identity at position [0,7]const tracked = [identity(sourceId(1), 0, 7, revenueBreakoutDef)];const { entities } = applyTrackedDefinitions(@@ -1194,7 +1428,7 @@ describe("applyTrackedDefinitions", () => {it("preserves definition when token survives edit (position tracked by RangeSet)", () => {// "Revenue + 5" — Revenue token at [0,7] survived the editconst text = "Revenue + 5";- const parsed = parseFullText(text, metricNames);+ const parsed = parseFullText(text, metricNames, []);const tracked = [identity(sourceId(1), 0, 7, revenueDef)];const { entities } = applyTrackedDefinitions(parsed,@@ -1208,7 +1442,7 @@ describe("applyTrackedDefinitions", () => {it("two instances of same metric at different positions keep independent definitions", () => {const text = "Revenue, Revenue";- const parsed = parseFullText(text, metricNames);+ const parsed = parseFullText(text, metricNames, []);const tracked = [identity(sourceId(1), 0, 7, revenueBreakoutDef, 0),identity(sourceId(1), 9, 16, revenueDef, 1),@@ -1225,3 +1459,191 @@ describe("applyTrackedDefinitions", () => {expect((entities[1] as MetricDefinitionEntry).definition).toBe(revenueDef);});});++// ---------------------------------------------------------------------------+// buildFullTextWithIdentities+// ---------------------------------------------------------------------------++describe("buildFullTextWithIdentities", () => {+ const metricNames: MetricNameMap = {+ "metric:1": "Revenue",+ "metric:2": "Costs",+ "metric:3": "123",+ };++ const revenueDef = { "display-name": "Revenue" } as any;+ const costsDef = { "display-name": "Costs" } as any;+ const numericDef = { "display-name": "123" } as any;++ it("produces text and identity ranges for standalone metrics", () => {+ const entities: MetricsViewerFormulaEntity[] = [+ { id: "metric:1", type: "metric", definition: revenueDef },+ { id: "metric:2", type: "metric", definition: costsDef },+ ];+ expect(buildFullTextWithIdentities(entities, metricNames)).toEqual({+ text: "Revenue, Costs",+ identities: [+ {+ sourceId: "metric:1",+ from: 0,+ to: 7,+ definition: revenueDef,+ slotIndex: 0,+ },+ {+ sourceId: "metric:2",+ from: 9,+ to: 14,+ definition: costsDef,+ slotIndex: 1,+ },+ ],+ });+ });++ it("produces identity ranges for metrics inside expressions", () => {+ const entities: MetricsViewerFormulaEntity[] = [+ {+ id: "expression:Revenue + Costs" as const,+ type: "expression",+ name: "Revenue + Costs",+ tokens: [+ { type: "metric", sourceId: "metric:1" as const, count: 1 },+ { type: "operator", op: "+" as const },+ { type: "metric", sourceId: "metric:2" as const, count: 1 },+ ],+ },+ ];+ expect(buildFullTextWithIdentities(entities, metricNames)).toEqual({+ text: "Revenue + Costs",+ identities: [+ {+ sourceId: "metric:1",+ from: 0,+ to: 7,+ definition: null,+ slotIndex: 0,+ },+ {+ sourceId: "metric:2",+ from: 10,+ to: 15,+ definition: null,+ slotIndex: 1,+ },+ ],+ });+ });++ it("handles numeric metric names", () => {+ const entities: MetricsViewerFormulaEntity[] = [+ { id: "metric:3", type: "metric", definition: numericDef },+ ];+ expect(buildFullTextWithIdentities(entities, metricNames)).toEqual({+ text: "123",+ identities: [+ {+ sourceId: "metric:3",+ from: 0,+ to: 3,+ definition: numericDef,+ slotIndex: 0,+ },+ ],+ });+ });++ it("handles numeric metric in an expression with a constant", () => {+ const entities: MetricsViewerFormulaEntity[] = [+ {+ id: "expression:123 + 456" as const,+ type: "expression",+ name: "123 + 456",+ tokens: [+ { type: "metric", sourceId: "metric:3" as const, count: 1 },+ { type: "operator", op: "+" as const },+ { type: "constant", value: 456 },+ ],+ },+ ];+ expect(buildFullTextWithIdentities(entities, metricNames)).toEqual({+ text: "123 + 456",+ identities: [+ {+ sourceId: "metric:3",+ from: 0,+ to: 3,+ definition: null,+ slotIndex: 0,+ },+ ],+ });+ });++ it("handles empty entities", () => {+ expect(buildFullTextWithIdentities([], metricNames)).toEqual({+ text: "",+ identities: [],+ });+ });+});++// ---------------------------------------------------------------------------+// parseFullText with identities (numeric metric disambiguation)+// ---------------------------------------------------------------------------++describe("parseFullText with identities", () => {+ const metricNames: MetricNameMap = {+ "metric:1": "Revenue",+ "metric:3": "123",+ };++ function identity(+ sourceId: MetricSourceId,+ from: number,+ to: number,+ ): MetricIdentityEntry {+ return { sourceId, from, to, definition: null, slotIndex: 0 };+ }++ it("treats '123' as a metric when identity range covers it", () => {+ const identities = [identity("metric:3", 0, 3)];+ const result = parseFullText("123 + 456", metricNames, identities);+ expect(result).toEqual([+ {+ id: "expression:123 + 456",+ type: "expression",+ name: "123 + 456",+ tokens: [+ { type: "metric", sourceId: "metric:3", count: 1 },+ { type: "operator", op: "+" },+ { type: "constant", value: 456 },+ ],+ },+ ]);+ });++ it("treats '123' as a number when no identity covers it", () => {+ const result = parseFullText("123 + 456", metricNames, []);+ expect(result).toEqual([+ {+ id: "expression:123 + 456",+ type: "expression",+ name: "123 + 456",+ tokens: [+ { type: "constant", value: 123 },+ { type: "operator", op: "+" },+ { type: "constant", value: 456 },+ ],+ },+ ]);+ });++ it("handles numeric metric as standalone", () => {+ const identities = [identity("metric:3", 0, 3)];+ const result = parseFullText("123", metricNames, identities);+ expect(result).toEqual([+ { id: "metric:3", type: "metric", definition: null },+ ]);+ });+});