Skip to content

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

Move `metabase/metrics-viewer` to the feature tier (#75775)

Romeo Van Snick97c046ec87a1
diff --git a/frontend/lint/module-boundaries.mjs b/frontend/lint/module-boundaries.mjs
index a31b4d9b0ec..f89f7b506e0 100644
--- a/frontend/lint/module-boundaries.mjs
+++ b/frontend/lint/module-boundaries.mjs
@@ -96,7 +96,7 @@ const elements = [
createElement({ type: "shared", name: "metabot" }),
createElement({ type: "shared", name: "metadata" }),
createElement({ type: "shared", name: "metrics" }),
- createElement({ type: "shared", name: "metrics-viewer" }),
+ createElement({ type: "feature", name: "metrics-viewer" }),
createElement({ type: "feature", name: "models" }),
createElement({ type: "shared", name: "new" }),
createElement({ type: "shared", name: "notifications" }),
diff --git a/frontend/src/metabase/metrics-viewer/utils/compact-schema.ts b/frontend/src/metabase/common/metrics-viewer/compact-schema.ts
similarity index 100%
rename from frontend/src/metabase/metrics-viewer/utils/compact-schema.ts
rename to frontend/src/metabase/common/metrics-viewer/compact-schema.ts
diff --git a/frontend/src/metabase/metrics-viewer/utils/compact-schema.unit.spec.ts b/frontend/src/metabase/common/metrics-viewer/compact-schema.unit.spec.ts
similarity index 100%
rename from frontend/src/metabase/metrics-viewer/utils/compact-schema.unit.spec.ts
rename to frontend/src/metabase/common/metrics-viewer/compact-schema.unit.spec.ts
diff --git a/frontend/src/metabase/common/metrics-viewer/index.ts b/frontend/src/metabase/common/metrics-viewer/index.ts
new file mode 100644
index 00000000000..45d9a8e03a9
--- /dev/null
+++ b/frontend/src/metabase/common/metrics-viewer/index.ts
@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./url-state";
+export * from "./compact-schema";
diff --git a/frontend/src/metabase/common/metrics-viewer/types.ts b/frontend/src/metabase/common/metrics-viewer/types.ts
new file mode 100644
index 00000000000..005fc66793a
--- /dev/null
+++ b/frontend/src/metabase/common/metrics-viewer/types.ts
@@ -0,0 +1,67 @@
+import type { DimensionType } from "metabase/metrics/common/utils/dimension-types";
+import type {
+ BooleanFilterParts,
+ CoordinateFilterParts,
+ DefaultFilterParts,
+ ExcludeDateFilterParts,
+ NumberFilterParts,
+ RelativeDateFilterParts,
+ SpecificDateFilterParts,
+ StringFilterParts,
+ TimeFilterParts,
+} from "metabase-lib/metric";
+import type { CardDisplayType } from "metabase-types/api";
+
+export type MetricsViewerDisplayType = Extract<
+ CardDisplayType,
+ "line" | "area" | "bar" | "map" | "scatter" | "scalar"
+>;
+
+export type MetricsViewerDimensionBreakoutType = DimensionType | "scalar";
+
+// ── Dimension filter value (serializable, dimension-free) ──
+
+export type DimensionFilterValue =
+ | {
+ type: "string";
+ operator: StringFilterParts["operator"];
+ values: string[];
+ options: StringFilterParts["options"];
+ }
+ | {
+ type: "boolean";
+ operator: BooleanFilterParts["operator"];
+ values: boolean[];
+ }
+ | {
+ type: "number";
+ operator: NumberFilterParts["operator"];
+ values: NumberFilterParts["values"];
+ }
+ | {
+ type: "coordinate";
+ operator: CoordinateFilterParts["operator"];
+ values: CoordinateFilterParts["values"];
+ }
+ | {
+ type: "specific-date";
+ operator: SpecificDateFilterParts["operator"];
+ values: Date[];
+ hasTime: boolean;
+ }
+ | {
+ type: "relative-date";
+ unit: RelativeDateFilterParts["unit"];
+ value: number;
+ offsetUnit: RelativeDateFilterParts["offsetUnit"];
+ offsetValue: RelativeDateFilterParts["offsetValue"];
+ options: RelativeDateFilterParts["options"];
+ }
+ | {
+ type: "exclude-date";
+ operator: ExcludeDateFilterParts["operator"];
+ unit: ExcludeDateFilterParts["unit"];
+ values: number[];
+ }
+ | { type: "time"; operator: TimeFilterParts["operator"]; values: Date[] }
+ | { type: "default"; operator: DefaultFilterParts["operator"] };
diff --git a/frontend/src/metabase/common/metrics-viewer/url-state.ts b/frontend/src/metabase/common/metrics-viewer/url-state.ts
new file mode 100644
index 00000000000..42ae903dc84
--- /dev/null
+++ b/frontend/src/metabase/common/metrics-viewer/url-state.ts
@@ -0,0 +1,275 @@
+import { b64url_to_utf8, utf8_to_b64url } from "metabase/utils/encoding";
+import type {
+ MathOperator,
+ SegmentId,
+ TemporalUnit,
+ VisualizationSettings,
+} from "metabase-types/api";
+
+import { defineCompactSchema } from "./compact-schema";
+import type {
+ DimensionFilterValue,
+ MetricsViewerDimensionBreakoutType,
+ MetricsViewerDisplayType,
+} from "./types";
+
+function reviveFilter(filter: DimensionFilterValue): DimensionFilterValue {
+ if (filter.type === "specific-date" || filter.type === "time") {
+ return {
+ ...filter,
+ values: filter.values.map((value) =>
+ typeof value === "string" ? new Date(value) : value,
+ ),
+ };
+ } else if (filter.type === "number" || filter.type === "coordinate") {
+ return {
+ ...filter,
+ values: filter.values.map((value) =>
+ typeof value === "string" ? BigInt(value) : value,
+ ),
+ };
+ }
+ 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[];
+ segments?: SegmentId[];
+}
+
+// ── Serialized types (internal, URL-facing) ──
+
+export interface SerializedExpressionSubToken {
+ type: "metric" | "constant" | "operator" | "open-paren" | "close-paren";
+ sourceId?: string;
+ op?: MathOperator;
+ value?: number;
+ filters?: SerializedUrlFilter[];
+ segments?: SegmentId[];
+}
+
+export interface SerializedExpressionEntry {
+ type: "expression";
+ id: string;
+ name: string;
+ tokens: SerializedExpressionSubToken[];
+}
+
+export interface SerializedUrlFilter {
+ dimensionId: string;
+ value: DimensionFilterValue;
+}
+
+export interface SerializedSource {
+ type: "metric" | "measure";
+ id: number;
+ breakout?: string;
+ breakoutTemporalUnit?: TemporalUnit;
+ breakoutBinning?: string;
+ filters?: SerializedUrlFilter[];
+ segments?: SegmentId[];
+}
+
+export type SerializedFormulaEntity =
+ | SerializedExpressionEntry
+ | SerializedSource;
+
+export interface SerializedDimensionBreakoutDef {
+ slotIndex: number;
+ dimensionId?: string;
+}
+
+export interface SerializedProjectionConfig {
+ dimensionFilter?: DimensionFilterValue;
+ temporalUnit?: TemporalUnit;
+ binning?: string;
+}
+
+export interface SerializedDimensionBreakout {
+ id: string;
+ type: MetricsViewerDimensionBreakoutType;
+ label: string | null;
+ display: MetricsViewerDisplayType;
+ showColumnLabels?: boolean;
+ visualizationSettings?: Partial<VisualizationSettings>;
+ definitions: SerializedDimensionBreakoutDef[];
+ projectionConfig?: SerializedProjectionConfig;
+}
+
+export interface SerializedMetricsViewerPageState {
+ formulaEntities: SerializedFormulaEntity[];
+ dimensionBreakouts: SerializedDimensionBreakout[];
+ selectedDimensionBreakoutId: string | null;
+ showColumnLabels?: boolean;
+}
+
+// ── Compact schemas ──
+
+const sourceFilterSchema = defineCompactSchema<SerializedUrlFilter>({
+ dimensionId: "d",
+ value: { key: "v" },
+});
+
+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 },
+ segments: { key: "S", 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 },
+ segments: { key: "s", optional: true },
+ name: { key: "n", optional: true },
+ tokens: { key: "T", schema: expressionSubTokenSchema, optional: true },
+});
+
+const dimensionBreakoutDefSchema =
+ defineCompactSchema<SerializedDimensionBreakoutDef>({
+ slotIndex: "i",
+ dimensionId: { key: "d", optional: true },
+ });
+
+const projectionConfigSchema = defineCompactSchema<SerializedProjectionConfig>({
+ dimensionFilter: { key: "f", optional: true },
+ temporalUnit: { key: "u", optional: true },
+ binning: { key: "b", optional: true },
+});
+
+const dimensionBreakoutSchema =
+ defineCompactSchema<SerializedDimensionBreakout>({
+ id: "i",
+ type: "t",
+ label: { key: "l", default: null },
+ display: { key: "d", default: "line" },
+ showColumnLabels: { key: "c", optional: true },
+ visualizationSettings: { key: "V", optional: true },
+ definitions: {
+ key: "D",
+ schema: dimensionBreakoutDefSchema,
+ default: [],
+ },
+ projectionConfig: {
+ key: "p",
+ schema: projectionConfigSchema,
+ optional: true,
+ },
+ });
+
+const rootSchema = defineCompactSchema<SerializedMetricsViewerPageState>({
+ formulaEntities: { key: "f", schema: formulaEntitySchema, default: [] },
+ dimensionBreakouts: {
+ key: "t",
+ schema: dimensionBreakoutSchema,
+ default: [],
+ },
+ selectedDimensionBreakoutId: { key: "a", default: null },
+ showColumnLabels: { key: "c", optional: true },
+});
+
+// ── Encode / decode ──
+
+function emptyState(): SerializedMetricsViewerPageState {
+ return {
+ formulaEntities: [],
+ dimensionBreakouts: [],
+ selectedDimensionBreakoutId: null,
+ showColumnLabels: false,
+ };
+}
+
+// After JSON.parse, Date values are ISO strings. Walk the decoded state and revive them.
+function reviveStateDates(
+ state: SerializedMetricsViewerPageState,
+): SerializedMetricsViewerPageState {
+ return {
+ ...state,
+ 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;
+ }),
+ dimensionBreakouts: state.dimensionBreakouts.map((dimensionBreakout) =>
+ dimensionBreakout.projectionConfig?.dimensionFilter
+ ? {
+ ...dimensionBreakout,
+ projectionConfig: {
+ ...dimensionBreakout.projectionConfig,
+ dimensionFilter: reviveFilter(
+ dimensionBreakout.projectionConfig.dimensionFilter,
+ ),
+ },
+ }
+ : dimensionBreakout,
+ ),
+ };
+}
+
+export function encodeState(
+ state: SerializedMetricsViewerPageState,
+): string | undefined {
+ try {
+ return utf8_to_b64url(
+ JSON.stringify(rootSchema.compact(state), (_, value) =>
+ typeof value === "bigint" ? String(value) : value,
+ ),
+ );
+ } catch (err) {
+ console.error("Failed to encode metrics viewer URL state:", err);
+ return undefined;
+ }
+}
+
+export function decodeState(hash: string): SerializedMetricsViewerPageState {
+ if (!hash) {
+ return emptyState();
+ }
+
+ try {
+ const state =
+ rootSchema.expand(JSON.parse(b64url_to_utf8(hash))) ?? emptyState();
+ return reviveStateDates(state);
+ } catch (err) {
+ console.warn("Failed to decode metrics viewer URL state:", err);
+ return emptyState();
+ }
+}
diff --git a/frontend/src/metabase/metrics-viewer/types/viewer-state.ts b/frontend/src/metabase/metrics-viewer/types/viewer-state.ts
index d3224bb8aaf..edc2f720459 100644
--- a/frontend/src/metabase/metrics-viewer/types/viewer-state.ts
+++ b/frontend/src/metabase/metrics-viewer/types/viewer-state.ts
@@ -1,14 +1,15 @@
import type {
- DimensionType,
- GeoSubtype,
-} from "metabase/metrics/common/utils/dimension-types";
+ MetricsViewerDimensionBreakoutType,
+ MetricsViewerDisplayType,
+ SerializedDefinitionInfo,
+} from "metabase/common/metrics-viewer";
+import type { GeoSubtype } from "metabase/metrics/common/utils/dimension-types";
import type {
DimensionGroup,
MetricDefinition,
ProjectionClause,
} from "metabase-lib/metric";
import type {
- CardDisplayType,
CardId,
DimensionId,
IconName,
@@ -20,20 +21,17 @@ import type {
import type { DimensionFilterValue } from "../utils/dimension-filters";
import type { MetricSlot } from "../utils/metric-slots";
-import type { SerializedDefinitionInfo } from "../utils/url-serialization";
-// ── Core types ──
+export type {
+ MetricsViewerDimensionBreakoutType,
+ MetricsViewerDisplayType,
+} from "metabase/common/metrics-viewer";
-export type MetricsViewerDisplayType = Extract<
- CardDisplayType,
- "line" | "area" | "bar" | "map" | "scatter" | "scalar"
->;
+// ── Core types ──
export type MetricSourceId = `metric:${number}` | `measure:${number}`;
export type MetricExpressionId = `expression:${string}`;
-export type MetricsViewerDimensionBreakoutType = DimensionType | "scalar";
-
export interface StoredMetricsViewerDimensionBreakout {
id: string;
type: MetricsViewerDimensionBreakoutType;
diff --git a/frontend/src/metabase/metrics-viewer/utils/dimension-filters.ts b/frontend/src/metabase/metrics-viewer/utils/dimension-filters.ts
index 022ff84bd64..550a46acc08 100644
--- a/frontend/src/metabase/metrics-viewer/utils/dimension-filters.ts
+++ b/frontend/src/metabase/metrics-viewer/utils/dimension-filters.ts
@@ -1,65 +1,12 @@
+import type { DimensionFilterValue } from "metabase/common/metrics-viewer";
import type {
- BooleanFilterParts,
- CoordinateFilterParts,
- DefaultFilterParts,
DimensionMetadata,
- ExcludeDateFilterParts,
FilterClause,
MetricDefinition,
- NumberFilterParts,
- RelativeDateFilterParts,
- SpecificDateFilterParts,
- StringFilterParts,
- TimeFilterParts,
} from "metabase-lib/metric";
import * as LibMetric from "metabase-lib/metric";
-// ── Dimension filter value (serializable, dimension-free) ──
-
-export type DimensionFilterValue =
- | {
- type: "string";
- operator: StringFilterParts["operator"];
- values: string[];
- options: StringFilterParts["options"];
- }
- | {
- type: "boolean";
- operator: BooleanFilterParts["operator"];
- values: boolean[];
- }
- | {
- type: "number";
- operator: NumberFilterParts["operator"];
- values: NumberFilterParts["values"];
- }
- | {
- type: "coordinate";
- operator: CoordinateFilterParts["operator"];
- values: CoordinateFilterParts["values"];
- }
- | {
- type: "specific-date";
- operator: SpecificDateFilterParts["operator"];
- values: Date[];
- hasTime: boolean;
- }
- | {
- type: "relative-date";
- unit: RelativeDateFilterParts["unit"];
- value: number;
- offsetUnit: RelativeDateFilterParts["offsetUnit"];
- offsetValue: RelativeDateFilterParts["offsetValue"];
- options: RelativeDateFilterParts["options"];
- }
- | {
- type: "exclude-date";
- operator: ExcludeDateFilterParts["operator"];
- unit: ExcludeDateFilterParts["unit"];
- values: number[];
- }
- | { type: "time"; operator: TimeFilterParts["operator"]; values: Date[] }
- | { type: "default"; operator: DefaultFilterParts["operator"] };
+export type { DimensionFilterValue } from "metabase/common/metrics-viewer";
type ParsedFilter = {
dimension: DimensionMetadata;
diff --git a/frontend/src/metabase/metrics-viewer/utils/index.ts b/frontend/src/metabase/metrics-viewer/utils/index.ts
index 095d13a0f59..6fe4cfd2aab 100644
--- a/frontend/src/metabase/metrics-viewer/utils/index.ts
+++ b/frontend/src/metabase/metrics-viewer/utils/index.ts
@@ -7,5 +7,4 @@ export * from "./dimension-breakout-config";
export * from "./series";
export * from "./dimension-breakouts";
export * from "./dimension-picker";
-export * from "./compact-schema";
export * from "./url-serialization";
diff --git a/frontend/src/metabase/metrics-viewer/utils/url-serialization.ts b/frontend/src/metabase/metrics-viewer/utils/url-serialization.ts
index 498b0285272..428e5a42d68 100644
--- a/frontend/src/metabase/metrics-viewer/utils/url-serialization.ts
+++ b/frontend/src/metabase/metrics-viewer/utils/url-serialization.ts
@@ -1,13 +1,15 @@
-import { b64url_to_utf8, utf8_to_b64url } from "metabase/utils/encoding";
+import type {
+ SerializedDefinitionInfo,
+ SerializedDimensionBreakout,
+ SerializedExpressionSubToken,
+ SerializedFormulaEntity,
+ SerializedMetricsViewerPageState,
+ SerializedSource,
+} from "metabase/common/metrics-viewer";
import { getObjectEntries } from "metabase/utils/objects";
import type { MetricDefinition } from "metabase-lib/metric";
import * as LibMetric from "metabase-lib/metric";
-import type {
- MathOperator,
- SegmentId,
- TemporalUnit,
- VisualizationSettings,
-} from "metabase-types/api";
+import type { SegmentId } from "metabase-types/api";
import type {
ExpressionSubToken,
@@ -15,8 +17,6 @@ import type {
MetricSourceId,
MetricsViewerDefinitionEntry,
MetricsViewerDimensionBreakoutState,
- MetricsViewerDimensionBreakoutType,
- MetricsViewerDisplayType,
MetricsViewerFormulaEntity,
MetricsViewerPageState,
} from "../types/viewer-state";
@@ -30,13 +30,11 @@ import {
extractDefinitionFilters,
} from "../utils/dimension-filters";
-import { defineCompactSchema } from "./compact-schema";
import {
getEffectiveDefinitionEntry,
getEffectiveTokenDefinitionEntry,
getEntryBreakout,
} from "./definition-entries";
-import type { DimensionFilterValue } from "./dimension-filters";
import {
findBinningStrategy,
findDimensionById,
@@ -45,36 +43,11 @@ import {
} from "./dimension-lookup";
import { stampMetricCounts } from "./expression";
-function reviveFilter(filter: DimensionFilterValue): DimensionFilterValue {
- if (filter.type === "specific-date" || filter.type === "time") {
- return {
- ...filter,
- values: filter.values.map((value) =>
- typeof value === "string" ? new Date(value) : value,
- ),
- };
- } else if (filter.type === "number" || filter.type === "coordinate") {
- return {
- ...filter,
- values: filter.values.map((value) =>
- typeof value === "string" ? BigInt(value) : value,
- ),
- };
- }
- 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[];
- segments?: SegmentId[];
-}
+export { decodeState, encodeState } from "metabase/common/metrics-viewer";
+export type {
+ SerializedDefinitionInfo,
+ SerializedMetricsViewerPageState,
+} from "metabase/common/metrics-viewer";
export function applySerializedDefinitionInfo(
definition: MetricDefinition,
@@ -148,70 +121,6 @@ export function applySerializedDefinitionInfo(
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[];
- segments?: SegmentId[];
-}
-
-interface SerializedExpressionEntry {
- type: "expression";
- id: string;
- name: string;
- tokens: SerializedExpressionSubToken[];
-}
-
-interface SerializedUrlFilter {
- dimensionId: string;
- value: DimensionFilterValue;
-}
-
-interface SerializedSource {
- type: "metric" | "measure";
- id: number;
- breakout?: string;
- breakoutTemporalUnit?: TemporalUnit;
- breakoutBinning?: string;
- filters?: SerializedUrlFilter[];
- segments?: SegmentId[];
-}
-
-type SerializedFormulaEntity = SerializedExpressionEntry | SerializedSource;
-
-interface SerializedDimensionBreakoutDef {
- slotIndex: number;
- dimensionId?: string;
-}
-
-interface SerializedProjectionConfig {
- dimensionFilter?: DimensionFilterValue;
- temporalUnit?: TemporalUnit;
- binning?: string;
-}
-
-interface SerializedDimensionBreakout {
- id: string;
- type: MetricsViewerDimensionBreakoutType;
- label: string | null;
- display: MetricsViewerDisplayType;
- showColumnLabels?: boolean;
- visualizationSettings?: Partial<VisualizationSettings>;
- definitions: SerializedDimensionBreakoutDef[];
- projectionConfig?: SerializedProjectionConfig;
-}
-
-export interface SerializedMetricsViewerPageState {
- formulaEntities: SerializedFormulaEntity[];
- dimensionBreakouts: SerializedDimensionBreakout[];
- selectedDimensionBreakoutId: string | null;
- showColumnLabels?: boolean;
-}
-
// ── Expression sub-token helpers ──
function serializeSubToken(
@@ -536,167 +445,3 @@ export function stateToSerializedState(
...(state.showColumnLabels ? { showColumnLabels: true } : {}),
};
}
-
-// ── Compact schemas ──
-
-const sourceFilterSchema = defineCompactSchema<SerializedUrlFilter>({
- dimensionId: "d",
- value: { key: "v" },
-});
-
-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 },
- segments: { key: "S", 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 },
- segments: { key: "s", optional: true },
- name: { key: "n", optional: true },
- tokens: { key: "T", schema: expressionSubTokenSchema, optional: true },
-});
-
-const dimensionBreakoutDefSchema =
- defineCompactSchema<SerializedDimensionBreakoutDef>({
- slotIndex: "i",
- dimensionId: { key: "d", optional: true },
- });
-
-const projectionConfigSchema = defineCompactSchema<SerializedProjectionConfig>({
- dimensionFilter: { key: "f", optional: true },
- temporalUnit: { key: "u", optional: true },
- binning: { key: "b", optional: true },
-});
-
-const dimensionBreakoutSchema =
- defineCompactSchema<SerializedDimensionBreakout>({
- id: "i",
- type: "t",
- label: { key: "l", default: null },
- display: { key: "d", default: "line" },
- showColumnLabels: { key: "c", optional: true },
- visualizationSettings: { key: "V", optional: true },
- definitions: {
- key: "D",
- schema: dimensionBreakoutDefSchema,
- default: [],
- },
- projectionConfig: {
- key: "p",
- schema: projectionConfigSchema,
- optional: true,
- },
- });
-
-const rootSchema = defineCompactSchema<SerializedMetricsViewerPageState>({
- formulaEntities: { key: "f", schema: formulaEntitySchema, default: [] },
- dimensionBreakouts: {
- key: "t",
- schema: dimensionBreakoutSchema,
- default: [],
- },
- selectedDimensionBreakoutId: { key: "a", default: null },
- showColumnLabels: { key: "c", optional: true },
-});
-
-// ── Encode / decode ──
-
-function emptyState(): SerializedMetricsViewerPageState {
- return {
- formulaEntities: [],
- dimensionBreakouts: [],
- selectedDimensionBreakoutId: null,
- showColumnLabels: false,
- };
-}
-
-// After JSON.parse, Date values are ISO strings. Walk the decoded state and revive them.
-function reviveStateDates(
- state: SerializedMetricsViewerPageState,
-): SerializedMetricsViewerPageState {
- return {
- ...state,
- 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;
- }),
- dimensionBreakouts: state.dimensionBreakouts.map((dimensionBreakout) =>
- dimensionBreakout.projectionConfig?.dimensionFilter
- ? {
- ...dimensionBreakout,
- projectionConfig: {
- ...dimensionBreakout.projectionConfig,
- dimensionFilter: reviveFilter(
- dimensionBreakout.projectionConfig.dimensionFilter,
- ),
- },
- }
- : dimensionBreakout,
- ),
- };
-}
-
-export function encodeState(
- state: SerializedMetricsViewerPageState,
-): string | undefined {
- try {
- return utf8_to_b64url(
- JSON.stringify(rootSchema.compact(state), (_, value) =>
- typeof value === "bigint" ? String(value) : value,
- ),
- );
- } catch (err) {
- console.error("Failed to encode metrics viewer URL state:", err);
- return undefined;
- }
-}
-
-export function decodeState(hash: string): SerializedMetricsViewerPageState {
- if (!hash) {
- return emptyState();
- }
-
- try {
- const state =
- rootSchema.expand(JSON.parse(b64url_to_utf8(hash))) ?? emptyState();
- return reviveStateDates(state);
- } catch (err) {
- console.warn("Failed to decode metrics viewer URL state:", err);
- return emptyState();
- }
-}
diff --git a/frontend/src/metabase/urls/metrics.ts b/frontend/src/metabase/urls/metrics.ts
index 03b73b202f3..f57aedd2221 100644
--- a/frontend/src/metabase/urls/metrics.ts
+++ b/frontend/src/metabase/urls/metrics.ts
@@ -1,9 +1,9 @@
-import type { DimensionType } from "metabase/metrics/common/utils/dimension-types";
-import type { MetricsViewerDisplayType } from "metabase/metrics-viewer/types/viewer-state";
import {
+ type MetricsViewerDisplayType,
type SerializedMetricsViewerPageState,
encodeState,
-} from "metabase/metrics-viewer/utils/url-serialization";
+} from "metabase/common/metrics-viewer";
+import type { DimensionType } from "metabase/metrics/common/utils/dimension-types";
import type { CardId, CollectionId } from "metabase-types/api";
import { card as urlForCard } from "./cards";