Skip to content

The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:

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.ts
index 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.css
index 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.tsx
index 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.ts
index 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.ts
index 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.ts
index 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 entry
const 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 entry
const 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.ts
index 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 identity
const 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 edit
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,
@@ -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 },
+ ]);
+ });
+});