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
Metrics Math UX (#70733)
Denis Berezin4c217bdb3c58
diff --git a/.clj-kondo/config.edn b/.clj-kondo/config.ednindex 41b20e42d11..d1508c765af 100644--- a/.clj-kondo/config.edn+++ b/.clj-kondo/config.edn@@ -186,6 +186,7 @@;; Workspace isolation functions are safe in parallel tests because they operate on;; isolated, test-specific workspaces and databases that don't affect other testsmetabase-enterprise.workspaces.isolation/destroy-workspace-isolation!+ metabase.lib-metric.ast.plan/validate-arithmetic-ast!metabase-enterprise.workspaces.isolation/ensure-database-isolation!metabase-enterprise.workspaces.test-util/create-ready-ws!;; Safe in tests, where we typically use a private, temporary index per thread.diff --git a/e2e/support/helpers/e2e-metrics-viewer-helpers.ts b/e2e/support/helpers/e2e-metrics-viewer-helpers.tsindex 94b52f37c61..bbcbb147d9e 100644--- a/e2e/support/helpers/e2e-metrics-viewer-helpers.ts+++ b/e2e/support/helpers/e2e-metrics-viewer-helpers.ts@@ -1,6 +1,11 @@export const MetricsViewer = {goToViewer: () => cy.visit("/explore"),- searchInput: () => cy.findByTestId("metrics-viewer-search-input"),+ searchInput: () => {+ // Click the right edge of the container to focus the CodeMirror input+ // without accidentally hitting a pill (which would trigger the swap-metric flow).+ cy.findByTestId("metrics-formula-input").click("right");+ return cy.findByTestId("metrics-viewer-search-input");+ },searchBarPills: () => cy.findAllByTestId("metrics-viewer-search-pill"),searchResults: () => cy.findByTestId("metrics-search-results"),breakoutLegend: () => cy.findByTestId("metrics-viewer-breakout-legend"),@@ -29,6 +34,15 @@ export const MetricsViewer = {"data-viz-ui-name",displayType,),+ assertAllVizTypes: (displayType: string, expectedLength?: number) => {+ const subject = MetricsViewer.getAllMetricVisualizations();+ if (expectedLength !== undefined) {+ subject.should("have.length", expectedLength);+ }+ subject.each(($el) => {+ cy.wrap($el).should("have.attr", "data-viz-ui-name", displayType);+ });+ },getMerticControls: () => cy.findByTestId("metrics-viewer-controls"),changeVizType: (display: string) =>MetricsViewer.getMerticControls()@@ -44,4 +58,5 @@ export const MetricsViewer = {MetricsViewer.searchBarPills().contains(metricName).rightclick();cy.findByText(/Go to metric home page/).click();},+ runButton: () => cy.findByTestId("run-expression-button"),};diff --git a/e2e/test/scenarios/metrics/metrics-explorer.cy.spec.ts b/e2e/test/scenarios/metrics/metrics-explorer.cy.spec.tsindex 93f8bcee6c2..92fa64fb7b2 100644--- a/e2e/test/scenarios/metrics/metrics-explorer.cy.spec.ts+++ b/e2e/test/scenarios/metrics/metrics-explorer.cy.spec.ts@@ -1,6 +1,7 @@import Color from "color";const { H } = cy;+import { SAMPLE_DB_ID, WRITABLE_DB_ID } from "e2e/support/cypress_data";import { SAMPLE_DATABASE } from "e2e/support/cypress_sample_database";import {@@ -8,7 +9,6 @@ import {ORDERS_MODEL_ID,} from "e2e/support/cypress_sample_instance_data";import type { StructuredQuestionDetails } from "e2e/support/helpers";-const { ORDERS_ID, ORDERS, PRODUCTS_ID, PRODUCTS, ACCOUNTS_ID, FEEDBACK_ID } =SAMPLE_DATABASE;@@ -113,6 +113,150 @@ const ALL_MODELS = [const SNAPSHOT_NAME = "metrics-explorer-snapshot";+// ============================================================================+// Test Helpers+// ============================================================================++/**+ * Add a metric or measure to the explorer via the search panel+ */+const addMetric = (name: string) => {+ // for some reason `type` clicks in the middle of the input first+ // so we use `{end}` to make sure we type at the end+ H.MetricsViewer.searchInput().type(`{end}, ${name}`);+ H.MetricsViewer.searchResults().findByText(name).click();++ H.MetricsViewer.runButton().click();+};+const addMetricMath = (expression: ({ metricName: string } | string)[]) => {+ H.MetricsViewer.searchInput().type("{end}, ");+ for (const item of expression) {+ if (typeof item === "string") {+ H.MetricsViewer.searchInput().type(`{end}${item}`);+ } else {+ H.MetricsViewer.searchInput().type(`{end}${item.metricName}`);+ H.MetricsViewer.searchResults().findByText(item.metricName).click();+ }+ }+ H.MetricsViewer.runButton().click();+};++/**+ * Select a breakout dimension+ */+const selectBreakout = (+ cardname: string,+ dimensionName: string,+ index = 0,+ binning?: string,+) => {+ H.MetricsViewer.searchBarPills().contains(cardname).rightclick();+ H.popover().findByText("Break out").click();+ const breakout = H.popover()+ .findAllByText(dimensionName)+ .should("have.length.at.least", index)+ .eq(index)+ .closest("[role=option]");++ if (binning) {+ breakout.findByTestId("dimension-list-item-binning").realHover().click();+ H.popover().findByRole("menuitem", { name: binning }).click();+ } else {+ breakout.click();+ }+};++/**+ * Intercept and wait for dataset query+ */+const interceptDatasetQuery = () => {+ cy.intercept("POST", "/api/metric/dataset").as("dataset");+};++/**+ * Verify the grid displays the correct number of metric cards+ */+const verifyMetricCount = (count: number) => {+ H.MetricsViewer.searchBarPills().should("have.length", count);+};++/**+ * Switch to a specific tab+ */+const switchToTab = (tabName: string) => {+ H.MetricsViewer.getTab(tabName).click();+};++/**+ * Convert CSS rgb() color string to uppercase hex (#RRGGBB).+ */+const rgbToHex = (rgb: string): string => {+ return Color(rgb).hex().toUpperCase();+};++/**+ * Get hex color(s) from a search bar pill's color indicator.+ * Returns an array of hex color strings.+ */+const getPillColors = (pillIndex: number): Cypress.Chainable<string[]> => {+ // eslint-disable-next-line metabase/no-unsafe-element-filtering+ return H.MetricsViewer.searchBarPills()+ .should("have.length.greaterThan", pillIndex)+ .eq(pillIndex)+ .findByTestId("color-indicator-container")+ .children()+ .then(($children) => {+ const colors: string[] = [];+ $children.each((_i, el) => {+ const $el = Cypress.$(el);+ // Multi-dot: backgroundColor is set; single icon: color is set+ const bg = $el.css("background-color");+ const fg = $el.css("color");+ const raw =+ bg && bg !== "rgba(0, 0, 0, 0)" && bg !== "transparent" ? bg : fg;+ colors.push(rgbToHex(raw));+ });+ return colors;+ });+};++/**+ * Assert that every color in a pill's indicator appears somewhere on the+ * chart (as a `fill` or `stroke` attribute on an SVG `path`).+ */+const assertPillColorsInChart = (pillIndex: number) => {+ getPillColors(pillIndex).then((colors) => {+ for (const color of colors) {+ H.echartsContainer()+ .find(`path[fill="${color}"], path[stroke="${color}"]`)+ .should("exist");+ }+ });+};++/**+ * Assert that the breakout legend dot colors match the pill colors for the+ * given pill index.+ */+const assertLegendColorsMatchPill = (pillIndex: number) => {+ getPillColors(pillIndex).then((pillColors) => {+ H.MetricsViewer.breakoutLegend()+ .findAllByTestId("breakout-legend-dot")+ .then(($dots) => {+ const legendColors: string[] = [];+ $dots.each((_i, el) => {+ const bg = Cypress.$(el).css("background-color");+ legendColors.push(rgbToHex(bg));+ });++ // Every pill color should appear in the legend+ for (const color of pillColors) {+ expect(legendColors).to.include(color);+ }+ });+ });+};+describe("scenarios > metrics > explorer", () => {before(() => {H.restore();@@ -124,6 +268,10 @@ describe("scenarios > metrics > explorer", () => {beforeEach(() => {H.restore(SNAPSHOT_NAME as any);cy.signInAsAdmin();++ interceptDatasetQuery();+ cy.intercept("GET", "/api/metric/*").as("getMetric");+ cy.intercept("GET", "/api/measure/*").as("getMeasure");H.resetSnowplow();H.enableTracking();});@@ -132,64 +280,6 @@ describe("scenarios > metrics > explorer", () => {H.expectNoBadSnowplowEvents();});- // ============================================================================- // Test Helpers- // ============================================================================-- /**- * Add a metric or measure to the explorer via the search panel- */- const addMetric = (name: string) => {- H.MetricsViewer.searchInput().clear().type(name);- H.MetricsViewer.searchResults().findByText(name).click();- };-- /**- * Select a breakout dimension- */- const selectBreakout = (- cardname: string,- dimensionName: string,- index = 0,- binning?: string,- ) => {- H.MetricsViewer.searchBarPills().contains(cardname).rightclick();- H.popover().findByText("Break out").click();- const breakout = H.popover()- .findAllByText(dimensionName)- .should("have.length.at.least", index)- .eq(index)- .closest("[role=option]");-- if (binning) {- breakout.findByTestId("dimension-list-item-binning").realHover().click();- H.popover().findByRole("menuitem", { name: binning }).click();- } else {- breakout.click();- }- };-- /**- * Intercept and wait for dataset query- */- const intercedptDatasetQuery = () => {- cy.intercept("POST", "/api/metric/dataset").as("dataset");- };-- /**- * Verify the grid displays the correct number of metric cards- */- const verifyMetricCount = (count: number) => {- H.MetricsViewer.searchBarPills().should("have.length", count);- };-- /**- * Switch to a specific tab- */- const switchToTab = (tabName: string) => {- H.MetricsViewer.getTab(tabName).click();- };-// ============================================================================// Entry Points// ============================================================================@@ -245,10 +335,6 @@ describe("scenarios > metrics > explorer", () => {// ============================================================================describe("Adding metrics and measures", () => {- beforeEach(() => {- intercedptDatasetQuery();- });-it("should add multiple metrics", () => {H.MetricsViewer.goToViewer();@@ -264,28 +350,22 @@ describe("scenarios > metrics > explorer", () => {cy.wait("@dataset");verifyMetricCount(2);- cy.log("no results");- H.MetricsViewer.searchInput().type("xyznonexistent");- H.MetricsViewer.searchResults().should(- "contain.text",- "No results found",- );-- cy.log("does not allow duplicates");- H.MetricsViewer.searchInput().clear().type("Count of products");- H.MetricsViewer.searchResults().should(- "contain.text",- "No results found",- );+ cy.log("allows duplicates");+ addMetric("Count of products");cy.log("Should allow me to add measures");- H.MetricsViewer.searchInput().clear();addMetric("Test Measure");-H.expectUnstructuredSnowplowEvent({event: "metrics_viewer_metric_added",event_detail: "measure",});++ cy.log("no results");+ H.MetricsViewer.searchInput().type("{end}, xyznonexistent");+ H.MetricsViewer.searchResults().should(+ "contain.text",+ "No results found",+ );});it("Should not show me metrics that live in collections I do not have permissions to see", () => {@@ -310,6 +390,8 @@ describe("scenarios > metrics > explorer", () => {"No results found",);+ H.MetricsViewer.searchInput().clear();+addMetric("Count of orders");cy.log("even though we can see the metric, we don't have permissions to run the query",@@ -326,9 +408,11 @@ describe("scenarios > metrics > explorer", () => {describe("Breakouts", () => {beforeEach(() => {- intercedptDatasetQuery();+ interceptDatasetQuery();+ cy.intercept("GET", "/api/metric/*").as("getMetric");H.MetricsViewer.goToViewer();addMetric("Count of orders");+ cy.wait("@getMetric");cy.wait("@dataset");});@@ -403,6 +487,384 @@ describe("scenarios > metrics > explorer", () => {.children().should("have.length", 6);});++ it("should handle breakout independently for multiple instances of the same metric", () => {+ cy.log(+ "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.searchResults().findByText("Count of products").click();+ cy.wait("@getMetric");++ H.MetricsViewer.searchInput().type(", Count of orders");+ cy.findByTestId("run-expression-button").click();++ cy.wait("@dataset");++ cy.log("Should have 2 metric pills (expression pill is separate)");+ H.MetricsViewer.searchBarPills().should("have.length", 3);++ cy.log(+ "Two standalone instances of the same metric should have different pill colors",+ );+ getPillColors(0).then((pill0Colors) => {+ getPillColors(2).then((pill2Colors) => {+ expect(pill0Colors[0]).to.not.equal(pill2Colors[0]);+ });+ });++ cy.log(+ "Each standalone pill color should appear on the chart as fill or stroke",+ );+ assertPillColorsInChart(0);+ assertPillColorsInChart(2);++ cy.log("Apply breakout to first instance of Count of orders");+ H.MetricsViewer.searchBarPills().eq(0).rightclick();+ H.popover().findByText("Break out").click();+ H.popover().findByText("Source").click();+ cy.wait("@dataset");++ cy.log("Breakout legend should be visible with Source values");+ H.MetricsViewer.breakoutLegend().should("be.visible");+ H.MetricsViewer.breakoutLegend().within(() => {+ cy.findByRole("heading", { name: "User → Source" }).should(+ "be.visible",+ );+ cy.findByText("Twitter").should("be.visible");+ cy.findByText("Facebook").should("be.visible");+ cy.findByText("Organic").should("be.visible");+ cy.findByText("Google").should("be.visible");+ cy.findByText("Affiliate").should("be.visible");+ });++ cy.log("First pill should show multiple color indicators (breakout)");+ H.MetricsViewer.searchBarPills()+ .eq(0)+ .findByTestId("color-indicator-container")+ .children()+ .should("have.length.greaterThan", 1);++ cy.log("Second pill should have single color (no breakout yet)");+ H.MetricsViewer.searchBarPills()+ .eq(2)+ .findByTestId("color-indicator-container")+ .children()+ .should("have.length", 1);++ cy.log("Breakout pill colors should appear on the chart");+ assertPillColorsInChart(0);++ cy.log("Non-breakout pill color should appear on the chart");+ assertPillColorsInChart(2);++ cy.log(+ "Legend dot colors should match pill colors for breakout instance",+ );+ assertLegendColorsMatchPill(0);++ cy.log("Apply breakout to second instance of Count of orders");+ H.MetricsViewer.searchBarPills().eq(2).rightclick();+ H.popover().findByText("Break out").click();+ H.popover().findByText("Source").click();+ cy.wait("@dataset");++ cy.log("Both pills should now have multiple color indicators");+ H.MetricsViewer.searchBarPills()+ .eq(0)+ .findByTestId("color-indicator-container")+ .children()+ .should("have.length.greaterThan", 1);+ H.MetricsViewer.searchBarPills()+ .eq(2)+ .findByTestId("color-indicator-container")+ .children()+ .should("have.length.greaterThan", 1);++ cy.log("Both breakout pills' colors should appear on the chart");+ assertPillColorsInChart(0);+ assertPillColorsInChart(2);++ cy.log(+ "The two breakout pills should have different color sets (different entities)",+ );+ getPillColors(0).then((pill0Colors) => {+ getPillColors(2).then((pill2Colors) => {+ expect(pill0Colors[0]).to.not.equal(pill2Colors[0]);+ });+ });++ cy.log("Remove breakout from first instance");+ H.MetricsViewer.searchBarPills().eq(0).rightclick();+ H.popover().findByText("Remove breakout").click();++ cy.log(+ "Legend should still be visible because second instance has breakout",+ );+ H.MetricsViewer.breakoutLegend().should("be.visible");+ H.MetricsViewer.breakoutLegend().within(() => {+ cy.findByRole("heading", { name: "User → Source" }).should(+ "be.visible",+ );+ });++ cy.log("First pill should have single color (breakout removed)");+ H.MetricsViewer.searchBarPills()+ .eq(0)+ .findByTestId("color-indicator-container")+ .children()+ .should("have.length", 1);++ cy.log("Second pill should still have multiple colors");+ H.MetricsViewer.searchBarPills()+ .eq(2)+ .findByTestId("color-indicator-container")+ .children()+ .should("have.length.greaterThan", 1);++ cy.log("After removing breakout, pill colors should still match chart");+ assertPillColorsInChart(0);+ assertPillColorsInChart(2);+ });++ it("should preserve breakout state when editing formula and re-running", () => {+ 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();++ H.MetricsViewer.searchBarPills().should("have.length", 2);++ cy.log("Apply breakout to first instance of Count of orders");+ H.MetricsViewer.searchBarPills().eq(0).rightclick();+ H.popover().findByText("Break out").click();+ H.popover().findByText("Source").click();+ cy.wait("@dataset");++ cy.log("Verify breakout is applied — first pill has multiple colors");+ H.MetricsViewer.searchBarPills()+ .eq(0)+ .findByTestId("color-indicator-container")+ .children()+ .should("have.length.greaterThan", 1);++ H.MetricsViewer.breakoutLegend().should("be.visible");++ cy.log("Enter formula edit mode and append a new metric");+ cy.findByTestId("metrics-formula-input").click();+ H.MetricsViewer.searchInput().type(", Count of products");+ H.MetricsViewer.searchResults().findByText("Count of products").click();+ cy.wait("@getMetric");++ cy.findByTestId("run-expression-button").click();+ cy.wait("@dataset");++ cy.log("Should now have 3 metric pills");+ H.MetricsViewer.searchBarPills().should("have.length", 3);++ cy.log(+ "First pill should still have breakout — multiple color indicators preserved",+ );+ H.MetricsViewer.searchBarPills()+ .eq(0)+ .findByTestId("color-indicator-container")+ .children()+ .should("have.length.greaterThan", 1);++ cy.log("Breakout legend should still be visible");+ H.MetricsViewer.breakoutLegend().should("be.visible");+ H.MetricsViewer.breakoutLegend().within(() => {+ cy.findByRole("heading", { name: "User → Source" }).should(+ "be.visible",+ );+ });++ cy.log("Newly added third pill should have single color (no breakout)");+ H.MetricsViewer.searchBarPills()+ .eq(2)+ .findByTestId("color-indicator-container")+ .children()+ .should("have.length", 1);++ cy.log("Second pill (standalone Count of orders) should still be single");+ H.MetricsViewer.searchBarPills()+ .eq(1)+ .findByTestId("color-indicator-container")+ .children()+ .should("have.length", 1);++ cy.log("Remove second pill (standalone Count of orders)");+ H.MetricsViewer.searchBarPills()+ .eq(1)+ .findByLabelText("Remove Count of orders")+ .click();++ cy.log(+ "First pill should still have breakout — multiple color indicators preserved",+ );+ H.MetricsViewer.searchBarPills()+ .eq(0)+ .findByTestId("color-indicator-container")+ .children()+ .should("have.length.greaterThan", 1);+ });++ it("cannot breakout a metric math expression", () => {+ addMetricMath([+ { metricName: "Count of orders" },+ "+",+ { metricName: "Test Measure" },+ ]);+ cy.wait("@dataset");+ H.MetricsViewer.searchBarPills().eq(1).rightclick();+ H.popover({ skipVisibilityCheck: true }).should("not.exist");+ });++ 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.searchResults().findByText("Count of products").click();+ cy.wait("@getMetric");++ cy.findByTestId("run-expression-button").click();+ cy.wait("@dataset");++ cy.log(+ "Dimension pill bar should contain an expression dimension pill with a selected dimension",+ );+ H.MetricsViewer.getDimensionPillContainer().within(() => {+ cy.findByTestId("expression-dimension-pill").should("exist");+ cy.findByTestId("expression-dimension-pill").should(+ "not.contain.text",+ "Select dimensions",+ );+ });++ cy.log("Click the expression dimension pill to open the popover");+ H.MetricsViewer.getDimensionPillContainer()+ .findByTestId("expression-dimension-pill")+ .click();++ cy.log(+ "Popover should show accordion sections for each metric in the expression",+ );+ H.popover().within(() => {+ cy.findAllByTestId("expression-metric-section").should(+ "have.length",+ 2,+ );+ cy.findAllByTestId("expression-metric-header")+ .eq(0)+ .should("contain.text", "Count of orders");+ cy.findAllByTestId("expression-metric-header")+ .eq(1)+ .should("contain.text", "Count of products");+ });++ cy.log(+ "Expand the second metric section and verify dimension options are shown",+ );+ H.popover().findAllByTestId("expression-metric-header").eq(1).click();++ H.popover().within(() => {+ cy.get("[data-element-id=list-item][aria-selected=false]")+ .contains(/Created At/)+ .click();+ });++ cy.wait("@dataset");++ cy.log("Expression dimension pill should now show 'Multiple dimensions'");+ H.MetricsViewer.getDimensionPillContainer()+ .findByTestId("expression-dimension-pill")+ .should("contain.text", "Multiple dimensions");+ });++ it("should preserve non-default expression dimensions after page reload", () => {+ 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");+ H.MetricsViewer.searchResults().findByText("Count of products").click();+ cy.wait("@getMetric");++ cy.findByTestId("run-expression-button").click();+ cy.wait("@dataset");++ cy.log(+ "Open the expression dimension pill and pick a non-default dimension for the second metric",+ );+ H.MetricsViewer.getDimensionPillContainer()+ .findByTestId("expression-dimension-pill")+ .click();++ // Expand the second metric accordion section+ H.popover().findAllByTestId("expression-metric-header").eq(1).click();++ // Pick a non-default dimension (e.g. "Created At" for Products)+ H.popover().within(() => {+ cy.get("[data-element-id=list-item][aria-selected=false]")+ .contains(/Created At/)+ .click();+ });++ cy.wait("@dataset");++ cy.log("Verify the pill shows 'Multiple dimensions' (non-default state)");+ H.MetricsViewer.getDimensionPillContainer()+ .findByTestId("expression-dimension-pill")+ .should("contain.text", "Multiple dimensions");++ cy.log(+ "Remember the selected dimension index for the first metric before reload",+ );+ H.MetricsViewer.getDimensionPillContainer()+ .findByTestId("expression-dimension-pill")+ .click();++ H.popover()+ .find("[data-element-id=list-item]")+ .then(($items) => {+ const selectedIndex = $items+ .toArray()+ .findIndex((el) => el.getAttribute("aria-selected") === "true");+ expect(selectedIndex).to.be.gte(0);+ cy.wrap(selectedIndex).as("firstMetricDimensionIndex");+ });++ // Close the popover+ cy.realPress("Escape");++ cy.log("Reload the page and verify the dimension choice persists");+ cy.reload();+ cy.wait("@getMetric");+ cy.wait("@dataset");++ H.MetricsViewer.getDimensionPillContainer()+ .findByTestId("expression-dimension-pill")+ .should("contain.text", "Multiple dimensions")+ .click();++ cy.log(+ "Verify the first metric still has the same selected dimension after reload",+ );++ cy.get<number>("@firstMetricDimensionIndex").then((expectedIndex) => {+ // eslint-disable-next-line metabase/no-unsafe-element-filtering+ H.popover()+ .find("[data-element-id=list-item]")+ .eq(expectedIndex)+ .should("have.attr", "aria-selected", "true");+ });+ });});// ============================================================================@@ -411,18 +873,27 @@ describe("scenarios > metrics > explorer", () => {describe("Tabs", () => {beforeEach(() => {- intercedptDatasetQuery();+ interceptDatasetQuery();H.MetricsViewer.goToViewer();addMetric("Count of orders");cy.wait("@dataset");});it("should switch between tabs", () => {+ //should work with metric math as well+ addMetricMath([+ { metricName: "Count of orders" },+ "+",+ { metricName: "Test Measure" },+ ]);+ cy.wait("@dataset");+H.MetricsViewer.tabsShouldBe(["Created At","State","Title","Category",+ "Totals",]);H.MetricsViewer.assertVizType("Line");@@ -430,7 +901,7 @@ describe("scenarios > metrics > explorer", () => {H.expectUnstructuredSnowplowEvent({event: "metrics_viewer_dimension_tab_switched",});- H.MetricsViewer.assertVizType("Map");+ H.MetricsViewer.assertAllVizTypes("Map", 2);switchToTab("Category");H.MetricsViewer.assertVizType("Bar");@@ -438,6 +909,9 @@ describe("scenarios > metrics > explorer", () => {cy.log("should allow changing display types");H.MetricsViewer.changeVizType("line");H.MetricsViewer.assertVizType("Line");++ switchToTab("Totals");+ H.MetricsViewer.assertAllVizTypes("Number", 2);});it("should not show dimensions that are already in tabs in the dimension picker", () => {@@ -461,6 +935,28 @@ describe("scenarios > metrics > explorer", () => {});});+ it("should auto-assign dimensions for a newly added metric after running the formula", () => {+ cy.log(+ "After adding a second metric, all dimension pills should have a selected dimension",+ );++ cy.findByTestId("metrics-formula-input").click();+ addMetric("Count of products");+ cy.wait("@dataset");++ H.MetricsViewer.getDimensionPillContainer().within(() => {+ cy.findAllByText("Select a dimension").should("not.exist");+ });++ cy.log(+ "Switch to another tab and verify dimensions are assigned there too",+ );+ switchToTab("Category");+ H.MetricsViewer.getDimensionPillContainer().within(() => {+ cy.findAllByText("Select a dimension").should("not.exist");+ });+ });+it("should map shared dimensions to all metrics when adding a tab from the picker", () => {addMetric("Count of products");cy.wait("@dataset");@@ -481,6 +977,37 @@ describe("scenarios > metrics > explorer", () => {});});+ it("should remove then re-add the totals tab", () => {+ //should work with metric math as well+ addMetricMath([+ { metricName: "Count of orders" },+ "+",+ { metricName: "Test Measure" },+ ]);+ cy.wait("@dataset");++ // Need to hover the tab so that the remove button is accessible+ H.MetricsViewer.tablist()+ .findByRole("tab", { name: "Totals" })+ .realHover();+ H.MetricsViewer.getRemoveTabButton("Totals").click();+ H.MetricsViewer.tablist()+ .findByRole("tab", { name: "Totals" })+ .should("not.exist");++ H.MetricsViewer.getAddDimensionButton().click();+ H.popover().within(() => {+ cy.findAllByText("Totals").click();+ });+ cy.wait("@dataset");++ cy.log("totals tab should be selected and show correct viz type");+ H.MetricsViewer.tablist()+ .findByRole("tab", { name: "Totals" })+ .should("have.attr", "aria-selected", "true");+ H.MetricsViewer.assertAllVizTypes("Number", 2);+ });+it("should add a dimension tab and remove it", () => {addMetric("Count of feedback");H.MetricsViewer.tabsShouldBe([@@ -533,7 +1060,7 @@ describe("scenarios > metrics > explorer", () => {});H.MetricsViewer.getDimensionPillContainer().within(() => {cy.findByText("User → Source").should("exist");- cy.findByText("Select a dimension").click();+ cy.findByText("Account → Source").click();});H.popover().findByText("Plan").click();@@ -607,7 +1134,7 @@ describe("scenarios > metrics > explorer", () => {describe("Automatic split view", () => {beforeEach(() => {- intercedptDatasetQuery();+ interceptDatasetQuery();H.MetricsViewer.goToViewer();addMetric("Count of orders");cy.wait("@dataset");@@ -678,7 +1205,7 @@ describe("scenarios > metrics > explorer", () => {describe("Filters", () => {beforeEach(() => {- intercedptDatasetQuery();+ interceptDatasetQuery();H.MetricsViewer.goToViewer();addMetric("Count of orders");cy.wait("@dataset");@@ -1012,17 +1539,30 @@ describe("scenarios > metrics > explorer", () => {describe("Drill through", () => {beforeEach(() => {- intercedptDatasetQuery();+ interceptDatasetQuery();H.MetricsViewer.goToViewer();addMetric("Count of orders");cy.wait("@dataset");+ //should work with metric math as well+ addMetricMath([+ { metricName: "Count of orders" },+ "+",+ { metricName: "Test Measure" },+ ]);+ cy.wait("@dataset");});- it("should drill into more graual time dimensions on timeseries chart", () => {+ it("should drill into more granular time dimensions on timeseries chart", () => {H.MetricsViewer.getMerticControls().findByRole("button", { name: /by month/ }).should("exist");- H.MetricsViewer.getMetricVisualizationDataPoints().eq(4).click();+ // this is messy, but adding the metric math expression causes the viz to unmount and dispose the ECharts instance+ // if you click on the chart while it's being disposed, the click isn't handled properly+ cy.wait(1000);+ H.MetricsViewer.getMetricVisualization()+ .get("path[stroke='#EF8C8C']")+ .eq(4)+ .click();H.popover().findByText("See this month by week").click();H.MetricsViewer.getMerticControls()@@ -1030,7 +1570,7 @@ describe("scenarios > metrics > explorer", () => {.should("exist");H.MetricsViewer.getMetricVisualizationDataPoints().should("have.length",- 5,+ 12,);});@@ -1043,10 +1583,98 @@ describe("scenarios > metrics > explorer", () => {cy.findByText(/September/).should("be.visible");cy.findByText(/October/).should("be.visible");cy.findByText(/November/).should("be.visible");- cy.findByText(/December/).should("be.visible");});});});++ describe("metric math", () => {+ beforeEach(() => {+ interceptDatasetQuery();+ H.MetricsViewer.goToViewer();+ addMetric("Count of orders");+ cy.wait("@dataset");+ });+ it("should apply filters and dimensions to individual metric instances within expressions", () => {+ selectBreakout("Count of orders", "Category");+ cy.wait("@dataset");+ addMetricMath([+ { metricName: "Count of orders" },+ "+",+ { metricName: "Count of orders" },+ ]);+ cy.wait("@dataset");++ H.MetricsViewer.getFilterButton().click();+ H.popover().within(() => {+ cy.findAllByText("Count of orders")+ .should("have.length", 3)+ .eq(1)+ .click();+ cy.findByText("Category").click();+ cy.findByText("Doohickey").click();+ cy.button("Add filter").click();+ });+ H.MetricsViewer.getFilterButton().click();+ H.popover().within(() => {+ cy.findAllByText("Count of orders").eq(2).click();+ cy.findByText("Category").click();+ cy.findByText("Gadget").click();+ cy.button("Add filter").click();+ });+ H.MetricsViewer.getMerticControls()+ .findByRole("button", { name: /All time/i })+ .click();+ H.popover().findByText("Previous 12 months").click();++ function assertMetricMath() {+ cy.log("breakout is applied");+ H.MetricsViewer.searchBarPills()+ .contains(+ "[data-testid=metrics-viewer-search-pill]",+ "Count of orders",+ )+ .findByTestId("color-indicator-container")+ .children()+ .should("have.length", 4);+ cy.log(+ "filter pills are in place and show the badge indicating the unique metric instance",+ );+ const filterPills = H.MetricsViewer.getAllFilterPills();+ filterPills.should("have.length", 2);+ H.MetricsViewer.getAllFilterPills()+ .eq(0)+ .findByText("2")+ .should("not.exist");+ H.MetricsViewer.getAllFilterPills()+ .eq(1)+ .findByText("2")+ .should("exist");++ cy.log("dimension filter is applied");+ H.MetricsViewer.getMetricVisualizationDataPoints().should(+ "have.length.of.at.most",+ 60,+ );+ switchToTab("Totals");+ cy.log("correct value is calculated from metric math expression");+ H.MetricsViewer.getAllMetricVisualizations()+ .should("have.length", 5)+ .eq(4)+ .contains("8,915");+ switchToTab("Created At");+ }+ assertMetricMath();++ cy.log("refresh and assert again");+ cy.reload();+ assertMetricMath();++ cy.log("edit formula and assert again");+ H.MetricsViewer.searchInput().type("{end} + 0", { delay: 100 });+ H.MetricsViewer.runButton().click();+ assertMetricMath();+ });+ });});describe("scenarios > metrics > explorer > BigInt filters", () => {@@ -1073,8 +1701,7 @@ describe("scenarios > metrics > explorer > BigInt filters", () => {};H.createQuestion(BIGINT_METRIC);H.MetricsViewer.goToViewer();- H.MetricsViewer.searchInput().type(METRIC_NAME);- H.MetricsViewer.searchResults().findByText(METRIC_NAME).click();+ addMetric(METRIC_NAME);H.MetricsViewer.getFilterButton().click();H.popover().findByText("ID").click();H.popover().within(() => {diff --git a/frontend/src/metabase-lib/metric/core.ts b/frontend/src/metabase-lib/metric/core.tsindex 7bd46a2e736..11d7725758a 100644--- a/frontend/src/metabase-lib/metric/core.ts+++ b/frontend/src/metabase-lib/metric/core.ts@@ -713,3 +713,10 @@ export function isSameSource(): boolean {return LibMetric.isSameSource(dimension1, dimension2) as boolean;}++export function isCompatibleType(+ dimension1: DimensionMetadata,+ dimension2: DimensionMetadata,+): boolean {+ return LibMetric.isCompatibleType(dimension1, dimension2) as boolean;+}diff --git a/frontend/src/metabase-types/api/metric.ts b/frontend/src/metabase-types/api/metric.tsindex 745fc47ba4c..9d702d708d1 100644--- a/frontend/src/metabase-types/api/metric.ts+++ b/frontend/src/metabase-types/api/metric.ts@@ -23,10 +23,40 @@ export type Metric = {result_column_name?: string;};-export type ExpressionRef =+export const MATH_OPERATORS = ["+", "-", "*", "/"] as const;+export type MathOperator = (typeof MATH_OPERATORS)[number];++export function isMathOperator(key: string): key is MathOperator {+ return (MATH_OPERATORS as readonly string[]).includes(key);+}++export const MATH_EXPRESSION_OPERATORS = [+ ...MATH_OPERATORS,+ "(",+ ")",+ ",",+] as const;+export type MathExpressionOperator = (typeof MATH_OPERATORS)[number];++export function isMathExpressionOperator(+ key: string,+): key is MathExpressionOperator {+ return (MATH_EXPRESSION_OPERATORS as readonly string[]).includes(key);+}++export type JsExpressionRef =| ["metric", { "lib/uuid": string }, number]| ["measure", { "lib/uuid": string }, number];+export type ExpressionRef =+ | JsExpressionRef+ | [+ MathOperator,+ Record<string, never>,+ ExpressionRef | number,+ ExpressionRef | number,+ ];+export type InstanceFilter = {"lib/uuid": string;filter: unknown;@@ -40,7 +70,7 @@ export type TypedProjection = {};export type JsMetricDefinition = {- expression: ExpressionRef | unknown[];+ expression: JsExpressionRef | unknown[];filters?: InstanceFilter[];projections?: TypedProjection[];};diff --git a/frontend/src/metabase/common/components/SourceColorIndicator/SourceColorIndicator.tsx b/frontend/src/metabase/common/components/SourceColorIndicator/SourceColorIndicator.tsxindex bb44df05440..4d10584fbe8 100644--- a/frontend/src/metabase/common/components/SourceColorIndicator/SourceColorIndicator.tsx+++ b/frontend/src/metabase/common/components/SourceColorIndicator/SourceColorIndicator.tsx@@ -5,7 +5,7 @@ import S from "./SourceColorIndicator.module.css";type SourceColorIndicatorProps = {colors?: string[];- fallbackIcon: IconName;+ fallbackIcon?: IconName;size?: number;limit?: number;};@@ -34,8 +34,22 @@ export function SourceColorIndicator({</Flex>);}-+ const color = colors?.[0] ?? "var(--mb-color-text-primary)";+ if (fallbackIcon) {+ return (+ <Flex align="center" data-testid="color-indicator-container">+ <Icon name={fallbackIcon} size={size} style={{ color }} />+ </Flex>+ );+ }return (- <Icon name={fallbackIcon} size={size} style={{ color: colors?.[0] }} />+ <Box+ className={S.colorDot}+ w={size}+ h={size}+ style={{+ backgroundColor: color,+ }}+ />);}diff --git a/frontend/src/metabase/metrics-viewer/components/BreakoutLegend/BreakoutLegend.tsx b/frontend/src/metabase/metrics-viewer/components/BreakoutLegend/BreakoutLegend.tsxindex 538b90f3756..6d2fd505cc5 100644--- a/frontend/src/metabase/metrics-viewer/components/BreakoutLegend/BreakoutLegend.tsx+++ b/frontend/src/metabase/metrics-viewer/components/BreakoutLegend/BreakoutLegend.tsx@@ -3,7 +3,9 @@ import { useMemo } from "react";import { Box, Flex, Paper, Stack, Text, Title } from "metabase/ui";import type {+ MetricSourceId,MetricsViewerDefinitionEntry,+ MetricsViewerFormulaEntity,SourceBreakoutColorMap,} from "../../types/viewer-state";import { buildLegendGroups } from "../../utils/legend";@@ -11,17 +13,19 @@ import { buildLegendGroups } from "../../utils/legend";import S from "./BreakoutLegend.module.css";type BreakoutLegendProps = {- definitions: MetricsViewerDefinitionEntry[];+ formulaEntities: MetricsViewerFormulaEntity[];+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>;activeBreakoutColors: SourceBreakoutColorMap;};export function BreakoutLegend({+ formulaEntities,definitions,activeBreakoutColors,}: BreakoutLegendProps) {const groups = useMemo(- () => buildLegendGroups(definitions, activeBreakoutColors),- [definitions, activeBreakoutColors],+ () => buildLegendGroups(formulaEntities, definitions, activeBreakoutColors),+ [formulaEntities, definitions, activeBreakoutColors],);if (groups.length === 0) {@@ -41,7 +45,7 @@ export function BreakoutLegend({<Paper withBorder radius="md" p="lg"><Stack gap="lg">{groups.map((group) => (- <Stack key={group.header} gap="sm">+ <Stack key={group.key} gap="sm"><div><Title fw="bold" size="md" lh={1.3}>{group.header}diff --git a/frontend/src/metabase/metrics-viewer/components/DimensionPillBar/DimensionPillBar.tsx b/frontend/src/metabase/metrics-viewer/components/DimensionPillBar/DimensionPillBar.tsxindex 2712f03000e..147e4473866 100644--- a/frontend/src/metabase/metrics-viewer/components/DimensionPillBar/DimensionPillBar.tsx+++ b/frontend/src/metabase/metrics-viewer/components/DimensionPillBar/DimensionPillBar.tsx@@ -6,21 +6,54 @@ import type { DimensionMetadata } from "metabase-lib/metric";import type { MetricSourceId } from "../../types/viewer-state";-export interface DimensionItem {- id: MetricSourceId;+import { ExpressionDimensionPill } from "./ExpressionDimensionPill";++// ── Standalone metric pill item ──++export interface MetricDimensionItem {+ type: "metric";+ id: number;label?: string;icon?: IconName;colors?: string[];availableOptions: DimensionOption[];}+// ── Expression pill item (one pill per expression entity) ──++export interface ExpressionMetricSource {+ /** Slot index in dimensionMapping — used as the callback key. */+ slotIndex: number;+ sourceId: MetricSourceId;+ metricName: string;+ metricCount?: number;+ colors?: string[];+ currentDimensionLabel?: string;+ currentDimensionIcon?: IconName;+ availableOptions: DimensionOption[];+}++export interface ExpressionDimensionItem {+ type: "expression";+ /** Expression entity index — used as the React key. */+ id: number;+ colors?: string[];+ icon?: IconName;+ /** Aggregate label derived from selected dimensions. */+ label?: string;+ metricSources: ExpressionMetricSource[];+}++export type DimensionPillBarItem =+ | MetricDimensionItem+ | ExpressionDimensionItem;++// ── Component ──+export interface DimensionPillBarProps {- items: DimensionItem[];- onDimensionChange: (- itemId: MetricSourceId,- dimension: DimensionMetadata,- ) => void;- onDimensionRemove?: (itemId: MetricSourceId) => void;+ items: DimensionPillBarItem[];+ onDimensionChange: (slotIndex: number, dimension: DimensionMetadata) => void;+ onDimensionRemove?: (slotIndex: number) => void;disabled?: boolean;}@@ -46,20 +79,29 @@ export function DimensionPillBar({wrap="wrap"data-testid="metrics-viewer-dimension-pill-container">- {items.map((item) => (- <DimensionPill- key={item.id}- label={item.label}- icon={item.icon}- colors={item.colors}- options={item.availableOptions}- onSelect={(dimension) => onDimensionChange(item.id, dimension)}- onRemove={- onDimensionRemove ? () => onDimensionRemove(item.id) : undefined- }- disabled={disabled}- />- ))}+ {items.map((item) =>+ item.type === "expression" ? (+ <ExpressionDimensionPill+ key={`expr-${item.id}`}+ item={item}+ onDimensionChange={onDimensionChange}+ disabled={disabled}+ />+ ) : (+ <DimensionPill+ key={item.id}+ label={item.label}+ icon={item.icon}+ colors={item.colors}+ options={item.availableOptions}+ onSelect={(dimension) => onDimensionChange(item.id, dimension)}+ onRemove={+ onDimensionRemove ? () => onDimensionRemove(item.id) : undefined+ }+ disabled={disabled}+ />+ ),+ )}</Flex>);}diff --git a/frontend/src/metabase/metrics-viewer/components/DimensionPillBar/ExpressionDimensionPill.module.css b/frontend/src/metabase/metrics-viewer/components/DimensionPillBar/ExpressionDimensionPill.module.cssnew file mode 100644index 00000000000..2441366f3df--- /dev/null+++ b/frontend/src/metabase/metrics-viewer/components/DimensionPillBar/ExpressionDimensionPill.module.css@@ -0,0 +1,25 @@+.dropdown {+ display: flex;+ flex-direction: column;+ overflow-y: auto;+}++.dimensionList {+ max-width: 100%;+ color: var(--mb-color-brand);+}++.accordionItem {+ &:not(:last-child) {+ border-bottom: 1px solid var(--mb-color-border);+ }+}++.accordionControl {+ padding-block: 0.875rem;+ cursor: pointer;+}++.accordionControlExpanded {+ padding-bottom: 0.375rem;+}diff --git a/frontend/src/metabase/metrics-viewer/components/DimensionPillBar/ExpressionDimensionPill.tsx b/frontend/src/metabase/metrics-viewer/components/DimensionPillBar/ExpressionDimensionPill.tsxnew file mode 100644index 00000000000..21a843dcd1c--- /dev/null+++ b/frontend/src/metabase/metrics-viewer/components/DimensionPillBar/ExpressionDimensionPill.tsx@@ -0,0 +1,293 @@+import cx from "classnames";+import { useCallback, useMemo, useState } from "react";+import { t } from "ttag";++import {+ AccordionList,+ type Section,+} from "metabase/common/components/AccordionList";+import type { DimensionOption } from "metabase/common/components/DimensionPill";+import DPS from "metabase/common/components/DimensionPill/DimensionPill.module.css";+import { groupIntoSections } from "metabase/common/components/DimensionPill/utils";+import { SourceColorIndicator } from "metabase/common/components/SourceColorIndicator";+import {+ Badge,+ Box,+ Flex,+ Icon,+ Popover,+ Text,+ UnstyledButton,+} from "metabase/ui";+import type { DimensionMetadata } from "metabase-lib/metric";++import type {+ ExpressionDimensionItem,+ ExpressionMetricSource,+} from "./DimensionPillBar";+import S from "./ExpressionDimensionPill.module.css";++const LIST_WIDTH = "20rem";++interface ExpressionDimensionPillProps {+ item: ExpressionDimensionItem;+ onDimensionChange: (slotIndex: number, dimension: DimensionMetadata) => void;+ disabled?: boolean;+}++function renderItemName(item: DimensionOption) {+ return item.displayName;+}++function renderItemIcon(item: DimensionOption) {+ return <Icon name={item.icon} />;+}++function itemIsSelected(item: DimensionOption) {+ return item.selected ?? false;+}++/**+ * A dimension pill for expression entities. Renders a single pill that, when+ * clicked, opens a popover with per-metric accordion sections so the user can+ * independently pick dimensions for each metric token in the expression.+ *+ * When the expression contains only one metric, the popover shows a flat+ * dimension list (same as a regular DimensionPill).+ */+export function ExpressionDimensionPill({+ item,+ onDimensionChange,+ disabled,+}: ExpressionDimensionPillProps) {+ const [isOpen, setIsOpen] = useState(false);+ const [expandedSlots, setExpandedSlots] = useState<number[]>(() =>+ item.metricSources.length > 0 ? [item.metricSources[0].slotIndex] : [],+ );++ const hasOptions = item.metricSources.some(+ (s) => s.availableOptions.length > 0,+ );+ const isSingleMetric = item.metricSources.length === 1;+ const isPlaceholder = !item.label;+ const isEmpty = isPlaceholder && !hasOptions;+ const canOpenPopover = hasOptions && !disabled;++ const handleToggleExpanded = useCallback((slotIndex: number) => {+ setExpandedSlots((prev) =>+ prev.includes(slotIndex)+ ? prev.filter((s) => s !== slotIndex)+ : [...prev, slotIndex],+ );+ }, []);++ let pillLabel: string;+ if (isEmpty) {+ pillLabel = t`No compatible dimensions`;+ } else if (isPlaceholder) {+ pillLabel = t`Select dimensions`;+ } else {+ pillLabel = item.label ?? "";+ }++ return (+ <Popover+ opened={isOpen}+ onChange={setIsOpen}+ position="top-start"+ disabled={!canOpenPopover}+ >+ <Popover.Target>+ <Flex+ className={cx(DPS.pill, canOpenPopover && DPS.interactive)}+ align="center"+ gap="xs"+ opacity={disabled || isEmpty ? 0.6 : undefined}+ onClick={canOpenPopover ? () => setIsOpen(true) : undefined}+ data-testid="expression-dimension-pill"+ >+ <SourceColorIndicator colors={item.colors} fallbackIcon={item.icon} />+ <Text size="sm" lh={1} c={isEmpty ? "text-tertiary" : undefined}>+ {pillLabel}+ </Text>+ </Flex>+ </Popover.Target>+ <Popover.Dropdown+ px={0}+ py="xs"+ w={LIST_WIDTH}+ mah={300}+ className={S.dropdown}+ >+ {isSingleMetric ? (+ <SingleMetricContent+ source={item.metricSources[0]}+ onDimensionChange={onDimensionChange}+ onClose={() => setIsOpen(false)}+ />+ ) : (+ <MultiMetricContent+ sources={item.metricSources}+ expandedSlots={expandedSlots}+ onToggleExpanded={handleToggleExpanded}+ onDimensionChange={onDimensionChange}+ onClose={() => setIsOpen(false)}+ />+ )}+ </Popover.Dropdown>+ </Popover>+ );+}++// ── Single metric: flat dimension list ──++interface SingleMetricContentProps {+ source: ExpressionMetricSource;+ onDimensionChange: (slotIndex: number, dimension: DimensionMetadata) => void;+ onClose: () => void;+}++function SingleMetricContent({+ source,+ onDimensionChange,+ onClose,+}: SingleMetricContentProps) {+ const sections = useMemo(+ () => groupIntoSections(source.availableOptions),+ [source.availableOptions],+ );++ const handleSelect = useCallback(+ (option: DimensionOption) => {+ onDimensionChange(source.slotIndex, option.dimension);+ onClose();+ },+ [onDimensionChange, source.slotIndex, onClose],+ );++ return (+ <AccordionList+ className={S.dimensionList}+ sections={sections}+ onChange={handleSelect}+ renderItemName={renderItemName}+ renderItemIcon={renderItemIcon}+ itemIsSelected={itemIsSelected}+ alwaysExpanded+ maxHeight={Infinity}+ width={240}+ />+ );+}++// ── Multiple metrics: accordion sections ──++interface MultiMetricContentProps {+ sources: ExpressionMetricSource[];+ expandedSlots: number[];+ onToggleExpanded: (slotIndex: number) => void;+ onDimensionChange: (slotIndex: number, dimension: DimensionMetadata) => void;+ onClose: () => void;+}++function MultiMetricContent({+ sources,+ expandedSlots,+ onToggleExpanded,+ onDimensionChange,+ onClose,+}: MultiMetricContentProps) {+ return (+ <Box>+ {sources.map((source) => {+ const isExpanded = expandedSlots.includes(source.slotIndex);+ const hasDimensions = source.availableOptions.length > 0;+ const showDimensions = isExpanded && hasDimensions;++ return (+ <MetricAccordionItem+ key={source.slotIndex}+ source={source}+ isExpanded={isExpanded}+ showDimensions={showDimensions}+ onToggle={() => onToggleExpanded(source.slotIndex)}+ onDimensionChange={onDimensionChange}+ onClose={onClose}+ />+ );+ })}+ </Box>+ );+}++interface MetricAccordionItemProps {+ source: ExpressionMetricSource;+ isExpanded: boolean;+ showDimensions: boolean;+ onToggle: () => void;+ onDimensionChange: (slotIndex: number, dimension: DimensionMetadata) => void;+ onClose: () => void;+}++function MetricAccordionItem({+ source,+ isExpanded,+ showDimensions,+ onToggle,+ onDimensionChange,+ onClose,+}: MetricAccordionItemProps) {+ const sections: Section<DimensionOption>[] = useMemo(+ () => groupIntoSections(source.availableOptions),+ [source.availableOptions],+ );++ const handleSelect = useCallback(+ (option: DimensionOption) => {+ onDimensionChange(source.slotIndex, option.dimension);+ onClose();+ },+ [onDimensionChange, source.slotIndex, onClose],+ );++ return (+ <Box className={S.accordionItem} data-testid="expression-metric-section">+ <UnstyledButton+ className={cx(S.accordionControl, {+ [S.accordionControlExpanded]: showDimensions,+ })}+ onClick={onToggle}+ w="100%"+ data-testid="expression-metric-header"+ >+ <Flex align="center" gap="sm" px="md">+ <SourceColorIndicator colors={source.colors} size={16} />+ <Flex align="center" gap="xs" fw={700} style={{ flex: 1 }}>+ <span>{source.metricName}</span>+ {(source.metricCount ?? 0) > 1 && (+ <Badge circle c="text-hover">+ {source.metricCount}+ </Badge>+ )}+ </Flex>+ <Icon name={isExpanded ? "chevronup" : "chevrondown"} size={12} />+ </Flex>+ </UnstyledButton>+ {showDimensions && (+ <Box pb="sm">+ <AccordionList+ className={S.dimensionList}+ sections={sections}+ onChange={handleSelect}+ renderItemName={renderItemName}+ renderItemIcon={renderItemIcon}+ itemIsSelected={itemIsSelected}+ alwaysExpanded+ maxHeight={Infinity}+ width="100%"+ />+ </Box>+ )}+ </Box>+ );+}diff --git a/frontend/src/metabase/metrics-viewer/components/DimensionPillBar/index.ts b/frontend/src/metabase/metrics-viewer/components/DimensionPillBar/index.tsindex 24827e77ccf..df64899b439 100644--- a/frontend/src/metabase/metrics-viewer/components/DimensionPillBar/index.ts+++ b/frontend/src/metabase/metrics-viewer/components/DimensionPillBar/index.ts@@ -1,2 +1,8 @@export { DimensionPillBar } from "./DimensionPillBar";-export type { DimensionPillBarProps, DimensionItem } from "./DimensionPillBar";+export type {+ DimensionPillBarProps,+ MetricDimensionItem,+ DimensionPillBarItem,+ ExpressionDimensionItem,+ ExpressionMetricSource,+} from "./DimensionPillBar";diff --git a/frontend/src/metabase/metrics-viewer/components/FilterPopover/FilterPopover.tsx b/frontend/src/metabase/metrics-viewer/components/FilterPopover/FilterPopover.tsxindex 1ca37517c3a..2f7ff08a309 100644--- a/frontend/src/metabase/metrics-viewer/components/FilterPopover/FilterPopover.tsx+++ b/frontend/src/metabase/metrics-viewer/components/FilterPopover/FilterPopover.tsx@@ -1,53 +1,41 @@import { useCallback, useState } from "react";import { Box, Popover } from "metabase/ui";-import type { FilterClause, MetricDefinition } from "metabase-lib/metric";-import * as LibMetric from "metabase-lib/metric";+import type { MetricDefinition } from "metabase-lib/metric";import { trackMetricsViewerFilterAdded } from "../../analytics";-import type { MetricSourceId, SourceColorMap } from "../../types/viewer-state";+import type { SourceColorMap } from "../../types/viewer-state";+import type { DefinitionSource } from "../../utils/definition-sources";import S from "./FilterPopover.module.css";-import type { DefinitionSource } from "./FilterPopoverContent";import { FilterPopoverContent } from "./FilterPopoverContent";const POPOVER_MAX_HEIGHT = "37.5rem";interface FilterPopoverProps {- definitions: DefinitionSource[];+ definitionSources: DefinitionSource[];metricColors: SourceColorMap;- onUpdateDefinition: (- id: MetricSourceId,- definition: MetricDefinition,+ onSourceDefinitionChange: (+ source: DefinitionSource,+ newDefinition: MetricDefinition,) => void;children: React.ReactNode;}export function FilterPopover({- definitions,+ definitionSources,metricColors,- onUpdateDefinition,+ onSourceDefinitionChange,children,}: FilterPopoverProps) {const [isOpen, setIsOpen] = useState(false);const [contentKey, setContentKey] = useState(0);- const handleFilterApplied = useCallback(- (sourceId: MetricSourceId, filter: FilterClause) => {- const source = definitions.find(- (definition) => definition.id === sourceId,- );- if (!source) {- return;- }- const newDefinition = LibMetric.filter(source.definition, filter);- onUpdateDefinition(sourceId, newDefinition);- trackMetricsViewerFilterAdded("metric_filter");- setIsOpen(false);- setContentKey((key) => key + 1);- },- [definitions, onUpdateDefinition],- );+ const handleFilterApplied = useCallback(() => {+ setIsOpen(false);+ setContentKey((key) => key + 1);+ trackMetricsViewerFilterAdded("metric_filter");+ }, []);const handleToggle = useCallback(() => {setIsOpen((prev) => !prev);@@ -61,11 +49,12 @@ export function FilterPopover({</Box></Popover.Target><Popover.Dropdown p={0} mah={POPOVER_MAX_HEIGHT} className={S.dropdown}>- {definitions.length > 0 && (+ {definitionSources.length > 0 && (<FilterPopoverContentkey={contentKey}- definitions={definitions}+ definitionSources={definitionSources}metricColors={metricColors}+ onSourceDefinitionChange={onSourceDefinitionChange}onFilterApplied={handleFilterApplied}/>)}diff --git a/frontend/src/metabase/metrics-viewer/components/FilterPopover/FilterPopoverContent.tsx b/frontend/src/metabase/metrics-viewer/components/FilterPopover/FilterPopoverContent.tsxindex a47389d8699..865df51f85f 100644--- a/frontend/src/metabase/metrics-viewer/components/FilterPopover/FilterPopoverContent.tsx+++ b/frontend/src/metabase/metrics-viewer/components/FilterPopover/FilterPopoverContent.tsx@@ -7,19 +7,29 @@ import { SourceColorIndicator } from "metabase/common/components/SourceColorIndiimport type {DimensionListItem,DimensionSection,+ MetricGroup,} from "metabase/metrics/components/FilterPicker/FilterDimensionPicker/types";import { getMetricGroups } from "metabase/metrics/components/FilterPicker/FilterDimensionPicker/utils";import { FilterPickerBody } from "metabase/metrics/components/FilterPicker/FilterPickerBody";import { getDimensionIcon } from "metabase/metrics/utils/dimensions";-import type { IconName } from "metabase/ui";-import { Box, Flex, Icon, Text, TextInput, UnstyledButton } from "metabase/ui";+import {+ Badge,+ Box,+ Flex,+ Icon,+ Text,+ TextInput,+ UnstyledButton,+} from "metabase/ui";import type {DimensionMetadata,FilterClause,MetricDefinition,} from "metabase-lib/metric";+import * as LibMetric from "metabase-lib/metric";-import type { MetricSourceId, SourceColorMap } from "../../types/viewer-state";+import type { SourceColorMap } from "../../types/viewer-state";+import type { DefinitionSource } from "../../utils/definition-sources";import S from "./FilterPopover.module.css";import { filterDisplayGroupsBySearch } from "./utils";@@ -27,53 +37,33 @@ import { filterDisplayGroupsBySearch } from "./utils";const LIST_WIDTH = "20rem";const FILTER_WIDTH = "24rem";-export type DefinitionSource = {- id: MetricSourceId;- definition: MetricDefinition;-};-type NavigationState =| { view: "list" }| { view: "filter"; definitionIndex: number; dimension: DimensionMetadata };-type DisplayMetricGroup = {- id: MetricSourceId;- metricName: string;- icon: IconName;- colors: string[] | undefined;- sections: DimensionSection[];-};-interface FilterPopoverContentProps {- definitions: DefinitionSource[];+ definitionSources: DefinitionSource[];metricColors: SourceColorMap;- onFilterApplied: (id: MetricSourceId, filter: FilterClause) => void;+ onSourceDefinitionChange: (+ source: DefinitionSource,+ newDefinition: MetricDefinition,+ ) => void;+ onFilterApplied: () => void;}export function FilterPopoverContent({- definitions,+ definitionSources,metricColors,+ onSourceDefinitionChange,onFilterApplied,}: FilterPopoverContentProps) {const [navState, setNavState] = useState<NavigationState>({ view: "list" });- const [expandedItems, setExpandedItems] = useState<string[]>([]);+ const [expandedItems, setExpandedItems] = useState<number[]>([]);const [searchText, setSearchText] = useState("");- const displayGroups = useMemo((): DisplayMetricGroup[] => {- const rawGroups = getMetricGroups(- definitions.map((definition) => definition.definition),- );- return rawGroups.map((group, index) => {- const sourceId = definitions[index].id;- return {- id: sourceId,- metricName: group.metricName,- icon: group.icon,- colors: metricColors[sourceId],- sections: group.sections,- };- });- }, [definitions, metricColors]);+ const displayGroups = useMemo((): MetricGroup[] => {+ return getMetricGroups(definitionSources, metricColors);+ }, [definitionSources, metricColors]);const filteredDisplayGroups = useMemo(() => filterDisplayGroupsBySearch(displayGroups, searchText),@@ -97,17 +87,16 @@ export function FilterPopoverContent({if (navState.view !== "filter") {return;}- const selected = definitions[navState.definitionIndex];- if (!selected) {- return;- }- onFilterApplied(selected.id, filter);+ const selected = definitionSources[navState.definitionIndex];+ const newDefinition = LibMetric.filter(selected.definition, filter);+ onSourceDefinitionChange(selected, newDefinition);+ onFilterApplied();setNavState({ view: "list" });},- [navState, definitions, onFilterApplied],+ [navState, definitionSources, onFilterApplied, onSourceDefinitionChange],);- const toggleExpanded = useCallback((id: string) => {+ const toggleExpanded = useCallback((id: number) => {setExpandedItems((prev) =>prev.includes(id) ? prev.filter((item) => item !== id) : [...prev, id],);@@ -116,10 +105,10 @@ export function FilterPopoverContent({const isSearching = filteredDisplayGroups !== null;const visibleGroups = isSearching ? filteredDisplayGroups : displayGroups;const hasNoResults = isSearching && visibleGroups.length === 0;- const showMetricHeaders = definitions.length > 1;+ const showMetricHeaders = definitionSources.length > 1;if (navState.view === "filter") {- const selected = definitions[navState.definitionIndex];+ const selected = definitionSources[navState.definitionIndex];if (!selected) {return null;}@@ -209,10 +198,10 @@ function MetricGroupList({onToggleExpanded,onDimensionSelect,}: {- groups: DisplayMetricGroup[];- expandedItems: string[];+ groups: MetricGroup[];+ expandedItems: number[];collapsible: boolean;- onToggleExpanded: (id: string) => void;+ onToggleExpanded: (id: number) => void;onDimensionSelect: (item: DimensionListItem) => void;}) {return (@@ -240,7 +229,14 @@ function MetricGroupList({fallbackIcon={group.icon}size={16}/>- <Box fw={700}>{group.metricName}</Box>+ <Flex align="center" gap="xs" fw={700}>+ <span>{group.metricName}</span>+ {(group.metricCount ?? 0) > 1 && (+ <Badge circle c="text-hover">+ {group.metricCount}+ </Badge>+ )}+ </Flex><Iconname={isExpanded ? "chevronup" : "chevrondown"}size={12}diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricExpressionPill/MetricExpressionPill.module.css b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricExpressionPill/MetricExpressionPill.module.cssnew file mode 100644index 00000000000..9ab785abec9--- /dev/null+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricExpressionPill/MetricExpressionPill.module.css@@ -0,0 +1,15 @@+.metricExpressionPill {+ background-color: var(--mb-color-background-primary);+ border: 1px solid var(--mb-color-border);+ border-radius: var(--default-border-radius);+ transition: background-color 150ms ease;+ max-width: 100%;+}++.metricExpressionPill:hover {+ background-color: var(--mb-color-background-secondary);+}++.expressionText {+ white-space: pre-wrap;+}diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricExpressionPill/MetricExpressionPill.tsx b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricExpressionPill/MetricExpressionPill.tsxnew file mode 100644index 00000000000..7840fc1c5a9--- /dev/null+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricExpressionPill/MetricExpressionPill.tsx@@ -0,0 +1,73 @@+import { t } from "ttag";++import { SourceColorIndicator } from "metabase/common/components/SourceColorIndicator";+import { Badge, Flex, Pill } from "metabase/ui";++import type { ExpressionDefinitionEntry } from "../../../types/viewer-state";+import { type MetricNameMap, buildExpressionForPill } from "../utils";++import S from "./MetricExpressionPill.module.css";++type MetricExpressionPillProps = {+ expressionEntry: ExpressionDefinitionEntry;+ metricNames: MetricNameMap;+ colors?: string[];+ onClick: (e: React.MouseEvent) => void;+ onRemove: () => void;+};++export function MetricExpressionPill({+ expressionEntry,+ metricNames,+ colors,+ onClick,+ onRemove,+}: MetricExpressionPillProps) {+ const expression = buildExpressionForPill(+ expressionEntry.tokens,+ metricNames,+ );+ return (+ <Pill+ className={S.metricExpressionPill}+ c="text-primary"+ h="2rem"+ px="sm"+ py="xs"+ fw={600}+ withRemoveButton+ onRemove={onRemove}+ removeButtonProps={{+ mr: 0,+ "aria-label": t`Remove expression`,+ }}+ onClick={onClick}+ data-testid="metrics-viewer-search-pill"+ >+ <Flex align="center" gap="xs">+ <SourceColorIndicator colors={colors} />+ <Flex align="center" gap={0}>+ {expression.map((e, i) => {+ if (typeof e === "number") {+ return (+ <Badge+ key={i}+ circle+ c="text-hover"+ style={{ marginInlineStart: "0.2em" }}+ >+ {e}+ </Badge>+ );+ }+ return (+ <span key={i} className={S.expressionText}>+ {e}+ </span>+ );+ })}+ </Flex>+ </Flex>+ </Pill>+ );+}diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricExpressionPill/index.ts b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricExpressionPill/index.tsnew file mode 100644index 00000000000..ee57573a2fa--- /dev/null+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricExpressionPill/index.ts@@ -0,0 +1 @@+export { MetricExpressionPill } from "./MetricExpressionPill";diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricPill/MetricPill.module.css b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricPill/MetricPill.module.cssindex 1aa8fe63eb3..5a63e1aae35 100644--- a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricPill/MetricPill.module.css+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricPill/MetricPill.module.css@@ -1,13 +1,13 @@.metricPill {background-color: var(--mb-color-background-primary);- border-radius: var(--mantine-radius-md);+ border: 1px solid var(--mb-color-border);+ border-radius: var(--default-border-radius);cursor: pointer;transition: background-color 150ms ease;- box-shadow: var(--mantine-shadow-xs);}.metricPill:hover {- background-color: var(--mb-color-background-brand);+ background-color: var(--mb-color-background-secondary);}.menuTarget {diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricPill/MetricPill.tsx b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricPill/MetricPill.tsxindex 9b6d2675517..f49b5727b31 100644--- a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricPill/MetricPill.tsx+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricPill/MetricPill.tsx@@ -25,8 +25,6 @@ type MetricPillProps = {metric: SelectedMetric;colors?: string[];definitionEntry: MetricsViewerDefinitionEntry;- selectedMetricIds: Set<number>;- selectedMeasureIds: Set<number>;onSwap: (oldMetric: SelectedMetric, newMetric: SelectedMetric) => void;onRemove: (metricId: number, sourceType: "metric" | "measure") => void;onSetBreakout: (dimension: ProjectionClause | undefined) => void;@@ -37,8 +35,6 @@ export function MetricPill({metric,colors,definitionEntry,- selectedMetricIds,- selectedMeasureIds,onSwap,onRemove,onSetBreakout,@@ -46,6 +42,26 @@ export function MetricPill({}: MetricPillProps) {const [popoverState, setPopoverState] = useState<PillPopoverState>("closed");+ const { selectedMetricIds, selectedMeasureIds } = useMemo(() => {+ if (metric.sourceType === "metric") {+ return {+ selectedMetricIds: new Set<number>([metric.id]),+ selectedMeasureIds: new Set<number>(),+ };+ }+ if (metric.sourceType === "measure") {+ return {+ selectedMetricIds: new Set<number>(),+ selectedMeasureIds: new Set<number>([metric.id]),+ };+ }++ return {+ selectedMetricIds: new Set<number>(),+ selectedMeasureIds: new Set<number>(),+ };+ }, [metric.id, metric.sourceType]);+const dimensions = useMemo(() =>definitionEntry.definitiondiff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricPill/MetricPill.unit.spec.tsx b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricPill/MetricPill.unit.spec.tsxindex b174dfef11c..755aa2071f1 100644--- a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricPill/MetricPill.unit.spec.tsx+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricPill/MetricPill.unit.spec.tsx@@ -25,8 +25,6 @@ function setup({<MetricPillmetric={metric}definitionEntry={definitionEntry ?? { id: "measure:1", definition: null }}- selectedMetricIds={new Set()}- selectedMeasureIds={new Set()}onSwap={jest.fn()}onRemove={jest.fn()}onSetBreakout={jest.fn()}diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchDropdown/MetricSearchDropdown.tsx b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchDropdown/MetricSearchDropdown.tsxindex d78dbc070e7..0f0257a8c56 100644--- a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchDropdown/MetricSearchDropdown.tsx+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchDropdown/MetricSearchDropdown.tsx@@ -1,4 +1,4 @@-import { useCallback, useMemo, useState } from "react";+import { useCallback, useEffect, useMemo, useState } from "react";import { t } from "ttag";import { useListKeyboardNavigation } from "metabase/common/hooks/use-list-keyboard-navigation";@@ -15,13 +15,14 @@ import { type ExcludeMetric, filterSearchResults } from "../utils";import S from "./MetricSearchDropdown.module.css";type MetricSearchDropdownProps = {- selectedMetricIds: Set<number>;- selectedMeasureIds: Set<number>;+ selectedMetricIds?: Set<number>;+ selectedMeasureIds?: Set<number>;onSelect: (metric: SelectedMetric) => void;onClose?: () => void;excludeMetric?: ExcludeMetric;showSearchInput?: boolean;externalSearchText?: string;+ onHasSelectionChange?: (hasSelection: boolean) => void;};export function MetricSearchDropdown({@@ -32,6 +33,7 @@ export function MetricSearchDropdown({excludeMetric,showSearchInput = false,externalSearchText,+ onHasSelectionChange,}: MetricSearchDropdownProps) {const [internalSearchText, setInternalSearchText] = useState("");const searchText = showSearchInput@@ -84,6 +86,10 @@ export function MetricSearchDropdown({onEnter: handleEnter,});+ useEffect(() => {+ onHasSelectionChange?.(cursorIndex != null);+ }, [cursorIndex, onHasSelectionChange]);+const handleKeyDown = useCallback((e: React.KeyboardEvent) => {if (e.key === "Escape") {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 1eb7e2b58d8..fac66b697ff 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@@ -8,8 +8,76 @@padding: 0;height: auto;min-height: unset;+ font-family: Monaco, monospace;}.inputField::placeholder {color: var(--mb-color-text-tertiary);}++.cmOperator {+ color: var(--mb-color-syntax-parameters);+}++.cmMetricToken {+ border: 1px solid var(--mb-color-border);+ border-radius: 0.25rem;+ padding: 0 0.25rem;+}++.cmErrorUnderline {+ text-decoration: underline wavy;+ text-decoration-color: var(--mb-color-error);+ text-decoration-skip-ink: none;+}++.cmErrorTooltip {+ padding: 4px 8px;+ font-size: 0.75rem;+ color: var(--mb-color-error);+ background: var(--mb-color-background-primary);+ border: 1px solid var(--mb-color-error);+ border-radius: var(--mantine-radius-sm, 4px);+ max-width: 20rem;+ white-space: normal;+ pointer-events: none;+}++.codeEditor {+ flex: 1;+ min-width: 7.5rem;++ :global {+ .cm-editor {+ background: transparent;+ }++ .cm-focused {+ outline: none;+ }++ .cm-content {+ padding: 0;+ font-family: var(--mb-default-monospace-font-family);+ font-size: 0.875rem;+ color: var(--mb-color-text-primary);+ }++ .cm-line {+ padding: 0;+ }++ .cm-cursor {+ border-left-width: 1.6px;+ border-left-color: var(--mb-color-text-secondary);+ }++ .cm-placeholder {+ color: var(--mb-color-text-tertiary);+ }++ .cm-scroller {+ overflow: hidden;+ }+ }+}diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/MetricSearchInput.tsx b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/MetricSearchInput.tsxindex 641873ea236..adc6988db02 100644--- a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/MetricSearchInput.tsx+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/MetricSearchInput.tsx@@ -1,172 +1,275 @@-import { useCallback, useMemo, useRef, useState } from "react";+import type { ReactCodeMirrorRef } from "@uiw/react-codemirror";+import { useMemo, useRef } from "react";import { t } from "ttag";-import { Flex, Popover, TextInput } from "metabase/ui";+import { CodeMirror } from "metabase/common/components/CodeMirror";+import { Button, Flex, Icon, Popover } from "metabase/ui";import type { ProjectionClause } from "metabase-lib/metric";import type {+ MetricDefinitionEntry,MetricSourceId,MetricsViewerDefinitionEntry,+ MetricsViewerFormulaEntity,SelectedMetric,SourceColorMap,} from "../../../types/viewer-state";+import { isExpressionEntry, isMetricEntry } from "../../../types/viewer-state";+import { getEffectiveDefinitionEntry } from "../../../utils/definition-entries";import {createMeasureSourceId,createMetricSourceId,} from "../../../utils/source-ids";+import { MetricExpressionPill } from "../MetricExpressionPill";import { MetricPill } from "../MetricPill";import { MetricSearchDropdown } from "../MetricSearchDropdown";-import { getSelectedMeasureIds, getSelectedMetricIds } from "../utils";import S from "./MetricSearchInput.module.css";+import { buildEditorExtensions } from "./editorExtensions";+import { useFormulaEditor } from "./useFormulaEditor";+import { useMetricNameTracking } from "./useMetricNameTracking";type MetricSearchInputProps = {+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>;+ formulaEntities: MetricsViewerFormulaEntity[];+ onFormulaEntitiesChange: (+ entities: MetricsViewerFormulaEntity[],+ slotMapping?: Map<number, number>,+ ) => void;selectedMetrics: SelectedMetric[];metricColors: SourceColorMap;- definitions: MetricsViewerDefinitionEntry[];onAddMetric: (metric: SelectedMetric) => void;onRemoveMetric: (metricId: number, sourceType: "metric" | "measure") => void;onSwapMetric: (oldMetric: SelectedMetric, newMetric: SelectedMetric) => void;onSetBreakout: (- id: MetricSourceId,+ entity: MetricDefinitionEntry,dimension: ProjectionClause | undefined,) => void;};export function MetricSearchInput({+ definitions,+ formulaEntities,+ onFormulaEntitiesChange,selectedMetrics,metricColors,- definitions,onAddMetric,onRemoveMetric,onSwapMetric,onSetBreakout,}: MetricSearchInputProps) {- const [searchText, setSearchText] = useState("");- const [isOpen, setIsOpen] = useState(false);- const inputRef = useRef<HTMLInputElement>(null);-- const selectedMetricIds = useMemo(- () => getSelectedMetricIds(selectedMetrics),- [selectedMetrics],- );-- const selectedMeasureIds = useMemo(- () => getSelectedMeasureIds(selectedMetrics),- [selectedMetrics],- );+ const containerRef = useRef<HTMLDivElement>(null);+ const editorRef = useRef<ReactCodeMirrorRef>(null);- const definitionsBySourceId = useMemo(- () => new Map(definitions.map((entry) => [entry.id, entry] as const)),- [definitions],- );+ const { metricNames, metricNamesRef, ...metricHandlers } =+ useMetricNameTracking({+ definitions,+ onAddMetric,+ onRemoveMetric,+ onSwapMetric,+ });- const handleSelect = useCallback(- (metric: SelectedMetric) => {- onAddMetric(metric);- setSearchText("");- setIsOpen(false);- },- [onAddMetric],- );+ const {+ editText,+ isFocused,+ isOpen,+ setIsOpen,+ currentWord,+ validationError,+ anchorRect,+ isExpressionDirty,+ pendingFocusRef,+ handleInputFocus,+ handleInputBlur,+ handleChange,+ handleSelect,+ handleRemoveItem,+ handleContainerClick,+ handleEditorClick,+ handleEditorKeyDown,+ handleDropdownHasSelectionChange,+ handleRun,+ handleRunRef,+ isOpenRef,+ dropdownHasSelectionRef,+ } = useFormulaEditor({+ formulaEntities,+ onFormulaEntitiesChange,+ selectedMetrics,+ definitions,+ metricNames,+ metricNamesRef,+ handleAddMetric: metricHandlers.handleAddMetric,+ handleRemoveMetric: metricHandlers.handleRemoveMetric,+ editorRef,+ containerRef,+ });- const handleKeyDown = useCallback(- (event: React.KeyboardEvent) => {- if (- event.key === "Backspace" &&- searchText === "" &&- selectedMetrics.length > 0- ) {- const last = selectedMetrics[selectedMetrics.length - 1];- onRemoveMetric(last.id, last.sourceType);- }- },- [searchText, selectedMetrics, onRemoveMetric],+ const editorExtensions = useMemo(+ () =>+ buildEditorExtensions(formulaEntities.length, {+ dropdownHasSelectionRef,+ handleRunRef,+ isOpenRef,+ }),+ [formulaEntities.length, dropdownHasSelectionRef, handleRunRef, isOpenRef],);- const handleContainerClick = useCallback(() => {- inputRef.current?.focus();- }, []);-- const handleInputClick = useCallback(() => {- setIsOpen(true);- }, []);+ const isCollapsed = !isFocused && formulaEntities.length > 0;return (<Flex+ ref={containerRef}className={S.inputWrapper}- bg="background-secondary"+ bg="background-primary"align="center"gap="sm"px="sm"py="xs"onClick={handleContainerClick}+ data-has-error={validationError ? true : undefined}+ data-testid="metrics-formula-input">- <Flex align="center" gap="sm" flex={1} wrap="wrap" mih="2.25rem">- {selectedMetrics.map((metric) => {- const sid =- metric.sourceType === "metric"- ? createMetricSourceId(metric.id)- : createMeasureSourceId(metric.id);- const entry = definitionsBySourceId.get(sid);- if (!entry) {- return null;- }- return (- <MetricPill- key={`${metric.sourceType}-${metric.id}`}- metric={metric}- colors={metricColors[sid]}- definitionEntry={entry}- selectedMetricIds={selectedMetricIds}- selectedMeasureIds={selectedMeasureIds}- onSwap={onSwapMetric}- onRemove={onRemoveMetric}- onSetBreakout={(dimension) => onSetBreakout(sid, dimension)}- onOpen={() => setIsOpen(false)}- />- );- })}- <Popover- opened={isOpen}- onChange={setIsOpen}- position="bottom-start"- shadow="md"- withinPortal- >- <Popover.Target>- <TextInput- ref={inputRef}- classNames={{ input: S.inputField }}- flex={1}- miw="7.5rem"- ml="xs"- variant="unstyled"- placeholder={- selectedMetrics.length === 0 ? t`Search for metrics...` : ""+ <Flex align="center" gap="sm" flex={1} wrap="wrap" mih="2.375rem">+ {isCollapsed ? (+ // Unfocused: each formula entity rendered as MetricPill or MetricExpressionPill+ <>+ {formulaEntities.map((entry, entryIndex) => {+ if (isMetricEntry(entry)) {+ const metric = selectedMetrics.find((m) => {+ const sid =+ m.sourceType === "metric"+ ? createMetricSourceId(m.id)+ : createMeasureSourceId(m.id);+ return sid === entry.id;+ });+ if (!metric) {+ return null;+ }+ const definition = getEffectiveDefinitionEntry(+ entry,+ definitions,+ );+ return (+ <span key={`${entry.id}-${entryIndex}`}>+ <MetricPill+ metric={metric}+ colors={metricColors[entryIndex]}+ definitionEntry={definition}+ onSwap={metricHandlers.handleSwapMetric}+ onRemove={(_id, _sourceType) =>+ handleRemoveItem(entryIndex)+ }+ onSetBreakout={(dimension) =>+ onSetBreakout(entry, dimension)+ }+ />+ </span>+ );}- value={searchText}- onChange={(event) => {- setSearchText(event.target.value);- setIsOpen(true);- }}- onClick={handleInputClick}- onKeyDown={handleKeyDown}- data-testid="metrics-viewer-search-input"- />- </Popover.Target>- <Popover.Dropdown p={0} miw="19rem" maw="25rem">- {isOpen && (- <MetricSearchDropdown- selectedMetricIds={selectedMetricIds}- selectedMeasureIds={selectedMeasureIds}- onSelect={handleSelect}- externalSearchText={searchText}++ if (isExpressionEntry(entry)) {+ const expressionColors = metricColors[entryIndex]+ ? [metricColors[entryIndex][0]]+ : undefined;++ return (+ <span key={`${entry.id}-${entryIndex}`}>+ <MetricExpressionPill+ expressionEntry={entry}+ metricNames={metricNames}+ colors={expressionColors}+ onClick={(e: React.MouseEvent) => {+ e.stopPropagation();+ handleContainerClick(e);+ }}+ onRemove={() => handleRemoveItem(entryIndex)}+ />+ </span>+ );+ }++ return null;+ })}+ </>+ ) : (+ // Focused: CodeMirror editor with syntax highlighting.+ // The Popover is anchored to a zero-size fixed span that tracks the+ // viewport position of the word under the cursor, so the dropdown+ // appears directly below the current word rather than the full input.+ <>+ <div+ className={S.codeEditor}+ onFocus={handleInputFocus}+ onBlur={handleInputBlur}+ onClick={handleEditorClick}+ onKeyDown={handleEditorKeyDown}+ >+ <CodeMirror+ ref={editorRef}+ basicSetup={false}+ autoFocus+ value={editText}+ onChange={handleChange}+ extensions={editorExtensions}+ data-testid="metrics-viewer-search-input"/>- )}- </Popover.Dropdown>- </Popover>+ </div>+ <Popover+ opened={isOpen}+ onChange={setIsOpen}+ position="bottom-start"+ shadow="md"+ withinPortal+ >+ <Popover.Target>+ <span+ aria-hidden+ style={{+ position: "fixed",+ left: anchorRect.left,+ top: anchorRect.top,+ width: 0,+ height: 0,+ pointerEvents: "none",+ }}+ />+ </Popover.Target>+ <Popover.Dropdown+ p={0}+ miw="19rem"+ maw="25rem"+ onMouseDown={(e) => e.preventDefault()}+ >+ {isOpen && (+ <MetricSearchDropdown+ onSelect={handleSelect}+ externalSearchText={currentWord}+ onHasSelectionChange={handleDropdownHasSelectionChange}+ onClose={() => setIsOpen(false)}+ />+ )}+ </Popover.Dropdown>+ </Popover>+ </>+ )}</Flex>+ {isFocused && !pendingFocusRef.current && isExpressionDirty && (+ <Button+ variant="light"+ color="brand"+ size="xs"+ py="sm"+ px="sm"+ leftSection={<Icon size="0.75rem" name="enter_or_return" />}+ disabled={!!validationError}+ data-testid="run-expression-button"+ onClick={(e: React.MouseEvent) => {+ e.stopPropagation();+ handleRun();+ }}+ >{t`Run`}</Button>+ )}</Flex>);}diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/MetricSearchInput.unit.spec.tsx b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/MetricSearchInput.unit.spec.tsxnew file mode 100644index 00000000000..ed64bf2828a--- /dev/null+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/MetricSearchInput.unit.spec.tsx@@ -0,0 +1,640 @@+import { fireEvent, within } from "@testing-library/react";+import userEvent from "@testing-library/user-event";++import { renderWithProviders, screen, waitFor } from "__support__/ui";++import type {+ ExpressionDefinitionEntry,+ ExpressionSubToken,+ MetricDefinitionEntry,+ MetricExpressionId,+ MetricSourceId,+ MetricsViewerDefinitionEntry,+ MetricsViewerFormulaEntity,+ SelectedMetric,+ SourceColorMap,+} from "../../../types/viewer-state";+import { isExpressionEntry, isMetricEntry } from "../../../types/viewer-state";+import { createMetricSourceId } from "../../../utils/source-ids";++import { MetricSearchInput } from "./MetricSearchInput";++// ---------------------------------------------------------------------------+// Mocks+// ---------------------------------------------------------------------------++jest.mock("../../../utils/definition-builder", () => ({+ getDefinitionName: (def: any) => def?.["display-name"] ?? null,+}));++jest.mock("../MetricPill", () => ({+ MetricPill: ({+ metric,+ onRemove,+ }: {+ metric: SelectedMetric;+ onRemove: (id: number, sourceType: "metric" | "measure") => void;+ }) => (+ <div data-testid="metric-pill" data-metric-name={metric.name}>+ <span>{metric.name}</span>+ <button onClick={() => onRemove(metric.id, metric.sourceType)}>+ remove+ </button>+ </div>+ ),+}));++jest.mock("../MetricExpressionPill", () => ({+ MetricExpressionPill: ({+ expressionEntry,+ onClick,+ onRemove,+ }: {+ expressionEntry: { name: string };+ metricEntries: unknown[];+ colors?: string[];+ onClick: (e: React.MouseEvent) => void;+ onRemove: () => void;+ }) => {+ return (+ <div+ data-testid="metric-expression-pill"+ data-expression-text={expressionEntry.name}+ onClick={onClick}+ >+ <span>{expressionEntry.name}</span>+ <button onClick={onRemove}>remove</button>+ </div>+ );+ },+}));++jest.mock("../MetricSearchDropdown", () => ({+ MetricSearchDropdown: ({+ onSelect,+ externalSearchText,+ }: {+ onSelect: (metric: SelectedMetric) => void;+ externalSearchText: string;+ }) => (+ <div data-testid="search-dropdown" data-search-text={externalSearchText}>+ <button+ onClick={() =>+ onSelect({ id: 99, name: "New Metric", sourceType: "metric" })+ }+ >+ select-new-metric+ </button>+ </div>+ ),+}));++// ---------------------------------------------------------------------------+// Helpers+// ---------------------------------------------------------------------------++function makeMetric(+ id: number,+ name: string,+ sourceType: "metric" | "measure" = "metric",+): SelectedMetric {+ return { id, name, sourceType };+}++function makeMetricEntry(metric: SelectedMetric): MetricDefinitionEntry {+ const sid =+ metric.sourceType === "metric"+ ? createMetricSourceId(metric.id)+ : (`measure:${metric.id}` as MetricSourceId);+ // Create a fake definition with display-name for getDefinitionName+ const fakeDefinition = {+ "display-name": metric.name,+ } as unknown as MetricDefinitionEntry["definition"];+ return { id: sid, type: "metric" as const, definition: fakeDefinition };+}++function makeExpressionEntry(+ name: string,+ tokens: ExpressionSubToken[],+): ExpressionDefinitionEntry {+ return {+ id: `expression:${name}` as MetricExpressionId,+ type: "expression",+ name,+ tokens,+ };+}++/** Build a definitions map from metric entries only */+function buildDefinitionsMap(+ entries: MetricDefinitionEntry[],+): Record<MetricSourceId, MetricsViewerDefinitionEntry> {+ const map: Record<MetricSourceId, MetricsViewerDefinitionEntry> = {};+ for (const entry of entries) {+ map[entry.id] = { id: entry.id, definition: entry.definition };+ }+ return map;+}++/** Build formulaEntities from a mixed array of metric + expression entries */+function buildFormulaEntities(+ entries: (MetricDefinitionEntry | ExpressionDefinitionEntry)[],+): MetricsViewerFormulaEntity[] {+ return entries;+}++type SetupOptions = {+ /** Mixed array of metric and expression entries (old-style convenience) */+ entries?: (MetricDefinitionEntry | ExpressionDefinitionEntry)[];+ selectedMetrics?: SelectedMetric[];+ metricColors?: SourceColorMap;+ onFormulaEntitiesChange?: jest.Mock;+ onAddMetric?: jest.Mock;+ onRemoveMetric?: jest.Mock;+ onSwapMetric?: jest.Mock;+ onSetBreakout?: jest.Mock;+};++function setup(options: SetupOptions = {}) {+ const revenue = makeMetric(1, "Revenue");+ const costs = makeMetric(2, "Costs");++ const {+ selectedMetrics = [revenue, costs],+ metricColors = {},+ entries = selectedMetrics.map(makeMetricEntry),+ onFormulaEntitiesChange = jest.fn(),+ onAddMetric = jest.fn(),+ onRemoveMetric = jest.fn(),+ onSwapMetric = jest.fn(),+ onSetBreakout = jest.fn(),+ } = options;++ // Derive definitions map from metric entries only+ const metricEntries = entries.filter(isMetricEntry);+ const definitions = buildDefinitionsMap(metricEntries);+ const formulaEntities = buildFormulaEntities(entries);++ const user = userEvent.setup({ advanceTimers: jest.advanceTimersByTime });++ renderWithProviders(+ <MetricSearchInput+ definitions={definitions}+ formulaEntities={formulaEntities}+ onFormulaEntitiesChange={onFormulaEntitiesChange}+ selectedMetrics={selectedMetrics}+ metricColors={metricColors}+ onAddMetric={onAddMetric}+ onRemoveMetric={onRemoveMetric}+ onSwapMetric={onSwapMetric}+ onSetBreakout={onSetBreakout}+ />,+ );++ return {+ user,+ onFormulaEntitiesChange,+ onAddMetric,+ onRemoveMetric,+ onSwapMetric,+ onSetBreakout,+ };+}++// ---------------------------------------------------------------------------+// Definition factories+// ---------------------------------------------------------------------------++const revenue = makeMetric(1, "Revenue");+const costs = makeMetric(2, "Costs");+const revenueEntry = makeMetricEntry(revenue);+const costsEntry = makeMetricEntry(costs);++const m = (sourceId: MetricSourceId): ExpressionSubToken => ({+ type: "metric",+ sourceId,+ count: 1,+});+const op = (o: "+" | "-" | "*" | "/"): ExpressionSubToken => ({+ type: "operator",+ op: o,+});++// ---------------------------------------------------------------------------+// Tests+// ---------------------------------------------------------------------------++beforeEach(() => {+ jest.useFakeTimers();+});++afterEach(() => {+ jest.runOnlyPendingTimers();+ jest.useRealTimers();+});++// ── Collapsed view (pills) ──────────────────────────────────────────────────++describe("collapsed view (definitions present, not focused)", () => {+ it("renders a single metric definition as a MetricPill", () => {+ setup({ entries: [revenueEntry] });++ expect(screen.getByTestId("metric-pill")).toBeInTheDocument();+ expect(screen.getByText("Revenue")).toBeInTheDocument();+ expect(screen.queryByRole("textbox")).not.toBeInTheDocument();+ });++ it("renders an expression entry as MetricExpressionPill", () => {+ const expr = makeExpressionEntry("Revenue + Costs", [+ m("metric:1"),+ op("+"),+ m("metric:2"),+ ]);+ setup({+ entries: [revenueEntry, costsEntry, expr],+ });++ const pill = screen.getByTestId("metric-expression-pill");+ expect(pill).toBeInTheDocument();+ expect(pill).toHaveAttribute("data-expression-text", "Revenue + Costs");+ });++ it("renders two separate metric entries as two pills", () => {+ setup({ entries: [revenueEntry, costsEntry] });++ const pills = screen.getAllByTestId("metric-pill");+ expect(pills).toHaveLength(2);+ expect(pills[0]).toHaveAttribute("data-metric-name", "Revenue");+ expect(pills[1]).toHaveAttribute("data-metric-name", "Costs");+ });++ it("does not render a text input when collapsed", () => {+ setup({ entries: [revenueEntry] });+ expect(screen.queryByRole("textbox")).not.toBeInTheDocument();+ });++ it("shows the CodeMirror editor when there are no definitions", () => {+ setup({ entries: [] });+ expect(+ screen.getByTestId("metrics-viewer-search-input"),+ ).toBeInTheDocument();+ });+});++// ── Expanded view (focused text input) ─────────────────────────────────────++describe("expanded view (focused text input)", () => {+ it("transitions to text input when clicking the container", async () => {+ const { user } = setup({ entries: [revenueEntry] });++ await user.click(screen.getByTestId("metric-pill"));++ await waitFor(() => {+ expect(screen.getByRole("textbox")).toBeInTheDocument();+ });+ });++ it("shows the text editor when focused (transitions from pills)", async () => {+ const expr = makeExpressionEntry("Revenue + Costs", [+ m("metric:1"),+ op("+"),+ m("metric:2"),+ ]);+ const { user } = setup({+ entries: [revenueEntry, costsEntry, expr],+ });++ await user.click(screen.getByTestId("metric-expression-pill"));++ await waitFor(() => {+ expect(+ screen.getByTestId("metrics-viewer-search-input"),+ ).toBeInTheDocument();+ });+ });++ it("opens the search dropdown when typing in the editor", async () => {+ const { user } = setup({ entries: [] });++ const input = screen.getByTestId("metrics-viewer-search-input");+ await user.type(input, "R");++ await waitFor(() => {+ expect(screen.getByTestId("search-dropdown")).toBeInTheDocument();+ });+ });+});++// ── Blur / unfocus behavior ─────────────────────────────────────────────────++describe("blur behavior", () => {+ it("collapses back to pill view on blur when text is unchanged", async () => {+ const { user } = setup({+ entries: [revenueEntry],+ selectedMetrics: [revenue],+ });++ await user.click(screen.getByTestId("metric-pill"));+ await waitFor(() => {+ expect(+ screen.getByTestId("metrics-viewer-search-input"),+ ).toBeInTheDocument();+ });++ await user.tab();++ expect(+ screen.queryByTestId("metrics-viewer-search-input"),+ ).not.toBeInTheDocument();+ expect(screen.getByTestId("metric-pill")).toBeInTheDocument();+ });++ it("shows the Run button when formula is dirty", async () => {+ const { user } = setup({+ entries: [revenueEntry],+ selectedMetrics: [revenue],+ });++ // Click pill → transitions to editor+ await user.click(screen.getByTestId("metric-pill"));+ await waitFor(() => {+ expect(+ screen.getByTestId("metrics-viewer-search-input"),+ ).toBeInTheDocument();+ });++ // Directly change the textarea value to simulate editing+ const input = screen.getByTestId("metrics-viewer-search-input");+ fireEvent.change(input, { target: { value: "Revenue + Costs" } });++ await waitFor(() => {+ expect(screen.getByTestId("run-expression-button")).toBeInTheDocument();+ });+ });++ it("does not show the Run button when focused if formula is unchanged", async () => {+ const expr = makeExpressionEntry("Revenue + Costs", [+ m("metric:1"),+ op("+"),+ m("metric:2"),+ ]);+ const { user } = setup({+ entries: [revenueEntry, costsEntry, expr],+ });++ await user.click(screen.getByTestId("metric-expression-pill"));+ expect(await screen.findByRole("textbox")).toBeInTheDocument();++ expect(+ screen.queryByTestId("run-expression-button"),+ ).not.toBeInTheDocument();+ });+});++// ── Run button and validation ───────────────────────────────────────────────++describe("run button and validation", () => {+ it("collapses and commits when Run is clicked with a valid expression", async () => {+ const onFormulaEntitiesChange = jest.fn();+ const { user } = setup({+ entries: [revenueEntry],+ selectedMetrics: [revenue],+ onFormulaEntitiesChange,+ });++ // Click pill → transitions to editor+ await user.click(screen.getByTestId("metric-pill"));+ await waitFor(() => {+ expect(+ screen.getByTestId("metrics-viewer-search-input"),+ ).toBeInTheDocument();+ });++ // Directly change the textarea value to something different+ const input = screen.getByTestId("metrics-viewer-search-input");+ fireEvent.change(input, { target: { value: "Revenue, Revenue" } });++ await waitFor(() => {+ expect(screen.getByTestId("run-expression-button")).toBeInTheDocument();+ });++ await user.click(screen.getByTestId("run-expression-button"));++ await waitFor(() => {+ expect(onFormulaEntitiesChange).toHaveBeenCalled();+ });+ });++ it("removes unreferenced metrics when Run commits a new expression", async () => {+ const onRemoveMetric = jest.fn();+ const onFormulaEntitiesChange = jest.fn();+ const { user } = setup({+ entries: [revenueEntry, costsEntry],+ selectedMetrics: [revenue, costs],+ onRemoveMetric,+ onFormulaEntitiesChange,+ });++ // Click a pill to transition to the editor+ const pills = screen.getAllByTestId("metric-pill");+ await user.click(pills[0]);++ await waitFor(() => {+ expect(+ screen.getByTestId("metrics-viewer-search-input"),+ ).toBeInTheDocument();+ });++ // Directly change the textarea value to only reference Revenue (not Costs)+ const input = screen.getByTestId("metrics-viewer-search-input");+ fireEvent.change(input, { target: { value: "Revenue" } });++ await waitFor(() => {+ expect(screen.getByTestId("run-expression-button")).toBeInTheDocument();+ });++ await user.click(screen.getByTestId("run-expression-button"));++ await waitFor(() => {+ // Costs (metric:2) is no longer referenced after text was replaced+ expect(onRemoveMetric).toHaveBeenCalledWith(2, "metric");+ });+ });+});++// ── Removing items ──────────────────────────────────────────────────────────++describe("removing pills", () => {+ it("calls onRemoveMetric and onFormulaEntitiesChange when removing a standalone MetricPill", async () => {+ const onRemoveMetric = jest.fn();+ const onFormulaEntitiesChange = jest.fn();+ const { user } = setup({+ entries: [revenueEntry],+ selectedMetrics: [revenue],+ onRemoveMetric,+ onFormulaEntitiesChange,+ });++ await user.click(screen.getByRole("button", { name: "remove" }));++ expect(onRemoveMetric).toHaveBeenCalledWith(1, "metric");+ expect(onFormulaEntitiesChange).toHaveBeenCalledWith(+ [],+ new Map(), // slot mapping: no slots remain+ );+ });++ it("removes a MetricPill from a two-item list, keeping the other metric", async () => {+ const onRemoveMetric = jest.fn();+ const onFormulaEntitiesChange = jest.fn();+ const { user } = setup({+ entries: [revenueEntry, costsEntry],+ selectedMetrics: [revenue, costs],+ onRemoveMetric,+ onFormulaEntitiesChange,+ });++ const removeButtons = screen.getAllByRole("button", { name: "remove" });+ // Remove the first item (Revenue)+ await user.click(removeButtons[0]);++ expect(onRemoveMetric).toHaveBeenCalledWith(1, "metric");+ expect(onFormulaEntitiesChange).toHaveBeenCalledWith(+ [costsEntry],+ new Map([[1, 0]]), // slot mapping: Costs moved from slot 1 → 0+ );+ });++ it("calls onRemoveMetric for all metrics in an expression pill when removed", async () => {+ const onRemoveMetric = jest.fn();+ const onFormulaEntitiesChange = jest.fn();+ const expr = makeExpressionEntry("Revenue + Costs", [+ m("metric:1"),+ op("+"),+ m("metric:2"),+ ]);+ const { user } = setup({+ entries: [revenueEntry, costsEntry, expr],+ selectedMetrics: [revenue, costs],+ onRemoveMetric,+ onFormulaEntitiesChange,+ });++ // The expression pill's remove button+ const exprPill = screen.getByTestId("metric-expression-pill");+ const removeButton = within(exprPill).getByRole("button");+ await user.click(removeButton);++ // Both Revenue and Costs are only referenced in the expression (the metric entries remain)+ // Since revenueEntry and costsEntry still exist in remaining definitions,+ // they should NOT be removed+ expect(onFormulaEntitiesChange).toHaveBeenCalled();+ });+});++// ── Expression pill display after Run ────────────────────────────────────────++describe("expression pill display after committing a formula", () => {+ it("preserves metric entries so the expression pill displays full metric names", async () => {+ const metricA = makeMetric(1, "MetricA");+ const metricB = makeMetric(2, "MetricB");+ const metricC = makeMetric(3, "MetricC");+ const metricAEntry = makeMetricEntry(metricA);+ const metricBEntry = makeMetricEntry(metricB);+ const metricCEntry = makeMetricEntry(metricC);++ const onFormulaEntitiesChange = jest.fn();++ const { user } = setup({+ entries: [metricAEntry, metricBEntry, metricCEntry],+ selectedMetrics: [metricA, metricB, metricC],+ onFormulaEntitiesChange,+ });++ // Click a pill to transition to the editor+ const pills = screen.getAllByTestId("metric-pill");+ await user.click(pills[0]);++ await waitFor(() => {+ expect(+ screen.getByTestId("metrics-viewer-search-input"),+ ).toBeInTheDocument();+ });++ // Type the expression formula+ const input = screen.getByTestId("metrics-viewer-search-input");+ fireEvent.change(input, {+ target: {+ value: `${[metricA, metricB, metricC].map((m) => m.name).join(", ")}, (MetricA + MetricB) / MetricC`,+ },+ });++ // Run button should appear (formula is dirty)+ await waitFor(() => {+ expect(screen.getByTestId("run-expression-button")).toBeInTheDocument();+ });++ // Click Run to commit+ await user.click(screen.getByTestId("run-expression-button"));++ // The committed formula entities should include the metric entries referenced+ // by the expression so that buildExpressionText can resolve their names.+ await waitFor(() => {+ expect(onFormulaEntitiesChange).toHaveBeenCalled();+ });++ const committedEntities = onFormulaEntitiesChange.mock.calls[+ onFormulaEntitiesChange.mock.calls.length - 1+ ][0] as MetricsViewerFormulaEntity[];++ // Must contain the 3 metric entries plus the expression entry+ const metricDefs = committedEntities.filter(isMetricEntry);+ const exprDefs = committedEntities.filter(isExpressionEntry);++ expect(metricDefs).toHaveLength(3);+ expect(exprDefs).toHaveLength(1);++ // The expression entry should have the correct tokens+ const expr = exprDefs[0];+ expect(expr.tokens).toEqual([+ { type: "open-paren" },+ { type: "metric", sourceId: "metric:1", count: 1 },+ { type: "operator", op: "+" },+ { type: "metric", sourceId: "metric:2", count: 1 },+ { type: "close-paren" },+ { type: "operator", op: "/" },+ { type: "metric", sourceId: "metric:3", count: 1 },+ ]);+ expect(expr.name).toBe("(MetricA + MetricB) / MetricC");+ });+});++// ── Typing / onChange ───────────────────────────────────────────────────────++describe("typing in the text input", () => {+ it("does not call onFormulaEntitiesChange as the user types (deferred to Run)", async () => {+ const onFormulaEntitiesChange = jest.fn();+ const { user } = setup({+ entries: [],+ onFormulaEntitiesChange,+ });++ const input = screen.getByRole("textbox");+ await user.type(input, "R");++ expect(onFormulaEntitiesChange).not.toHaveBeenCalled();+ });++ it("opens the search dropdown on input", async () => {+ const { user } = setup({ entries: [] });++ const input = screen.getByRole("textbox");+ await user.type(input, "Rev");++ expect(screen.getByTestId("search-dropdown")).toBeInTheDocument();+ expect(screen.getByTestId("search-dropdown")).toHaveAttribute(+ "data-search-text",+ "Rev",+ );+ });+});diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/editorExtensions.ts b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/editorExtensions.tsnew file mode 100644index 00000000000..dbf4e7ebe62--- /dev/null+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/editorExtensions.ts@@ -0,0 +1,62 @@+import { history, redo, undo } from "@codemirror/commands";+import type { Extension } from "@codemirror/state";+import { keymap, placeholder } from "@codemirror/view";+import { t } from "ttag";++import { errorHighlight } from "./errorHighlight";+import { metricTokenHighlight } from "./metricTokenHighlight";+import { operatorHighlight } from "./operatorHighlight";++type EditorExtensionRefs = {+ dropdownHasSelectionRef: { current: boolean };+ handleRunRef: { current: () => void };+ isOpenRef: { current: boolean };+};++export function buildEditorExtensions(+ formulaEntityCount: number,+ refs: EditorExtensionRefs,+): Extension[] {+ return [+ history(),+ operatorHighlight,+ errorHighlight,+ metricTokenHighlight,+ placeholder(formulaEntityCount === 0 ? t`Search for metrics...` : ""),+ // Prevent Enter from creating newlines; trigger run when dirty.+ // If the dropdown has a keyboard-highlighted item, skip running —+ // let the dropdown's Enter handler select the item instead.+ keymap.of([+ { key: "Mod-z", run: undo, preventDefault: true },+ { key: "Mod-Shift-z", run: redo, preventDefault: true },+ {+ key: "Enter",+ run: () => {+ if (!refs.dropdownHasSelectionRef.current) {+ refs.handleRunRef.current();+ }+ return true;+ },+ },+ // don't move the cursor when using the arrow keys to navigate the dropdown+ {+ key: "ArrowDown",+ run: () => {+ if (refs.isOpenRef.current) {+ return true;+ }+ return false;+ },+ },+ {+ key: "ArrowUp",+ run: () => {+ if (refs.isOpenRef.current) {+ return true;+ }+ return false;+ },+ },+ ]),+ ];+}diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/errorHighlight.ts b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/errorHighlight.tsnew file mode 100644index 00000000000..ad8e62d3e62--- /dev/null+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/errorHighlight.ts@@ -0,0 +1,83 @@+import { StateEffect, StateField } from "@codemirror/state";+import {+ Decoration,+ type DecorationSet,+ EditorView,+ hoverTooltip,+} from "@codemirror/view";++import type { ErrorRange } from "../utils";++import S from "./MetricSearchInput.module.css";++const errorMark = Decoration.mark({ class: S.cmErrorUnderline });++export const setErrorDecoration = StateEffect.define<ErrorRange[]>();++/** Stores error ranges with messages for tooltip lookup. */+const errorRangesField = StateField.define<ErrorRange[]>({+ create: () => [],+ update(ranges, tr) {+ if (tr.docChanged) {+ return [];+ }+ for (const effect of tr.effects) {+ if (effect.is(setErrorDecoration)) {+ return effect.value;+ }+ }+ return ranges;+ },+});++/** Builds mark decorations from stored error ranges. */+const errorDecorationField = StateField.define<DecorationSet>({+ create: () => Decoration.none,+ update(deco, tr) {+ if (tr.docChanged) {+ return Decoration.none;+ }+ for (const effect of tr.effects) {+ if (effect.is(setErrorDecoration)) {+ if (effect.value.length === 0) {+ return Decoration.none;+ }+ const docLen = tr.newDoc.length;+ // Ranges must be sorted and non-overlapping for Decoration.set+ const marks = [...effect.value]+ .filter((r) => r.from < r.to && r.from >= 0 && r.to <= docLen)+ .sort((a, b) => a.from - b.from)+ .map((r) => errorMark.range(r.from, r.to));+ return marks.length > 0 ? Decoration.set(marks) : Decoration.none;+ }+ }+ return deco;+ },+ provide: (f) => EditorView.decorations.from(f),+});++/** Shows the error message in a tooltip when hovering over an underlined range. */+const errorHoverTooltip = hoverTooltip((view, pos) => {+ const ranges = view.state.field(errorRangesField);+ const match = ranges.find((r) => r.from <= pos && pos < r.to);+ if (!match) {+ return null;+ }+ return {+ pos: match.from,+ end: match.to,+ above: true,+ create() {+ const dom = document.createElement("div");+ dom.className = S.cmErrorTooltip;+ dom.textContent = match.message;+ return { dom };+ },+ };+});++export const errorHighlight = [+ errorRangesField,+ errorDecorationField,+ errorHoverTooltip,+];diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/metricTokenHighlight.ts b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/metricTokenHighlight.tsnew file mode 100644index 00000000000..c2f34d1e8dc--- /dev/null+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/metricTokenHighlight.ts@@ -0,0 +1,305 @@+import {+ MapMode,+ RangeSet,+ RangeValue,+ StateEffect,+ StateField,+} from "@codemirror/state";+import {+ Decoration,+ type DecorationSet,+ EditorView,+ WidgetType,+ keymap,+} from "@codemirror/view";++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 S from "./MetricSearchInput.module.css";++class MetricTokenWidget extends WidgetType {+ constructor(readonly name: string) {+ super();+ }++ eq(other: MetricTokenWidget) {+ return this.name === other.name;+ }++ toDOM() {+ const span = document.createElement("span");+ span.className = S.cmMetricToken;+ span.textContent = this.name;+ return span;+ }++ ignoreEvent() {+ return false;+ }+}++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.+ override startSide = 1;+ override endSide = -1;++ constructor(+ readonly sourceId: MetricSourceId,+ readonly definition: MetricDefinition | null,+ readonly slotIndex: number,+ ) {+ super();+ }++ override eq(other: MetricIdentity) {+ return (+ this.sourceId === other.sourceId &&+ this.definition === other.definition &&+ this.slotIndex === other.slotIndex+ );+ }+}++export const setMetricIdentities =+ StateEffect.define<RangeSet<MetricIdentity>>();++export const metricIdentityField = StateField.define<RangeSet<MetricIdentity>>({+ create: () => RangeSet.empty,+ update(identities, tr) {+ for (const effect of tr.effects) {+ if (effect.is(setMetricIdentities)) {+ return effect.value;+ }+ }+ if (tr.docChanged) {+ return identities.map(tr.changes);+ }+ return identities;+ },+});++export function buildMetricIdentities(+ text: string,+ metricNames: MetricNameMap,+ entities: MetricsViewerFormulaEntity[],+): 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,+ ),+ );+ });++ 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[] = [];+ const docLength = view.state.doc.length;+ identities.between(0, docLength, (from, to, value) => {+ result.push({+ sourceId: value.sourceId,+ from,+ to,+ definition: value.definition,+ slotIndex: value.slotIndex,+ });+ });+ return result;+}++// ── Token highlighting ─────────────────────────────────────────────────────++type MetricRange = { from: number; to: number; name: string };++function computeMetricTokenRanges(+ docText: string,+ docLength: number,+ metricNames: MetricNameMap,+): MetricRange[] {+ if (Object.keys(metricNames).length === 0) {+ return [];+ }++ 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),+ }));+}++function rangesToDecorations(ranges: MetricRange[]): DecorationSet {+ if (ranges.length === 0) {+ return Decoration.none;+ }+ const decorations = ranges.map((r) =>+ Decoration.replace({+ widget: new MetricTokenWidget(r.name),+ }).range(r.from, r.to),+ );+ return Decoration.set(decorations);+}++/** Stores the raw metric ranges for lookup by keymap handlers. */+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,+ );+ }+ return ranges;+ },+});++/** 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));+ }+ return deco;+ },+ provide: (f) => EditorView.decorations.from(f),+});++/**+ * Find the metric range that the cursor is adjacent to or inside of.+ * For Backspace: find a range whose `to` equals cursor pos (cursor is right after it),+ * or a range that contains the cursor.+ * For Delete: find a range whose `from` equals cursor pos (cursor is right before it),+ * or a range that contains the cursor.+ */+function findAdjacentMetricRange(+ ranges: MetricRange[],+ pos: number,+ direction: "backward" | "forward",+): MetricRange | undefined {+ for (const range of ranges) {+ // Cursor is inside the range+ if (pos > range.from && pos < range.to) {+ return range;+ }+ // Backspace: cursor is right after the range+ if (direction === "backward" && pos === range.to) {+ return range;+ }+ // Delete: cursor is right before the range+ if (direction === "forward" && pos === range.from) {+ return range;+ }+ }+ return undefined;+}++const metricTokenKeymap = keymap.of([+ {+ key: "Backspace",+ run(view) {+ const { state } = view;+ const sel = state.selection.main;+ if (!sel.empty) {+ return false;+ }+ const ranges = state.field(metricTokenRangesField);+ const match = findAdjacentMetricRange(ranges, sel.head, "backward");+ if (!match) {+ return false;+ }+ view.dispatch({+ changes: { from: match.from, to: match.to },+ });+ return true;+ },+ },+ {+ key: "Delete",+ run(view) {+ const { state } = view;+ const sel = state.selection.main;+ if (!sel.empty) {+ return false;+ }+ const ranges = state.field(metricTokenRangesField);+ const match = findAdjacentMetricRange(ranges, sel.head, "forward");+ if (!match) {+ return false;+ }+ view.dispatch({+ changes: { from: match.from, to: match.to },+ });+ return true;+ },+ },+]);++export const metricTokenHighlight = [+ metricNamesField,+ metricIdentityField,+ metricTokenRangesField,+ metricDecorationsField,+ EditorView.atomicRanges.of((view) =>+ view.state.field(metricDecorationsField),+ ),+ metricTokenKeymap,+];diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/operatorHighlight.ts b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/operatorHighlight.tsnew file mode 100644index 00000000000..6b150b3cc16--- /dev/null+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/operatorHighlight.ts@@ -0,0 +1,40 @@+import { RangeSetBuilder } from "@codemirror/state";+import {+ Decoration,+ type DecorationSet,+ type EditorView,+ ViewPlugin,+ type ViewUpdate,+} from "@codemirror/view";++import { isMathExpressionOperator } from "metabase-types/api";++import S from "./MetricSearchInput.module.css";++const operatorMark = Decoration.mark({ class: S.cmOperator });++function buildDecorations(view: EditorView): DecorationSet {+ const builder = new RangeSetBuilder<Decoration>();+ const text = view.state.doc.toString();+ for (let i = 0; i < text.length; i++) {+ if (isMathExpressionOperator(text[i])) {+ builder.add(i, i + 1, operatorMark);+ }+ }+ return builder.finish();+}++export const operatorHighlight = ViewPlugin.fromClass(+ class {+ decorations: DecorationSet;+ constructor(view: EditorView) {+ this.decorations = buildDecorations(view);+ }+ update(update: ViewUpdate) {+ if (update.docChanged) {+ this.decorations = buildDecorations(update.view);+ }+ }+ },+ { decorations: (v) => v.decorations },+);diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/useFormulaEditor.ts b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/useFormulaEditor.tsnew file mode 100644index 00000000000..7ed1f27a89e--- /dev/null+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/useFormulaEditor.ts@@ -0,0 +1,594 @@+import { isolateHistory } from "@codemirror/commands";+import { EditorSelection } from "@codemirror/state";+import type { ReactCodeMirrorRef } from "@uiw/react-codemirror";+import type { MutableRefObject } from "react";+import { useCallback, useEffect, useRef, useState } from "react";++import type {+ MetricSourceId,+ MetricsViewerDefinitionEntry,+ MetricsViewerFormulaEntity,+ SelectedMetric,+} from "../../../types/viewer-state";+import { isExpressionEntry, isMetricEntry } from "../../../types/viewer-state";+import { computeMetricSlots } from "../../../utils/metric-slots";+import {+ createMeasureSourceId,+ createMetricSourceId,+} from "../../../utils/source-ids";+import {+ type MetricNameMap,+ applyTrackedDefinitions,+ buildFullText,+ cleanupParens,+ findInvalidRanges,+ getWordAtCursor,+ parseFullText,+ removeUnmatchedParens,+} from "../utils";++import { setErrorDecoration } from "./errorHighlight";+import {+ buildMetricIdentities,+ readMetricIdentities,+ setMetricIdentities,+ setMetricNames,+} from "./metricTokenHighlight";++type UseFormulaEditorParams = {+ formulaEntities: MetricsViewerFormulaEntity[];+ onFormulaEntitiesChange: (+ entities: MetricsViewerFormulaEntity[],+ slotMapping?: Map<number, number>,+ ) => void;+ selectedMetrics: SelectedMetric[];+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>;+ metricNames: MetricNameMap;+ metricNamesRef: MutableRefObject<MetricNameMap>;+ handleAddMetric: (metric: SelectedMetric) => void;+ handleRemoveMetric: (+ metricId: number,+ sourceType: "metric" | "measure",+ ) => void;+ editorRef: React.RefObject<ReactCodeMirrorRef | null>;+ containerRef: React.RefObject<HTMLDivElement | null>;+};++export type UseFormulaEditorResult = {+ editText: string;+ isFocused: boolean;+ isOpen: boolean;+ setIsOpen: (open: boolean) => void;+ currentWord: string;+ validationError: string | null;+ anchorRect: { left: number; top: number };+ isExpressionDirty: boolean;+ pendingFocusRef: MutableRefObject<boolean>;+ handleInputFocus: () => void;+ handleInputBlur: () => void;+ handleChange: (newText: string) => void;+ handleSelect: (metric: SelectedMetric) => void;+ handleRemoveItem: (itemIndex: number) => void;+ handleContainerClick: (e: React.MouseEvent) => void;+ handleEditorClick: () => void;+ handleEditorKeyDown: (e: React.KeyboardEvent) => void;+ handleDropdownHasSelectionChange: (hasSelection: boolean) => void;+ handleRun: () => void;+ // Refs needed by editorExtensions builder+ handleRunRef: MutableRefObject<() => void>;+ isOpenRef: MutableRefObject<boolean>;+ dropdownHasSelectionRef: MutableRefObject<boolean>;+};++export function useFormulaEditor({+ formulaEntities,+ onFormulaEntitiesChange,+ selectedMetrics,+ definitions,+ metricNames,+ metricNamesRef,+ handleAddMetric,+ handleRemoveMetric,+ editorRef,+ containerRef,+}: UseFormulaEditorParams): UseFormulaEditorResult {+ // editText is the full expression as plain text — only meaningful while focused+ const [editText, setEditText] = useState("");+ // currentWord is the word under the cursor, used as the dropdown search query+ const [currentWord, setCurrentWord] = useState("");+ const [isOpen, setIsOpen] = useState(false);+ const isOpenRef = useRef(isOpen);+ isOpenRef.current = isOpen;+ const [isFocused, setIsFocused] = useState(false);+ const [validationError, setValidationError] = useState<string | null>(null);+ // Pixel position (viewport-relative) of the current word's left edge and+ // line bottom — used to anchor the search dropdown at the cursor word.+ const [anchorRect, setAnchorRect] = useState<{ left: number; top: number }>({+ left: 0,+ top: 0,+ });++ const pendingFocusRef = useRef(false);+ // Refs for reading latest values in callbacks without stale closures+ const editTextRef = useRef(editText);+ editTextRef.current = editText;+ const formulaEntitiesRef = useRef(formulaEntities);+ formulaEntitiesRef.current = formulaEntities;+ const definitionsRef = useRef(definitions);+ definitionsRef.current = definitions;+ // Tracks whether an editing session is active. Set to true only once+ // handleInputFocus initializes the session; set back to false in commitAndCollapse.+ // Used to prevent autoFocus / view.focus() re-entrancy from reinitializing text.+ const isEditingSessionActiveRef = useRef(false);+ // Tracks whether the dropdown has a keyboard-highlighted item.+ // When true, Enter should select from the dropdown, not run the expression.+ const dropdownHasSelectionRef = useRef(false);++ const handleRunRef = useRef<() => void>(() => {});+ // Text captured at focus time — used to detect whether the user actually+ // changed the expression and therefore needs to click "Run" to commit.+ const [textAtFocus, setTextAtFocus] = useState("");+ const textAtFocusRef = useRef(textAtFocus);+ textAtFocusRef.current = textAtFocus;+ // Explicitly tracks whether the expression was modified during this editing+ // session (metric selected from dropdown, or text typed). Avoids timing+ // issues with comparing editText vs textAtFocus across async state updates.+ const [isExpressionDirty, setIsExpressionDirty] = useState(false);++ // Clean up parens per expression entry (only when not actively editing)+ useEffect(() => {+ if (isFocused) {+ return;+ }+ let changed = false;+ const cleaned = formulaEntities.map((entry) => {+ if (!isExpressionEntry(entry)) {+ return entry;+ }+ const cleanedTokens = cleanupParens(removeUnmatchedParens(entry.tokens));+ if (cleanedTokens !== entry.tokens) {+ changed = true;+ return { ...entry, tokens: cleanedTokens };+ }+ return entry;+ });+ if (changed) {+ onFormulaEntitiesChange(cleaned);+ }+ }, [isFocused, formulaEntities, onFormulaEntitiesChange]);++ // Focus the editor after transitioning from collapsed → expanded mode+ useEffect(() => {+ if (isFocused && pendingFocusRef.current) {+ pendingFocusRef.current = false;+ editorRef.current?.view?.focus();+ }+ }, [isFocused, editorRef]);++ const handleInputFocus = useCallback(() => {+ // If an editing session is already active (e.g. focus returning from a+ // dropdown item click via view.focus()), do not reset the text or the+ // committed baseline.+ if (isEditingSessionActiveRef.current) {+ return;+ }+ isEditingSessionActiveRef.current = true;+ const fullText = buildFullText(+ formulaEntitiesRef.current,+ metricNamesRef.current,+ );+ setTextAtFocus(fullText);+ setIsFocused(true);+ setEditText(fullText);+ setValidationError(null);+ setIsExpressionDirty(false);+ // After CodeMirror renders the initial text, position the caret and+ // create an undo boundary. The @uiw/react-codemirror value sync adds+ // to the undo history, so without isolateHistory("before"), a quick+ // Cmd+Z after deleting a metric token would undo both the deletion+ // AND the initial text insertion (they'd be grouped together).+ setTimeout(() => {+ const view = editorRef.current?.view;+ if (view) {+ const endPos = view.state.doc.length;+ const identities = buildMetricIdentities(+ fullText,+ metricNamesRef.current,+ formulaEntitiesRef.current,+ );+ view.dispatch({+ selection: EditorSelection.cursor(endPos),+ effects: [+ setMetricNames.of(metricNamesRef.current),+ setMetricIdentities.of(identities),+ ],+ annotations: isolateHistory.of("full"),+ });+ const coords = view.coordsAtPos(endPos);+ if (coords) {+ setAnchorRect({ left: coords.left, top: coords.bottom });+ }+ }+ }, 0);+ }, [editorRef, metricNamesRef]);++ /** 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 { entities: reconciledEntities, slotMapping } =+ applyTrackedDefinitions(+ parsedEntities,+ trackedIdentities,+ newText,+ metricNamesRef.current,+ );++ // Find which metric sourceIds are referenced in the parsed entities+ const referencedSourceIds = new Set<MetricSourceId>();+ for (const entry of reconciledEntities) {+ if (isMetricEntry(entry)) {+ referencedSourceIds.add(entry.id);+ } else if (isExpressionEntry(entry)) {+ for (const token of entry.tokens) {+ if (token.type === "metric") {+ referencedSourceIds.add(token.sourceId);+ }+ }+ }+ }++ // Remove unreferenced metrics from definitions+ for (const entry of Object.values(definitionsRef.current)) {+ if (!referencedSourceIds.has(entry.id)) {+ const metricId = selectedMetrics.find((m) => {+ const sid =+ m.sourceType === "metric"+ ? createMetricSourceId(m.id)+ : createMeasureSourceId(m.id);+ return sid === entry.id;+ });+ if (metricId) {+ handleRemoveMetric(metricId.id, metricId.sourceType);+ }+ }+ }++ onFormulaEntitiesChange(reconciledEntities, slotMapping);+ isEditingSessionActiveRef.current = false;+ setIsFocused(false);+ setIsOpen(false);+ setCurrentWord("");+ setEditText("");+ setValidationError(null);+ setIsExpressionDirty(false);+ }, [+ editorRef,+ metricNamesRef,+ handleRemoveMetric,+ onFormulaEntitiesChange,+ selectedMetrics,+ ]);++ const handleInputBlur = useCallback(() => {+ // If the text hasn't changed since focus, collapse back to pills view+ // without requiring the user to click "Run".+ if (+ editTextRef.current === textAtFocusRef.current &&+ !dropdownHasSelectionRef.current+ ) {+ isEditingSessionActiveRef.current = false;+ setIsFocused(false);+ setIsOpen(false);+ setCurrentWord("");+ setEditText("");+ setValidationError(null);+ setIsExpressionDirty(false);+ return;+ }++ // Text was modified — validate on blur but do NOT commit.+ // The expression is only executed when the user explicitly clicks "Run".+ const invalidRanges = findInvalidRanges(+ editTextRef.current,+ metricNamesRef.current,+ );+ if (invalidRanges.length > 0) {+ setValidationError(invalidRanges[0].message);+ return;+ }++ setValidationError(null);+ }, [metricNamesRef]);++ const handleChange = useCallback(+ (newText: string) => {+ setEditText(newText);+ setValidationError(null);+ if (newText !== textAtFocusRef.current) {+ setIsExpressionDirty(true);+ }++ // Extract the word at the cursor for the dropdown search+ const view = editorRef.current?.view;+ const cursorPos = view?.state.selection.main.head ?? newText.length;+ const { word, start: wordStart } = getWordAtCursor(+ newText,+ cursorPos,+ metricNamesRef.current,+ );+ // Anchor the dropdown at the word's left edge / line bottom in the viewport+ if (view) {+ const coords = view.coordsAtPos(wordStart);+ if (coords) {+ setAnchorRect({ left: coords.left, top: coords.bottom });+ }+ }+ setCurrentWord(word);+ setIsOpen(true);+ },+ [editorRef, metricNamesRef],+ );++ const handleSelect = useCallback(+ (metric: SelectedMetric) => {+ const view = editorRef.current?.view;+ if (!view) {+ return;+ }+ const docText = view.state.doc.toString();+ const cursorPos = view.state.selection.main.head;+ const { start, end } = getWordAtCursor(+ docText,+ cursorPos,+ metricNamesRef.current,+ );++ const metricName = metric.name ?? "";++ // 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;+ replaceFrom = textBeforeWord.length;+ newCursorPos = replaceFrom + insertText.length;+ } else {+ insertText = metricName;+ replaceFrom = start;+ newCursorPos = start + metricName.length;+ }++ view.dispatch({+ changes: { from: replaceFrom, to: end, insert: insertText },+ selection: EditorSelection.cursor(newCursorPos),+ });++ setIsExpressionDirty(true);+ handleAddMetric(metric);++ setCurrentWord("");+ setIsOpen(false);+ dropdownHasSelectionRef.current = false;++ // Return focus to the editor after dropdown closes+ setTimeout(() => {+ editorRef.current?.view?.focus();+ }, 0);+ },+ [editorRef, metricNamesRef, handleAddMetric],+ );++ // Remove one formula entity by index+ const handleRemoveItem = useCallback(+ (itemIndex: number) => {+ const removedEntry = formulaEntities[itemIndex];+ const newFormulaEntities = formulaEntities.filter(+ (_, i) => i !== itemIndex,+ );++ // Find sourceIds that were only referenced by the removed entry+ const removedSourceIds = new Set<MetricSourceId>();+ if (isMetricEntry(removedEntry)) {+ removedSourceIds.add(removedEntry.id);+ } else if (isExpressionEntry(removedEntry)) {+ for (const token of removedEntry.tokens) {+ if (token.type === "metric") {+ removedSourceIds.add(token.sourceId);+ }+ }+ }++ // Check if any of those sourceIds are still referenced+ const stillReferenced = new Set<MetricSourceId>();+ for (const entry of newFormulaEntities) {+ if (isMetricEntry(entry)) {+ stillReferenced.add(entry.id);+ } else if (isExpressionEntry(entry)) {+ for (const token of entry.tokens) {+ if (token.type === "metric") {+ stillReferenced.add(token.sourceId);+ }+ }+ }+ }++ // Remove unreferenced metrics from definitions+ for (const sourceId of removedSourceIds) {+ if (!stillReferenced.has(sourceId)) {+ const metric = selectedMetrics.find((m) => {+ const sid =+ m.sourceType === "metric"+ ? createMetricSourceId(m.id)+ : createMeasureSourceId(m.id);+ return sid === sourceId;+ });+ if (metric) {+ handleRemoveMetric(metric.id, metric.sourceType);+ }+ }+ }++ // Build slot mapping for the removal: surviving old slots map to their+ // new (shifted) indices. Slots from the removed entity are absent.+ const oldSlots = computeMetricSlots(formulaEntities);+ const slotMapping = new Map<number, number>();+ let newIdx = 0;+ for (const slot of oldSlots) {+ if (slot.entityIndex === itemIndex) {+ continue; // removed+ }+ slotMapping.set(slot.slotIndex, newIdx++);+ }++ onFormulaEntitiesChange(newFormulaEntities, slotMapping);+ },+ [+ formulaEntities,+ selectedMetrics,+ handleRemoveMetric,+ onFormulaEntitiesChange,+ ],+ );++ const handleContainerClick = useCallback(+ (e: React.MouseEvent) => {+ // Ignore clicks originating from portal-rendered content (e.g. context+ // menus, breakout pickers). These fire "click outside" on the container+ // but should not switch the input into text-editing mode.+ if (+ containerRef.current &&+ e.target instanceof Node &&+ !containerRef.current.contains(e.target)+ ) {+ return;+ }+ const view = editorRef.current?.view;+ if (view) {+ view.focus();+ } else {+ // Editor not rendered yet (collapsed mode) — transition to expanded+ pendingFocusRef.current = true;+ setIsFocused(true);+ }+ },+ [containerRef, editorRef],+ );++ const handleEditorClick = useCallback(() => {+ const view = editorRef.current?.view;+ if (!view) {+ return;+ }+ // Re-extract word at the new cursor position after a click+ const cursorPos = view.state.selection.main.head;+ const text = view.state.doc.toString();+ const { word, start: wordStart } = getWordAtCursor(+ text,+ cursorPos,+ metricNamesRef.current,+ );+ // Update the anchor position so the dropdown is correctly placed+ const coords = view.coordsAtPos(wordStart);+ if (coords) {+ setAnchorRect({ left: coords.left, top: coords.bottom });+ }+ setCurrentWord(word);+ setIsOpen(true);+ }, [editorRef, metricNamesRef]);++ const handleEditorKeyDown = useCallback((e: React.KeyboardEvent) => {+ if (e.key === "Escape") {+ setIsOpen(false);+ }+ }, []);++ const handleDropdownHasSelectionChange = useCallback(+ (hasSelection: boolean) => {+ dropdownHasSelectionRef.current = hasSelection;+ },+ [],+ );++ /** 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 invalidRanges = findInvalidRanges(+ editTextRef.current,+ metricNamesRef.current,+ );+ if (invalidRanges.length > 0) {+ setValidationError(invalidRanges[0].message);+ return;+ }++ setValidationError(null);+ commitAndCollapse();+ }, [commitAndCollapse, metricNamesRef]);+ handleRunRef.current = handleRun;++ // Sync validation error into the CodeMirror decoration field+ useEffect(() => {+ const view = editorRef.current?.view;+ if (!view) {+ return;+ }+ const ranges =+ validationError !== null+ ? findInvalidRanges(editTextRef.current, metricNamesRef.current)+ : [];+ 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,+ isOpen,+ setIsOpen,+ currentWord,+ validationError,+ anchorRect,+ isExpressionDirty,+ pendingFocusRef,+ handleInputFocus,+ handleInputBlur,+ handleChange,+ handleSelect,+ handleRemoveItem,+ handleContainerClick,+ handleEditorClick,+ handleEditorKeyDown,+ handleDropdownHasSelectionChange,+ handleRun,+ handleRunRef,+ isOpenRef,+ dropdownHasSelectionRef,+ };+}diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/useMetricNameTracking.ts b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/useMetricNameTracking.tsnew file mode 100644index 00000000000..18fdd50885e--- /dev/null+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/useMetricNameTracking.ts@@ -0,0 +1,112 @@+import type { MutableRefObject } from "react";+import { useCallback, useMemo, useRef, useState } from "react";++import type { MetricDefinition } from "metabase-lib/metric";++import type {+ MetricSourceId,+ MetricsViewerDefinitionEntry,+ SelectedMetric,+} from "../../../types/viewer-state";+import { getDefinitionName } from "../../../utils/definition-builder";+import { createSourceId } from "../../../utils/source-ids";+import type { MetricNameMap } from "../utils";++type UseMetricNameTrackingParams = {+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>;+ onAddMetric: (metric: SelectedMetric) => void;+ onRemoveMetric: (metricId: number, sourceType: "metric" | "measure") => void;+ onSwapMetric: (oldMetric: SelectedMetric, newMetric: SelectedMetric) => void;+};++type UseMetricNameTrackingResult = {+ metricNames: MetricNameMap;+ metricNamesRef: MutableRefObject<MetricNameMap>;+ handleAddMetric: (metric: SelectedMetric) => void;+ handleRemoveMetric: (+ metricId: number,+ sourceType: "metric" | "measure",+ ) => void;+ handleSwapMetric: (+ oldMetric: SelectedMetric,+ newMetric: SelectedMetric,+ ) => void;+};++export function useMetricNameTracking({+ definitions,+ onAddMetric,+ onRemoveMetric,+ onSwapMetric,+}: UseMetricNameTrackingParams): UseMetricNameTrackingResult {+ const [localMetricNames, setLocalMetricNames] = useState<MetricNameMap>({});++ const metricNames: MetricNameMap = useMemo(+ () => ({+ ...localMetricNames,+ ...Object.fromEntries(+ Object.values(definitions)+ .filter(+ (e): e is { id: MetricSourceId; definition: MetricDefinition } =>+ e.definition !== null,+ )+ .map((e) => [e.id, getDefinitionName(e.definition)])+ .filter(([, name]) => name !== null),+ ),+ }),+ [localMetricNames, definitions],+ );++ const metricNamesRef = useRef<MetricNameMap>(metricNames);+ metricNamesRef.current = metricNames;++ const handleAddMetric = useCallback(+ (metric: SelectedMetric) => {+ onAddMetric(metric);+ if (metric.name != null) {+ setLocalMetricNames((prev) => ({+ ...prev,+ [createSourceId(metric.id, metric.sourceType)]: metric.name!,+ }));+ }+ },+ [onAddMetric],+ );++ const handleRemoveMetric = useCallback(+ (metricId: number, sourceType: "metric" | "measure") => {+ onRemoveMetric(metricId, sourceType);+ const sourceId = createSourceId(metricId, sourceType);+ setLocalMetricNames((prev) => {+ const next = { ...prev };+ delete next[sourceId];+ return next;+ });+ },+ [onRemoveMetric],+ );++ const handleSwapMetric = useCallback(+ (oldMetric: SelectedMetric, newMetric: SelectedMetric) => {+ onSwapMetric(oldMetric, newMetric);+ setLocalMetricNames((prev) => {+ const next = { ...prev };+ delete next[createSourceId(oldMetric.id, oldMetric.sourceType)];+ if (newMetric.name != null) {+ next[createSourceId(newMetric.id, newMetric.sourceType)] =+ newMetric.name;+ }+ return next;+ });+ },+ [onSwapMetric],+ );++ return {+ metricNames,+ metricNamesRef,+ handleAddMetric,+ handleRemoveMetric,+ handleSwapMetric,+ };+}diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/index.ts b/frontend/src/metabase/metrics-viewer/components/MetricSearch/index.tsindex 6184bc2dfa4..18017cbc645 100644--- a/frontend/src/metabase/metrics-viewer/components/MetricSearch/index.ts+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/index.ts@@ -1 +1 @@-export { MetricSearchInput as MetricSearch } from "./MetricSearchInput";+export { MetricSearchInput } from "./MetricSearchInput";diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/utils.ts b/frontend/src/metabase/metrics-viewer/components/MetricSearch/utils.tsindex b3825272b6d..7b1e85b39b2 100644--- a/frontend/src/metabase/metrics-viewer/components/MetricSearch/utils.ts+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/utils.ts@@ -1,25 +1,511 @@-import type { SelectedMetric } from "../../types/viewer-state";--export function getSelectedMetricIds(- selectedMetrics: SelectedMetric[],-): Set<number> {- return new Set(- selectedMetrics- .filter((metric) => metric.sourceType === "metric")- .map((metric) => metric.id),- );+import { t } from "ttag";++import type { MetricDefinition } from "metabase-lib/metric";+import * as LibMetric from "metabase-lib/metric";+import { MATH_OPERATORS, isMathOperator } from "metabase-types/api";++import type {+ ExpressionDefinitionEntry,+ ExpressionSubToken,+ MetricDefinitionEntry,+ MetricSourceId,+ MetricsViewerFormulaEntity,+} from "../../types/viewer-state";+import { isExpressionEntry, isMetricEntry } from "../../types/viewer-state";+import { stampMetricCounts } from "../../utils/expression";++export type MetricNameMap = Partial<Record<MetricSourceId, string>>;++/**+ * Returns an array of human-readable expression strings interleaved with numbers+ * identifying when metrics are used multiple times in the expression.+ */+export function buildExpressionForPill(+ tokens: ExpressionSubToken[],+ metricNames: MetricNameMap,+): (string | number)[] {+ const result: (string | number)[] = [];+ let curr = "";+ for (let i = 0; i < tokens.length; i++) {+ const token = tokens[i];+ const prev = tokens[i - 1];+ const needsSpace =+ i > 0 && prev?.type !== "open-paren" && token.type !== "close-paren";+ if (needsSpace) {+ curr += " ";+ }+ if (token.type === "open-paren") {+ curr += "(";+ } else if (token.type === "close-paren") {+ curr += ")";+ } else if (token.type === "operator") {+ curr += token.op;+ } else if (token.type === "metric") {+ const name = metricNames[token.sourceId];+ curr += name ?? "";+ if (token.count > 1) {+ result.push(curr);+ curr = "";+ result.push(token.count);+ }+ } else if (token.type === "constant") {+ curr += String(token.value);+ }+ }+ result.push(curr);+ return result;+}++/**+ * Builds a human-readable expression string from a single expression's sub-tokens+ */+export function buildExpressionText(+ tokens: ExpressionSubToken[],+ metricNames: MetricNameMap,+): string {+ return buildExpressionForPill(tokens, metricNames)+ .filter((x) => typeof x === "string")+ .join("");+}++export function buildFullText(+ formulaEntities: MetricsViewerFormulaEntity[],+ metricNames: MetricNameMap,+): string {+ return formulaEntities+ .map((entity) => {+ if (isExpressionEntry(entity)) {+ return buildExpressionText(entity.tokens, metricNames);+ }+ if (isMetricEntry(entity)) {+ return metricNames[entity.id] ?? "";+ }+ return "";+ })+ .join(", ");+}++const COMMA = ",";++const PAREN_DELIMITERS = ["(", ")"] as const;+const NON_COMMA_DELIMITERS = new Set<string>([+ ...MATH_OPERATORS,+ ...PAREN_DELIMITERS,+]);+const EXPRESSION_DELIMITERS = new Set<string>([...NON_COMMA_DELIMITERS, COMMA]);++/** Returns true for characters that form word continuations (letters, digits, underscore). */+function isWordChar(ch: string): boolean {+ return /\w/.test(ch);+}++/**+ * Extracts the "word" (potential metric name) at the given cursor position,+ * using expression delimiters as boundaries.+ *+ * Spaces are NOT delimiters so that multi-word metric names like "Page Views"+ * are returned as a single word. Surrounding whitespace is trimmed.+ *+ * When `metricEntries` is provided, commas are only treated as delimiters+ * when they are real item separators — i.e. the text before the comma forms+ * a complete token (known metric, number, or closing paren). This allows+ * metric names containing commas (e.g. "Revenue, Total") to be typed and+ * searched as a single word.+ */+export function getWordAtCursor(+ text: string,+ cursorPos: number,+ metricNames?: MetricNameMap,+): { word: string; start: number; end: number } {+ // Build a set of metric names (lowercased) for quick lookup.+ let metricNamesLower: Set<string> | null = null;+ if (metricNames && Object.values(metricNames).length > 0) {+ metricNamesLower = new Set(+ Object.values(metricNames)+ .map((name) => name?.toLowerCase() ?? "")+ .filter((n) => n.length > 0),+ );+ }++ /**+ * Decides whether the comma at `pos` is a separator (delimiter) rather+ * than part of a metric name being typed.+ *+ * A comma is a separator when the trimmed text before it ends with:+ * - a known metric name,+ * - a numeric constant, or+ * - a closing parenthesis.+ *+ * Otherwise the comma is likely inside a metric name the user is still+ * typing (e.g. "Revenue," as part of "Revenue, Total").+ */+ const isCommaASeparator = (commaPos: number): boolean => {+ if (!metricNamesLower) {+ return true; // no entries → fall back to always splitting on commas+ }++ const before = text.slice(0, commaPos).trimEnd();+ if (before.length === 0) {+ return true;+ }++ const lastCh = before[before.length - 1];+ // After a closing paren → separator+ if (lastCh === ")") {+ return true;+ }+ // After a digit → separator (number constant)+ if (/\d/.test(lastCh)) {+ return true;+ }+ // Check if `before` ends with a known metric name+ const beforeLower = before.toLowerCase();+ for (const name of metricNamesLower) {+ const charBeforeName = before[before.length - name.length - 1];+ const isAtTextStart = before.length === name.length;+ const hasDelimiterBefore =+ NON_COMMA_DELIMITERS.has(charBeforeName) ||+ charBeforeName === COMMA ||+ charBeforeName === " ";+ const endsWithMetricName =+ beforeLower.endsWith(name) && (isAtTextStart || hasDelimiterBefore);+ if (endsWithMetricName) {+ return true;+ }+ }+ return false;+ };++ const isDelimiter = (pos: number): boolean => {+ const ch = text[pos];+ if (NON_COMMA_DELIMITERS.has(ch)) {+ return true;+ }+ if (ch === COMMA) {+ return isCommaASeparator(pos);+ }+ return false;+ };++ let start = cursorPos;+ while (start > 0 && !isDelimiter(start - 1)) {+ start--;+ }++ let end = cursorPos;+ while (end < text.length && !isDelimiter(end)) {+ end++;+ }++ const rawWord = text.slice(start, end);+ const trimmedWord = rawWord.trim();+ const leadingSpaces = rawWord.length - rawWord.trimStart().length;++ return {+ word: trimmedWord,+ start: start + leadingSpaces,+ end: start + leadingSpaces + trimmedWord.length,+ };+}++/**+ * Returns positions of commas in the text that are NOT inside a metric token.+ * These are the real item separators. Metric names may contain commas (e.g.+ * "Revenue, Total") — those commas are consumed by the greedy metric matcher+ * in `parseFullTextWithPositions` and must not be treated as separators.+ */+function findSeparatorCommaPositions(+ text: string,+ allTokens: PositionedToken[],+): number[] {+ const metricRanges = allTokens.filter((t) => t.type === "metric");+ const commas: number[] = [];+ for (let i = 0; i < text.length; i++) {+ const isComma = text[i] === COMMA;+ const isInsideMetricToken = metricRanges.some(+ (r) => i >= r.from && i < r.to,+ );+ if (isComma && !isInsideMetricToken) {+ commas.push(i);+ }+ }+ return commas;+}++/**+ * Groups an array of positioned tokens into segments split by separator commas.+ */+function groupTokensBySegment(+ allTokens: PositionedToken[],+ separatorPositions: number[],+): PositionedToken[][] {+ const segments: PositionedToken[][] = [];+ let current: PositionedToken[] = [];+ let commaIdx = 0;++ for (const token of allTokens) {+ while (+ commaIdx < separatorPositions.length &&+ token.from > separatorPositions[commaIdx]+ ) {+ segments.push(current);+ current = [];+ commaIdx++;+ }+ current.push(token);+ }+ segments.push(current);+ return segments;+}++type MetricPositionedToken = PositionedToken & { type: "metric" };++type MetricSubToken = Extract<ExpressionSubToken, { type: "metric" }>;++export type MetricTokenVisit =+ | {+ kind: "standalone";+ positioned: MetricPositionedToken;+ entity: MetricDefinitionEntry;+ }+ | {+ kind: "expression";+ positioned: MetricPositionedToken;+ entity: ExpressionDefinitionEntry;+ exprToken: MetricSubToken;+ exprTokenIndex: number;+ };++/**+ * Parses text into segments aligned with entities, then calls `visitor`+ * for each metric token with its positioned counterpart and parent entity.+ */+export function traverseMetricTokens(+ text: string,+ metricNames: MetricNameMap,+ entities: MetricsViewerFormulaEntity[],+ visitor: (visit: MetricTokenVisit) => void,+): void {+ const allTokens = parseFullTextWithPositions(text, metricNames);+ const separators = findSeparatorCommaPositions(text, allTokens);+ const segments = groupTokensBySegment(allTokens, separators);++ let entityIndex = 0;+ for (const segmentTokens of segments) {+ if (segmentTokens.length === 0) {+ continue;+ }++ const entity = entities[entityIndex++];+ if (!entity) {+ continue;+ }++ const metricTokens = segmentTokens.filter(+ (token): token is MetricPositionedToken => token.type === "metric",+ );++ if (isMetricEntry(entity)) {+ const positioned = metricTokens[0];+ if (!positioned) {+ continue;+ }+ visitor({ kind: "standalone", positioned, entity });+ continue;+ }++ if (!isExpressionEntry(entity)) {+ continue;+ }++ let metricIdx = 0;+ for (let tokenIndex = 0; tokenIndex < entity.tokens.length; tokenIndex++) {+ const exprToken = entity.tokens[tokenIndex];+ if (exprToken.type !== "metric") {+ continue;+ }+ const positioned = metricTokens[metricIdx++];+ if (!positioned) {+ continue;+ }+ visitor({+ kind: "expression",+ positioned,+ entity,+ exprToken,+ exprTokenIndex: tokenIndex,+ });+ }+ }}-export function getSelectedMeasureIds(- selectedMetrics: SelectedMetric[],-): Set<number> {- return new Set(- selectedMetrics- .filter((metric) => metric.sourceType === "measure")- .map((metric) => metric.id),+/** Strip position info from a positioned token, dropping unknown tokens. */+function stripPositions(token: PositionedToken): ExpressionSubToken | null {+ switch (token.type) {+ case "metric":+ return { type: "metric", sourceId: token.sourceId, count: 0 };+ case "operator":+ return { type: "operator", op: token.op };+ case "constant":+ return { type: "constant", value: token.value };+ case "open-paren":+ return { type: "open-paren" };+ case "close-paren":+ return { type: "close-paren" };+ case "unknown":+ return null;+ }+}++/**+ * Parses a full expression text (with ", " separating items) into a+ * `MetricsViewerFormulaEntity[]`. Each comma-separated segment becomes+ * either a standalone metric entry (if it matches a single metric name) or+ * an expression entry (if it contains operators / multiple operands).+ *+ * Metric names are matched greedily, longest first, so names containing+ * operators (e.g. "Year-to-Date") or commas (e.g. "Revenue, Total") are+ * handled correctly — metrics are identified before commas are used as+ * separators.+ */+export function parseFullText(+ text: string,+ metricNames: MetricNameMap,+): MetricsViewerFormulaEntity[] {+ const allTokens = parseFullTextWithPositions(text, metricNames);+ const separators = findSeparatorCommaPositions(text, allTokens);+ const segments = groupTokensBySegment(allTokens, separators);+ const result: MetricsViewerFormulaEntity[] = [];++ for (const segmentTokens of segments) {+ if (segmentTokens.length === 0) {+ continue;+ }++ const subTokens = stampMetricCounts(+ segmentTokens+ .map(stripPositions)+ .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];+ if (name) {+ result.push({+ id: firstToken.sourceId,+ type: "metric",+ definition: null,+ });+ continue;+ }+ }++ // Multiple tokens or operators → expression entry+ const name = buildExpressionText(subTokens, metricNames);+ result.push({+ id: `expression:${name}`,+ type: "expression",+ name,+ tokens: subTokens,+ });+ }++ return result;+}++/**+ * Removes unmatched parentheses from a sub-token stream.+ */+export function removeUnmatchedParens(+ tokens: ExpressionSubToken[],+): ExpressionSubToken[] {+ const openStack: number[] = [];+ const matchedIndices = new Set<number>();++ tokens.forEach((token, i) => {+ if (token.type === "open-paren") {+ openStack.push(i);+ } else if (token.type === "close-paren") {+ if (openStack.length > 0) {+ matchedIndices.add(openStack.pop()!);+ matchedIndices.add(i);+ }+ }+ });++ const hasDangling = tokens.some(+ (token, i) =>+ (token.type === "open-paren" || token.type === "close-paren") &&+ !matchedIndices.has(i),+ );++ if (!hasDangling) {+ return tokens;+ }++ return tokens.filter((token, i) =>+ token.type !== "open-paren" && token.type !== "close-paren"+ ? true+ : matchedIndices.has(i),);}+/**+ * Removes unnecessary parentheses from a sub-token stream.+ * Parens are unnecessary when they contain 0 or 1 operand tokens.+ */+export function cleanupParens(+ tokens: ExpressionSubToken[],+): ExpressionSubToken[] {+ let current = tokens;+ let changed = true;++ while (changed) {+ changed = false;++ for (let i = 0; i < current.length; i++) {+ if (current[i].type !== "open-paren") {+ continue;+ }++ let depth = 1;+ let j = i + 1;+ while (j < current.length && depth > 0) {+ if (current[j].type === "open-paren") {+ depth++;+ } else if (current[j].type === "close-paren") {+ depth--;+ }+ j++;+ }++ if (depth !== 0) {+ continue;+ }++ const closeIdx = j - 1;+ const content = current.slice(i + 1, closeIdx);+ const operandCount = content.filter(+ (tok) => tok.type === "metric" || tok.type === "constant",+ ).length;++ if (operandCount <= 1) {+ current = [+ ...current.slice(0, i),+ ...content,+ ...current.slice(closeIdx + 1),+ ];+ changed = true;+ break;+ }+ }+ }++ return current;+}+export type ExcludeMetric = {id: number;sourceType: "metric" | "measure";@@ -30,19 +516,473 @@ type SearchResultLike = {model: "metric" | "measure";};+// ── Positioned token type (internal) ────────────────────────────────────────++export type PositionedToken = (+ | ExpressionSubToken+ | { type: "unknown"; text: string }+) & { from: number; to: number };++function isDigit(ch: string | undefined): boolean {+ return ch !== undefined && ch >= "0" && ch <= "9";+}++function skipDigits(text: string, index: number): number {+ while (index < text.length && isDigit(text[index])) {+ index++;+ }+ return index;+}++function consumeNumber(text: string, startIndex: number): number | null {+ let index = startIndex;++ const startsWithDot = text[index] === "." && isDigit(text[index + 1]);+ if (!startsWithDot && !isDigit(text[index])) {+ return null;+ }++ index = skipDigits(text, index);++ if (text[index] === "." && isDigit(text[index + 1])) {+ index = skipDigits(text, index + 1);+ }++ return index;+}++/** Same as the main parser but records character positions for each token. */+export function parseFullTextWithPositions(+ text: string,+ metricNames: MetricNameMap,+): PositionedToken[] {+ const sortedMetrics = Object.entries(metricNames)+ .map(([id, name]) => ({ id, name: (name ?? "").toLowerCase() }))+ .filter(+ (m): m is { id: MetricSourceId; name: string } =>+ (m.name?.length ?? 0) > 0,+ )+ .sort((a, b) => b.name.length - a.name.length);++ const lower = text.toLowerCase();+ const tokens: PositionedToken[] = [];+ let i = 0;++ while (i < text.length) {+ const ch = text[i];++ const isWhitespace = ch === " " || ch === "\t";+ if (isWhitespace) {+ i++;+ continue;+ }++ // Commas are item separators — tracked for position-based splitting+ // but NOT emitted as a token type (no more "separator" tokens).+ if (ch === COMMA) {+ i++;+ continue;+ }++ if (ch === "(") {+ tokens.push({ type: "open-paren", from: i, to: i + 1 });+ i++;+ continue;+ }++ if (ch === ")") {+ tokens.push({ type: "close-paren", from: i, to: i + 1 });+ i++;+ continue;+ }++ if (isMathOperator(ch)) {+ const lastToken = tokens.length > 0 ? tokens[tokens.length - 1] : null;+ const isUnaryContext =+ lastToken === null ||+ lastToken.type === "operator" ||+ lastToken.type === "open-paren";++ if (ch === "-" && isUnaryContext) {+ const endIndex = consumeNumber(text, i + 1);+ if (endIndex !== null) {+ tokens.push({+ type: "constant",+ value: parseFloat(text.slice(i, endIndex)),+ from: i,+ to: endIndex,+ });+ i = endIndex;+ continue;+ }+ }++ tokens.push({+ type: "operator",+ op: ch,+ from: i,+ to: i + 1,+ });+ i++;+ continue;+ }++ const isNumberStart = isDigit(ch) || (ch === "." && isDigit(text[i + 1]));+ if (isNumberStart) {+ const endIndex = consumeNumber(text, i)!;+ tokens.push({+ type: "constant",+ value: parseFloat(text.slice(i, endIndex)),+ from: i,+ to: endIndex,+ });+ i = endIndex;+ continue;+ }++ let matched = false;+ for (const { name, id } of sortedMetrics) {+ if (lower.startsWith(name, i)) {+ const nextI = i + name.length;+ const nextCh = text[nextI];+ // Accept the match unless the next character continues an+ // alphanumeric word (e.g. "Revenue" inside "Revenues").+ const isWordBoundary =+ !nextCh || !isWordChar(nextCh) || !isWordChar(name[name.length - 1]);+ if (isWordBoundary) {+ tokens.push({+ type: "metric",+ sourceId: id,+ count: 0,+ from: i,+ to: nextI,+ });+ i = nextI;+ matched = true;+ break;+ }+ }+ }++ if (!matched) {+ // Collect consecutive unrecognized characters into a single unknown token+ const start = i;+ i++;+ while (i < text.length) {+ const char = text[i];+ const isTokenBoundary =+ EXPRESSION_DELIMITERS.has(char) || char === " " || isDigit(char);+ if (isTokenBoundary) {+ break;+ }+ // Check if a metric name starts here — if so, stop the unknown span+ let metricStartsHere = false;+ for (const { name } of sortedMetrics) {+ if (lower.startsWith(name, i)) {+ const nameEndIndex = i + name.length;+ const afterNameChar = text[nameEndIndex];+ const isMetricBoundary =+ !afterNameChar ||+ afterNameChar === " " ||+ EXPRESSION_DELIMITERS.has(afterNameChar);+ if (isMetricBoundary) {+ metricStartsHere = true;+ break;+ }+ }+ }+ if (metricStartsHere) {+ break;+ }+ i++;+ }+ tokens.push({+ type: "unknown",+ text: text.slice(start, i),+ from: start,+ to: i,+ });+ }+ }++ return tokens;+}++export type ErrorRange = { from: number; to: number; message: string };++/**+ * Returns character ranges of invalid tokens in the expression text, each+ * annotated with an error message. Used to apply red-underline decorations+ * and hover tooltips in the CodeMirror editor.+ *+ * Splits by comma to validate each item independently.+ */+export function findInvalidRanges(+ text: string,+ metricNames: MetricNameMap,+): ErrorRange[] {+ const allTokens = parseFullTextWithPositions(text, metricNames);+ const separators = findSeparatorCommaPositions(text, allTokens);+ const segments = groupTokensBySegment(allTokens, separators);++ const invalid: ErrorRange[] = [];++ for (const itemTokens of segments) {+ if (itemTokens.length === 0) {+ continue;+ }++ const itemInvalid: ErrorRange[] = [];++ // Unmatched parentheses+ const openStack: PositionedToken[] = [];+ for (const token of itemTokens) {+ if (token.type === "open-paren") {+ openStack.push(token);+ } else if (token.type === "close-paren") {+ if (openStack.length === 0) {+ itemInvalid.push({+ from: token.from,+ to: token.to,+ message: t`Unmatched closing parenthesis`,+ });+ } else {+ openStack.pop();+ }+ }+ }+ for (const token of openStack) {+ itemInvalid.push({+ from: token.from,+ to: token.to,+ message: t`Unmatched opening parenthesis`,+ });+ }++ // Token predecessor validity+ let prevSignificant: PositionedToken | null = null;+ for (const token of itemTokens) {+ if (token.type === "unknown") {+ prevSignificant = token;+ continue;+ }++ const prevType = prevSignificant?.type ?? null;++ if (+ token.type === "metric" ||+ token.type === "constant" ||+ token.type === "open-paren"+ ) {+ if (+ prevType !== null &&+ prevType !== "open-paren" &&+ prevType !== "operator" &&+ prevType !== "unknown"+ ) {+ itemInvalid.push({+ from: token.from,+ to: token.to,+ message: t`Missing operator`,+ });+ }+ } else if (token.type === "operator") {+ if (+ prevType !== "metric" &&+ prevType !== "constant" &&+ prevType !== "close-paren" &&+ prevType !== "unknown"+ ) {+ itemInvalid.push({+ from: token.from,+ to: token.to,+ message: t`Missing operand`,+ });+ }+ } else if (token.type === "close-paren") {+ if (+ prevType !== "metric" &&+ prevType !== "constant" &&+ prevType !== "close-paren" &&+ prevType !== "unknown"+ ) {+ itemInvalid.push({+ from:+ prevType === "open-paren"+ ? (prevSignificant?.from ?? token.from)+ : token.from,+ to: token.to,+ message:+ prevType === "open-paren"+ ? t`Empty parentheses`+ : t`Missing operand before closing parenthesis`,+ });+ }+ }+ prevSignificant = token;+ }++ if (prevSignificant?.type === "operator") {+ itemInvalid.push({+ from: prevSignificant.from,+ to: prevSignificant.to,+ message: t`Expression cannot end with an operator`,+ });+ }++ for (const token of itemTokens) {+ if (token.type === "unknown") {+ itemInvalid.push({+ from: token.from,+ to: token.to,+ message: t`Unknown token: "${token.text}"`,+ });+ }+ }++ const hasMetric = itemTokens.some((tok) => tok.type === "metric");+ if (!hasMetric && itemInvalid.length === 0) {+ itemInvalid.push({+ from: itemTokens[0].from,+ to: itemTokens[itemTokens.length - 1].to,+ message: t`Expression must contain at least one metric`,+ });+ }++ invalid.push(...itemInvalid);+ }++ return invalid;+}+export function filterSearchResults<T extends SearchResultLike>(results: T[],- selectedMetricIds: Set<number>,- selectedMeasureIds: Set<number>,+ selectedMetricIds?: Set<number>,+ selectedMeasureIds?: Set<number>,excludeMetric?: ExcludeMetric,): T[] {- return results.filter(- (result) =>- (result.model === "metric"- ? !selectedMetricIds.has(result.id)- : !selectedMeasureIds.has(result.id)) &&- (!excludeMetric ||- result.id !== excludeMetric.id ||- result.model !== excludeMetric.sourceType),+ return results.filter((result) => {+ const isAlreadySelected =+ result.model === "metric"+ ? selectedMetricIds?.has(result.id)+ : selectedMeasureIds?.has(result.id);+ const isExcluded =+ excludeMetric &&+ result.id === excludeMetric.id &&+ result.model === excludeMetric.sourceType;+ return !isAlreadySelected && !isExcluded;+ });+}++export type MetricIdentityEntry = {+ sourceId: MetricSourceId;+ from: number;+ to: number;+ definition: MetricDefinition | null;+ slotIndex: number;+};++export function stripDefinitionProjections(+ definition: MetricDefinition,+): MetricDefinition {+ const projections = LibMetric.projections(definition);+ if (projections.length === 0) {+ return definition;+ }+ return projections.reduce(+ (def, projection) => LibMetric.removeClause(def, projection),+ definition,);}++const getPositionKey = (from: number, to: number) => `${from}:${to}`;++export interface ApplyTrackedDefinitionsResult {+ entities: MetricsViewerFormulaEntity[];+ /** Maps old slot index → new slot index for matched metric tokens. */+ slotMapping: Map<number, number>;+}++export function applyTrackedDefinitions(+ newEntities: MetricsViewerFormulaEntity[],+ trackedIdentities: MetricIdentityEntry[],+ text: string,+ metricNames: MetricNameMap,+): ApplyTrackedDefinitionsResult {+ const identityByPosition = new Map<+ string,+ { definition: MetricDefinition | null; slotIndex: number }+ >();+ for (const identity of trackedIdentities) {+ identityByPosition.set(getPositionKey(identity.from, identity.to), {+ definition: identity.definition,+ slotIndex: identity.slotIndex,+ });+ }++ const metricOverrides = new Map<+ MetricsViewerFormulaEntity,+ MetricDefinition | null+ >();+ const exprTokenOverrides = new Map<+ MetricsViewerFormulaEntity,+ Map<number, MetricDefinition | undefined>+ >();+ 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);+ }++ if (!tracked) {+ 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);+ });++ const entities = newEntities.map((entity) => {+ if (metricOverrides.has(entity)) {+ return { ...entity, definition: metricOverrides.get(entity) ?? null };+ }++ const tokenMap = exprTokenOverrides.get(entity);+ if (tokenMap && isExpressionEntry(entity)) {+ const newTokens = entity.tokens.map((token, index) => {+ if (!tokenMap.has(index)) {+ return token;+ }+ return { ...token, definition: tokenMap.get(index) };+ });+ const hasChanges = newTokens.some(+ (token, index) => token !== entity.tokens[index],+ );+ return hasChanges ? { ...entity, tokens: newTokens } : entity;+ }++ return entity;+ });++ return { entities, slotMapping };+}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 4a5b1aabe77..141d5f18c16 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@@ -1,68 +1,40 @@-import type { SelectedMetric } from "../../types/viewer-state";+import * as LibMetric from "metabase-lib/metric";+import type {+ ExpressionDefinitionEntry,+ ExpressionSubToken,+ MetricDefinitionEntry,+ MetricSourceId,+ MetricsViewerFormulaEntity,+} from "../../types/viewer-state";+import { isExpressionEntry } from "../../types/viewer-state";import {+ GEO_METRIC,+ REVENUE_METRIC,+ createMetricMetadata,+ setupDefinition,+ setupDefinitionWithBreakout,+} from "../../utils/__tests__/test-helpers";++import type { MetricIdentityEntry, MetricNameMap } from "./utils";+import {+ applyTrackedDefinitions,+ buildExpressionText,+ cleanupParens,filterSearchResults,- getSelectedMeasureIds,- getSelectedMetricIds,+ findInvalidRanges,+ getWordAtCursor,+ parseFullText,} from "./utils";-function makeSelectedMetric(- overrides: Partial<SelectedMetric> &- Pick<SelectedMetric, "id" | "sourceType">,-): SelectedMetric {- return { name: "Test", ...overrides };-}+jest.mock("../../utils/definition-builder", () => ({+ getDefinitionName: (def: any) => def?.["display-name"] ?? null,+}));function makeSearchResult(id: number, model: "metric" | "measure") {return { id, model, name: `Result ${id}` };}-describe("getSelectedMetricIds", () => {- it("returns Set of IDs for metrics only", () => {- const selected: SelectedMetric[] = [- makeSelectedMetric({ id: 1, sourceType: "metric" }),- makeSelectedMetric({ id: 2, sourceType: "measure" }),- makeSelectedMetric({ id: 3, sourceType: "metric" }),- ];- const result = getSelectedMetricIds(selected);- expect(result).toEqual(new Set([1, 3]));- });-- it("returns empty Set for empty array", () => {- expect(getSelectedMetricIds([])).toEqual(new Set());- });-- it("returns empty Set when no metrics exist", () => {- const selected: SelectedMetric[] = [- makeSelectedMetric({ id: 1, sourceType: "measure" }),- ];- expect(getSelectedMetricIds(selected)).toEqual(new Set());- });-});--describe("getSelectedMeasureIds", () => {- it("returns Set of IDs for measures only", () => {- const selected: SelectedMetric[] = [- makeSelectedMetric({ id: 1, sourceType: "metric" }),- makeSelectedMetric({ id: 2, sourceType: "measure" }),- makeSelectedMetric({ id: 5, sourceType: "measure" }),- ];- const result = getSelectedMeasureIds(selected);- expect(result).toEqual(new Set([2, 5]));- });-- it("returns empty Set for empty array", () => {- expect(getSelectedMeasureIds([])).toEqual(new Set());- });-- it("returns empty Set when no measures exist", () => {- const selected: SelectedMetric[] = [- makeSelectedMetric({ id: 1, sourceType: "metric" }),- ];- expect(getSelectedMeasureIds(selected)).toEqual(new Set());- });-});-describe("filterSearchResults", () => {const results = [makeSearchResult(1, "metric"),@@ -123,3 +95,1133 @@ describe("filterSearchResults", () => {]);});});++describe("cleanupParens", () => {+ const m = (sourceId: MetricSourceId): ExpressionSubToken => ({+ type: "metric",+ sourceId,+ count: 1,+ });+ const op = (o: "+" | "-" | "*" | "/"): ExpressionSubToken => ({+ type: "operator",+ op: o,+ });+ const open: ExpressionSubToken = { type: "open-paren" };+ const close: ExpressionSubToken = { type: "close-paren" };++ it("returns empty array unchanged", () => {+ expect(cleanupParens([])).toEqual([]);+ });++ it("returns same reference when no cleanup needed", () => {+ const tokens: ExpressionSubToken[] = [+ m("metric:1"),+ op("+"),+ m("metric:2"),+ ];+ expect(cleanupParens(tokens)).toBe(tokens);+ });++ it("removes empty parentheses", () => {+ expect(cleanupParens([open, close])).toEqual([]);+ });++ it("removes parentheses around a single metric", () => {+ expect(cleanupParens([open, m("metric:1"), close])).toEqual([+ m("metric:1"),+ ]);+ });++ it("keeps parentheses around multiple metrics", () => {+ const tokens = [open, m("metric:1"), op("+"), m("metric:2"), close];+ expect(cleanupParens(tokens)).toEqual(tokens);+ });++ it("removes nested single-metric parens", () => {+ // ((A)) → A+ expect(cleanupParens([open, open, m("metric:1"), close, close])).toEqual([+ m("metric:1"),+ ]);+ });++ it("removes inner single-metric parens but keeps outer multi-metric parens", () => {+ // (A + (B)) → (A + B)+ expect(+ cleanupParens([+ open,+ m("metric:1"),+ op("+"),+ open,+ m("metric:2"),+ close,+ close,+ ]),+ ).toEqual([open, m("metric:1"), op("+"), m("metric:2"), close]);+ });++ it("removes single-metric parens in a larger expression", () => {+ // (A) + B → A + B+ expect(+ cleanupParens([open, m("metric:1"), close, op("+"), m("metric:2")]),+ ).toEqual([m("metric:1"), op("+"), m("metric:2")]);+ });++ it("removes multiple independent single-metric paren groups", () => {+ // (A) + (B) → A + B+ expect(+ cleanupParens([+ open,+ m("metric:1"),+ close,+ op("+"),+ open,+ m("metric:2"),+ close,+ ]),+ ).toEqual([m("metric:1"), op("+"), m("metric:2")]);+ });++ it("keeps parentheses around a metric and a constant (two operands)", () => {+ // (A * 0.85) stays — two operands inside+ const k = (v: number): ExpressionSubToken => ({+ type: "constant",+ value: v,+ });+ expect(+ cleanupParens([open, m("metric:1"), op("*"), k(0.85), close]),+ ).toEqual([open, m("metric:1"), op("*"), k(0.85), close]);+ });++ it("removes parentheses around a lone constant (one operand)", () => {+ const k = (v: number): ExpressionSubToken => ({+ type: "constant",+ value: v,+ });+ expect(cleanupParens([open, k(1), close])).toEqual([k(1)]);+ });+});++// ---------------------------------------------------------------------------+// buildExpressionText — constants+// ---------------------------------------------------------------------------++describe("buildExpressionText", () => {+ const metricNames: MetricNameMap = {+ "metric:1": "Revenue",+ "metric:2": "Costs",+ };++ const m = (sourceId: MetricSourceId): ExpressionSubToken => ({+ type: "metric",+ sourceId,+ count: 1,+ });+ const op = (o: "+" | "-" | "*" | "/"): ExpressionSubToken => ({+ type: "operator",+ op: o,+ });+ const k = (v: number): ExpressionSubToken => ({+ type: "constant",+ value: v,+ });+ const open: ExpressionSubToken = { type: "open-paren" };+ const close: ExpressionSubToken = { type: "close-paren" };++ it("renders a metric scaled by a decimal constant", () => {+ expect(+ buildExpressionText([m("metric:1"), op("*"), k(0.85)], metricNames),+ ).toBe("Revenue * 0.85");+ });++ it("renders an integer constant", () => {+ expect(+ buildExpressionText([m("metric:1"), op("*"), k(100)], metricNames),+ ).toBe("Revenue * 100");+ });++ it("renders constants inside parentheses", () => {+ // (Revenue + Costs) * 0.85+ expect(+ buildExpressionText(+ [open, m("metric:1"), op("+"), m("metric:2"), close, op("*"), k(0.85)],+ metricNames,+ ),+ ).toBe("(Revenue + Costs) * 0.85");+ });++ it("renders a constant divided by a metric", () => {+ expect(+ buildExpressionText([k(1), op("/"), m("metric:1")], metricNames),+ ).toBe("1 / Revenue");+ });+});++// ---------------------------------------------------------------------------+// parseFullText — numeric literals+// ---------------------------------------------------------------------------++describe("parseFullText — numeric literal parsing", () => {+ const metricNames: MetricNameMap = {+ "metric:1": "Revenue",+ "metric:2": "Costs",+ };++ const m = (sourceId: MetricSourceId): ExpressionSubToken => ({+ type: "metric",+ sourceId,+ count: 1,+ });+ const op = (o: "+" | "-" | "*" | "/"): ExpressionSubToken => ({+ type: "operator",+ op: o,+ });+ const k = (v: number): ExpressionSubToken => ({+ type: "constant",+ value: v,+ });++ it("parses a metric multiplied by a decimal constant", () => {+ const result = parseFullText("Revenue * 0.85", metricNames);+ expect(result).toHaveLength(1);+ expect(result[0]).toMatchObject({+ type: "expression",+ tokens: [m("metric:1"), op("*"), k(0.85)],+ });+ });++ it("parses a metric multiplied by an integer constant", () => {+ const result = parseFullText("Revenue * 100", metricNames);+ expect(result).toHaveLength(1);+ expect(result[0]).toMatchObject({+ type: "expression",+ tokens: [m("metric:1"), op("*"), k(100)],+ });+ });++ it("parses a constant on the left side", () => {+ const result = parseFullText("0.5 * Revenue", metricNames);+ expect(result).toHaveLength(1);+ expect(result[0]).toMatchObject({+ type: "expression",+ tokens: [k(0.5), op("*"), m("metric:1")],+ });+ });++ it("parses a constant inside parentheses — (Revenue + Costs) * 0.85", () => {+ const result = parseFullText("(Revenue + Costs) * 0.85", metricNames);+ expect(result).toHaveLength(1);+ expect(result[0]).toMatchObject({+ type: "expression",+ tokens: [+ { type: "open-paren" },+ m("metric:1"),+ op("+"),+ m("metric:2"),+ { type: "close-paren" },+ op("*"),+ k(0.85),+ ],+ });+ });++ it("parses multiple constants in one expression", () => {+ // 0.5 * Revenue + 0.5 * Costs+ const result = parseFullText("0.5 * Revenue + 0.5 * Costs", metricNames);+ expect(result).toHaveLength(1);+ expect(result[0]).toMatchObject({+ type: "expression",+ tokens: [+ k(0.5),+ op("*"),+ m("metric:1"),+ op("+"),+ k(0.5),+ op("*"),+ m("metric:2"),+ ],+ });+ });++ 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);+ expect(result).toHaveLength(1);+ expect(result[0]).toMatchObject({+ type: "expression",+ tokens: [k(1), op("+"), m("metric:1")],+ });+ });++ it("parses a leading-dot decimal like .5", () => {+ const result = parseFullText(".5 * Revenue", metricNames);+ expect(result).toHaveLength(1);+ expect(result[0]).toMatchObject({+ type: "expression",+ tokens: [k(0.5), op("*"), m("metric:1")],+ });+ });++ it("parses a metric multiplied by a leading-dot decimal", () => {+ const result = parseFullText("Revenue * .85", metricNames);+ expect(result).toHaveLength(1);+ expect(result[0]).toMatchObject({+ type: "expression",+ tokens: [m("metric:1"), op("*"), k(0.85)],+ });+ });++ it("parses a negative leading-dot decimal", () => {+ const result = parseFullText("-.5 * Revenue", metricNames);+ expect(result).toHaveLength(1);+ expect(result[0]).toMatchObject({+ type: "expression",+ tokens: [k(-0.5), op("*"), m("metric:1")],+ });+ });++ 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);+ expect(result).toHaveLength(1);+ expect(result[0]).toMatchObject({+ type: "expression",+ tokens: [k(1)],+ });+ });++ it("parses constants and metrics as separate items separated by a comma", () => {+ // "Revenue * 0.85, Costs"+ const result = parseFullText("Revenue * 0.85, Costs", metricNames);+ expect(result).toHaveLength(2);+ expect(result[0]).toMatchObject({+ type: "expression",+ tokens: [m("metric:1"), op("*"), k(0.85)],+ });+ // "Costs" is a standalone metric+ expect(result[1]).toMatchObject({+ type: "metric",+ id: "metric:2",+ });+ });++ it("round-trips through buildExpressionText", () => {+ const text = "(Revenue + Costs) * 0.85";+ const result = parseFullText(text, metricNames);+ expect(result).toHaveLength(1);+ const entry = result[0];+ if (entry.type === "expression") {+ // eslint-disable-next-line jest/no-conditional-expect+ expect(buildExpressionText(entry.tokens, metricNames)).toBe(text);+ } else {+ throw new Error("Expected expression entry");+ }+ });+});++// ---------------------------------------------------------------------------+// parseFullText — negative numbers+// ---------------------------------------------------------------------------++describe("parseFullText — negative numbers", () => {+ const metricNames: MetricNameMap = {+ "metric:1": "Revenue",+ "metric:2": "Costs",+ };++ const metric = (sourceId: MetricSourceId): ExpressionSubToken => ({+ type: "metric",+ sourceId,+ count: 1,+ });+ const op = (o: "+" | "-" | "*" | "/"): ExpressionSubToken => ({+ type: "operator",+ op: o,+ });+ const constant = (v: number): ExpressionSubToken => ({+ type: "constant",+ value: v,+ });+ const open: ExpressionSubToken = { type: "open-paren" };+ const close: ExpressionSubToken = { type: "close-paren" };++ it("parses a standalone negative integer", () => {+ const result = parseFullText("-50", metricNames);+ expect(result).toEqual([+ {+ id: "expression:-50",+ type: "expression",+ name: "-50",+ tokens: [constant(-50)],+ },+ ]);+ });++ it("parses metric plus negative constant", () => {+ const result = parseFullText("Revenue + -50", metricNames);+ expect(result).toEqual([+ {+ id: "expression:Revenue + -50",+ type: "expression",+ name: "Revenue + -50",+ tokens: [metric("metric:1"), op("+"), constant(-50)],+ },+ ]);+ });++ it("parses metric multiplied by negative decimal", () => {+ const result = parseFullText("Revenue * -0.85", metricNames);+ expect(result).toEqual([+ {+ id: "expression:Revenue * -0.85",+ type: "expression",+ name: "Revenue * -0.85",+ tokens: [metric("metric:1"), op("*"), constant(-0.85)],+ },+ ]);+ });++ it("parses negative constant at the start of expression", () => {+ const result = parseFullText("-50 * Revenue", metricNames);+ expect(result).toEqual([+ {+ id: "expression:-50 * Revenue",+ type: "expression",+ name: "-50 * Revenue",+ tokens: [constant(-50), op("*"), metric("metric:1")],+ },+ ]);+ });++ it("parses negative constant after open-paren", () => {+ const result = parseFullText("(-50 + Revenue)", metricNames);+ expect(result).toEqual([+ {+ id: "expression:(-50 + Revenue)",+ type: "expression",+ name: "(-50 + Revenue)",+ tokens: [open, constant(-50), op("+"), metric("metric:1"), close],+ },+ ]);+ });++ it("parses subtraction of a negative constant", () => {+ const result = parseFullText("Revenue - -50", metricNames);+ expect(result).toEqual([+ {+ id: "expression:Revenue - -50",+ type: "expression",+ name: "Revenue - -50",+ tokens: [metric("metric:1"), op("-"), constant(-50)],+ },+ ]);+ });++ it("round-trips negative constants through buildExpressionText", () => {+ const text = "Revenue + -50";+ const result = parseFullText(text, metricNames);+ expect(result).toHaveLength(1);+ const entry = result[0];+ if (entry.type === "expression") {+ // eslint-disable-next-line jest/no-conditional-expect+ expect(buildExpressionText(entry.tokens, metricNames)).toBe(text);+ } else {+ throw new Error("Expected expression entry");+ }+ });++ it.each([+ "-50 * Revenue",+ "Revenue + -50",+ "Revenue - -50",+ "(-50 + Revenue)",+ "Revenue * -0.85",+ ])("does not report validation errors for: %s", (text) => {+ expect(findInvalidRanges(text, metricNames)).toEqual([]);+ });++ it("parses metric minus negative constant without spaces (Revenue--50)", () => {+ const result = parseFullText("Revenue--50", metricNames);+ expect(result).toEqual([+ {+ id: "expression:Revenue - -50",+ type: "expression",+ name: "Revenue - -50",+ tokens: [metric("metric:1"), op("-"), constant(-50)],+ },+ ]);+ });++ it("parses metric minus negative decimal without spaces (Revenue--0.5)", () => {+ const result = parseFullText("Revenue--0.5", metricNames);+ expect(result).toEqual([+ {+ id: "expression:Revenue - -0.5",+ type: "expression",+ name: "Revenue - -0.5",+ tokens: [metric("metric:1"), op("-"), constant(-0.5)],+ },+ ]);+ });++ it("does not report validation errors for Revenue--50", () => {+ expect(findInvalidRanges("Revenue--50", metricNames)).toEqual([]);+ });++ it("still treats minus as binary operator after a metric", () => {+ const result = parseFullText("Revenue - 50", metricNames);+ expect(result).toEqual([+ {+ id: "expression:Revenue - 50",+ type: "expression",+ name: "Revenue - 50",+ tokens: [metric("metric:1"), op("-"), constant(50)],+ },+ ]);+ });++ it("still treats minus as binary operator after a constant", () => {+ const result = parseFullText("100 - Revenue", metricNames);+ expect(result).toEqual([+ {+ id: "expression:100 - Revenue",+ type: "expression",+ name: "100 - Revenue",+ tokens: [constant(100), op("-"), metric("metric:1")],+ },+ ]);+ });+});++// ---------------------------------------------------------------------------+// parseFullText — metric names containing commas+// ---------------------------------------------------------------------------++describe("parseFullText — metric names with commas", () => {+ const m = (sourceId: MetricSourceId): ExpressionSubToken => ({+ type: "metric",+ sourceId,+ count: 1,+ });+ const op = (o: "+" | "-" | "*" | "/"): ExpressionSubToken => ({+ type: "operator",+ op: o,+ });+ const k = (v: number): ExpressionSubToken => ({+ type: "constant",+ value: v,+ });++ it("parses a single metric whose name contains a comma", () => {+ const names: MetricNameMap = {+ "metric:10": "Revenue, Total",+ "metric:2": "Costs",+ };+ const result = parseFullText("Revenue, Total", names);+ expect(result).toHaveLength(1);+ expect(result[0]).toMatchObject({ type: "metric", id: "metric:10" });+ });++ it("parses metric-with-comma followed by another metric", () => {+ const names: MetricNameMap = {+ "metric:10": "Revenue, Total",+ "metric:2": "Costs",+ };+ 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" });+ });++ it("parses metric-with-comma in an expression", () => {+ const names: MetricNameMap = {+ "metric:10": "Revenue, Total",+ "metric:2": "Costs",+ };+ const result = parseFullText("Revenue, Total + Costs", names);+ expect(result).toHaveLength(1);+ expect(result[0]).toMatchObject({+ type: "expression",+ tokens: [m("metric:10"), op("+"), m("metric:2")],+ });+ });++ it("parses two metrics whose names each contain commas", () => {+ const names: MetricNameMap = {+ "metric:10": "Revenue, Total",+ "metric:11": "Costs, Annual",+ };+ 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" });+ });++ it("prefers longer metric name over shorter one when both match", () => {+ // "Revenue, Total" should match as one metric, not "Revenue" + separator+ const names: MetricNameMap = {+ "metric:10": "Revenue, Total",+ "metric:1": "Revenue",+ "metric:2": "Costs",+ };+ 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" });+ });++ 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);+ expect(result).toHaveLength(2);+ expect(result[0]).toMatchObject({ type: "metric", id: "metric:1" });+ expect(result[1]).toMatchObject({ type: "metric", id: "metric:2" });+ });++ it("handles metric-with-comma multiplied by a constant", () => {+ const names: MetricNameMap = { "metric:10": "Revenue, Total" };+ const result = parseFullText("Revenue, Total * 0.85", names);+ expect(result).toHaveLength(1);+ expect(result[0]).toMatchObject({+ type: "expression",+ tokens: [m("metric:10"), op("*"), k(0.85)],+ });+ });+});++// ---------------------------------------------------------------------------+// findInvalidRanges — unknown token detection+// ---------------------------------------------------------------------------++describe("findInvalidRanges — unknown token detection", () => {+ const metricNames: MetricNameMap = {+ "metric:1": "Revenue",+ "metric:2": "Costs",+ };++ it("returns no errors for valid expression", () => {+ expect(findInvalidRanges("Revenue + Costs", metricNames)).toEqual([]);+ });++ it("returns no errors for valid expression with constant", () => {+ expect(findInvalidRanges("Revenue * 0.85", metricNames)).toEqual([]);+ });++ it("flags a single unknown word", () => {+ const errors = findInvalidRanges("Revenue + xyz", metricNames);+ expect(errors).toHaveLength(1);+ expect(errors[0]).toMatchObject({+ from: 10,+ to: 13,+ message: expect.stringContaining("xyz"),+ });+ });++ it("flags unknown text that is not a known metric", () => {+ const errors = findInvalidRanges("Foo", metricNames);+ expect(errors).toHaveLength(1);+ expect(errors[0]).toMatchObject({+ message: expect.stringContaining("Foo"),+ });+ });++ it("flags multiple unknown tokens in different segments", () => {+ const errors = findInvalidRanges("abc, def", metricNames);+ expect(errors.length).toBeGreaterThanOrEqual(2);+ });++ it("flags unknown token mixed with valid tokens", () => {+ const errors = findInvalidRanges("Revenue + unknown + Costs", metricNames);+ expect(errors).toHaveLength(1);+ expect(errors[0]).toMatchObject({+ message: expect.stringContaining("unknown"),+ });+ });++ it("does not flag numbers as unknown", () => {+ expect(findInvalidRanges("Revenue * 100", metricNames)).toEqual([]);+ });++ it("does not flag parentheses as unknown", () => {+ expect(findInvalidRanges("(Revenue + Costs)", metricNames)).toEqual([]);+ });++ it("does not flag operators as unknown", () => {+ expect(findInvalidRanges("Revenue + Costs - Revenue", metricNames)).toEqual(+ [],+ );+ });++ it("flags unknown token at the start of expression", () => {+ const errors = findInvalidRanges("xyz + Revenue", metricNames);+ expect(errors).toHaveLength(1);+ expect(errors[0]).toMatchObject({+ from: 0,+ to: 3,+ message: expect.stringContaining("xyz"),+ });+ });++ it("returns both structural and unknown errors", () => {+ // "xyz +" has an unknown token AND a trailing operator+ const errors = findInvalidRanges("xyz +", metricNames);+ expect(errors.length).toBeGreaterThanOrEqual(2);+ const messages = errors.map((e) => e.message);+ expect(messages.some((m) => m.includes("xyz"))).toBe(true);+ expect(messages.some((m) => m.includes("end with an operator"))).toBe(true);+ });++ 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);+ expect(errors).toHaveLength(1);+ expect(errors[0]).toMatchObject({+ from: 26,+ to: 29,+ message: expect.stringContaining("!!!"),+ });+ });+});++// ---------------------------------------------------------------------------+// findInvalidRanges — predecessor validation+// ---------------------------------------------------------------------------++describe("findInvalidRanges — predecessor validation", () => {+ const metricNames: MetricNameMap = {+ "metric:1": "Revenue",+ "metric:2": "Costs",+ };++ it("flags missing operator between metric and constant", () => {+ const errors = findInvalidRanges("Revenue 2", metricNames);+ expect(errors).toHaveLength(1);+ expect(errors[0]).toMatchObject({+ from: 8,+ to: 9,+ message: expect.stringContaining("Missing operator"),+ });+ });++ it("flags missing operator between two metrics", () => {+ const errors = findInvalidRanges("Revenue Costs", metricNames);+ expect(errors).toHaveLength(1);+ expect(errors[0]).toMatchObject({+ from: 8,+ to: 13,+ message: expect.stringContaining("Missing operator"),+ });+ });++ it("flags missing operator between constant and metric", () => {+ const errors = findInvalidRanges("2 Revenue", metricNames);+ expect(errors).toHaveLength(1);+ expect(errors[0]).toMatchObject({+ from: 2,+ to: 9,+ message: expect.stringContaining("Missing operator"),+ });+ });++ it("flags missing operator between close-paren and metric", () => {+ const errors = findInvalidRanges("(Revenue + Costs) Revenue", metricNames);+ expect(errors).toHaveLength(1);+ expect(errors[0]).toMatchObject({+ from: 18,+ to: 25,+ message: expect.stringContaining("Missing operator"),+ });+ });++ it("flags operator before closing parenthesis", () => {+ const errors = findInvalidRanges("(Revenue +)", metricNames);+ expect(errors).toHaveLength(1);+ expect(errors[0]).toMatchObject({+ from: 10,+ to: 11,+ message: expect.stringContaining("closing parenthesis"),+ });+ });++ it("flags consecutive operators", () => {+ const errors = findInvalidRanges("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);+ 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);+ 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);+ 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);+ 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);+ expect(errors).toHaveLength(1);+ expect(errors[0]).toMatchObject({+ message: expect.stringContaining("at least one metric"),+ });+ });++ it("flags unmatched opening parenthesis", () => {+ const errors = findInvalidRanges("(Revenue + Costs", metricNames);+ expect(errors).toHaveLength(1);+ expect(errors[0]).toMatchObject({+ from: 0,+ to: 1,+ message: expect.stringContaining("Unmatched opening parenthesis"),+ });+ });++ it("flags unmatched closing parenthesis", () => {+ const errors = findInvalidRanges("Revenue + Costs)", metricNames);+ expect(errors).toHaveLength(1);+ expect(errors[0]).toMatchObject({+ from: 15,+ to: 16,+ message: expect.stringContaining("Unmatched closing parenthesis"),+ });+ });++ it("accepts valid nested parentheses", () => {+ expect(findInvalidRanges("(2 * (Revenue + Costs))", metricNames)).toEqual(+ [],+ );+ });++ it("accepts close-paren followed by operator", () => {+ expect(findInvalidRanges("(Revenue + Costs) * 2", metricNames)).toEqual([]);+ });+});++describe("getWordAtCursor — comma handling with metric entries", () => {+ const commaMetricNames: MetricNameMap = { "metric:99": "Revenue, Total" };++ it("without entries, comma is always a delimiter", () => {+ const text = "Revenue, Total";+ // cursor at end+ const result = getWordAtCursor(text, text.length);+ expect(result.word).toBe("Total");+ });++ it("with entries, comma inside a known metric name is not a delimiter", () => {+ const text = "Revenue, Total";+ const result = getWordAtCursor(text, text.length, commaMetricNames);+ expect(result.word).toBe("Revenue, Total");+ });++ it("with entries, separator comma between two metrics is still a delimiter", () => {+ const text = "Revenue, Orders";+ // cursor at end (inside "Orders")+ const result = getWordAtCursor(text, text.length, {+ "metric:1": "Revenue",+ "metric:2": "Orders",+ });+ expect(result.word).toBe("Orders");+ });++ it("treats comma as part of metric name when typing a partial match", () => {+ // User is typing "Revenue, T" which is a prefix of "Revenue, Total"+ // The comma is NOT a separator because "Revenue" alone is not a known+ // metric in this set — the only known metric is "Revenue, Total".+ const text = "Revenue, T";+ const result = getWordAtCursor(text, text.length, commaMetricNames);+ expect(result.word).toBe("Revenue, T");+ });++ it("math-operator delimiters still work with metric entries", () => {+ const text = "Revenue, Total + 1";+ const result = getWordAtCursor(text, text.length, commaMetricNames);+ expect(result.word).toBe("1");+ });++ it("returns full metric name when cursor is in the middle", () => {+ const text = "Revenue, Total";+ // cursor after the comma+space (position 9, inside "Total")+ const result = getWordAtCursor(text, 9, commaMetricNames);+ expect(result.word).toBe("Revenue, Total");+ });+});++function sourceId(id: number): MetricSourceId {+ return `metric:${id}`;+}++function getExprTokenDefinitions(+ entities: MetricsViewerFormulaEntity[],+ entityIndex: number,+): (LibMetric.MetricDefinition | undefined)[] {+ const entity = entities[entityIndex];+ if (!isExpressionEntry(entity)) {+ return [];+ }+ return entity.tokens+ .filter((token) => token.type === "metric")+ .map((token) =>+ token.type === "metric" ? (token.definition ?? undefined) : undefined,+ );+}++let nextSlotIndex = 0;++function identity(+ metricSourceId: MetricSourceId,+ from: number,+ to: number,+ definition: MetricDefinitionEntry["definition"] = null,+ slotIndex: number = nextSlotIndex++,+): MetricIdentityEntry {+ return { sourceId: metricSourceId, from, to, definition, slotIndex };+}++describe("applyTrackedDefinitions", () => {+ beforeEach(() => {+ nextSlotIndex = 0;+ });++ const metricNames: MetricNameMap = {+ [sourceId(1)]: "Revenue",+ [sourceId(2)]: "Geo Revenue",+ };+ const metadata = createMetricMetadata([REVENUE_METRIC, GEO_METRIC]);+ const revenueDef = setupDefinition(metadata, REVENUE_METRIC.id);+ const revenueBreakoutDef = setupDefinitionWithBreakout(+ metadata,+ REVENUE_METRIC.id,+ 0,+ );+ const geoBreakoutDef = setupDefinitionWithBreakout(+ metadata,+ GEO_METRIC.id,+ 0,+ );++ it("returns empty array for empty inputs", () => {+ const result = applyTrackedDefinitions([], [], "", metricNames);+ expect(result.entities).toEqual([]);+ expect(result.slotMapping.size).toBe(0);+ });++ it("applies tracked definition to a standalone metric by position", () => {+ const text = "Revenue";+ const parsed = parseFullText(text, metricNames);+ const tracked = [identity(sourceId(1), 0, 7, revenueBreakoutDef)];+ const { entities } = applyTrackedDefinitions(+ parsed,+ tracked,+ text,+ metricNames,+ );+ expect(entities).toHaveLength(1);+ expect((entities[0] as MetricDefinitionEntry).definition).toBe(+ revenueBreakoutDef,+ );+ });++ it("preserves null definition when tracked identity has null", () => {+ const text = "Revenue";+ const parsed = parseFullText(text, metricNames);+ const tracked = [identity(sourceId(1), 0, 7, null)];+ const { entities } = applyTrackedDefinitions(+ parsed,+ tracked,+ text,+ metricNames,+ );+ expect((entities[0] as MetricDefinitionEntry).definition).toBeNull();+ });++ it("leaves entity unchanged when no tracked identity matches its position", () => {+ const text = "Revenue";+ 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 tracked = [+ identity(sourceId(1), 0, 7, revenueBreakoutDef),+ identity(sourceId(2), 9, 20, geoBreakoutDef),+ ];+ const { entities } = applyTrackedDefinitions(+ parsed,+ tracked,+ text,+ metricNames,+ );+ expect((entities[0] as MetricDefinitionEntry).definition).toBe(+ revenueBreakoutDef,+ );+ expect((entities[1] as MetricDefinitionEntry).definition).toBe(+ geoBreakoutDef,+ );+ });++ it("strips breakout projections from expression token definitions", () => {+ const text = "Revenue + 5";+ const parsed = parseFullText(text, metricNames);+ const tracked = [identity(sourceId(1), 0, 7, revenueBreakoutDef)];+ const { entities } = applyTrackedDefinitions(+ parsed,+ tracked,+ text,+ metricNames,+ );+ const [tokenDef] = getExprTokenDefinitions(entities, 0);+ expect(tokenDef).toBeDefined();+ expect(LibMetric.projections(tokenDef!)).toEqual([]);+ });++ it("preserves non-breakout definitions on expression tokens", () => {+ const text = "Revenue + 5";+ const parsed = parseFullText(text, metricNames);+ const tracked = [identity(sourceId(1), 0, 7, revenueDef)];+ const { entities } = applyTrackedDefinitions(+ parsed,+ tracked,+ text,+ metricNames,+ );+ const [tokenDef] = getExprTokenDefinitions(entities, 0);+ expect(tokenDef).toBe(revenueDef);+ });++ it("preserves reference identity for expression entries when no tokens change", () => {+ const text = "Revenue + 5";+ 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 tracked = [identity(sourceId(1), 0, 7, revenueDef)];+ const { entities } = applyTrackedDefinitions(+ parsed,+ tracked,+ text,+ metricNames,+ );+ const resultExpr = entities[0] as ExpressionDefinitionEntry;+ const parsedExpr = parsed[0] as ExpressionDefinitionEntry;+ expect(resultExpr.tokens[1]).toBe(parsedExpr.tokens[1]);+ expect(resultExpr.tokens[2]).toBe(parsedExpr.tokens[2]);+ });++ it("applies definition only to standalone metric, not expression token at different position", () => {+ const text = "Revenue, Revenue + 5";+ 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(+ parsed,+ tracked,+ text,+ metricNames,+ );+ expect((entities[0] as MetricDefinitionEntry).definition).toBe(+ revenueBreakoutDef,+ );+ const [tokenDef] = getExprTokenDefinitions(entities, 1);+ expect(tokenDef).toBeUndefined();+ });++ it("does not carry definition to a token at a non-matching position", () => {+ // 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 tracked = [identity(sourceId(1), 100, 107, revenueDef)];+ const { entities } = applyTrackedDefinitions(+ parsed,+ tracked,+ text,+ metricNames,+ );+ expect((entities[0] as MetricDefinitionEntry).definition).not.toBe(+ revenueDef,+ );+ });++ it("newly added duplicate of same metric gets no definition from the tracked one", () => {+ const text = "Revenue, Revenue";+ const parsed = parseFullText(text, metricNames);+ // Only one tracked identity at position [0,7]+ const tracked = [identity(sourceId(1), 0, 7, revenueBreakoutDef)];+ const { entities } = applyTrackedDefinitions(+ parsed,+ tracked,+ text,+ metricNames,+ );+ // First Revenue at [0,7] — exact position match+ expect((entities[0] as MetricDefinitionEntry).definition).toBe(+ revenueBreakoutDef,+ );+ // Second Revenue at [9,16] — no match, independent new instance+ expect((entities[1] as MetricDefinitionEntry).definition).not.toBe(+ revenueBreakoutDef,+ );+ });++ 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 tracked = [identity(sourceId(1), 0, 7, revenueDef)];+ const { entities } = applyTrackedDefinitions(+ parsed,+ tracked,+ text,+ metricNames,+ );+ const [tokenDef] = getExprTokenDefinitions(entities, 0);+ expect(tokenDef).toBe(revenueDef);+ });++ it("two instances of same metric at different positions keep independent definitions", () => {+ const text = "Revenue, Revenue";+ const parsed = parseFullText(text, metricNames);+ const tracked = [+ identity(sourceId(1), 0, 7, revenueBreakoutDef, 0),+ identity(sourceId(1), 9, 16, revenueDef, 1),+ ];+ const { entities } = applyTrackedDefinitions(+ parsed,+ tracked,+ text,+ metricNames,+ );+ expect((entities[0] as MetricDefinitionEntry).definition).toBe(+ revenueBreakoutDef,+ );+ expect((entities[1] as MetricDefinitionEntry).definition).toBe(revenueDef);+ });+});diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearchPanel/MetricSearchPanel.module.css b/frontend/src/metabase/metrics-viewer/components/MetricSearchPanel/MetricSearchPanel.module.cssindex 4c525827210..31055f77d8d 100644--- a/frontend/src/metabase/metrics-viewer/components/MetricSearchPanel/MetricSearchPanel.module.css+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearchPanel/MetricSearchPanel.module.css@@ -10,6 +10,10 @@border-color: var(--mb-color-brand);}+.container:has([data-has-error]) {+ border-color: var(--mb-color-error);+}+.filterPillsSection {border-radius: 0 0 var(--mantine-radius-lg) var(--mantine-radius-lg);}diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearchPanel/MetricSearchPanel.tsx b/frontend/src/metabase/metrics-viewer/components/MetricSearchPanel/MetricSearchPanel.tsxindex b9a08e4dc6b..841032339a1 100644--- a/frontend/src/metabase/metrics-viewer/components/MetricSearchPanel/MetricSearchPanel.tsx+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearchPanel/MetricSearchPanel.tsx@@ -1,4 +1,4 @@-import { useMemo, useState } from "react";+import { useCallback, useMemo, useState } from "react";import { t } from "ttag";import { Box, Button, Flex, Icon, Stack, Text, Tooltip } from "metabase/ui";@@ -6,79 +6,95 @@ import type { MetricDefinition, ProjectionClause } from "metabase-lib/metric";import * as LibMetric from "metabase-lib/metric";import type {+ MetricDefinitionEntry,MetricSourceId,MetricsViewerDefinitionEntry,+ MetricsViewerFormulaEntity,SelectedMetric,SourceColorMap,} from "../../types/viewer-state";+import type { DefinitionSource } from "../../utils/definition-sources";+import {+ applyDefinitionToFormulaEntities,+ getDefinitionSources,+} from "../../utils/definition-sources";import { FilterPopover } from "../FilterPopover";-import type { DefinitionSource } from "../FilterPopover/FilterPopoverContent";-import { MetricSearch } from "../MetricSearch";+import { MetricSearchInput as MetricSearch } from "../MetricSearch";import { MetricsFilterPills } from "../MetricsFilterPills";import S from "./MetricSearchPanel.module.css";type MetricSearchPanelProps = {+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>;+ formulaEntities: MetricsViewerFormulaEntity[];+ onFormulaEntitiesChange: (+ entities: MetricsViewerFormulaEntity[],+ slotMapping?: Map<number, number>,+ ) => void;selectedMetrics: SelectedMetric[];metricColors: SourceColorMap;- definitions: MetricsViewerDefinitionEntry[];onAddMetric: (metric: SelectedMetric) => void;onRemoveMetric: (metricId: number, sourceType: "metric" | "measure") => void;onSwapMetric: (oldMetric: SelectedMetric, newMetric: SelectedMetric) => void;onSetBreakout: (- id: MetricSourceId,+ entity: MetricDefinitionEntry,dimension: ProjectionClause | undefined,) => void;- onUpdateDefinition: (- id: MetricSourceId,- definition: MetricDefinition,- ) => void;};export function MetricSearchPanel({+ definitions,+ formulaEntities,+ onFormulaEntitiesChange,selectedMetrics,metricColors,- definitions,onAddMetric,onRemoveMetric,onSwapMetric,onSetBreakout,- onUpdateDefinition,}: MetricSearchPanelProps) {const [isFilterPillsExpanded, setIsFilterPillsExpanded] = useState(true);- const readyDefinitions = useMemo(- () =>- definitions.filter(- (definition): definition is DefinitionSource =>- definition.definition != null,- ),- [definitions],+ const definitionSources = useMemo(+ () => getDefinitionSources(formulaEntities, definitions),+ [formulaEntities, definitions],);const filterCount = useMemo(() =>- readyDefinitions.reduce(- (count, definition) =>- count + LibMetric.filters(definition.definition).length,+ definitionSources.reduce(+ (count, source) => count + LibMetric.filters(source.definition).length,0,),- [readyDefinitions],+ [definitionSources],+ );++ const handleSourceDefinitionChange = useCallback(+ (source: DefinitionSource, newDefinition: MetricDefinition) => {+ onFormulaEntitiesChange(+ applyDefinitionToFormulaEntities(+ formulaEntities,+ source,+ newDefinition,+ ),+ );+ },+ [formulaEntities, onFormulaEntitiesChange],);- const hasDefinitions = readyDefinitions.length > 0;+ const hasDefinitions = definitionSources.length > 0;const hasFilters = filterCount > 0;const toggleLabel = isFilterPillsExpanded ? t`Hide filters` : t`Show filters`;return (- <Stack gap="sm">- <Flex align="center" justify="space-between">+ <Stack gap="md">+ <Flex align="center" justify="space-between" mih="1.875rem"><Text fw={700} size="lg">{t`Explore`}</Text>{hasDefinitions && (<FilterPopover- definitions={readyDefinitions}+ definitionSources={definitionSources}metricColors={metricColors}- onUpdateDefinition={onUpdateDefinition}+ onSourceDefinitionChange={handleSourceDefinitionChange}><Button.Group><Button@@ -87,10 +103,7 @@ export function MetricSearchPanel({size="xs"p="sm"leftSection={- <Icon- name={hasFilters ? "filter_plus" : "filter"}- size={14}- />+ <Icon name={hasFilters ? "filter_plus" : "filter"} />}className={hasFilters ? S.filterButtonWithCount : undefined}>@@ -122,9 +135,11 @@ export function MetricSearchPanel({<Box className={S.container}><Box><MetricSearch+ definitions={definitions}+ formulaEntities={formulaEntities}+ onFormulaEntitiesChange={onFormulaEntitiesChange}selectedMetrics={selectedMetrics}metricColors={metricColors}- definitions={definitions}onAddMetric={onAddMetric}onRemoveMetric={onRemoveMetric}onSwapMetric={onSwapMetric}@@ -139,9 +154,9 @@ export function MetricSearchPanel({bg="background-filter"><MetricsFilterPills- definitions={readyDefinitions}+ definitionSources={definitionSources}sourceColors={metricColors}- onUpdateDefinition={onUpdateDefinition}+ onSourceDefinitionChange={handleSourceDefinitionChange}/></Box>)}diff --git a/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPill.module.css b/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPill.module.cssindex 1071eb0dae3..9d0aa7903b2 100644--- a/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPill.module.css+++ b/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPill.module.css@@ -4,3 +4,7 @@border: 1px solid var(--mb-color-border-filter);border-radius: 0.75rem;}++.root:hover {+ background-color: var(--mb-color-background-secondary);+}diff --git a/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPill.tsx b/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPill.tsxindex 091a41be1c8..9ea8c3deaef 100644--- a/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPill.tsx+++ b/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPill.tsx@@ -10,7 +10,7 @@ import S from "./MetricsFilterPill.module.css";interface MetricsFilterPillProps extends HTMLAttributes<HTMLDivElement> {colors: string[];- fallbackIcon: IconName;+ fallbackIcon?: IconName;onRemoveClick?: () => void;}diff --git a/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPillPopover.tsx b/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPillPopover.tsxindex 1d56b7771b3..6cf22878eb5 100644--- a/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPillPopover.tsx+++ b/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPillPopover.tsx@@ -6,7 +6,7 @@ import {trackMetricsViewerFilterRemoved,} from "metabase/metrics-viewer/analytics";import type { IconName } from "metabase/ui";-import { Popover, Text } from "metabase/ui";+import { Badge, Flex, Popover, Text } from "metabase/ui";import * as LibMetric from "metabase-lib/metric";import { MetricsFilterPill } from "./MetricsFilterPill";@@ -16,7 +16,9 @@ interface MetricsFilterPillPopoverProps {definition: LibMetric.MetricDefinition;filter: LibMetric.FilterClause;colors: string[];- icon: IconName;+ icon?: IconName;+ metricName?: string;+ metricCount?: number;onUpdate: (newFilter: LibMetric.FilterClause) => void;onRemove: () => void;}@@ -26,6 +28,8 @@ export function MetricsFilterPillPopover({filter,colors,icon,+ metricName,+ metricCount,onUpdate,onRemove,}: MetricsFilterPillPopoverProps) {@@ -62,13 +66,30 @@ export function MetricsFilterPillPopover({onClick={() => setIsOpened((prev) => !prev)}onRemoveClick={handleRemove}>- {displayParts.label}- {displayParts.value && (- <Text component="span" fw={700} c="text-filter" fz="sm">- {" "}- {displayParts.value}- </Text>- )}+ <Flex align="center" gap="xs">+ {metricName && (+ <Text component="span" fw={700} c="inherit" fz="inherit">+ {metricName}+ </Text>+ )}+ {metricName && (metricCount ?? 0) > 1 && (+ <Badge+ circle+ color="filter"+ // override background from Badge.config.tsx+ styles={{ root: { background: "var(--badge-bg)" } }}+ >+ {metricCount}+ </Badge>+ )}+ {displayParts.label}+ {displayParts.value && (+ <Text component="span" fw={700} c="inherit" fz="inherit">+ {" "}+ {displayParts.value}+ </Text>+ )}+ </Flex></MetricsFilterPill></Popover.Target><Popover.Dropdown>diff --git a/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPills.tsx b/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPills.tsxindex 0aaf9eff9a2..76f001fdf57 100644--- a/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPills.tsx+++ b/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPills.tsx@@ -5,63 +5,67 @@ import { Group } from "metabase/ui";import type { MetricDefinition } from "metabase-lib/metric";import * as LibMetric from "metabase-lib/metric";-import type { MetricSourceId, SourceColorMap } from "../../types/viewer-state";-import { getSourceIcon } from "../../utils/source-ids";-import type { DefinitionSource } from "../FilterPopover/FilterPopoverContent";+import type { SourceColorMap } from "../../types/viewer-state";+import { isExpressionEntry } from "../../types/viewer-state";+import type { DefinitionSource } from "../../utils/definition-sources";+import {+ getDefinitionSourceIcon,+ getDefinitionSourceName,+} from "../../utils/definition-sources";import { MetricsFilterPillPopover } from "./MetricsFilterPillPopover";interface MetricsFilterPillsProps {- definitions: DefinitionSource[];+ definitionSources: DefinitionSource[];sourceColors: SourceColorMap;- onUpdateDefinition: (- id: MetricSourceId,+ onSourceDefinitionChange: (+ source: DefinitionSource,definition: MetricDefinition,) => void;}type FlattenedFilter = {- entryId: MetricSourceId;- definition: MetricDefinition;+ source: DefinitionSource;filter: LibMetric.FilterClause;colors: string[];- icon: IconName;+ icon?: IconName;key: string;+ metricName?: string;+ metricCount?: number;};export function MetricsFilterPills({- definitions,+ definitionSources,sourceColors,- onUpdateDefinition,+ onSourceDefinitionChange,}: MetricsFilterPillsProps) {const flatFilters = useMemo(- () => getFlatFilters(definitions, sourceColors),- [definitions, sourceColors],+ () => getFlatFilters(definitionSources, sourceColors),+ [definitionSources, sourceColors],);const handleUpdate = useCallback((- entryId: MetricSourceId,- definition: MetricDefinition,+ source: DefinitionSource,oldFilter: LibMetric.FilterClause,newFilter: LibMetric.FilterClause,) => {- const newDef = LibMetric.replaceClause(definition, oldFilter, newFilter);- onUpdateDefinition(entryId, newDef);+ const newDef = LibMetric.replaceClause(+ source.definition,+ oldFilter,+ newFilter,+ );+ onSourceDefinitionChange(source, newDef);},- [onUpdateDefinition],+ [onSourceDefinitionChange],);const handleRemove = useCallback(- (- entryId: MetricSourceId,- definition: MetricDefinition,- filter: LibMetric.FilterClause,- ) => {- const newDef = LibMetric.removeClause(definition, filter);- onUpdateDefinition(entryId, newDef);+ (source: DefinitionSource, filter: LibMetric.FilterClause) => {+ const newDef = LibMetric.removeClause(source.definition, filter);+ onSourceDefinitionChange(source, newDef);},- [onUpdateDefinition],+ [onSourceDefinitionChange],);if (flatFilters.length === 0) {@@ -73,16 +77,16 @@ export function MetricsFilterPills({{flatFilters.map((item) => (<MetricsFilterPillPopoverkey={item.key}- definition={item.definition}+ definition={item.source.definition}filter={item.filter}colors={item.colors}icon={item.icon}+ metricName={item.metricName}+ metricCount={item.metricCount}onUpdate={(newFilter) =>- handleUpdate(item.entryId, item.definition, item.filter, newFilter)- }- onRemove={() =>- handleRemove(item.entryId, item.definition, item.filter)+ handleUpdate(item.source, item.filter, newFilter)}+ onRemove={() => handleRemove(item.source, item.filter)}/>))}</Group>@@ -90,19 +94,28 @@ export function MetricsFilterPills({}function getFlatFilters(- definitions: DefinitionSource[],+ sources: DefinitionSource[],sourceColors: SourceColorMap,): FlattenedFilter[] {- return definitions.flatMap((definition) => {- const colors = sourceColors[definition.id] ?? ["var(--mb-color-brand)"];- const icon = getSourceIcon(definition.id);- return LibMetric.filters(definition.definition).map((filter, index) => ({- entryId: definition.id,- definition: definition.definition,+ return sources.flatMap((source) => {+ const colors = sourceColors[source.entityIndex] ?? [+ "var(--mb-color-text-primary)",+ ];+ const icon = getDefinitionSourceIcon(source);+ const shouldDisplayMetricName =+ isExpressionEntry(source.entity) &&+ source.entity.tokens.filter((token) => token.type === "metric").length >+ 1;+ return LibMetric.filters(source.definition).map((filter, filterIndex) => ({+ source,filter,colors,icon,- key: `${definition.id}-${index}`,+ key: `${source.index}-${filterIndex}`,+ metricName: shouldDisplayMetricName+ ? getDefinitionSourceName(source)+ : undefined,+ metricCount: source.token?.count,}));});}diff --git a/frontend/src/metabase/metrics-viewer/components/MetricsViewerTabs/AddDimensionPopover/AddDimensionPopover.tsx b/frontend/src/metabase/metrics-viewer/components/MetricsViewerTabs/AddDimensionPopover/AddDimensionPopover.tsxindex 75e26b96ad8..01d4774e4c3 100644--- a/frontend/src/metabase/metrics-viewer/components/MetricsViewerTabs/AddDimensionPopover/AddDimensionPopover.tsx+++ b/frontend/src/metabase/metrics-viewer/components/MetricsViewerTabs/AddDimensionPopover/AddDimensionPopover.tsx@@ -10,9 +10,11 @@ import type { MetricSourceId } from "../../../types/viewer-state";import type {AvailableDimensionsResult,DimensionPickerItem,+ DimensionPickerSection,SourceDisplayInfo,} from "../../../utils/dimension-picker";import { buildDimensionPickerSections } from "../../../utils/dimension-picker";+import { getScalarTabLabel } from "../../../utils/tabs";import S from "./AddDimensionPopover.module.css";@@ -21,6 +23,7 @@ type AddDimensionPopoverProps = {sourceOrder: MetricSourceId[];sourceDataById: Record<MetricSourceId, SourceDisplayInfo>;hasMultipleSources: boolean;+ canAddScalarTab: boolean;onAddTab: (tabInfo: TabInfo) => void;};@@ -30,6 +33,7 @@ export function AddDimensionPopover({sourceDataById,hasMultipleSources,onAddTab,+ canAddScalarTab,}: AddDimensionPopoverProps) {const [isOpen, setIsOpen] = useState(false);@@ -58,6 +62,26 @@ export function AddDimensionPopover({[],);+ let finalSections: DimensionPickerSection[] = sections;+ if (canAddScalarTab) {+ finalSections = [+ {+ items: [+ {+ name: getScalarTabLabel(),+ icon: "number",+ tabInfo: {+ type: "scalar",+ label: getScalarTabLabel(),+ dimensionMapping: {},+ },+ },+ ],+ },+ ...sections,+ ];+ }+return (<Popover opened={isOpen} onChange={setIsOpen} position="bottom-start"><Popover.Target>@@ -73,7 +97,7 @@ export function AddDimensionPopover({<Popover.Dropdown p={0} className={S.dropdown}><AccordionListclassName={S.dimensionPicker}- sections={sections}+ sections={finalSections}onChange={handleSelect}renderItemIcon={renderItemIcon}alwaysExpandeddiff --git a/frontend/src/metabase/metrics-viewer/components/MetricsViewerTabs/MetricsViewerTabContent/MetricsViewerTabContent.tsx b/frontend/src/metabase/metrics-viewer/components/MetricsViewerTabs/MetricsViewerTabContent/MetricsViewerTabContent.tsxindex 59f909e9ebc..467746227b0 100644--- a/frontend/src/metabase/metrics-viewer/components/MetricsViewerTabs/MetricsViewerTabContent/MetricsViewerTabContent.tsx+++ b/frontend/src/metabase/metrics-viewer/components/MetricsViewerTabs/MetricsViewerTabContent/MetricsViewerTabContent.tsx@@ -1,13 +1,11 @@import { useCallback, useMemo } from "react";-import { t } from "ttag";import { LoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper";import { Center, Flex, Stack } from "metabase/ui";-import { getObjectKeys } from "metabase/utils/objects";+import { getObjectKeys, getObjectValues } from "metabase/utils/objects";import { isNotNull } from "metabase/utils/types";import type { DimensionMetadata, MetricDefinition } from "metabase-lib/metric";import * as LibMetric from "metabase-lib/metric";-import { isMetric } from "metabase-lib/v1/types/utils/isa";import type {CardId,SingleSeries,@@ -19,68 +17,50 @@ import type {MetricSourceId,MetricsViewerDefinitionEntry,MetricsViewerDisplayType,+ MetricsViewerFormulaEntity,MetricsViewerTabProjectionConfig,MetricsViewerTabState,SourceColorMap,} from "../../../types/viewer-state";import { getProjectionInfo } from "../../../utils/definition-builder";import type { DimensionFilterValue } from "../../../utils/dimension-filters";+import type { MetricSlot } from "../../../utils/metric-slots";import { buildDimensionItemsFromDefinitions } from "../../../utils/series";import { DISPLAY_TYPE_REGISTRY, getTabConfig } from "../../../utils/tab-config";import { MetricControls } from "../../MetricControls";import { MetricsViewerVisualization } from "../../MetricsViewerVisualization";type MetricsViewerTabContentProps = {- definitions: MetricsViewerDefinitionEntry[];+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>;+ formulaEntities: MetricsViewerFormulaEntity[];tab: MetricsViewerTabState;- errorsByDefinitionId: Map<MetricSourceId, string>;- modifiedDefinitions: Map<MetricSourceId, MetricDefinition>;+ queriesAreLoading: boolean;+ queriesError: string | null;+ modifiedDefinitionsBySlotIndex: Map<number, MetricDefinition>;+ metricSlots: MetricSlot[];series: SingleSeries[];- cardIdToDefinitionId: Record<CardId, MetricSourceId>;+ cardIdToEntityIndex: Record<CardId, number>;sourceColors: SourceColorMap;- isExecuting: (id: MetricSourceId) => boolean;onTabUpdate: (updates: Partial<MetricsViewerTabState>) => void;- onDimensionChange: (- definitionId: MetricSourceId,- dimension: DimensionMetadata,- ) => void;- onDimensionRemove: (definitionId: MetricSourceId) => void;+ onDimensionChange: (slotIndex: number, dimension: DimensionMetadata) => void;+ onDimensionRemove: (slotIndex: number) => void;};export function MetricsViewerTabContent({definitions,+ formulaEntities,tab,- errorsByDefinitionId,- modifiedDefinitions,+ queriesAreLoading,+ queriesError,+ modifiedDefinitionsBySlotIndex,+ metricSlots,series: rawSeries,- cardIdToDefinitionId,+ cardIdToEntityIndex,sourceColors,- isExecuting,onTabUpdate,onDimensionChange,onDimensionRemove,}: MetricsViewerTabContentProps) {- const isLoading = useMemo(() => {- return getObjectKeys(tab.dimensionMapping).some(isExecuting);- }, [tab.dimensionMapping, isExecuting]);-- const firstError = useMemo(() => {- for (const series of rawSeries) {- const cols = series.data.cols;- if (!cols.some((col) => isMetric(col))) {- return t`Non-numeric metrics are not supported`;- }- }-- for (const sourceId of getObjectKeys(tab.dimensionMapping)) {- const err = errorsByDefinitionId.get(sourceId);- if (err) {- return err;- }- }- return null;- }, [tab.dimensionMapping, errorsByDefinitionId, rawSeries]);-const dimensionFilter = getTabConfig(tab.type).dimensionPredicate;const dimensionItems = useMemo(@@ -88,43 +68,45 @@ export function MetricsViewerTabContent({buildDimensionItemsFromDefinitions(definitions,tab.dimensionMapping,- modifiedDefinitions,+ modifiedDefinitionsBySlotIndex,sourceColors,+ metricSlots,+ formulaEntities,+ tab.projectionConfig,dimensionFilter,),[definitions,tab.dimensionMapping,- modifiedDefinitions,+ modifiedDefinitionsBySlotIndex,sourceColors,+ metricSlots,+ formulaEntities,+ tab.projectionConfig,dimensionFilter,],);const definitionForControls = useMemo((): MetricDefinition | null => {- for (const sourceId of getObjectKeys(tab.dimensionMapping)) {- const entry = definitions.find((d) => d.id === sourceId);- if (!entry) {- continue;- }-- const modDef = modifiedDefinitions.get(entry.id);+ for (const key of getObjectKeys(tab.dimensionMapping)) {+ const slotIndex = Number(key);+ const modDef = modifiedDefinitionsBySlotIndex.get(slotIndex);if (!modDef) {continue;}-const projs = LibMetric.projections(modDef);if (projs.length > 0) {return modDef;}}return null;- }, [definitions, tab.dimensionMapping, modifiedDefinitions]);+ }, [tab.dimensionMapping, modifiedDefinitionsBySlotIndex]);const allFilterDimensions = useMemo(() => {const filterDimensions: DimensionMetadata[] = [];- for (const sourceId of getObjectKeys(tab.dimensionMapping)) {- const modDef = modifiedDefinitions.get(sourceId);+ for (const key of getObjectKeys(tab.dimensionMapping)) {+ const slotIndex = Number(key);+ const modDef = modifiedDefinitionsBySlotIndex.get(slotIndex);if (!modDef) {continue;}@@ -134,7 +116,7 @@ export function MetricsViewerTabContent({}}return filterDimensions;- }, [tab.dimensionMapping, modifiedDefinitions]);+ }, [tab.dimensionMapping, modifiedDefinitionsBySlotIndex]);const updateProjectionConfig = useCallback((updates: Partial<MetricsViewerTabProjectionConfig>) => {@@ -203,16 +185,19 @@ export function MetricsViewerTabContent({DISPLAY_TYPE_REGISTRY[tab.display].supportsStacking && rawSeries.length > 1;const isTimeTab = tab.type === "time";- const mappedDimensionCount = Object.values(tab.dimensionMapping).filter(+ const mappedDimensionCount = getObjectValues(tab.dimensionMapping).filter(isNotNull,).length;const dimensionRemoveHandler =mappedDimensionCount > 1 ? onDimensionRemove : undefined;- if (isLoading || firstError) {+ if (queriesAreLoading || queriesError) {return (<Center h="100%">- <LoadingAndErrorWrapper loading={isLoading} error={firstError} />+ <LoadingAndErrorWrapper+ loading={queriesAreLoading}+ error={queriesError}+ /></Center>);}@@ -230,9 +215,11 @@ export function MetricsViewerTabContent({onDimensionRemove={dimensionRemoveHandler}onBrush={isTimeTab ? handleBrush : undefined}definitions={definitions}+ formulaEntities={formulaEntities}+ metricSlots={metricSlots}tab={tab}onTabUpdate={onTabUpdate}- cardIdToDefinitionId={cardIdToDefinitionId}+ cardIdToEntityIndex={cardIdToEntityIndex}/>{definitionForControls && (<Flex justify="center" align="center">diff --git a/frontend/src/metabase/metrics-viewer/components/MetricsViewerTabs/MetricsViewerTabs.tsx b/frontend/src/metabase/metrics-viewer/components/MetricsViewerTabs/MetricsViewerTabs.tsxindex dbfcef078fc..c6a0202e0ea 100644--- a/frontend/src/metabase/metrics-viewer/components/MetricsViewerTabs/MetricsViewerTabs.tsx+++ b/frontend/src/metabase/metrics-viewer/components/MetricsViewerTabs/MetricsViewerTabs.tsx@@ -71,6 +71,8 @@ export function MetricsViewerTabs({return null;}+ const canAddScalarTab = !tabs.some((tab) => tab.type === "scalar");+return (<Tabsvalue={activeTabId}@@ -112,6 +114,7 @@ export function MetricsViewerTabs({sourceDataById={sourceDataById}hasMultipleSources={hasMultipleSources}onAddTab={onAddTab}+ canAddScalarTab={canAddScalarTab}/>)}</Tabs.List>diff --git a/frontend/src/metabase/metrics-viewer/components/MetricsViewerVisualization/MetricsViewerVisualization.module.css b/frontend/src/metabase/metrics-viewer/components/MetricsViewerVisualization/MetricsViewerVisualization.module.cssindex 3306df0469f..dbf276ee408 100644--- a/frontend/src/metabase/metrics-viewer/components/MetricsViewerVisualization/MetricsViewerVisualization.module.css+++ b/frontend/src/metabase/metrics-viewer/components/MetricsViewerVisualization/MetricsViewerVisualization.module.css@@ -6,4 +6,8 @@background-color: var(--mb-color-background-primary);overflow: hidden;height: 100%;++ & :global(.CardVisualization) {+ padding: 0;+ }}diff --git a/frontend/src/metabase/metrics-viewer/components/MetricsViewerVisualization/MetricsViewerVisualization.tsx b/frontend/src/metabase/metrics-viewer/components/MetricsViewerVisualization/MetricsViewerVisualization.tsxindex a38560e3250..f707ae888bd 100644--- a/frontend/src/metabase/metrics-viewer/components/MetricsViewerVisualization/MetricsViewerVisualization.tsx+++ b/frontend/src/metabase/metrics-viewer/components/MetricsViewerVisualization/MetricsViewerVisualization.tsx@@ -2,11 +2,15 @@ import { useMemo } from "react";import { noop } from "underscore";import { DebouncedFrame } from "metabase/common/components/DebouncedFrame";-import type { DimensionItem } from "metabase/metrics-viewer/components/DimensionPillBar";+import type { DimensionPillBarItem } from "metabase/metrics-viewer/components/DimensionPillBar";import { DimensionPillBar } from "metabase/metrics-viewer/components/DimensionPillBar";-import { DISPLAY_TYPE_REGISTRY } from "metabase/metrics-viewer/utils";+import {+ DISPLAY_TYPE_REGISTRY,+ getTabConfig,+} from "metabase/metrics-viewer/utils";import { MetricsViewerClickActionsMode } from "metabase/metrics-viewer/utils/MetricsViewerClickActionsMode";import { getGridColumns } from "metabase/metrics-viewer/utils/grid-columns";+import type { MetricSlot } from "metabase/metrics-viewer/utils/metric-slots";import { Flex, SimpleGrid, Stack, useElementSize } from "metabase/ui";import Visualization from "metabase/visualizations/components/Visualization";import type { DimensionMetadata } from "metabase-lib/metric";@@ -15,6 +19,7 @@ import type { CardId, SingleSeries } from "metabase-types/api";import type {MetricSourceId,MetricsViewerDefinitionEntry,+ MetricsViewerFormulaEntity,MetricsViewerTabState,} from "../../types/viewer-state";@@ -22,18 +27,17 @@ import S from "./MetricsViewerVisualization.module.css";type MetricsViewerVisualizationProps = {rawSeries: SingleSeries[];- dimensionItems: DimensionItem[];- onDimensionChange?: (- definitionId: MetricSourceId,- dimension: DimensionMetadata,- ) => void;- onDimensionRemove?: (definitionId: MetricSourceId) => void;+ dimensionItems: DimensionPillBarItem[];+ onDimensionChange: (slotIndex: number, dimension: DimensionMetadata) => void;+ onDimensionRemove?: (slotIndex: number) => void;onBrush?: (range: { start: number; end: number }) => void;className?: string;- definitions: MetricsViewerDefinitionEntry[];+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>;+ formulaEntities: MetricsViewerFormulaEntity[];+ metricSlots: MetricSlot[];tab: MetricsViewerTabState;onTabUpdate: (updates: Partial<MetricsViewerTabState>) => void;- cardIdToDefinitionId: Record<CardId, MetricSourceId>;+ cardIdToEntityIndex: Record<CardId, number>;interactive?: boolean;};@@ -45,9 +49,11 @@ export function MetricsViewerVisualization({onBrush,className,definitions,+ formulaEntities,+ metricSlots,tab,onTabUpdate,- cardIdToDefinitionId,+ cardIdToEntityIndex,interactive = true,}: MetricsViewerVisualizationProps) {const { ref, width } = useElementSize();@@ -58,14 +64,32 @@ export function MetricsViewerVisualization({interactive? new MetricsViewerClickActionsMode({definitions,+ formulaEntities,+ metricSlots,tab,onTabUpdate,- cardIdToDefinitionId,+ cardIdToEntityIndex,}): undefined,- [cardIdToDefinitionId, definitions, interactive, onTabUpdate, tab],+ [+ definitions,+ cardIdToEntityIndex,+ formulaEntities,+ metricSlots,+ interactive,+ onTabUpdate,+ tab,+ ],);+ const tabConfig = getTabConfig(tab.type);+ const hasAnyOptions = dimensionItems.some((item) =>+ item.type === "expression"+ ? item.metricSources.some((s) => s.availableOptions.length > 0)+ : item.availableOptions.length > 0,+ );+ const hideDimensionPill = tabConfig.minDimensions === 0 && !hasAnyOptions;+return (<Flexref={ref}@@ -114,7 +138,7 @@ export function MetricsViewerVisualization({</DebouncedFrame>)}- {dimensionItems.length > 0 && onDimensionChange && (+ {!hideDimensionPill && (<DimensionPillBaritems={dimensionItems}onDimensionChange={onDimensionChange}diff --git a/frontend/src/metabase/metrics-viewer/constants.ts b/frontend/src/metabase/metrics-viewer/constants.tsindex 68017697609..98251f232f1 100644--- a/frontend/src/metabase/metrics-viewer/constants.ts+++ b/frontend/src/metabase/metrics-viewer/constants.ts@@ -1,3 +1,3 @@export const UNBINNED = "__unbinned__" as const;-export const MAX_AUTO_TABS = 4;+export const MAX_AUTO_TABS = 5;diff --git a/frontend/src/metabase/metrics-viewer/hooks/use-definition-queries.ts b/frontend/src/metabase/metrics-viewer/hooks/use-definition-queries.tsindex a3b1ea5827a..44eb1047b84 100644--- a/frontend/src/metabase/metrics-viewer/hooks/use-definition-queries.ts+++ b/frontend/src/metabase/metrics-viewer/hooks/use-definition-queries.ts@@ -1,108 +1,293 @@import { useEffect, useMemo } from "react";+import { t } from "ttag";import { metricApi } from "metabase/api";import { getErrorMessage } from "metabase/api/utils/errors";import { useDispatch, useSelector } from "metabase/utils/redux";import type { MetricDefinition } from "metabase-lib/metric";-import type { Dataset, MetricBreakoutValuesResponse } from "metabase-types/api";+import * as LibMetric from "metabase-lib/metric";+import { isMetric } from "metabase-lib/v1/types/utils/isa";+import type {+ Dataset,+ ExpressionRef,+ InstanceFilter,+ MetricBreakoutValuesResponse,+ TypedProjection,+} from "metabase-types/api";+import type { MetricDatasetRequest } from "metabase-types/api/metric";import type { State } from "metabase-types/store";-import type {- MetricSourceId,- MetricsViewerDefinitionEntry,- MetricsViewerTabState,+import {+ type ExpressionDefinitionEntry,+ type MetricSourceId,+ type MetricsViewerDefinitionEntry,+ type MetricsViewerFormulaEntity,+ type MetricsViewerTabState,+ isExpressionEntry,+ isMetricEntry,} from "../types/viewer-state";import {getModifiedDefinition,toJsDefinition,} from "../utils/definition-cache";-import { entryHasBreakout } from "../utils/definition-entries";+import {+ entryHasBreakout,+ getEffectiveDefinitionEntry,+ getEffectiveTokenDefinitionEntry,+} from "../utils/definition-entries";+import type { MetricSlot } from "../utils/metric-slots";+import {+ computeMetricSlots,+ findExpressionTokenSlot,+ findStandaloneSlot,+} from "../utils/metric-slots";+import { parseExpression } from "../utils/parse-expression";+import { getTabConfig } from "../utils/tab-config";export interface UseDefinitionQueriesResult {- resultsByDefinitionId: Map<MetricSourceId, Dataset>;- errorsByDefinitionId: Map<MetricSourceId, string>;- modifiedDefinitions: Map<MetricSourceId, MetricDefinition>;- breakoutValuesBySourceId: Map<MetricSourceId, MetricBreakoutValuesResponse>;- isExecuting: (id: MetricSourceId) => boolean;+ resultsByEntityIndex: Map<number, Dataset>;+ queriesAreLoading: boolean;+ queriesError: string | null;+ modifiedDefinitionsBySlotIndex: Map<number, MetricDefinition>;+ breakoutValuesByEntityIndex: Map<number, MetricBreakoutValuesResponse>;}-export function useDefinitionQueries(- definitions: MetricsViewerDefinitionEntry[],- tab: MetricsViewerTabState | null,-): UseDefinitionQueriesResult {- const dispatch = useDispatch();+function getModifiedDefinitionForTab(+ definition: MetricsViewerDefinitionEntry,+ slotIndex: number,+ tab: MetricsViewerTabState,+): MetricDefinition | null {+ if (!definition.definition) {+ return null;+ }+ const tabConfig = getTabConfig(tab.type);+ const dimensionId = tab.dimensionMapping[slotIndex];+ if (!dimensionId) {+ if (tabConfig.minDimensions > 0) {+ return null;+ }+ return definition.definition;+ }+ return getModifiedDefinition(+ definition.definition,+ dimensionId,+ tab.projectionConfig,+ );+}++function buildArithmeticRequest(+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>,+ tab: MetricsViewerTabState,+ entity: ExpressionDefinitionEntry,+ metricSlots: MetricSlot[],+ entityIndex: number,+ datasetRequestsByEntityIndex: Map<number, MetricDatasetRequest>,+ modifiedDefinitionsBySlotIndex: Map<number, MetricDefinition>,+ expressionErrorsByEntityIndex: Map<number, string>,+): void {+ const { tokens } = entity;++ // Build leaf refs and projections for each metric occurrence in the expression.+ // Each occurrence gets its own unique UUID keyed by token position so the same+ // metric can appear multiple times (e.g. Revenue / Revenue).+ const leafRefs = new Map<number, ExpressionRef>();+ const projections: TypedProjection[] = [];+ const filters: InstanceFilter[] = [];- const datasetRequests = useMemo(() => {- if (!tab) {- return [];+ for (let i = 0; i < tokens.length; i++) {+ const token = tokens[i];+ if (token.type !== "metric") {+ continue;}- return definitions.flatMap((entry) => {- const dimensionId = tab.dimensionMapping[entry.id];- if (!dimensionId || !entry.definition) {- return [];+ const definition = getEffectiveTokenDefinitionEntry(token, definitions);+ // Find the specific slot for this expression token+ const tokenSlot = findExpressionTokenSlot(metricSlots, entityIndex, i);+ const slotIndex = tokenSlot?.slotIndex ?? -1;+ const modifiedDefinition = getModifiedDefinitionForTab(+ definition,+ slotIndex,+ tab,+ );+ if (!modifiedDefinition) {+ if (!definition.definition) {+ return; // still loading the metric, not an error}-- const modifiedDefinition = getModifiedDefinition(- entry.definition,- dimensionId,- tab.projectionConfig,+ expressionErrorsByEntityIndex.set(+ entityIndex,+ t`No compatible dimensions`,);+ return;+ }- if (!modifiedDefinition) {- return [];+ modifiedDefinitionsBySlotIndex.set(slotIndex, modifiedDefinition);++ const uuid = `leaf-${i}`;+ const metricId = LibMetric.sourceMetricId(modifiedDefinition);+ const measureId = LibMetric.sourceMeasureId(modifiedDefinition);++ if (metricId != null) {+ leafRefs.set(i, ["metric", { "lib/uuid": uuid }, metricId]);+ } else if (measureId != null) {+ leafRefs.set(i, ["measure", { "lib/uuid": uuid }, measureId]);+ } else {+ expressionErrorsByEntityIndex.set(entityIndex, t`Invalid expression`);+ return;+ }++ const jsdef = toJsDefinition(modifiedDefinition);++ if (jsdef.projections) {+ for (const proj of jsdef.projections) {+ projections.push({+ ...proj,+ "lib/uuid": uuid,+ });}+ }++ filters.push(+ ...(jsdef.filters ?? []).map((f) => ({+ "lib/uuid": uuid,+ filter: f.filter,+ })),+ );+ }+ const expr = parseExpression(tokens, leafRefs);+ if (!expr) {+ expressionErrorsByEntityIndex.set(entityIndex, t`Invalid expression`);+ return;+ }++ datasetRequestsByEntityIndex.set(entityIndex, {+ definition: {+ expression: expr,+ projections,+ filters,+ },+ });+}++function buildQueryItems(+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>,+ formulaEntities: MetricsViewerFormulaEntity[],+ tab: MetricsViewerTabState | null,+): {+ datasetRequestsByEntityIndex: Map<number, MetricDatasetRequest>;+ modifiedDefinitionsBySlotIndex: Map<number, MetricDefinition>;+ expressionErrorsByEntityIndex: Map<number, string>;+} {+ const datasetRequestsByEntityIndex = new Map<number, MetricDatasetRequest>();+ const modifiedDefinitionsBySlotIndex = new Map<number, MetricDefinition>();+ const expressionErrorsByEntityIndex = new Map<number, string>();++ if (!tab) {+ return {+ datasetRequestsByEntityIndex,+ modifiedDefinitionsBySlotIndex,+ expressionErrorsByEntityIndex,+ };+ }++ const metricSlots = computeMetricSlots(formulaEntities);++ formulaEntities.forEach((entity, entityIndex) => {+ if (isMetricEntry(entity)) {+ const effectiveEntry = getEffectiveDefinitionEntry(entity, definitions);+ const slot = findStandaloneSlot(metricSlots, entityIndex);+ if (!slot) {+ return;+ }+ const modifiedDefinition = getModifiedDefinitionForTab(+ effectiveEntry,+ slot.slotIndex,+ tab,+ );+ if (!modifiedDefinition) {+ return;+ }const jsDefinition = toJsDefinition(modifiedDefinition);+ datasetRequestsByEntityIndex.set(entityIndex, {+ definition: jsDefinition,+ });+ modifiedDefinitionsBySlotIndex.set(slot.slotIndex, modifiedDefinition);+ }- return [- {- sourceId: entry.id,- modifiedDefinition,- request: { definition: jsDefinition },- },- ];- });- }, [definitions, tab]);+ if (isExpressionEntry(entity)) {+ buildArithmeticRequest(+ definitions,+ tab,+ entity,+ metricSlots,+ entityIndex,+ // buildArithmeticRequest mutates these+ datasetRequestsByEntityIndex,+ modifiedDefinitionsBySlotIndex,+ expressionErrorsByEntityIndex,+ );+ }+ });++ return {+ datasetRequestsByEntityIndex,+ modifiedDefinitionsBySlotIndex,+ expressionErrorsByEntityIndex,+ };+}++export function useDefinitionQueries(+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>,+ formulaEntities: MetricsViewerFormulaEntity[],+ tab: MetricsViewerTabState | null,+): UseDefinitionQueriesResult {+ const dispatch = useDispatch();++ const {+ datasetRequestsByEntityIndex,+ modifiedDefinitionsBySlotIndex,+ expressionErrorsByEntityIndex,+ } = useMemo(+ () => buildQueryItems(definitions, formulaEntities, tab),+ [definitions, formulaEntities, tab],+ );const breakoutRequests = useMemo(() => {- return definitions.flatMap((entry) => {- if (!entry.definition || !entryHasBreakout(entry)) {+ return formulaEntities.flatMap((entity, entityIndex) => {+ if (!isMetricEntry(entity)) {+ return [];+ }+ const effectiveEntry = getEffectiveDefinitionEntry(entity, definitions);+ if (!effectiveEntry.definition || !entryHasBreakout(effectiveEntry)) {return [];}- const jsDefinition = toJsDefinition(entry.definition);+ const jsDefinition = toJsDefinition(effectiveEntry.definition);return [{- sourceId: entry.id,+ entityIndex,request: { definition: jsDefinition },},];});- }, [definitions]);-- const modifiedDefinitions = useMemo(() => {- const map = new Map<MetricSourceId, MetricDefinition>();- for (const { sourceId, modifiedDefinition } of datasetRequests) {- map.set(sourceId, modifiedDefinition);- }- return map;- }, [datasetRequests]);+ }, [formulaEntities, definitions]);useEffect(() => {- if (datasetRequests.length === 0) {+ const requestsToMake = [...datasetRequestsByEntityIndex.values()];++ if (requestsToMake.length === 0) {return;}- const subscriptions = datasetRequests.map((query) =>- dispatch(metricApi.endpoints.getMetricDataset.initiate(query.request)),+ const subscriptions = requestsToMake.map((request) =>+ dispatch(metricApi.endpoints.getMetricDataset.initiate(request)),);return () => {subscriptions.forEach((subscription) => subscription.unsubscribe());};- }, [datasetRequests, dispatch]);+ }, [datasetRequestsByEntityIndex, dispatch]);useEffect(() => {if (breakoutRequests.length === 0) {@@ -121,61 +306,77 @@ export function useDefinitionQueries(}, [breakoutRequests, dispatch]);const datasetResults = useSelector((state: State) =>- datasetRequests.map((query) => ({- sourceId: query.sourceId,- result: metricApi.endpoints.getMetricDataset.select(query.request)(state),- })),+ Array.from(datasetRequestsByEntityIndex.entries()).map(+ ([entityIndex, request]) => ({+ entityIndex,+ result: metricApi.endpoints.getMetricDataset.select(request)(state),+ }),+ ),);const breakoutResults = useSelector((state: State) =>breakoutRequests.map((query) => ({- sourceId: query.sourceId,+ entityIndex: query.entityIndex,result: metricApi.endpoints.getMetricBreakoutValues.select(query.request)(state,),})),);- const { resultsByDefinitionId, errorsByDefinitionId, isExecuting } =+ const { resultsByEntityIndex, queriesAreLoading, queriesError } =useMemo(() => {- const results = new Map<MetricSourceId, Dataset>();- const errors = new Map<MetricSourceId, string>();- const executing = new Set<MetricSourceId>();+ const resultsByEntityIndex = new Map<number, Dataset>();+ let queriesAreLoading = false;+ let queriesError = null;- for (const { sourceId, result } of datasetResults) {- if (result.data) {- results.set(sourceId, result.data);+ for (const { entityIndex, result } of datasetResults) {+ if (result.data?.data?.cols?.length) {+ if (result.data.data.cols.some((col) => isMetric(col))) {+ resultsByEntityIndex.set(entityIndex, result.data);+ } else {+ queriesError = t`Non-numeric metrics are not supported`;+ }}- if (result.error) {- errors.set(sourceId, getErrorMessage(result.error));+ if (result.error && queriesError == null) {+ queriesError = getErrorMessage(result.error);}if (result.isLoading || ("isFetching" in result && result.isFetching)) {- executing.add(sourceId);+ queriesAreLoading = true;}}+ // only show expression errors if we have no data to show+ if (+ !queriesAreLoading &&+ resultsByEntityIndex.size === 0 &&+ queriesError == null &&+ expressionErrorsByEntityIndex.size > 0+ ) {+ queriesError = expressionErrorsByEntityIndex.values().next().value!;+ }+return {- resultsByDefinitionId: results,- errorsByDefinitionId: errors,- isExecuting: (id: MetricSourceId) => executing.has(id),+ resultsByEntityIndex,+ queriesAreLoading,+ queriesError,};- }, [datasetResults]);+ }, [datasetResults, expressionErrorsByEntityIndex]);- const breakoutValuesBySourceId = useMemo(() => {- const map = new Map<MetricSourceId, MetricBreakoutValuesResponse>();- for (const { sourceId, result } of breakoutResults) {+ const breakoutValuesByEntityIndex = useMemo(() => {+ const map = new Map<number, MetricBreakoutValuesResponse>();+ for (const { entityIndex, result } of breakoutResults) {if (result.data) {- map.set(sourceId, result.data);+ map.set(entityIndex, result.data);}}return map;}, [breakoutResults]);return {- resultsByDefinitionId,- errorsByDefinitionId,- modifiedDefinitions,- breakoutValuesBySourceId,- isExecuting,+ resultsByEntityIndex,+ queriesAreLoading,+ queriesError,+ modifiedDefinitionsBySlotIndex,+ breakoutValuesByEntityIndex,};}diff --git a/frontend/src/metabase/metrics-viewer/hooks/use-metrics-viewer.ts b/frontend/src/metabase/metrics-viewer/hooks/use-metrics-viewer.tsindex cffca8ccb26..9cadb49821c 100644--- a/frontend/src/metabase/metrics-viewer/hooks/use-metrics-viewer.ts+++ b/frontend/src/metabase/metrics-viewer/hooks/use-metrics-viewer.ts@@ -1,6 +1,6 @@import { useCallback, useMemo } from "react";-import { getObjectEntries, objectFromEntries } from "metabase/utils/objects";+import { objectFromEntries } from "metabase/utils/objects";import { isNotNull } from "metabase/utils/types";import type {DimensionMetadata,@@ -17,45 +17,33 @@ import type {import type { MetricsViewerPageProps } from "../pages/MetricsViewerPage/MetricsViewerPage";import type {+ MetricDefinitionEntry,MetricSourceId,MetricsViewerDefinitionEntry,+ MetricsViewerFormulaEntity,MetricsViewerTabState,SelectedMetric,SourceBreakoutColorMap,SourceColorMap,} from "../types/viewer-state";-import {- applyProjection,- buildBinnedBreakoutDefinition,- getDefinitionName,-} from "../utils/definition-builder";-import { buildDimensionFilterClause } from "../utils/dimension-filters";-import {- findBinningStrategy,- findDimensionById,- findFilterDimensionById,- findTemporalBucket,-} from "../utils/dimension-lookup";+import { isExpressionEntry, isMetricEntry } from "../types/viewer-state";+import { getDefinitionName } from "../utils/definition-builder";import type {AvailableDimensionsResult,SourceDisplayInfo,} from "../utils/dimension-picker";import { getAvailableDimensionsForPicker } from "../utils/dimension-picker";+import { type MetricSlot, computeMetricSlots } from "../utils/metric-slots";import {- buildRawSeriesFromDefinitions,+ buildSeries,computeSourceBreakoutColors,getSelectedMetricsInfo,} from "../utils/series";-import {- createMeasureSourceId,- createMetricSourceId,- createSourceId,-} from "../utils/source-ids";+import { createSourceId } from "../utils/source-ids";import {type TabInfo,createTabFromTabInfo,- getDimensionsByType,- resolveCommonTabLabel,+ recomputeTabLabels,} from "../utils/tabs";import { useDefinitionQueries } from "./use-definition-queries";@@ -63,22 +51,23 @@ import { useViewerState } from "./use-viewer-state";import { type LoadSourcesRequest, useViewerUrl } from "./use-viewer-url";export interface UseMetricsViewerResult {- definitions: MetricsViewerDefinitionEntry[];+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>;+ formulaEntities: MetricsViewerFormulaEntity[];tabs: MetricsViewerTabState[];activeTab: MetricsViewerTabState | null;activeTabId: string | null;-+ initialLoadComplete: boolean;loadingIds: Set<MetricSourceId>;- resultsByDefinitionId: Map<MetricSourceId, Dataset>;- errorsByDefinitionId: Map<MetricSourceId, string>;- modifiedDefinitions: Map<MetricSourceId, MetricDefinition>;- isExecuting: (id: MetricSourceId) => boolean;-+ resultsByEntityIndex: Map<number, Dataset>;+ queriesAreLoading: boolean;+ queriesError: string | null;+ modifiedDefinitionsBySlotIndex: Map<number, MetricDefinition>;+ breakoutValuesByEntityIndex: Map<number, MetricBreakoutValuesResponse>;+ metricSlots: MetricSlot[];series: SingleSeries[];- cardIdToDefinitionId: Record<CardId, MetricSourceId>;+ cardIdToEntityIndex: Record<CardId, number>;activeBreakoutColors: SourceBreakoutColorMap;sourceColors: SourceColorMap;- breakoutValuesBySourceId: Map<MetricSourceId, MetricBreakoutValuesResponse>;selectedMetrics: SelectedMetric[];sourceOrder: MetricSourceId[];sourceDataById: Record<MetricSourceId, SourceDisplayInfo>;@@ -94,75 +83,18 @@ export interface UseMetricsViewerResult {updateActiveTab: (updates: Partial<MetricsViewerTabState>) => void;changeTabDimension: (tabId: string,- definitionId: MetricSourceId,+ slotIndex: number,dimension: DimensionMetadata,) => void;- removeTabDimension: (tabId: string, definitionId: MetricSourceId) => void;- updateDefinition: (id: MetricSourceId, definition: MetricDefinition) => void;+ removeTabDimension: (tabId: string, slotIndex: number) => void;setBreakoutDimension: (- id: MetricSourceId,+ entity: MetricDefinitionEntry,dimension: ProjectionClause | undefined,) => void;-}--function buildUrlRestoreTransform(- sourceId: MetricSourceId,- request: LoadSourcesRequest,-): ((definition: MetricDefinition) => MetricDefinition) | undefined {- const breakoutInfo = request.breakoutBySourceId?.[sourceId];- const filters = request.filtersBySourceId?.[sourceId];-- if (!breakoutInfo && (!filters || filters.length === 0)) {- return undefined;- }-- return (definition: MetricDefinition): MetricDefinition => {- let result = definition;-- if (breakoutInfo) {- const dimension = findDimensionById(result, breakoutInfo.dimensionId);- if (dimension) {- const dimensionRef = LibMetric.dimensionReference(dimension);-- let modifiedRef: LibMetric.ProjectionClause | null = null;- if (breakoutInfo.temporalUnit) {- const bucket = findTemporalBucket(- result,- dimension,- breakoutInfo.temporalUnit,- );- if (bucket) {- modifiedRef = LibMetric.withTemporalBucket(dimensionRef, bucket);- }- } else if (breakoutInfo.binning) {- const strategy = findBinningStrategy(- result,- dimension,- breakoutInfo.binning,- );- if (strategy) {- modifiedRef = LibMetric.withBinning(dimensionRef, strategy);- }- }-- result = modifiedRef- ? applyProjection(result, modifiedRef)- : buildBinnedBreakoutDefinition(result, dimensionRef);- }- }-- if (filters) {- for (const filter of filters) {- const dimension = findFilterDimensionById(result, filter.dimensionId);- if (dimension) {- const clause = buildDimensionFilterClause(dimension, filter.value);- result = LibMetric.filter(result, clause);- }- }- }-- return result;- };+ setFormulaEntities: (+ entities: MetricsViewerFormulaEntity[],+ slotMapping?: Map<number, number>,+ ) => void;}export function useMetricsViewer({@@ -171,8 +103,10 @@ export function useMetricsViewer({const {state,loadingIds,+ initialLoadComplete,+ setInitialLoadComplete,removeDefinition,- updateDefinition,+ setFormulaEntities,selectTab: changeTab,addTab,removeTab,@@ -190,21 +124,23 @@ export function useMetricsViewer({const handleLoadSources = useCallback((request: LoadSourcesRequest) => {for (const metricId of request.metricIds) {- const sourceId = createMetricSourceId(metricId);- loadAndAddMetric(metricId, buildUrlRestoreTransform(sourceId, request));+ loadAndAddMetric(metricId);}for (const measureId of request.measureIds) {- const sourceId = createMeasureSourceId(measureId);- loadAndAddMeasure(- measureId,- buildUrlRestoreTransform(sourceId, request),- );+ loadAndAddMeasure(measureId);}},[loadAndAddMetric, loadAndAddMeasure],);- useViewerUrl(state, initialize, handleLoadSources, location);+ useViewerUrl(+ state,+ initialize,+ handleLoadSources,+ location,+ setFormulaEntities,+ setInitialLoadComplete,+ );const activeTab = useMemo((): MetricsViewerTabState | null => {if (state.tabs.length === 0) {@@ -216,42 +152,60 @@ export function useMetricsViewer({}, [state.tabs, state.selectedTabId]);const {- resultsByDefinitionId,- errorsByDefinitionId,- modifiedDefinitions,- breakoutValuesBySourceId,- isExecuting,- } = useDefinitionQueries(state.definitions, activeTab);+ resultsByEntityIndex,+ queriesAreLoading,+ queriesError,+ modifiedDefinitionsBySlotIndex,+ breakoutValuesByEntityIndex,+ } = useDefinitionQueries(state.definitions, state.formulaEntities, activeTab);++ const definitionValues = useMemo(+ () => Object.values(state.definitions),+ [state.definitions],+ );const selectedMetrics = useMemo(- () => getSelectedMetricsInfo(state.definitions, loadingIds),- [state.definitions, loadingIds],+ () => getSelectedMetricsInfo(definitionValues, loadingIds),+ [definitionValues, loadingIds],+ );++ const metricSlots = useMemo(+ () => computeMetricSlots(state.formulaEntities),+ [state.formulaEntities],);const sourceBreakoutColors = useMemo(() =>- computeSourceBreakoutColors(state.definitions, breakoutValuesBySourceId),- [state.definitions, breakoutValuesBySourceId],+ computeSourceBreakoutColors(+ state.formulaEntities,+ state.definitions,+ breakoutValuesByEntityIndex,+ ),+ [state.formulaEntities, state.definitions, breakoutValuesByEntityIndex],);- const { series, cardIdToDefinitionId, activeBreakoutColors } = useMemo(() => {+ const { series, cardIdToEntityIndex, activeBreakoutColors } = useMemo(() => {if (!activeTab) {- return { series: [], cardIdToDefinitionId: {}, activeBreakoutColors: {} };+ return { series: [], cardIdToEntityIndex: {}, activeBreakoutColors: {} };}- return buildRawSeriesFromDefinitions(- state.definitions,- activeTab.dimensionMapping,- activeTab.display,- resultsByDefinitionId,- modifiedDefinitions,+ return buildSeries({+ formulaEntities: state.formulaEntities,+ definitions: state.definitions,+ metricSlots,+ dimensionMapping: activeTab.dimensionMapping,+ display: activeTab.display,+ resultsByEntityIndex,+ modifiedDefinitionsBySlotIndex,sourceBreakoutColors,- activeTab.visualizationSettings,- );+ extraVizSettings: activeTab.visualizationSettings,+ });}, [+ state.formulaEntities,state.definitions,+ metricSlots,activeTab,- resultsByDefinitionId,- modifiedDefinitions,+ resultsByEntityIndex,+ modifiedDefinitionsBySlotIndex,sourceBreakoutColors,]);@@ -273,22 +227,37 @@ export function useMetricsViewer({const definitionsBySourceId = useMemo(() =>objectFromEntries(- state.definitions.map((entry) => [entry.id, entry.definition] as const),+ definitionValues.map((entry) => [entry.id, entry.definition] as const),),- [state.definitions],+ [definitionValues],);- const sourceOrder = useMemo(- () => state.definitions.map((entry) => entry.id),- [state.definitions],- );+ const sourceOrder = useMemo(() => {+ const out: MetricSourceId[] = [];+ const seen = new Set<MetricSourceId>();+ for (const entry of state.formulaEntities) {+ if (isMetricEntry(entry) && !seen.has(entry.id)) {+ out.push(entry.id);+ seen.add(entry.id);+ }+ if (isExpressionEntry(entry)) {+ for (const token of entry.tokens) {+ if (token.type === "metric" && !seen.has(token.sourceId)) {+ out.push(token.sourceId);+ seen.add(token.sourceId);+ }+ }+ }+ }+ return out;+ }, [state.formulaEntities]);const sourceDataById = useMemo((): Record<MetricSourceId,SourceDisplayInfo> => {const result: Record<MetricSourceId, SourceDisplayInfo> = {};- for (const entry of state.definitions) {+ for (const entry of definitionValues) {const { definition } = entry;if (!definition) {continue;@@ -304,7 +273,7 @@ export function useMetricsViewer({}}return result;- }, [state.definitions]);+ }, [definitionValues]);const existingTabDimensionIds = useMemo(() =>@@ -316,50 +285,26 @@ export function useMetricsViewer({[state.tabs],);- const effectiveTabs = useMemo(() => {- const dimsBySource = new Map(- state.definitions- .filter((entry) => entry.definition != null)- .map(- (entry) =>- [entry.id, getDimensionsByType(entry.definition!)] as const,- ),- );-- return state.tabs.map((tab) => {- const names: string[] = [];- for (const [sourceId, dimensionId] of getObjectEntries(- tab.dimensionMapping,- )) {- if (dimensionId == null) {- continue;- }- const sourceDimensions = dimsBySource.get(sourceId);- const dimensionInfo = sourceDimensions?.get(dimensionId);- if (dimensionInfo) {- names.push(dimensionInfo.displayName);- }- }- const label = resolveCommonTabLabel(names);- return label != null && label !== tab.label ? { ...tab, label } : tab;- });- }, [state.tabs, state.definitions]);+ const effectiveTabs = useMemo(+ () => recomputeTabLabels(state.tabs, state.definitions, metricSlots),+ [state.tabs, metricSlots, state.definitions],+ );const availableDimensions = useMemo(() =>getAvailableDimensionsForPicker(definitionsBySourceId,- sourceOrder,+ metricSlots,existingTabDimensionIds,),- [definitionsBySourceId, sourceOrder, existingTabDimensionIds],+ [definitionsBySourceId, metricSlots, existingTabDimensionIds],);const addMetric = useCallback((metric: SelectedMetric) => {const sourceId = createSourceId(metric.id, metric.sourceType);- if (state.definitions.some((entry) => entry.id === sourceId)) {+ if (sourceId in state.definitions) {return;}@@ -417,21 +362,22 @@ export function useMetricsViewer({return {definitions: state.definitions,+ formulaEntities: state.formulaEntities,tabs: effectiveTabs,activeTab,activeTabId: state.selectedTabId,-+ initialLoadComplete,loadingIds,- resultsByDefinitionId,- errorsByDefinitionId,- modifiedDefinitions,- isExecuting,-+ resultsByEntityIndex,+ queriesAreLoading,+ queriesError,+ modifiedDefinitionsBySlotIndex,+ breakoutValuesByEntityIndex,+ metricSlots,series,- cardIdToDefinitionId,+ cardIdToEntityIndex,activeBreakoutColors,sourceColors,- breakoutValuesBySourceId,selectedMetrics,sourceOrder,sourceDataById,@@ -447,7 +393,7 @@ export function useMetricsViewer({updateActiveTab,changeTabDimension,removeTabDimension,- updateDefinition,setBreakoutDimension,+ setFormulaEntities,};}diff --git a/frontend/src/metabase/metrics-viewer/hooks/use-viewer-state.ts b/frontend/src/metabase/metrics-viewer/hooks/use-viewer-state.tsindex e9766702638..19903c099ab 100644--- a/frontend/src/metabase/metrics-viewer/hooks/use-viewer-state.ts+++ b/frontend/src/metabase/metrics-viewer/hooks/use-viewer-state.ts@@ -1,4 +1,4 @@-import { useCallback, useRef, useState } from "react";+import { useCallback, useEffect, useRef, useState } from "react";import { measureApi, metricApi } from "metabase/api";import { getMetadata } from "metabase/selectors/metadata";@@ -15,19 +15,30 @@ import type { MeasureId } from "metabase-types/api";import type { MetricId } from "metabase-types/api/metric";import type {+ MetricDefinitionEntry,MetricSourceId,MetricsViewerDefinitionEntry,+ MetricsViewerFormulaEntity,MetricsViewerPageState,MetricsViewerTabState,StoredMetricsViewerTab,} from "../types/viewer-state";-import { getInitialMetricsViewerPageState } from "../types/viewer-state";+import {+ getInitialMetricsViewerPageState,+ isExpressionEntry,+ isMetricEntry,+} from "../types/viewer-state";import { buildBinnedBreakoutDefinition } from "../utils/definition-builder";+import { getEffectiveDefinitionEntry } from "../utils/definition-entries";+import { computeMetricSlots } from "../utils/metric-slots";+import { remapDimensionMappings } from "../utils/remap-dimension-mappings";import {createMeasureSourceId,createMetricSourceId,} from "../utils/source-ids";+import { getTabConfig } from "../utils/tab-config";import { computeDefaultTabs, findMatchingDimensionForTab } from "../utils/tabs";+import { applySerializedDefinitionInfo } from "../utils/url-serialization";async function loadMetricDefinition(dispatch: ReturnType<typeof useDispatch>,@@ -76,61 +87,134 @@ function getValidSelectedTabId(return selectedTabExists ? currentSelectedId : (newTabs[0]?.id ?? null);}-function addDefinitionToTabs(+/**+ * For each tab, find slots that have no dimension assigned yet but whose+ * definition IS loaded, and try to smart-match a dimension using the same+ * logic as `addDefinitionToTabs`. This handles both timing orderings:+ * - definition loaded before formula committed (called from setFormulaEntities)+ * - formula committed before definition loaded (called from updateDefinition)+ */+function assignDimensionsForUnmappedSlots(tabs: MetricsViewerTabState[],- definitionEntries: MetricsViewerDefinitionEntry[],- newDefId: MetricSourceId,- newDef: MetricDefinition,+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>,+ formulaEntities: MetricsViewerFormulaEntity[],): MetricsViewerTabState[] {- const existingDefinitions = objectFromEntries(- definitionEntries- .filter((entry) => entry.id !== newDefId)- .map((entry) => [entry.id, entry.definition] as const),- );+ const slots = computeMetricSlots(formulaEntities);+ if (slots.length === 0) {+ return tabs;+ }++ const slotIndexToSourceId = new Map<number, MetricSourceId>();+ for (const slot of slots) {+ slotIndexToSourceId.set(slot.slotIndex, slot.sourceId);+ }return tabs.map((tab) => {- if (newDefId in tab.dimensionMapping || tab.label == null) {+ if (tab.label == null) {return tab;}- const activeMappings = objectFromEntries(- getObjectEntries(tab.dimensionMapping).filter(- (entry): entry is [MetricSourceId, string] => entry[1] != null,- ),- );+ // Collect unmapped slots grouped by sourceId.+ const unmappedBySource = new Map<+ MetricSourceId,+ { slotIndices: number[]; definition: MetricDefinition }+ >();++ for (const slot of slots) {+ const existing = tab.dimensionMapping[slot.slotIndex];+ if (existing !== undefined) {+ continue; // already mapped (even if null — that's an explicit clear)+ }+ const defEntry = definitions[slot.sourceId];+ if (!defEntry?.definition) {+ continue; // definition not loaded yet+ }+ let group = unmappedBySource.get(slot.sourceId);+ if (!group) {+ group = { slotIndices: [], definition: defEntry.definition };+ unmappedBySource.set(slot.sourceId, group);+ }+ group.slotIndices.push(slot.slotIndex);+ }++ if (unmappedBySource.size === 0) {+ return tab;+ }++ // Build stored-tab representation for matching.+ const activeMappings: Record<number, string> = {};+ for (const [key, value] of getObjectEntries(tab.dimensionMapping)) {+ if (value != null) {+ activeMappings[Number(key)] = value;+ }+ }const storedTab: StoredMetricsViewerTab = {id: tab.id,type: tab.type,label: tab.label,- dimensionsBySource: activeMappings,+ dimensionBySlotIndex: activeMappings,};- const matchingDimension = findMatchingDimensionForTab(- newDef,- storedTab,- existingDefinitions,- );-- if (matchingDimension) {- return {- ...tab,- dimensionMapping: {- ...tab.dimensionMapping,- [newDefId]: matchingDimension,- },- };+ let newMappings: Record<number, string> | null = null;++ for (const [sourceId, { slotIndices, definition }] of unmappedBySource) {+ const existingDefinitions = objectFromEntries(+ Object.values(definitions)+ .filter((entry) => entry.id !== sourceId && entry.definition != null)+ .map((entry) => [entry.id, entry.definition] as const),+ );++ const matchingDimension = findMatchingDimensionForTab(+ definition,+ storedTab,+ existingDefinitions,+ slotIndexToSourceId,+ );++ if (matchingDimension) {+ if (!newMappings) {+ newMappings = {};+ }+ for (const idx of slotIndices) {+ newMappings[idx] = matchingDimension;+ }+ }}- return tab;+ if (!newMappings) {+ return tab;+ }++ return {+ ...tab,+ dimensionMapping: {+ ...tab.dimensionMapping,+ ...newMappings,+ },+ };});}+function areTabDimensionsValid(tab: MetricsViewerTabState): boolean {+ const tabConfig = getTabConfig(tab.type);+ return (+ Object.values(tab.dimensionMapping).filter(isNotNull).length >=+ tabConfig.minDimensions+ );+}+export interface UseViewerStateResult {state: MetricsViewerPageState;loadingIds: Set<MetricSourceId>;+ initialLoadComplete: boolean;+ setInitialLoadComplete: (initialLoadComplete: boolean) => void;removeDefinition: (id: MetricSourceId) => void;updateDefinition: (id: MetricSourceId, definition: MetricDefinition) => void;+ setFormulaEntities: (+ entities: MetricsViewerFormulaEntity[],+ slotMapping?: Map<number, number>,+ ) => void;selectTab: (tabId: string) => void;addTab: (tab: MetricsViewerTabState) => void;@@ -138,15 +222,12 @@ export interface UseViewerStateResult {updateTab: (tabId: string, updates: Partial<MetricsViewerTabState>) => void;setDefinitionDimension: (tabId: string,- definitionId: MetricSourceId,+ slotIndex: number,dimension: DimensionMetadata,) => void;- removeDefinitionDimension: (- tabId: string,- definitionId: MetricSourceId,- ) => void;+ removeDefinitionDimension: (tabId: string, slotIndex: number) => void;setBreakoutDimension: (- id: MetricSourceId,+ entity: MetricDefinitionEntry,dimension: ProjectionClause | undefined,) => void;@@ -182,33 +263,23 @@ export function useViewerState(): UseViewerStateResult {const loadingRef = useRef<Set<MetricSourceId>>(new Set());const [loadingIds, setLoadingIds] = useState<Set<MetricSourceId>>(new Set());- const initialize = useCallback(- (newState: MetricsViewerPageState) => setState(newState),- [],- );+ const [initialLoadComplete, setInitialLoadComplete] = useState(false);++ const initialize: (newState: MetricsViewerPageState) => void = setState;const addDefinition = useCallback((entry: MetricsViewerDefinitionEntry) =>setState((prev) => {- if (prev.definitions.some((existing) => existing.id === entry.id)) {+ if (entry.id in prev.definitions) {return prev;}- const newDefinitions = [...prev.definitions, entry];-- if (prev.tabs.length === 0 || !entry.definition) {- return { ...prev, definitions: newDefinitions };- }-return {...prev,- definitions: newDefinitions,- tabs: addDefinitionToTabs(- prev.tabs,- newDefinitions,- entry.id,- entry.definition,- ),+ definitions: {+ ...prev.definitions,+ [entry.id]: entry,+ },};}),[],@@ -217,15 +288,36 @@ export function useViewerState(): UseViewerStateResult {const removeDefinition = useCallback((id: MetricSourceId) =>setState((prev) => {- const newDefinitions = prev.definitions.filter(- (entry) => entry.id !== id,+ const { [id]: _, ...newDefinitions } = prev.definitions;++ // Find slot indices being removed (slots for this sourceId)+ const slots = computeMetricSlots(prev.formulaEntities);+ const removedSlotIndices = new Set(+ slots.filter((s) => s.sourceId === id).map((s) => s.slotIndex),);- const newTabs = prev.tabs- .map((tab) => {- const { [id]: _, ...rest } = tab.dimensionMapping;- return { ...tab, dimensionMapping: rest };- })- .filter((tab) => Object.values(tab.dimensionMapping).some(isNotNull));++ const newTabs =+ // scalar tab is always valid, but we want to remove it if there are no definitions+ // so that adding a new definition triggers computeDefaultTabs+ Object.keys(newDefinitions).length === 0+ ? []+ : prev.tabs+ .map((tab) => {+ // Remove entries for removed slot indices.+ // Don't shift — remapDimensionMappings handles that+ // when formulaEntities are updated separately.+ const newMapping: Record<number, string | null> = {};+ for (const [key, value] of getObjectEntries(+ tab.dimensionMapping,+ )) {+ const idx = Number(key);+ if (!removedSlotIndices.has(idx)) {+ newMapping[idx] = value;+ }+ }+ return { ...tab, dimensionMapping: newMapping };+ })+ .filter((tab) => areTabDimensionsValid(tab));return {...prev,@@ -240,24 +332,27 @@ export function useViewerState(): UseViewerStateResult {const updateDefinition = useCallback((id: MetricSourceId, definition: MetricDefinition) =>setState((prev) => {- const newDefinitions = prev.definitions.map((entry) =>- entry.id === id ? { ...entry, definition } : entry,- );+ const existing = prev.definitions[id];+ if (!existing) {+ return prev;+ }++ const newDefinitions = {+ ...prev.definitions,+ [id]: { ...existing, definition },+ };if (prev.tabs.length === 0) {return { ...prev, definitions: newDefinitions };}- const updatedTabs = addDefinitionToTabs(+ const updatedTabs = assignDimensionsForUnmappedSlots(prev.tabs,newDefinitions,- id,- definition,+ prev.formulaEntities,);- const newTabs = updatedTabs.filter((tab) =>- Object.values(tab.dimensionMapping).some(isNotNull),- );+ const newTabs = updatedTabs.filter((tab) => areTabDimensionsValid(tab));return {...prev,@@ -272,23 +367,53 @@ export function useViewerState(): UseViewerStateResult {const replaceDefinition = useCallback((oldId: MetricSourceId, newEntry: MetricsViewerDefinitionEntry) =>setState((prev) => {- const index = prev.definitions.findIndex((entry) => entry.id === oldId);- if (index === -1) {+ if (!(oldId in prev.definitions)) {return prev;}- const newDefinitions = [...prev.definitions];- newDefinitions[index] = newEntry;+ // Check if any expression token still references the old sourceId.+ // If so, keep the old definition so the expression remains valid.+ const expressionStillReferencesOld = prev.formulaEntities.some(+ (fe) =>+ fe.type === "expression" &&+ fe.tokens.some((t) => t.type === "metric" && t.sourceId === oldId),+ );++ const { [oldId]: _oldDef, ...rest } = prev.definitions;+ const newDefinitions = expressionStillReferencesOld+ ? { ...prev.definitions, [newEntry.id]: newEntry }+ : { ...rest, [newEntry.id]: newEntry };++ // Update formulaEntities: replace standalone metric refs with the new one+ // (expression tokens keep referencing the old sourceId)+ const newFormulaEntities = prev.formulaEntities.map((fe) => {+ if (fe.type === "metric" && fe.id === oldId) {+ return { ...newEntry, type: "metric" as const };+ }+ return fe;+ });+ // Find slot indices that were replaced+ const slots = computeMetricSlots(prev.formulaEntities);+ const replacedSlotIndices = new Set(+ slots.filter((s) => s.sourceId === oldId).map((s) => s.slotIndex),+ );++ // Remove dimension mappings for replaced slot indices (new metric has different dimensions)const newTabs = prev.tabs.map((tab) => {- if (!(oldId in tab.dimensionMapping)) {- return tab;+ const newMapping = { ...tab.dimensionMapping };+ for (const idx of replacedSlotIndices) {+ delete newMapping[idx];}- const { [oldId]: _, ...rest } = tab.dimensionMapping;- return { ...tab, dimensionMapping: rest };+ return { ...tab, dimensionMapping: newMapping };});- return { ...prev, definitions: newDefinitions, tabs: newTabs };+ return {+ ...prev,+ definitions: newDefinitions,+ formulaEntities: newFormulaEntities,+ tabs: newTabs,+ };}),[],);@@ -304,9 +429,14 @@ export function useViewerState(): UseViewerStateResult {if (prev.tabs.some((existing) => existing.id === tab.id)) {return prev;}+ const newTabs = assignDimensionsForUnmappedSlots(+ [...prev.tabs, tab],+ prev.definitions,+ prev.formulaEntities,+ );return {...prev,- tabs: [...prev.tabs, tab],+ tabs: newTabs,selectedTabId:prev.selectedTabId == null ? tab.id : prev.selectedTabId,};@@ -343,15 +473,15 @@ export function useViewerState(): UseViewerStateResult {);const setDefinitionDimension = useCallback(- (- tabId: string,- definitionId: MetricSourceId,- dimension: DimensionMetadata,- ) =>+ (tabId: string, slotIndex: number, dimension: DimensionMetadata) =>setState((prev) => {- const entry = prev.definitions.find(- (defEntry) => defEntry.id === definitionId,- );+ const slots = computeMetricSlots(prev.formulaEntities);+ const slot = slots[slotIndex];+ if (!slot) {+ return prev;+ }++ const entry = prev.definitions[slot.sourceId];const def = entry?.definition;const dimId = def? LibMetric.dimensionValuesInfo(def, dimension).id@@ -367,20 +497,12 @@ export function useViewerState(): UseViewerStateResult {if (tab.id !== tabId) {return tab;}- const previousDimId = tab.dimensionMapping[definitionId];- const dimensionChanged = previousDimId !== dimId;return {...tab,dimensionMapping: {...tab.dimensionMapping,- [definitionId]: dimId,+ [slotIndex]: dimId,},- projectionConfig: dimensionChanged- ? {- ...tab.projectionConfig,- dimensionFilter: undefined,- }- : tab.projectionConfig,};}),};@@ -389,7 +511,7 @@ export function useViewerState(): UseViewerStateResult {);const removeDefinitionDimension = useCallback(- (tabId: string, definitionId: MetricSourceId) =>+ (tabId: string, slotIndex: number) =>setState((prev) => ({...prev,tabs: prev.tabs.map((tab) => {@@ -398,47 +520,102 @@ export function useViewerState(): UseViewerStateResult {}return {...tab,- dimensionMapping: { ...tab.dimensionMapping, [definitionId]: null },- projectionConfig: {- ...tab.projectionConfig,- dimensionFilter: undefined,- },+ dimensionMapping: { ...tab.dimensionMapping, [slotIndex]: null },};}),})),[],);- const setBreakoutDimension = useCallback(- (id: MetricSourceId, dimension: ProjectionClause | undefined) =>- setState((prev) => ({- ...prev,- definitions: prev.definitions.map((entry) => {- if (entry.id !== id || !entry.definition) {- return entry;+ const setFormulaEntities = useCallback(+ (+ formulaEntities: MetricsViewerFormulaEntity[],+ slotMapping?: Map<number, number>,+ ) =>+ setState((prev) => {+ // When a slotMapping is provided (from commitAndCollapse or+ // handleRemoveItem), use it to remap dimension mappings efficiently.+ // Otherwise the caller is not changing entity structure (paren cleanup,+ // filter/breakout changes, URL restore) so tabs are kept as-is.+ const reconciledTabs = slotMapping+ ? remapDimensionMappings(prev.tabs, slotMapping, formulaEntities)+ : prev.tabs;+ let tabs = assignDimensionsForUnmappedSlots(+ reconciledTabs,+ prev.definitions,+ formulaEntities,+ );++ // When tabs are empty (e.g. all metrics were removed then one was+ // added back), generate default tabs now that formulaEntities includes+ // the new metric and its definition may already be loaded.+ if (tabs.length === 0) {+ const metricSlots = computeMetricSlots(formulaEntities);+ if (metricSlots.length > 0) {+ const definitionsBySourceId: Record<+ MetricSourceId,+ MetricDefinition | null+ > = {};+ for (const [id, entry] of Object.entries(prev.definitions)) {+ definitionsBySourceId[id as MetricSourceId] =+ entry.definition ?? null;+ }+ tabs = computeDefaultTabs(definitionsBySourceId, metricSlots);}+ }- let newDefinition = entry.definition;- const existingProjections = LibMetric.projections(newDefinition);+ return {+ ...prev,+ formulaEntities,+ tabs,+ };+ }),+ [],+ );++ const setBreakoutDimension = useCallback(+ (entity: MetricDefinitionEntry, dimension: ProjectionClause | undefined) =>+ setState((prev) => {+ const defEntry = getEffectiveDefinitionEntry(entity, prev.definitions);+ if (!defEntry?.definition) {+ return prev;+ }++ const entityIndex = prev.formulaEntities.indexOf(entity);+ if (entityIndex === -1) {+ return prev;+ }++ let newDefinition: MetricDefinition | null = null;++ if (dimension) {+ let baseDef = defEntry.definition;+ const existingProjections = LibMetric.projections(baseDef);for (const proj of existingProjections) {- newDefinition = LibMetric.removeClause(newDefinition, proj);+ baseDef = LibMetric.removeClause(baseDef, proj);}+ newDefinition = buildBinnedBreakoutDefinition(baseDef, dimension);+ }- if (dimension) {- newDefinition = buildBinnedBreakoutDefinition(- newDefinition,- dimension,- );- }+ const newEntities = [...prev.formulaEntities];+ newEntities[entityIndex] = {+ ...entity,+ definition: newDefinition,+ };- return { ...entry, definition: newDefinition };- }),- })),+ return {+ ...prev,+ formulaEntities: newEntities,+ };+ }),[],);const clearLoading = useCallback((id: MetricSourceId) => {loadingRef.current.delete(id);+ if (loadingRef.current.size === 0) {+ setInitialLoadComplete(true);+ }setLoadingIds((prev) => {const next = new Set(prev);next.delete(id);@@ -467,25 +644,33 @@ export function useViewerState(): UseViewerStateResult {// but the temporarily incorrect ordering breaks our handling of the browser's forward/back buttons// so wrap updateDefinition in a setTimeout to ensure it runs after addDefinitionsetTimeout(() => {- const definition = transform- ? transform(rawDefinition)- : rawDefinition;- updateDefinition(id, definition);-- if (stateRef.current.tabs.length === 0) {- const definitions: Record<MetricSourceId, MetricDefinition | null> =- {+ try {+ const definition = transform+ ? transform(rawDefinition)+ : rawDefinition;+ updateDefinition(id, definition);++ if (stateRef.current.tabs.length === 0) {+ const definitions: Record<+ MetricSourceId,+ MetricDefinition | null+ > = {[id]: definition,};- const tabs = computeDefaultTabs(definitions, [id]);- for (const tab of tabs) {- addTab(tab);+ const metricSlots = computeMetricSlots(+ stateRef.current.formulaEntities,+ );+ const tabs = computeDefaultTabs(definitions, metricSlots);+ for (const tab of tabs) {+ addTab(tab);+ }}+ } finally {+ clearLoading(id);}}, 0);} catch {removeDefinition(id);- } finally {clearLoading(id);}},@@ -504,17 +689,23 @@ export function useViewerState(): UseViewerStateResult {loadingRef.current.add(newId);setLoadingIds((prev) => new Set(prev).add(newId));- replaceDefinition(oldSourceId, { id: newId, definition: null });+ replaceDefinition(oldSourceId, {+ id: newId,+ definition: null,+ });try {const definition = await loader();// see comment above setTimeout in loadDefinitionsetTimeout(() => {- updateDefinition(newId, definition);+ try {+ updateDefinition(newId, definition);+ } finally {+ clearLoading(newId);+ }}, 0);} catch {removeDefinition(newId);- } finally {clearLoading(newId);}},@@ -563,12 +754,70 @@ export function useViewerState(): UseViewerStateResult {[loadAndReplace, dispatch, store],);+ // as definitions load, apply SerializedDefinitionInfo to formulaEntities+ useEffect(() => {+ let changed = false;+ const updatedEntities = state.formulaEntities.map((entity) => {+ if (+ isMetricEntry(entity) &&+ entity.serializedDefinitionInfo &&+ !entity.definition+ ) {+ const baseDef = state.definitions[entity.id]?.definition;+ if (baseDef) {+ changed = true;+ return {+ ...entity,+ definition: applySerializedDefinitionInfo(+ baseDef,+ entity.serializedDefinitionInfo,+ ),+ serializedDefinitionInfo: undefined,+ };+ }+ }+ if (isExpressionEntry(entity)) {+ let tokenChanged = false;+ const updatedTokens = entity.tokens.map((token) => {+ if (+ token.type === "metric" &&+ token.serializedDefinitionInfo &&+ !token.definition+ ) {+ const baseDef = state.definitions[token.sourceId]?.definition;+ if (baseDef) {+ tokenChanged = true;+ changed = true;+ return {+ ...token,+ definition: applySerializedDefinitionInfo(+ baseDef,+ token.serializedDefinitionInfo,+ ),+ serializedDefinitionInfo: undefined,+ };+ }+ }+ return token;+ });+ return tokenChanged ? { ...entity, tokens: updatedTokens } : entity;+ }+ return entity;+ });+ if (changed) {+ setFormulaEntities(updatedEntities);+ }+ }, [state.definitions, state.formulaEntities, setFormulaEntities]);+return {state,loadingIds,+ initialLoadComplete,+ setInitialLoadComplete,removeDefinition,updateDefinition,+ setFormulaEntities,selectTab,addTab,diff --git a/frontend/src/metabase/metrics-viewer/hooks/use-viewer-url.ts b/frontend/src/metabase/metrics-viewer/hooks/use-viewer-url.tsindex 0bd707577fe..96c33ec306c 100644--- a/frontend/src/metabase/metrics-viewer/hooks/use-viewer-url.ts+++ b/frontend/src/metabase/metrics-viewer/hooks/use-viewer-url.ts@@ -1,38 +1,34 @@import type { Location } from "history";import { useEffect, useRef } from "react";import { push, replace } from "react-router-redux";+import { t } from "ttag";+import { useToast } from "metabase/common/hooks";import { useDispatch } from "metabase/utils/redux";import * as Urls from "metabase/utils/urls";-import type { MeasureId, TemporalUnit } from "metabase-types/api";+import type { MeasureId } from "metabase-types/api";import type { MetricId } from "metabase-types/api/metric";-import type {- MetricSourceId,- MetricsViewerPageState,- MetricsViewerTabState,+import {+ type MetricsViewerFormulaEntity,+ type MetricsViewerPageState,+ type MetricsViewerTabState,+ isExpressionEntry,+ isMetricEntry,} from "../types/viewer-state";-import type { SourceFilter } from "../utils/dimension-filters";-import { createSourceId } from "../utils/source-ids";+import { parseSourceId } from "../utils/source-ids";import {type SerializedMetricsViewerPageState,decodeState,+ deserializeFormulaEntities,deserializeTab,encodeState,stateToSerializedState,} from "../utils/url-serialization";-export interface BreakoutInfo {- dimensionId: string;- temporalUnit?: TemporalUnit;- binning?: string;-}-export interface LoadSourcesRequest {metricIds: MetricId[];measureIds: MeasureId[];- breakoutBySourceId?: Record<MetricSourceId, BreakoutInfo>;- filtersBySourceId?: Record<MetricSourceId, SourceFilter[]>;}export function useViewerUrl(@@ -40,96 +36,142 @@ export function useViewerUrl(initialize: (state: MetricsViewerPageState) => void,onLoadSources: (request: LoadSourcesRequest) => void,location: Location,+ setFormulaEntities: (+ entities: MetricsViewerFormulaEntity[],+ slotMapping?: Map<number, number>,+ ) => void,+ setInitialLoadComplete: (initialLoadComplete: boolean) => void,): void {const dispatch = useDispatch();+ const [sendToast] = useToast();const lastHashRef = useRef<string | null>(null);// sync URL to stateuseEffect(() => {- let hash = location.hash.slice(1);- let serializedState: SerializedMetricsViewerPageState;-- if (!hash) {- const params = new URLSearchParams(location.search);- const metricId = params.get("metricId");- if (metricId) {- serializedState = {- sources: [{ type: "metric", id: parseInt(metricId, 10) }],- tabs: [],- selectedTabId: null,- };- const encodedHash = encodeState(serializedState);- if (encodedHash === undefined) {- return;+ try {+ let hash = location.hash.slice(1);+ let serializedState: SerializedMetricsViewerPageState;++ if (!hash) {+ const params = new URLSearchParams(location.search);+ const metricId = params.get("metricId");+ if (metricId) {+ serializedState = {+ formulaEntities: [{ type: "metric", id: parseInt(metricId, 10) }],+ tabs: [],+ selectedTabId: null,+ };+ const encodedHash = encodeState(serializedState);+ if (encodedHash === undefined) {+ setInitialLoadComplete(true);+ return;+ }+ hash = encodedHash;+ } else {+ serializedState = decodeState(hash);}- hash = encodedHash;} else {serializedState = decodeState(hash);}- } else {- serializedState = decodeState(hash);- }- if (hash === lastHashRef.current) {- return;- }- lastHashRef.current = hash;-- const metricIds: MetricId[] = [];- const measureIds: MeasureId[] = [];- const breakoutBySourceId: Record<MetricSourceId, BreakoutInfo> = {};- const filtersBySourceId: Record<MetricSourceId, SourceFilter[]> = {};-- for (const source of serializedState.sources) {- const sourceId = createSourceId(source.id, source.type);-- if (source.type === "metric") {- metricIds.push(source.id);- } else if (source.type === "measure") {- measureIds.push(source.id);+ if (hash === lastHashRef.current) {+ setInitialLoadComplete(true);+ return;}+ lastHashRef.current = hash;- if (source.breakout) {- breakoutBySourceId[sourceId] = {- dimensionId: source.breakout,- temporalUnit: source.breakoutTemporalUnit,- binning: source.breakoutBinning,- };- }+ if (serializedState.tabs.length > 0) {+ const tabs: MetricsViewerTabState[] =+ serializedState.tabs.map(deserializeTab);- if (source.filters && source.filters.length > 0) {- filtersBySourceId[sourceId] = source.filters;+ initialize({+ definitions: {},+ formulaEntities: [],+ tabs,+ selectedTabId: serializedState.selectedTabId,+ });}- }- if (serializedState.tabs.length > 0) {- const tabs: MetricsViewerTabState[] =- serializedState.tabs.map(deserializeTab);+ const metricIds: MetricId[] = [];+ const measureIds: MeasureId[] = [];++ const restoredFormulaEntities =+ deserializeFormulaEntities(serializedState);- initialize({- definitions: [],- tabs,- selectedTabId: serializedState.selectedTabId,+ restoredFormulaEntities.forEach((entity) => {+ if (isMetricEntry(entity)) {+ const { type, id } = parseSourceId(entity.id);+ if (type === "metric") {+ metricIds.push(id);+ } else if (type === "measure") {+ measureIds.push(id);+ }+ }+ if (isExpressionEntry(entity)) {+ entity.tokens.forEach((token) => {+ if (token.type === "metric") {+ const { type, id } = parseSourceId(token.sourceId);+ if (type === "metric") {+ metricIds.push(id);+ } else if (type === "measure") {+ measureIds.push(id);+ }+ }+ });+ }});- }- if (metricIds.length > 0 || measureIds.length > 0) {- const hasBreakouts = Object.keys(breakoutBySourceId).length > 0;- const hasFilters = Object.keys(filtersBySourceId).length > 0;- onLoadSources({- metricIds,- measureIds,- breakoutBySourceId: hasBreakouts ? breakoutBySourceId : undefined,- filtersBySourceId: hasFilters ? filtersBySourceId : undefined,+ if (metricIds.length > 0 || measureIds.length > 0) {+ onLoadSources({+ metricIds,+ measureIds,+ });+ } else {+ setInitialLoadComplete(true);+ }++ if (restoredFormulaEntities.length > 0) {+ setFormulaEntities(restoredFormulaEntities);+ }+ } catch (error) {+ console.error(error);+ setInitialLoadComplete(true);+ sendToast({+ icon: "warning_triangle_filled",+ iconColor: "warning",+ message: t`There was a problem restoring the page state`,});}- }, [location, dispatch, initialize, onLoadSources]);+ }, [+ location,+ dispatch,+ initialize,+ onLoadSources,+ setFormulaEntities,+ setInitialLoadComplete,+ sendToast,+ ]);// sync state to URLuseEffect(() => {+ // don't update URL until state is fully resolved+ // definitions are loaded and there are no outstanding SerializedDefinitionInfos+ const definitionValues = Object.values(state.definitions);+ const hasPendingSerializedInfo = state.formulaEntities.some((entity) => {+ if (isMetricEntry(entity) && entity.serializedDefinitionInfo) {+ return true;+ }+ if (isExpressionEntry(entity)) {+ return entity.tokens.some(+ (token) => token.type === "metric" && token.serializedDefinitionInfo,+ );+ }+ return false;+ });if (- state.definitions.length === 0 ||- state.definitions.some((entry) => entry.definition === null)+ definitionValues.length === 0 ||+ definitionValues.some((entry) => entry.definition === null) ||+ hasPendingSerializedInfo) {return;}diff --git a/frontend/src/metabase/metrics-viewer/pages/MetricsViewerPage/MetricsViewerPage.tsx b/frontend/src/metabase/metrics-viewer/pages/MetricsViewerPage/MetricsViewerPage.tsxindex 27bc9a64c9f..badb6caa4ab 100644--- a/frontend/src/metabase/metrics-viewer/pages/MetricsViewerPage/MetricsViewerPage.tsx+++ b/frontend/src/metabase/metrics-viewer/pages/MetricsViewerPage/MetricsViewerPage.tsx@@ -1,7 +1,8 @@import type { Location } from "history";import { useCallback } from "react";-import { Box, Flex, Stack } from "metabase/ui";+import { LoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper";+import { Box, Center, Flex, Stack } from "metabase/ui";import {trackMetricsViewerMetricAdded,@@ -27,22 +28,27 @@ export type MetricsViewerPageProps = {};export function MetricsViewerPage(props: MetricsViewerPageProps) {+ const useMetricsViewerResult = useMetricsViewer(props);+const {definitions,+ formulaEntities,tabs,activeTab,activeTabId,- errorsByDefinitionId,- modifiedDefinitions,+ initialLoadComplete,+ queriesAreLoading,+ queriesError,+ modifiedDefinitionsBySlotIndex,+ metricSlots,series,- cardIdToDefinitionId,+ cardIdToEntityIndex,activeBreakoutColors,sourceColors,selectedMetrics,sourceOrder,sourceDataById,availableDimensions,- isExecuting,addMetric,swapMetric,removeMetric,@@ -52,9 +58,9 @@ export function MetricsViewerPage(props: MetricsViewerPageProps) {updateActiveTab,changeTabDimension,removeTabDimension,- updateDefinition,setBreakoutDimension,- } = useMetricsViewer(props);+ setFormulaEntities,+ } = useMetricsViewerResult;const handleAddMetric = useCallback((metric: SelectedMetric) => {@@ -72,29 +78,39 @@ export function MetricsViewerPage(props: MetricsViewerPageProps) {[removeMetric],);- const hasDefinitions = definitions.length > 0;- const hasLoadedDefinitions = definitions.some(+ if (!initialLoadComplete) {+ // parsing formulas won't work until the initial set of definitions are loaded+ return (+ <Center h="100%">+ <LoadingAndErrorWrapper loading />+ </Center>+ );+ }++ const hasDefinitions = Object.keys(definitions).length > 0;+ const hasLoadedDefinitions = Object.values(definitions).some((entry) => entry.definition != null,);return (<Stack h="100%" gap={0} className={S.root}>- <Box px="lg" pt="md" flex="0 0 auto">+ <Box px="xl" pt="md" flex="0 0 auto"><MetricSearchPanel+ definitions={definitions}+ formulaEntities={formulaEntities}+ onFormulaEntitiesChange={setFormulaEntities}selectedMetrics={selectedMetrics}metricColors={sourceColors}- definitions={definitions}onAddMetric={handleAddMetric}onRemoveMetric={handleRemoveMetric}onSwapMetric={swapMetric}onSetBreakout={setBreakoutDimension}- onUpdateDefinition={updateDefinition}/></Box><Flex flex="1 1 auto" mih={0}><Stack gap={0} flex={1} mih={0} miw={0}>{hasDefinitions && (- <Box px="lg" pt="xs" flex="0 0 auto" className={S.tabsBar}>+ <Box px="lg" pt="sm" flex="0 0 auto" className={S.tabsBar}><MetricsViewerTabstabs={tabs}activeTabId={activeTabId}@@ -123,19 +139,23 @@ export function MetricsViewerPage(props: MetricsViewerPageProps) {) : activeTab ? (<MetricsViewerTabContentdefinitions={definitions}+ formulaEntities={formulaEntities}tab={activeTab}- errorsByDefinitionId={errorsByDefinitionId}- modifiedDefinitions={modifiedDefinitions}+ queriesAreLoading={queriesAreLoading}+ queriesError={queriesError}+ modifiedDefinitionsBySlotIndex={+ modifiedDefinitionsBySlotIndex+ }+ metricSlots={metricSlots}series={series}- cardIdToDefinitionId={cardIdToDefinitionId}+ cardIdToEntityIndex={cardIdToEntityIndex}sourceColors={sourceColors}- isExecuting={isExecuting}onTabUpdate={updateActiveTab}- onDimensionChange={(defId, dim) =>- changeTabDimension(activeTab.id, defId, dim)+ onDimensionChange={(slotIndex, dim) =>+ changeTabDimension(activeTab.id, slotIndex, dim)}- onDimensionRemove={(defId) =>- removeTabDimension(activeTab.id, defId)+ onDimensionRemove={(slotIndex) =>+ removeTabDimension(activeTab.id, slotIndex)}/>) : hasLoadedDefinitions ? (@@ -143,6 +163,7 @@ export function MetricsViewerPage(props: MetricsViewerPageProps) {) : null}</Flex><BreakoutLegend+ formulaEntities={formulaEntities}definitions={definitions}activeBreakoutColors={activeBreakoutColors}/>diff --git a/frontend/src/metabase/metrics-viewer/types/viewer-state.ts b/frontend/src/metabase/metrics-viewer/types/viewer-state.tsindex 879c3d23bb4..6bb1a8041fb 100644--- a/frontend/src/metabase/metrics-viewer/types/viewer-state.ts+++ b/frontend/src/metabase/metrics-viewer/types/viewer-state.ts@@ -4,30 +4,54 @@ import type {CardDisplayType,ConcreteTableId,DimensionId,+ MathOperator,TemporalUnit,VisualizationSettings,} from "metabase-types/api";import type { DimensionFilterValue } from "../utils/dimension-filters";+import type { SerializedDefinitionInfo } from "../utils/url-serialization";// ── Core types ──export type MetricsViewerDisplayType = Extract<CardDisplayType,- "line" | "area" | "bar" | "map" | "row" | "pie" | "scatter"+ "line" | "area" | "bar" | "map" | "scatter" | "scalar">;export type MetricSourceId = `metric:${number}` | `measure:${number}`;+export type MetricExpressionId = `expression:${string}`;-export type MetricsViewerTabType = DimensionType;+export type MetricsViewerTabType = DimensionType | "scalar";export interface StoredMetricsViewerTab {id: string;type: MetricsViewerTabType;label: string;- dimensionsBySource: Record<MetricSourceId, DimensionId>;+ dimensionBySlotIndex: Record<number, DimensionId>;}+// ── Expression sub-tokens ──++export type ExpressionMetricSubToken = {+ type: "metric";+ sourceId: MetricSourceId;+ count: number;+ definition?: MetricDefinition;+ serializedDefinitionInfo?: SerializedDefinitionInfo;+};++/**+ * Tokens that appear inside a single expression formula.+ * These are the building blocks of an expression definition entry.+ */+export type ExpressionSubToken =+ | ExpressionMetricSubToken+ | { type: "constant"; value: number }+ | { type: "operator"; op: MathOperator }+ | { type: "open-paren" }+ | { type: "close-paren" };+// ── Definition types ──/**@@ -45,6 +69,34 @@ export interface MetricsViewerDefinitionEntry {definition: MetricDefinition | null;}+export type MetricDefinitionEntry = MetricsViewerDefinitionEntry & {+ type: "metric";+ serializedDefinitionInfo?: SerializedDefinitionInfo;+};++export type ExpressionDefinitionEntry = {+ id: MetricExpressionId;+ type: "expression";+ name: string;+ tokens: ExpressionSubToken[];+};++export type MetricsViewerFormulaEntity =+ | MetricDefinitionEntry+ | ExpressionDefinitionEntry;++export function isMetricEntry(+ entry: MetricsViewerFormulaEntity,+): entry is MetricDefinitionEntry {+ return entry.type === "metric";+}++export function isExpressionEntry(+ entry: MetricsViewerFormulaEntity,+): entry is ExpressionDefinitionEntry {+ return entry.type === "expression";+}+// ── Tab state ──export interface MetricsViewerTabProjectionConfig {@@ -59,21 +111,23 @@ export interface MetricsViewerTabState {label: string | null;display: MetricsViewerDisplayType;visualizationSettings?: Partial<VisualizationSettings>;- dimensionMapping: Record<MetricSourceId, DimensionId | null>;+ dimensionMapping: Record<number, DimensionId | null>;projectionConfig: MetricsViewerTabProjectionConfig;}// ── Page state ──export interface MetricsViewerPageState {- definitions: MetricsViewerDefinitionEntry[];- tabs: MetricsViewerTabState[];+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>; // pristine definitions for unique metrics used in formula+ formulaEntities: MetricsViewerFormulaEntity[]; // specific items used in formula, definitions there contains filters+ tabs: MetricsViewerTabState[]; // visualization settings for a tabselectedTabId: string | null;}export function getInitialMetricsViewerPageState(): MetricsViewerPageState {return {- definitions: [],+ definitions: {},+ formulaEntities: [],tabs: [],selectedTabId: null,};@@ -89,14 +143,15 @@ export type BreakoutColorMap = Map<string, string>;/*** Values are either BreakoutColorMap or a single color for non-breakout sources.*/-export type SourceBreakoutColorMap = Partial<- Record<MetricSourceId, BreakoutColorMap | string>+export type SourceBreakoutColorMap = Record<+ number,+ BreakoutColorMap | string | undefined>;/*** For consumers that expect an array of colors and don't care about breakout values.*/-export type SourceColorMap = Partial<Record<MetricSourceId, string[]>>;+export type SourceColorMap = Record<number, string[]>;// ── Shared display types ──diff --git a/frontend/src/metabase/metrics-viewer/utils/MetricsViewerClickActionsMode.ts b/frontend/src/metabase/metrics-viewer/utils/MetricsViewerClickActionsMode.tsindex ea66da5d000..07b1558f772 100644--- a/frontend/src/metabase/metrics-viewer/utils/MetricsViewerClickActionsMode.ts+++ b/frontend/src/metabase/metrics-viewer/utils/MetricsViewerClickActionsMode.ts@@ -8,49 +8,63 @@ import type {import * as LibMetric from "metabase-lib/metric";import type { CardId, DatetimeUnit, TemporalUnit } from "metabase-types/api";-import type {- MetricSourceId,- MetricsViewerDefinitionEntry,- MetricsViewerTabState,+import {+ type MetricDefinitionEntry,+ type MetricSourceId,+ type MetricsViewerDefinitionEntry,+ type MetricsViewerFormulaEntity,+ type MetricsViewerTabState,+ isMetricEntry,} from "../types/viewer-state";+import { getEffectiveDefinitionEntry } from "./definition-entries";import type { DimensionFilterValue } from "./dimension-filters";import { findDimensionById } from "./dimension-lookup";+import { type MetricSlot, findStandaloneSlot } from "./metric-slots";type MetricsViewerClickActionParams = {- definitions: MetricsViewerDefinitionEntry[];+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>;+ formulaEntities: MetricsViewerFormulaEntity[];+ metricSlots: MetricSlot[];tab: MetricsViewerTabState;onTabUpdate: (updates: Partial<MetricsViewerTabState>) => void;- cardIdToDefinitionId: Record<CardId, MetricSourceId>;+ cardIdToEntityIndex: Record<CardId, number>;};export class MetricsViewerClickActionsMode implements ClickActionsMode {- private definitions: MetricsViewerDefinitionEntry[];+ private definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>;+ private formulaEntities: MetricsViewerFormulaEntity[];+ private metricSlots: MetricSlot[];private tab: MetricsViewerTabState;private onTabUpdate: (updates: Partial<MetricsViewerTabState>) => void;- private cardIdToDefinitionId: Record<CardId, MetricSourceId>;+ private cardIdToEntityIndex: Record<CardId, number>;constructor({definitions,+ formulaEntities,+ metricSlots,tab,onTabUpdate,- cardIdToDefinitionId,+ cardIdToEntityIndex,}: MetricsViewerClickActionParams) {this.definitions = definitions;+ this.formulaEntities = formulaEntities;+ this.metricSlots = metricSlots;this.tab = tab;this.onTabUpdate = onTabUpdate;- this.cardIdToDefinitionId = cardIdToDefinitionId;+ this.cardIdToEntityIndex = cardIdToEntityIndex;}actionsForClick(clickObject: ClickObject): ClickAction[] {const cardId = clickObject.cardId;if (cardId == null) {return [];}- const definition = this.definitions.find(- (definition) => definition.id === this.cardIdToDefinitionId[cardId],- );+ const entityIndex = this.cardIdToEntityIndex[cardId];+ const entity = this.formulaEntities[entityIndex];const params = {definitions: this.definitions,- definition,+ entity,+ entityIndex,+ metricSlots: this.metricSlots,tab: this.tab,onTabUpdate: this.onTabUpdate,clickObject,@@ -62,20 +76,25 @@ export class MetricsViewerClickActionsMode implements ClickActionsMode {}type GetActionParams = {- definitions: MetricsViewerDefinitionEntry[];- definition: MetricsViewerDefinitionEntry | undefined; //definition that was clicked on+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>;+ entity: MetricsViewerFormulaEntity | undefined; //entity that was clicked on+ entityIndex: number | undefined;+ metricSlots: MetricSlot[];tab: MetricsViewerTabState;onTabUpdate: (updates: Partial<MetricsViewerTabState>) => void;clickObject: ClickObject;};function getZoomInTimeSeriesAction({- definition,+ definitions,+ entity,+ entityIndex,+ metricSlots,tab,onTabUpdate,clickObject,}: GetActionParams): ClickAction | undefined {- if (!definition || !definition.definition) {+ if (!entity || entityIndex == null || !isMetricEntry(entity)) {return;}const dimension = clickObject.dimensions?.[0];@@ -87,7 +106,10 @@ function getZoomInTimeSeriesAction({return;}const nextTemporalUnit = getNextTemporalUnit(- definition,+ definitions,+ entity,+ entityIndex,+ metricSlots,tab,currentTemporalUnit,);@@ -163,12 +185,22 @@ const nextTemporalUnitMap: Partial<Record<TemporalUnit, TemporalUnit>> = {};function getNextTemporalUnit(- entry: MetricsViewerDefinitionEntry,+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>,+ entity: MetricDefinitionEntry,+ entityIndex: number,+ metricSlots: MetricSlot[],tab: MetricsViewerTabState,currentUnit: TemporalUnit,): TemporalUnit | undefined {- const definition = entry.definition;- const dimensionId = tab.dimensionMapping[entry.id];+ const definition = getEffectiveDefinitionEntry(+ entity,+ definitions,+ )?.definition;+ const slot = findStandaloneSlot(metricSlots, entityIndex);+ if (!slot) {+ return undefined;+ }+ const dimensionId = tab.dimensionMapping[slot.slotIndex];if (!definition || !dimensionId) {return undefined;}diff --git a/frontend/src/metabase/metrics-viewer/utils/definition-entries.ts b/frontend/src/metabase/metrics-viewer/utils/definition-entries.tsindex 6ef73199dab..e10d3ab5fed 100644--- a/frontend/src/metabase/metrics-viewer/utils/definition-entries.ts+++ b/frontend/src/metabase/metrics-viewer/utils/definition-entries.ts@@ -1,6 +1,11 @@import * as LibMetric from "metabase-lib/metric";-import type { MetricsViewerDefinitionEntry } from "../types/viewer-state";+import type {+ ExpressionMetricSubToken,+ MetricDefinitionEntry,+ MetricSourceId,+ MetricsViewerDefinitionEntry,+} from "../types/viewer-state";export function getEntryBreakout(entry: MetricsViewerDefinitionEntry,@@ -15,3 +20,41 @@ export function getEntryBreakout(export function entryHasBreakout(entry: MetricsViewerDefinitionEntry): boolean {return getEntryBreakout(entry) !== undefined;}++/**+ * Returns a definition entry with the "effective" definition for a formula entity.+ * If the entity has a per-instance definition (e.g. with breakout applied), uses that.+ * Otherwise falls back to the pristine definition from the shared definitions map.+ */+export function getEffectiveDefinitionEntry(+ entity: MetricDefinitionEntry,+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>,+): MetricDefinitionEntry {+ return {+ ...entity,+ definition: entity.definition ?? definitions[entity.id]?.definition ?? null,+ };+}++export function getEffectiveTokenDefinitionEntry(+ token: ExpressionMetricSubToken,+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>,+): MetricsViewerDefinitionEntry {+ return {+ id: token.sourceId,+ definition:+ token.definition ?? definitions[token.sourceId]?.definition ?? null,+ };+}++/**+ * Narrows a definition entry to one that has a non-null definition.+ * Useful for filtering arrays/maps of entries to only those with loaded definitions.+ */+export function isLoadedEntry(+ entry: MetricsViewerDefinitionEntry,+): entry is MetricsViewerDefinitionEntry & {+ definition: NonNullable<MetricsViewerDefinitionEntry["definition"]>;+} {+ return entry.definition != null;+}diff --git a/frontend/src/metabase/metrics-viewer/utils/definition-sources.ts b/frontend/src/metabase/metrics-viewer/utils/definition-sources.tsnew file mode 100644index 00000000000..357e68000e1--- /dev/null+++ b/frontend/src/metabase/metrics-viewer/utils/definition-sources.ts@@ -0,0 +1,126 @@+import { t } from "ttag";++import type { MetricDefinition } from "metabase-lib/metric";+import * as LibMetric from "metabase-lib/metric";++import {+ type ExpressionMetricSubToken,+ type MetricSourceId,+ type MetricsViewerDefinitionEntry,+ type MetricsViewerFormulaEntity,+ isExpressionEntry,+ isMetricEntry,+} from "../types/viewer-state";++import {+ getEffectiveDefinitionEntry,+ getEffectiveTokenDefinitionEntry,+} from "./definition-entries";++export type DefinitionSource = {+ index: number;+ id: MetricSourceId;+ definition: MetricDefinition;+ entity: MetricsViewerFormulaEntity;+ entityIndex: number;+ token?: ExpressionMetricSubToken;+};++export function getDefinitionSources(+ formulaEntities: MetricsViewerFormulaEntity[],+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>,+): DefinitionSource[] {+ type MaybeDefinitionSource = Omit<+ DefinitionSource,+ "definition" | "index"+ > & {+ definition: DefinitionSource["definition"] | null;+ };+ const maybeDefinitionSources = formulaEntities.flatMap<MaybeDefinitionSource>(+ (entity, index) => {+ if (isMetricEntry(entity)) {+ const effectiveEntry = getEffectiveDefinitionEntry(entity, definitions);+ return [+ {+ id: entity.id,+ definition: effectiveEntry.definition,+ entity,+ entityIndex: index,+ },+ ];+ }+ if (isExpressionEntry(entity)) {+ return entity.tokens+ .filter((token) => token.type === "metric")+ .map((token) => {+ const effectiveEntry = getEffectiveTokenDefinitionEntry(+ token,+ definitions,+ );+ return {+ id: token.sourceId,+ definition: effectiveEntry.definition,+ entity,+ entityIndex: index,+ token,+ };+ });+ }+ return [];+ },+ );+ // Assign stable indices before filtering so they don't shift as definitions+ // load asynchronously (formulaEntities are stable while the popover is open).+ return maybeDefinitionSources+ .map((source, index) => ({ ...source, index }))+ .filter((source): source is DefinitionSource => source.definition != null);+}++/**+ * Produces an updated formulaEntities array with a new definition applied+ * to the entity/token identified by the given DefinitionSource.+ */+export function applyDefinitionToFormulaEntities(+ formulaEntities: MetricsViewerFormulaEntity[],+ source: DefinitionSource,+ newDefinition: MetricDefinition,+): MetricsViewerFormulaEntity[] {+ return formulaEntities.map((entity, index) => {+ if (index !== source.entityIndex) {+ return entity;+ }+ if (isMetricEntry(entity)) {+ return { ...entity, definition: newDefinition };+ }+ if (isExpressionEntry(entity)) {+ return {+ ...entity,+ tokens: entity.tokens.map((token) =>+ token === source.token+ ? { ...token, definition: newDefinition }+ : token,+ ),+ };+ }+ return entity;+ });+}++export function getDefinitionSourceName(source: DefinitionSource): string {+ const metric = LibMetric.sourceMetricOrMeasureMetadata(source.definition);+ if (metric) {+ const metricInfo = LibMetric.displayInfo(source.definition, metric);+ return metricInfo.displayName;+ }+ return t`Unknown`;+}++export function getDefinitionSourceIcon(+ source: DefinitionSource,+): "metric" | "ruler" | undefined {+ if (isMetricEntry(source.entity)) {+ const metricId = LibMetric.sourceMetricId(source.definition);+ return metricId != null ? "metric" : "ruler";+ }+ return undefined;+}diff --git a/frontend/src/metabase/metrics-viewer/utils/dimension-picker.ts b/frontend/src/metabase/metrics-viewer/utils/dimension-picker.tsindex eb27761e05f..664355dc8a9 100644--- a/frontend/src/metabase/metrics-viewer/utils/dimension-picker.ts+++ b/frontend/src/metabase/metrics-viewer/utils/dimension-picker.ts@@ -13,6 +13,7 @@ import type {MetricsViewerTabType,} from "../types/viewer-state";+import type { MetricSlot } from "./metric-slots";import { type TabInfo, getDimensionIcon, getDimensionsByType } from "./tabs";// ── Dimension picker ──@@ -36,17 +37,18 @@ interface DimensionEntry {tabType: MetricsViewerTabType;group?: DimensionGroup;sourceId: MetricSourceId;+ slotIndex: number;}function collectAllDimensionEntries(- sourceOrder: MetricSourceId[],+ metricSlots: MetricSlot[],definitionsBySourceId: Record<MetricSourceId, MetricDefinition | null>,existingTabDimensionIds: Set<string>,): DimensionEntry[] {const entries: DimensionEntry[] = [];- for (const sourceId of sourceOrder) {- const def = definitionsBySourceId[sourceId];+ for (const slot of metricSlots) {+ const def = definitionsBySourceId[slot.sourceId];if (!def) {continue;}@@ -63,7 +65,8 @@ function collectAllDimensionEntries(icon: getDimensionIcon(info.dimensionMetadata),tabType: info.dimensionType,group: info.group,- sourceId,+ sourceId: slot.sourceId,+ slotIndex: slot.slotIndex,});}}@@ -92,17 +95,17 @@ function groupBySource(entries: DimensionEntry[]): DimensionEntry[][] {export function getAvailableDimensionsForPicker(definitionsBySourceId: Record<MetricSourceId, MetricDefinition | null>,- sourceOrder: MetricSourceId[],+ metricSlots: MetricSlot[],existingTabDimensionIds: Set<string>,): AvailableDimensionsResult {const result: AvailableDimensionsResult = { shared: [], bySource: {} };- if (sourceOrder.length === 0) {+ if (metricSlots.length === 0) {return result;}const entries = collectAllDimensionEntries(- sourceOrder,+ metricSlots,definitionsBySourceId,existingTabDimensionIds,);@@ -123,7 +126,7 @@ export function getAvailableDimensionsForPicker(type: first.tabType,label: first.label,dimensionMapping: Object.fromEntries(- group.map((entry) => [entry.sourceId, entry.id]),+ group.map((entry) => [entry.slotIndex, entry.id]),),},});@@ -136,7 +139,7 @@ export function getAvailableDimensionsForPicker(tabInfo: {type: entry.tabType,label: entry.label,- dimensionMapping: { [entry.sourceId]: entry.id },+ dimensionMapping: { [entry.slotIndex]: entry.id },},});}@@ -146,8 +149,8 @@ export function getAvailableDimensionsForPicker(result.shared.sort((first, second) =>first.tabInfo.label.localeCompare(second.tabInfo.label),);- for (const sourceId of sourceOrder) {- result.bySource[sourceId]?.sort((first, second) =>+ for (const slot of metricSlots) {+ result.bySource[slot.sourceId]?.sort((first, second) =>first.tabInfo.label.localeCompare(second.tabInfo.label),);}diff --git a/frontend/src/metabase/metrics-viewer/utils/dimension-picker.unit.spec.ts b/frontend/src/metabase/metrics-viewer/utils/dimension-picker.unit.spec.tsindex 48bf268a400..08adf01cc55 100644--- a/frontend/src/metabase/metrics-viewer/utils/dimension-picker.unit.spec.ts+++ b/frontend/src/metabase/metrics-viewer/utils/dimension-picker.unit.spec.ts@@ -42,7 +42,7 @@ const REVENUE_DIMENSIONS = [tabInfo: {type: "numeric",label: "Amount",- dimensionMapping: { [REVENUE_SOURCE_ID]: "dim-amount" },+ dimensionMapping: { 0: "dim-amount" },},},{@@ -51,7 +51,7 @@ const REVENUE_DIMENSIONS = [tabInfo: {type: "category",label: "Category",- dimensionMapping: { [REVENUE_SOURCE_ID]: "dim-category" },+ dimensionMapping: { 0: "dim-category" },},},{@@ -60,7 +60,7 @@ const REVENUE_DIMENSIONS = [tabInfo: {type: "time",label: "Created At",- dimensionMapping: { [REVENUE_SOURCE_ID]: "dim-created-at" },+ dimensionMapping: { 0: "dim-created-at" },},},{@@ -69,7 +69,7 @@ const REVENUE_DIMENSIONS = [tabInfo: {type: "boolean",label: "Is Active",- dimensionMapping: { [REVENUE_SOURCE_ID]: "dim-active" },+ dimensionMapping: { 0: "dim-active" },},},];@@ -81,7 +81,7 @@ const ORDERS_DIMENSIONS = [tabInfo: {type: "time",label: "Created At",- dimensionMapping: { [ORDERS_SOURCE_ID]: "dim-created-at" },+ dimensionMapping: { 0: "dim-created-at" },},},{@@ -90,7 +90,7 @@ const ORDERS_DIMENSIONS = [tabInfo: {type: "category",label: "Status",- dimensionMapping: { [ORDERS_SOURCE_ID]: "dim-status" },+ dimensionMapping: { 0: "dim-status" },},},];@@ -105,7 +105,7 @@ describe("getAvailableDimensionsForPicker", () => {it("returns dimensions for a single metric source", () => {const result = getAvailableDimensionsForPicker({ [REVENUE_SOURCE_ID]: revenueDefinition },- [REVENUE_SOURCE_ID],+ [{ slotIndex: 0, entityIndex: 0, sourceId: REVENUE_SOURCE_ID }],new Set(),);@@ -120,7 +120,7 @@ describe("getAvailableDimensionsForPicker", () => {it("returns dimensions for a second metric source", () => {const result = getAvailableDimensionsForPicker({ [ORDERS_SOURCE_ID]: ordersDefinition },- [ORDERS_SOURCE_ID],+ [{ slotIndex: 0, entityIndex: 0, sourceId: ORDERS_SOURCE_ID }],new Set(),);@@ -138,7 +138,10 @@ describe("getAvailableDimensionsForPicker", () => {[REVENUE_SOURCE_ID]: revenueDefinition,[ORDERS_SOURCE_ID]: ordersDefinition,},- [REVENUE_SOURCE_ID, ORDERS_SOURCE_ID],+ [+ { slotIndex: 0, entityIndex: 0, sourceId: REVENUE_SOURCE_ID },+ { slotIndex: 1, entityIndex: 1, sourceId: ORDERS_SOURCE_ID },+ ],new Set(),);@@ -146,7 +149,26 @@ describe("getAvailableDimensionsForPicker", () => {shared: [],bySource: {[REVENUE_SOURCE_ID]: REVENUE_DIMENSIONS,- [ORDERS_SOURCE_ID]: ORDERS_DIMENSIONS,+ [ORDERS_SOURCE_ID]: [+ {+ icon: "calendar",+ group: undefined,+ tabInfo: {+ type: "time",+ label: "Created At",+ dimensionMapping: { 1: "dim-created-at" },+ },+ },+ {+ icon: "string",+ group: undefined,+ tabInfo: {+ type: "category",+ label: "Status",+ dimensionMapping: { 1: "dim-status" },+ },+ },+ ],},});});@@ -158,7 +180,7 @@ describe("getAvailableDimensionsForPicker", () => {const result = getAvailableDimensionsForPicker({ [REVENUE_SOURCE_ID]: revenueDefinition },- [REVENUE_SOURCE_ID],+ [{ slotIndex: 0, entityIndex: 0, sourceId: REVENUE_SOURCE_ID }],new Set(allIds),);diff --git a/frontend/src/metabase/metrics-viewer/utils/expression.ts b/frontend/src/metabase/metrics-viewer/utils/expression.tsnew file mode 100644index 00000000000..57c98b39bee--- /dev/null+++ b/frontend/src/metabase/metrics-viewer/utils/expression.ts@@ -0,0 +1,23 @@+import type { ExpressionSubToken, MetricSourceId } from "../types/viewer-state";++/**+ * Stamps sequential occurrence counts on metric tokens so that duplicate+ * metrics within an expression can be disambiguated in the UI+ * (e.g. "Revenue / Revenue (2)").+ *+ * Call this once when finalising a token array — after parsing user input+ * or deserialising from the URL.+ */+export function stampMetricCounts(+ tokens: ExpressionSubToken[],+): ExpressionSubToken[] {+ const counts = new Map<MetricSourceId, number>();+ return tokens.map((token) => {+ if (token.type === "metric") {+ const count = (counts.get(token.sourceId) ?? 0) + 1;+ counts.set(token.sourceId, count);+ return { ...token, count };+ }+ return token;+ });+}diff --git a/frontend/src/metabase/metrics-viewer/utils/legend.ts b/frontend/src/metabase/metrics-viewer/utils/legend.tsindex 0d465dadf3f..a4cd139292d 100644--- a/frontend/src/metabase/metrics-viewer/utils/legend.ts+++ b/frontend/src/metabase/metrics-viewer/utils/legend.ts@@ -1,13 +1,20 @@import * as LibMetric from "metabase-lib/metric";-import type {- MetricsViewerDefinitionEntry,- SourceBreakoutColorMap,+import {+ type MetricSourceId,+ type MetricsViewerDefinitionEntry,+ type MetricsViewerFormulaEntity,+ type SourceBreakoutColorMap,+ isExpressionEntry,} from "../types/viewer-state";+import { isMetricEntry } from "../types/viewer-state";import { getDefinitionName } from "./definition-builder";-import { entryHasBreakout, getEntryBreakout } from "./definition-entries";-import { getSingleColor } from "./series";+import {+ entryHasBreakout,+ getEffectiveDefinitionEntry,+ getEntryBreakout,+} from "./definition-entries";export interface LegendItem {label: string;@@ -15,43 +22,77 @@ export interface LegendItem {}export interface LegendGroup {+ key: number;header: string;subtitle?: string;items: LegendItem[];}export function buildLegendGroups(- definitions: MetricsViewerDefinitionEntry[],+ formulaEntities: MetricsViewerFormulaEntity[],+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>,activeBreakoutColors: SourceBreakoutColorMap,): LegendGroup[] {- // if the breakout has more than MAX_SERIES values, we don't show the breakout- // in that case, the value in activeBreakoutColors is a string- const hasAnyBreakout = definitions.some(- (entry) =>- entryHasBreakout(entry) && activeBreakoutColors[entry.id] instanceof Map,- );+ const hasAnyBreakout = formulaEntities.some((entity, entityIndex) => {+ if (!isMetricEntry(entity)) {+ return false;+ }+ return (+ entryHasBreakout(getEffectiveDefinitionEntry(entity, definitions)) &&+ activeBreakoutColors[entityIndex] instanceof Map+ );+ });+if (!hasAnyBreakout) {return [];}const groups: LegendGroup[] = [];- for (const entry of definitions) {- if (!entry.definition) {- continue;+ formulaEntities.forEach((entity, entityIndex) => {+ const colors = activeBreakoutColors[entityIndex];++ const getNextColor = () => {+ return typeof colors === "string"+ ? colors+ : colors instanceof Map+ ? colors.values().next().value+ : undefined;+ };++ if (isExpressionEntry(entity)) {+ const color = getNextColor();++ if (!color) {+ return;+ }++ groups.push({+ key: entityIndex,+ header: entity.name,+ items: [{ label: entity.name, color }],+ });+ return;+ }++ const effectiveEntry = getEffectiveDefinitionEntry(entity, definitions);+ if (!effectiveEntry.definition) {+ return;}- const colors = activeBreakoutColors[entry.id];- const definitionName = getDefinitionName(entry.definition);- const breakoutProjection = getEntryBreakout(entry);+ const pristineDef = definitions[entity.id];+ const definitionName = getDefinitionName(+ pristineDef?.definition ?? effectiveEntry.definition,+ );+ const breakoutProjection = getEntryBreakout(effectiveEntry);if (breakoutProjection && colors instanceof Map) {const rawDimension = LibMetric.projectionDimension(- entry.definition,+ effectiveEntry.definition,breakoutProjection,);const dimensionInfo = rawDimension- ? LibMetric.displayInfo(entry.definition, rawDimension)+ ? LibMetric.displayInfo(effectiveEntry.definition, rawDimension): null;const items: LegendItem[] = Array.from(colors.entries()).map(@@ -64,25 +105,28 @@ export function buildLegendGroups(const header =dimensionInfo?.longDisplayName ?? dimensionInfo?.displayName;if (!header) {- continue;+ return;}groups.push({+ key: entityIndex,header,subtitle: definitionName ?? undefined,items,});} else {- const color = getSingleColor(colors);- if (!color || !definitionName) {- continue;+ const color = getNextColor();++ if (!definitionName || !color) {+ return;}groups.push({+ key: entityIndex,header: definitionName,items: [{ label: definitionName, color }],});}- }+ });return groups;}diff --git a/frontend/src/metabase/metrics-viewer/utils/legend.unit.spec.ts b/frontend/src/metabase/metrics-viewer/utils/legend.unit.spec.tsindex d2425371787..6b3edc08544 100644--- a/frontend/src/metabase/metrics-viewer/utils/legend.unit.spec.ts+++ b/frontend/src/metabase/metrics-viewer/utils/legend.unit.spec.ts@@ -7,6 +7,8 @@ import {} from "metabase-types/api/mocks/metric";import type {+ MetricDefinitionEntry,+ MetricSourceId,MetricsViewerDefinitionEntry,SourceBreakoutColorMap,} from "../types/viewer-state";@@ -84,32 +86,44 @@ describe("buildLegendGroups", () => {const metadata = createMetadata([REVENUE_METRIC]);const definition = setupDefinition(metadata, REVENUE_METRIC.id);- const definitions: MetricsViewerDefinitionEntry[] = [- { id: "metric:1", definition },- ];+ const definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry> = {+ "metric:1": { id: "metric:1", definition },+ };const activeBreakoutColors: SourceBreakoutColorMap = {- "metric:1": "#509EE3",+ 0: "#509EE3",};- expect(buildLegendGroups(definitions, activeBreakoutColors)).toEqual([]);+ const formulaEntities: MetricDefinitionEntry[] = [+ { id: "metric:1", type: "metric", definition: null },+ ];++ expect(+ buildLegendGroups(formulaEntities, definitions, activeBreakoutColors),+ ).toEqual([]);});it("returns empty array when activeBreakoutColors has only string values", () => {const metadata = createMetadata([REVENUE_METRIC]);- const revenueDefinition = setupDefinitionWithBreakout(+ const definition = setupDefinitionWithBreakout(metadata,REVENUE_METRIC.id,1,);- const definitions: MetricsViewerDefinitionEntry[] = [- { id: "metric:1", definition: revenueDefinition },- ];+ const definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry> = {+ "metric:1": { id: "metric:1", definition },+ };const activeBreakoutColors: SourceBreakoutColorMap = {- "metric:1": "#509EE3",+ 0: "#509EE3",};- expect(buildLegendGroups(definitions, activeBreakoutColors)).toEqual([]);+ const formulaEntities: MetricDefinitionEntry[] = [+ { id: "metric:1", type: "metric", definition: null },+ ];++ expect(+ buildLegendGroups(formulaEntities, definitions, activeBreakoutColors),+ ).toEqual([]);});it("builds legend groups for definitions with and without breakouts", () => {@@ -121,21 +135,33 @@ describe("buildLegendGroups", () => {);const ordersDefinition = setupDefinition(metadata, ORDERS_METRIC.id);- const definitions: MetricsViewerDefinitionEntry[] = [- { id: "metric:1", definition: revenueDefinition },- { id: "metric:2", definition: ordersDefinition },+ const definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry> = {+ "metric:1": { id: "metric:1", definition: revenueDefinition },+ "metric:2": { id: "metric:2", definition: ordersDefinition },+ };++ const formulaEntities: MetricDefinitionEntry[] = [+ {+ id: "metric:1",+ type: "metric",+ definition: revenueDefinition,+ },+ { id: "metric:2", type: "metric", definition: null },];const activeBreakoutColors: SourceBreakoutColorMap = {- "metric:1": new Map([+ 0: new Map([["Gadgets", "#509EE3"],["Widgets", "#88BF4D"],]),- "metric:2": "#A989C5",+ 1: "#A989C5",};- expect(buildLegendGroups(definitions, activeBreakoutColors)).toEqual([+ expect(+ buildLegendGroups(formulaEntities, definitions, activeBreakoutColors),+ ).toEqual([{+ key: 0,header: "Category",subtitle: "Revenue",items: [@@ -144,6 +170,7 @@ describe("buildLegendGroups", () => {],},{+ key: 1,header: "Orders",items: [{ label: "Orders", color: "#A989C5" }],},diff --git a/frontend/src/metabase/metrics-viewer/utils/metric-slots.ts b/frontend/src/metabase/metrics-viewer/utils/metric-slots.tsnew file mode 100644index 00000000000..c1c3f751599--- /dev/null+++ b/frontend/src/metabase/metrics-viewer/utils/metric-slots.ts@@ -0,0 +1,92 @@+import type {+ MetricSourceId,+ MetricsViewerFormulaEntity,+} from "../types/viewer-state";+import { isExpressionEntry, isMetricEntry } from "../types/viewer-state";++/**+ * A metric slot represents a single position in the formula where a metric+ * needs a dimension assignment. Standalone metrics produce one slot each;+ * expression entities produce one slot per metric token (so the same metric+ * appearing twice in an expression creates two separate slots).+ *+ * The `slotIndex` is used as the key in `dimensionMapping`.+ */+export type MetricSlot = {+ /** Sequential index — used as the dimensionMapping key. */+ slotIndex: number;+ /** Which formulaEntities entry this slot belongs to. */+ entityIndex: number;+ /** The metric's source id (e.g. "metric:42"). */+ sourceId: MetricSourceId;+ /**+ * For expression-token slots, the index within `entity.tokens`.+ * `undefined` for standalone metric slots.+ */+ tokenPosition?: number;+};++/**+ * Walk `formulaEntities` and produce a flat list of metric slots.+ * The returned array's indices equal each slot's `slotIndex`.+ */+export function computeMetricSlots(+ formulaEntities: MetricsViewerFormulaEntity[],+): MetricSlot[] {+ const slots: MetricSlot[] = [];++ for (let i = 0; i < formulaEntities.length; i++) {+ const entity = formulaEntities[i];++ if (isMetricEntry(entity)) {+ slots.push({+ slotIndex: slots.length,+ entityIndex: i,+ sourceId: entity.id,+ });+ } else if (isExpressionEntry(entity)) {+ for (let j = 0; j < entity.tokens.length; j++) {+ const token = entity.tokens[j];+ if (token.type === "metric") {+ slots.push({+ slotIndex: slots.length,+ entityIndex: i,+ sourceId: token.sourceId,+ tokenPosition: j,+ });+ }+ }+ }+ }++ return slots;+}++/** Find the slot for a standalone metric at the given entity index. */+export function findStandaloneSlot(+ slots: MetricSlot[],+ entityIndex: number,+): MetricSlot | undefined {+ return slots.find(+ (s) => s.entityIndex === entityIndex && s.tokenPosition === undefined,+ );+}++/** Find the slot for an expression token at the given entity + token position. */+export function findExpressionTokenSlot(+ slots: MetricSlot[],+ entityIndex: number,+ tokenPosition: number,+): MetricSlot | undefined {+ return slots.find(+ (s) => s.entityIndex === entityIndex && s.tokenPosition === tokenPosition,+ );+}++/** Get all slots belonging to a given entity index. */+export function slotsForEntity(+ slots: MetricSlot[],+ entityIndex: number,+): MetricSlot[] {+ return slots.filter((s) => s.entityIndex === entityIndex);+}diff --git a/frontend/src/metabase/metrics-viewer/utils/parse-expression.ts b/frontend/src/metabase/metrics-viewer/utils/parse-expression.tsnew file mode 100644index 00000000000..b7c5cba041d--- /dev/null+++ b/frontend/src/metabase/metrics-viewer/utils/parse-expression.ts@@ -0,0 +1,112 @@+import type { ExpressionRef, MathOperator } from "metabase-types/api";++import type { ExpressionSubToken } from "../types/viewer-state";++type ParseCtx = {+ tokens: ExpressionSubToken[];+ pos: number;+ leafRefs: Map<number, ExpressionRef>;+};++function parseTerm(ctx: ParseCtx): ExpressionRef | number | null {+ if (ctx.pos >= ctx.tokens.length) {+ return null;+ }+ const token = ctx.tokens[ctx.pos];++ if (token.type === "metric") {+ const tokenPos = ctx.pos;+ ctx.pos++;+ return ctx.leafRefs.get(tokenPos) ?? null;+ }++ if (token.type === "constant") {+ ctx.pos++;+ return token.value;+ }++ if (token.type === "open-paren") {+ ctx.pos++;+ const expr = parseExpressionWithContext(ctx);+ if (+ ctx.pos < ctx.tokens.length &&+ ctx.tokens[ctx.pos].type === "close-paren"+ ) {+ ctx.pos++;+ }+ return expr;+ }++ return null;+}++const PRECEDENCE: Record<MathOperator, number> = {+ "+": 1,+ "-": 1,+ "*": 2,+ "/": 2,+};++function isOperatorAtPrecedence(ctx: ParseCtx, level: number): boolean {+ if (ctx.pos >= ctx.tokens.length) {+ return false;+ }+ const token = ctx.tokens[ctx.pos];+ return token.type === "operator" && PRECEDENCE[token.op] === level;+}++function parseFactor(ctx: ParseCtx): ExpressionRef | number | null {+ let left = parseTerm(ctx);+ if (left == null) {+ return null;+ }++ while (isOperatorAtPrecedence(ctx, 2)) {+ const op = (ctx.tokens[ctx.pos] as { type: "operator"; op: MathOperator })+ .op;+ ctx.pos++;+ const right = parseTerm(ctx);+ if (right == null) {+ return null;+ }+ left = [op, {}, left, right];+ }++ return left;+}++function parseExpressionWithContext(ctx: ParseCtx): ExpressionRef | null {+ let left = parseFactor(ctx);+ if (left == null) {+ return null;+ }++ while (isOperatorAtPrecedence(ctx, 1)) {+ const op = (ctx.tokens[ctx.pos] as { type: "operator"; op: MathOperator })+ .op;+ ctx.pos++;+ const right = parseFactor(ctx);+ if (right == null) {+ return null;+ }+ left = [op, {}, left, right];+ }++ if (typeof left === "number") {+ return null;+ }++ return left;+}++export function parseExpression(+ tokens: ExpressionSubToken[],+ leafRefs: Map<number, ExpressionRef>,+): ExpressionRef | null {+ const ctx: ParseCtx = { tokens, pos: 0, leafRefs };+ const result = parseExpressionWithContext(ctx);+ if (ctx.pos < tokens.length) {+ return null;+ }+ return result;+}diff --git a/frontend/src/metabase/metrics-viewer/utils/parse-expression.unit.spec.ts b/frontend/src/metabase/metrics-viewer/utils/parse-expression.unit.spec.tsnew file mode 100644index 00000000000..f3659791200--- /dev/null+++ b/frontend/src/metabase/metrics-viewer/utils/parse-expression.unit.spec.ts@@ -0,0 +1,260 @@+import type { ExpressionRef } from "metabase-types/api";++import type { ExpressionSubToken } from "../types/viewer-state";++import { parseExpression } from "./parse-expression";+import { parseSourceId } from "./source-ids";++function createLeafRefs(+ tokens: ExpressionSubToken[],+): Map<number, ExpressionRef> {+ const leafRefs = new Map<number, ExpressionRef>();+ for (let i = 0; i < tokens.length; i++) {+ const token = tokens[i];+ if (token.type === "metric") {+ const uuid = `leaf-${i}`;+ const { id, type } = parseSourceId(token.sourceId);++ if (type === "metric") {+ leafRefs.set(i, ["metric", { "lib/uuid": uuid }, id]);+ } else if (type === "measure") {+ leafRefs.set(i, ["measure", { "lib/uuid": uuid }, id]);+ }+ }+ }+ return leafRefs;+}++// remove options to make comparisons easier+function stripOptions(expr: ExpressionRef | number | null): any {+ if (typeof expr === "number" || expr === null) {+ return expr;+ }+ if (expr[0] === "metric" || expr[0] === "measure") {+ return [expr[0], expr[2]];+ }+ return [expr[0], stripOptions(expr[2]), stripOptions(expr[3])];+}++describe("parseExpression", () => {+ it("should parse a simple expression", () => {+ const tokens: ExpressionSubToken[] = [+ { type: "metric", sourceId: "metric:1", count: 1 },+ { type: "operator", op: "+" },+ { type: "metric", sourceId: "metric:2", count: 1 },+ ];+ const expr = parseExpression(tokens, createLeafRefs(tokens));+ expect(stripOptions(expr)).toEqual(["+", ["metric", 1], ["metric", 2]]);+ });++ it("should handle parens", () => {+ const tokens: ExpressionSubToken[] = [+ { type: "metric", sourceId: "metric:1", count: 1 },+ { type: "operator", op: "-" },+ { type: "open-paren" },+ { type: "metric", sourceId: "metric:2", count: 1 },+ { type: "operator", op: "+" },+ { type: "metric", sourceId: "measure:3", count: 1 },+ { type: "close-paren" },+ ];+ const expr = parseExpression(tokens, createLeafRefs(tokens));+ expect(stripOptions(expr)).toEqual([+ "-",+ ["metric", 1],+ ["+", ["metric", 2], ["measure", 3]],+ ]);+ });++ it("should handle a single metric", () => {+ const tokens: ExpressionSubToken[] = [+ { type: "metric", sourceId: "metric:1", count: 1 },+ ];+ const expr = parseExpression(tokens, createLeafRefs(tokens));+ expect(stripOptions(expr)).toEqual(["metric", 1]);+ });++ it("should return null for invalid input", () => {+ const tokens: ExpressionSubToken[] = [+ { type: "metric", sourceId: "metric:1", count: 1 },+ { type: "operator", op: "+" },+ ];+ const expr = parseExpression(tokens, createLeafRefs(tokens));+ expect(expr).toBeNull();+ });++ // A + B * C => A + (B * C)+ it("should respect precedence: + before *", () => {+ const tokens: ExpressionSubToken[] = [+ { type: "metric", sourceId: "metric:1", count: 1 },+ { type: "operator", op: "+" },+ { type: "metric", sourceId: "metric:2", count: 1 },+ { type: "operator", op: "*" },+ { type: "metric", sourceId: "metric:3", count: 1 },+ ];+ const expr = parseExpression(tokens, createLeafRefs(tokens));+ expect(stripOptions(expr)).toEqual([+ "+",+ ["metric", 1],+ ["*", ["metric", 2], ["metric", 3]],+ ]);+ });++ // A * B + C => (A * B) + C+ it("should respect precedence: * before +", () => {+ const tokens: ExpressionSubToken[] = [+ { type: "metric", sourceId: "metric:1", count: 1 },+ { type: "operator", op: "*" },+ { type: "metric", sourceId: "metric:2", count: 1 },+ { type: "operator", op: "+" },+ { type: "metric", sourceId: "metric:3", count: 1 },+ ];+ const expr = parseExpression(tokens, createLeafRefs(tokens));+ expect(stripOptions(expr)).toEqual([+ "+",+ ["*", ["metric", 1], ["metric", 2]],+ ["metric", 3],+ ]);+ });++ // A - B / C => A - (B / C)+ it("should respect precedence: - before /", () => {+ const tokens: ExpressionSubToken[] = [+ { type: "metric", sourceId: "metric:1", count: 1 },+ { type: "operator", op: "-" },+ { type: "metric", sourceId: "metric:2", count: 1 },+ { type: "operator", op: "/" },+ { type: "metric", sourceId: "metric:3", count: 1 },+ ];+ const expr = parseExpression(tokens, createLeafRefs(tokens));+ expect(stripOptions(expr)).toEqual([+ "-",+ ["metric", 1],+ ["/", ["metric", 2], ["metric", 3]],+ ]);+ });++ // A * B + C * D => (A * B) + (C * D)+ it("should handle multiple high-precedence groups", () => {+ const tokens: ExpressionSubToken[] = [+ { type: "metric", sourceId: "metric:1", count: 1 },+ { type: "operator", op: "*" },+ { type: "metric", sourceId: "metric:2", count: 1 },+ { type: "operator", op: "+" },+ { type: "metric", sourceId: "metric:3", count: 1 },+ { type: "operator", op: "*" },+ { type: "metric", sourceId: "metric:4", count: 1 },+ ];+ const expr = parseExpression(tokens, createLeafRefs(tokens));+ expect(stripOptions(expr)).toEqual([+ "+",+ ["*", ["metric", 1], ["metric", 2]],+ ["*", ["metric", 3], ["metric", 4]],+ ]);+ });++ // (A + B) * C => parens override precedence+ it("should allow parens to override precedence", () => {+ const tokens: ExpressionSubToken[] = [+ { type: "open-paren" },+ { type: "metric", sourceId: "metric:1", count: 1 },+ { type: "operator", op: "+" },+ { type: "metric", sourceId: "metric:2", count: 1 },+ { type: "close-paren" },+ { type: "operator", op: "*" },+ { type: "metric", sourceId: "metric:3", count: 1 },+ ];+ const expr = parseExpression(tokens, createLeafRefs(tokens));+ expect(stripOptions(expr)).toEqual([+ "*",+ ["+", ["metric", 1], ["metric", 2]],+ ["metric", 3],+ ]);+ });++ it("should handle constants in precedence expressions", () => {+ // A + 2 * B => A + (2 * B)+ const tokens: ExpressionSubToken[] = [+ { type: "metric", sourceId: "metric:1", count: 1 },+ { type: "operator", op: "+" },+ { type: "constant", value: 2 },+ { type: "operator", op: "*" },+ { type: "metric", sourceId: "metric:2", count: 1 },+ ];+ const expr = parseExpression(tokens, createLeafRefs(tokens));+ expect(stripOptions(expr)).toEqual([+ "+",+ ["metric", 1],+ ["*", 2, ["metric", 2]],+ ]);+ });++ // 8 - 3 - 2 => (8 - 3) - 2 = 3, not 8 - (3 - 2) = 7+ it("should associate subtraction left-to-right", () => {+ const tokens: ExpressionSubToken[] = [+ { type: "constant", value: 8 },+ { type: "operator", op: "-" },+ { type: "metric", sourceId: "metric:1", count: 1 },+ { type: "operator", op: "-" },+ { type: "metric", sourceId: "metric:2", count: 1 },+ ];+ const expr = parseExpression(tokens, createLeafRefs(tokens));+ expect(stripOptions(expr)).toEqual([+ "-",+ ["-", 8, ["metric", 1]],+ ["metric", 2],+ ]);+ });++ // 8 / 4 / 2 => (8 / 4) / 2 = 1, not 8 / (4 / 2) = 4+ it("should associate division left-to-right", () => {+ const tokens: ExpressionSubToken[] = [+ { type: "constant", value: 8 },+ { type: "operator", op: "/" },+ { type: "metric", sourceId: "metric:1", count: 1 },+ { type: "operator", op: "/" },+ { type: "metric", sourceId: "metric:2", count: 1 },+ ];+ const expr = parseExpression(tokens, createLeafRefs(tokens));+ expect(stripOptions(expr)).toEqual([+ "/",+ ["/", 8, ["metric", 1]],+ ["metric", 2],+ ]);+ });++ it("should return null when tokens are not fully consumed", () => {+ // "Metric1 2" — two operands with no operator+ const tokens: ExpressionSubToken[] = [+ { type: "metric", sourceId: "metric:1", count: 1 },+ { type: "constant", value: 2 },+ ];+ const expr = parseExpression(tokens, createLeafRefs(tokens));+ expect(expr).toBeNull();+ });++ it("should return null for metric followed by another metric without operator", () => {+ const tokens: ExpressionSubToken[] = [+ { type: "metric", sourceId: "metric:1", count: 1 },+ { type: "metric", sourceId: "metric:2", count: 1 },+ ];+ const expr = parseExpression(tokens, createLeafRefs(tokens));+ expect(expr).toBeNull();+ });++ // 6 / 2 * 3 => (6 / 2) * 3 = 9, not 6 / (2 * 3) = 1+ it("should associate mixed * and / left-to-right", () => {+ const tokens: ExpressionSubToken[] = [+ { type: "constant", value: 6 },+ { type: "operator", op: "/" },+ { type: "metric", sourceId: "metric:1", count: 1 },+ { type: "operator", op: "*" },+ { type: "metric", sourceId: "metric:2", count: 1 },+ ];+ const expr = parseExpression(tokens, createLeafRefs(tokens));+ expect(stripOptions(expr)).toEqual([+ "*",+ ["/", 6, ["metric", 1]],+ ["metric", 2],+ ]);+ });+});diff --git a/frontend/src/metabase/metrics-viewer/utils/remap-dimension-mappings.ts b/frontend/src/metabase/metrics-viewer/utils/remap-dimension-mappings.tsnew file mode 100644index 00000000000..2e31da82022--- /dev/null+++ b/frontend/src/metabase/metrics-viewer/utils/remap-dimension-mappings.ts@@ -0,0 +1,82 @@+import { getObjectEntries } from "metabase/utils/objects";++import type {+ MetricSourceId,+ MetricsViewerFormulaEntity,+ MetricsViewerTabState,+} from "../types/viewer-state";++import type { MetricSlot } from "./metric-slots";+import { computeMetricSlots } from "./metric-slots";++/**+ * Look through the already-remapped entries for a slot with the same+ * sourceId and return its dimension id.+ */+function findSiblingDimension(+ mapping: Record<number, string | null>,+ slots: MetricSlot[],+ targetSourceId: MetricSourceId,+): string | null | undefined {+ for (const [idxStr, dimId] of Object.entries(mapping)) {+ const idx = Number(idxStr);+ const slot = slots.find((s) => s.slotIndex === idx);+ if (slot && slot.sourceId === targetSourceId) {+ return dimId;+ }+ }+ return undefined; // no sibling found — leave unmapped+}++/**+ * Remap dimension mappings using a precomputed old→new slot index mapping+ * (produced by `applyTrackedDefinitions`). This is the fast path used when+ * the slot mapping is available from CodeMirror position tracking.+ *+ * 1. Remap existing entries via the slot mapping (simple lookup).+ * 2. Inherit sibling dimensions for unmapped new slots.+ */+export function remapDimensionMappings(+ tabs: MetricsViewerTabState[],+ slotMapping: Map<number, number>,+ newEntities: MetricsViewerFormulaEntity[],+): MetricsViewerTabState[] {+ const newSlots = computeMetricSlots(newEntities);++ return tabs.map((tab) => {+ const newMapping: Record<number, string | null> = {};+ let changed = false;++ // 1. Remap existing entries from old slot index → new slot index+ for (const [oldKey, dimId] of getObjectEntries(tab.dimensionMapping)) {+ const oldSlotIndex = Number(oldKey);+ const newSlotIndex = slotMapping.get(oldSlotIndex);+ if (newSlotIndex == null) {+ changed = true;+ continue; // slot was removed+ }+ if (newSlotIndex !== oldSlotIndex) {+ changed = true;+ }+ newMapping[newSlotIndex] = dimId;+ }++ // 2. Inherit sibling dimensions for unmapped new slots+ for (const slot of newSlots) {+ if (slot.slotIndex in newMapping) {+ continue;+ }+ const siblingDimId = findSiblingDimension(+ newMapping,+ newSlots,+ slot.sourceId,+ );+ if (siblingDimId !== undefined) {+ newMapping[slot.slotIndex] = siblingDimId;+ changed = true;+ }+ }++ return changed ? { ...tab, dimensionMapping: newMapping } : tab;+ });+}diff --git a/frontend/src/metabase/metrics-viewer/utils/remap-dimension-mappings.unit.spec.ts b/frontend/src/metabase/metrics-viewer/utils/remap-dimension-mappings.unit.spec.tsnew file mode 100644index 00000000000..de770b904fc--- /dev/null+++ b/frontend/src/metabase/metrics-viewer/utils/remap-dimension-mappings.unit.spec.ts@@ -0,0 +1,178 @@+import type {+ MetricDefinitionEntry,+ MetricSourceId,+ MetricsViewerTabState,+} from "../types/viewer-state";++import { remapDimensionMappings } from "./remap-dimension-mappings";++// ---------------------------------------------------------------------------+// Helpers+// ---------------------------------------------------------------------------++function metric(sourceId: MetricSourceId): MetricDefinitionEntry {+ return { id: sourceId, type: "metric", definition: null as any };+}++function makeTab(+ overrides: Partial<MetricsViewerTabState> = {},+): MetricsViewerTabState {+ return {+ id: "tab-1",+ type: "time",+ label: "By Month",+ display: "line",+ dimensionMapping: {},+ projectionConfig: {},+ ...overrides,+ };+}++const REVENUE: MetricSourceId = "metric:1" as MetricSourceId;+const ORDERS: MetricSourceId = "metric:2" as MetricSourceId;+const COSTS: MetricSourceId = "metric:3" as MetricSourceId;++// ---------------------------------------------------------------------------+// remapDimensionMappings — fast path using precomputed slot mapping+// ---------------------------------------------------------------------------++describe("remapDimensionMappings", () => {+ it("returns same tab objects when slot mapping is identity", () => {+ const entities = [metric(REVENUE), metric(ORDERS)];+ const tab = makeTab({+ dimensionMapping: { 0: "created_at", 1: "created_at" },+ });+ const slotMapping = new Map([+ [0, 0],+ [1, 1],+ ]);++ const result = remapDimensionMappings([tab], slotMapping, entities);++ expect(result[0]).toBe(tab); // referential equality+ });++ it("remaps indices when slots shift", () => {+ // Old: [Revenue(0), Orders(1), Costs(2)], New: [Orders(0), Costs(1)]+ // Revenue removed, Orders 1→0, Costs 2→1+ const next = [metric(ORDERS), metric(COSTS)];+ const tab = makeTab({+ dimensionMapping: { 0: "dim-rev", 1: "dim-ord", 2: "dim-cost" },+ });+ const slotMapping = new Map([+ [1, 0], // Orders: old 1 → new 0+ [2, 1], // Costs: old 2 → new 1+ // Revenue (old 0) not in map — removed+ ]);++ const result = remapDimensionMappings([tab], slotMapping, next);++ expect(result[0].dimensionMapping).toEqual({+ 0: "dim-ord",+ 1: "dim-cost",+ });+ });++ it("remaps indices when entities are reordered", () => {+ const next = [metric(ORDERS), metric(REVENUE)]; // swapped+ const tab = makeTab({+ dimensionMapping: { 0: "dim-rev", 1: "dim-ord" },+ });+ const slotMapping = new Map([+ [0, 1], // Revenue: old 0 → new 1+ [1, 0], // Orders: old 1 → new 0+ ]);++ const result = remapDimensionMappings([tab], slotMapping, next);++ expect(result[0].dimensionMapping).toEqual({+ 0: "dim-ord",+ 1: "dim-rev",+ });+ });++ it("inherits sibling dimension for a new slot with same sourceId", () => {+ const next = [metric(REVENUE), metric(REVENUE)]; // second instance added+ const tab = makeTab({+ dimensionMapping: { 0: "created_at" },+ });+ const slotMapping = new Map([+ [0, 0], // original Revenue stays at 0+ // slot 1 is new — not in the mapping+ ]);++ const result = remapDimensionMappings([tab], slotMapping, next);++ expect(result[0].dimensionMapping).toEqual({+ 0: "created_at",+ 1: "created_at", // inherited from sibling+ });+ });++ it("does not add mapping for a brand-new metric with no sibling", () => {+ const next = [metric(REVENUE), metric(ORDERS)]; // Orders is new+ const tab = makeTab({+ dimensionMapping: { 0: "created_at" },+ });+ const slotMapping = new Map([+ [0, 0], // Revenue stays+ // slot 1 (Orders) is new with no sibling+ ]);++ const result = remapDimensionMappings([tab], slotMapping, next);++ expect(result[0].dimensionMapping).toEqual({ 0: "created_at" });+ });++ it("reconciles multiple tabs independently", () => {+ const next = [metric(ORDERS), metric(REVENUE)]; // swapped+ const tab1 = makeTab({+ id: "tab-1",+ dimensionMapping: { 0: "dim-rev", 1: "dim-ord" },+ });+ const tab2 = makeTab({+ id: "tab-2",+ dimensionMapping: { 0: "cat-rev", 1: "cat-ord" },+ });+ const slotMapping = new Map([+ [0, 1],+ [1, 0],+ ]);++ const result = remapDimensionMappings([tab1, tab2], slotMapping, next);++ expect(result[0].dimensionMapping).toEqual({+ 0: "dim-ord",+ 1: "dim-rev",+ });+ expect(result[1].dimensionMapping).toEqual({+ 0: "cat-ord",+ 1: "cat-rev",+ });+ });++ it("handles empty slot mapping (all entities new)", () => {+ const next = [metric(REVENUE)];+ const tab = makeTab({ dimensionMapping: { 0: "created_at" } });+ const slotMapping = new Map<number, number>();++ const result = remapDimensionMappings([tab], slotMapping, next);++ expect(result[0].dimensionMapping).toEqual({});+ });++ it("inherits null dimension from sibling", () => {+ const next = [metric(REVENUE), metric(REVENUE)];+ const tab = makeTab({+ dimensionMapping: { 0: null },+ });+ const slotMapping = new Map([[0, 0]]);++ const result = remapDimensionMappings([tab], slotMapping, next);++ expect(result[0].dimensionMapping).toEqual({+ 0: null,+ 1: null,+ });+ });+});diff --git a/frontend/src/metabase/metrics-viewer/utils/series.ts b/frontend/src/metabase/metrics-viewer/utils/series.tsindex 08dc2e578cc..3989d8fa886 100644--- a/frontend/src/metabase/metrics-viewer/utils/series.ts+++ b/frontend/src/metabase/metrics-viewer/utils/series.ts@@ -1,5 +1,13 @@+import { t } from "ttag";+import type { DimensionOption } from "metabase/common/components/DimensionPill";-import type { DimensionItem } from "metabase/metrics-viewer/components/DimensionPillBar";+import type {+ DimensionPillBarItem,+ ExpressionDimensionItem,+ ExpressionMetricSource,+ MetricDimensionItem,+} from "metabase/metrics-viewer/components/DimensionPillBar";+import type { IconName } from "metabase/ui";import { getColorsForValues } from "metabase/ui/colors/charts";import { getColorplethColorScale } from "metabase/visualizations/components/ChoroplethMap";import {@@ -7,7 +15,7 @@ import {getBreakoutSeriesName,} from "metabase/visualizations/echarts/cartesian/model/series";import { MAX_SERIES } from "metabase/visualizations/lib/utils";-import type { DimensionMetadata, MetricDefinition } from "metabase-lib/metric";+import type { MetricDefinition } from "metabase-lib/metric";import * as LibMetric from "metabase-lib/metric";import type {Card,@@ -21,82 +29,321 @@ import type {RowValues,SeriesSettings,SingleSeries,+ TemporalUnit,VisualizationDisplay,VisualizationSettings,} from "metabase-types/api";-import type {- BreakoutColorMap,- MetricSourceId,- MetricsViewerDefinitionEntry,- MetricsViewerDisplayType,- SelectedMetric,- SourceBreakoutColorMap,- SourceColorMap,+import {+ type BreakoutColorMap,+ type ExpressionDefinitionEntry,+ type MetricDefinitionEntry,+ type MetricSourceId,+ type MetricsViewerDefinitionEntry,+ type MetricsViewerDisplayType,+ type MetricsViewerFormulaEntity,+ type SelectedMetric,+ type SourceBreakoutColorMap,+ type SourceColorMap,+ isExpressionEntry,+ isMetricEntry,} from "../types/viewer-state";import { getDefinitionName } from "./definition-builder";-import { entryHasBreakout, getEntryBreakout } from "./definition-entries";+import { getModifiedDefinition } from "./definition-cache";+import {+ entryHasBreakout,+ getEffectiveDefinitionEntry,+ getEntryBreakout,+} from "./definition-entries";import { findDimensionById } from "./dimension-lookup";+import { type MetricSlot, slotsForEntity } from "./metric-slots";import { nextSyntheticCardId, parseSourceId } from "./source-ids";import { DISPLAY_TYPE_REGISTRY } from "./tab-config";import { getDimensionIcon } from "./tabs";-function getDefinitionCardId(def: MetricDefinition): number | null {- const metricId = LibMetric.sourceMetricId(def);- if (metricId != null) {- return metricId;+interface BuildSeriesParams {+ formulaEntities: MetricsViewerFormulaEntity[];+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>;+ resultsByEntityIndex: Map<number, Dataset>;+ metricSlots: MetricSlot[];+ dimensionMapping: Record<number, DimensionId | null>;+ display: MetricsViewerDisplayType;+ modifiedDefinitionsBySlotIndex: Map<number, MetricDefinition>;+ sourceBreakoutColors: SourceBreakoutColorMap;+ extraVizSettings?: Partial<VisualizationSettings>;+}++export function buildSeries({+ formulaEntities,+ definitions,+ resultsByEntityIndex,+ metricSlots,+ dimensionMapping,+ display,+ modifiedDefinitionsBySlotIndex,+ sourceBreakoutColors,+ extraVizSettings,+}: BuildSeriesParams): {+ series: SingleSeries[];+ cardIdToEntityIndex: Record<CardId, number>;+ activeBreakoutColors: SourceBreakoutColorMap;+} {+ const uniqueNamesByEntityIndex = computeUniqueEntityNames(+ formulaEntities,+ definitions,+ );+ const displayType = DISPLAY_TYPE_REGISTRY[display];++ let isFirstSeries = true;+ const cardIdToEntityIndex: Record<CardId, number> = {};+ const activeBreakoutColors: SourceBreakoutColorMap = {};++ const series = Array.from(resultsByEntityIndex.entries()).flatMap(+ ([entityIndex, result]) => {+ let vizSettings: VisualizationSettings | null = null;+ const entity = formulaEntities[entityIndex];++ const name = uniqueNamesByEntityIndex.get(entityIndex);+ if (!name) {+ return [];+ }++ const colors = sourceBreakoutColors[entityIndex];+ const color = getSingleColor(colors);+ const hasBreakout =+ isMetricEntry(entity) &&+ entryHasBreakout(getEffectiveDefinitionEntry(entity, definitions)) &&+ result.data.rows.length > 0;+ const breakoutIsSameAsDimension =+ hasBreakout && result.data.cols.length === 2;+ const nativeBreakout =+ hasBreakout &&+ !breakoutIsSameAsDimension &&+ displayType.supportsMultipleSeries;+ const needsManualBreakoutSplit = hasBreakout && !nativeBreakout;++ if (nativeBreakout) {+ vizSettings = buildCartesianVizSettings(+ result.data,+ true,+ formulaEntities.length > 1,+ name,+ colors instanceof Map ? colors : undefined,+ );+ } else {+ vizSettings = getVizSettings(+ dimensionMapping,+ display,+ modifiedDefinitionsBySlotIndex,+ metricSlots+ .filter((slot) => slot.entityIndex === entityIndex)+ .map((slot) => slot.slotIndex),+ );+ }+ if (!vizSettings) {+ return [];+ }+ const cardId = nextSyntheticCardId();++ const seriesKey = isFirstSeries ? result.data.cols[1]?.name : name;++ const singleSeries: SingleSeries = {+ card: createSeriesCard(cardId, name, display, {+ ...vizSettings,+ ...(nativeBreakout+ ? {}+ : computeColorVizSettings({+ displayType: display,+ seriesKey,+ color,+ })),+ ...extraVizSettings,+ }),+ data: result.data,+ };++ let entrySeries: SingleSeries[];+ if (needsManualBreakoutSplit && colors instanceof Map) {+ const { series, activeBreakoutColorMap } = splitByBreakout(+ singleSeries,+ formulaEntities.length,+ isFirstSeries,+ colors,+ vizSettings,+ );+ entrySeries = series;+ activeBreakoutColors[entityIndex] = activeBreakoutColorMap;+ } else {+ entrySeries = [singleSeries];+ if (hasBreakout && !needsManualBreakoutSplit && colors instanceof Map) {+ activeBreakoutColors[entityIndex] = filterBreakoutColorsByData(+ colors,+ result.data,+ );+ } else {+ activeBreakoutColors[entityIndex] = color;+ }+ }++ isFirstSeries = false;++ for (const series of entrySeries) {+ cardIdToEntityIndex[series.card.id] = entityIndex;+ }+ return entrySeries;+ },+ );++ if (series.length > 1 && displayType.combineSettings) {+ series[0].card.visualization_settings = displayType.combineSettings(+ series.map((s) => s.card.visualization_settings),+ );}- const measureId = LibMetric.sourceMeasureId(def);- if (measureId != null) {- return nextSyntheticCardId();++ return { series, cardIdToEntityIndex, activeBreakoutColors };+}++function getVizSettings(+ dimensionMapping: Record<number, DimensionId | null>,+ display: MetricsViewerDisplayType,+ modifiedDefinitionsBySlotIndex: Map<number, MetricDefinition>,+ slotIndices: number[],+): VisualizationSettings | null {+ const displayConfig = DISPLAY_TYPE_REGISTRY[display];+ for (const slotIndex of slotIndices) {+ const modifiedDefinition = modifiedDefinitionsBySlotIndex.get(slotIndex);+ if (!modifiedDefinition) {+ continue;+ }+ const dimensionId = dimensionMapping[slotIndex];+ if (displayConfig.dimensionRequired) {+ if (!dimensionId) {+ continue;+ }+ const dimension = findDimensionById(modifiedDefinition, dimensionId);+ if (!dimension) {+ continue;+ }+ return displayConfig.getSettings(modifiedDefinition, dimension);+ }+ return displayConfig.getSettings(modifiedDefinition);}return null;}+/**+ * Compute unique display names for each formula entity, disambiguating+ * duplicate names by appending " (N)" starting from the second occurrence.+ * This ensures that `card.name` (used by `keyForSingleSeries` for color+ * resolution) is unique for each entity.+ */+export function computeUniqueEntityNames(+ formulaEntities: MetricsViewerFormulaEntity[],+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>,+): Map<number, string> {+ const rawNames: { entityIndex: number; name: string }[] = [];+ const totalCounts = new Map<string, number>();++ formulaEntities.forEach((entity, index) => {+ let name;+ if (isMetricEntry(entity)) {+ const effectiveDef = getEffectiveDefinitionEntry(entity, definitions);+ if (effectiveDef?.definition) {+ name = getDefinitionName(effectiveDef.definition);+ if (name) {+ rawNames.push({ entityIndex: index, name });+ }+ }+ } else if (isExpressionEntry(entity)) {+ name = entity.name;+ rawNames.push({ entityIndex: index, name: entity.name });+ }++ if (name) {+ totalCounts.set(name, (totalCounts.get(name) ?? 0) + 1);+ }+ });++ // Assign unique names: first occurrence keeps original, subsequent get " (N)"+ const result = new Map<number, string>();+ const seenCounts = new Map<string, number>();+ for (const { entityIndex, name } of rawNames) {+ const occurrence = (seenCounts.get(name) ?? 0) + 1;+ seenCounts.set(name, occurrence);+ if ((totalCounts.get(name) ?? 0) > 1 && occurrence > 1) {+ result.set(entityIndex, `${name} (${occurrence})`);+ } else {+ result.set(entityIndex, name);+ }+ }++ return result;+}+interface SourceColorEntry {- sourceId: MetricSourceId;+ entityIndex: number;keys: string[];keyToBreakoutValue: Record<string, string>;}export function computeSourceBreakoutColors(- definitions: MetricsViewerDefinitionEntry[],- breakoutValuesBySourceId?: Map<MetricSourceId, MetricBreakoutValuesResponse>,+ formulaEntities: MetricsViewerFormulaEntity[],+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>,+ breakoutValuesByEntityIndex?: Map<number, MetricBreakoutValuesResponse>,): SourceBreakoutColorMap {+ const uniqueNames = computeUniqueEntityNames(formulaEntities, definitions);+const entries: SourceColorEntry[] = [];- for (const entry of definitions) {- if (!entry.definition) {+ for (+ let entityIndex = 0;+ entityIndex < formulaEntities.length;+ entityIndex+++ ) {+ const entity = formulaEntities[entityIndex];+ const uniqueName = uniqueNames.get(entityIndex);+ if (!uniqueName) {continue;}- const displayName = getDefinitionName(entry.definition);- if (!displayName) {- continue;++ if (isMetricEntry(entity)) {+ const effectiveDef = getEffectiveDefinitionEntry(entity, definitions);+ if (!effectiveDef?.definition) {+ continue;+ }++ const response = breakoutValuesByEntityIndex?.get(entityIndex);+ if (+ entryHasBreakout(effectiveDef) &&+ response &&+ response.values.length > 0+ ) {+ const keys: string[] = [];+ const keyToBreakoutValue: Record<string, string> = {};+ response.values.forEach((val) => {+ const breakoutValue = formatBreakoutValue(val, response.col);+ const key = getBreakoutSeriesName(+ val,+ response.col,+ uniqueNames.size > 1,+ uniqueName,+ );+ keys.push(key);+ keyToBreakoutValue[key] = breakoutValue;+ });+ entries.push({ entityIndex, keys, keyToBreakoutValue });+ } else {+ entries.push({+ entityIndex,+ keys: [uniqueName],+ keyToBreakoutValue: {},+ });+ }}- const response = breakoutValuesBySourceId?.get(entry.id);- if (entryHasBreakout(entry) && response && response.values.length > 0) {- const keys: string[] = [];- const keyToBreakoutValue: Record<string, string> = {};- response.values.forEach((val) => {- const breakoutValue = formatBreakoutValue(val, response.col);- const key = getBreakoutSeriesName(- val,- response.col,- definitions.length > 1,- displayName,- );- keys.push(key);- keyToBreakoutValue[key] = breakoutValue;- });- entries.push({ sourceId: entry.id, keys, keyToBreakoutValue });- } else {- entries.push({- sourceId: entry.id,- keys: [displayName],- keyToBreakoutValue: {},- });+ if (isExpressionEntry(entity)) {+ entries.push({ entityIndex, keys: [uniqueName], keyToBreakoutValue: {} });}}@@ -111,9 +358,9 @@ export function computeSourceBreakoutColors(const result: SourceBreakoutColorMap = {};for (const entry of entries) {if (entry.keys.length === 1) {- result[entry.sourceId] = colorMapping[entry.keys[0]];+ result[entry.entityIndex] = colorMapping[entry.keys[0]];} else {- result[entry.sourceId] = new Map(+ result[entry.entityIndex] = new Map(Object.entries(entry.keyToBreakoutValue).map(([key, breakoutValue]) => [breakoutValue,colorMapping[key],@@ -183,6 +430,7 @@ export function splitByBreakout(seriesCount: number,isFirstSeries: boolean,breakoutColorMap: BreakoutColorMap,+ vizSettings: VisualizationSettings,): {series: SingleSeries[];activeBreakoutColorMap: BreakoutColorMap | string | undefined;@@ -209,7 +457,7 @@ export function splitByBreakout(if (rowsByBreakoutValue.size > MAX_SERIES) {return {series: [series],- activeBreakoutColorMap: getSingleColor(breakoutColorMap),+ activeBreakoutColorMap: breakoutColorMap.values().next().value,};}}@@ -247,6 +495,7 @@ export function splitByBreakout(id: nextSyntheticCardId(),name,visualization_settings: {+ ...vizSettings,...computeColorVizSettings({displayType: card.display,seriesKey,@@ -308,161 +557,6 @@ function createSeriesCard(} as Card;}-export function buildRawSeriesFromDefinitions(- definitions: MetricsViewerDefinitionEntry[],- dimensionMapping: Record<MetricSourceId, DimensionId | null>,- display: MetricsViewerDisplayType,- resultsByDefinitionId: Map<MetricSourceId, Dataset>,- modifiedDefinitions: Map<MetricSourceId, MetricDefinition>,- sourceBreakoutColors: SourceBreakoutColorMap,- extraVizSettings?: Partial<VisualizationSettings>,-): {- series: SingleSeries[];- cardIdToDefinitionId: Record<CardId, MetricSourceId>;- activeBreakoutColors: SourceBreakoutColorMap;-} {- const firstSettingsEntry = definitions.reduce<{- def: MetricDefinition;- dimension: DimensionMetadata;- } | null>((found, entry) => {- if (found) {- return found;- }- const dimensionId = dimensionMapping[entry.id];- if (!dimensionId || !entry.definition) {- return null;- }- const dimension = findDimensionById(entry.definition, dimensionId);- if (!dimension) {- return null;- }- const def = modifiedDefinitions.get(entry.id);- if (!def) {- return null;- }- return { def, dimension };- }, null);-- if (!firstSettingsEntry) {- return { series: [], cardIdToDefinitionId: {}, activeBreakoutColors: {} };- }-- const displayType = DISPLAY_TYPE_REGISTRY[display];- const baseSettings = displayType.getSettings(- firstSettingsEntry.def,- firstSettingsEntry.dimension,- );-- let isFirstSeries = true;- const cardIdToDefinitionId: Record<CardId, MetricSourceId> = {};- const activeBreakoutColors: SourceBreakoutColorMap = {};-- const series = definitions.flatMap((entry) => {- const dimensionId = dimensionMapping[entry.id];- if (!dimensionId || !entry.definition) {- return [];- }-- const modDef = modifiedDefinitions.get(entry.id);- const result = resultsByDefinitionId.get(entry.id);- if (!modDef || !result?.data?.cols?.length) {- return [];- }-- if (LibMetric.projections(modDef).length === 0) {- return [];- }-- const cardId = getDefinitionCardId(entry.definition);- if (cardId == null) {- return [];- }-- const name = getDefinitionName(entry.definition);- if (!name) {- return [];- }-- const colors = sourceBreakoutColors[entry.id];- const color = getSingleColor(colors);- const hasBreakout = entryHasBreakout(entry) && result.data.rows.length > 0;- const breakoutIsSameAsDimension =- hasBreakout && result.data.cols.length === 2;- const nativeBreakout =- hasBreakout &&- !breakoutIsSameAsDimension &&- displayType.supportsMultipleSeries;- const needsManualBreakoutSplit = hasBreakout && !nativeBreakout;-- let vizSettings: VisualizationSettings;- if (nativeBreakout) {- vizSettings = buildCartesianVizSettings(- result.data,- true,- definitions.length > 1,- name,- colors instanceof Map ? colors : undefined,- );- } else {- const seriesKey = isFirstSeries ? result.data.cols[1].name : name;- vizSettings = {- ...baseSettings,- ...computeColorVizSettings({- displayType: display,- seriesKey,- color,- }),- };- }-- if (extraVizSettings) {- vizSettings = { ...vizSettings, ...extraVizSettings };- }-- const singleSeries: SingleSeries = {- card: createSeriesCard(cardId, name, display, vizSettings),- data: result.data,- };-- let entrySeries: SingleSeries[];- if (needsManualBreakoutSplit && colors instanceof Map) {- const { series, activeBreakoutColorMap } = splitByBreakout(- singleSeries,- definitions.length,- isFirstSeries,- colors,- );- entrySeries = series;- activeBreakoutColors[entry.id] = activeBreakoutColorMap;- } else {- entrySeries = [singleSeries];- if (hasBreakout && !needsManualBreakoutSplit && colors instanceof Map) {- activeBreakoutColors[entry.id] = filterBreakoutColorsByData(- colors,- result.data,- );- } else {- activeBreakoutColors[entry.id] = color;- }- }- isFirstSeries = false;-- for (const s of entrySeries) {- cardIdToDefinitionId[s.card.id] = entry.id;- }-- return entrySeries;- });-- if (series.length > 1 && displayType.combineSettings) {- series[0].card.visualization_settings = displayType.combineSettings(- series.map((s) => s.card.visualization_settings),- );- }-- return { series, cardIdToDefinitionId, activeBreakoutColors };-}-export function computeBreakoutColorSettings(breakoutColors: BreakoutColorMap,breakoutCol: DatasetColumn,@@ -552,69 +646,245 @@ function computeAvailableOptions(});}+/**+ * Builds dimension items for the pill bar. Standalone metrics produce one+ * `DimensionItem` each. Expression entities produce one+ * `ExpressionDimensionItem` that groups all constituent metric-token slots+ * into a single pill with per-metric accordion sections.+ */export function buildDimensionItemsFromDefinitions(- definitions: MetricsViewerDefinitionEntry[],- dimensionMapping: Record<MetricSourceId, DimensionId | null>,- modifiedDefinitions: Map<MetricSourceId, MetricDefinition>,+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>,+ dimensionMapping: Record<number, DimensionId | null>,+ modifiedDefinitionsBySlotIndex: Map<number, MetricDefinition>,sourceColors: SourceColorMap,+ metricSlots: MetricSlot[],+ formulaEntities: MetricsViewerFormulaEntity[],+ projectionConfig: { temporalUnit?: TemporalUnit; binningStrategy?: string },dimensionFilter?: (dimension: LibMetric.DimensionMetadata) => boolean,-): DimensionItem[] {- return definitions.flatMap((entry): DimensionItem[] => {- if (!entry.definition) {- return [];+): DimensionPillBarItem[] {+ const items: DimensionPillBarItem[] = [];++ // Track which entity indices we've already emitted items for.+ const processedEntityIndices = new Set<number>();++ for (const slot of metricSlots) {+ // Skip if we already processed this entity index.+ if (processedEntityIndices.has(slot.entityIndex)) {+ continue;}- const dimensionId = dimensionMapping[entry.id];- const entryColors = sourceColors[entry.id];- const modifiedDefinition = modifiedDefinitions.get(entry.id);+ const entity = formulaEntities[slot.entityIndex];++ if (isExpressionEntry(entity)) {+ // Expression entity — gather all token slots for this entity and+ // produce a single ExpressionDimensionItem.+ processedEntityIndices.add(slot.entityIndex);++ const entitySlots = slotsForEntity(metricSlots, slot.entityIndex);+ const metricSources = buildExpressionMetricSources(+ entitySlots,+ definitions,+ dimensionMapping,+ sourceColors,+ projectionConfig,+ entity,+ dimensionFilter,+ );- if (dimensionId != null && modifiedDefinition) {- const projections = LibMetric.projections(modifiedDefinition);- if (projections.length === 0) {- return [];- }+ // Derive aggregate label and icon from selected dimensions.+ const selectedLabels = metricSources+ .map((s) => s.currentDimensionLabel)+ .filter(Boolean);+ const uniqueLabels = [...new Set(selectedLabels)];+ const label =+ uniqueLabels.length === 1+ ? uniqueLabels[0]+ : uniqueLabels.length > 1+ ? t`Multiple dimensions`+ : undefined;+ const selectedIcons = metricSources+ .map((s) => s.currentDimensionIcon)+ .filter(Boolean);+ const uniqueIcons = [...new Set(selectedIcons)];+ const icon = uniqueIcons.length === 1 ? uniqueIcons[0] : undefined;++ const expressionColors = sourceColors[slot.entityIndex];++ items.push({+ type: "expression",+ id: slot.entityIndex,+ colors: expressionColors,+ label,+ icon,+ metricSources,+ } satisfies ExpressionDimensionItem);+ }- const projectionDimension = LibMetric.projectionDimension(- modifiedDefinition,- projections[0],+ if (isMetricEntry(entity)) {+ processedEntityIndices.add(slot.entityIndex);++ const item = buildStandaloneDimensionItem(+ entity,+ slot,+ definitions,+ dimensionMapping,+ modifiedDefinitionsBySlotIndex,+ sourceColors,+ dimensionFilter,);- if (!projectionDimension) {- return [];+ if (item) {+ items.push(item);}+ }+ }- const dimensionInfo = LibMetric.displayInfo(- modifiedDefinition,- projectionDimension,- );+ return items;+}- return [- {- id: entry.id,- label: dimensionInfo.longDisplayName,- icon: getDimensionIcon(projectionDimension),- colors: entryColors,- availableOptions: computeAvailableOptions(- entry,- modifiedDefinition,- dimensionFilter,- ),- },- ];+function buildStandaloneDimensionItem(+ entity: MetricDefinitionEntry,+ slot: MetricSlot,+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>,+ dimensionMapping: Record<number, DimensionId | null>,+ modifiedDefinitionsBySlotIndex: Map<number, MetricDefinition>,+ sourceColors: SourceColorMap,+ dimensionFilter?: (dimension: LibMetric.DimensionMetadata) => boolean,+): MetricDimensionItem | null {+ const defEntry = getEffectiveDefinitionEntry(entity, definitions);+ if (!defEntry?.definition) {+ return null;+ }++ const effectiveEntry: MetricsViewerDefinitionEntry = {+ id: slot.sourceId,+ definition: defEntry.definition,+ };++ const dimensionId = dimensionMapping[slot.slotIndex];+ const entryColors = sourceColors[slot.entityIndex];+ const modifiedDefinition = modifiedDefinitionsBySlotIndex.get(slot.slotIndex);++ if (dimensionId != null && modifiedDefinition) {+ const projections = LibMetric.projections(modifiedDefinition);+ if (projections.length === 0) {+ return null;}- const availableOptions = computeAvailableOptions(- entry,+ const projectionDimension = LibMetric.projectionDimension(+ modifiedDefinition,+ projections[0],+ );+ if (!projectionDimension) {+ return null;+ }++ const dimensionInfo = LibMetric.displayInfo(+ modifiedDefinition,+ projectionDimension,+ );++ return {+ id: slot.slotIndex,+ type: "metric",+ label: dimensionInfo.longDisplayName,+ icon: getDimensionIcon(projectionDimension),+ colors: entryColors,+ availableOptions: computeAvailableOptions(+ effectiveEntry,+ modifiedDefinition,+ dimensionFilter,+ ),+ };+ }++ return {+ id: slot.slotIndex,+ type: "metric",+ label: undefined,+ icon: undefined,+ colors: entryColors,+ availableOptions: computeAvailableOptions(+ effectiveEntry,undefined,dimensionFilter,- );+ ),+ };+}++function buildExpressionMetricSources(+ entitySlots: MetricSlot[],+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>,+ dimensionMapping: Record<number, DimensionId | null>,+ sourceColors: SourceColorMap,+ projectionConfig: { temporalUnit?: TemporalUnit; binningStrategy?: string },+ entity: ExpressionDefinitionEntry,+ dimensionFilter?: (dimension: LibMetric.DimensionMetadata) => boolean,+): ExpressionMetricSource[] {+ return entitySlots.flatMap((slot): ExpressionMetricSource[] => {+ const defEntry = definitions[slot.sourceId];+ if (!defEntry?.definition) {+ return [];+ }++ const effectiveEntry: MetricsViewerDefinitionEntry = {+ id: slot.sourceId,+ definition: defEntry.definition,+ };++ const dimensionId = dimensionMapping[slot.slotIndex];+ const entryColors = sourceColors[slot.entityIndex];+ const metricName = getDefinitionName(defEntry.definition) ?? slot.sourceId;++ // Compute modified definition on the fly for expression token slots.+ let modifiedDefinition: MetricDefinition | undefined;+ if (dimensionId) {+ modifiedDefinition =+ getModifiedDefinition(+ defEntry.definition,+ dimensionId,+ projectionConfig,+ ) ?? undefined;+ }++ let currentDimensionLabel: string | undefined;+ let currentDimensionIcon: IconName | undefined;+ if (dimensionId != null && modifiedDefinition) {+ const projections = LibMetric.projections(modifiedDefinition);+ if (projections.length > 0) {+ const projDim = LibMetric.projectionDimension(+ modifiedDefinition,+ projections[0],+ );+ if (projDim) {+ currentDimensionLabel = LibMetric.displayInfo(+ modifiedDefinition,+ projDim,+ ).longDisplayName;+ currentDimensionIcon = getDimensionIcon(projDim);+ }+ }+ }return [{- id: entry.id,- label: undefined,- icon: undefined,+ slotIndex: slot.slotIndex,+ sourceId: slot.sourceId,+ metricName,+ metricCount: (() => {+ if (slot.tokenPosition == null) {+ return undefined;+ }+ const token = entity.tokens[slot.tokenPosition];+ return token?.type === "metric" ? token.count : undefined;+ })(),colors: entryColors,- availableOptions,+ currentDimensionLabel,+ currentDimensionIcon,+ availableOptions: computeAvailableOptions(+ effectiveEntry,+ modifiedDefinition,+ dimensionFilter,+ ),},];});diff --git a/frontend/src/metabase/metrics-viewer/utils/series.unit.spec.ts b/frontend/src/metabase/metrics-viewer/utils/series.unit.spec.tsindex 60e88743d29..3712ffcd96e 100644--- a/frontend/src/metabase/metrics-viewer/utils/series.unit.spec.ts+++ b/frontend/src/metabase/metrics-viewer/utils/series.unit.spec.ts@@ -1,6 +1,7 @@import type {MetricBreakoutValuesResponse,RowValues,+ VisualizationSettings,} from "metabase-types/api";import { createMockColumn } from "metabase-types/api/mocks";import { createMockDatasetData } from "metabase-types/api/mocks/dataset";@@ -46,6 +47,7 @@ const metricCol = createMockColumn({});const CARD_OPTS = { id: 1, name: "Revenue", display: "line" } as const;+const EMPTY_VIZ: VisualizationSettings = {};function makeColorMap(values: string[]): BreakoutColorMap {const palette = [@@ -79,6 +81,7 @@ describe("splitByBreakout", () => {1,true,makeColorMap(["Gadgets", "Widgets"]),+ EMPTY_VIZ,);expect(result).toHaveLength(2);@@ -114,6 +117,7 @@ describe("splitByBreakout", () => {2,true,makeColorMap(["Gadgets", "Widgets"]),+ EMPTY_VIZ,);expect(result[0].card.name).toBe("Revenue: Gadgets");@@ -139,6 +143,7 @@ describe("splitByBreakout", () => {1,true,makeColorMap(["Gadgets", "Widgets"]),+ EMPTY_VIZ,);expect(result).toHaveLength(2);@@ -172,6 +177,7 @@ describe("splitByBreakout", () => {1,true,makeColorMap(["Gadgets", "Widgets"]),+ EMPTY_VIZ,);const ids = result.map((s) => s.card.id);@@ -190,7 +196,13 @@ describe("splitByBreakout", () => {});const colorMap = makeColorMap(["Gadgets", "Widgets"]);- const { series: result } = splitByBreakout(series, 1, true, colorMap);+ const { series: result } = splitByBreakout(+ series,+ 1,+ true,+ colorMap,+ EMPTY_VIZ,+ );expect(result[0].card.visualization_settings.series_settings).toBeDefined();expect(result[1].card.visualization_settings.series_settings).toBeDefined();@@ -208,6 +220,7 @@ describe("splitByBreakout", () => {1,true,makeColorMap(values),+ EMPTY_VIZ,);expect(result).toHaveLength(1);@@ -230,6 +243,7 @@ describe("splitByBreakout", () => {1,true,makeColorMap(["Gadgets", "Widgets"]),+ EMPTY_VIZ,);expect(result[0].data.cols).toBe(result[1].data.cols);@@ -257,6 +271,7 @@ describe("splitByBreakout", () => {1,true,colorMap,+ EMPTY_VIZ,);expect(result).toHaveLength(1);@@ -280,7 +295,13 @@ describe("splitByBreakout", () => {["Widgets", "#88BF4D"],]);- const { series: result } = splitByBreakout(series, 1, true, colorMap);+ const { series: result } = splitByBreakout(+ series,+ 1,+ true,+ colorMap,+ EMPTY_VIZ,+ );expect(result).toHaveLength(2);// series order follows colorMap iteration order, not data order@@ -306,19 +327,21 @@ describe("splitByBreakout", () => {});describe("computeSourceBreakoutColors", () => {- it("returns empty object for empty definitions", () => {- expect(computeSourceBreakoutColors([])).toEqual({});+ it("returns empty object for empty formula entities", () => {+ expect(computeSourceBreakoutColors([], {})).toEqual({});});it("returns a string color for a definition without breakout", () => {const metadata = createMetricMetadata([REVENUE_METRIC]);const definition = setupDefinition(metadata, REVENUE_METRIC.id);+ const sourceId: MetricSourceId = `metric:${REVENUE_METRIC.id}`;- const result = computeSourceBreakoutColors([- { id: "metric:1", definition },- ]);+ const result = computeSourceBreakoutColors(+ [{ id: sourceId, type: "metric" as const, definition }],+ { [sourceId]: { id: sourceId, definition } },+ );- expect(typeof result["metric:1"]).toBe("string");+ expect(typeof result[0]).toBe("string");});it("returns a Map for a definition with breakout and breakout values", () => {@@ -328,13 +351,11 @@ describe("computeSourceBreakoutColors", () => {REVENUE_METRIC.id,1,);+ const sourceId: MetricSourceId = `metric:${REVENUE_METRIC.id}`;- const breakoutValues = new Map<- MetricSourceId,- MetricBreakoutValuesResponse- >([+ const breakoutValues = new Map<number, MetricBreakoutValuesResponse>([[- "metric:1",+ 0,{values: ["Gadgets", "Widgets"],col: createMockColumn({@@ -347,12 +368,13 @@ describe("computeSourceBreakoutColors", () => {]);const result = computeSourceBreakoutColors(- [{ id: "metric:1", definition }],+ [{ id: sourceId, type: "metric" as const, definition }],+ { [sourceId]: { id: sourceId, definition } },breakoutValues,);- expect(result["metric:1"]).toBeInstanceOf(Map);- const colorMap = result["metric:1"] as Map<string, string>;+ expect(result[0]).toBeInstanceOf(Map);+ const colorMap = result[0] as Map<string, string>;expect(colorMap.size).toBe(2);expect(colorMap.has("Gadgets")).toBe(true);expect(colorMap.has("Widgets")).toBe(true);@@ -368,13 +390,12 @@ describe("computeSourceBreakoutColors", () => {1,);const withoutBreakout = setupDefinition(metadata, REVENUE_METRIC.id);+ const sourceId1: MetricSourceId = `metric:${REVENUE_METRIC.id}`;+ const sourceId2: MetricSourceId = `metric:${REVENUE_METRIC.id}`;- const breakoutValues = new Map<- MetricSourceId,- MetricBreakoutValuesResponse- >([+ const breakoutValues = new Map<number, MetricBreakoutValuesResponse>([[- "metric:1",+ 0,{values: ["Gadgets", "Widgets"],col: createMockColumn({@@ -388,14 +409,22 @@ describe("computeSourceBreakoutColors", () => {const result = computeSourceBreakoutColors([- { id: "metric:1", definition: withBreakout },- { id: "metric:2" as MetricSourceId, definition: withoutBreakout },+ { id: sourceId1, type: "metric" as const, definition: withBreakout },+ {+ id: sourceId2,+ type: "metric" as const,+ definition: withoutBreakout,+ },],+ {+ [sourceId1]: { id: sourceId1, definition: withBreakout },+ [sourceId2]: { id: sourceId2, definition: withoutBreakout },+ },breakoutValues,);- expect(result["metric:1"]).toBeInstanceOf(Map);- expect(typeof result["metric:2" as MetricSourceId]).toBe("string");+ expect(result[0]).toBeInstanceOf(Map);+ expect(typeof result[1]).toBe("string");});it("falls back to string when breakout definition has no breakout values", () => {@@ -405,13 +434,15 @@ describe("computeSourceBreakoutColors", () => {REVENUE_METRIC.id,1,);+ const sourceId: MetricSourceId = `metric:${REVENUE_METRIC.id}`;const result = computeSourceBreakoutColors(- [{ id: "metric:1", definition }],+ [{ id: sourceId, type: "metric" as const, definition }],+ { [sourceId]: { id: sourceId, definition } },new Map(),);- expect(typeof result["metric:1"]).toBe("string");+ expect(typeof result[0]).toBe("string");});});diff --git a/frontend/src/metabase/metrics-viewer/utils/tab-config.ts b/frontend/src/metabase/metrics-viewer/utils/tab-config.tsindex 82482d8d2b3..f84ca6a21c7 100644--- a/frontend/src/metabase/metrics-viewer/utils/tab-config.ts+++ b/frontend/src/metabase/metrics-viewer/utils/tab-config.ts@@ -12,6 +12,7 @@ import type {MetricsViewerTabType,} from "../types/viewer-state";+import { getDefinitionColumnName } from "./definition-builder";import { getMapRegionForDimension } from "./geo-dimensions";// ── Types ──@@ -21,17 +22,28 @@ export interface ChartTypeOption {icon: IconName;}-interface DisplayTypeDefinition {- supportsMultipleSeries: boolean;- supportsStacking: boolean;- getSettings: (- def: MetricDefinition,- dimension: DimensionMetadata,- ) => VisualizationSettings;- combineSettings?: (- settings: VisualizationSettings[],- ) => VisualizationSettings;-}+type DisplayTypeDefinition =+ | {+ dimensionRequired: true;+ supportsMultipleSeries: boolean;+ supportsStacking: boolean;+ getSettings: (+ def: MetricDefinition,+ dimension: DimensionMetadata,+ ) => VisualizationSettings;+ combineSettings?: (+ settings: VisualizationSettings[],+ ) => VisualizationSettings;+ }+ | {+ dimensionRequired: false;+ supportsMultipleSeries: boolean;+ supportsStacking: boolean;+ getSettings: (def: MetricDefinition) => VisualizationSettings;+ combineSettings?: (+ settings: VisualizationSettings[],+ ) => VisualizationSettings;+ };interface BaseTabTypeDefinition {type: MetricsViewerTabType;@@ -40,6 +52,8 @@ interface BaseTabTypeDefinition {dimensionSubtype?: (dimension: DimensionMetadata) => string | null;defaultDisplayType: MetricsViewerDisplayType;availableDisplayTypes: ChartTypeOption[];+ minDimensions: number;+ index?: number;}interface AggregateTabType extends BaseTabTypeDefinition {@@ -82,6 +96,7 @@ export const TAB_TYPE_REGISTRY: TabTypeDefinition[] = [fixedId: "time",defaultDisplayType: "line",availableDisplayTypes: STANDARD_CHART_TYPES,+ minDimensions: 1,},{type: "geo",@@ -92,6 +107,18 @@ export const TAB_TYPE_REGISTRY: TabTypeDefinition[] = [dimensionSubtype: getGeoSubtype,defaultDisplayType: "map",availableDisplayTypes: GEO_CHART_TYPES,+ minDimensions: 1,+ },+ {+ type: "scalar",+ autoCreate: true,+ matchMode: "aggregate",+ fixedId: "scalar",+ dimensionPredicate: () => false,+ defaultDisplayType: "scalar",+ availableDisplayTypes: [{ type: "scalar", icon: "number" }],+ index: 5,+ minDimensions: 0,},{type: "category",@@ -100,6 +127,7 @@ export const TAB_TYPE_REGISTRY: TabTypeDefinition[] = [matchMode: "exact-column",defaultDisplayType: "bar",availableDisplayTypes: STANDARD_CHART_TYPES,+ minDimensions: 1,},{type: "boolean",@@ -108,6 +136,7 @@ export const TAB_TYPE_REGISTRY: TabTypeDefinition[] = [matchMode: "exact-column",defaultDisplayType: "bar",availableDisplayTypes: STANDARD_CHART_TYPES,+ minDimensions: 1,},{type: "numeric",@@ -116,6 +145,7 @@ export const TAB_TYPE_REGISTRY: TabTypeDefinition[] = [matchMode: "exact-column",defaultDisplayType: "bar",availableDisplayTypes: NUMERIC_CHART_TYPES,+ minDimensions: 1,},];@@ -162,13 +192,6 @@ function getChartSettings(};}-function getPieSettings(- _def: MetricDefinition,- _dimension: DimensionMetadata,-): VisualizationSettings {- return {};-}-function getScatterSettings(def: MetricDefinition,dimension: DimensionMetadata,@@ -201,6 +224,12 @@ function getMapSettings(};}+function getScalarSettings(def: MetricDefinition): VisualizationSettings {+ return {+ "scalar.field": getDefinitionColumnName(def) ?? undefined,+ };+}+function combineColors(settings: VisualizationSettings[],): VisualizationSettings {@@ -221,41 +250,43 @@ export const DISPLAY_TYPE_REGISTRY: Record<DisplayTypeDefinition> = {line: {+ dimensionRequired: true,supportsMultipleSeries: true,supportsStacking: true,getSettings: getChartSettings,combineSettings: combineColors,},area: {+ dimensionRequired: true,supportsMultipleSeries: true,supportsStacking: true,getSettings: getChartSettings,combineSettings: combineColors,},bar: {+ dimensionRequired: true,supportsMultipleSeries: true,supportsStacking: true,getSettings: getChartSettings,combineSettings: combineColors,},- row: {- supportsMultipleSeries: true,- supportsStacking: false,- getSettings: getChartSettings,- },scatter: {+ dimensionRequired: true,supportsMultipleSeries: true,- supportsStacking: false,+ supportsStacking: true,getSettings: getScatterSettings,+ combineSettings: combineColors,},map: {+ dimensionRequired: true,supportsMultipleSeries: false,- supportsStacking: false,+ supportsStacking: true,getSettings: getMapSettings,},- pie: {+ scalar: {+ dimensionRequired: false,supportsMultipleSeries: false,- supportsStacking: false,- getSettings: getPieSettings,+ supportsStacking: true,+ getSettings: getScalarSettings,},};diff --git a/frontend/src/metabase/metrics-viewer/utils/tabs.ts b/frontend/src/metabase/metrics-viewer/utils/tabs.tsindex 5e3781c6ae4..8b27a1cb5a8 100644--- a/frontend/src/metabase/metrics-viewer/utils/tabs.ts+++ b/frontend/src/metabase/metrics-viewer/utils/tabs.ts@@ -1,3 +1,5 @@+import { t } from "ttag";+import type { DimensionDescriptor } from "metabase/metrics/common/utils/dimension-descriptors";import { getDimensionDescriptors } from "metabase/metrics/common/utils/dimension-descriptors";import { GEO_SUBTYPE_PRIORITY } from "metabase/metrics/common/utils/dimension-types";@@ -9,11 +11,13 @@ import * as LibMetric from "metabase-lib/metric";import { MAX_AUTO_TABS } from "../constants";import type {MetricSourceId,+ MetricsViewerDefinitionEntry,MetricsViewerTabState,MetricsViewerTabType,StoredMetricsViewerTab,} from "../types/viewer-state";+import type { MetricSlot } from "./metric-slots";import {TAB_TYPE_REGISTRY,type TabTypeDefinition,@@ -108,18 +112,58 @@ export function resolveCommonTabLabel(names: string[]): string | null {return bestName;}+/**+ * Recompute tab labels from the current dimension mappings.+ * Returns a new array only if at least one label changed.+ */+export function recomputeTabLabels(+ tabs: MetricsViewerTabState[],+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>,+ metricSlots: MetricSlot[],+): MetricsViewerTabState[] {+ const dimsBySlotIndex = new Map<+ number,+ Map<string, ViewerDimensionDescriptor>+ >();+ for (const slot of metricSlots) {+ const entry = definitions[slot.sourceId];+ if (entry?.definition) {+ dimsBySlotIndex.set(+ slot.slotIndex,+ getDimensionsByType(entry.definition),+ );+ }+ }++ let changed = false;+ const result = tabs.map((tab) => {+ const names = resolveTabDimensionNames(+ tab.dimensionMapping,+ dimsBySlotIndex,+ );+ const label = resolveCommonTabLabel(names);+ if (label != null && label !== tab.label) {+ changed = true;+ return { ...tab, label };+ }+ return tab;+ });++ return changed ? result : tabs;+}+// ── Default tab computation ──-function getDimensionDescriptorsBySource(+function getDimensionDescriptorsBySlotIndex(definitionsBySourceId: Record<MetricSourceId, MetricDefinition | null>,- sourceOrder: MetricSourceId[],-): Map<MetricSourceId, Map<string, DimensionDescriptor>> {- const result = new Map<MetricSourceId, Map<string, DimensionDescriptor>>();+ metricSlots: MetricSlot[],+): Map<number, Map<string, DimensionDescriptor>> {+ const result = new Map<number, Map<string, DimensionDescriptor>>();- for (const sourceId of sourceOrder) {- const def = definitionsBySourceId[sourceId];+ for (const slot of metricSlots) {+ const def = definitionsBySourceId[slot.sourceId];if (def) {- result.set(sourceId, getDimensionDescriptors(def));+ result.set(slot.slotIndex, getDimensionDescriptors(def));}}@@ -127,13 +171,19 @@ function getDimensionDescriptorsBySource(}function resolveTabDimensionNames(- dimensionMapping: Record<MetricSourceId, string>,- dimensionsBySource: Map<MetricSourceId, Map<string, DimensionDescriptor>>,+ dimensionMapping: Record<number, string | null>,+ dimensionsBySlotIndex: Map<number, Map<string, DimensionDescriptor>>,): string[] {const names: string[] = [];- for (const [sourceId, dimensionId] of getObjectEntries(dimensionMapping)) {- const dimensionInfo = dimensionsBySource.get(sourceId)?.get(dimensionId);+ for (const [key, dimensionId] of getObjectEntries(dimensionMapping)) {+ if (dimensionId == null) {+ continue;+ }+ const slotIndex = Number(key);+ const dimensionInfo = dimensionsBySlotIndex+ .get(slotIndex)+ ?.get(dimensionId);if (dimensionInfo) {names.push(dimensionInfo.displayName);}@@ -181,52 +231,68 @@ function pickBestGeoSubtype(found: Set<string>): string | null {return found.size > 0 ? (found.values().next().value ?? null) : null;}-function computeBestSubtypeAcrossSources(- dimensionsBySource: Map<MetricSourceId, Map<string, DimensionDescriptor>>,+function collectSubtypes(+ dimensions: Map<string, DimensionDescriptor>,type: MetricsViewerTabType,getSubtype: (dimension: DimensionMetadata) => string | null,-): string | null {- const found = new Set<string>();-- for (const [, dimensions] of dimensionsBySource) {- for (const [, info] of dimensions) {- if (info.dimensionType === type) {- const subtype = getSubtype(info.dimensionMetadata);- if (subtype) {- found.add(subtype);- }+ into: Set<string>,+): void {+ for (const [, info] of dimensions) {+ if (info.dimensionType === type) {+ const subtype = getSubtype(info.dimensionMetadata);+ if (subtype) {+ into.add(subtype);}}}+}+function computeBestSubtypeAcrossSources(+ dimensionsByEntityIndex: Map<number, Map<string, DimensionDescriptor>>,+ type: MetricsViewerTabType,+ getSubtype: (dimension: DimensionMetadata) => string | null,+): string | null {+ const found = new Set<string>();+ for (const [, dimensions] of dimensionsByEntityIndex) {+ collectSubtypes(dimensions, type, getSubtype, found);+ }return pickBestGeoSubtype(found);}function findReferenceAcrossSources(- dimensionsBySource: Map<MetricSourceId, Map<string, DimensionDescriptor>>,- sourceOrder: MetricSourceId[],+ dimensionsByEntityIndex: Map<number, Map<string, DimensionDescriptor>>,+ entityOrder: number[],type: MetricsViewerTabType,-): { sourceId: MetricSourceId; dimension: DimensionDescriptor } | null {- for (const sourceId of sourceOrder) {- const dimensions = dimensionsBySource.get(sourceId);+): { entityIndex: number; dimension: DimensionDescriptor } | null {+ for (const entityIndex of entityOrder) {+ const dimensions = dimensionsByEntityIndex.get(entityIndex);if (!dimensions) {continue;}const defaultDimension = findDimensionOfType(dimensions, type, true);if (defaultDimension) {- return { sourceId, dimension: defaultDimension };+ return { entityIndex, dimension: defaultDimension };}}return null;}+/**+ * Find the best matching dimension in `dimensions` for a given `reference`.+ *+ * Match priority: exact source > case-insensitive name > compatible type.+ * When `getSubtype` is provided, name and type matches also require the+ * subtype to agree (used for geo dimension matching).+ */function findSourceMatch(dimensions: Map<string, DimensionDescriptor>,type: MetricsViewerTabType,reference: DimensionDescriptor,+ getSubtype?: (dimension: DimensionMetadata) => string | null,): DimensionDescriptor | null {let nameMatch: DimensionDescriptor | null = null;- const referenceName = reference.name;+ let typeMatch: DimensionDescriptor | null = null;+ const referenceName = reference.name.toLowerCase();for (const [, info] of dimensions) {if (info.dimensionType !== type) {@@ -240,24 +306,49 @@ function findSourceMatch() {return info;}- if (!nameMatch && referenceName && info.name === referenceName) {- nameMatch = info;+ if (+ !nameMatch &&+ referenceName &&+ info.name.toLowerCase() === referenceName+ ) {+ if (+ !getSubtype ||+ getSubtype(info.dimensionMetadata) ===+ getSubtype(reference.dimensionMetadata)+ ) {+ nameMatch = info;+ }+ }+ if (+ !typeMatch &&+ LibMetric.isCompatibleType(+ info.dimensionMetadata,+ reference.dimensionMetadata,+ )+ ) {+ if (+ !getSubtype ||+ getSubtype(info.dimensionMetadata) ===+ getSubtype(reference.dimensionMetadata)+ ) {+ typeMatch = info;+ }}}- return nameMatch;+ return nameMatch ?? typeMatch;}function resolveAggregateDimensionMapping(- dimensionsBySource: Map<MetricSourceId, Map<string, DimensionDescriptor>>,- sourceOrder: MetricSourceId[],+ dimensionsByEntityIndex: Map<number, Map<string, DimensionDescriptor>>,+ entityOrder: number[],config: TabTypeDefinition,-): Record<MetricSourceId, string> {- const mapping: Record<MetricSourceId, string> = {};+): Record<number, string> {+ const mapping: Record<number, string> = {};if (config.dimensionSubtype) {const targetSubtype = computeBestSubtypeAcrossSources(- dimensionsBySource,+ dimensionsByEntityIndex,config.type,config.dimensionSubtype,);@@ -265,8 +356,8 @@ function resolveAggregateDimensionMapping(return mapping;}- for (const sourceId of sourceOrder) {- const dimensions = dimensionsBySource.get(sourceId);+ for (const entityIndex of entityOrder) {+ const dimensions = dimensionsByEntityIndex.get(entityIndex);if (!dimensions) {continue;}@@ -277,7 +368,7 @@ function resolveAggregateDimensionMapping(targetSubtype,);if (match) {- mapping[sourceId] = match.id;+ mapping[entityIndex] = match.id;}}@@ -285,21 +376,21 @@ function resolveAggregateDimensionMapping(}const reference = findReferenceAcrossSources(- dimensionsBySource,- sourceOrder,+ dimensionsByEntityIndex,+ entityOrder,config.type,);if (reference) {- mapping[reference.sourceId] = reference.dimension.id;+ mapping[reference.entityIndex] = reference.dimension.id;}- for (const sourceId of sourceOrder) {- if (mapping[sourceId]) {+ for (const entityIndex of entityOrder) {+ if (mapping[entityIndex]) {continue;}- const dimensions = dimensionsBySource.get(sourceId);+ const dimensions = dimensionsByEntityIndex.get(entityIndex);if (!dimensions) {continue;}@@ -312,7 +403,7 @@ function resolveAggregateDimensionMapping(findDimensionOfType(dimensions, config.type);if (match) {- mapping[sourceId] = match.id;+ mapping[entityIndex] = match.id;}}@@ -320,24 +411,24 @@ function resolveAggregateDimensionMapping(}function collectUniqueExactDimensions(- dimensionsBySource: Map<MetricSourceId, Map<string, DimensionDescriptor>>,- sourceOrder: MetricSourceId[],+ dimensionsBySlotIndex: Map<number, Map<string, DimensionDescriptor>>,+ slotOrder: number[],type: MetricsViewerTabType,): Map<string,- { displayName: string; sourceIds: MetricSourceId[]; canListValues: boolean }+ { displayName: string; slotIndices: number[]; canListValues: boolean }> {const unique = new Map<string,{displayName: string;- sourceIds: MetricSourceId[];+ slotIndices: number[];canListValues: boolean;}>();- for (const sourceId of sourceOrder) {- const dimensions = dimensionsBySource.get(sourceId);+ for (const slotIndex of slotOrder) {+ const dimensions = dimensionsBySlotIndex.get(slotIndex);if (!dimensions) {continue;}@@ -349,14 +440,14 @@ function collectUniqueExactDimensions(const existing = unique.get(info.id);if (existing) {- existing.sourceIds.push(sourceId);+ existing.slotIndices.push(slotIndex);if (info.canListValues) {existing.canListValues = true;}} else {unique.set(info.id, {displayName: info.displayName,- sourceIds: [sourceId],+ slotIndices: [slotIndex],canListValues: info.canListValues ?? false,});}@@ -368,21 +459,23 @@ function collectUniqueExactDimensions(export function computeDefaultTabs(definitionsBySourceId: Record<MetricSourceId, MetricDefinition | null>,- sourceOrder: MetricSourceId[],+ metricSlots: MetricSlot[],): MetricsViewerTabState[] {- if (sourceOrder.length === 0) {+ if (metricSlots.length === 0) {return [];}- const dimensionsBySource = getDimensionDescriptorsBySource(+ const slotOrder = metricSlots.map((s) => s.slotIndex);++ const dimensionsBySlotIndex = getDimensionDescriptorsBySlotIndex(definitionsBySourceId,- sourceOrder,+ metricSlots,);- if (dimensionsBySource.size === 0) {+ if (dimensionsBySlotIndex.size === 0) {return [];}- const tabs: MetricsViewerTabState[] = [];+ const tabs: (MetricsViewerTabState & { index?: number })[] = [];for (const config of TAB_TYPE_REGISTRY) {if (!config.autoCreate || tabs.length >= MAX_AUTO_TABS) {@@ -391,29 +484,33 @@ export function computeDefaultTabs(if (config.matchMode === "aggregate") {const mapping = resolveAggregateDimensionMapping(- dimensionsBySource,- sourceOrder,+ dimensionsBySlotIndex,+ slotOrder,config,);- if (Object.keys(mapping).length === 0) {+ if (Object.keys(mapping).length < config.minDimensions) {continue;}- const names = resolveTabDimensionNames(mapping, dimensionsBySource);+ const names = resolveTabDimensionNames(mapping, dimensionsBySlotIndex);tabs.push({id: config.fixedId,type: config.type,- label: resolveCommonTabLabel(names),+ label:+ config.type === "scalar"+ ? getScalarTabLabel()+ : resolveCommonTabLabel(names),display: config.defaultDisplayType,dimensionMapping: mapping,projectionConfig: {},+ index: config.index,});continue;}const uniqueDimensions = collectUniqueExactDimensions(- dimensionsBySource,- sourceOrder,+ dimensionsBySlotIndex,+ slotOrder,config.type,);@@ -426,14 +523,17 @@ export function computeDefaultTabs(},);- for (const [dimensionId, { displayName, sourceIds }] of sortedDimensions) {+ for (const [+ dimensionId,+ { displayName, slotIndices },+ ] of sortedDimensions) {if (tabs.length >= MAX_AUTO_TABS) {break;}- const mapping: Record<MetricSourceId, string> = {};- for (const sourceId of sourceIds) {- mapping[sourceId] = dimensionId;+ const mapping: Record<number, string> = {};+ for (const slotIndex of slotIndices) {+ mapping[slotIndex] = dimensionId;}tabs.push({@@ -443,11 +543,14 @@ export function computeDefaultTabs(display: config.defaultDisplayType,dimensionMapping: mapping,projectionConfig: {},+ index: config.index,});}}- return tabs;+ tabs.sort((a, b) => (a.index ?? 0) - (b.index ?? 0));++ return tabs.map(({ index, ...tab }) => tab);}// ── Manual tab creation ──@@ -455,13 +558,16 @@ export function computeDefaultTabs(export interface TabInfo {type: MetricsViewerTabType;label: string;- dimensionMapping: Record<MetricSourceId, string>;+ dimensionMapping: Record<number, string>;}export function createTabFromTabInfo(tabInfo: TabInfo,): MetricsViewerTabState | null {const { type, label, dimensionMapping } = tabInfo;+ if (type === "scalar") {+ return createScalarTab();+ }const id = Object.values(dimensionMapping)[0];if (id == null) {return null;@@ -477,20 +583,45 @@ export function createTabFromTabInfo(};}+function createScalarTab(): MetricsViewerTabState | null {+ const config = getTabConfig("scalar");+ if (config.matchMode !== "aggregate") {+ return null;+ }+ return {+ id: config.fixedId,+ type: config.type,+ label: getScalarTabLabel(),+ display: config.defaultDisplayType,+ dimensionMapping: {},+ projectionConfig: {},+ };+}++export function getScalarTabLabel() {+ return t`Totals`;+}+// ── Tab dimension matching ──function findSubtypeFromExistingTab(tab: StoredMetricsViewerTab,getSubtype: (dimension: DimensionMetadata) => string | null,baseDefinitions?: Record<MetricSourceId, MetricDefinition | null>,+ slotIndexToSourceId?: Map<number, MetricSourceId>,): string | null {- if (!baseDefinitions) {+ if (!baseDefinitions || !slotIndexToSourceId) {return null;}- for (const [sourceId, dimensionName] of getObjectEntries(- tab.dimensionsBySource,+ for (const [key, dimensionName] of getObjectEntries(+ tab.dimensionBySlotIndex,)) {+ const slotIndex = Number(key);+ const sourceId = slotIndexToSourceId.get(slotIndex);+ if (!sourceId) {+ continue;+ }const def = baseDefinitions[sourceId];if (!def) {continue;@@ -505,21 +636,12 @@ function findSubtypeFromExistingTab(}function findBestSubtypeInDimensions(- dimensionsByType: Map<string, DimensionDescriptor>,+ dimensions: Map<string, DimensionDescriptor>,tabType: MetricsViewerTabType,getSubtype: (dimension: DimensionMetadata) => string | null,): string | null {const found = new Set<string>();-- for (const [, info] of dimensionsByType) {- if (info.dimensionType === tabType) {- const subtype = getSubtype(info.dimensionMetadata);- if (subtype) {- found.add(subtype);- }- }- }-+ collectSubtypes(dimensions, tabType, getSubtype, found);return pickBestGeoSubtype(found);}@@ -527,14 +649,20 @@ function findReferenceFromTab(tab: StoredMetricsViewerTab,type: MetricsViewerTabType,baseDefinitions?: Record<MetricSourceId, MetricDefinition | null>,+ slotIndexToSourceId?: Map<number, MetricSourceId>,): DimensionDescriptor | null {- if (!baseDefinitions) {+ if (!baseDefinitions || !slotIndexToSourceId) {return null;}- for (const [sourceId, dimensionName] of getObjectEntries(- tab.dimensionsBySource,+ for (const [key, dimensionName] of getObjectEntries(+ tab.dimensionBySlotIndex,)) {+ const entityIndex = Number(key);+ const sourceId = slotIndexToSourceId.get(entityIndex);+ if (!sourceId) {+ continue;+ }const def = baseDefinitions[sourceId];if (!def) {continue;@@ -548,52 +676,21 @@ function findReferenceFromTab(return null;}-function findDimensionBySourceMatch(- dimensionsByType: Map<string, DimensionDescriptor>,- reference: DimensionDescriptor,- getSubtype?: (dimension: DimensionMetadata) => string | null,-): string | null {- let nameMatch: DimensionDescriptor | null = null;-- for (const [, info] of dimensionsByType) {- if (info.dimensionType !== reference.dimensionType) {- continue;- }- if (- LibMetric.isSameSource(- info.dimensionMetadata,- reference.dimensionMetadata,- )- ) {- return info.id;- }- if (- !nameMatch &&- info.name.toLowerCase() === reference.name.toLowerCase()- ) {- if (- !getSubtype ||- getSubtype(info.dimensionMetadata) ===- getSubtype(reference.dimensionMetadata)- ) {- nameMatch = info;- }- }- }-- return nameMatch?.id ?? null;-}-function resolveSubtypeFallback(dimensionsByType: Map<string, DimensionDescriptor>,tabType: MetricsViewerTabType,getSubtype: (dimension: DimensionMetadata) => string | null,tab: StoredMetricsViewerTab,baseDefinitions?: Record<MetricSourceId, MetricDefinition | null>,+ slotIndexToSourceId?: Map<number, MetricSourceId>,): string | null {const targetSubtype =- findSubtypeFromExistingTab(tab, getSubtype, baseDefinitions) ??- findBestSubtypeInDimensions(dimensionsByType, tabType, getSubtype);+ findSubtypeFromExistingTab(+ tab,+ getSubtype,+ baseDefinitions,+ slotIndexToSourceId,+ ) ?? findBestSubtypeInDimensions(dimensionsByType, tabType, getSubtype);if (!targetSubtype) {return null;@@ -609,15 +706,21 @@ function findExactColumnMatch(dimensions: Map<string, DimensionDescriptor>,tab: StoredMetricsViewerTab,baseDefinitions?: Record<MetricSourceId, MetricDefinition | null>,+ slotIndexToSourceId?: Map<number, MetricSourceId>,): string | null {const exactMatch = dimensions.get(tab.id);if (exactMatch?.dimensionType === tab.type) {return exactMatch.id;}- const reference = findReferenceFromTab(tab, tab.type, baseDefinitions);+ const reference = findReferenceFromTab(+ tab,+ tab.type,+ baseDefinitions,+ slotIndexToSourceId,+ );if (reference) {- return findDimensionBySourceMatch(dimensions, reference);+ return findSourceMatch(dimensions, tab.type, reference)?.id ?? null;}return null;@@ -628,8 +731,14 @@ function findAggregateMatch(tab: StoredMetricsViewerTab,config: TabTypeDefinition,baseDefinitions?: Record<MetricSourceId, MetricDefinition | null>,+ slotIndexToSourceId?: Map<number, MetricSourceId>,): string | null {- const reference = findReferenceFromTab(tab, config.type, baseDefinitions);+ const reference = findReferenceFromTab(+ tab,+ config.type,+ baseDefinitions,+ slotIndexToSourceId,+ );const defaultMatch = findDimensionOfType(dimensions, config.type, true);if (defaultMatch) {@@ -637,13 +746,14 @@ function findAggregateMatch(}if (reference) {- const sourceMatch = findDimensionBySourceMatch(+ const sourceMatch = findSourceMatch(dimensions,+ config.type,reference,config.dimensionSubtype,);if (sourceMatch) {- return sourceMatch;+ return sourceMatch.id;}}@@ -654,6 +764,7 @@ function findAggregateMatch(config.dimensionSubtype,tab,baseDefinitions,+ slotIndexToSourceId,);if (subtypeMatch) {return subtypeMatch;@@ -667,13 +778,25 @@ export function findMatchingDimensionForTab(def: MetricDefinition,tab: StoredMetricsViewerTab,baseDefinitions?: Record<MetricSourceId, MetricDefinition | null>,+ slotIndexToSourceId?: Map<number, MetricSourceId>,): string | null {const dimensions = getDimensionsByType(def);- const config = TAB_TYPE_REGISTRY.find((config) => config.type === tab.type);+ const config = getTabConfig(tab.type);if (config?.matchMode !== "aggregate") {- return findExactColumnMatch(dimensions, tab, baseDefinitions);+ return findExactColumnMatch(+ dimensions,+ tab,+ baseDefinitions,+ slotIndexToSourceId,+ );}- return findAggregateMatch(dimensions, tab, config, baseDefinitions);+ return findAggregateMatch(+ dimensions,+ tab,+ config,+ baseDefinitions,+ slotIndexToSourceId,+ );}diff --git a/frontend/src/metabase/metrics-viewer/utils/url-serialization.ts b/frontend/src/metabase/metrics-viewer/utils/url-serialization.tsindex 8b25e1a0530..70e3c8a918b 100644--- a/frontend/src/metabase/metrics-viewer/utils/url-serialization.ts+++ b/frontend/src/metabase/metrics-viewer/utils/url-serialization.ts@@ -2,20 +2,47 @@ import { b64url_to_utf8, utf8_to_b64url } from "metabase/utils/encoding";import { getObjectEntries } from "metabase/utils/objects";import type { MetricDefinition } from "metabase-lib/metric";import * as LibMetric from "metabase-lib/metric";-import type { TemporalUnit, VisualizationSettings } from "metabase-types/api";+import type {+ MathOperator,+ TemporalUnit,+ VisualizationSettings,+} from "metabase-types/api";import type {+ ExpressionSubToken,+ MetricExpressionId,MetricSourceId,+ MetricsViewerDefinitionEntry,MetricsViewerDisplayType,+ MetricsViewerFormulaEntity,MetricsViewerPageState,MetricsViewerTabState,MetricsViewerTabType,} from "../types/viewer-state";+import { isExpressionEntry, isMetricEntry } from "../types/viewer-state";+import {+ applyProjection,+ buildBinnedBreakoutDefinition,+} from "../utils/definition-builder";+import {+ buildDimensionFilterClause,+ extractDefinitionFilters,+} from "../utils/dimension-filters";import { defineCompactSchema } from "./compact-schema";-import { getEntryBreakout } from "./definition-entries";+import {+ getEffectiveDefinitionEntry,+ getEffectiveTokenDefinitionEntry,+ getEntryBreakout,+} from "./definition-entries";import type { DimensionFilterValue } from "./dimension-filters";-import { extractDefinitionFilters } from "./dimension-filters";+import {+ findBinningStrategy,+ findDimensionById,+ findFilterDimensionById,+ findTemporalBucket,+} from "./dimension-lookup";+import { stampMetricCounts } from "./expression";function reviveFilter(filter: DimensionFilterValue): DimensionFilterValue {if (filter.type === "specific-date" || filter.type === "time") {@@ -36,8 +63,90 @@ function reviveFilter(filter: DimensionFilterValue): DimensionFilterValue {return filter;}+/**+ * When we deserialize an entity, we can't apply breakouts or filters until the definition has loaded.+ * So we store them and apply them lazily after the definition has loaded.+ */+export interface SerializedDefinitionInfo {+ breakout?: string;+ breakoutTemporalUnit?: TemporalUnit;+ breakoutBinning?: string;+ filters?: SerializedUrlFilter[];+}++export function applySerializedDefinitionInfo(+ definition: MetricDefinition,+ {+ breakout,+ breakoutTemporalUnit,+ breakoutBinning,+ filters,+ }: SerializedDefinitionInfo,+): MetricDefinition {+ let result = definition;++ if (breakout) {+ const dimension = findDimensionById(result, breakout);+ if (dimension) {+ const dimensionRef = LibMetric.dimensionReference(dimension);++ let modifiedRef: LibMetric.ProjectionClause | null = null;+ if (breakoutTemporalUnit) {+ const bucket = findTemporalBucket(+ result,+ dimension,+ breakoutTemporalUnit,+ );+ if (bucket) {+ modifiedRef = LibMetric.withTemporalBucket(dimensionRef, bucket);+ }+ } else if (breakoutBinning) {+ const strategy = findBinningStrategy(+ result,+ dimension,+ breakoutBinning,+ );+ if (strategy) {+ modifiedRef = LibMetric.withBinning(dimensionRef, strategy);+ }+ }++ result = modifiedRef+ ? applyProjection(result, modifiedRef)+ : buildBinnedBreakoutDefinition(result, dimensionRef);+ }+ }++ if (filters) {+ for (const filter of filters) {+ const dimension = findFilterDimensionById(result, filter.dimensionId);+ if (dimension) {+ const clause = buildDimensionFilterClause(dimension, filter.value);+ result = LibMetric.filter(result, clause);+ }+ }+ }++ return result;+}+// ── Serialized types (internal, URL-facing) ──+interface SerializedExpressionSubToken {+ type: "metric" | "constant" | "operator" | "open-paren" | "close-paren";+ sourceId?: string;+ op?: MathOperator;+ value?: number;+ filters?: SerializedUrlFilter[];+}++interface SerializedExpressionEntry {+ type: "expression";+ id: string;+ name: string;+ tokens: SerializedExpressionSubToken[];+}+interface SerializedUrlFilter {dimensionId: string;value: DimensionFilterValue;@@ -52,8 +161,10 @@ interface SerializedSource {filters?: SerializedUrlFilter[];}+type SerializedFormulaEntity = SerializedExpressionEntry | SerializedSource;+interface SerializedTabDef {- definitionId: MetricSourceId;+ slotIndex: number;dimensionId?: string;}@@ -74,11 +185,113 @@ interface SerializedTab {}export interface SerializedMetricsViewerPageState {- sources: SerializedSource[];+ formulaEntities: SerializedFormulaEntity[];tabs: SerializedTab[];selectedTabId: string | null;}+// ── Expression sub-token helpers ──++function serializeSubToken(+ token: ExpressionSubToken,+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>,+): SerializedExpressionSubToken {+ if (token.type === "metric") {+ const effectiveEntry = getEffectiveTokenDefinitionEntry(token, definitions);+ if (!effectiveEntry.definition) {+ return { type: "metric", sourceId: token.sourceId };+ }+ const serializedSource = definitionToSource(effectiveEntry.definition);+ if (!serializedSource) {+ return { type: "metric", sourceId: token.sourceId };+ }+ const annotatedSource = annotateSource(serializedSource, effectiveEntry);+ return {+ type: "metric",+ sourceId: token.sourceId,+ filters: annotatedSource.filters,+ };+ }+ if (token.type === "constant") {+ return { type: "constant", value: token.value };+ }+ if (token.type === "operator") {+ return { type: "operator", op: token.op };+ }+ return { type: token.type };+}++function deserializeSubToken(+ token: SerializedExpressionSubToken,+): ExpressionSubToken | null {+ if (token.type === "metric" && token.sourceId) {+ return {+ type: "metric",+ sourceId: token.sourceId as MetricSourceId,+ count: 0,+ serializedDefinitionInfo: token.filters+ ? {+ filters: token.filters,+ }+ : undefined,+ };+ }+ if (token.type === "constant" && token.value !== undefined) {+ return { type: "constant", value: token.value };+ }+ if (token.type === "operator" && token.op) {+ return { type: "operator", op: token.op };+ }+ if (token.type === "open-paren") {+ return { type: "open-paren" };+ }+ if (token.type === "close-paren") {+ return { type: "close-paren" };+ }+ return null;+}++export function deserializeFormulaEntities(+ serializedState: SerializedMetricsViewerPageState,+): MetricsViewerFormulaEntity[] {+ const entities: MetricsViewerFormulaEntity[] = [];++ for (const entity of serializedState.formulaEntities) {+ if (entity.type === "metric" || entity.type === "measure") {+ entities.push({+ id:+ entity.type === "metric"+ ? `metric:${entity.id}`+ : `measure:${entity.id}`,+ type: "metric" as const,+ definition: null,+ serializedDefinitionInfo:+ entity.breakout || entity.filters+ ? {+ breakout: entity.breakout,+ breakoutTemporalUnit: entity.breakoutTemporalUnit,+ breakoutBinning: entity.breakoutBinning,+ filters: entity.filters,+ }+ : undefined,+ });+ }+ if (entity.type === "expression") {+ entities.push({+ id: entity.id as MetricExpressionId,+ type: "expression" as const,+ name: entity.name,+ tokens: stampMetricCounts(+ entity.tokens+ .map(deserializeSubToken)+ .filter((t): t is ExpressionSubToken => t !== null),+ ),+ });+ }+ }+ return entities;+}+// ── Conversion functions ──function definitionToSource(def: MetricDefinition): SerializedSource | null {@@ -111,8 +324,8 @@ function tabToSerializedTab(tab: MetricsViewerTabState): SerializedTab {? { visualizationSettings: tab.visualizationSettings }: {}),definitions: getObjectEntries(tab.dimensionMapping).map(- ([sourceId, dimensionId]) => ({- definitionId: sourceId,+ ([key, dimensionId]) => ({+ slotIndex: Number(key),...(dimensionId != null ? { dimensionId } : {}),}),),@@ -129,9 +342,9 @@ function tabToSerializedTab(tab: MetricsViewerTabState): SerializedTab {export function deserializeTab(serializedTab: SerializedTab,): MetricsViewerTabState {- const dimensionMapping: Record<MetricSourceId, string | null> = {};+ const dimensionMapping: Record<number, string | null> = {};for (const serializedDefinition of serializedTab.definitions) {- dimensionMapping[serializedDefinition.definitionId] =+ dimensionMapping[serializedDefinition.slotIndex] =serializedDefinition.dimensionId ?? null;}return {@@ -151,71 +364,98 @@ export function deserializeTab(};}-export function stateToSerializedState(- state: MetricsViewerPageState,-): SerializedMetricsViewerPageState {- return {- sources: state.definitions.flatMap((entry) => {- if (!entry.definition) {- return [];- }- const source = definitionToSource(entry.definition);- if (!source) {- return [];- }- const breakoutProjection = getEntryBreakout(entry);- if (breakoutProjection) {- const rawDim = LibMetric.projectionDimension(+function annotateSource(+ source: SerializedSource,+ entry: MetricsViewerDefinitionEntry,+): SerializedSource {+ if (!entry.definition) {+ return source;+ }++ const breakoutProjection = getEntryBreakout(entry);+ if (breakoutProjection) {+ const rawDim = LibMetric.projectionDimension(+ entry.definition,+ breakoutProjection,+ );+ if (rawDim) {+ const dimInfo = LibMetric.dimensionValuesInfo(entry.definition, rawDim);+ source.breakout = dimInfo.id;++ if (LibMetric.temporalBucket(breakoutProjection)) {+ const buckets = LibMetric.availableTemporalBuckets(entry.definition,- breakoutProjection,+ rawDim,);- if (rawDim) {- const dimInfo = LibMetric.dimensionValuesInfo(- entry.definition,- rawDim,- );- source.breakout = dimInfo.id;-- if (LibMetric.temporalBucket(breakoutProjection)) {- const buckets = LibMetric.availableTemporalBuckets(- entry.definition,- rawDim,- );- for (const bucket of buckets) {- const info = LibMetric.displayInfo(entry.definition, bucket);- if (info.selected) {- source.breakoutTemporalUnit = info.shortName;- break;- }- }+ for (const bucket of buckets) {+ const info = LibMetric.displayInfo(entry.definition, bucket);+ if (info.selected) {+ source.breakoutTemporalUnit = info.shortName;+ break;}+ }+ }- if (LibMetric.binning(breakoutProjection)) {- const strategies = LibMetric.availableBinningStrategies(- entry.definition,- rawDim,- );- for (const strategy of strategies) {- const info = LibMetric.displayInfo(entry.definition, strategy);- if (info.selected) {- source.breakoutBinning = info.displayName;- break;- }- }+ if (LibMetric.binning(breakoutProjection)) {+ const strategies = LibMetric.availableBinningStrategies(+ entry.definition,+ rawDim,+ );+ for (const strategy of strategies) {+ const info = LibMetric.displayInfo(entry.definition, strategy);+ if (info.selected) {+ source.breakoutBinning = info.displayName;+ break;}}}+ }+ }++ const definitionFilters = extractDefinitionFilters(entry.definition);+ if (definitionFilters.length > 0) {+ source.filters = definitionFilters.map((filter) => ({+ dimensionId: filter.dimensionId,+ value: filter.value,+ }));+ }++ return source;+}- const definitionFilters = extractDefinitionFilters(entry.definition);- if (definitionFilters.length > 0) {- source.filters = definitionFilters.map((filter) => ({- dimensionId: filter.dimensionId,- value: filter.value,- }));+export function stateToSerializedState(+ state: MetricsViewerPageState,+): SerializedMetricsViewerPageState {+ const formulaEntities: SerializedFormulaEntity[] = [];++ for (const entity of state.formulaEntities) {+ if (isMetricEntry(entity)) {+ const effectiveEntry = getEffectiveDefinitionEntry(+ entity,+ state.definitions,+ );+ if (!effectiveEntry.definition) {+ continue;+ }+ const source = definitionToSource(effectiveEntry.definition);+ if (!source) {+ continue;}+ formulaEntities.push(annotateSource(source, effectiveEntry));+ } else if (isExpressionEntry(entity)) {+ formulaEntities.push({+ type: "expression",+ id: entity.id,+ name: entity.name,+ tokens: entity.tokens.map((token) =>+ serializeSubToken(token, state.definitions),+ ),+ });+ }+ }- return [source];- }),+ return {+ formulaEntities,tabs: state.tabs.map(tabToSerializedTab),selectedTabId: state.selectedTabId,};@@ -228,17 +468,28 @@ const sourceFilterSchema = defineCompactSchema<SerializedUrlFilter>({value: { key: "v" },});-const sourceSchema = defineCompactSchema<SerializedSource>({+const expressionSubTokenSchema =+ defineCompactSchema<SerializedExpressionSubToken>({+ type: "t",+ sourceId: { key: "s", optional: true },+ op: { key: "o", optional: true },+ value: { key: "v", optional: true },+ filters: { key: "F", schema: sourceFilterSchema, optional: true },+ });++const formulaEntitySchema = defineCompactSchema<SerializedFormulaEntity>({type: "t",id: "i",breakout: { key: "b", optional: true },breakoutTemporalUnit: { key: "u", optional: true },breakoutBinning: { key: "B", optional: true },filters: { key: "F", schema: sourceFilterSchema, optional: true },+ name: { key: "n", optional: true },+ tokens: { key: "T", schema: expressionSubTokenSchema, optional: true },});const tabDefSchema = defineCompactSchema<SerializedTabDef>({- definitionId: "i",+ slotIndex: "i",dimensionId: { key: "d", optional: true },});@@ -263,7 +514,7 @@ const tabSchema = defineCompactSchema<SerializedTab>({});const rootSchema = defineCompactSchema<SerializedMetricsViewerPageState>({- sources: { key: "s", schema: sourceSchema, default: [] },+ formulaEntities: { key: "f", schema: formulaEntitySchema, default: [] },tabs: { key: "t", schema: tabSchema, default: [] },selectedTabId: { key: "a", default: null },});@@ -271,7 +522,7 @@ const rootSchema = defineCompactSchema<SerializedMetricsViewerPageState>({// ── Encode / decode ──function emptyState(): SerializedMetricsViewerPageState {- return { sources: [], tabs: [], selectedTabId: null };+ return { formulaEntities: [], tabs: [], selectedTabId: null };}// After JSON.parse, Date values are ISO strings. Walk the decoded state and revive them.@@ -280,17 +531,35 @@ function reviveStateDates(): SerializedMetricsViewerPageState {return {...state,- sources: state.sources.map((source) =>- source.filters- ? {- ...source,- filters: source.filters.map((filter) => ({- ...filter,- value: reviveFilter(filter.value),- })),- }- : source,- ),+ formulaEntities: state.formulaEntities.map((entity) => {+ if ("filters" in entity && entity.filters) {+ return {+ ...entity,+ filters: entity.filters.map((filter) => ({+ ...filter,+ value: reviveFilter(filter.value),+ })),+ };+ }+ if ("tokens" in entity && entity.tokens) {+ return {+ ...entity,+ tokens: entity.tokens.map((token) => {+ if ("filters" in token && token.filters) {+ return {+ ...token,+ filters: token.filters.map((filter) => ({+ ...filter,+ value: reviveFilter(filter.value),+ })),+ };+ }+ return token;+ }),+ };+ }+ return entity;+ }),tabs: state.tabs.map((tab) =>tab.projectionConfig?.dimensionFilter? {diff --git a/frontend/src/metabase/metrics-viewer/utils/url-serialization.unit.spec.ts b/frontend/src/metabase/metrics-viewer/utils/url-serialization.unit.spec.tsindex 649c017ee4f..12deaec9b99 100644--- a/frontend/src/metabase/metrics-viewer/utils/url-serialization.unit.spec.ts+++ b/frontend/src/metabase/metrics-viewer/utils/url-serialization.unit.spec.ts@@ -2,6 +2,7 @@ import type { DimensionFilterValue } from "./dimension-filters";import {type SerializedMetricsViewerPageState,decodeState,+ deserializeFormulaEntities,encodeState,} from "./url-serialization";@@ -15,9 +16,9 @@ function encodeStateOrThrow(state: SerializedMetricsViewerPageState): string {describe("url-serialization", () => {describe("encodeState / decodeState round-trip", () => {- it("round-trips a state with sources and tabs", () => {+ it("round-trips a state with formula entities and tabs", () => {const state: SerializedMetricsViewerPageState = {- sources: [+ formulaEntities: [{ type: "metric", id: 1, breakout: "dim-1" },{ type: "measure", id: 42 },],@@ -27,9 +28,7 @@ describe("url-serialization", () => {type: "time",label: "By Month",display: "bar",- definitions: [- { definitionId: "metric:1", dimensionId: "created_at" },- ],+ definitions: [{ slotIndex: 0, dimensionId: "created_at" }],projectionConfig: {temporalUnit: "month",},@@ -43,9 +42,9 @@ describe("url-serialization", () => {expect(decoded).toEqual(state);});- it("round-trips a source with breakoutTemporalUnit", () => {+ it("round-trips a metric with breakoutTemporalUnit", () => {const state: SerializedMetricsViewerPageState = {- sources: [+ formulaEntities: [{type: "metric",id: 1,@@ -62,9 +61,9 @@ describe("url-serialization", () => {expect(decoded).toEqual(state);});- it("round-trips a source with breakoutBinning", () => {+ it("round-trips a metric with breakoutBinning", () => {const state: SerializedMetricsViewerPageState = {- sources: [+ formulaEntities: [{type: "metric",id: 2,@@ -81,9 +80,9 @@ describe("url-serialization", () => {expect(decoded).toEqual(state);});- it("round-trips a source with both breakoutTemporalUnit and breakoutBinning", () => {+ it("round-trips a metric with both breakoutTemporalUnit and breakoutBinning", () => {const state: SerializedMetricsViewerPageState = {- sources: [+ formulaEntities: [{type: "metric",id: 3,@@ -103,7 +102,7 @@ describe("url-serialization", () => {it("round-trips an empty state", () => {const state: SerializedMetricsViewerPageState = {- sources: [],+ formulaEntities: [],tabs: [],selectedTabId: null,};@@ -113,9 +112,9 @@ describe("url-serialization", () => {expect(decoded).toEqual(state);});- it("round-trips sources with filters", () => {+ it("round-trips metrics with filters", () => {const state: SerializedMetricsViewerPageState = {- sources: [+ formulaEntities: [{type: "metric",id: 5,@@ -140,12 +139,104 @@ describe("url-serialization", () => {const decoded = decodeState(hash);expect(decoded).toEqual(state);});++ it("round-trips expressions in formula entities", () => {+ const state: SerializedMetricsViewerPageState = {+ formulaEntities: [+ { type: "metric", id: 1 },+ { type: "metric", id: 2 },+ {+ type: "expression",+ id: "expression:Revenue + Costs",+ name: "Revenue + Costs",+ tokens: [+ { type: "metric", sourceId: "metric:1" },+ { type: "operator", op: "+" },+ { type: "metric", sourceId: "metric:2" },+ ],+ },+ ],+ tabs: [],+ selectedTabId: null,+ };++ const hash = encodeStateOrThrow(state);+ const decoded = decodeState(hash);+ expect(decoded).toEqual(state);+ });++ it("round-trips an expression with parentheses", () => {+ const state: SerializedMetricsViewerPageState = {+ formulaEntities: [+ { type: "metric", id: 1 },+ { type: "metric", id: 2 },+ { type: "metric", id: 3 },+ {+ type: "expression",+ id: "expression:(A + B) * C",+ name: "(A + B) * C",+ tokens: [+ { type: "open-paren" },+ { type: "metric", sourceId: "metric:1" },+ { type: "operator", op: "+" },+ { type: "metric", sourceId: "metric:2" },+ { type: "close-paren" },+ { type: "operator", op: "*" },+ { type: "metric", sourceId: "metric:3" },+ ],+ },+ ],+ tabs: [],+ selectedTabId: null,+ };++ const hash = encodeStateOrThrow(state);+ const decoded = decodeState(hash);+ expect(decoded).toEqual(state);+ });++ it("round-trips expression tokens with filters", () => {+ const state: SerializedMetricsViewerPageState = {+ formulaEntities: [+ {+ type: "expression",+ id: "expression:test",+ name: "test",+ tokens: [+ {+ type: "metric",+ sourceId: "metric:1",+ filters: [+ {+ dimensionId: "category",+ value: {+ type: "string",+ operator: "=",+ values: ["Gadget"],+ options: {},+ },+ },+ ],+ },+ { type: "operator", op: "+" },+ { type: "metric", sourceId: "metric:2" },+ ],+ },+ ],+ tabs: [],+ selectedTabId: null,+ };++ const hash = encodeStateOrThrow(state);+ const decoded = decodeState(hash);+ expect(decoded).toEqual(state);+ });});describe("decodeState with empty/invalid input", () => {it("returns empty state for empty string", () => {expect(decodeState("")).toEqual({- sources: [],+ formulaEntities: [],tabs: [],selectedTabId: null,});@@ -153,7 +244,7 @@ describe("url-serialization", () => {it("returns empty state for invalid base64", () => {expect(decodeState("!!!not-valid-base64!!!")).toEqual({- sources: [],+ formulaEntities: [],tabs: [],selectedTabId: null,});@@ -162,7 +253,7 @@ describe("url-serialization", () => {it("returns empty state for valid base64 but invalid JSON", () => {const hash = btoa("not json");expect(decodeState(hash)).toEqual({- sources: [],+ formulaEntities: [],tabs: [],selectedTabId: null,});@@ -178,7 +269,7 @@ describe("url-serialization", () => {describe("Unicode round-trip", () => {it("survives non-ASCII metric labels in tabs", () => {const state: SerializedMetricsViewerPageState = {- sources: [{ type: "metric", id: 1 }],+ formulaEntities: [{ type: "metric", id: 1 }],tabs: [{id: "tab-1",@@ -198,7 +289,7 @@ describe("url-serialization", () => {it("survives CJK characters", () => {const state: SerializedMetricsViewerPageState = {- sources: [{ type: "metric", id: 1 }],+ formulaEntities: [{ type: "metric", id: 1 }],tabs: [{id: "tab-1",@@ -218,7 +309,7 @@ describe("url-serialization", () => {it("survives emoji characters", () => {const state: SerializedMetricsViewerPageState = {- sources: [{ type: "metric", id: 1 }],+ formulaEntities: [{ type: "metric", id: 1 }],tabs: [{id: "tab-1",@@ -240,7 +331,7 @@ describe("url-serialization", () => {describe("Date filter revival through encode/decode", () => {function roundTripFilter(filter: DimensionFilterValue) {const state: SerializedMetricsViewerPageState = {- sources: [+ formulaEntities: [{type: "metric",id: 1,@@ -250,8 +341,43 @@ describe("url-serialization", () => {tabs: [],selectedTabId: null,};- return decodeState(encodeStateOrThrow(state)).sources[0].filters![0]- .value;+ const decoded = decodeState(encodeStateOrThrow(state));+ const entity = decoded.formulaEntities[0];+ if (entity.type === "expression") {+ throw new Error("Expected metric entity");+ }+ return entity.filters![0].value;+ }++ function roundTripTokenFilter(filter: DimensionFilterValue) {+ const state: SerializedMetricsViewerPageState = {+ formulaEntities: [+ {+ type: "expression",+ id: "expression:test",+ name: "test",+ tokens: [+ {+ type: "metric",+ sourceId: "metric:1",+ filters: [{ dimensionId: "created_at", value: filter }],+ },+ ],+ },+ ],+ tabs: [],+ selectedTabId: null,+ };+ const decoded = decodeState(encodeStateOrThrow(state));+ const entity = decoded.formulaEntities[0];+ if (entity.type !== "expression") {+ throw new Error("Expected expression entity");+ }+ const token = entity.tokens[0];+ if (!("filters" in token) || !token.filters) {+ throw new Error("Expected token with filters");+ }+ return token.filters[0].value;}it("revives specific-date Date values after encode/decode", () => {@@ -301,6 +427,30 @@ describe("url-serialization", () => {expect(roundTripFilter(filter)).toEqual(filter);});++ it("revives specific-date Date values on expression token filters", () => {+ const filter: DimensionFilterValue = {+ type: "specific-date",+ operator: "between",+ values: [+ new Date("2024-01-01T00:00:00Z"),+ new Date("2024-12-31T23:59:59Z"),+ ],+ hasTime: false,+ };++ expect(roundTripTokenFilter(filter)).toEqual(filter);+ });++ it("revives time Date values on expression token filters", () => {+ const filter: DimensionFilterValue = {+ type: "time",+ operator: ">",+ values: [new Date("2024-06-15T10:30:00Z")],+ };++ expect(roundTripTokenFilter(filter)).toEqual(filter);+ });});describe("BigInt filter revival through encode/decode", () => {@@ -311,7 +461,7 @@ describe("url-serialization", () => {values: [BigInt("9007199254740993"), BigInt("-9007199254740993")],};const state: SerializedMetricsViewerPageState = {- sources: [+ formulaEntities: [{type: "metric",id: 1,@@ -323,7 +473,183 @@ describe("url-serialization", () => {};const decoded = decodeState(encodeStateOrThrow(state));- expect(decoded.sources[0].filters![0].value).toEqual(filter);+ const entity = decoded.formulaEntities[0];+ if (entity.type === "expression") {+ throw new Error("Expected metric entity");+ }+ expect(entity.filters![0].value).toEqual(filter);+ });+ });++ describe("expression with duplicate metrics and different breakouts", () => {+ it("round-trips an expression where the same metric appears twice with different dimension mappings", () => {+ const state: SerializedMetricsViewerPageState = {+ formulaEntities: [+ {+ type: "expression",+ id: "expression:Revenue + Revenue",+ name: "Revenue + Revenue",+ tokens: [+ { type: "metric", sourceId: "metric:1" },+ { type: "operator", op: "+" },+ { type: "metric", sourceId: "metric:1" },+ ],+ },+ ],+ tabs: [+ {+ id: "tab-time",+ type: "time",+ label: "By Time",+ display: "line",+ definitions: [+ { slotIndex: 0, dimensionId: "created_at" },+ { slotIndex: 1, dimensionId: "updated_at" },+ ],+ },+ ],+ selectedTabId: "tab-time",+ };++ const hash = encodeStateOrThrow(state);+ const decoded = decodeState(hash);+ expect(decoded).toEqual(state);+ });++ it("round-trips an expression where the same metric appears twice with different filters on each token", () => {+ const state: SerializedMetricsViewerPageState = {+ formulaEntities: [+ {+ type: "expression",+ id: "expression:Revenue filtered",+ name: "Revenue filtered",+ tokens: [+ {+ type: "metric",+ sourceId: "metric:1",+ filters: [+ {+ dimensionId: "category",+ value: {+ type: "string",+ operator: "=",+ values: ["Gadget"],+ options: {},+ },+ },+ ],+ },+ { type: "operator", op: "-" },+ {+ type: "metric",+ sourceId: "metric:1",+ filters: [+ {+ dimensionId: "category",+ value: {+ type: "string",+ operator: "=",+ values: ["Widget"],+ options: {},+ },+ },+ ],+ },+ ],+ },+ ],+ tabs: [],+ selectedTabId: null,+ };++ const hash = encodeStateOrThrow(state);+ const decoded = decodeState(hash);+ expect(decoded).toEqual(state);+ });++ it("preserves per-slot dimension mappings when same metric has different breakouts across multiple tabs", () => {+ const state: SerializedMetricsViewerPageState = {+ formulaEntities: [+ {+ type: "expression",+ id: "expression:A + A",+ name: "A + A",+ tokens: [+ { type: "metric", sourceId: "metric:5" },+ { type: "operator", op: "+" },+ { type: "metric", sourceId: "metric:5" },+ ],+ },+ ],+ tabs: [+ {+ id: "tab-time",+ type: "time",+ label: "By Time",+ display: "line",+ definitions: [+ { slotIndex: 0, dimensionId: "created_at" },+ { slotIndex: 1, dimensionId: "shipped_at" },+ ],+ },+ {+ id: "tab-cat",+ type: "category",+ label: "By Category",+ display: "bar",+ definitions: [+ { slotIndex: 0, dimensionId: "product_category" },+ { slotIndex: 1, dimensionId: "user_state" },+ ],+ },+ ],+ selectedTabId: "tab-cat",+ };++ const hash = encodeStateOrThrow(state);+ const decoded = decodeState(hash);+ expect(decoded).toEqual(state);+ });++ it("round-trips a mix of standalone metric and expression with a duplicate of that metric", () => {+ const state: SerializedMetricsViewerPageState = {+ formulaEntities: [+ {+ type: "metric",+ id: 1,+ breakout: "created_at",+ breakoutTemporalUnit: "month",+ },+ {+ type: "expression",+ id: "expression:A + A",+ name: "A + A",+ tokens: [+ { type: "metric", sourceId: "metric:1" },+ { type: "operator", op: "+" },+ { type: "metric", sourceId: "metric:1" },+ ],+ },+ ],+ tabs: [+ {+ id: "tab-time",+ type: "time",+ label: "By Month",+ display: "line",+ definitions: [+ { slotIndex: 0, dimensionId: "created_at" },+ { slotIndex: 1, dimensionId: "created_at" },+ { slotIndex: 2, dimensionId: "updated_at" },+ ],+ },+ ],+ selectedTabId: "tab-time",+ };++ const hash = encodeStateOrThrow(state);+ const decoded = decodeState(hash);+ expect(decoded).toEqual(state);});});@@ -332,8 +658,312 @@ describe("url-serialization", () => {const first = decodeState("");const second = decodeState("");expect(first).not.toBe(second);- expect(first.sources).not.toBe(second.sources);+ expect(first.formulaEntities).not.toBe(second.formulaEntities);expect(first.tabs).not.toBe(second.tabs);});});++ describe("deserializeFormulaEntities", () => {+ function emptyState(+ overrides: Partial<SerializedMetricsViewerPageState> = {},+ ): SerializedMetricsViewerPageState {+ return {+ formulaEntities: [],+ tabs: [],+ selectedTabId: null,+ ...overrides,+ };+ }++ it("returns empty array for empty state", () => {+ expect(deserializeFormulaEntities(emptyState())).toEqual([]);+ });++ it("returns metric entities for metric/measure formula entities", () => {+ const result = deserializeFormulaEntities(+ emptyState({+ formulaEntities: [+ { type: "metric", id: 1 },+ { type: "measure", id: 42 },+ ],+ }),+ );+ expect(result).toEqual([+ { id: "metric:1", type: "metric", definition: null },+ { id: "measure:42", type: "metric", definition: null },+ ]);+ });++ it("deserializes expression entries with metric tokens", () => {+ const result = deserializeFormulaEntities(+ emptyState({+ formulaEntities: [+ { type: "metric", id: 1 },+ { type: "metric", id: 2 },+ {+ type: "expression",+ id: "expression:test",+ name: "test",+ tokens: [+ { type: "metric", sourceId: "metric:1" },+ { type: "operator", op: "+" },+ { type: "metric", sourceId: "metric:2" },+ ],+ },+ ],+ }),+ );+ expect(result).toEqual([+ { id: "metric:1", type: "metric", definition: null },+ { id: "metric:2", type: "metric", definition: null },+ {+ id: "expression:test",+ type: "expression",+ name: "test",+ tokens: [+ { type: "metric", sourceId: "metric:1", count: 1 },+ { type: "operator", op: "+" },+ { type: "metric", sourceId: "metric:2", count: 1 },+ ],+ },+ ]);+ });++ it("deserializes parentheses", () => {+ const result = deserializeFormulaEntities(+ emptyState({+ formulaEntities: [+ {+ type: "expression",+ id: "expression:test",+ name: "test",+ tokens: [{ type: "open-paren" }, { type: "close-paren" }],+ },+ ],+ }),+ );+ const expressions = result.filter((e) => e.type === "expression");+ expect(expressions).toHaveLength(1);+ expect(expressions[0]).toMatchObject({+ tokens: [{ type: "open-paren" }, { type: "close-paren" }],+ });+ });++ it("skips metric tokens with missing sourceId", () => {+ const result = deserializeFormulaEntities(+ emptyState({+ formulaEntities: [+ {+ type: "expression",+ id: "expression:test",+ name: "test",+ tokens: [{ type: "metric" } as any],+ },+ ],+ }),+ );+ const expressions = result.filter((e) => e.type === "expression");+ expect(expressions[0]).toMatchObject({ tokens: [] });+ });++ it("skips operator tokens with missing op", () => {+ const result = deserializeFormulaEntities(+ emptyState({+ formulaEntities: [+ {+ type: "expression",+ id: "expression:test",+ name: "test",+ tokens: [{ type: "operator" } as any],+ },+ ],+ }),+ );+ const expressions = result.filter((e) => e.type === "expression");+ expect(expressions[0]).toMatchObject({ tokens: [] });+ });++ it("preserves formula entity order with expression before metric", () => {+ const result = deserializeFormulaEntities(+ emptyState({+ formulaEntities: [+ {+ type: "expression",+ id: "expression:Total",+ name: "Total",+ tokens: [+ { type: "metric", sourceId: "metric:1" },+ { type: "operator", op: "+" },+ { type: "constant", value: 10 },+ ],+ },+ { type: "metric", id: 1 },+ ],+ }),+ );+ expect(result).toEqual([+ {+ id: "expression:Total",+ type: "expression",+ name: "Total",+ tokens: [+ { type: "metric", sourceId: "metric:1", count: 1 },+ { type: "operator", op: "+" },+ { type: "constant", value: 10 },+ ],+ },+ { id: "metric:1", type: "metric", definition: null },+ ]);+ });++ it("preserves formula entity order with metric before expression", () => {+ const result = deserializeFormulaEntities(+ emptyState({+ formulaEntities: [+ { type: "metric", id: 1 },+ {+ type: "expression",+ id: "expression:Total",+ name: "Total",+ tokens: [+ { type: "metric", sourceId: "metric:1" },+ { type: "operator", op: "*" },+ { type: "constant", value: 2 },+ ],+ },+ ],+ }),+ );+ expect(result).toEqual([+ { id: "metric:1", type: "metric", definition: null },+ {+ id: "expression:Total",+ type: "expression",+ name: "Total",+ tokens: [+ { type: "metric", sourceId: "metric:1", count: 1 },+ { type: "operator", op: "*" },+ { type: "constant", value: 2 },+ ],+ },+ ]);+ });++ it("populates serializedDefinitionInfo for metrics with breakout", () => {+ const result = deserializeFormulaEntities(+ emptyState({+ formulaEntities: [+ {+ type: "metric",+ id: 1,+ breakout: "created_at",+ breakoutTemporalUnit: "month",+ },+ ],+ }),+ );+ expect(result).toEqual([+ {+ id: "metric:1",+ type: "metric",+ definition: null,+ serializedDefinitionInfo: {+ breakout: "created_at",+ breakoutTemporalUnit: "month",+ },+ },+ ]);+ });++ it("populates serializedDefinitionInfo for metrics with filters", () => {+ const filters = [+ {+ dimensionId: "category",+ value: {+ type: "string",+ operator: "=",+ values: ["Gadget"],+ options: {},+ },+ },+ ];+ const result = deserializeFormulaEntities(+ emptyState({+ formulaEntities: [+ {+ type: "metric",+ id: 5,+ filters: filters as any,+ },+ ],+ }),+ );+ expect(result).toEqual([+ {+ id: "metric:5",+ type: "metric",+ definition: null,+ serializedDefinitionInfo: {+ filters,+ },+ },+ ]);+ });++ it("populates serializedDefinitionInfo on expression tokens with filters", () => {+ const tokenFilters = [+ {+ dimensionId: "category",+ value: {+ type: "string",+ operator: "=",+ values: ["Widget"],+ options: {},+ },+ },+ ];+ const result = deserializeFormulaEntities(+ emptyState({+ formulaEntities: [+ {+ type: "expression",+ id: "expression:test",+ name: "test",+ tokens: [+ {+ type: "metric",+ sourceId: "metric:1",+ filters: tokenFilters as any,+ },+ ],+ },+ ],+ }),+ );+ const expression = result[0];+ if (expression.type !== "expression") {+ throw new Error("Expected expression entity");+ }+ const metricToken = expression.tokens[0];+ if (metricToken.type !== "metric") {+ throw new Error("Expected metric token");+ }+ expect(metricToken.serializedDefinitionInfo).toEqual({+ filters: tokenFilters,+ });+ });++ it("omits serializedDefinitionInfo for metrics without breakout or filters", () => {+ const result = deserializeFormulaEntities(+ emptyState({+ formulaEntities: [{ type: "metric", id: 1 }],+ }),+ );+ expect(result[0]).toEqual({+ id: "metric:1",+ type: "metric",+ definition: null,+ });+ });+ });});diff --git a/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/FilterDimensionPicker.module.css b/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/FilterDimensionPicker.module.cssdeleted file mode 100644index 3bd7a2442fe..00000000000--- a/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/FilterDimensionPicker.module.css+++ /dev/null@@ -1,13 +0,0 @@-.dimensionList {- max-width: 100%;- color: var(--mb-color-brand);-}--.metricListItem {- cursor: pointer;- border-radius: var(--mantine-radius-sm);-- &:hover {- background-color: var(--mb-color-background-hover);- }-}diff --git a/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/FilterDimensionPicker.tsx b/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/FilterDimensionPicker.tsxdeleted file mode 100644index 5082da99cf6..00000000000--- a/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/FilterDimensionPicker.tsx+++ /dev/null@@ -1,132 +0,0 @@-import { useCallback, useMemo, useState } from "react";-import { t } from "ttag";--import { AccordionList } from "metabase/common/components/AccordionList";-import { getDimensionIcon } from "metabase/metrics/utils/dimensions";-import {- Box,- Flex,- Icon,- PopoverBackButton,- Text,- UnstyledButton,-} from "metabase/ui";-import type * as LibMetric from "metabase-lib/metric";--import { FILTER_PICKER_WIDTH } from "../constants";--import S from "./FilterDimensionPicker.module.css";-import type { DimensionListItem, DimensionSection } from "./types";-import { getMetricGroups } from "./utils";--interface FilterDimensionPickerProps {- definitions: LibMetric.MetricDefinition[];- onSelect: (- definition: LibMetric.MetricDefinition,- definitionIndex: number,- dimension: LibMetric.DimensionMetadata,- ) => void;-}--export function FilterDimensionPicker({- definitions,- onSelect,-}: FilterDimensionPickerProps) {- const [selectedGroupIndex, setSelectedGroupIndex] = useState<number | null>(- null,- );-- const metricGroups = useMemo(- () => getMetricGroups(definitions),- [definitions],- );-- const handleSelect = useCallback(- (item: DimensionListItem) => {- onSelect(item.definition, item.definitionIndex, item.dimension);- },- [onSelect],- );-- const renderItemIcon = useCallback((item: DimensionListItem) => {- const icon = getDimensionIcon(item.dimension);- return <Icon name={icon} size={18} />;- }, []);-- if (definitions.length === 0) {- return null;- }-- if (metricGroups.length === 1) {- const group = metricGroups[0];- return (- <AccordionList<DimensionListItem, DimensionSection>- className={S.dimensionList}- sections={group.sections}- onChange={handleSelect}- renderItemName={(item) => item.name}- renderItemDescription={() => undefined}- renderItemIcon={renderItemIcon}- width={FILTER_PICKER_WIDTH}- maxHeight={Infinity}- itemTestId="dimension-list-item"- alwaysExpanded- />- );- }-- if (selectedGroupIndex != null) {- const group = metricGroups[selectedGroupIndex];- return (- <Box>- <Box px="md" py="sm">- <PopoverBackButton onClick={() => setSelectedGroupIndex(null)}>- {group.metricName}- </PopoverBackButton>- </Box>- <AccordionList<DimensionListItem, DimensionSection>- className={S.dimensionList}- sections={group.sections}- onChange={handleSelect}- renderItemName={(item) => item.name}- renderItemDescription={() => undefined}- renderItemIcon={renderItemIcon}- width={FILTER_PICKER_WIDTH}- maxHeight={Infinity}- itemTestId="dimension-list-item"- alwaysExpanded- />- </Box>- );- }-- return (- <Box>- <Box px="md" pt="md" pb="sm">- <Text fw="bold" fz="lg" c="text-primary">- {t`Pick a metric to filter`}- </Text>- </Box>- {metricGroups.map((group, i) => (- <UnstyledButton- key={i}- className={S.metricListItem}- w="100%"- px="md"- py="sm"- onClick={() => setSelectedGroupIndex(i)}- >- <Flex align="center" justify="space-between">- <Flex align="center" gap="sm">- <Icon name={group.icon} c="brand" />- <Text fw="bold" fz="md">- {group.metricName}- </Text>- </Flex>- <Icon name="chevronright" c="text-tertiary" />- </Flex>- </UnstyledButton>- ))}- </Box>- );-}diff --git a/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/index.ts b/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/index.tsdeleted file mode 100644index 1c0f1ecda64..00000000000--- a/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/index.ts+++ /dev/null@@ -1 +0,0 @@-export * from "./FilterDimensionPicker";diff --git a/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/types.ts b/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/types.tsindex b2dbd5dbdca..b1eded004de 100644--- a/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/types.ts+++ b/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/types.ts@@ -11,7 +11,10 @@ export type DimensionListItem = {export type DimensionSection = BaseSection<DimensionListItem>;export type MetricGroup = {+ id: number;metricName: string;- icon: "metric" | "ruler";+ metricCount?: number;+ icon?: "metric" | "ruler";+ colors: string[] | undefined;sections: DimensionSection[];};diff --git a/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/utils.ts b/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/utils.tsindex 800402f9591..e97877737c6 100644--- a/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/utils.ts+++ b/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/utils.ts@@ -1,13 +1,19 @@-import { t } from "ttag";-+import type { SourceColorMap } from "metabase/metrics-viewer/types/viewer-state";+import type { DefinitionSource } from "metabase/metrics-viewer/utils/definition-sources";+import {+ getDefinitionSourceIcon,+ getDefinitionSourceName,+} from "metabase/metrics-viewer/utils/definition-sources";import * as LibMetric from "metabase-lib/metric";import type { DimensionListItem, DimensionSection, MetricGroup } from "./types";export function getMetricGroups(- definitions: LibMetric.MetricDefinition[],+ definitionSources: DefinitionSource[],+ metricColors: SourceColorMap,): MetricGroup[] {- return definitions.map((definition, definitionIndex) => {+ return definitionSources.map((definitionSource, definitionIndex) => {+ const definition = definitionSource.definition;const dimensions = LibMetric.filterableDimensions(definition);const byGroupId = new Map<@@ -45,25 +51,12 @@ export function getMetricGroups(}return {- metricName: getSectionName(definition),- icon: getSectionIcon(definition),+ id: definitionSource.index,+ metricName: getDefinitionSourceName(definitionSource),+ metricCount: definitionSource.token?.count,+ icon: getDefinitionSourceIcon(definitionSource),+ colors: metricColors[definitionSource.entityIndex],sections,};});}--export function getSectionName(definition: LibMetric.MetricDefinition): string {- const metric = LibMetric.sourceMetricOrMeasureMetadata(definition);- if (metric) {- const metricInfo = LibMetric.displayInfo(definition, metric);- return metricInfo.displayName;- }- return t`Unknown`;-}--export function getSectionIcon(- definition: LibMetric.MetricDefinition,-): "metric" | "ruler" {- const metricId = LibMetric.sourceMetricId(definition);- return metricId != null ? "metric" : "ruler";-}diff --git a/frontend/src/metabase/metrics/components/FilterPicker/FilterPicker.tsx b/frontend/src/metabase/metrics/components/FilterPicker/FilterPicker.tsxdeleted file mode 100644index ee60116010c..00000000000--- a/frontend/src/metabase/metrics/components/FilterPicker/FilterPicker.tsx+++ /dev/null@@ -1,81 +0,0 @@-import { type Ref, forwardRef, useState } from "react";-import { t } from "ttag";--import { Button, Icon } from "metabase/ui";-import type * as LibMetric from "metabase-lib/metric";--import { FilterDimensionPicker } from "./FilterDimensionPicker";-import { FilterPickerBody } from "./FilterPickerBody";--type FilterPickerProps = {- definitions: LibMetric.MetricDefinition[];- onSelect: (- definition: LibMetric.MetricDefinition,- definitionIndex: number,- filter: LibMetric.FilterClause,- ) => void;-};--export function FilterPicker({ definitions, onSelect }: FilterPickerProps) {- const [definition, setDefinition] =- useState<LibMetric.MetricDefinition | null>(null);- const [definitionIndex, setDefinitionIndex] = useState<number | null>(null);- const [dimension, setDimension] =- useState<LibMetric.DimensionMetadata | null>(null);-- const handleDimensionSelect = (- definition: LibMetric.MetricDefinition,- definitionIndex: number,- dimension: LibMetric.DimensionMetadata,- ) => {- setDefinition(definition);- setDefinitionIndex(definitionIndex);- setDimension(dimension);- };-- const handleFilterSelect = (filter: LibMetric.FilterClause) => {- if (definition == null || definitionIndex == null) {- return;- }- onSelect(definition, definitionIndex, filter);- };-- const handleBack = () => {- setDefinition(null);- setDimension(null);- };-- if (!definition || !dimension) {- return (- <FilterDimensionPicker- definitions={definitions}- onSelect={handleDimensionSelect}- />- );- }-- return (- <FilterPickerBody- definition={definition}- dimension={dimension}- isNew- onSelect={handleFilterSelect}- onBack={handleBack}- />- );-}--type FilterPickerButtonProps = {- onClick?: () => void;-};--export const FilterPickerButton = forwardRef(function FilterPickerButton(- { onClick }: FilterPickerButtonProps,- ref: Ref<HTMLButtonElement>,-) {- return (- <Button ref={ref} leftSection={<Icon name="filter" />} onClick={onClick}>- {t`Filter`}- </Button>- );-});diff --git a/frontend/src/metabase/metrics/components/FilterPicker/index.ts b/frontend/src/metabase/metrics/components/FilterPicker/index.tsdeleted file mode 100644index 24e7622d588..00000000000--- a/frontend/src/metabase/metrics/components/FilterPicker/index.ts+++ /dev/null@@ -1 +0,0 @@-export * from "./FilterPicker";diff --git a/frontend/src/metabase/utils/objects.ts b/frontend/src/metabase/utils/objects.tsindex 4e2a2f94efc..1c464d6b314 100644--- a/frontend/src/metabase/utils/objects.ts+++ b/frontend/src/metabase/utils/objects.ts@@ -10,6 +10,10 @@ export const getObjectKeys = <K extends string>(return Object.keys(obj) as K[];};+export const getObjectValues = <V>(obj: Record<string, V>): V[] => {+ return Object.values(obj) as V[];+};+export const objectFromEntries = <K extends string, V>(entries: readonly (readonly [K, V])[],): Record<K, V> => {diff --git a/frontend/src/metabase/utils/urls/metrics.ts b/frontend/src/metabase/utils/urls/metrics.tsindex 35059f1520a..2440b3785c0 100644--- a/frontend/src/metabase/utils/urls/metrics.ts+++ b/frontend/src/metabase/utils/urls/metrics.ts@@ -1,8 +1,5 @@import type { DimensionType } from "metabase/metrics/common/utils/dimension-types";-import type {- MetricSourceId,- MetricsViewerDisplayType,-} from "metabase/metrics-viewer/types/viewer-state";+import type { MetricsViewerDisplayType } from "metabase/metrics-viewer/types/viewer-state";import {type SerializedMetricsViewerPageState,encodeState,@@ -40,16 +37,15 @@ export function exploreMetricDimension({displayType,label,}: ExploreMetricDimensionOptions): string {- const sourceId: MetricSourceId = `metric:${metricId}`;const state: SerializedMetricsViewerPageState = {- sources: [{ type: "metric", id: metricId }],+ formulaEntities: [{ type: "metric", id: metricId }],tabs: [{id: dimensionId,type: dimensionType,label: label ?? null,display: displayType,- definitions: [{ definitionId: sourceId, dimensionId }],+ definitions: [{ slotIndex: 0, dimensionId }],},],selectedTabId: dimensionId,diff --git a/frontend/src/metabase/visualizations/components/ScalarValue/ScalarValue.styled.tsx b/frontend/src/metabase/visualizations/components/ScalarValue/ScalarValue.styled.tsxindex 8605983889e..2e8c2b87fe0 100644--- a/frontend/src/metabase/visualizations/components/ScalarValue/ScalarValue.styled.tsx+++ b/frontend/src/metabase/visualizations/components/ScalarValue/ScalarValue.styled.tsx@@ -16,6 +16,7 @@ export const ScalarRoot = styled.div`interface ScalarValueWrapperProps {fontSize?: string | number;lineHeight?: string;+ disableHover?: boolean;}export const ScalarValueWrapper = styled.h1<ScalarValueWrapperProps>`@@ -26,6 +27,7 @@ export const ScalarValueWrapper = styled.h1<ScalarValueWrapperProps>`color: ${({ color }) => color};&:hover {- color: var(--mb-color-brand);+ color: ${({ disableHover }) =>+ disableHover ? undefined : "var(--mb-color-brand)"};}`;diff --git a/frontend/src/metabase/visualizations/components/ScalarValue/ScalarValue.tsx b/frontend/src/metabase/visualizations/components/ScalarValue/ScalarValue.tsxindex ed94af39afd..6bb484b6da6 100644--- a/frontend/src/metabase/visualizations/components/ScalarValue/ScalarValue.tsx+++ b/frontend/src/metabase/visualizations/components/ScalarValue/ScalarValue.tsx@@ -25,6 +25,7 @@ interface ScalarValueProps {totalNumGridCols?: number;fontFamily: string;color?: string;+ disableHover?: boolean;}export const ScalarValue = ({@@ -35,6 +36,7 @@ export const ScalarValue = ({totalNumGridCols,fontFamily,color = "inherit",+ disableHover,}: ScalarValueProps) => {const {other: { number: numberTheme },@@ -75,6 +77,7 @@ export const ScalarValue = ({lineHeight={numberTheme?.value?.lineHeight}data-testid="scalar-value"color={color}+ disableHover={disableHover}>{value ?? t`null`}</ScalarValueWrapper>diff --git a/frontend/src/metabase/visualizations/visualizations/CartesianChart/use-chart-events.ts b/frontend/src/metabase/visualizations/visualizations/CartesianChart/use-chart-events.tsindex 4065c0e0783..eb077fa54b4 100644--- a/frontend/src/metabase/visualizations/visualizations/CartesianChart/use-chart-events.ts+++ b/frontend/src/metabase/visualizations/visualizations/CartesianChart/use-chart-events.ts@@ -200,6 +200,7 @@ export const useChartEvents = (if (!visualizationIsClickable(clickData)) {onOpenQuestion(clickData?.cardId);+ return;}onVisualizationClick?.(clickData);diff --git a/frontend/src/metabase/visualizations/visualizations/Scalar/Scalar.tsx b/frontend/src/metabase/visualizations/visualizations/Scalar/Scalar.tsxindex 459f5eced25..cb42ab550fe 100644--- a/frontend/src/metabase/visualizations/visualizations/Scalar/Scalar.tsx+++ b/frontend/src/metabase/visualizations/visualizations/Scalar/Scalar.tsx@@ -87,6 +87,11 @@ export class Scalar extends Component<},]) => cols.length < 2,}),+ // used by metrics viewer to set the color, overrides "scalar.segments"+ "scalar.color": {+ hidden: true,+ getDefault: () => undefined,+ },"scalar.segments": {get section() {return t`Conditional colors`;@@ -205,8 +210,9 @@ export class Scalar extends Component<segmentIsValid(segment, { allowOpenEnded: true }),);- const color = getColor(value, segments);- const tooltipContent = getTooltipContent(segments);+ const explicitColor = settings["scalar.color"];+ const color = explicitColor ?? getColor(value, segments);+ const tooltipContent = explicitColor ? null : getTooltipContent(segments);const { displayValue, fullScalarValue } = compactifyValue(value,@@ -259,6 +265,7 @@ export class Scalar extends Component<><ScalarValuecolor={color}+ disableHover={!!explicitColor}fontFamily={fontFamily}gridSize={gridSize}height={Math.max(height - PADDING * 2, 0)}diff --git a/src/metabase/lib_metric/ast/build.cljc b/src/metabase/lib_metric/ast/build.cljcindex fcdfa3b7b4d..d046ca5e934 100644--- a/src/metabase/lib_metric/ast/build.cljc+++ b/src/metabase/lib_metric/ast/build.cljc@@ -340,6 +340,13 @@(= 3 (count expression))(#{:metric :measure} (first expression))))+(defn arithmetic-expression?+ "Returns true if the expression is an arithmetic node [op opts expr expr ...]."+ [expression]+ (and (sequential? expression)+ (>= (count expression) 4)+ (operators/arithmetic? (first expression))))+(defn expression-leaf-type"Returns :metric or :measure from an expression leaf."[expression]@@ -358,27 +365,15 @@(when (expression-leaf? expression)(get (second expression) :lib/uuid)))-(defn from-definition- "Create complete AST from MetricDefinition.- Converts legacy MBQL to MBQL 5 before processing.-- Metadata is loaded from the provider using the expression leaf's type and ID.- Dimensions and dimension-mappings are loaded from the fetched metadata."- [definition]- (let [{:keys [expression metadata-provider filters projections]} definition- leaf-type (expression-leaf-type expression)- leaf-id (expression-leaf-id expression)- leaf-uuid (expression-leaf-uuid expression)- _ (when-not leaf-type- (throw (ex-info "Arithmetic metric math expressions are not yet supported in AST builder"- {:expression expression})))- ;; Load metadata from provider- source-type (case leaf-type :metric :source/metric :measure :source/measure)- metadata-type (case leaf-type :metric :metadata/metric :measure :metadata/measure)- metadata (first (lib.metadata.protocols/metadatas- metadata-provider- {:lib/type metadata-type :id #{leaf-id}}))- ;; Load dimensions/mappings from source metadata+(defn- build-leaf-ast+ "Build a complete single-source AST for one expression leaf.+ Extracted from from-definition for reuse in arithmetic expressions."+ [leaf-type leaf-id leaf-uuid metadata-provider filters projections]+ (let [source-type (case leaf-type :metric :source/metric :measure :source/measure)+ metadata-type (case leaf-type :metric :metadata/metric :measure :metadata/measure)+ metadata (first (lib.metadata.protocols/metadatas+ metadata-provider+ {:lib/type metadata-type :id #{leaf-id}}))dimensions (lib-metric.dimension/get-persisted-dimensions metadata)dimension-mappings (lib-metric.dimension/get-persisted-dimension-mappings metadata)raw-query (case leaf-type@@ -397,10 +392,57 @@;; Convert filters and projections to AST nodesast-filter (when (seq leaf-filters) (mbql-filters->ast-filter leaf-filters))ast-group-by (when (seq leaf-projections) (perf/mapv dimension-ref->ast-dimension-ref leaf-projections))]- {:node/type :ast/root+ {:node/type :ast/source-query:source (mbql5-query->source-node source-type leaf-id metadata mbql5-query):dimensions (perf/mapv dimension-node (or dimensions [])):mappings (perf/mapv dimension-mapping-node (or dimension-mappings [])):filter ast-filter- :group-by (or ast-group-by [])+ :group-by (or ast-group-by [])}))++(defn- arithmetic-operator+ "Returns the arithmetic operator keyword if expression is an arithmetic node, nil otherwise."+ [expression]+ (when (arithmetic-expression? expression)+ (first expression)))++(defn- build-expression-ast+ "Recursively build expression AST from a metric-math expression tree.+ For numeric constants, produces :expression/constant.+ For leaves, calls build-leaf-ast and wraps in :expression/leaf.+ For arithmetic, recursively builds children and wraps in :expression/arithmetic."+ [expression metadata-provider filters projections]+ (cond+ (number? expression)+ {:node/type :expression/constant :value expression}++ (expression-leaf-type expression)+ (let [leaf-type (expression-leaf-type expression)+ leaf-id (expression-leaf-id expression)+ leaf-uuid (expression-leaf-uuid expression)+ sub-ast (build-leaf-ast leaf-type leaf-id leaf-uuid metadata-provider filters projections)]+ {:node/type :expression/leaf+ :uuid leaf-uuid+ :ast sub-ast})++ :else+ (let [op (arithmetic-operator expression)+ children (drop 2 expression)]+ {:node/type :expression/arithmetic+ :operator op+ :children (perf/mapv #(build-expression-ast % metadata-provider filters projections) children)})))++(defn from-definition+ "Create complete AST from MetricDefinition.+ Converts legacy MBQL to MBQL 5 before processing.++ Metadata is loaded from the provider using the expression leaf's type and ID.+ Dimensions and dimension-mappings are loaded from the fetched metadata.++ Always produces a unified root shape {:node/type :ast/root, :expression ...}.+ Single-leaf definitions become a single :expression/leaf node."+ [definition]+ (let [{:keys [expression metadata-provider filters projections]} definition+ expr-ast (build-expression-ast expression metadata-provider filters projections)]+ {:node/type :ast/root+ :expression expr-ast:metadata-provider metadata-provider}))diff --git a/src/metabase/lib_metric/ast/compile.cljc b/src/metabase/lib_metric/ast/compile.cljcindex 8d2b7f0b83b..e8a7705132c 100644--- a/src/metabase/lib_metric/ast/compile.cljc+++ b/src/metabase/lib_metric/ast/compile.cljc@@ -262,7 +262,7 @@:stages [stage-0 stage-1]}))(mu/defn compile-to-mbql- "Compile AST to MBQL query.+ "Compile a source-query to MBQL query.Generates a two-stage query when the source has joins or is based on asource-card (model / saved question):@@ -271,11 +271,11 @@Options:- :limit - add limit to query"- [{:keys [source] :as ast} :- ::ast.schema/ast+ [{:keys [source] :as source-query} :- ::ast.schema/source-query& {:as opts}](if (needs-two-stage? source)- (compile-two-stage-query ast opts)- (compile-single-stage-query ast opts)))+ (compile-two-stage-query source-query opts)+ (compile-single-stage-query source-query opts)));;; -------------------- Values Query Compilation (no aggregation) --------------------@@ -328,15 +328,15 @@:stages [stage-0 stage-1]}))(mu/defn compile-to-values-query- "Compile AST to MBQL query for fetching distinct values (no aggregation).+ "Compile a source-query to MBQL query for fetching distinct values (no aggregation).Like [[compile-to-mbql]] but omits the aggregation clause, producing a querythat returns distinct breakout values instead of aggregated results.Options:- :limit - add limit to query"- [{:keys [source] :as ast} :- ::ast.schema/ast+ [{:keys [source] :as source-query} :- ::ast.schema/source-query& {:as opts}](if (needs-two-stage? source)- (compile-two-stage-values-query ast opts)- (compile-single-stage-values-query ast opts)))+ (compile-two-stage-values-query source-query opts)+ (compile-single-stage-values-query source-query opts)))diff --git a/src/metabase/lib_metric/ast/plan.cljc b/src/metabase/lib_metric/ast/plan.cljcnew file mode 100644index 00000000000..f3ef8974972--- /dev/null+++ b/src/metabase/lib_metric/ast/plan.cljc@@ -0,0 +1,241 @@+(ns metabase.lib-metric.ast.plan+ "Query planning and execution for metric ASTs.+ Takes an AST (from ast.build/from-definition) and produces a query plan+ that can be compiled and executed."+ (:require+ [clojure.set :as set]+ [metabase.lib-metric.ast.compile :as ast.compile]+ [metabase.lib-metric.ast.walk :as ast.walk]+ [metabase.lib-metric.operators :as operators]+ [metabase.types.core]+ [metabase.util.performance :as perf]))++;; Ensure type hierarchy is loaded+(comment metabase.types.core/keep-me)++;;; -------------------- Plan Data Structures --------------------+;;;+;;; Leaf plan (single-source, pass-through):+;;; {:plan/type :leaf+;;; :plan/mbql <compiled-mbql-query>}+;;;+;;; Arithmetic plan (multi-query):+;;; {:plan/type :arithmetic+;;; :plan/expression <expression-node from AST>+;;; :plan/leaves {"uuid-a" {:leaf/uuid "a" :leaf/mbql <mbql>} ...}+;;; :plan/breakout-count 2+;;; :plan/limit 10000}++;;; -------------------- Validation --------------------++(defn- dimension-signature+ "Build a signature for a group-by dimension ref that captures its type compatibility.+ Two dimensions are compatible for joining if they have the same effective type+ and the same bucketing/binning options."+ [dim-ref sub-ast]+ (let [dim-id (:dimension-id dim-ref)+ ;; Look up the dimension node to get effective-type+ dim-node (perf/some #(when (= dim-id (:id %)) %) (:dimensions sub-ast))+ ;; Get bucketing/binning from the ref options+ ref-options (:options dim-ref)]+ {:effective-type (:effective-type dim-node)+ :temporal-unit (:temporal-unit ref-options)+ :binning (:binning ref-options)}))++(defn- collect-leaf-group-bys+ "Collect group-by info from all expression leaves in an expression AST.+ Returns a vector of maps with :uuid, :has-group-by, :breakout-count,+ and :signatures (a vector of dimension signatures in group-by order)."+ [expression-node]+ (let [leaves (ast.walk/collect #(= :expression/leaf (:node/type %)) expression-node)]+ (perf/mapv (fn [leaf]+ (let [sub-ast (:ast leaf)+ group-by (:group-by sub-ast)]+ {:uuid (:uuid leaf)+ :has-group-by (boolean (seq group-by))+ :breakout-count (count group-by)+ :signatures (perf/mapv #(dimension-signature % sub-ast) group-by)}))+ leaves)))++(defn- effective-types-compatible?+ "Check if two effective types are compatible for dimension joining.+ Types are compatible if they are equal, or if both are date/datetime types+ (Date, DateTime, DateTimeWithLocalTZ, etc.), or if both are time types."+ [type-a type-b]+ (or (= type-a type-b)+ ;; Both have a date component — Date, DateTime, DateTimeWithLocalTZ, etc.+ (and (isa? type-a :type/HasDate)+ (isa? type-b :type/HasDate))+ ;; Both are pure time types — Time, TimeWithLocalTZ+ (and (isa? type-a :type/Time)+ (isa? type-b :type/Time))))++(defn- signatures-compatible?+ "Check if two dimension signatures are compatible for joining.+ nil values are treated as unknown and compatible with any known value.+ Only rejects when both sides have known but different values.+ Effective types are matched using [[effective-types-compatible?]] which allows+ compatible-but-not-identical temporal types (e.g. Date vs DateTimeWithLocalTZ)."+ [sig-a sig-b]+ (and (or (nil? (:effective-type sig-a))+ (nil? (:effective-type sig-b))+ (effective-types-compatible? (:effective-type sig-a) (:effective-type sig-b)))+ (or (nil? (:temporal-unit sig-a))+ (nil? (:temporal-unit sig-b))+ (= (:temporal-unit sig-a) (:temporal-unit sig-b)))+ (or (nil? (:binning sig-a))+ (nil? (:binning sig-b))+ (= (:binning sig-a) (:binning sig-b)))))++(defn- all-signatures-compatible?+ "Check that all leaves' signature vectors are pairwise compatible at each position."+ [sig-vecs]+ (let [positions (count (first sig-vecs))]+ (perf/every? (fn [pos]+ (let [sigs-at-pos (map #(nth % pos) sig-vecs)]+ (perf/every? #(signatures-compatible? (first sigs-at-pos) %)+ (rest sigs-at-pos))))+ (range positions))))++(defn validate-arithmetic-ast!+ "Validate that an arithmetic expression AST has consistent group-by dimensions.+ All leaves must have the same number of breakout dimensions, and those dimensions must be+ type-compatible (same effective type, temporal unit, and binning) across all leaves.+ nil values are treated as unknown and compatible with any known value.+ Throws ex-info with :status-code 400 on validation failure."+ [expression-node]+ (let [leaf-infos (collect-leaf-group-bys expression-node)]+ (let [breakout-counts (map :breakout-count leaf-infos)]+ (when-not (apply = breakout-counts)+ (throw (ex-info "All leaves in arithmetic expression must have the same number of breakout dimensions"+ {:status-code 400+ :breakout-counts (zipmap (map :uuid leaf-infos) breakout-counts)}))))+ (let [sig-vecs (map :signatures leaf-infos)]+ (when-not (all-signatures-compatible? sig-vecs)+ (throw (ex-info "All leaves in arithmetic expression must have the same breakout dimension types and bucketing"+ {:status-code 400+ :signatures (zipmap (map :uuid leaf-infos) sig-vecs)}))))))++;;; -------------------- Plan Construction --------------------++(defn- compile-leaf-queries+ "Walk the expression AST, compile each leaf's sub-AST to MBQL.+ Returns a map of {uuid -> {:leaf/uuid uuid :leaf/mbql mbql}}."+ [expression-node opts]+ (let [leaves (ast.walk/collect #(= :expression/leaf (:node/type %)) expression-node)]+ (into {}+ (map (fn [leaf]+ (let [uuid (:uuid leaf)+ mbql (if-let [limit (:limit opts)]+ (ast.compile/compile-to-mbql (:ast leaf) :limit limit)+ (ast.compile/compile-to-mbql (:ast leaf)))]+ [uuid {:leaf/uuid uuid :leaf/mbql mbql}])))+ leaves)))++(defn- single-leaf?+ "Returns true if the expression is a single leaf (no arithmetic operator)."+ [expression-node]+ (= :expression/leaf (:node/type expression-node)))++(defn plan-from-ast+ "Take a complete AST (from from-definition) and produce a query plan.+ Single-leaf expressions produce a :leaf plan.+ Arithmetic expressions validate and produce an :arithmetic plan.++ Options:+ - :limit - add limit to compiled queries+ - :values-only - if true, compile as values query (no aggregation, for breakout values)"+ [ast & {:as opts}]+ (let [expression (:expression ast)+ compile-fn (if (:values-only opts) ast.compile/compile-to-values-query ast.compile/compile-to-mbql)]+ (if (single-leaf? expression)+ ;; Single leaf — compile the sub-AST directly+ {:plan/type :leaf+ :plan/mbql (if-let [limit (:limit opts)]+ (compile-fn (:ast expression) :limit limit)+ (compile-fn (:ast expression)))}+ ;; Arithmetic — validate and compile each leaf+ (do+ (validate-arithmetic-ast! expression)+ (let [leaf-infos (collect-leaf-group-bys expression)+ breakout-ct (:breakout-count (first leaf-infos))+ leaves (compile-leaf-queries expression opts)]+ {:plan/type :arithmetic+ :plan/expression expression+ :plan/leaves leaves+ :plan/breakout-count breakout-ct+ :plan/limit (:limit opts)})))))++;;; -------------------- Expression Evaluation --------------------++(defn evaluate-expression+ "Recursively evaluate an expression AST node given {uuid -> numeric-value}.+ Returns nil on nil inputs or division by zero.+ Operator behavior is driven by metadata in [[operators/operator-metadata]]."+ [expression-node uuid->value]+ (case (:node/type expression-node)+ :expression/leaf+ (get uuid->value (:uuid expression-node))++ :expression/constant+ (:value expression-node)++ :expression/arithmetic+ (let [{:keys [operator children]} expression-node+ child-vals (perf/mapv #(evaluate-expression % uuid->value) children)]+ (when (perf/every? some? child-vals)+ (let [f (operators/eval-fn operator)+ [init & rest-vals] child-vals]+ (when-not (and (operators/zero-guard? operator)+ (perf/some zero? rest-vals))+ (reduce f init rest-vals)))))))++;;; -------------------- Result Joining --------------------++(defn index-result-by-dimensions+ "Index QP result rows as {dim-value-tuple -> agg-value}.+ The first `breakout-count` columns are dimension values, the rest is the aggregate."+ [result breakout-count]+ (let [rows (perf/get-in result [:data :rows])]+ (into {}+ (map (fn [row]+ [(vec (take breakout-count row))+ (nth row breakout-count)]))+ rows)))++(defn join-and-compute+ "Inner-join all leaf results on dimension tuples, evaluate expression per row.+ Returns {:cols [...] :rows [...]}."+ [expression-node leaf-results breakout-count]+ (let [;; Index each leaf's results by dimension tuple+ uuid->indexed (into {}+ (map (fn [[uuid result]]+ [uuid (index-result-by-dimensions result breakout-count)]))+ leaf-results)+ ;; Find dimension tuples present in ALL leaves (inner join)+ all-dim-tuples (reduce (fn [acc [_uuid indexed]]+ (if (nil? acc)+ (set (keys indexed))+ (set/intersection acc (set (keys indexed)))))+ nil+ uuid->indexed)+ ;; Compute expression for each joined row+ rows (into []+ (keep (fn [dim-tuple]+ (let [uuid->val (into {}+ (map (fn [[uuid indexed]]+ [uuid (get indexed dim-tuple)]))+ uuid->indexed)+ result (evaluate-expression expression-node uuid->val)]+ (when (some? result)+ (conj dim-tuple result)))))+ (sort all-dim-tuples))+ ;; Build column metadata from the first leaf's result+ first-result (val (first leaf-results))+ source-cols (perf/get-in first-result [:data :cols])+ breakout-cols (vec (take breakout-count source-cols))+ ;; Use the last col (aggregate) with a generic name for the computed result+ agg-col (-> (last source-cols)+ (assoc :name "expression" :display_name "Expression"))]+ {:cols (conj breakout-cols agg-col)+ :rows rows}))diff --git a/src/metabase/lib_metric/ast/schema.cljc b/src/metabase/lib_metric/ast/schema.cljcindex e4fefb137df..6ab9e75f1db 100644--- a/src/metabase/lib_metric/ast/schema.cljc+++ b/src/metabase/lib_metric/ast/schema.cljc@@ -3,6 +3,7 @@The AST provides an intermediate representation for metric definitionsthat can be walked, transformed, and compiled to MBQL queries."(:require+ [metabase.lib-metric.operators :as operators][metabase.lib-metric.schema :as lib-metric.schema][metabase.util.malli.registry :as mr]))@@ -247,15 +248,49 @@"Union of source node types."[:or ::source-metric ::source-measure])-;;; -------------------- Root Node --------------------+;;; -------------------- Expression Nodes ---------------------(mr/def ::ast- "Root AST node - the complete metric exploration."+(mr/def ::source-query+ "A single-source query node with source, dimensions, mappings, filters, and group-by.+ Used inside expression leaves as the compilable sub-query."[:map- [:node/type [:= :ast/root]]+ [:node/type [:= :ast/source-query]][:source ::source-node][:dimensions [:sequential ::dimension-node]][:mappings [:sequential ::dimension-mapping-node]][:filter {:optional true} [:maybe ::filter-node]]- [:group-by {:optional true} [:maybe [:sequential ::dimension-ref-node]]]+ [:group-by {:optional true} [:maybe [:sequential ::dimension-ref-node]]]])++(mr/def ::expression-leaf+ "A leaf in an expression tree — wraps a source-query."+ [:map+ [:node/type [:= :expression/leaf]]+ [:uuid string?]+ [:ast ::source-query]])++(mr/def ::expression-constant+ "A numeric constant in an expression tree."+ [:map+ [:node/type [:= :expression/constant]]+ [:value number?]])++(mr/def ::expression-arithmetic+ "An arithmetic operation over expression children."+ [:map+ [:node/type [:= :expression/arithmetic]]+ [:operator (into [:enum] (operators/arithmetic-operator-keywords))]+ [:children [:sequential [:or [:ref ::expression-leaf] [:ref ::expression-arithmetic] [:ref ::expression-constant]]]]])++(mr/def ::expression-node+ "Union of expression node types."+ [:or ::expression-leaf ::expression-arithmetic ::expression-constant])++;;; -------------------- Root Node --------------------++(mr/def ::ast+ "Root AST node - the complete metric exploration.+ Always has an :expression tree (single leaf or arithmetic)."+ [:map+ [:node/type [:= :ast/root]]+ [:expression ::expression-node][:metadata-provider {:optional true} [:maybe :some]]])diff --git a/src/metabase/lib_metric/ast/walk.cljc b/src/metabase/lib_metric/ast/walk.cljcindex 77bfceada72..6cef5c65f85 100644--- a/src/metabase/lib_metric/ast/walk.cljc+++ b/src/metabase/lib_metric/ast/walk.cljc@@ -60,7 +60,22 @@(:lat-dimension ast) (update :lat-dimension inner)(:lon-dimension ast) (update :lon-dimension inner)))-(defmethod walk-node :ast/root+;; Expression leaf — walk into the nested AST+(defmethod walk-node :expression/leaf+ [inner ast]+ (update ast :ast inner))++;; Expression constant — no children to walk+(defmethod walk-node :expression/constant+ [_inner ast]+ ast)++;; Expression arithmetic — walk into children+(defmethod walk-node :expression/arithmetic+ [inner ast]+ (update ast :children #(perf/mapv inner %)))++(defmethod walk-node :ast/source-query[inner ast](cond-> ast(:filter ast) (update :filter inner)@@ -69,6 +84,10 @@(:dimensions ast) (update :dimensions #(perf/mapv inner %))(:mappings ast) (update :mappings #(perf/mapv inner %))))+(defmethod walk-node :ast/root+ [inner ast]+ (update ast :expression inner))+(defmethod walk-node :source/any[inner ast](cond-> astdiff --git a/src/metabase/lib_metric/core.cljc b/src/metabase/lib_metric/core.cljcindex b6a019e2f56..35ee813a334 100644--- a/src/metabase/lib_metric/core.cljc+++ b/src/metabase/lib_metric/core.cljc@@ -11,7 +11,8 @@or column aliases. Dimension refs `[:dimension {} \"uuid\"]` are resolved toconcrete field refs when the definition is converted to an executable MBQL query."(:require- #?@(:clj [[metabase.lib-metric.dimension.jvm :as lib-metric.dimension.jvm]+ #?@(:clj [[metabase.lib-metric.ast.plan :as ast.plan]+ [metabase.lib-metric.dimension.jvm :as lib-metric.dimension.jvm][metabase.lib-metric.metadata.jvm :as lib-metric.metadata.jvm][potemkin :as p]]:cljs [[metabase.lib-metric.metadata.js :as lib-metric.metadata.js]])@@ -38,6 +39,8 @@remove-clausereplace-clauseswap-clauses]+ [ast.plan+ join-and-compute][lib-metric.definitionexpression-leaf-idexpression-leaf-type@@ -46,11 +49,12 @@filtersfrom-measure-metadatafrom-metric-metadata+ projection-valid?projectionssource-measure-idsource-metric-id- ->mbql-query- ->values-query]+ unprojected-sources+ ->query-plan][lib-metric.dimensiondimensiondimensionable-querydiff --git a/src/metabase/lib_metric/definition.cljc b/src/metabase/lib_metric/definition.cljcindex 69749caa442..5c27f7d3a83 100644--- a/src/metabase/lib_metric/definition.cljc+++ b/src/metabase/lib_metric/definition.cljc@@ -2,10 +2,11 @@"Functions for creating and manipulating MetricDefinitions."(:require[metabase.lib-metric.ast.build :as ast.build]- [metabase.lib-metric.ast.compile :as ast.compile]+ [metabase.lib-metric.ast.plan :as ast.plan][metabase.lib-metric.ast.schema :as ast.schema][metabase.lib-metric.schema :as lib-metric.schema]- [metabase.util.malli :as mu]))+ [metabase.util.malli :as mu]+ [metabase.util.performance :as perf]))(comment ast.schema/keep-me)@@ -15,6 +16,10 @@"Returns true if the expression is a single leaf node ([:metric opts id] or [:measure opts id])."ast.build/expression-leaf?)+(def arithmetic-expression?+ "Returns true if the expression is an arithmetic node [op opts expr expr ...]."+ ast.build/arithmetic-expression?)+(def expression-leaf-type"Returns the type keyword (:metric or :measure) from an expression leaf."ast.build/expression-leaf-type)@@ -42,10 +47,9 @@[expression](cond(nil? expression) []+ (number? expression) [](expression-leaf? expression) [expression]- (and (sequential? expression)- (#{:+ :- :* :/} (first expression))- (>= (count expression) 4))+ (arithmetic-expression? expression)(into [] (mapcat expression-leaves) (drop 2 expression)):else (throw (ex-info "Invalid expression: not a leaf or arithmetic node"{:expression expression}))))@@ -97,6 +101,36 @@(when (= :measure (expression-leaf-type expr))(expression-leaf-id expr))))+(defn projection-valid?+ "Returns true when every distinct source leaf in the expression has a non-empty projection defined."+ [definition]+ (let [leaves (expression-leaves (:expression definition))+ projections (or (:projections definition) [])]+ (perf/every? (fn [leaf]+ (let [leaf-type (expression-leaf-type leaf)+ leaf-id (expression-leaf-id leaf)]+ (perf/some (fn [tp]+ (and (= leaf-type (:type tp))+ (= leaf-id (:id tp))+ (seq (:projection tp))))+ projections)))+ leaves)))++(defn unprojected-sources+ "Returns a vector of expression leaves that are missing projections."+ [definition]+ (let [leaves (expression-leaves (:expression definition))+ projections (or (:projections definition) [])+ projected? (fn [leaf]+ (let [leaf-type (expression-leaf-type leaf)+ leaf-id (expression-leaf-id leaf)]+ (perf/some (fn [tp]+ (and (= leaf-type (:type tp))+ (= leaf-id (:id tp))+ (seq (:projection tp))))+ projections)))]+ (into [] (remove projected?) leaves)))+(defn filters"Get the filter clauses from a metric definition.Returns the instance-filters vector."@@ -116,27 +150,13 @@[definition :- ::lib-metric.schema/metric-definition](ast.build/from-definition definition))-(mu/defn ->mbql-query- "Convert MetricDefinition to MBQL query via AST."- ([definition :- ::lib-metric.schema/metric-definition]- (->mbql-query definition {}))- ([definition :- ::lib-metric.schema/metric-definition- opts :- [:map- [:limit {:optional true} [:maybe pos-int?]]]]- (let [ast (->ast definition)]- (if (some? (:limit opts))- (ast.compile/compile-to-mbql ast :limit (:limit opts))- (ast.compile/compile-to-mbql ast)))))--(mu/defn ->values-query- "Convert MetricDefinition to a values-only MBQL query via AST.- Like [[->mbql-query]] but omits aggregation, returning distinct breakout values."+(mu/defn ->query-plan+ "Convert MetricDefinition to a QueryPlan via AST.+ For single-leaf definitions, returns a :leaf plan with compiled MBQL.+ For arithmetic expressions, returns an :arithmetic plan with multiple compiled queries."([definition :- ::lib-metric.schema/metric-definition]- (->values-query definition {}))+ (->query-plan definition {}))([definition :- ::lib-metric.schema/metric-definition- opts :- [:map- [:limit {:optional true} [:maybe pos-int?]]]]+ opts](let [ast (->ast definition)]- (if (some? (:limit opts))- (ast.compile/compile-to-values-query ast :limit (:limit opts))- (ast.compile/compile-to-values-query ast)))))+ (ast.plan/plan-from-ast ast opts))))diff --git a/src/metabase/lib_metric/hierarchy.cljc b/src/metabase/lib_metric/hierarchy.cljcindex 2ca97a359e2..0847935896b 100644--- a/src/metabase/lib_metric/hierarchy.cljc+++ b/src/metabase/lib_metric/hierarchy.cljc@@ -2,7 +2,7 @@"Shared keyword hierarchy for lib-metric dispatch.Provides a hierarchy that can be used for multimethod dispatch andoperator categorization throughout the lib-metric system."- (:refer-clojure :exclude [derive isa?]))+ (:refer-clojure :exclude [derive isa? descendants]))(defonce ^{:doc "Hierarchy for lib-metric dispatch."} hierarchy(atom (make-hierarchy)))@@ -17,3 +17,8 @@"Like [[clojure.core/isa?]], but uses the lib-metric [[hierarchy]]."[tag parent](clojure.core/isa? @hierarchy tag parent))++(defn descendants+ "Like [[clojure.core/descendants]], but uses the lib-metric [[hierarchy]]."+ [tag]+ (clojure.core/descendants @hierarchy tag))diff --git a/src/metabase/lib_metric/js.cljs b/src/metabase/lib_metric/js.cljsindex 246ea3a9bca..7bd568de8b9 100644--- a/src/metabase/lib_metric/js.cljs+++ b/src/metabase/lib_metric/js.cljs@@ -848,3 +848,18 @@(boolean(when (and (seq sources1) (seq sources2))(some (set sources1) sources2)))))++(defn ^:export isCompatibleType+ "Check if two dimensions have compatible effective types for cross-database matching.+ Two date/datetime dimensions are compatible, two time dimensions are compatible,+ otherwise requires exact type match. Returns false if either type is nil."+ [dimension1 dimension2]+ (let [type1 (types.isa/column-type dimension1)+ type2 (types.isa/column-type dimension2)]+ (boolean+ (when (and type1 type2)+ (or (= type1 type2)+ (and (isa? type1 :type/HasDate)+ (isa? type2 :type/HasDate))+ (and (isa? type1 :type/Time)+ (isa? type2 :type/Time)))))))diff --git a/src/metabase/lib_metric/operators.cljc b/src/metabase/lib_metric/operators.cljcindex 4e0ec1f4f25..fc45a0f91f6 100644--- a/src/metabase/lib_metric/operators.cljc+++ b/src/metabase/lib_metric/operators.cljc@@ -1,8 +1,8 @@(ns metabase.lib-metric.operators- "Unified operator definitions for lib-metric filters.+ "Unified operator definitions for lib-metric filters and arithmetic.Uses lib-metric.hierarchy for category dispatch.- Operator categories:+ Filter categories:- ::nullary - no value argument (:is-null, :not-null, :is-empty, :not-empty)- ::comparison - single or variadic values (:=, :!=, :<, :<=, :>, :>=)- ::string-op - string-specific operators (:contains, :does-not-contain, :starts-with, :ends-with)@@ -11,7 +11,10 @@- ::compound - logical operators (:and, :or, :not)- ::multi-value - multi-value operators (:in, :not-in)- All categories derive from ::filter-operator for display-info compatibility."+ Arithmetic category:+ - ::arithmetic - numeric operations (:+, :-, :*, :/)++ All filter categories derive from ::filter-operator for display-info compatibility."(:require[metabase.lib-metric.hierarchy :as hierarchy][metabase.util.performance :as perf]))@@ -50,15 +53,25 @@(doseq [op [:get-day-of-week :get-month :get-hour :get-quarter]](hierarchy/derive op ::temporal-extraction))-;; All operator categories are filter operators (for display-info compatibility)+;; Arithmetic operators+(doseq [op [:+ :- :* :/]]+ (hierarchy/derive op ::arithmetic))++;; All filter categories are filter operators (for display-info compatibility)(doseq [cat [::nullary ::comparison ::string-op ::range ::temporal ::compound ::multi-value]](hierarchy/derive cat ::filter-operator));;; -------------------------------------------------- Operator Metadata --------------------------------------------------(def ^:private operator-metadata- "Metadata for each filter operator."- {:is-null {:display-name "is empty" :arity 0 :ast-node-type :filter/null}+ "Metadata for all operators (filter and arithmetic)."+ {;; --- Arithmetic operators ---+ :+ {:display-name "plus" :arity :variadic :eval-fn +}+ :- {:display-name "minus" :arity :variadic :eval-fn -}+ :* {:display-name "times" :arity :variadic :eval-fn *}+ :/ {:display-name "divided by" :arity :variadic :eval-fn (fn [a b] (/ (double a) (double b))) :zero-guard? true}+ ;; --- Filter operators ---+ :is-null {:display-name "is empty" :arity 0 :ast-node-type :filter/null}:not-null {:display-name "is not empty" :arity 0 :ast-node-type :filter/null}:is-empty {:display-name "is empty" :arity 0 :ast-node-type :filter/null}:not-empty {:display-name "is not empty" :arity 0 :ast-node-type :filter/null}@@ -129,6 +142,11 @@[op](hierarchy/isa? op ::filter-operator))+(defn arithmetic?+ "Returns true if `op` is an arithmetic operator."+ [op]+ (hierarchy/isa? op ::arithmetic))+;;; -------------------------------------------------- Query Functions --------------------------------------------------(defn display-name@@ -146,6 +164,21 @@[op](perf/get-in operator-metadata [op :ast-node-type]))+(defn eval-fn+ "Get the evaluation function for an arithmetic operator."+ [op]+ (perf/get-in operator-metadata [op :eval-fn]))++(defn zero-guard?+ "Returns true if the arithmetic operator needs division-by-zero protection."+ [op]+ (perf/get-in operator-metadata [op :zero-guard?]))++(defn arithmetic-operator-keywords+ "Returns the set of registered arithmetic operator keywords."+ []+ (hierarchy/descendants ::arithmetic))+;;; -------------------------------------------------- Operators by Dimension Type --------------------------------------------------(def ^:private operators-by-dimension-typediff --git a/src/metabase/lib_metric/projection.cljc b/src/metabase/lib_metric/projection.cljcindex cf84cc30efe..26c876c6a2d 100644--- a/src/metabase/lib_metric/projection.cljc+++ b/src/metabase/lib_metric/projection.cljc@@ -118,13 +118,32 @@(update definition :projections (fnil conj []){:type leaf-type :id leaf-id :lib/uuid leaf-uuid :projection [dimension-ref]}))))+(defn- all-projectable-dimensions+ "Get all projectable dimensions, handling both single-source and multi-source definitions."+ [definition]+ (let [expression (:expression definition)]+ (if (lib-metric.definition/expression-leaf? expression)+ (projectable-dimensions definition)+ ;; Multi-source: collect dimensions from each leaf source+ (let [leaves (lib-metric.definition/expression-leaves expression)]+ (into []+ (mapcat (fn [leaf]+ (let [leaf-type (lib-metric.definition/expression-leaf-type leaf)+ leaf-id (lib-metric.definition/expression-leaf-id leaf)+ source-metadata {:lib/type (case leaf-type+ :metric :metadata/metric+ :measure :metadata/measure)+ :id leaf-id}]+ (projectable-dimensions-for-source definition source-metadata))))+ leaves)))))+(mu/defn projection-dimension :- [:maybe ::lib-metric.schema/metadata-dimension]"Get the dimension metadata for a projection clause.The projection is a dimension-reference [:dimension opts uuid].Returns the dimension metadata or nil if not found."[definition :- ::lib-metric.schema/metric-definitionprojection-or-reference :- ::lib-metric.schema/dimension-or-reference]- (let [dimensions (projectable-dimensions definition)+ (let [dimensions (all-projectable-dimensions definition)dimension-id (if (map? projection-or-reference)(:id projection-or-reference)(projection-dimension-id projection-or-reference))]diff --git a/src/metabase/lib_metric/schema.cljc b/src/metabase/lib_metric/schema.cljcindex a71bf2b122a..49af2b81716 100644--- a/src/metabase/lib_metric/schema.cljc+++ b/src/metabase/lib_metric/schema.cljc@@ -2,6 +2,7 @@"Malli schemas for metric dimensions, dimension-mappings, and dimension-references."(:refer-clojure :exclude [some])(:require+ [metabase.lib-metric.operators :as operators][metabase.lib.schema.common :as lib.schema.common][metabase.lib.schema.id :as lib.schema.id][metabase.lib.schema.ref :as lib.schema.ref]@@ -227,13 +228,16 @@(mr/def ::arithmetic-operator"Arithmetic operators for metric math."- [:enum {:decode/normalize lib.schema.common/normalize-keyword} :+ :- :* :/])+ (into [:enum {:decode/normalize lib.schema.common/normalize-keyword}]+ (operators/arithmetic-operator-keywords)))(defn normalize-math-expression"Recursively normalize a metric math expression from API format.- Handles string keys, string operators, and nested expressions."+ Handles string keys, string operators, nested expressions, and bare numeric constants."[x]- (when (sequential? x)+ (cond+ (number? x) x+ (sequential? x)(let [[first-el] x](if (and (>= (count x) 3)(let [tag (lib.schema.common/normalize-keyword first-el)]@@ -245,7 +249,8 @@(let [[op opts & exprs] x](into [(lib.schema.common/normalize-keyword op)(lib.schema.common/normalize-options-map (or opts {}))]- (map normalize-math-expression exprs))))))))+ (map normalize-math-expression exprs))))))+ :else nil))(mr/def ::metric-math-expression"A recursive metric math expression tree.@@ -256,12 +261,13 @@{:decode/normalize normalize-math-expression}[:or::expression-leaf+ number?[:andvector?[:fn {:error/message "must be arithmetic expression [op opts expr expr ...] with at least 2 operands"}(fn [x](and (>= (count x) 4)- (#{:+ :- :* :/} (first x))+ (operators/arithmetic? (first x))(map? (second x))))]]]]);;; ------------------------------------------------- Per-Instance Filters -------------------------------------------------diff --git a/src/metabase/metrics/api.clj b/src/metabase/metrics/api.cljindex 44009909ff1..8e8cfd22c58 100644--- a/src/metabase/metrics/api.clj+++ b/src/metabase/metrics/api.clj@@ -9,6 +9,7 @@[metabase.metrics.core :as metrics][metabase.metrics.permissions :as metrics.perms][metabase.query-processor.core :as qp]+ [metabase.query-processor.pipeline :as qp.pipeline][metabase.query-processor.streaming :as qp.streaming][metabase.request.core :as request][metabase.server.core :as server]@@ -17,6 +18,8 @@[metabase.util.malli.schema :as ms][toucan2.core :as t2]))+(set! *warn-on-reflection* true)+(mr/def ::Metric"Schema for a Metric in list responses (without hydrated dimensions)."[:map@@ -121,6 +124,9 @@[:expression ::lib-metric.schema/metric-math-expression][:filters {:optional true} [:maybe ::lib-metric.schema/instance-filters]][:projections {:optional true} [:maybe ::lib-metric.schema/typed-projections]]]+ [:fn {:error/message "Expression must contain at least one metric or measure"}+ (fn [{:keys [expression]}]+ (seq (collect-expression-leaves expression)))][:fn {:error/message "All :lib/uuid values in expression must be unique"}(fn [{:keys [expression]}](let [uuids (collect-expression-uuids expression)]@@ -181,6 +187,29 @@:projections (or projections []):metadata-provider provider}))+(defn- execute-leaf-queries+ "Execute all leaf queries in parallel, collecting results eagerly.+ Must be called OUTSIDE streaming context to avoid JSON writer conflicts.+ Returns {uuid -> qp-result}."+ [leaves]+ (let [uuid->future (into {}+ (map (fn [[uuid leaf-plan]]+ [uuid (future (qp/process-query (qp/userland-query (:leaf/mbql leaf-plan))))]))+ leaves)]+ (into {}+ (map (fn [[uuid f]] [uuid @f]))+ uuid->future)))++(defn- stream-arithmetic-results+ "Join leaf results and stream the computed output through the QP reduce pipeline.+ Called INSIDE streaming context with the rff."+ [{:keys [plan/expression plan/breakout-count]} uuid->result rff]+ (let [{:keys [cols rows]} (lib-metric/join-and-compute expression uuid->result breakout-count)+ reducible (reify clojure.lang.IReduceInit+ (reduce [_ rf init]+ (reduce rf init rows)))]+ (qp.pipeline/*reduce* rff {:cols cols} reducible)))+(api.macros/defendpoint :post "/dataset":- (server/streaming-response-schema ::DatasetResponse)"Execute a metric or measure-based query and stream the results.@@ -193,11 +222,15 @@[_route-params_query-params{:keys [definition]} :- ::DatasetRequest]- (let [query (-> (lib-metric/metadata-provider)- (from-api-definition definition)- (lib-metric/->mbql-query {:limit 10000}))]- (qp.streaming/streaming-response [rff :api]- (qp/process-query (qp/userland-query query) rff))))+ (let [definition (from-api-definition (lib-metric/metadata-provider) definition)+ plan (lib-metric/->query-plan definition {:limit 10000})]+ (if (= :leaf (:plan/type plan))+ (qp.streaming/streaming-response [rff :api]+ (qp/process-query (qp/userland-query (:plan/mbql plan)) rff))+ ;; Arithmetic: execute leaf queries BEFORE streaming to avoid JSON writer conflicts+ (let [uuid->result (execute-leaf-queries (:plan/leaves plan))]+ (qp.streaming/streaming-response [rff :api]+ (stream-arithmetic-results plan uuid->result rff))))));;; +----------------------------------------------------------------------------------------------------------------+;;; | Dimension Value Endpoints |@@ -215,12 +248,11 @@[_route-params_query-params{:keys [definition]} :- ::DatasetRequest]- (let [query (-> (lib-metric/metadata-provider)- (from-api-definition definition)- (lib-metric/->values-query {:limit 100}))- result (qp/process-query (qp/userland-query query))- col (first (get-in result [:data :cols]))- values (mapv first (get-in result [:data :rows]))]+ (let [definition (from-api-definition (lib-metric/metadata-provider) definition)+ plan (lib-metric/->query-plan definition {:limit 100 :values-only true})+ result (qp/process-query (qp/userland-query (:plan/mbql plan)))+ col (first (get-in result [:data :cols]))+ values (mapv first (get-in result [:data :rows]))]{:values values:col (or col {})}))diff --git a/test/metabase/lib_metric/ast/build_test.cljc b/test/metabase/lib_metric/ast/build_test.cljcindex 418e70e1f23..fd1b89b02c4 100644--- a/test/metabase/lib_metric/ast/build_test.cljc+++ b/test/metabase/lib_metric/ast/build_test.cljc@@ -137,24 +137,33 @@(testing "has correct root structure"(is (= :ast/root (:node/type ast)))- (is (nil? (:filter ast)))- (is (= [] (:group-by ast)))+ (is (some? (:expression ast)))(is (some? (:metadata-provider ast))))- (testing "has correct source"- (let [source (:source ast)]- (is (= :source/metric (:node/type source)))- (is (= 42 (:id source)))- (is (= "Total Revenue" (:name source)))))+ (testing "expression is a single leaf"+ (is (= :expression/leaf (get-in ast [:expression :node/type])))+ (is (string? (get-in ast [:expression :uuid]))))- (testing "has dimensions as nodes"- (is (= 2 (count (:dimensions ast))))- (is (every? #(= :ast/dimension (:node/type %)) (:dimensions ast)))- (is (= uuid-1 (get-in ast [:dimensions 0 :id]))))+ (let [source-query (get-in ast [:expression :ast])]+ (testing "leaf wraps a source-query"+ (is (= :ast/source-query (:node/type source-query)))+ (is (nil? (:filter source-query)))+ (is (= [] (:group-by source-query))))- (testing "has mappings as nodes"- (is (= 2 (count (:mappings ast))))- (is (every? #(= :ast/dimension-mapping (:node/type %)) (:mappings ast))))))+ (testing "has correct source"+ (let [source (:source source-query)]+ (is (= :source/metric (:node/type source)))+ (is (= 42 (:id source)))+ (is (= "Total Revenue" (:name source)))))++ (testing "has dimensions as nodes"+ (is (= 2 (count (:dimensions source-query))))+ (is (every? #(= :ast/dimension (:node/type %)) (:dimensions source-query)))+ (is (= uuid-1 (get-in source-query [:dimensions 0 :id]))))++ (testing "has mappings as nodes"+ (is (= 2 (count (:mappings source-query))))+ (is (every? #(= :ast/dimension-mapping (:node/type %)) (:mappings source-query)))))))(deftest ^:parallel from-definition-measure-test(let [measure-def {:lib/type :metric/definition@@ -168,10 +177,10 @@(is (nil? (me/humanize (mr/explain ::ast.schema/ast ast)))))(testing "has measure source type"- (is (= :source/measure (get-in ast [:source :node/type]))))+ (is (= :source/measure (get-in ast [:expression :ast :source :node/type]))))(testing "extracts sum aggregation"- (is (= :aggregation/sum (get-in ast [:source :aggregation :node/type]))))))+ (is (= :aggregation/sum (get-in ast [:expression :ast :source :aggregation :node/type]))))));;; -------------------------------------------------- Dimension Reference Conversion --------------------------------------------------@@ -377,15 +386,16 @@(let [definition-with-filters (assoc (sample-definition):filters [{:lib/uuid expr-uuid:filter [:= {} [:dimension {} uuid-1] 42]}])- ast (ast.build/from-definition definition-with-filters)]+ ast (ast.build/from-definition definition-with-filters)+ source-query (get-in ast [:expression :ast])](testing "creates valid AST structure with filter"(is (nil? (me/humanize (mr/explain ::ast.schema/ast ast)))))(testing "has filter node"- (is (some? (:filter ast)))- (is (= :filter/comparison (get-in ast [:filter :node/type])))- (is (= := (get-in ast [:filter :operator]))))))+ (is (some? (:filter source-query)))+ (is (= :filter/comparison (get-in source-query [:filter :node/type])))+ (is (= := (get-in source-query [:filter :operator]))))))(deftest ^:parallel from-definition-with-projections-test(let [definition-with-projections (assoc (sample-definition)@@ -394,24 +404,26 @@:lib/uuid expr-uuid:projection [[:dimension {} uuid-1][:dimension {"temporal-unit" "year"} uuid-2]]}])- ast (ast.build/from-definition definition-with-projections)]+ ast (ast.build/from-definition definition-with-projections)+ source-query (get-in ast [:expression :ast])](testing "creates valid AST structure with group-by"(is (nil? (me/humanize (mr/explain ::ast.schema/ast ast)))))(testing "has group-by dimension refs"- (is (= 2 (count (:group-by ast))))- (is (every? #(= :ast/dimension-ref (:node/type %)) (:group-by ast)))- (is (= uuid-1 (get-in ast [:group-by 0 :dimension-id])))- (is (= {:temporal-unit :year} (get-in ast [:group-by 1 :options]))))))+ (is (= 2 (count (:group-by source-query))))+ (is (every? #(= :ast/dimension-ref (:node/type %)) (:group-by source-query)))+ (is (= uuid-1 (get-in source-query [:group-by 0 :dimension-id])))+ (is (= {:temporal-unit :year} (get-in source-query [:group-by 1 :options]))))))(deftest ^:parallel from-definition-loads-dimensions-from-provider-test(testing "dimensions are loaded from metadata fetched via provider"(let [definition (sample-definition)- ast (ast.build/from-definition definition)]+ ast (ast.build/from-definition definition)+ source-query (get-in ast [:expression :ast])];; Dimensions are loaded from provider -> sample-metric-metadata- (is (= 2 (count (:dimensions ast))))- (is (= 2 (count (:mappings ast)))))))+ (is (= 2 (count (:dimensions source-query))))+ (is (= 2 (count (:mappings source-query)))))));;; -------------------------------------------------- Multi-Stage Source Queries --------------------------------------------------@@ -441,6 +453,101 @@:metadata-provider provider}ast (ast.build/from-definition definition)](testing "has joins extracted from stage 0"- (is (seq (get-in ast [:source :joins]))))+ (is (seq (get-in ast [:expression :ast :source :joins]))))(testing "has aggregation extracted from stage 0"- (is (some? (get-in ast [:source :aggregation])))))))+ (is (some? (get-in ast [:expression :ast :source :aggregation])))))))++;;; -------------------------------------------------- Arithmetic Expression Building --------------------------------------------------++(def ^:private arith-uuid-a "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")+(def ^:private arith-uuid-b "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb")++(defn- arithmetic-definition []+ {:lib/type :metric/definition+ :expression [:+ {}+ [:metric {:lib/uuid arith-uuid-a} 42]+ [:metric {:lib/uuid arith-uuid-b} 42]]+ :filters []+ :projections []+ :metadata-provider (make-test-provider (sample-metric-metadata) (sample-measure-metadata))})++(deftest ^:parallel from-definition-arithmetic-test+ (let [ast (ast.build/from-definition (arithmetic-definition))]++ (testing "arithmetic expression builds AST with :expression key"+ (is (= :ast/root (:node/type ast)))+ (is (some? (:expression ast)))+ (is (nil? (:source ast))))++ (testing "expression root is arithmetic node"+ (is (= :expression/arithmetic (get-in ast [:expression :node/type])))+ (is (= :+ (get-in ast [:expression :operator]))))++ (testing "arithmetic has two children"+ (is (= 2 (count (get-in ast [:expression :children])))))++ (testing "each child is an expression leaf with complete sub-AST"+ (doseq [child (get-in ast [:expression :children])]+ (is (= :expression/leaf (:node/type child)))+ (is (string? (:uuid child)))+ (let [sub-ast (:ast child)]+ (is (= :ast/source-query (:node/type sub-ast)))+ (is (some? (:source sub-ast)))+ (is (seq (:dimensions sub-ast)))+ (is (seq (:mappings sub-ast))))))++ (testing "leaf UUIDs match expression"+ (let [uuids (set (map :uuid (get-in ast [:expression :children])))]+ (is (contains? uuids arith-uuid-a))+ (is (contains? uuids arith-uuid-b))))))++(deftest ^:parallel from-definition-arithmetic-with-filters-test+ (let [definition (assoc (arithmetic-definition)+ :filters [{:lib/uuid arith-uuid-a+ :filter [:= {} [:dimension {} uuid-1] 42]}])+ ast (ast.build/from-definition definition)]++ (testing "instance filters are partitioned to matching leaf sub-ASTs"+ (let [children (get-in ast [:expression :children])+ child-a (first (filter #(= arith-uuid-a (:uuid %)) children))+ child-b (first (filter #(= arith-uuid-b (:uuid %)) children))]+ (is (some? (get-in child-a [:ast :filter])))+ (is (nil? (get-in child-b [:ast :filter])))))))++(deftest ^:parallel from-definition-arithmetic-with-constant-test+ (let [definition {:lib/type :metric/definition+ :expression [:* {} [:metric {:lib/uuid arith-uuid-a} 42] 100]+ :filters []+ :projections []+ :metadata-provider (make-test-provider (sample-metric-metadata) (sample-measure-metadata))}+ ast (ast.build/from-definition definition)]++ (testing "creates valid AST with constant child"+ (is (nil? (me/humanize (mr/explain ::ast.schema/ast ast)))))++ (testing "expression root is arithmetic"+ (is (= :expression/arithmetic (get-in ast [:expression :node/type])))+ (is (= :* (get-in ast [:expression :operator]))))++ (testing "has one leaf and one constant child"+ (let [children (get-in ast [:expression :children])]+ (is (= 2 (count children)))+ (is (= :expression/leaf (get-in children [0 :node/type])))+ (is (= :expression/constant (get-in children [1 :node/type])))+ (is (= 100 (get-in children [1 :value])))))))++(deftest ^:parallel from-definition-arithmetic-with-projections-test+ (let [definition (assoc (arithmetic-definition)+ :projections [{:type :metric+ :id 42+ :lib/uuid arith-uuid-a+ :projection [[:dimension {} uuid-1]]}+ {:type :metric+ :id 42+ :lib/uuid arith-uuid-b+ :projection [[:dimension {} uuid-1]]}])+ ast (ast.build/from-definition definition)]++ (testing "projections are assigned to matching leaf sub-ASTs"+ (doseq [child (get-in ast [:expression :children])]+ (is (= 1 (count (get-in child [:ast :group-by]))))))))diff --git a/test/metabase/lib_metric/ast/compile_test.cljc b/test/metabase/lib_metric/ast/compile_test.cljcindex 3571eee8881..0481a7cfccf 100644--- a/test/metabase/lib_metric/ast/compile_test.cljc+++ b/test/metabase/lib_metric/ast/compile_test.cljc@@ -12,7 +12,7 @@(def ^:private dim-ref-2 {:node/type :ast/dimension-ref :dimension-id uuid-2 :options {:temporal-unit :month}})(def ^:private sample-ast- {:node/type :ast/root+ {:node/type :ast/source-query:source {:node/type :source/metric:id 42:name "Test Metric"@@ -36,8 +36,7 @@:table-id 100:column {:node/type :ast/column :id 2}}]:filter nil- :group-by []- :metadata-provider :test-provider})+ :group-by []});;; -------------------------------------------------- Basic Compilation --------------------------------------------------diff --git a/test/metabase/lib_metric/ast/plan_test.cljc b/test/metabase/lib_metric/ast/plan_test.cljcnew file mode 100644index 00000000000..9e6f6380d92--- /dev/null+++ b/test/metabase/lib_metric/ast/plan_test.cljc@@ -0,0 +1,233 @@+(ns metabase.lib-metric.ast.plan-test+ (:require+ [clojure.test :refer [deftest is testing]]+ [metabase.lib-metric.ast.plan :as ast.plan]))++;;; -------------------------------------------------- Test Data --------------------------------------------------++(def ^:private uuid-a "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")+(def ^:private uuid-b "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb")+(def ^:private uuid-c "cccccccc-cccc-cccc-cccc-cccccccccccc")+(def ^:private dim-1 "dddddddd-dddd-dddd-dddd-dddddddddd01")+(def ^:private dim-2 "dddddddd-dddd-dddd-dddd-dddddddddd02")++(defn- make-leaf-ast+ "Build a minimal single-source AST for testing.+ Includes dimension mappings so compile-to-mbql can resolve dimension refs."+ [group-by-dim-ids]+ {:node/type :ast/source-query+ :source {:node/type :source/metric+ :id 1+ :name "test"+ :aggregation {:node/type :aggregation/count}+ :base-table {:node/type :ast/table :id 1}+ :metadata {:dataset-query {:database 1}}}+ :dimensions (mapv (fn [dim-id] {:node/type :ast/dimension :id dim-id}) group-by-dim-ids)+ :mappings (mapv (fn [dim-id]+ {:node/type :ast/dimension-mapping+ :dimension-id dim-id+ :column {:node/type :ast/column :id 100}})+ group-by-dim-ids)+ :group-by (mapv (fn [dim-id] {:node/type :ast/dimension-ref :dimension-id dim-id})+ group-by-dim-ids)})++(defn- make-expression-leaf+ ([uuid group-by-dim-ids]+ {:node/type :expression/leaf+ :uuid uuid+ :ast (make-leaf-ast group-by-dim-ids)})+ ([uuid group-by-dim-ids dim-opts]+ {:node/type :expression/leaf+ :uuid uuid+ :ast (-> (make-leaf-ast group-by-dim-ids)+ (update :dimensions+ (fn [dims]+ (mapv (fn [dim]+ (merge dim (get dim-opts (:id dim))))+ dims)))+ (update :group-by+ (fn [refs]+ (mapv (fn [ref]+ (if-let [opts (get dim-opts (:dimension-id ref))]+ (cond-> ref+ (:temporal-unit opts) (assoc-in [:options :temporal-unit] (:temporal-unit opts)))+ ref))+ refs))))}))++(defn- make-expression-arithmetic [op children]+ {:node/type :expression/arithmetic+ :operator op+ :children children})++;;; -------------------------------------------------- evaluate-expression --------------------------------------------------++(deftest ^:parallel evaluate-expression-addition-test+ (testing "addition of two leaves"+ (let [expr (make-expression-arithmetic :+ [(make-expression-leaf uuid-a [])+ (make-expression-leaf uuid-b [])])]+ (is (= 30 (ast.plan/evaluate-expression expr {uuid-a 10 uuid-b 20}))))))++(deftest ^:parallel evaluate-expression-subtraction-test+ (testing "subtraction of two leaves"+ (let [expr (make-expression-arithmetic :- [(make-expression-leaf uuid-a [])+ (make-expression-leaf uuid-b [])])]+ (is (= -10 (ast.plan/evaluate-expression expr {uuid-a 10 uuid-b 20}))))))++(deftest ^:parallel evaluate-expression-multiplication-test+ (testing "multiplication of two leaves"+ (let [expr (make-expression-arithmetic :* [(make-expression-leaf uuid-a [])+ (make-expression-leaf uuid-b [])])]+ (is (= 200 (ast.plan/evaluate-expression expr {uuid-a 10 uuid-b 20}))))))++(deftest ^:parallel evaluate-expression-division-test+ (testing "division of two leaves"+ (let [expr (make-expression-arithmetic :/ [(make-expression-leaf uuid-a [])+ (make-expression-leaf uuid-b [])])]+ (is (= 0.5 (ast.plan/evaluate-expression expr {uuid-a 10 uuid-b 20}))))))++(deftest ^:parallel evaluate-expression-nested-test+ (testing "nested expression (a + b) * c"+ (let [inner (make-expression-arithmetic :+ [(make-expression-leaf uuid-a [])+ (make-expression-leaf uuid-b [])])+ expr (make-expression-arithmetic :* [inner+ (make-expression-leaf uuid-c [])])]+ (is (= 150 (ast.plan/evaluate-expression expr {uuid-a 10 uuid-b 20 uuid-c 5}))))))++(deftest ^:parallel evaluate-expression-nil-propagation-test+ (testing "nil input propagates as nil"+ (let [expr (make-expression-arithmetic :+ [(make-expression-leaf uuid-a [])+ (make-expression-leaf uuid-b [])])]+ (is (nil? (ast.plan/evaluate-expression expr {uuid-a 10 uuid-b nil})))+ (is (nil? (ast.plan/evaluate-expression expr {uuid-a nil uuid-b 20})))+ (is (nil? (ast.plan/evaluate-expression expr {uuid-a 10}))))))++(deftest ^:parallel evaluate-expression-constant-test+ (testing "constant node returns its value"+ (is (= 42 (ast.plan/evaluate-expression {:node/type :expression/constant :value 42} {})))))++(deftest ^:parallel evaluate-expression-leaf-times-constant-test+ (testing "leaf * constant evaluates correctly"+ (let [expr (make-expression-arithmetic :* [(make-expression-leaf uuid-a [])+ {:node/type :expression/constant :value 100}])]+ (is (= 500 (ast.plan/evaluate-expression expr {uuid-a 5}))))))++(deftest ^:parallel validate-arithmetic-ast-with-constants-test+ (testing "arithmetic with constants + leaves with projections passes validation"+ (let [expr (make-expression-arithmetic :* [(make-expression-leaf uuid-a [dim-1])+ {:node/type :expression/constant :value 100}])]+ (is (nil? (ast.plan/validate-arithmetic-ast! expr))))))++(deftest ^:parallel evaluate-expression-division-by-zero-test+ (testing "division by zero returns nil"+ (let [expr (make-expression-arithmetic :/ [(make-expression-leaf uuid-a [])+ (make-expression-leaf uuid-b [])])]+ (is (nil? (ast.plan/evaluate-expression expr {uuid-a 10 uuid-b 0}))))))++;;; -------------------------------------------------- index-result-by-dimensions --------------------------------------------------++(deftest ^:parallel index-result-by-dimensions-no-breakouts-test+ (testing "no breakout columns — single row, empty key"+ (let [result {:data {:rows [[42]]}}]+ (is (= {[] 42} (ast.plan/index-result-by-dimensions result 0))))))++(deftest ^:parallel index-result-by-dimensions-with-breakouts-test+ (testing "two breakout columns"+ (let [result {:data {:rows [["US" "NY" 100]+ ["US" "CA" 200]+ ["UK" "London" 50]]}}]+ (is (= {["US" "NY"] 100+ ["US" "CA"] 200+ ["UK" "London"] 50}+ (ast.plan/index-result-by-dimensions result 2))))))++;;; -------------------------------------------------- join-and-compute --------------------------------------------------++(deftest ^:parallel join-and-compute-inner-join-test+ (testing "inner join semantics — only matching dimension tuples"+ (let [expr (make-expression-arithmetic :+ [(make-expression-leaf uuid-a [dim-1])+ (make-expression-leaf uuid-b [dim-1])])+ leaf-results {uuid-a {:data {:cols [{:name "dim1"} {:name "count"}]+ :rows [["X" 10] ["Y" 20] ["Z" 30]]}}+ uuid-b {:data {:cols [{:name "dim1"} {:name "count"}]+ :rows [["X" 100] ["Y" 200] ["W" 400]]}}}+ result (ast.plan/join-and-compute expr leaf-results 1)]+ (is (= [["X" 110] ["Y" 220]]+ (:rows result))))))++(deftest ^:parallel join-and-compute-empty-results-test+ (testing "no matching tuples returns empty rows"+ (let [expr (make-expression-arithmetic :+ [(make-expression-leaf uuid-a [dim-1])+ (make-expression-leaf uuid-b [dim-1])])+ leaf-results {uuid-a {:data {:cols [{:name "dim1"} {:name "count"}]+ :rows [["X" 10]]}}+ uuid-b {:data {:cols [{:name "dim1"} {:name "count"}]+ :rows [["Y" 20]]}}}+ result (ast.plan/join-and-compute expr leaf-results 1)]+ (is (= [] (:rows result))))))++;;; -------------------------------------------------- validate-arithmetic-ast! --------------------------------------------------++(deftest ^:parallel validate-arithmetic-ast-mismatched-dims-test+ (testing "throws 400 when leaves have different number of breakout dimensions"+ (let [expr (make-expression-arithmetic :+ [(make-expression-leaf uuid-a [dim-1])+ (make-expression-leaf uuid-b [dim-1 dim-2])])]+ (is (thrown-with-msg?+ #?(:clj clojure.lang.ExceptionInfo :cljs js/Error)+ #"same number of breakout"+ (ast.plan/validate-arithmetic-ast! expr))))))++(deftest ^:parallel validate-arithmetic-ast-mismatched-types-test+ (testing "throws 400 when leaves have same count but different dimension types"+ (let [expr (make-expression-arithmetic+ :+ [(make-expression-leaf uuid-a [dim-1] {dim-1 {:effective-type :type/Integer}})+ (make-expression-leaf uuid-b [dim-1] {dim-1 {:effective-type :type/Text}})])]+ (is (thrown-with-msg?+ #?(:clj clojure.lang.ExceptionInfo :cljs js/Error)+ #"same breakout dimension types"+ (ast.plan/validate-arithmetic-ast! expr))))))++(deftest ^:parallel validate-arithmetic-ast-compatible-datetime-types-test+ (testing "accepts compatible date/datetime types across different databases"+ (let [expr (make-expression-arithmetic+ :+ [(make-expression-leaf uuid-a [dim-1] {dim-1 {:effective-type :type/Date}})+ (make-expression-leaf uuid-b [dim-1] {dim-1 {:effective-type :type/DateTimeWithLocalTZ}})])]+ (is (nil? (ast.plan/validate-arithmetic-ast! expr)))))+ (testing "rejects incompatible temporal types (date vs time)"+ (let [expr (make-expression-arithmetic+ :+ [(make-expression-leaf uuid-a [dim-1] {dim-1 {:effective-type :type/Date}})+ (make-expression-leaf uuid-b [dim-1] {dim-1 {:effective-type :type/Time}})])]+ (is (thrown-with-msg?+ #?(:clj clojure.lang.ExceptionInfo :cljs js/Error)+ #"same breakout dimension types"+ (ast.plan/validate-arithmetic-ast! expr))))))++(deftest ^:parallel validate-arithmetic-ast-valid-test+ (testing "valid arithmetic AST passes validation"+ (let [expr (make-expression-arithmetic :+ [(make-expression-leaf uuid-a [dim-1])+ (make-expression-leaf uuid-b [dim-1])])]+ (is (nil? (ast.plan/validate-arithmetic-ast! expr))))))++;;; -------------------------------------------------- plan-from-ast --------------------------------------------------++(deftest ^:parallel plan-from-ast-leaf-test+ (testing "single-source AST produces :leaf plan"+ (let [ast {:node/type :ast/root+ :expression {:node/type :expression/leaf+ :uuid uuid-a+ :ast (make-leaf-ast [dim-1])}}+ plan (ast.plan/plan-from-ast ast)]+ (is (= :leaf (:plan/type plan)))+ (is (some? (:plan/mbql plan))))))++(deftest ^:parallel plan-from-ast-arithmetic-test+ (testing "arithmetic AST produces :arithmetic plan"+ (let [expr (make-expression-arithmetic :+ [(make-expression-leaf uuid-a [dim-1])+ (make-expression-leaf uuid-b [dim-1])])+ ast {:node/type :ast/root+ :expression expr}+ plan (ast.plan/plan-from-ast ast)]+ (is (= :arithmetic (:plan/type plan)))+ (is (= 2 (count (:plan/leaves plan))))+ (is (= 1 (:plan/breakout-count plan)))+ (is (contains? (:plan/leaves plan) uuid-a))+ (is (contains? (:plan/leaves plan) uuid-b)))))diff --git a/test/metabase/lib_metric/ast/schema_test.cljc b/test/metabase/lib_metric/ast/schema_test.cljcindex 450b2a55fae..1d4cedcaead 100644--- a/test/metabase/lib_metric/ast/schema_test.cljc+++ b/test/metabase/lib_metric/ast/schema_test.cljc@@ -277,6 +277,48 @@:aggregation {:node/type :aggregation/count}:base-table {:node/type :ast/table :id 1}})))+;;; -------------------------------------------------- Expression Constant Nodes --------------------------------------------------++(deftest ^:parallel expression-constant-test+ (testing "valid expression constant nodes"+ (are [node] (nil? (me/humanize (mr/explain ::ast.schema/expression-constant node)))+ {:node/type :expression/constant :value 42}+ {:node/type :expression/constant :value 3.14}+ {:node/type :expression/constant :value -7}+ {:node/type :expression/constant :value 0}))+ (testing "invalid expression constant nodes"+ (testing "missing value"+ (is (some? (me/humanize (mr/explain ::ast.schema/expression-constant+ {:node/type :expression/constant})))))+ (testing "non-numeric value"+ (is (some? (me/humanize (mr/explain ::ast.schema/expression-constant+ {:node/type :expression/constant :value "nope"})))))))++(deftest ^:parallel expression-arithmetic-with-constant-children-test+ (let [source {:node/type :source/metric+ :id 1+ :aggregation {:node/type :aggregation/count}+ :base-table {:node/type :ast/table :id 1}}+ source-query {:node/type :ast/source-query+ :source source+ :dimensions []+ :mappings []}]+ (testing "arithmetic with constant children validates"+ (is (nil? (me/humanize (mr/explain ::ast.schema/expression-arithmetic+ {:node/type :expression/arithmetic+ :operator :*+ :children [{:node/type :expression/leaf+ :uuid "test-uuid"+ :ast source-query}+ {:node/type :expression/constant+ :value 100}]})))))))++(deftest ^:parallel expression-node-includes-constant-test+ (testing "expression-node union includes constants"+ (is (nil? (me/humanize (mr/explain ::ast.schema/expression-node+ {:node/type :expression/constant+ :value 42}))))))+;;; -------------------------------------------------- Root Node --------------------------------------------------(deftest ^:parallel ast-root-test@@ -287,31 +329,42 @@dim {:node/type :ast/dimension :id uuid-1}mapping {:node/type :ast/dimension-mapping:dimension-id uuid-1- :column {:node/type :ast/column :id 1}}]- (testing "valid root AST"+ :column {:node/type :ast/column :id 1}}+ source-query-simple {:node/type :ast/source-query+ :source source+ :dimensions []+ :mappings []}+ source-query-full {:node/type :ast/source-query+ :source source+ :dimensions [dim]+ :mappings [mapping]+ :filter {:node/type :filter/comparison+ :operator :=+ :dimension {:node/type :ast/dimension-ref :dimension-id uuid-1}+ :values ["test"]}+ :group-by [{:node/type :ast/dimension-ref :dimension-id uuid-1}]}]+ (testing "valid root AST with expression leaf"(are [node] (nil? (me/humanize (mr/explain ::ast.schema/ast node))){:node/type :ast/root- :source source- :dimensions []- :mappings []}- {:node/type :ast/root- :source source- :dimensions [dim]- :mappings [mapping]- :filter nil- :group-by []}+ :expression {:node/type :expression/leaf+ :uuid "test-uuid"+ :ast source-query-simple}}{:node/type :ast/root- :source source- :dimensions [dim]- :mappings [mapping]- :filter {:node/type :filter/comparison- :operator :=- :dimension {:node/type :ast/dimension-ref :dimension-id uuid-1}- :values ["test"]}- :group-by [{:node/type :ast/dimension-ref :dimension-id uuid-1}]}))+ :expression {:node/type :expression/leaf+ :uuid "test-uuid"+ :ast source-query-full}}))+ (testing "valid root AST with arithmetic expression"+ (is (nil? (me/humanize (mr/explain ::ast.schema/ast+ {:node/type :ast/root+ :expression {:node/type :expression/arithmetic+ :operator :++ :children [{:node/type :expression/leaf+ :uuid "uuid-a"+ :ast source-query-simple}+ {:node/type :expression/leaf+ :uuid "uuid-b"+ :ast source-query-simple}]}})))))(testing "invalid root AST"- (testing "missing source"+ (testing "missing expression"(is (some? (me/humanize (mr/explain ::ast.schema/ast- {:node/type :ast/root- :dimensions []- :mappings []}))))))))+ {:node/type :ast/root}))))))))diff --git a/test/metabase/lib_metric/ast/walk_test.cljc b/test/metabase/lib_metric/ast/walk_test.cljcindex d239e363114..33eb417b3d5 100644--- a/test/metabase/lib_metric/ast/walk_test.cljc+++ b/test/metabase/lib_metric/ast/walk_test.cljc@@ -60,8 +60,8 @@(def ^:private filter-b (comparison-filter :> dim-ref-2 10))(def ^:private filter-c (string-filter :contains dim-ref-1 "foo"))-(def ^:private sample-ast- {:node/type :ast/root+(def ^:private sample-source-query+ {:node/type :ast/source-query:source {:node/type :source/metric:id 1:aggregation {:node/type :aggregation/count}@@ -74,6 +74,12 @@:filter (and-filter filter-a filter-b):group-by [dim-ref-1]})+(def ^:private sample-ast+ {:node/type :ast/root+ :expression {:node/type :expression/leaf+ :uuid "test-uuid"+ :ast sample-source-query}})+;;; -------------------------------------------------- Predicates --------------------------------------------------(deftest ^:parallel node?-test@@ -179,7 +185,7 @@#(assoc % :transformed true)sample-ast)];; Original filters in :filter/and children should be transformed- (is (every? :transformed (get-in result [:filter :children]))))))+ (is (every? :transformed (get-in result [:expression :ast :filter :children]))))))(deftest ^:parallel transform-by-type-test(testing "transforms nodes by type"@@ -228,7 +234,7 @@placeholdersample-ast)];; filter-a had := operator, should be replaced- (is (= ["REPLACED"] (get-in result [:filter :children 0 :values]))))))+ (is (= ["REPLACED"] (get-in result [:expression :ast :filter :children 0 :values]))))))(deftest ^:parallel remove-filters-test(testing "removes matching filters from and"@@ -237,40 +243,42 @@sample-ast)];; filter-b had :> operator, should be removed;; Since only one child remains, :filter/and should be unwrapped- (is (= :filter/comparison (get-in result [:filter :node/type])))- (is (= := (get-in result [:filter :operator])))))+ (is (= :filter/comparison (get-in result [:expression :ast :filter :node/type])))+ (is (= := (get-in result [:expression :ast :filter :operator])))))(testing "removes all filters leaving nil"(let [all-comparison (ast.walk/remove-filters#(= :filter/comparison (:node/type %))sample-ast)]- (is (nil? (:filter all-comparison)))))+ (is (nil? (get-in all-comparison [:expression :ast :filter])))))(testing "handles nested compound filters"- (let [nested-ast (assoc sample-ast- :filter (and-filter- (or-filter filter-a filter-b)- filter-c))+ (let [nested-source-query (assoc sample-source-query+ :filter (and-filter+ (or-filter filter-a filter-b)+ filter-c))+ nested-ast (assoc-in sample-ast [:expression :ast] nested-source-query)result (ast.walk/remove-filters#(= :> (:operator %))nested-ast)];; filter-b removed from inner :or, leaving just filter-a;; Inner :or should unwrap to just filter-a- (is (= :filter/and (get-in result [:filter :node/type])))- (is (= 2 (count (get-in result [:filter :children]))))))+ (is (= :filter/and (get-in result [:expression :ast :filter :node/type])))+ (is (= 2 (count (get-in result [:expression :ast :filter :children]))))))(testing "handles nested compound where all inner children are removed"- (let [nested-ast (assoc sample-ast- :filter (and-filter- (or-filter filter-a filter-b)- filter-c))+ (let [nested-source-query (assoc sample-source-query+ :filter (and-filter+ (or-filter filter-a filter-b)+ filter-c))+ nested-ast (assoc-in sample-ast [:expression :ast] nested-source-query);; Remove all comparison filters — inner :or loses both children → nilresult (ast.walk/remove-filters#(= :filter/comparison (:node/type %))nested-ast)];; Only filter-c (string filter) should remain, :and unwrapped- (is (= :filter/string (get-in result [:filter :node/type])))- (is (= :contains (get-in result [:filter :operator]))))))+ (is (= :filter/string (get-in result [:expression :ast :filter :node/type])))+ (is (= :contains (get-in result [:expression :ast :filter :operator]))))));;; -------------------------------------------------- Complex Transformations --------------------------------------------------@@ -288,21 +296,51 @@(and-filter existing audit-filter)audit-filter))))sample-ast)]- (is (= audit-filter (get-in result [:source :filters]))))))+ (is (= audit-filter (get-in result [:expression :ast :source :filters]))))))++(deftest ^:parallel collect-constants-test+ (testing "collect with :expression/constant pred finds constants"+ (let [constant-node {:node/type :expression/constant :value 100}+ arith-ast {:node/type :ast/root+ :expression {:node/type :expression/arithmetic+ :operator :*+ :children [{:node/type :expression/leaf+ :uuid "test-uuid"+ :ast sample-source-query}+ constant-node]}}+ constants (ast.walk/collect #(= :expression/constant (:node/type %)) arith-ast)]+ (is (= 1 (count constants)))+ (is (= 100 (:value (first constants))))))+ (testing "collect with :expression/leaf pred excludes constants"+ (let [constant-node {:node/type :expression/constant :value 100}+ arith-ast {:node/type :ast/root+ :expression {:node/type :expression/arithmetic+ :operator :*+ :children [{:node/type :expression/leaf+ :uuid "test-uuid"+ :ast sample-source-query}+ constant-node]}}+ leaves (ast.walk/collect #(= :expression/leaf (:node/type %)) arith-ast)]+ (is (= 1 (count leaves)))+ (is (= "test-uuid" (:uuid (first leaves)))))))(deftest ^:parallel dimension-ref-collection-from-filters-test(testing "can collect dimension refs from filters only"- (let [filter-only-ast {:node/type :ast/root- :source (:source sample-ast)- :dimensions []- :mappings []- :filter (and-filter- (comparison-filter := dim-ref-1 1)- (comparison-filter := dim-ref-2 2)- (or-filter- (comparison-filter := dim-ref-1 3)- (comparison-filter := dim-ref-2 4)))- :group-by []}+ (let [filter-only-source-query {:node/type :ast/source-query+ :source (:source sample-source-query)+ :dimensions []+ :mappings []+ :filter (and-filter+ (comparison-filter := dim-ref-1 1)+ (comparison-filter := dim-ref-2 2)+ (or-filter+ (comparison-filter := dim-ref-1 3)+ (comparison-filter := dim-ref-2 4)))+ :group-by []}+ filter-only-ast {:node/type :ast/root+ :expression {:node/type :expression/leaf+ :uuid "filter-test-uuid"+ :ast filter-only-source-query}}refs (ast.walk/collect-dimension-refs filter-only-ast)](is (= 4 (count refs)))(is (= #{uuid-1 uuid-2} (set (map :dimension-id refs)))))))diff --git a/test/metabase/lib_metric/definition_test.cljc b/test/metabase/lib_metric/definition_test.cljcindex 664e76cd8a5..eda3d9cbe54 100644--- a/test/metabase/lib_metric/definition_test.cljc+++ b/test/metabase/lib_metric/definition_test.cljc@@ -240,6 +240,13 @@expr [:* {} inner leaf3]](is (= [leaf1 leaf2 leaf3] (lib-metric.definition/expression-leaves expr))))))+(deftest ^:parallel expression-leaves-with-constant-test+ (testing "arithmetic with constant returns only the metric leaf"+ (let [leaf [:metric {:lib/uuid "a"} 1]]+ (is (= [leaf] (lib-metric.definition/expression-leaves [:* {} leaf 100])))))+ (testing "bare number returns empty vector"+ (is (= [] (lib-metric.definition/expression-leaves 42)))))+(deftest ^:parallel expression-leaves-invalid-input-test(testing "nil returns empty vector"(is (= [] (lib-metric.definition/expression-leaves nil))))@@ -260,6 +267,106 @@(lib-metric.definition/expression-leaves [op {} leaf1 leaf2]))(str "operator " op " should be supported"))))))+;;; -------------------------------------------------- projection-valid? --------------------------------------------------++(deftest ^:parallel projection-valid?-single-leaf-no-projections-test+ (testing "single leaf with no projections is not valid"+ (let [definition (lib-metric.definition/from-metric-metadata mock-provider sample-metric-metadata)]+ (is (not (lib-metric.definition/projection-valid? definition))))))++(deftest ^:parallel projection-valid?-single-leaf-with-projection-test+ (testing "single leaf with a projection is valid"+ (let [definition (-> (lib-metric.definition/from-metric-metadata mock-provider sample-metric-metadata)+ (assoc :projections [{:type :metric :id 42+ :projection [[:dimension {} uuid-1]]}]))]+ (is (lib-metric.definition/projection-valid? definition)))))++(deftest ^:parallel projection-valid?-single-leaf-empty-projection-vector-test+ (testing "single leaf with empty projection vector is not valid"+ (let [definition (-> (lib-metric.definition/from-metric-metadata mock-provider sample-metric-metadata)+ (assoc :projections [{:type :metric :id 42+ :projection []}]))]+ (is (not (lib-metric.definition/projection-valid? definition))))))++(deftest ^:parallel projection-valid?-arithmetic-all-projected-test+ (testing "arithmetic expression with all leaves projected is valid"+ (let [definition {:lib/type :metric/definition+ :expression [:+ {} [:metric {:lib/uuid "a"} 1] [:measure {:lib/uuid "b"} 2]]+ :filters []+ :projections [{:type :metric :id 1 :projection [[:dimension {} uuid-1]]}+ {:type :measure :id 2 :projection [[:dimension {} uuid-2]]}]+ :metadata-provider mock-provider}]+ (is (lib-metric.definition/projection-valid? definition)))))++(deftest ^:parallel projection-valid?-arithmetic-one-missing-test+ (testing "arithmetic expression with one leaf missing projection is not valid"+ (let [definition {:lib/type :metric/definition+ :expression [:+ {} [:metric {:lib/uuid "a"} 1] [:measure {:lib/uuid "b"} 2]]+ :filters []+ :projections [{:type :metric :id 1 :projection [[:dimension {} uuid-1]]}]+ :metadata-provider mock-provider}]+ (is (not (lib-metric.definition/projection-valid? definition))))))++(deftest ^:parallel projection-valid?-constant-in-arithmetic-test+ (testing "only real leaves need projections when constants present"+ (let [definition {:lib/type :metric/definition+ :expression [:* {} [:metric {:lib/uuid "a"} 1] 100]+ :filters []+ :projections [{:type :metric :id 1 :projection [[:dimension {} uuid-1]]}]+ :metadata-provider mock-provider}]+ (is (lib-metric.definition/projection-valid? definition)))))++(deftest ^:parallel projection-valid?-wrong-type-match-test+ (testing "projection with wrong type does not match"+ (let [definition {:lib/type :metric/definition+ :expression [:metric {:lib/uuid "a"} 1]+ :filters []+ :projections [{:type :measure :id 1 :projection [[:dimension {} uuid-1]]}]+ :metadata-provider mock-provider}]+ (is (not (lib-metric.definition/projection-valid? definition))))))++;;; -------------------------------------------------- unprojected-sources --------------------------------------------------++(deftest ^:parallel unprojected-sources-single-leaf-no-projections-test+ (testing "single leaf with no projections returns the leaf"+ (let [definition (lib-metric.definition/from-metric-metadata mock-provider sample-metric-metadata)+ result (lib-metric.definition/unprojected-sources definition)]+ (is (= 1 (count result)))+ (is (= :metric (first (first result))))+ (is (= 42 (nth (first result) 2))))))++(deftest ^:parallel unprojected-sources-single-leaf-with-projection-test+ (testing "single leaf with projection returns empty"+ (let [definition (-> (lib-metric.definition/from-metric-metadata mock-provider sample-metric-metadata)+ (assoc :projections [{:type :metric :id 42+ :projection [[:dimension {} uuid-1]]}]))+ result (lib-metric.definition/unprojected-sources definition)]+ (is (empty? result)))))++(deftest ^:parallel unprojected-sources-arithmetic-one-missing-test+ (testing "arithmetic with one missing returns that leaf"+ (let [leaf-b [:measure {:lib/uuid "b"} 2]+ definition {:lib/type :metric/definition+ :expression [:+ {} [:metric {:lib/uuid "a"} 1] leaf-b]+ :filters []+ :projections [{:type :metric :id 1 :projection [[:dimension {} uuid-1]]}]+ :metadata-provider mock-provider}+ result (lib-metric.definition/unprojected-sources definition)]+ (is (= 1 (count result)))+ (is (= :measure (first (first result))))+ (is (= 2 (nth (first result) 2))))))++(deftest ^:parallel unprojected-sources-all-projected-test+ (testing "all sources projected returns empty"+ (let [definition {:lib/type :metric/definition+ :expression [:+ {} [:metric {:lib/uuid "a"} 1] [:measure {:lib/uuid "b"} 2]]+ :filters []+ :projections [{:type :metric :id 1 :projection [[:dimension {} uuid-1]]}+ {:type :measure :id 2 :projection [[:dimension {} uuid-2]]}]+ :metadata-provider mock-provider}+ result (lib-metric.definition/unprojected-sources definition)]+ (is (empty? result)))))+;;; -------------------------------------------------- Schema Validation --------------------------------------------------(deftest ^:parallel metric-definition-schema-testdiff --git a/test/metabase/metrics/api_arithmetic_test.clj b/test/metabase/metrics/api_arithmetic_test.cljnew file mode 100644index 00000000000..3d3f72756e9--- /dev/null+++ b/test/metabase/metrics/api_arithmetic_test.clj@@ -0,0 +1,320 @@+(ns metabase.metrics.api-arithmetic-test+ (:require+ [clojure.test :refer :all]+ [metabase.lib.core :as lib]+ [metabase.lib.metadata :as lib.metadata]+ [metabase.metrics.core :as metrics]+ [metabase.test :as mt]+ [metabase.test.fixtures :as fixtures]+ [toucan2.core :as t2]))++(use-fixtures :once (fixtures/initialize :db :web-server :test-users))++(deftest arithmetic-metric-plus-metric-test+ (testing "POST /api/metric/dataset with metric_A + metric_B returns correct sum"+ (mt/with-temp [:model/Card metric-a {:name "Metric A"+ :type :metric+ :dataset_query (mt/mbql-query venues {:aggregation [[:count]]})}+ :model/Card metric-b {:name "Metric B"+ :type :metric+ :dataset_query (mt/mbql-query venues {:aggregation [[:count]]})}]+ ;; Trigger dimension sync for both metrics+ (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric-a)))+ (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric-b)))+ ;; Get dimension UUIDs from each metric separately+ (let [metric-a-response (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric-a)))+ metric-b-response (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric-b)))+ dim-a-uuid (:id (first (:dimensions metric-a-response)))+ dim-b-uuid (:id (first (:dimensions metric-b-response)))+ response (mt/user-http-request :rasta :post 202 "metric/dataset"+ {:definition+ {:expression [:+ {}+ [:metric {:lib/uuid "a"} (:id metric-a)]+ [:metric {:lib/uuid "b"} (:id metric-b)]]+ :projections [{:type :metric :id (:id metric-a) :lib/uuid "a"+ :projection [[:dimension {} dim-a-uuid]]}+ {:type :metric :id (:id metric-b) :lib/uuid "b"+ :projection [[:dimension {} dim-b-uuid]]}]}})]+ (is (= "completed" (:status response)))+ (is (pos? (:row_count response)))+ ;; Each row should have [dim-value, sum] where sum is a+b for that dimension value+ (is (every? #(= 2 (count %)) (get-in response [:data :rows])))))))++(deftest arithmetic-subtraction-test+ (testing "POST /api/metric/dataset with metric_A - metric_B"+ (mt/with-temp [:model/Card metric-a {:name "Metric A"+ :type :metric+ :dataset_query (mt/mbql-query venues {:aggregation [[:count]]})}+ :model/Card metric-b {:name "Metric B"+ :type :metric+ :dataset_query (mt/mbql-query venues {:aggregation [[:count]]})}]+ (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric-a)))+ (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric-b)))+ (let [metric-a-response (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric-a)))+ metric-b-response (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric-b)))+ dim-a-uuid (:id (first (:dimensions metric-a-response)))+ dim-b-uuid (:id (first (:dimensions metric-b-response)))+ response (mt/user-http-request :rasta :post 202 "metric/dataset"+ {:definition+ {:expression [:- {}+ [:metric {:lib/uuid "a"} (:id metric-a)]+ [:metric {:lib/uuid "b"} (:id metric-b)]]+ :projections [{:type :metric :id (:id metric-a) :lib/uuid "a"+ :projection [[:dimension {} dim-a-uuid]]}+ {:type :metric :id (:id metric-b) :lib/uuid "b"+ :projection [[:dimension {} dim-b-uuid]]}]}})]+ (is (= "completed" (:status response)))+ ;; Same query minus itself: all values should be 0+ (is (every? #(zero? (last %)) (get-in response [:data :rows])))))))++(deftest arithmetic-with-instance-filters-test+ (testing "POST /api/metric/dataset with instance filters on arithmetic"+ (mt/with-temp [:model/Card metric {:name "Test Metric"+ :type :metric+ :dataset_query (mt/mbql-query venues {:aggregation [[:count]]})}]+ (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric)))+ (let [metric-response (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric)))+ dim (first (:dimensions metric-response))+ dim-uuid (:id dim)+ response (mt/user-http-request :rasta :post 202 "metric/dataset"+ {:definition+ {:expression [:- {}+ [:metric {:lib/uuid "a"} (:id metric)]+ [:metric {:lib/uuid "b"} (:id metric)]]+ :filters [{:lib/uuid "a"+ :filter [:= {} [:dimension {} dim-uuid] 1]}]+ :projections [{:type :metric :id (:id metric) :lib/uuid "a"+ :projection [[:dimension {} dim-uuid]]}+ {:type :metric :id (:id metric) :lib/uuid "b"+ :projection [[:dimension {} dim-uuid]]}]}})]+ (is (= "completed" (:status response)))))))++(deftest arithmetic-missing-projections-test+ (testing "POST /api/metric/dataset arithmetic without projections returns scalar result"+ (mt/with-temp [:model/Card metric {:name "Test Metric"+ :type :metric+ :dataset_query (mt/mbql-query venues {:aggregation [[:count]]})}]+ (let [response (mt/user-http-request :rasta :post 202 "metric/dataset"+ {:definition+ {:expression [:+ {}+ [:metric {:lib/uuid "a"} (:id metric)]+ [:metric {:lib/uuid "b"} (:id metric)]]}})]+ (is (= "completed" (:status response)))+ (is (= 1 (:row_count response)))))))+(deftest arithmetic-nested-expression-test+ (testing "POST /api/metric/dataset with nested (A + B) * C"+ (mt/with-temp [:model/Card metric {:name "Test Metric"+ :type :metric+ :dataset_query (mt/mbql-query venues {:aggregation [[:count]]})}]+ (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric)))+ (let [metric-response (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric)))+ dim (first (:dimensions metric-response))+ dim-uuid (:id dim)+ _ (assert dim-uuid (str "No dimension found in metric response: " (pr-str (:dimensions metric-response))))+ response (mt/user-http-request :rasta :post 202 "metric/dataset"+ {:definition+ {:expression [:* {}+ [:+ {}+ [:metric {:lib/uuid "a"} (:id metric)]+ [:metric {:lib/uuid "b"} (:id metric)]]+ [:metric {:lib/uuid "c"} (:id metric)]]+ :projections [{:type :metric :id (:id metric) :lib/uuid "a"+ :projection [[:dimension {} dim-uuid]]}+ {:type :metric :id (:id metric) :lib/uuid "b"+ :projection [[:dimension {} dim-uuid]]}+ {:type :metric :id (:id metric) :lib/uuid "c"+ :projection [[:dimension {} dim-uuid]]}]}})]+ (is (= "completed" (:status response)))+ (is (pos? (:row_count response)))))))++(deftest arithmetic-metric-times-constant-test+ (testing "POST /api/metric/dataset with [:* {} [:metric ...] 2] returns correct results"+ (mt/with-temp [:model/Card metric {:name "Test Metric"+ :type :metric+ :dataset_query (mt/mbql-query venues {:aggregation [[:count]]})}]+ (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric)))+ (let [metric-response (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric)))+ dim-uuid (:id (first (:dimensions metric-response)))+ response (mt/user-http-request :rasta :post 202 "metric/dataset"+ {:definition+ {:expression [:* {}+ [:metric {:lib/uuid "a"} (:id metric)]+ 2]+ :projections [{:type :metric :id (:id metric) :lib/uuid "a"+ :projection [[:dimension {} dim-uuid]]}]}})]+ (is (= "completed" (:status response)))+ (is (pos? (:row_count response)))+ ;; Each result should be exactly double the count+ (let [single-response (mt/user-http-request :rasta :post 202 "metric/dataset"+ {:definition+ {:expression [:metric {:lib/uuid "x"} (:id metric)]+ :projections [{:type :metric :id (:id metric) :lib/uuid "x"+ :projection [[:dimension {} dim-uuid]]}]}})+ single-rows (into {} (map (fn [[k v]] [k v]) (get-in single-response [:data :rows])))+ double-rows (into {} (map (fn [[k v]] [k v]) (get-in response [:data :rows])))]+ (doseq [[dim-val single-val] single-rows]+ (is (= (* 2 single-val) (get double-rows dim-val))+ (str "Value for " dim-val " should be doubled"))))))))++(deftest arithmetic-nested-values-test+ (testing "POST /api/metric/dataset nested (A + A) * 2 returns 4N per row"+ (mt/with-temp [:model/Card metric {:name "Test Metric"+ :type :metric+ :dataset_query (mt/mbql-query venues {:aggregation [[:count]]})}]+ (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric)))+ (let [metric-response (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric)))+ dim-uuid (:id (first (:dimensions metric-response)))+ baseline (mt/user-http-request :rasta :post 202 "metric/dataset"+ {:definition+ {:expression [:metric {:lib/uuid "x"} (:id metric)]+ :projections [{:type :metric :id (:id metric) :lib/uuid "x"+ :projection [[:dimension {} dim-uuid]]}]}})+ response (mt/user-http-request :rasta :post 202 "metric/dataset"+ {:definition+ {:expression [:* {}+ [:+ {}+ [:metric {:lib/uuid "a"} (:id metric)]+ [:metric {:lib/uuid "b"} (:id metric)]]+ 2]+ :projections [{:type :metric :id (:id metric) :lib/uuid "a"+ :projection [[:dimension {} dim-uuid]]}+ {:type :metric :id (:id metric) :lib/uuid "b"+ :projection [[:dimension {} dim-uuid]]}]}})]+ (is (= "completed" (:status response)))+ (is (pos? (:row_count response)))+ (let [base-rows (into {} (map (fn [[k v]] [k v]) (get-in baseline [:data :rows])))+ nested-rows (into {} (map (fn [[k v]] [k v]) (get-in response [:data :rows])))]+ (doseq [[dim-val base-val] base-rows]+ (is (= (* 4 base-val) (get nested-rows dim-val))+ (str "Value for " dim-val " should be 4N"))))))))++(deftest arithmetic-associativity-test+ (testing "POST /api/metric/dataset nesting position affects result"+ (mt/with-temp [:model/Card metric {:name "Test Metric"+ :type :metric+ :dataset_query (mt/mbql-query venues {:aggregation [[:count]]})}]+ (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric)))+ (let [metric-response (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric)))+ dim-uuid (:id (first (:dimensions metric-response)))+ projections [{:type :metric :id (:id metric) :lib/uuid "a"+ :projection [[:dimension {} dim-uuid]]}+ {:type :metric :id (:id metric) :lib/uuid "b"+ :projection [[:dimension {} dim-uuid]]}]+ ;; A / (A / 2) = N / (N/2) = 2.0+ response-a (mt/user-http-request :rasta :post 202 "metric/dataset"+ {:definition+ {:expression [:/ {}+ [:metric {:lib/uuid "a"} (:id metric)]+ [:/ {}+ [:metric {:lib/uuid "b"} (:id metric)]+ 2]]+ :projections projections}})+ ;; (A / A) / 2 = (N/N) / 2 = 0.5+ response-b (mt/user-http-request :rasta :post 202 "metric/dataset"+ {:definition+ {:expression [:/ {}+ [:/ {}+ [:metric {:lib/uuid "a"} (:id metric)]+ [:metric {:lib/uuid "b"} (:id metric)]]+ 2]+ :projections projections}})]+ (is (= "completed" (:status response-a)))+ (is (= "completed" (:status response-b)))+ (let [rows-a (into {} (map (fn [[k v]] [k (double v)]) (get-in response-a [:data :rows])))+ rows-b (into {} (map (fn [[k v]] [k (double v)]) (get-in response-b [:data :rows])))]+ (doseq [[dim-val val-a] rows-a]+ (is (= 2.0 val-a) (str "A/(A/2) should be 2.0 for " dim-val))+ (is (= 0.5 (get rows-b dim-val)) (str "(A/A)/2 should be 0.5 for " dim-val))))))))++(deftest arithmetic-deeply-nested-test+ (testing "POST /api/metric/dataset with 3-level nesting ((A + A) * A) / 2 = N²"+ (mt/with-temp [:model/Card metric {:name "Test Metric"+ :type :metric+ :dataset_query (mt/mbql-query venues {:aggregation [[:count]]})}]+ (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric)))+ (let [metric-response (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric)))+ dim-uuid (:id (first (:dimensions metric-response)))+ baseline (mt/user-http-request :rasta :post 202 "metric/dataset"+ {:definition+ {:expression [:metric {:lib/uuid "x"} (:id metric)]+ :projections [{:type :metric :id (:id metric) :lib/uuid "x"+ :projection [[:dimension {} dim-uuid]]}]}})+ response (mt/user-http-request :rasta :post 202 "metric/dataset"+ {:definition+ {:expression [:/ {}+ [:* {}+ [:+ {}+ [:metric {:lib/uuid "a"} (:id metric)]+ [:metric {:lib/uuid "b"} (:id metric)]]+ [:metric {:lib/uuid "c"} (:id metric)]]+ 2]+ :projections [{:type :metric :id (:id metric) :lib/uuid "a"+ :projection [[:dimension {} dim-uuid]]}+ {:type :metric :id (:id metric) :lib/uuid "b"+ :projection [[:dimension {} dim-uuid]]}+ {:type :metric :id (:id metric) :lib/uuid "c"+ :projection [[:dimension {} dim-uuid]]}]}})]+ (is (= "completed" (:status response)))+ (is (pos? (:row_count response)))+ (let [base-rows (into {} (map (fn [[k v]] [k (double v)]) (get-in baseline [:data :rows])))+ deep-rows (into {} (map (fn [[k v]] [k (double v)]) (get-in response [:data :rows])))]+ (doseq [[dim-val base-val] base-rows]+ (is (= (* base-val base-val) (get deep-rows dim-val))+ (str "((A+A)*A)/2 should be N² for " dim-val))))))))++(deftest arithmetic-nested-division-by-zero-test+ (testing "POST /api/metric/dataset A / (A - A) returns 0 rows (zero guard)"+ (mt/with-temp [:model/Card metric {:name "Test Metric"+ :type :metric+ :dataset_query (mt/mbql-query venues {:aggregation [[:count]]})}]+ (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric)))+ (let [metric-response (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric)))+ dim-uuid (:id (first (:dimensions metric-response)))+ response (mt/user-http-request :rasta :post 202 "metric/dataset"+ {:definition+ {:expression [:/ {}+ [:metric {:lib/uuid "a"} (:id metric)]+ [:- {}+ [:metric {:lib/uuid "b"} (:id metric)]+ [:metric {:lib/uuid "c"} (:id metric)]]]+ :projections [{:type :metric :id (:id metric) :lib/uuid "a"+ :projection [[:dimension {} dim-uuid]]}+ {:type :metric :id (:id metric) :lib/uuid "b"+ :projection [[:dimension {} dim-uuid]]}+ {:type :metric :id (:id metric) :lib/uuid "c"+ :projection [[:dimension {} dim-uuid]]}]}})]+ (is (= "completed" (:status response)))+ (is (zero? (:row_count response)))))))++(deftest arithmetic-mixed-metric-measure-test+ (testing "POST /api/metric/dataset with metric + measure arithmetic"+ (let [mp (mt/metadata-provider)+ table-metadata (lib.metadata/table mp (mt/id :venues))+ pmbql-def (-> (lib/query mp table-metadata)+ (lib/aggregate (lib/count)))]+ (mt/with-temp [:model/Card metric {:name "Test Metric"+ :type :metric+ :dataset_query (mt/mbql-query venues {:aggregation [[:count]]})}+ :model/Measure measure {:name "Test Measure"+ :table_id (mt/id :venues)+ :definition pmbql-def}]+ (mt/with-full-data-perms-for-all-users!+ ;; Sync dimensions for both metric and measure+ (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric)))+ (metrics/sync-dimensions! :metadata/measure (:id measure))+ ;; Get dimension UUIDs from each entity+ (let [metric-response (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric)))+ dim-metric-uuid (:id (first (:dimensions metric-response)))+ measure-entity (t2/select-one :model/Measure :id (:id measure))+ dim-measure-uuid (:id (first (:dimensions measure-entity)))+ response (mt/user-http-request :rasta :post 202 "metric/dataset"+ {:definition+ {:expression [:+ {}+ [:metric {:lib/uuid "a"} (:id metric)]+ [:measure {:lib/uuid "b"} (:id measure)]]+ :projections [{:type :metric :id (:id metric) :lib/uuid "a"+ :projection [[:dimension {} dim-metric-uuid]]}+ {:type :measure :id (:id measure) :lib/uuid "b"+ :projection [[:dimension {} dim-measure-uuid]]}]}})]+ (is (= "completed" (:status response)))+ (is (pos? (:row_count response)))))))))diff --git a/test/metabase/metrics/api_math_test.clj b/test/metabase/metrics/api_math_test.cljindex e7c62b50036..e64bfabf47f 100644--- a/test/metabase/metrics/api_math_test.clj+++ b/test/metabase/metrics/api_math_test.clj@@ -194,3 +194,39 @@(is (= 42 (:id decoded)))(is (= "abc" (:lib/uuid decoded)))(is (= 1 (count (:projection decoded)))))))++;;; +----------------------------------------------------------------------------------------------------------------++;;; | Numeric Constant Tests |+;;; +----------------------------------------------------------------------------------------------------------------+++(deftest bare-integer-constant-test+ (testing "A bare integer is a valid expression"+ (is (valid? ::lib-metric.schema/metric-math-expression 42))))++(deftest bare-float-constant-test+ (testing "A bare float is a valid expression"+ (is (valid? ::lib-metric.schema/metric-math-expression 3.14))))++(deftest constant-in-arithmetic-test+ (testing "Constant as operand in arithmetic is valid"+ (is (valid? ::lib-metric.schema/metric-math-expression+ [:* {} [:metric {:lib/uuid "a"} 1] 100]))))++(deftest nested-constant-in-arithmetic-test+ (testing "Constant in nested arithmetic is valid"+ (is (valid? ::lib-metric.schema/metric-math-expression+ [:/ {} [:metric {:lib/uuid "a"} 1] [:- {} [:metric {:lib/uuid "b"} 2] 10]]))))++(deftest valid-definition-with-constant-test+ (testing "Valid definition with constant in arithmetic (no projection needed for constant)"+ (is (valid-definition?+ {:expression [:* {} [:metric {:lib/uuid "a"} 42] 100]+ :projections [{:type :metric+ :id 42+ :lib/uuid "a"+ :projection [[:dimension {} "550e8400-e29b-41d4-a716-446655440001"]]}]}))))++(deftest normalize-json-number-passthrough-test+ (testing "JSON number passes through normalization unchanged"+ (let [decoded (decode ::lib-metric.schema/metric-math-expression 42)]+ (is (= 42 decoded)))))