Skip to content

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

Segments list revision history, dependencies, list view in published tables (#66678)

Aleksandr Lesnenko028f67ab3473
diff --git a/e2e/support/helpers/e2e-data-studio-helpers.ts b/e2e/support/helpers/e2e-data-studio-helpers.ts
index 913430f8660..a802e20e44c 100644
--- a/e2e/support/helpers/e2e-data-studio-helpers.ts
+++ b/e2e/support/helpers/e2e-data-studio-helpers.ts
@@ -1,4 +1,4 @@
-import type { TableId } from "metabase-types/api";
+import type { SegmentId, TableId } from "metabase-types/api";
import { codeMirrorHelpers } from "./e2e-codemirror-helpers";
import { popover } from "./e2e-ui-elements-helpers";
@@ -67,15 +67,23 @@ export const DataStudio = {
overviewPage: () => cy.findByTestId("table-overview-page"),
fieldsPage: () => cy.findByTestId("table-fields-page"),
dependenciesPage: () => cy.findByTestId("table-dependencies-page"),
+ segmentsPage: () => cy.findByTestId("table-segments-page"),
header: () => cy.findByTestId("table-pane-header"),
nameInput: () => cy.findByTestId("table-name-input"),
moreMenu: () => DataStudio.Tables.header().icon("ellipsis"),
overviewTab: () => DataStudio.Tables.header().findByText("Overview"),
fieldsTab: () => DataStudio.Tables.header().findByText("Fields"),
+ segmentsTab: () => DataStudio.Tables.header().findByText("Segments"),
dependenciesTab: () =>
DataStudio.Tables.header().findByText("Dependencies"),
visitOverviewPage: (tableId: TableId) =>
cy.visit(`/data-studio/library/tables/${tableId}`),
+ visitSegmentsPage: (tableId: TableId) =>
+ cy.visit(`/data-studio/library/tables/${tableId}/segments`),
+ visitSegmentPage: (tableId: TableId, segmentId: SegmentId) =>
+ cy.visit(`/data-studio/library/tables/${tableId}/segments/${segmentId}`),
+ visitNewSegmentPage: (tableId: TableId) =>
+ cy.visit(`/data-studio/library/tables/${tableId}/segments/new`),
moreMenuViewTable: () =>
popover()
.findByRole("menuitem", { name: /View/ })
diff --git a/e2e/support/helpers/e2e-datamodel-helpers.ts b/e2e/support/helpers/e2e-datamodel-helpers.ts
index 4f0af2a0c50..6e4f68b42f5 100644
--- a/e2e/support/helpers/e2e-datamodel-helpers.ts
+++ b/e2e/support/helpers/e2e-datamodel-helpers.ts
@@ -79,11 +79,17 @@ export const DataModel = {
getNameInput: getSegmentEditorNameInput,
getDescriptionInput: getSegmentEditorDescriptionInput,
getFilterPlaceholder: getSegmentEditorFilterPlaceholder,
- getRowCount: getSegmentEditorRowCount,
getPreviewLink: getSegmentEditorPreviewLink,
getSaveButton: getSegmentEditorSaveButton,
+ getCancelButton: getSegmentEditorCancelButton,
getActionsButton: getSegmentEditorActionsButton,
getBreadcrumb: getSegmentEditorBreadcrumb,
+ getDefinitionTab: getSegmentEditorDefinitionTab,
+ getRevisionHistoryTab: getSegmentEditorRevisionHistoryTab,
+ getDependenciesTab: getSegmentEditorDependenciesTab,
+ },
+ SegmentRevisionHistory: {
+ get: getSegmentRevisionHistory,
},
};
@@ -444,7 +450,7 @@ function visitDataStudioSegments(options: {
}
function getSegmentList() {
- return cy.findByRole("tabpanel");
+ return cy.findByTestId("table-segments-page");
}
function getSegmentListEmptyState() {
@@ -467,7 +473,7 @@ function getSegmentListItems() {
function getSegmentEditor() {
return cy.get(
- "[data-testid='new-segment-page'], [data-testid='edit-segment-page']",
+ "[data-testid='new-segment-page'], [data-testid='segment-detail-page']",
);
}
@@ -483,10 +489,6 @@ function getSegmentEditorFilterPlaceholder() {
return getSegmentEditor().findByText("Add filters to narrow your answer");
}
-function getSegmentEditorRowCount() {
- return getSegmentEditor().findByText(/\d+ rows/);
-}
-
function getSegmentEditorPreviewLink() {
return getSegmentEditor().findByRole("link", { name: /Preview/i });
}
@@ -495,10 +497,30 @@ function getSegmentEditorSaveButton() {
return getSegmentEditor().button("Save");
}
+function getSegmentEditorCancelButton() {
+ return getSegmentEditor().button("Cancel");
+}
+
function getSegmentEditorActionsButton() {
return cy.findByLabelText("Segment actions");
}
function getSegmentEditorBreadcrumb(tableName: string) {
- return getSegmentEditor().findByText(`${tableName} segments`);
+ return cy.findByText(tableName);
+}
+
+function getSegmentEditorDefinitionTab() {
+ return cy.findByTestId("segment-pane-header").findByText("Definition");
+}
+
+function getSegmentEditorRevisionHistoryTab() {
+ return cy.findByTestId("segment-pane-header").findByText("Revision history");
+}
+
+function getSegmentEditorDependenciesTab() {
+ return cy.findByTestId("segment-pane-header").findByText("Dependencies");
+}
+
+function getSegmentRevisionHistory() {
+ return cy.findByTestId("segment-revision-history-page");
}
diff --git a/e2e/test/scenarios/data-studio/data-model/segments-data-studio.cy.spec.ts b/e2e/test/scenarios/data-studio/data-model/segments-data-studio.cy.spec.ts
index 077729c8c57..9c2bddf9719 100644
--- a/e2e/test/scenarios/data-studio/data-model/segments-data-studio.cy.spec.ts
+++ b/e2e/test/scenarios/data-studio/data-model/segments-data-studio.cy.spec.ts
@@ -2,7 +2,7 @@ import { SAMPLE_DB_ID, SAMPLE_DB_SCHEMA_ID } from "e2e/support/cypress_data";
import { SAMPLE_DATABASE } from "e2e/support/cypress_sample_database";
const { H } = cy;
-const { SegmentList, SegmentEditor } = H.DataModel;
+const { SegmentList, SegmentEditor, SegmentRevisionHistory } = H.DataModel;
const { ORDERS, ORDERS_ID, PRODUCTS, PRODUCTS_ID, PEOPLE, PEOPLE_ID } =
SAMPLE_DATABASE;
@@ -31,10 +31,7 @@ describe("scenarios > data studio > data model > segments", () => {
cy.log("verify new segment link and navigation");
SegmentList.getNewSegmentLink().scrollIntoView().click();
- cy.url().should(
- "include",
- `/data-studio/library/segments/new?tableId=${ORDERS_ID}`,
- );
+ cy.url().should("include", `${getSegmentsBaseUrl(ORDERS_ID)}/new`);
});
it("should display segments and allow navigation to edit page", () => {
@@ -57,7 +54,7 @@ describe("scenarios > data studio > data model > segments", () => {
cy.get<number>("@segmentId").then((segmentId) => {
cy.url().should(
"include",
- `/data-studio/library/segments/${segmentId}`,
+ `${getSegmentsBaseUrl(ORDERS_ID)}/${segmentId}`,
);
});
});
@@ -109,11 +106,10 @@ describe("scenarios > data studio > data model > segments", () => {
cy.button("Add filter").click();
});
- cy.log("verify row count preview");
- SegmentEditor.getRowCount().should("be.visible");
-
- cy.log("verify preview link");
- SegmentEditor.getPreviewLink().should("be.visible");
+ cy.log("verify filter was added");
+ SegmentEditor.get()
+ .findByText(/Total is greater than 100/i)
+ .should("exist");
cy.log("save segment");
SegmentEditor.getSaveButton().click();
@@ -121,13 +117,18 @@ describe("scenarios > data studio > data model > segments", () => {
cy.log("verify redirect to edit page and toast");
H.undoToast().should("contain.text", "Segment created");
- cy.url().should("match", /\/data-studio\/library\/segments\/\d+$/);
+ cy.url().should(
+ "match",
+ new RegExp(
+ `${getSegmentsBaseUrl(ORDERS_ID).replace(/\//g, "\\/")}\/\\d+$`,
+ ),
+ );
cy.log("verify segment in query builder");
verifySegmentInQueryBuilder("Premium Orders");
});
- it("should show row count when filters are added", () => {
+ it("should add filter and show preview in menu", () => {
visitDataStudioSegments(PRODUCTS_ID);
SegmentList.getNewSegmentLink().scrollIntoView().click();
@@ -140,7 +141,14 @@ describe("scenarios > data studio > data model > segments", () => {
cy.button("Add filter").click();
});
- SegmentEditor.getRowCount().should("be.visible");
+ cy.log("verify filter was added");
+ SegmentEditor.get()
+ .findByText(/Price is less than 50/i)
+ .should("exist");
+
+ cy.log("verify preview is available in menu");
+ SegmentEditor.getActionsButton().click();
+ H.popover().findByText("Preview").should("be.visible");
});
});
@@ -151,7 +159,7 @@ describe("scenarios > data studio > data model > segments", () => {
description: "Test description",
});
cy.get<number>("@segmentId").then((segmentId) => {
- cy.visit(`/data-studio/library/segments/${segmentId}`);
+ visitDataModelSegment(ORDERS_ID, segmentId);
});
cy.log("verify existing data displayed");
@@ -163,16 +171,20 @@ describe("scenarios > data studio > data model > segments", () => {
"Test description",
);
- cy.log("update segment name");
+ cy.log("update segment name (saves immediately on blur/enter)");
SegmentEditor.get()
.findByDisplayValue("Test Segment")
.click()
.type(" Updated{enter}");
- SegmentEditor.getSaveButton().click();
cy.wait("@updateSegment");
- cy.log("verify toast (stays on edit page)");
- H.undoToast().should("contain.text", "Segment updated");
+ cy.log("verify toast for name update");
+ H.undoToast().should("contain.text", "Segment name updated");
+
+ cy.log("update description");
+ SegmentEditor.getDescriptionInput().clear().type("Updated description");
+ SegmentEditor.getSaveButton().click();
+ cy.wait("@updateSegment");
cy.log("verify updated segment in query builder");
verifySegmentInQueryBuilder("Test Segment Updated");
@@ -181,7 +193,7 @@ describe("scenarios > data studio > data model > segments", () => {
it("should navigate back to segments tab via breadcrumb", () => {
createTestSegment({ name: "Breadcrumb Test Segment" });
cy.get<number>("@segmentId").then((segmentId) => {
- cy.visit(`/data-studio/library/segments/${segmentId}`);
+ visitDataModelSegment(ORDERS_ID, segmentId);
});
SegmentEditor.getBreadcrumb("Orders").click();
@@ -200,7 +212,7 @@ describe("scenarios > data studio > data model > segments", () => {
it("should remove segment via more menu", () => {
createTestSegment({ name: "Segment to Delete" });
cy.get<number>("@segmentId").then((segmentId) => {
- cy.visit(`/data-studio/library/segments/${segmentId}`);
+ visitDataModelSegment(ORDERS_ID, segmentId);
});
cy.log("delete via more menu");
@@ -264,8 +276,10 @@ describe("scenarios > data studio > data model > segments", () => {
cy.button("Add filter").click();
});
- cy.log("verify row count and save");
- SegmentEditor.getRowCount().should("be.visible");
+ cy.log("verify filter was added and save");
+ SegmentEditor.get()
+ .findByText(/Product → Category is Widget/i)
+ .should("exist");
SegmentEditor.getSaveButton().click();
cy.wait("@createSegment");
@@ -354,8 +368,10 @@ describe("scenarios > data studio > data model > segments", () => {
cy.button("Add filter").click();
});
- cy.log("save segment");
- SegmentEditor.getRowCount().should("be.visible");
+ cy.log("verify filter was added and save segment");
+ SegmentEditor.get()
+ .findByText(/Product → Category is Gadget/i)
+ .should("exist");
SegmentEditor.getSaveButton().click();
cy.wait("@createSegment");
@@ -466,7 +482,7 @@ describe("scenarios > data studio > data model > segments", () => {
});
cy.log("edit Segment A via UI and try to add Segment B as filter");
- cy.visit(`/data-studio/modeling/segments/${segmentA.id}`);
+ visitDataModelSegment(ORDERS_ID, segmentA.id);
cy.wait("@metadata");
SegmentEditor.get().icon("add").click();
@@ -482,6 +498,114 @@ describe("scenarios > data studio > data model > segments", () => {
});
});
});
+
+ describe("Revision history", () => {
+ it("should display revision history with changes to name, description, and filter", () => {
+ createTestSegment({
+ name: "Original Name",
+ description: "Original description",
+ filter: ["<", ["field", ORDERS.TOTAL, null], 50],
+ });
+ cy.get<number>("@segmentId").then((segmentId) => {
+ cy.log("update segment name");
+ cy.request("PUT", `/api/segment/${segmentId}`, {
+ name: "Updated Name",
+ description: "Original description",
+ revision_message: "Updated from Data Studio",
+ definition: {
+ type: "query",
+ database: SAMPLE_DB_ID,
+ query: {
+ "source-table": ORDERS_ID,
+ filter: ["<", ["field", ORDERS.TOTAL, null], 50],
+ },
+ },
+ });
+
+ cy.log("update segment description");
+ cy.request("PUT", `/api/segment/${segmentId}`, {
+ name: "Updated Name",
+ description: "Updated description",
+ revision_message: "Updated from Data Studio",
+ definition: {
+ type: "query",
+ database: SAMPLE_DB_ID,
+ query: {
+ "source-table": ORDERS_ID,
+ filter: ["<", ["field", ORDERS.TOTAL, null], 50],
+ },
+ },
+ });
+
+ cy.log("update segment filter");
+ cy.request("PUT", `/api/segment/${segmentId}`, {
+ name: "Updated Name",
+ description: "Updated description",
+ revision_message: "Updated from Data Studio",
+ definition: {
+ type: "query",
+ database: SAMPLE_DB_ID,
+ query: {
+ "source-table": ORDERS_ID,
+ filter: [">", ["field", ORDERS.TOTAL, null], 100],
+ },
+ },
+ });
+
+ cy.wait(1000);
+
+ visitDataModelSegment(ORDERS_ID, segmentId);
+ });
+
+ cy.log("navigate to revision history tab");
+ SegmentEditor.getRevisionHistoryTab().click();
+
+ cy.log("verify URL");
+ cy.get<number>("@segmentId").then((segmentId) => {
+ cy.url().should(
+ "include",
+ `${getSegmentsBaseUrl(ORDERS_ID)}/${segmentId}/revisions`,
+ );
+ });
+
+ cy.log("verify revision history entries");
+ SegmentRevisionHistory.get().within(() => {
+ cy.findByText(/created this segment/i)
+ .scrollIntoView()
+ .should("be.visible");
+ cy.findByText(/made multiple changes/i)
+ .scrollIntoView()
+ .should("be.visible");
+ cy.findByText(/updated the description/i)
+ .scrollIntoView()
+ .should("be.visible");
+ });
+ });
+ });
+
+ describe("Dependencies", () => {
+ it("should display dependency graph for a segment", () => {
+ createTestSegment({ name: "Dependencies Test Segment" });
+ cy.get<number>("@segmentId").then((segmentId) => {
+ visitDataModelSegment(ORDERS_ID, segmentId);
+ });
+
+ cy.log("navigate to dependencies tab");
+ SegmentEditor.getDependenciesTab().click();
+
+ cy.log("verify URL and dependency graph display");
+ cy.get<number>("@segmentId").then((segmentId) => {
+ cy.url().should(
+ "include",
+ `${getSegmentsBaseUrl(ORDERS_ID)}/${segmentId}/dependencies`,
+ );
+ });
+ H.DependencyGraph.graph().should("be.visible");
+ H.DependencyGraph.graph()
+ .findByText("Dependencies Test Segment")
+ .should("be.visible");
+ });
+ });
});
function visitDataStudioTable(tableId: number) {
@@ -500,6 +624,14 @@ function visitDataStudioSegments(tableId: number) {
});
}
+function getSegmentsBaseUrl(tableId: number) {
+ return `/data-studio/data/database/${SAMPLE_DB_ID}/schema/${SAMPLE_DB_SCHEMA_ID}/table/${tableId}/segments`;
+}
+
+function visitDataModelSegment(tableId: number, segmentId: number) {
+ cy.visit(`${getSegmentsBaseUrl(tableId)}/${segmentId}`);
+}
+
function createTestSegment(
opts: {
name?: string;
diff --git a/e2e/test/scenarios/data-studio/published-tables-segments.cy.spec.ts b/e2e/test/scenarios/data-studio/published-tables-segments.cy.spec.ts
new file mode 100644
index 00000000000..7735a9c86fb
--- /dev/null
+++ b/e2e/test/scenarios/data-studio/published-tables-segments.cy.spec.ts
@@ -0,0 +1,159 @@
+import { SAMPLE_DB_ID } from "e2e/support/cypress_data";
+import { SAMPLE_DATABASE } from "e2e/support/cypress_sample_database";
+
+const { H } = cy;
+const { SegmentList, SegmentEditor } = H.DataModel;
+const { ORDERS, ORDERS_ID } = SAMPLE_DATABASE;
+
+// Majority of the segments pages functionality is covered in the data-model/segments-data-studio.cy.spec.ts spec
+// This spec is focused on the published tables segments pages functionality while doing some smoke tests
+describe("scenarios > data studio > library > published tables > segments", () => {
+ beforeEach(() => {
+ H.restore();
+ cy.signInAsAdmin();
+ H.activateToken("bleeding-edge");
+ H.createLibrary();
+ H.publishTables({ table_ids: [ORDERS_ID] });
+
+ cy.intercept("POST", "/api/segment").as("createSegment");
+ cy.intercept("DELETE", "/api/segment/*").as("deleteSegment");
+ });
+
+ describe("Segment list", () => {
+ it("should show empty state and navigate to new segment page", () => {
+ H.DataStudio.Tables.visitSegmentsPage(ORDERS_ID);
+
+ SegmentList.getEmptyState().scrollIntoView().should("be.visible");
+ SegmentList.getNewSegmentLink().scrollIntoView().click();
+
+ cy.url().should(
+ "include",
+ `/data-studio/library/tables/${ORDERS_ID}/segments/new`,
+ );
+ });
+
+ it("should display segments and navigate to edit page", () => {
+ createTestSegment({ name: "High Value Orders" });
+ H.DataStudio.Tables.visitSegmentsPage(ORDERS_ID);
+
+ SegmentList.getSegment("High Value Orders").click();
+
+ cy.get<number>("@segmentId").then((segmentId) => {
+ cy.url().should(
+ "include",
+ `/data-studio/library/tables/${ORDERS_ID}/segments/${segmentId}`,
+ );
+ });
+ });
+
+ it("should navigate between Overview, Fields, and Segments tabs", () => {
+ H.DataStudio.Tables.visitOverviewPage(ORDERS_ID);
+
+ H.DataStudio.Tables.overviewTab().should("be.visible");
+ H.DataStudio.Tables.fieldsTab().should("be.visible");
+ H.DataStudio.Tables.segmentsTab().should("be.visible");
+
+ H.DataStudio.Tables.segmentsTab().click();
+ cy.url().should(
+ "include",
+ `/data-studio/library/tables/${ORDERS_ID}/segments`,
+ );
+
+ H.DataStudio.Tables.overviewTab().click();
+ cy.url().should("include", `/data-studio/library/tables/${ORDERS_ID}`);
+ cy.url().should("not.include", "/segments");
+ });
+ });
+
+ describe("Segment creation", () => {
+ it("should create a segment and redirect to edit page", () => {
+ H.DataStudio.Tables.visitSegmentsPage(ORDERS_ID);
+ SegmentList.getNewSegmentLink().click();
+
+ SegmentEditor.getNameInput().type("Premium Orders");
+ SegmentEditor.getFilterPlaceholder().click();
+ H.popover().findByText("Total").click();
+ H.selectFilterOperator("Greater than");
+ H.popover().within(() => {
+ cy.findByLabelText("Filter value").type("100");
+ cy.button("Add filter").click();
+ });
+
+ SegmentEditor.getSaveButton().click();
+ cy.wait("@createSegment");
+
+ H.undoToast().should("contain.text", "Segment created");
+ cy.url().should(
+ "match",
+ new RegExp(`/data-studio/library/tables/${ORDERS_ID}/segments/\\d+$`),
+ );
+ });
+ });
+
+ describe("Breadcrumbs", () => {
+ it("should display collection-based breadcrumbs", () => {
+ createTestSegment({ name: "Breadcrumb Test Segment" });
+ cy.get<number>("@segmentId").then((segmentId) => {
+ H.DataStudio.Tables.visitSegmentPage(ORDERS_ID, segmentId);
+ });
+
+ SegmentEditor.get().findByText("Data").should("be.visible");
+ });
+
+ it("should navigate back to published table segments via breadcrumb", () => {
+ createTestSegment({ name: "Breadcrumb Nav Test" });
+ cy.get<number>("@segmentId").then((segmentId) => {
+ H.DataStudio.Tables.visitSegmentPage(ORDERS_ID, segmentId);
+ });
+
+ SegmentEditor.getBreadcrumb("Orders").click();
+
+ cy.url().should(
+ "include",
+ `/data-studio/library/tables/${ORDERS_ID}/segments`,
+ );
+ cy.url().should("not.match", /segments\/\d+/);
+ });
+ });
+
+ describe("Segment deletion", () => {
+ it("should redirect to published table segments list after deletion", () => {
+ createTestSegment({ name: "Segment to Delete" });
+ cy.get<number>("@segmentId").then((segmentId) => {
+ H.DataStudio.Tables.visitSegmentPage(ORDERS_ID, segmentId);
+ });
+
+ SegmentEditor.getActionsButton().click();
+ H.popover().findByText("Remove segment").click();
+ H.modal().button("Remove").click();
+ cy.wait("@deleteSegment");
+
+ H.undoToast().should("contain.text", "Segment removed");
+ cy.url().should(
+ "include",
+ `/data-studio/library/tables/${ORDERS_ID}/segments`,
+ );
+ cy.url().should("not.match", /segments\/\d+/);
+ });
+ });
+});
+
+function createTestSegment(opts: { name?: string; description?: string } = {}) {
+ const { name = "Test Segment", description } = opts;
+
+ H.createSegment({
+ name,
+ description,
+ table_id: ORDERS_ID,
+ definition: {
+ type: "query",
+ database: SAMPLE_DB_ID,
+ query: {
+ "source-table": ORDERS_ID,
+ filter: ["<", ["field", ORDERS.TOTAL, null], 100],
+ },
+ },
+ }).then(({ body }) => {
+ cy.wrap(body.id).as("segmentId");
+ });
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/common/components/EntityList/EntityList.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/common/components/EntityList/EntityList.tsx
new file mode 100644
index 00000000000..f76cf5e9cc6
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/common/components/EntityList/EntityList.tsx
@@ -0,0 +1,57 @@
+import type { ReactNode } from "react";
+
+import EmptyState from "metabase/common/components/EmptyState";
+import { ForwardRefLink } from "metabase/common/components/Link";
+import type { IconName } from "metabase/ui";
+import { Button, Group, Icon, Stack, Title } from "metabase/ui";
+
+type EntityListEmptyState = {
+ icon: IconName;
+ title: string;
+ message: string;
+};
+
+type EntityListProps<T> = {
+ items: T[];
+ title: string;
+ emptyState: EntityListEmptyState;
+ newButtonLabel: string;
+ newButtonUrl: string;
+ renderItem: (item: T) => ReactNode;
+};
+
+export function EntityList<T>({
+ items,
+ title,
+ emptyState,
+ newButtonLabel,
+ newButtonUrl,
+ renderItem,
+}: EntityListProps<T>) {
+ return (
+ <Stack gap="md">
+ <Group justify="space-between" wrap="nowrap">
+ <Title order={4}>{title}</Title>
+ <Button component={ForwardRefLink} to={newButtonUrl} variant="filled">
+ {newButtonLabel}
+ </Button>
+ </Group>
+
+ {items.length === 0 ? (
+ <EmptyState
+ illustrationElement={
+ <Icon name={emptyState.icon} size={32} c="text-secondary" />
+ }
+ title={emptyState.title}
+ message={emptyState.message}
+ />
+ ) : (
+ <Stack gap="sm" role="list">
+ {items.map((item, index) => (
+ <div key={index}>{renderItem(item)}</div>
+ ))}
+ </Stack>
+ )}
+ </Stack>
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/common/components/EntityList/EntityListItem.module.css b/enterprise/frontend/src/metabase-enterprise/data-studio/common/components/EntityList/EntityListItem.module.css
new file mode 100644
index 00000000000..c099e1f0102
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/common/components/EntityList/EntityListItem.module.css
@@ -0,0 +1,7 @@
+.card {
+ box-shadow: 0 2px 4px 0 hsla(0, 0%, 0%, 0.05);
+
+ &:hover {
+ background-color: var(--mb-color-brand-lighter);
+ }
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/common/components/EntityList/EntityListItem.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/common/components/EntityList/EntityListItem.tsx
new file mode 100644
index 00000000000..11f60610bcf
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/common/components/EntityList/EntityListItem.tsx
@@ -0,0 +1,49 @@
+import { Link } from "react-router";
+
+import { Ellipsified } from "metabase/common/components/Ellipsified";
+import type { IconName } from "metabase/ui";
+import { Card, Flex, Icon, Stack, Text } from "metabase/ui";
+
+import S from "./EntityListItem.module.css";
+
+type EntityListItemProps = {
+ name: string;
+ description?: string | null;
+ icon: IconName;
+ iconColor?: string;
+ href: string;
+};
+
+export function EntityListItem({
+ name,
+ description,
+ icon,
+ iconColor = "brand",
+ href,
+}: EntityListItemProps) {
+ return (
+ <Card
+ className={S.card}
+ component={Link}
+ to={href}
+ aria-label={name}
+ role="listitem"
+ px="md"
+ py="0.75rem"
+ withBorder
+ >
+ <Stack gap="xs">
+ <Flex align="center" gap="sm">
+ <Icon name={icon} c={iconColor} />
+ <Ellipsified lines={1} tooltip={name}>
+ <Text fw="bold">{name}</Text>
+ </Ellipsified>
+ </Flex>
+
+ {description && (
+ <Text data-testid="list-item-description">{description}</Text>
+ )}
+ </Stack>
+ </Card>
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/common/components/EntityList/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/common/components/EntityList/index.ts
new file mode 100644
index 00000000000..deba33fcb36
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/common/components/EntityList/index.ts
@@ -0,0 +1,2 @@
+export { EntityList } from "./EntityList";
+export { EntityListItem } from "./EntityListItem";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TableSection/SegmentItem.unit.spec.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TableSection/SegmentItem.unit.spec.tsx
index ade82688481..5bd25f623be 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TableSection/SegmentItem.unit.spec.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TableSection/SegmentItem.unit.spec.tsx
@@ -1,6 +1,7 @@
import { Route } from "react-router";
import { renderWithProviders, screen } from "__support__/ui";
+import * as Urls from "metabase/lib/urls";
import { createMockSegment } from "metabase-types/api/mocks";
import { SegmentItem } from "./SegmentItem";
@@ -12,15 +13,12 @@ describe("SegmentItem", () => {
definition_description: "Total > $1000",
});
+ const segmentUrl = Urls.dataModelSegment(segment.id);
+
renderWithProviders(
<Route
path="/"
- component={() => (
- <SegmentItem
- segment={segment}
- href="/data-studio/library/segments/42"
- />
- )}
+ component={() => <SegmentItem segment={segment} href={segmentUrl} />}
/>,
{ withRouter: true },
);
@@ -30,7 +28,7 @@ describe("SegmentItem", () => {
const item = screen.getByRole("listitem");
expect(item).toBeInTheDocument();
- expect(item).toHaveAttribute("href", "/data-studio/library/segments/42");
+ expect(item).toHaveAttribute("href", segmentUrl);
expect(item).toHaveAttribute("aria-label", "Premium Customers");
});
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TableSection/SegmentList.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TableSection/SegmentList.tsx
index 8c8d23fb05a..cdf205a75a1 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TableSection/SegmentList.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TableSection/SegmentList.tsx
@@ -4,22 +4,34 @@ import EmptyState from "metabase/common/components/EmptyState";
import { ForwardRefLink } from "metabase/common/components/Link";
import * as Urls from "metabase/lib/urls";
import { Button, Group, Icon, Stack } from "metabase/ui";
-import type { Segment, TableId } from "metabase-types/api";
+import type { Table } from "metabase-types/api";
import { SegmentItem } from "./SegmentItem";
type SegmentListProps = {
- segments: Segment[];
- tableId: TableId;
+ table: Table;
};
-export function SegmentList({ segments, tableId }: SegmentListProps) {
+export function SegmentList({ table }: SegmentListProps) {
+ const segments = table.segments ?? [];
+ const getSegmentHref = (segmentId: number) =>
+ Urls.dataStudioDataModelSegment({
+ databaseId: table.db_id,
+ schemaName: table.schema,
+ tableId: table.id,
+ segmentId,
+ });
+
return (
- <Stack gap="md">
+ <Stack gap="md" data-testid="table-segments-page">
<Group gap="md" justify="flex-start" wrap="nowrap">
<Button
component={ForwardRefLink}
- to={Urls.newDataStudioSegment(tableId)}
+ to={Urls.newDataStudioDataModelSegment({
+ databaseId: table.db_id,
+ schemaName: table.schema,
+ tableId: table.id,
+ })}
h={32}
px="sm"
py="xs"
@@ -42,7 +54,7 @@ export function SegmentList({ segments, tableId }: SegmentListProps) {
<SegmentItem
key={segment.id}
segment={segment}
- href={Urls.dataStudioSegment(segment.id)}
+ href={getSegmentHref(segment.id)}
/>
))}
</Stack>
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TableSection/SegmentList.unit.spec.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TableSection/SegmentList.unit.spec.tsx
index 831635e29d6..89aa6d032e2 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TableSection/SegmentList.unit.spec.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TableSection/SegmentList.unit.spec.tsx
@@ -1,22 +1,27 @@
import { Route } from "react-router";
import { renderWithProviders, screen } from "__support__/ui";
-import type { Segment, TableId } from "metabase-types/api";
-import { createMockSegment } from "metabase-types/api/mocks";
+import type { Segment, Table } from "metabase-types/api";
+import { createMockSegment, createMockTable } from "metabase-types/api/mocks";
import { SegmentList } from "./SegmentList";
type SetupOpts = {
segments?: Segment[];
- tableId?: TableId;
+ table?: Partial<Table>;
};
-function setup({ segments = [], tableId = 1 }: SetupOpts = {}) {
+function setup({ segments = [], table = {} }: SetupOpts = {}) {
+ const mockTable = createMockTable({
+ id: 1,
+ db_id: 1,
+ schema: "PUBLIC",
+ segments,
+ ...table,
+ });
+
renderWithProviders(
- <Route
- path="/"
- component={() => <SegmentList segments={segments} tableId={tableId} />}
- />,
+ <Route path="/" component={() => <SegmentList table={mockTable} />} />,
{ withRouter: true },
);
}
@@ -51,6 +56,9 @@ describe("SegmentList", () => {
expect(screen.getByText("Active Users")).toBeInTheDocument();
expect(
screen.getByRole("listitem", { name: "High Value" }),
- ).toHaveAttribute("href", "/data-studio/library/segments/1");
+ ).toHaveAttribute(
+ "href",
+ "/data-studio/data/database/1/schema/1:PUBLIC/table/1/segments/1",
+ );
});
});
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TableSection/TableSection.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TableSection/TableSection.tsx
index fb2d34bb0bb..7f68b4838b9 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TableSection/TableSection.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TableSection/TableSection.tsx
@@ -348,7 +348,7 @@ const TableSectionBase = ({
</Tabs.Panel>
<Tabs.Panel value="segments">
- <SegmentList segments={table.segments ?? []} tableId={table.id} />
+ <SegmentList table={table} />
</Tabs.Panel>
</Tabs>
</Box>
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/pages/DataModel/DataModel.unit.spec.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/pages/DataModel/DataModel.unit.spec.tsx
index 0e83475d643..8e196f665a8 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/pages/DataModel/DataModel.unit.spec.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/pages/DataModel/DataModel.unit.spec.tsx
@@ -1040,10 +1040,7 @@ describe("DataModel", () => {
await userEvent.click(screen.getByRole("link", { name: /New segment/i }));
expect(history?.getCurrentLocation().pathname).toBe(
- "/data-studio/library/segments/new",
- );
- expect(history?.getCurrentLocation().search).toContain(
- `tableId=${ORDERS_TABLE.id}`,
+ `/data-studio/data/database/${ORDERS_TABLE.db_id}/schema/${ORDERS_TABLE.db_id}:${ORDERS_TABLE.schema}/table/${ORDERS_TABLE.id}/segments/new`,
);
});
});
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/routes.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/routes.tsx
index 8654f8ed701..6d73ad35a1b 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/routes.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/routes.tsx
@@ -1,8 +1,10 @@
import { IndexRoute, Redirect, Route } from "react-router";
-import RevisionHistoryApp from "metabase/admin/datamodel/containers/RevisionHistoryApp";
-import SegmentApp from "metabase/admin/datamodel/containers/SegmentApp";
-import SegmentListApp from "metabase/admin/datamodel/containers/SegmentListApp";
+import { PLUGIN_DEPENDENCIES } from "metabase/plugins";
+import { DataModelNewSegmentPage } from "metabase-enterprise/data-studio/segments/pages/DataModelNewSegmentPage";
+import { DataModelSegmentDependenciesPage } from "metabase-enterprise/data-studio/segments/pages/DataModelSegmentDependenciesPage";
+import { DataModelSegmentDetailPage } from "metabase-enterprise/data-studio/segments/pages/DataModelSegmentDetailPage";
+import { DataModelSegmentRevisionHistoryPage } from "metabase-enterprise/data-studio/segments/pages/DataModelSegmentRevisionHistoryPage";
import { DataModel } from "./pages/DataModel";
@@ -20,6 +22,26 @@ export function getDataStudioMetadataRoutes() {
path="database/:databaseId/schema/:schemaId/table/:tableId"
component={DataModel}
/>
+ <Route
+ path="database/:databaseId/schema/:schemaId/table/:tableId/segments/new"
+ component={DataModelNewSegmentPage}
+ />
+ <Route
+ path="database/:databaseId/schema/:schemaId/table/:tableId/segments/:segmentId"
+ component={DataModelSegmentDetailPage}
+ />
+ <Route
+ path="database/:databaseId/schema/:schemaId/table/:tableId/segments/:segmentId/revisions"
+ component={DataModelSegmentRevisionHistoryPage}
+ />
+ {PLUGIN_DEPENDENCIES.isEnabled && (
+ <Route
+ path="database/:databaseId/schema/:schemaId/table/:tableId/segments/:segmentId/dependencies"
+ component={DataModelSegmentDependenciesPage}
+ >
+ <IndexRoute component={PLUGIN_DEPENDENCIES.DependencyGraphPage} />
+ </Route>
+ )}
<Route
path="database/:databaseId/schema/:schemaId/table/:tableId/:tab"
component={DataModel}
@@ -44,12 +66,6 @@ export function getDataStudioMetadataRoutes() {
from="database/:databaseId/schema/:schemaId/table/:tableId/field/:fieldId/:section"
to="database/:databaseId/schema/:schemaId/table/:tableId/field/:fieldId"
/>
- <Route component={DataModel}>
- <Route path="segments" component={SegmentListApp} />
- <Route path="segment/create" component={SegmentApp} />
- <Route path="segment/:id" component={SegmentApp} />
- <Route path="segment/:id/revisions" component={RevisionHistoryApp} />
- </Route>
</>
);
}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/routes.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/routes.tsx
index 60f6e29f868..e06e427409e 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/routes.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/routes.tsx
@@ -18,7 +18,6 @@ import { TransformsSectionLayout } from "./app/pages/TransformsSectionLayout";
import { getDataStudioMetadataRoutes } from "./data-model/routes";
import { getDataStudioGlossaryRoutes } from "./glossary/routes";
import { getDataStudioMetricRoutes } from "./metrics/routes";
-import { getDataStudioSegmentRoutes } from "./segments/routes";
import { getDataStudioSnippetRoutes } from "./snippets/routes";
import { getDataStudioTableRoutes } from "./tables/routes";
@@ -53,7 +52,6 @@ export function getDataStudioRoutes(
<IndexRoute component={LibrarySectionLayout} />
{getDataStudioTableRoutes()}
{getDataStudioMetricRoutes()}
- {getDataStudioSegmentRoutes()}
{getDataStudioSnippetRoutes()}
</Route>
{PLUGIN_DEPENDENCIES.isEnabled && (
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/NewSegmentHeader/NewSegmentHeader.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/NewSegmentHeader/NewSegmentHeader.tsx
new file mode 100644
index 00000000000..aefa56c50e2
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/NewSegmentHeader/NewSegmentHeader.tsx
@@ -0,0 +1,52 @@
+import type { ReactNode } from "react";
+import { t } from "ttag";
+
+import EditableText from "metabase/common/components/EditableText";
+import { Group, Stack } from "metabase/ui";
+
+import { SegmentMoreMenu } from "../SegmentMoreMenu";
+
+const SEGMENT_NAME_MAX_LENGTH = 254;
+
+type NewSegmentHeaderProps = {
+ breadcrumbs: ReactNode;
+ previewUrl?: string;
+ onNameChange: (name: string) => void;
+ actions?: ReactNode;
+};
+
+export function NewSegmentHeader({
+ breadcrumbs,
+ previewUrl,
+ onNameChange,
+ actions,
+}: NewSegmentHeaderProps) {
+ return (
+ <Stack gap="sm">
+ {breadcrumbs}
+ <Group
+ gap="xs"
+ align="center"
+ justify="space-between"
+ w="100%"
+ px="lg"
+ mih={40}
+ >
+ <Group gap="xs" align="center">
+ <EditableText
+ initialValue=""
+ placeholder={t`New segment`}
+ maxLength={SEGMENT_NAME_MAX_LENGTH}
+ p={0}
+ fw="bold"
+ fz="h3"
+ lh="h3"
+ onContentChange={onNameChange}
+ />
+ {previewUrl && <SegmentMoreMenu previewUrl={previewUrl} />}
+ </Group>
+ {actions}
+ </Group>
+ </Stack>
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/NewSegmentHeader/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/NewSegmentHeader/index.ts
new file mode 100644
index 00000000000..169f5d31562
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/NewSegmentHeader/index.ts
@@ -0,0 +1 @@
+export { NewSegmentHeader } from "./NewSegmentHeader";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentBreadcrumbs/SegmentBreadcrumbs.module.css b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentBreadcrumbs/SegmentBreadcrumbs.module.css
new file mode 100644
index 00000000000..1d1c1f8f816
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentBreadcrumbs/SegmentBreadcrumbs.module.css
@@ -0,0 +1,8 @@
+.link {
+ color: inherit;
+ text-decoration: none;
+}
+
+.link:hover {
+ color: var(--mb-color-brand);
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentBreadcrumbs/SegmentBreadcrumbs.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentBreadcrumbs/SegmentBreadcrumbs.tsx
new file mode 100644
index 00000000000..2d689c60236
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentBreadcrumbs/SegmentBreadcrumbs.tsx
@@ -0,0 +1,138 @@
+import { skipToken } from "@reduxjs/toolkit/query";
+import { Fragment } from "react";
+import { Link } from "react-router";
+import { t } from "ttag";
+
+import { useListDatabaseSchemasQuery } from "metabase/api";
+import { Ellipsified } from "metabase/common/components/Ellipsified";
+import * as Urls from "metabase/lib/urls";
+import { getCollectionList } from "metabase/nav/components/CollectionBreadcrumbs/utils";
+import { Flex, Group, Text } from "metabase/ui";
+import type { Segment, Table } from "metabase-types/api";
+
+import S from "./SegmentBreadcrumbs.module.css";
+
+type SegmentBreadcrumbsProps = {
+ table: Table;
+ segment?: Segment;
+};
+
+export function PublishedTableSegmentBreadcrumbs({
+ table,
+ segment,
+}: SegmentBreadcrumbsProps) {
+ const collection = table.collection;
+ const ancestors = collection ? getCollectionList({ collection }) : [];
+
+ return (
+ <Group c="text-secondary" gap="sm" wrap="nowrap" px="lg" pt="md">
+ {ancestors.map((ancestor, index) => (
+ <Fragment key={ancestor.id}>
+ {index > 0 && <Separator />}
+ <BreadcrumbLink to={Urls.dataStudioCollection(ancestor.id)}>
+ <Ellipsified>{ancestor.name}</Ellipsified>
+ </BreadcrumbLink>
+ </Fragment>
+ ))}
+
+ {collection && (
+ <>
+ {ancestors.length > 0 && <Separator />}
+ <BreadcrumbLink to={Urls.dataStudioCollection(collection.id)}>
+ <Ellipsified>{collection.name}</Ellipsified>
+ </BreadcrumbLink>
+ </>
+ )}
+
+ <Separator />
+ <BreadcrumbLink to={Urls.dataStudioTableSegments(table.id)}>
+ <Ellipsified>{table.display_name}</Ellipsified>
+ </BreadcrumbLink>
+
+ <Separator />
+ <BreadcrumbText>
+ <Ellipsified>{segment?.name ?? t`New segment`}</Ellipsified>
+ </BreadcrumbText>
+ </Group>
+ );
+}
+
+export function DataModelSegmentBreadcrumbs({
+ table,
+ segment,
+}: SegmentBreadcrumbsProps) {
+ const { data: schemas } = useListDatabaseSchemasQuery(
+ table.db_id ? { id: table.db_id } : skipToken,
+ );
+
+ const showSchema = schemas && schemas.length > 1 && table.schema;
+
+ return (
+ <Group c="text-secondary" gap="sm" wrap="nowrap" px="lg" pt="md">
+ {table.db && (
+ <BreadcrumbLink to={Urls.dataStudioData({ databaseId: table.db_id })}>
+ <Ellipsified>{table.db.name}</Ellipsified>
+ </BreadcrumbLink>
+ )}
+
+ {showSchema && (
+ <>
+ <Separator />
+ <BreadcrumbLink
+ to={Urls.dataStudioData({
+ databaseId: table.db_id,
+ schemaName: table.schema,
+ })}
+ >
+ <Ellipsified>{table.schema}</Ellipsified>
+ </BreadcrumbLink>
+ </>
+ )}
+
+ <Separator />
+ <BreadcrumbLink
+ to={Urls.dataStudioData({
+ databaseId: table.db_id,
+ schemaName: table.schema,
+ tableId: table.id,
+ tab: "segments",
+ })}
+ >
+ <Ellipsified>{table.display_name}</Ellipsified>
+ </BreadcrumbLink>
+
+ <Separator />
+ <BreadcrumbText>
+ <Ellipsified>{segment?.name ?? t`New segment`}</Ellipsified>
+ </BreadcrumbText>
+ </Group>
+ );
+}
+
+function BreadcrumbLink({
+ to,
+ children,
+}: {
+ to: string;
+ children: React.ReactNode;
+}) {
+ return (
+ <Link to={to} className={S.link}>
+ <Flex align="center" gap="xs" wrap="nowrap">
+ {children}
+ </Flex>
+ </Link>
+ );
+}
+
+function BreadcrumbText({ children }: { children: React.ReactNode }) {
+ return (
+ <Flex align="center" gap="xs" wrap="nowrap">
+ {children}
+ </Flex>
+ );
+}
+
+function Separator() {
+ return <Text span>/</Text>;
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentBreadcrumbs/SegmentBreadcrumbs.unit.spec.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentBreadcrumbs/SegmentBreadcrumbs.unit.spec.tsx
new file mode 100644
index 00000000000..fc471a6c81c
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentBreadcrumbs/SegmentBreadcrumbs.unit.spec.tsx
@@ -0,0 +1,228 @@
+import { Route } from "react-router";
+
+import {
+ setupSchemaEndpoints,
+ setupTablesEndpoints,
+} from "__support__/server-mocks";
+import { renderWithProviders, screen, waitFor } from "__support__/ui";
+import { checkNotNull } from "metabase/lib/types";
+import type { Segment, Table } from "metabase-types/api";
+import {
+ createMockCollection,
+ createMockDatabase,
+ createMockSegment,
+ createMockTable,
+} from "metabase-types/api/mocks";
+
+import {
+ DataModelSegmentBreadcrumbs,
+ PublishedTableSegmentBreadcrumbs,
+} from "./SegmentBreadcrumbs";
+
+const SINGLE_SCHEMA_DB = createMockDatabase({
+ id: 1,
+ name: "Sample Database",
+ tables: [createMockTable({ schema: "PUBLIC" })],
+});
+
+const TEST_COLLECTION = createMockCollection({
+ id: 1,
+ name: "Data",
+ effective_ancestors: [],
+});
+
+const TEST_TABLE = createMockTable({
+ id: 42,
+ db_id: SINGLE_SCHEMA_DB.id,
+ db: SINGLE_SCHEMA_DB,
+ display_name: "Orders",
+ schema: "PUBLIC",
+ collection_id: TEST_COLLECTION.id,
+ collection: TEST_COLLECTION,
+});
+
+const TEST_SEGMENT = createMockSegment({
+ id: 1,
+ name: "High Value Orders",
+ table_id: TEST_TABLE.id,
+});
+
+describe("PublishedTableSegmentBreadcrumbs", () => {
+ function setup({
+ table = TEST_TABLE,
+ segment,
+ }: {
+ table?: Table;
+ segment?: Segment;
+ } = {}) {
+ renderWithProviders(
+ <Route
+ path="/"
+ component={() => (
+ <PublishedTableSegmentBreadcrumbs table={table} segment={segment} />
+ )}
+ />,
+ { withRouter: true },
+ );
+ }
+
+ it("renders collection as link, table as link to segments, and segment as text", async () => {
+ setup({ segment: TEST_SEGMENT });
+
+ await waitFor(() => {
+ expect(screen.getByText("Data")).toBeInTheDocument();
+ });
+
+ const collectionLink = screen.getByText("Data").closest("a");
+ expect(collectionLink).toHaveAttribute(
+ "href",
+ "/data-studio/library/collections/1",
+ );
+
+ const tableLink = screen.getByText("Orders").closest("a");
+ expect(tableLink).toHaveAttribute(
+ "href",
+ `/data-studio/library/tables/${TEST_TABLE.id}/segments`,
+ );
+
+ const segmentText = screen.getByText("High Value Orders");
+ expect(segmentText.closest("a")).toBeNull();
+ });
+
+ it("renders ancestor chain with separators and correct links", async () => {
+ const grandparent = createMockCollection({ id: 3, name: "Root" });
+ const parent = createMockCollection({
+ id: 2,
+ name: "Analytics",
+ effective_ancestors: [grandparent],
+ });
+ const collection = createMockCollection({
+ id: 1,
+ name: "Sales",
+ effective_ancestors: [grandparent, parent],
+ });
+
+ const tableWithAncestors = createMockTable({
+ ...TEST_TABLE,
+ collection_id: collection.id,
+ collection,
+ });
+
+ setup({ table: tableWithAncestors });
+
+ await waitFor(() => {
+ expect(screen.getByText("Root")).toBeInTheDocument();
+ });
+
+ expect(screen.getByText("Analytics")).toBeInTheDocument();
+ expect(screen.getByText("Sales")).toBeInTheDocument();
+
+ expect(screen.getByText("Root").closest("a")).toHaveAttribute(
+ "href",
+ "/data-studio/library/collections/3",
+ );
+ expect(screen.getByText("Analytics").closest("a")).toHaveAttribute(
+ "href",
+ "/data-studio/library/collections/2",
+ );
+
+ const separators = screen.getAllByText("/");
+ expect(separators.length).toBeGreaterThan(0);
+ });
+
+ it("uses display_name for table and renders 'New segment' when segment undefined", async () => {
+ const tableWithDifferentNames = createMockTable({
+ ...TEST_TABLE,
+ name: "orders_table",
+ display_name: "Customer Orders",
+ });
+
+ setup({ table: tableWithDifferentNames, segment: undefined });
+
+ await waitFor(() => {
+ expect(screen.getByText("Customer Orders")).toBeInTheDocument();
+ });
+
+ expect(screen.queryByText("orders_table")).not.toBeInTheDocument();
+ const newSegmentText = screen.getByText("New segment");
+ expect(newSegmentText).toBeInTheDocument();
+ expect(newSegmentText.closest("a")).toBeNull();
+ });
+
+ it("renders without collection when collection_id is null", async () => {
+ const tableNoCollection = createMockTable({
+ ...TEST_TABLE,
+ id: 44,
+ display_name: "Unpublished Table",
+ collection_id: null,
+ collection: undefined,
+ });
+
+ setup({ table: tableNoCollection });
+
+ await waitFor(() => {
+ expect(screen.getByText("Unpublished Table")).toBeInTheDocument();
+ });
+ });
+});
+
+describe("DataModelSegmentBreadcrumbs", () => {
+ function setup({
+ table = TEST_TABLE,
+ segment,
+ }: {
+ table?: Table;
+ segment?: Segment;
+ } = {}) {
+ setupTablesEndpoints([table]);
+ setupSchemaEndpoints(checkNotNull(table.db));
+
+ renderWithProviders(
+ <Route
+ path="/"
+ component={() => (
+ <DataModelSegmentBreadcrumbs table={table} segment={segment} />
+ )}
+ />,
+ { withRouter: true },
+ );
+ }
+
+ it("renders database as link, table as link to segments tab, and segment as text", async () => {
+ setup({ segment: TEST_SEGMENT });
+
+ await waitFor(() => {
+ expect(screen.getByText("Sample Database")).toBeInTheDocument();
+ });
+
+ const dbLink = screen.getByText("Sample Database").closest("a");
+ expect(dbLink).toHaveAttribute(
+ "href",
+ `/data-studio/data/database/${SINGLE_SCHEMA_DB.id}`,
+ );
+
+ const tableLink = screen.getByText("Orders").closest("a");
+ expect(tableLink).toHaveAttribute(
+ "href",
+ `/data-studio/data/database/${SINGLE_SCHEMA_DB.id}/schema/${SINGLE_SCHEMA_DB.id}:PUBLIC/table/${TEST_TABLE.id}/segments`,
+ );
+
+ const segmentText = screen.getByText("High Value Orders");
+ expect(segmentText.closest("a")).toBeNull();
+ });
+
+ it("hides schema when single schema, shows separators, and renders 'New segment' when undefined", async () => {
+ setup({ segment: undefined });
+
+ await waitFor(() => {
+ expect(screen.getByText("Sample Database")).toBeInTheDocument();
+ });
+
+ expect(screen.queryByText("PUBLIC")).not.toBeInTheDocument();
+ expect(screen.getByText("Orders")).toBeInTheDocument();
+ expect(screen.getByText("New segment")).toBeInTheDocument();
+
+ const separators = screen.getAllByText("/");
+ expect(separators).toHaveLength(2);
+ });
+});
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentBreadcrumbs/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentBreadcrumbs/index.ts
new file mode 100644
index 00000000000..ec91b7ee684
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentBreadcrumbs/index.ts
@@ -0,0 +1,4 @@
+export {
+ DataModelSegmentBreadcrumbs,
+ PublishedTableSegmentBreadcrumbs,
+} from "./SegmentBreadcrumbs";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentEditor/SegmentEditor.module.css b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentEditor/SegmentEditor.module.css
new file mode 100644
index 00000000000..fa3469e028e
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentEditor/SegmentEditor.module.css
@@ -0,0 +1,3 @@
+.scrollable {
+ overflow: auto;
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentEditor/SegmentEditor.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentEditor/SegmentEditor.tsx
new file mode 100644
index 00000000000..e1f1986d29a
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentEditor/SegmentEditor.tsx
@@ -0,0 +1,34 @@
+import { t } from "ttag";
+
+import { SegmentFilterEditor } from "metabase/querying/segments";
+import { Stack, Textarea } from "metabase/ui";
+import type * as Lib from "metabase-lib";
+
+import S from "./SegmentEditor.module.css";
+
+type SegmentEditorProps = {
+ query: Lib.Query | undefined;
+ description: string;
+ onQueryChange: (query: Lib.Query) => void;
+ onDescriptionChange: (description: string) => void;
+};
+
+export function SegmentEditor({
+ query,
+ description,
+ onQueryChange,
+ onDescriptionChange,
+}: SegmentEditorProps) {
+ return (
+ <Stack flex={1} gap="lg" px="lg" py="lg" className={S.scrollable}>
+ {query && <SegmentFilterEditor query={query} onChange={onQueryChange} />}
+ <Textarea
+ label={t`Description`}
+ placeholder={t`Give it a description`}
+ value={description}
+ onChange={(e) => onDescriptionChange(e.target.value)}
+ maw={400}
+ />
+ </Stack>
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentEditor/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentEditor/index.ts
new file mode 100644
index 00000000000..8a60b3e195a
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentEditor/index.ts
@@ -0,0 +1 @@
+export { SegmentEditor } from "./SegmentEditor";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentEditorPage/SegmentEditorPage.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentEditorPage/SegmentEditorPage.tsx
deleted file mode 100644
index b7ecfe9e366..00000000000
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentEditorPage/SegmentEditorPage.tsx
+++ /dev/null
@@ -1,220 +0,0 @@
-import { useEffect, useMemo, useState } from "react";
-import type { Route } from "react-router";
-import { Link } from "react-router";
-import { t } from "ttag";
-
-import EditableText from "metabase/common/components/EditableText";
-import { LeaveRouteConfirmModal } from "metabase/common/components/LeaveConfirmModal";
-import { useSelector } from "metabase/lib/redux";
-import * as Urls from "metabase/lib/urls";
-import { SegmentEditorV2 } from "metabase/querying/segments";
-import { getMetadata } from "metabase/selectors/metadata";
-import {
- Anchor,
- Button,
- FixedSizeIcon,
- Group,
- Stack,
- Textarea,
-} from "metabase/ui";
-import * as Lib from "metabase-lib";
-import type { DatasetQuery, Segment, Table } from "metabase-types/api";
-
-import { SegmentMoreMenu } from "./SegmentMoreMenu";
-import { SegmentPreview } from "./SegmentPreview";
-
-const SEGMENT_NAME_MAX_LENGTH = 254;
-
-type SegmentFormData = {
- name: string;
- description: string;
- definition: DatasetQuery;
-};
-
-type SegmentEditorPageProps = {
- segment?: Segment;
- table: Table;
- route: Route;
- isSaving: boolean;
- isRemoving?: boolean;
- onSave: (data: SegmentFormData) => void;
- onCancel?: () => void;
- onRemove?: () => void;
- testId?: string;
-};
-
-export function SegmentEditorPage({
- segment,
- table,
- route,
- isSaving,
- isRemoving,
- onSave,
- onCancel,
- onRemove,
- testId,
-}: SegmentEditorPageProps) {
- const metadata = useSelector(getMetadata);
-
- const [name, setName] = useState("");
- const [description, setDescription] = useState("");
- const [datasetQuery, setDatasetQuery] = useState<DatasetQuery | null>(null);
-
- const query = useMemo(() => {
- if (!datasetQuery?.database) {
- return undefined;
- }
- const metadataProvider = Lib.metadataProvider(
- datasetQuery.database,
- metadata,
- );
- return Lib.fromJsQuery(metadataProvider, datasetQuery);
- }, [metadata, datasetQuery]);
-
- const filters = useMemo(() => (query ? Lib.filters(query, -1) : []), [query]);
-
- useEffect(() => {
- if (segment) {
- setName(segment.name);
- setDescription(segment.description ?? "");
- setDatasetQuery(segment.definition);
- } else {
- const metadataProvider = Lib.metadataProvider(table.db_id, metadata);
- const tableMetadata = Lib.tableOrCardMetadata(metadataProvider, table.id);
- if (tableMetadata) {
- const initialQuery = Lib.queryFromTableOrCardMetadata(
- metadataProvider,
- tableMetadata,
- );
- setDatasetQuery(Lib.toJsQuery(initialQuery));
- }
- }
- }, [segment, table, metadata]);
-
- const isDirty = useMemo(() => {
- if (segment) {
- if (!datasetQuery) {
- return false;
- }
- const nameChanged = name !== segment.name;
- const descriptionChanged = description !== (segment.description ?? "");
- const queryChanged = !Lib.areLegacyQueriesEqual(
- datasetQuery,
- segment.definition,
- );
- return nameChanged || descriptionChanged || queryChanged;
- }
- return (
- name.trim().length > 0 || description.length > 0 || filters.length > 0
- );
- }, [segment, name, description, datasetQuery, filters]);
-
- const isNew = !segment;
- const hasName = name.trim().length > 0;
- const hasFilters = filters.length > 0;
- const isValid = hasName && hasFilters;
- const showButtons = isNew || isDirty;
- const canSave = showButtons && isValid && !isSaving;
-
- const handleChangeQuery = (newQuery: Lib.Query) => {
- setDatasetQuery(Lib.toJsQuery(newQuery));
- };
-
- const handleSave = () => {
- if (!datasetQuery || !isValid) {
- return;
- }
- onSave({
- name: name.trim(),
- description: description.trim(),
- definition: datasetQuery,
- });
- };
-
- const handleCancel = () => {
- if (segment) {
- setName(segment.name);
- setDescription(segment.description ?? "");
- setDatasetQuery(segment.definition);
- }
- onCancel?.();
- };
-
- const backUrl = Urls.dataStudioData({
- databaseId: table.db_id,
- schemaName: table.schema,
- tableId: table.id,
- tab: "segments",
- });
-
- return (
- <>
- <Stack
- pos="relative"
- w="100%"
- h="100%"
- bg="bg-white"
- px="xl"
- py="lg"
- gap="lg"
- data-testid={testId}
- >
- <Stack gap="sm" align="flex-start">
- <Anchor component={Link} to={backUrl} c="text-medium" fz="sm">
- <Group gap="xs">
- <FixedSizeIcon name="chevronleft" size={12} />
- {t`${table.display_name} segments`}
- </Group>
- </Anchor>
- <Group gap="xs" align="center">
- <EditableText
- initialValue={name}
- placeholder={t`New segment`}
- maxLength={SEGMENT_NAME_MAX_LENGTH}
- p={0}
- fw="bold"
- fz="h3"
- lh="h3"
- onContentChange={setName}
- />
- {segment && onRemove && <SegmentMoreMenu onRemove={onRemove} />}
- </Group>
- </Stack>
- <Stack flex={1} gap="lg">
- {query && (
- <SegmentEditorV2 query={query} onChange={handleChangeQuery} />
- )}
- <Group gap="lg" align="flex-start">
- <Textarea
- label={t`Description`}
- placeholder={t`Give it a description`}
- value={description}
- onChange={(e) => setDescription(e.target.value)}
- maw={400}
- flex={1}
- />
- {query && hasFilters && <SegmentPreview query={query} />}
- </Group>
- {showButtons && (
- <Group>
- <Button onClick={handleCancel}>{t`Cancel`}</Button>
- <Button
- variant="filled"
- disabled={!canSave}
- loading={isSaving}
- onClick={handleSave}
- >
- {t`Save`}
- </Button>
- </Group>
- )}
- </Stack>
- </Stack>
- <LeaveRouteConfirmModal
- key={segment?.id}
- route={route}
- isEnabled={isDirty && !isSaving && !isRemoving}
- />
- </>
- );
-}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentEditorPage/SegmentEditorPage.unit.spec.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentEditorPage/SegmentEditorPage.unit.spec.tsx
deleted file mode 100644
index 5ab5f687219..00000000000
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentEditorPage/SegmentEditorPage.unit.spec.tsx
+++ /dev/null
@@ -1,98 +0,0 @@
-import { Route } from "react-router";
-
-import { renderWithProviders, screen } from "__support__/ui";
-import type { Segment, Table } from "metabase-types/api";
-import { createMockSegment, createMockTable } from "metabase-types/api/mocks";
-
-import { SegmentEditorPage } from "./SegmentEditorPage";
-
-const mockRoute = {
- path: "/",
-};
-
-type SetupOpts = {
- segment?: Segment;
- table?: Table;
- isSaving?: boolean;
- isRemoving?: boolean;
- onRemove?: () => void;
-};
-
-function setup({
- segment,
- table = createMockTable({
- id: 42,
- db_id: 1,
- display_name: "Orders",
- schema: "PUBLIC",
- }),
- isSaving = false,
- isRemoving = false,
- onRemove,
-}: SetupOpts = {}) {
- const onSave = jest.fn();
- const onCancel = jest.fn();
- const onRemoveFn = onRemove ?? jest.fn();
-
- renderWithProviders(
- <Route
- path="/"
- component={() => (
- <SegmentEditorPage
- segment={segment}
- table={table}
- route={mockRoute as any}
- isSaving={isSaving}
- isRemoving={isRemoving}
- onSave={onSave}
- onCancel={onCancel}
- onRemove={segment ? onRemoveFn : undefined}
- testId="segment-editor"
- />
- )}
- />,
- { withRouter: true },
- );
-
- return { onSave, onCancel, onRemove: onRemoveFn };
-}
-
-describe("SegmentEditorPage", () => {
- it("renders new segment form with name placeholder, description, back link, and no menu", () => {
- setup({ segment: undefined });
-
- expect(screen.getByPlaceholderText("New segment")).toBeInTheDocument();
- expect(
- screen.getByPlaceholderText("Give it a description"),
- ).toBeInTheDocument();
- expect(screen.getByText("Orders segments")).toBeInTheDocument();
- expect(
- screen.queryByRole("button", { name: /segment actions/i }),
- ).not.toBeInTheDocument();
- });
-
- it("renders existing segment with name, description, and more menu", () => {
- const segment = createMockSegment({
- id: 1,
- name: "High Value",
- description: "Premium customers",
- });
- setup({ segment, onRemove: jest.fn() });
-
- expect(screen.getByDisplayValue("High Value")).toBeInTheDocument();
- expect(screen.getByDisplayValue("Premium customers")).toBeInTheDocument();
- expect(
- screen.getByRole("button", { name: /segment actions/i }),
- ).toBeInTheDocument();
- });
-
- it("links back to segments tab with correct URL", () => {
- setup({ segment: undefined });
-
- const backLink = screen.getByText("Orders segments").closest("a");
- expect(backLink).toHaveAttribute(
- "href",
- "/data-studio/data/database/1/schema/1:PUBLIC/table/42/segments",
- );
- });
-});
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentEditorPage/SegmentPreview/SegmentPreview.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentEditorPage/SegmentPreview/SegmentPreview.tsx
deleted file mode 100644
index 9212d6b95b8..00000000000
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentEditorPage/SegmentPreview/SegmentPreview.tsx
+++ /dev/null
@@ -1,43 +0,0 @@
-import { useMemo } from "react";
-import { Link } from "react-router";
-import { P, match } from "ts-pattern";
-import { t } from "ttag";
-
-import { useGetAdhocQueryQuery } from "metabase/api";
-import * as Urls from "metabase/lib/urls";
-import { Button, Group, Icon, Loader, Text } from "metabase/ui";
-import * as Lib from "metabase-lib";
-
-type SegmentPreviewProps = {
- query: Lib.Query;
-};
-
-export function SegmentPreview({ query }: SegmentPreviewProps) {
- const countQuery = useMemo(() => Lib.aggregateByCount(query, -1), [query]);
-
- const { data, isFetching } = useGetAdhocQueryQuery(Lib.toJsQuery(countQuery));
- const count = data?.data?.rows?.[0]?.[0];
-
- const previewUrl = Urls.newQuestion({
- dataset_query: Lib.toJsQuery(query),
- });
-
- return (
- <Group gap="md" ml="auto">
- {match({ isFetching, count })
- .with({ isFetching: true }, () => <Loader size="xs" />)
- .with({ isFetching: false, count: P.nonNullable }, ({ count }) => (
- <Text>{t`${count} rows`}</Text>
- ))
- .otherwise(() => null)}
- <Button
- component={Link}
- to={previewUrl}
- target="_blank"
- leftSection={<Icon name="share" size={16} />}
- variant="filled"
- size="compact-sm"
- >{t`Preview`}</Button>
- </Group>
- );
-}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentEditorPage/SegmentPreview/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentEditorPage/SegmentPreview/index.ts
deleted file mode 100644
index f5e3eba92f8..00000000000
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentEditorPage/SegmentPreview/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { SegmentPreview } from "./SegmentPreview";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentEditorPage/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentEditorPage/index.ts
deleted file mode 100644
index 83faa216f8c..00000000000
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentEditorPage/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { SegmentEditorPage } from "./SegmentEditorPage";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentHeader/SegmentHeader.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentHeader/SegmentHeader.tsx
new file mode 100644
index 00000000000..6ff0bc1508e
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentHeader/SegmentHeader.tsx
@@ -0,0 +1,94 @@
+import type { ReactNode } from "react";
+import { t } from "ttag";
+
+import { useUpdateSegmentMutation } from "metabase/api";
+import { useMetadataToasts } from "metabase/metadata/hooks";
+import { Stack } from "metabase/ui";
+import {
+ PaneHeader,
+ PaneHeaderInput,
+} from "metabase-enterprise/data-studio/common/components/PaneHeader";
+import type { SegmentTabUrls } from "metabase-enterprise/data-studio/segments/types";
+import type { Segment } from "metabase-types/api";
+
+import { SegmentMoreMenu } from "../SegmentMoreMenu";
+
+import { SegmentTabs } from "./SegmentTabs";
+
+const SEGMENT_NAME_MAX_LENGTH = 254;
+
+type SegmentHeaderProps = {
+ segment: Segment;
+ tabUrls: SegmentTabUrls;
+ previewUrl?: string;
+ onRemove: () => void;
+ onNameChange?: (name: string) => void;
+ breadcrumbs?: ReactNode;
+ actions?: ReactNode;
+};
+
+export function SegmentHeader({
+ segment,
+ tabUrls,
+ previewUrl,
+ onRemove,
+ onNameChange,
+ breadcrumbs,
+ actions,
+}: SegmentHeaderProps) {
+ return (
+ <Stack gap={0}>
+ {breadcrumbs}
+ <PaneHeader
+ data-testid="segment-pane-header"
+ title={
+ <SegmentNameInput segment={segment} onNameChange={onNameChange} />
+ }
+ icon="segment"
+ menu={<SegmentMoreMenu previewUrl={previewUrl} onRemove={onRemove} />}
+ tabs={<SegmentTabs urls={tabUrls} />}
+ actions={actions}
+ />
+ </Stack>
+ );
+}
+
+type SegmentNameInputProps = {
+ segment: Segment;
+ onNameChange?: (name: string) => void;
+};
+
+function SegmentNameInput({ segment, onNameChange }: SegmentNameInputProps) {
+ const [updateSegment] = useUpdateSegmentMutation();
+ const { sendSuccessToast, sendErrorToast } = useMetadataToasts();
+
+ const handleChange = async (newName: string) => {
+ onNameChange?.(newName);
+
+ if (newName === segment.name) {
+ return;
+ }
+
+ const { error } = await updateSegment({
+ id: segment.id,
+ name: newName,
+ revision_message: t`Updated segment name`,
+ });
+
+ if (error) {
+ sendErrorToast(t`Failed to update segment name`);
+ } else {
+ sendSuccessToast(t`Segment name updated`);
+ }
+ };
+
+ return (
+ <PaneHeaderInput
+ initialValue={segment.name}
+ placeholder={t`New segment`}
+ maxLength={SEGMENT_NAME_MAX_LENGTH}
+ onChange={handleChange}
+ onContentChange={onNameChange}
+ />
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentHeader/SegmentTabs.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentHeader/SegmentTabs.tsx
new file mode 100644
index 00000000000..40a141270bf
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentHeader/SegmentTabs.tsx
@@ -0,0 +1,40 @@
+import { t } from "ttag";
+
+import { useSelector } from "metabase/lib/redux";
+import { PLUGIN_DEPENDENCIES } from "metabase/plugins";
+import { getLocation } from "metabase/selectors/routing";
+import {
+ type PaneHeaderTab,
+ PaneHeaderTabs,
+} from "metabase-enterprise/data-studio/common/components/PaneHeader";
+import type { SegmentTabUrls } from "metabase-enterprise/data-studio/segments/types";
+
+type SegmentTabsProps = {
+ urls: SegmentTabUrls;
+};
+
+export function SegmentTabs({ urls }: SegmentTabsProps) {
+ const location = useSelector(getLocation);
+
+ const tabs: PaneHeaderTab[] = [
+ {
+ label: t`Definition`,
+ to: urls.definition,
+ },
+ {
+ label: t`Revision history`,
+ to: urls.revisions,
+ isSelected: location.pathname.startsWith(urls.revisions),
+ },
+ ];
+
+ if (PLUGIN_DEPENDENCIES.isEnabled) {
+ tabs.push({
+ label: t`Dependencies`,
+ to: urls.dependencies,
+ isSelected: location.pathname.startsWith(urls.dependencies),
+ });
+ }
+
+ return <PaneHeaderTabs tabs={tabs} />;
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentHeader/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentHeader/index.ts
new file mode 100644
index 00000000000..ae01edd374c
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentHeader/index.ts
@@ -0,0 +1,2 @@
+export { SegmentHeader } from "./SegmentHeader";
+export { SegmentTabs } from "./SegmentTabs";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentEditorPage/SegmentMoreMenu/SegmentMoreMenu.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentMoreMenu/SegmentMoreMenu.tsx
similarity index 54%
rename from enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentEditorPage/SegmentMoreMenu/SegmentMoreMenu.tsx
rename to enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentMoreMenu/SegmentMoreMenu.tsx
index 10ffa12a2a2..96f69a5ecfb 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentEditorPage/SegmentMoreMenu/SegmentMoreMenu.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentMoreMenu/SegmentMoreMenu.tsx
@@ -1,22 +1,31 @@
import { useDisclosure } from "@mantine/hooks";
+import { Link } from "react-router";
import { t } from "ttag";
import { ConfirmModal } from "metabase/common/components/ConfirmModal";
import { ActionIcon, Icon, Menu } from "metabase/ui";
type SegmentMoreMenuProps = {
- onRemove: () => void;
+ previewUrl?: string;
+ onRemove?: () => void;
};
-export function SegmentMoreMenu({ onRemove }: SegmentMoreMenuProps) {
+export function SegmentMoreMenu({
+ previewUrl,
+ onRemove,
+}: SegmentMoreMenuProps) {
const [isConfirmOpen, { open: openConfirm, close: closeConfirm }] =
useDisclosure();
const handleConfirm = () => {
closeConfirm();
- onRemove();
+ onRemove?.();
};
+ if (!previewUrl && !onRemove) {
+ return null;
+ }
+
return (
<>
<Menu>
@@ -26,13 +35,25 @@ export function SegmentMoreMenu({ onRemove }: SegmentMoreMenuProps) {
</ActionIcon>
</Menu.Target>
<Menu.Dropdown>
- <Menu.Item
- c="danger"
- leftSection={<Icon name="trash" />}
- onClick={openConfirm}
- >
- {t`Remove segment`}
- </Menu.Item>
+ {previewUrl && (
+ <Menu.Item
+ component={Link}
+ to={previewUrl}
+ target="_blank"
+ leftSection={<Icon name="share" />}
+ >
+ {t`Preview`}
+ </Menu.Item>
+ )}
+ {onRemove && (
+ <Menu.Item
+ c="danger"
+ leftSection={<Icon name="trash" />}
+ onClick={openConfirm}
+ >
+ {t`Remove segment`}
+ </Menu.Item>
+ )}
</Menu.Dropdown>
</Menu>
<ConfirmModal
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentEditorPage/SegmentMoreMenu/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentMoreMenu/index.ts
similarity index 100%
rename from enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentEditorPage/SegmentMoreMenu/index.ts
rename to enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentMoreMenu/index.ts
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentRevisionHistory/SegmentRevisionDiff.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentRevisionHistory/SegmentRevisionDiff.tsx
new file mode 100644
index 00000000000..0140c188a8b
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentRevisionHistory/SegmentRevisionDiff.tsx
@@ -0,0 +1,133 @@
+import { diffWords } from "diff";
+import { t } from "ttag";
+
+import { QueryDefinition } from "metabase/admin/datamodel/components/QueryDefinition";
+import { Box, Flex, Icon, Text } from "metabase/ui";
+import type { DatasetQuery, TableId } from "metabase-types/api";
+
+type DiffValue = {
+ before?: unknown;
+ after?: unknown;
+};
+
+type SegmentRevisionDiffProps = {
+ property: string;
+ diff: DiffValue | undefined;
+ tableId: TableId;
+};
+
+export function SegmentRevisionDiff({
+ property,
+ diff,
+ tableId,
+}: SegmentRevisionDiffProps) {
+ if (!diff) {
+ return null;
+ }
+
+ const { before, after } = diff;
+ const label = getPropertyLabel(property);
+
+ return (
+ <Box p="md" bg="bg-light" bd="1px solid border">
+ <Flex align="center" gap="sm" mb="sm">
+ <DiffIcon before={before} after={after} />
+ <Text size="sm" fw={400} c="text-secondary">
+ {label}
+ </Text>
+ </Flex>
+
+ {property === "definition" ? (
+ <DefinitionDiff before={before} after={after} tableId={tableId} />
+ ) : (
+ <TextDiff before={before} after={after} />
+ )}
+ </Box>
+ );
+}
+
+function DiffIcon({ before, after }: { before: unknown; after: unknown }) {
+ if (before != null && after != null) {
+ return <Icon name="pencil" size={12} c="text-secondary" />;
+ }
+ if (before != null) {
+ return <Icon name="dash" size={12} c="error" />;
+ }
+ return <Icon name="add" size={12} c="success" />;
+}
+
+function getPropertyLabel(property: string): string {
+ switch (property) {
+ case "name":
+ return t`Name`;
+ case "description":
+ return t`Description`;
+ case "definition":
+ return t`Filter`;
+ default:
+ return property;
+ }
+}
+
+type TextDiffProps = {
+ before: unknown;
+ after: unknown;
+};
+
+function TextDiff({ before, after }: TextDiffProps) {
+ const beforeStr = typeof before === "string" ? before : undefined;
+ const afterStr = typeof after === "string" ? after : undefined;
+
+ if (beforeStr != null && afterStr != null) {
+ const parts = diffWords(beforeStr, afterStr);
+ return (
+ <Text size="sm">
+ {parts.map((part, index) => (
+ <Text
+ key={index}
+ span
+ fw={part.added ? 600 : undefined}
+ td={part.removed ? "line-through" : undefined}
+ c={part.removed ? "text-tertiary" : undefined}
+ >
+ {part.value}
+ </Text>
+ ))}
+ </Text>
+ );
+ }
+
+ if (beforeStr != null) {
+ return (
+ <Text size="sm" td="line-through" c="text-tertiary">
+ {beforeStr}
+ </Text>
+ );
+ }
+
+ return (
+ <Text size="sm" fw={600}>
+ {afterStr}
+ </Text>
+ );
+}
+
+type DefinitionDiffProps = {
+ before: unknown;
+ after: unknown;
+ tableId: TableId;
+};
+
+function isDatasetQuery(value: unknown): value is DatasetQuery {
+ return value != null && typeof value === "object";
+}
+
+function DefinitionDiff({ before, after, tableId }: DefinitionDiffProps) {
+ const definition = after ?? before;
+
+ if (!isDatasetQuery(definition)) {
+ return null;
+ }
+
+ return <QueryDefinition definition={definition} tableId={tableId} />;
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentRevisionHistory/SegmentRevisionHistory.module.css b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentRevisionHistory/SegmentRevisionHistory.module.css
new file mode 100644
index 00000000000..6627d21d301
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentRevisionHistory/SegmentRevisionHistory.module.css
@@ -0,0 +1,3 @@
+.messageAccent {
+ border-left: 2px solid var(--mb-color-border);
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentRevisionHistory/SegmentRevisionHistory.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentRevisionHistory/SegmentRevisionHistory.tsx
new file mode 100644
index 00000000000..43c05823565
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentRevisionHistory/SegmentRevisionHistory.tsx
@@ -0,0 +1,68 @@
+import { useMemo } from "react";
+import { t } from "ttag";
+
+import { useListRevisionsQuery } from "metabase/api";
+import { LoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper";
+import { assignUserColors } from "metabase/lib/formatting";
+import { useSelector } from "metabase/lib/redux";
+import { getUserId } from "metabase/selectors/user";
+import { Center, Stack, Text, Timeline } from "metabase/ui";
+import type { Segment } from "metabase-types/api";
+
+import { SegmentRevisionItem } from "./SegmentRevisionItem";
+
+type SegmentRevisionHistoryProps = {
+ segment: Segment;
+};
+
+export function SegmentRevisionHistory({
+ segment,
+}: SegmentRevisionHistoryProps) {
+ const currentUserId = useSelector(getUserId);
+ const {
+ data: revisions,
+ isLoading,
+ error,
+ } = useListRevisionsQuery({ entity: "segment", id: segment.id });
+
+ const userColorAssignments = useMemo(() => {
+ if (!revisions || currentUserId == null) {
+ return {};
+ }
+ return assignUserColors(
+ revisions.map((r) => String(r.user.id)),
+ String(currentUserId),
+ );
+ }, [revisions, currentUserId]);
+
+ if (isLoading || error != null) {
+ return (
+ <Center h="100%">
+ <LoadingAndErrorWrapper loading={isLoading} error={error} />
+ </Center>
+ );
+ }
+
+ if (!revisions || revisions.length === 0) {
+ return (
+ <Center h="100%">
+ <Text c="text-secondary">{t`No revision history available.`}</Text>
+ </Center>
+ );
+ }
+
+ return (
+ <Stack p="xl" maw={720} mx="auto" w="100%">
+ <Timeline bulletSize={40} lineWidth={2}>
+ {revisions.map((revision) => (
+ <SegmentRevisionItem
+ key={revision.id}
+ revision={revision}
+ tableId={segment.table_id}
+ userColor={userColorAssignments[String(revision.user.id)]}
+ />
+ ))}
+ </Timeline>
+ </Stack>
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentRevisionHistory/SegmentRevisionHistory.unit.spec.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentRevisionHistory/SegmentRevisionHistory.unit.spec.tsx
new file mode 100644
index 00000000000..e4fe36e3d87
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentRevisionHistory/SegmentRevisionHistory.unit.spec.tsx
@@ -0,0 +1,293 @@
+import {
+ setupSegmentRevisionsEndpoint,
+ setupSegmentRevisionsEndpointError,
+} from "__support__/server-mocks";
+import {
+ renderWithProviders,
+ screen,
+ waitForLoaderToBeRemoved,
+} from "__support__/ui";
+import type { Revision, Segment } from "metabase-types/api";
+import {
+ createMockRevision,
+ createMockSegment,
+ createMockUser,
+} from "metabase-types/api/mocks";
+import { createMockState } from "metabase-types/store/mocks";
+
+import { SegmentRevisionHistory } from "./SegmentRevisionHistory";
+
+const TEST_SEGMENT = createMockSegment({
+ id: 1,
+ name: "Test Segment",
+ table_id: 42,
+});
+
+type SetupOpts = {
+ segment?: Segment;
+ revisions?: Revision[];
+ hasError?: boolean;
+ currentUserId?: number;
+};
+
+function setup({
+ segment = TEST_SEGMENT,
+ revisions = [],
+ hasError = false,
+ currentUserId = 1,
+}: SetupOpts = {}) {
+ if (hasError) {
+ setupSegmentRevisionsEndpointError(segment.id);
+ } else {
+ setupSegmentRevisionsEndpoint(segment.id, revisions);
+ }
+
+ const storeInitialState = createMockState({
+ currentUser: createMockUser({
+ id: currentUserId,
+ first_name: "Current",
+ last_name: "User",
+ common_name: "Current User",
+ }),
+ });
+
+ renderWithProviders(<SegmentRevisionHistory segment={segment} />, {
+ storeInitialState,
+ });
+}
+
+describe("SegmentRevisionHistory", () => {
+ it("shows loading state while fetching revisions", async () => {
+ setup({ revisions: [] });
+ expect(screen.getByTestId("loading-indicator")).toBeInTheDocument();
+ await waitForLoaderToBeRemoved();
+ });
+
+ it("shows error state when API fails", async () => {
+ setup({ hasError: true });
+ await waitForLoaderToBeRemoved();
+ expect(screen.getByText("Server error")).toBeInTheDocument();
+ });
+
+ it("shows empty state message when no revisions exist", async () => {
+ setup({ revisions: [] });
+ await waitForLoaderToBeRemoved();
+
+ expect(
+ screen.getByText("No revision history available."),
+ ).toBeInTheDocument();
+ });
+
+ it("renders revision with user name, action, and avatar initials", async () => {
+ const revisions = [
+ createMockRevision({
+ id: 1,
+ is_creation: true,
+ user: {
+ id: 99,
+ first_name: "John",
+ last_name: "Doe",
+ common_name: "John Doe",
+ },
+ }),
+ ];
+
+ setup({ revisions });
+ await waitForLoaderToBeRemoved();
+
+ expect(screen.getByText("John Doe")).toBeInTheDocument();
+ expect(screen.getByText("created this segment")).toBeInTheDocument();
+ expect(screen.getByText("JD")).toBeInTheDocument();
+ });
+
+ it("shows 'You' instead of name for current user's revisions", async () => {
+ const revisions = [
+ createMockRevision({
+ id: 1,
+ is_creation: true,
+ user: {
+ id: 1,
+ first_name: "Current",
+ last_name: "User",
+ common_name: "Current User",
+ },
+ }),
+ ];
+
+ setup({ revisions, currentUserId: 1 });
+ await waitForLoaderToBeRemoved();
+
+ expect(screen.getByText("You")).toBeInTheDocument();
+ expect(screen.queryByText("Current User")).not.toBeInTheDocument();
+ });
+
+ it("displays multiple revision items with different users", async () => {
+ const revisions = [
+ createMockRevision({
+ id: 2,
+ is_creation: false,
+ diff: { name: { before: "Old", after: "New" } },
+ user: {
+ id: 98,
+ first_name: "Alice",
+ last_name: "Smith",
+ common_name: "Alice Smith",
+ },
+ }),
+ createMockRevision({
+ id: 1,
+ is_creation: true,
+ user: {
+ id: 99,
+ first_name: "Bob",
+ last_name: "Jones",
+ common_name: "Bob Jones",
+ },
+ }),
+ ];
+
+ setup({ revisions });
+ await waitForLoaderToBeRemoved();
+
+ expect(screen.getByText("Alice Smith")).toBeInTheDocument();
+ expect(screen.getByText("Bob Jones")).toBeInTheDocument();
+ expect(screen.getByText("renamed the segment")).toBeInTheDocument();
+ expect(screen.getByText("created this segment")).toBeInTheDocument();
+ });
+
+ it("shows correct action descriptions for different change types", async () => {
+ const revisions = [
+ createMockRevision({
+ id: 4,
+ is_creation: false,
+ is_reversion: true,
+ user: {
+ id: 96,
+ first_name: "D",
+ last_name: "D",
+ common_name: "User D",
+ },
+ }),
+ createMockRevision({
+ id: 3,
+ is_creation: false,
+ diff: { description: { before: "Old", after: "New" } },
+ user: {
+ id: 97,
+ first_name: "C",
+ last_name: "C",
+ common_name: "User C",
+ },
+ }),
+ createMockRevision({
+ id: 2,
+ is_creation: false,
+ diff: {
+ definition: {
+ before: { filter: ["<", ["field", 1, null], 100] },
+ after: { filter: [">", ["field", 1, null], 200] },
+ },
+ },
+ user: {
+ id: 98,
+ first_name: "B",
+ last_name: "B",
+ common_name: "User B",
+ },
+ }),
+ createMockRevision({
+ id: 1,
+ is_creation: true,
+ user: {
+ id: 99,
+ first_name: "A",
+ last_name: "A",
+ common_name: "User A",
+ },
+ }),
+ ];
+
+ setup({ revisions });
+ await waitForLoaderToBeRemoved();
+
+ expect(
+ screen.getByText("reverted to a previous version"),
+ ).toBeInTheDocument();
+ expect(screen.getByText("updated the description")).toBeInTheDocument();
+ expect(
+ screen.getByText("changed the filter definition"),
+ ).toBeInTheDocument();
+ expect(screen.getByText("created this segment")).toBeInTheDocument();
+ });
+
+ it("shows 'made multiple changes' for multi-field updates and 'made changes' for empty diff", async () => {
+ const revisions = [
+ createMockRevision({
+ id: 2,
+ is_creation: false,
+ diff: {
+ name: { before: "Old", after: "New" },
+ description: { before: "Old desc", after: "New desc" },
+ },
+ user: {
+ id: 98,
+ first_name: "A",
+ last_name: "A",
+ common_name: "User A",
+ },
+ }),
+ createMockRevision({
+ id: 1,
+ is_creation: false,
+ diff: {},
+ user: {
+ id: 99,
+ first_name: "B",
+ last_name: "B",
+ common_name: "User B",
+ },
+ }),
+ ];
+
+ setup({ revisions });
+ await waitForLoaderToBeRemoved();
+
+ expect(screen.getByText("made multiple changes")).toBeInTheDocument();
+ expect(screen.getByText("made changes")).toBeInTheDocument();
+ });
+
+ it("displays revision message when provided, omits when null", async () => {
+ const revisions = [
+ createMockRevision({
+ id: 2,
+ is_creation: false,
+ message: "Updated from Data Studio",
+ diff: { name: { before: "Old", after: "New" } },
+ user: {
+ id: 98,
+ first_name: "A",
+ last_name: "A",
+ common_name: "User A",
+ },
+ }),
+ createMockRevision({
+ id: 1,
+ is_creation: false,
+ message: null,
+ diff: { description: { before: "Old", after: "New" } },
+ user: {
+ id: 99,
+ first_name: "B",
+ last_name: "B",
+ common_name: "User B",
+ },
+ }),
+ ];
+
+ setup({ revisions });
+ await waitForLoaderToBeRemoved();
+
+ expect(screen.getByText("Updated from Data Studio")).toBeInTheDocument();
+ expect(screen.getAllByText(/User [AB]/)).toHaveLength(2);
+ });
+});
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentRevisionHistory/SegmentRevisionItem.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentRevisionHistory/SegmentRevisionItem.tsx
new file mode 100644
index 00000000000..2585c241916
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentRevisionHistory/SegmentRevisionItem.tsx
@@ -0,0 +1,134 @@
+import dayjs from "dayjs";
+import relativeTime from "dayjs/plugin/relativeTime";
+import { t } from "ttag";
+
+import UserAvatar from "metabase/common/components/UserAvatar";
+import { useSelector } from "metabase/lib/redux";
+import { getUserId } from "metabase/selectors/user";
+import { Box, Flex, Stack, Text, Timeline } from "metabase/ui";
+import type { Revision, TableId } from "metabase-types/api";
+
+import { SegmentRevisionDiff } from "./SegmentRevisionDiff";
+import S from "./SegmentRevisionHistory.module.css";
+
+dayjs.extend(relativeTime);
+
+type SegmentRevisionItemProps = {
+ revision: Revision;
+ tableId: TableId;
+ userColor?: string;
+};
+
+export function SegmentRevisionItem({
+ revision,
+ tableId,
+ userColor,
+}: SegmentRevisionItemProps) {
+ const currentUserId = useSelector(getUserId);
+ const isCurrentUser = revision.user.id === currentUserId;
+ const userName = isCurrentUser ? t`You` : revision.user.common_name;
+
+ const action = getActionDescription(revision);
+ const timestamp = dayjs(revision.timestamp);
+ const timeAgo = timestamp.fromNow();
+ const formattedDate = timestamp.format("MMM D, YYYY [at] h:mm A");
+
+ const diffKeys = getDiffKeys(revision);
+
+ return (
+ <Timeline.Item bullet={<UserAvatar user={revision.user} bg={userColor} />}>
+ <Stack gap="sm" ml="md">
+ <Flex justify="space-between" align="flex-start" gap="md">
+ <Stack gap={2}>
+ <Text fw={600} size="md">
+ {userName}
+ </Text>
+ <Text c="text-secondary" size="sm">
+ {action}
+ </Text>
+ </Stack>
+ <Text size="sm" c="text-tertiary" title={formattedDate}>
+ {timeAgo}
+ </Text>
+ </Flex>
+
+ {revision.message && (
+ <Box pl="sm" className={S.messageAccent}>
+ <Text size="sm" c="text-secondary">
+ {revision.message}
+ </Text>
+ </Box>
+ )}
+
+ {diffKeys.length > 0 && (
+ <Stack gap="sm" mt="sm">
+ {diffKeys.map((key) => (
+ <SegmentRevisionDiff
+ key={key}
+ property={key}
+ diff={getDiffForKey(revision.diff, key)}
+ tableId={tableId}
+ />
+ ))}
+ </Stack>
+ )}
+ </Stack>
+ </Timeline.Item>
+ );
+}
+
+function getActionDescription(revision: Revision): string {
+ if (revision.is_creation) {
+ return t`created this segment`;
+ }
+ if (revision.is_reversion) {
+ return t`reverted to a previous version`;
+ }
+
+ const changedKeys = Object.keys(revision.diff || {});
+ if (changedKeys.length === 1) {
+ switch (changedKeys[0]) {
+ case "name":
+ return t`renamed the segment`;
+ case "description":
+ return t`updated the description`;
+ case "definition":
+ return t`changed the filter definition`;
+ }
+ }
+
+ if (changedKeys.length > 1) {
+ return t`made multiple changes`;
+ }
+
+ return t`made changes`;
+}
+
+type RevisionDiff = Record<string, { before?: unknown; after?: unknown }>;
+
+function getDiffKeys(revision: Revision): string[] {
+ if (!revision.diff) {
+ return [];
+ }
+
+ const diff = revision.diff as unknown as RevisionDiff;
+ let keys = Object.keys(diff);
+
+ if (revision.is_creation) {
+ keys = keys.filter((k) => k !== "name" && k !== "description");
+ }
+
+ return keys;
+}
+
+function getDiffForKey(
+ diff: Revision["diff"],
+ key: string,
+): { before?: unknown; after?: unknown } | undefined {
+ if (!diff) {
+ return undefined;
+ }
+
+ const revisionDiff = diff as unknown as RevisionDiff;
+ return revisionDiff[key];
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentRevisionHistory/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentRevisionHistory/index.ts
new file mode 100644
index 00000000000..9fdd148ae15
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/components/SegmentRevisionHistory/index.ts
@@ -0,0 +1 @@
+export { SegmentRevisionHistory } from "./SegmentRevisionHistory";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/hooks/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/hooks/index.ts
new file mode 100644
index 00000000000..33d2d77f713
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/hooks/index.ts
@@ -0,0 +1,2 @@
+export { useDataModelSegmentPage } from "./use-data-model-segment-page";
+export { usePublishedTableSegmentPage } from "./use-published-table-segment-page";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/hooks/use-data-model-segment-page.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/hooks/use-data-model-segment-page.ts
new file mode 100644
index 00000000000..bd274e0d900
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/hooks/use-data-model-segment-page.ts
@@ -0,0 +1,108 @@
+import { useCallback, useMemo } from "react";
+import { push } from "react-router-redux";
+import { t } from "ttag";
+
+import {
+ skipToken,
+ useDeleteSegmentMutation,
+ useGetSegmentQuery,
+} from "metabase/api";
+import { useDispatch } from "metabase/lib/redux";
+import * as Urls from "metabase/lib/urls";
+import { useMetadataToasts } from "metabase/metadata/hooks";
+import { getSchemaName } from "metabase-lib/v1/metadata/utils/schema";
+
+import { useLoadTableWithMetadata } from "../../common/hooks/use-load-table-with-metadata";
+import type { SegmentTabUrls } from "../types";
+
+type DataModelSegmentPageParams = {
+ databaseId: string;
+ schemaId: string;
+ tableId: string;
+ segmentId: string;
+};
+
+export function useDataModelSegmentPage(params: DataModelSegmentPageParams) {
+ const dispatch = useDispatch();
+ const { sendSuccessToast, sendErrorToast } = useMetadataToasts();
+ const [deleteSegment] = useDeleteSegmentMutation();
+
+ const databaseId = Number(params.databaseId);
+ const schemaName = getSchemaName(params.schemaId);
+ const tableId = Urls.extractEntityId(params.tableId);
+ const segmentId = Urls.extractEntityId(params.segmentId);
+
+ const {
+ data: segment,
+ isLoading: isLoadingSegment,
+ error: segmentError,
+ } = useGetSegmentQuery(segmentId ?? skipToken);
+
+ const {
+ table,
+ isLoading: isLoadingTable,
+ error: tableError,
+ } = useLoadTableWithMetadata(segment?.table_id, {
+ includeForeignTables: true,
+ });
+
+ const handleRemove = useCallback(async () => {
+ if (segment == null || tableId == null || schemaName == null) {
+ return;
+ }
+
+ const { error } = await deleteSegment({
+ id: segment.id,
+ revision_message: t`Removed from Data Studio`,
+ });
+
+ if (error) {
+ sendErrorToast(t`Failed to remove segment`);
+ } else {
+ sendSuccessToast(t`Segment removed`);
+ dispatch(
+ push(
+ Urls.dataStudioData({
+ databaseId,
+ schemaName,
+ tableId,
+ tab: "segments",
+ }),
+ ),
+ );
+ }
+ }, [
+ segment,
+ tableId,
+ schemaName,
+ databaseId,
+ deleteSegment,
+ dispatch,
+ sendSuccessToast,
+ sendErrorToast,
+ ]);
+
+ const isLoading = isLoadingSegment || isLoadingTable;
+ const error = segmentError ?? tableError;
+
+ const tabUrls: SegmentTabUrls | null = useMemo(() => {
+ if (tableId == null || schemaName == null || segmentId == null) {
+ return null;
+ }
+ const urlParams = { databaseId, schemaName, tableId, segmentId };
+ return {
+ definition: Urls.dataStudioDataModelSegment(urlParams),
+ revisions: Urls.dataStudioDataModelSegmentRevisions(urlParams),
+ dependencies: Urls.dataStudioDataModelSegmentDependencies(urlParams),
+ };
+ }, [databaseId, schemaName, tableId, segmentId]);
+
+ return {
+ isLoading,
+ error,
+ segment: segment ?? null,
+ table: table ?? null,
+ tabUrls,
+ onRemove: handleRemove,
+ };
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/hooks/use-published-table-segment-page.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/hooks/use-published-table-segment-page.ts
new file mode 100644
index 00000000000..7866cc7e4a4
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/hooks/use-published-table-segment-page.ts
@@ -0,0 +1,92 @@
+import { useCallback, useMemo } from "react";
+import { push } from "react-router-redux";
+import { t } from "ttag";
+
+import {
+ skipToken,
+ useDeleteSegmentMutation,
+ useGetSegmentQuery,
+} from "metabase/api";
+import { useToast } from "metabase/common/hooks/use-toast";
+import { useDispatch } from "metabase/lib/redux";
+import * as Urls from "metabase/lib/urls";
+
+import { useLoadTableWithMetadata } from "../../common/hooks/use-load-table-with-metadata";
+import type { SegmentTabUrls } from "../types";
+
+type PublishedTableSegmentPageParams = {
+ tableId: string;
+ segmentId: string;
+};
+
+export function usePublishedTableSegmentPage(
+ params: PublishedTableSegmentPageParams,
+) {
+ const dispatch = useDispatch();
+ const [sendToast] = useToast();
+ const [deleteSegment] = useDeleteSegmentMutation();
+
+ const tableId = Urls.extractEntityId(params.tableId);
+ const segmentId = Urls.extractEntityId(params.segmentId);
+
+ const {
+ data: segment,
+ isLoading: isLoadingSegment,
+ error: segmentError,
+ } = useGetSegmentQuery(segmentId ?? skipToken);
+
+ const {
+ table,
+ isLoading: isLoadingTable,
+ error: tableError,
+ } = useLoadTableWithMetadata(segment?.table_id, {
+ includeForeignTables: true,
+ });
+
+ const handleRemove = useCallback(async () => {
+ if (segment == null || tableId == null) {
+ return;
+ }
+
+ const { error } = await deleteSegment({
+ id: segment.id,
+ revision_message: t`Removed from Data Studio`,
+ });
+
+ if (error) {
+ sendToast({ icon: "warning", message: t`Failed to remove segment` });
+ } else {
+ sendToast({ icon: "check", message: t`Segment removed` });
+ dispatch(push(Urls.dataStudioTableSegments(tableId)));
+ }
+ }, [segment, tableId, deleteSegment, dispatch, sendToast]);
+
+ const isLoading = isLoadingSegment || isLoadingTable;
+ const error = segmentError ?? tableError;
+
+ const tabUrls: SegmentTabUrls | null = useMemo(() => {
+ if (tableId == null || segmentId == null) {
+ return null;
+ }
+ return {
+ definition: Urls.dataStudioPublishedTableSegment(tableId, segmentId),
+ revisions: Urls.dataStudioPublishedTableSegmentRevisions(
+ tableId,
+ segmentId,
+ ),
+ dependencies: Urls.dataStudioPublishedTableSegmentDependencies(
+ tableId,
+ segmentId,
+ ),
+ };
+ }, [tableId, segmentId]);
+
+ return {
+ isLoading,
+ error,
+ segment: segment ?? null,
+ table: table ?? null,
+ tabUrls,
+ onRemove: handleRemove,
+ };
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/hooks/use-segment-query.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/hooks/use-segment-query.ts
new file mode 100644
index 00000000000..5aed9fc82e9
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/hooks/use-segment-query.ts
@@ -0,0 +1,30 @@
+import { useMemo } from "react";
+
+import * as Lib from "metabase-lib";
+import type Metadata from "metabase-lib/v1/metadata/Metadata";
+import type { DatasetQuery } from "metabase-types/api";
+
+type UseSegmentQueryResult = {
+ query: Lib.Query | undefined;
+ filters: Lib.FilterClause[];
+};
+
+export function useSegmentQuery(
+ definition: DatasetQuery | null,
+ metadata: Metadata,
+): UseSegmentQueryResult {
+ const query = useMemo(() => {
+ if (!definition?.database) {
+ return undefined;
+ }
+ const metadataProvider = Lib.metadataProvider(
+ definition.database,
+ metadata,
+ );
+ return Lib.fromJsQuery(metadataProvider, definition);
+ }, [metadata, definition]);
+
+ const filters = useMemo(() => (query ? Lib.filters(query, -1) : []), [query]);
+
+ return { query, filters };
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/DataModelNewSegmentPage/DataModelNewSegmentPage.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/DataModelNewSegmentPage/DataModelNewSegmentPage.tsx
new file mode 100644
index 00000000000..83a839fab21
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/DataModelNewSegmentPage/DataModelNewSegmentPage.tsx
@@ -0,0 +1,60 @@
+import type { ReactNode } from "react";
+import type { Route } from "react-router";
+
+import { LoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper";
+import * as Urls from "metabase/lib/urls";
+import { Center } from "metabase/ui";
+import { useLoadTableWithMetadata } from "metabase-enterprise/data-studio/common/hooks/use-load-table-with-metadata";
+import { getSchemaName } from "metabase-lib/v1/metadata/utils/schema";
+
+import { DataModelSegmentBreadcrumbs } from "../../components/SegmentBreadcrumbs";
+import { NewSegmentPage } from "../NewSegmentPage";
+
+type DataModelNewSegmentPageParams = {
+ databaseId: string;
+ schemaId: string;
+ tableId: string;
+};
+
+type DataModelNewSegmentPageProps = {
+ params: DataModelNewSegmentPageParams;
+ route: Route;
+ children?: ReactNode;
+};
+
+export function DataModelNewSegmentPage({
+ params,
+ route,
+}: DataModelNewSegmentPageProps) {
+ const databaseId = Number(params.databaseId);
+ const schemaName = getSchemaName(params.schemaId);
+ const tableId = Urls.extractEntityId(params.tableId);
+
+ const { table, isLoading, error } = useLoadTableWithMetadata(tableId, {
+ includeForeignTables: true,
+ });
+
+ if (isLoading || error || !table || tableId == null || schemaName == null) {
+ return (
+ <Center h="100%">
+ <LoadingAndErrorWrapper loading={isLoading} error={error} />
+ </Center>
+ );
+ }
+
+ return (
+ <NewSegmentPage
+ route={route}
+ table={table}
+ breadcrumbs={<DataModelSegmentBreadcrumbs table={table} />}
+ getSuccessUrl={(segment) =>
+ Urls.dataStudioDataModelSegment({
+ databaseId,
+ schemaName,
+ tableId,
+ segmentId: segment.id,
+ })
+ }
+ />
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/DataModelNewSegmentPage/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/DataModelNewSegmentPage/index.ts
new file mode 100644
index 00000000000..c10d434e1ea
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/DataModelNewSegmentPage/index.ts
@@ -0,0 +1 @@
+export { DataModelNewSegmentPage } from "./DataModelNewSegmentPage";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/DataModelSegmentDependenciesPage/DataModelSegmentDependenciesPage.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/DataModelSegmentDependenciesPage/DataModelSegmentDependenciesPage.tsx
new file mode 100644
index 00000000000..f64a26c4aad
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/DataModelSegmentDependenciesPage/DataModelSegmentDependenciesPage.tsx
@@ -0,0 +1,49 @@
+import type { ReactNode } from "react";
+
+import { LoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper";
+import { Center } from "metabase/ui";
+
+import { DataModelSegmentBreadcrumbs } from "../../components/SegmentBreadcrumbs";
+import { useDataModelSegmentPage } from "../../hooks";
+import { SegmentDependenciesPage } from "../SegmentDependenciesPage";
+
+type DataModelSegmentDependenciesPageParams = {
+ databaseId: string;
+ schemaId: string;
+ tableId: string;
+ segmentId: string;
+};
+
+type DataModelSegmentDependenciesPageProps = {
+ params: DataModelSegmentDependenciesPageParams;
+ children?: ReactNode;
+};
+
+export function DataModelSegmentDependenciesPage({
+ params,
+ children,
+}: DataModelSegmentDependenciesPageProps) {
+ const { isLoading, error, segment, table, tabUrls, onRemove } =
+ useDataModelSegmentPage(params);
+
+ if (isLoading || error || !segment || !table || !tabUrls) {
+ return (
+ <Center h="100%">
+ <LoadingAndErrorWrapper loading={isLoading} error={error} />
+ </Center>
+ );
+ }
+
+ return (
+ <SegmentDependenciesPage
+ segment={segment}
+ tabUrls={tabUrls}
+ breadcrumbs={
+ <DataModelSegmentBreadcrumbs table={table} segment={segment} />
+ }
+ onRemove={onRemove}
+ >
+ {children}
+ </SegmentDependenciesPage>
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/DataModelSegmentDependenciesPage/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/DataModelSegmentDependenciesPage/index.ts
new file mode 100644
index 00000000000..f0edddd482b
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/DataModelSegmentDependenciesPage/index.ts
@@ -0,0 +1 @@
+export { DataModelSegmentDependenciesPage } from "./DataModelSegmentDependenciesPage";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/DataModelSegmentDetailPage/DataModelSegmentDetailPage.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/DataModelSegmentDetailPage/DataModelSegmentDetailPage.tsx
new file mode 100644
index 00000000000..87343b460f2
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/DataModelSegmentDetailPage/DataModelSegmentDetailPage.tsx
@@ -0,0 +1,48 @@
+import type { Route } from "react-router";
+
+import { LoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper";
+import { Center } from "metabase/ui";
+
+import { DataModelSegmentBreadcrumbs } from "../../components/SegmentBreadcrumbs";
+import { useDataModelSegmentPage } from "../../hooks";
+import { SegmentDetailPage } from "../SegmentDetailPage";
+
+type DataModelSegmentDetailPageParams = {
+ databaseId: string;
+ schemaId: string;
+ tableId: string;
+ segmentId: string;
+};
+
+type DataModelSegmentDetailPageProps = {
+ params: DataModelSegmentDetailPageParams;
+ route: Route;
+};
+
+export function DataModelSegmentDetailPage({
+ params,
+ route,
+}: DataModelSegmentDetailPageProps) {
+ const { isLoading, error, segment, table, tabUrls, onRemove } =
+ useDataModelSegmentPage(params);
+
+ if (isLoading || error || !segment || !table || !tabUrls) {
+ return (
+ <Center h="100%">
+ <LoadingAndErrorWrapper loading={isLoading} error={error} />
+ </Center>
+ );
+ }
+
+ return (
+ <SegmentDetailPage
+ route={route}
+ segment={segment}
+ tabUrls={tabUrls}
+ breadcrumbs={
+ <DataModelSegmentBreadcrumbs table={table} segment={segment} />
+ }
+ onRemove={onRemove}
+ />
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/DataModelSegmentDetailPage/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/DataModelSegmentDetailPage/index.ts
new file mode 100644
index 00000000000..1968f463c5f
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/DataModelSegmentDetailPage/index.ts
@@ -0,0 +1 @@
+export { DataModelSegmentDetailPage } from "./DataModelSegmentDetailPage";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/DataModelSegmentRevisionHistoryPage/DataModelSegmentRevisionHistoryPage.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/DataModelSegmentRevisionHistoryPage/DataModelSegmentRevisionHistoryPage.tsx
new file mode 100644
index 00000000000..a324b05e3bb
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/DataModelSegmentRevisionHistoryPage/DataModelSegmentRevisionHistoryPage.tsx
@@ -0,0 +1,43 @@
+import { LoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper";
+import { Center } from "metabase/ui";
+
+import { DataModelSegmentBreadcrumbs } from "../../components/SegmentBreadcrumbs";
+import { useDataModelSegmentPage } from "../../hooks";
+import { SegmentRevisionHistoryPage } from "../SegmentRevisionHistoryPage";
+
+type DataModelSegmentRevisionHistoryPageParams = {
+ databaseId: string;
+ schemaId: string;
+ tableId: string;
+ segmentId: string;
+};
+
+type DataModelSegmentRevisionHistoryPageProps = {
+ params: DataModelSegmentRevisionHistoryPageParams;
+};
+
+export function DataModelSegmentRevisionHistoryPage({
+ params,
+}: DataModelSegmentRevisionHistoryPageProps) {
+ const { isLoading, error, segment, table, tabUrls, onRemove } =
+ useDataModelSegmentPage(params);
+
+ if (isLoading || error || !segment || !table || !tabUrls) {
+ return (
+ <Center h="100%">
+ <LoadingAndErrorWrapper loading={isLoading} error={error} />
+ </Center>
+ );
+ }
+
+ return (
+ <SegmentRevisionHistoryPage
+ segment={segment}
+ tabUrls={tabUrls}
+ breadcrumbs={
+ <DataModelSegmentBreadcrumbs table={table} segment={segment} />
+ }
+ onRemove={onRemove}
+ />
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/DataModelSegmentRevisionHistoryPage/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/DataModelSegmentRevisionHistoryPage/index.ts
new file mode 100644
index 00000000000..8e380ee2c05
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/DataModelSegmentRevisionHistoryPage/index.ts
@@ -0,0 +1 @@
+export { DataModelSegmentRevisionHistoryPage } from "./DataModelSegmentRevisionHistoryPage";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/EditSegmentPage/EditSegmentPage.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/EditSegmentPage/EditSegmentPage.tsx
deleted file mode 100644
index ceab870bfc1..00000000000
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/EditSegmentPage/EditSegmentPage.tsx
+++ /dev/null
@@ -1,131 +0,0 @@
-import { skipToken } from "@reduxjs/toolkit/query";
-import { useCallback } from "react";
-import type { Route } from "react-router";
-import { push } from "react-router-redux";
-import { t } from "ttag";
-
-import {
- useDeleteSegmentMutation,
- useGetSegmentQuery,
- useUpdateSegmentMutation,
-} from "metabase/api";
-import { LoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper";
-import { useDispatch } from "metabase/lib/redux";
-import * as Urls from "metabase/lib/urls";
-import { useMetadataToasts } from "metabase/metadata/hooks";
-import { Center } from "metabase/ui";
-import { useLoadTableWithMetadata } from "metabase-enterprise/data-studio/common/hooks/use-load-table-with-metadata";
-import type { DatasetQuery } from "metabase-types/api";
-
-import { SegmentEditorPage } from "../../components/SegmentEditorPage";
-
-type EditSegmentPageProps = {
- params: { segmentId: string };
- route: Route;
-};
-
-export function EditSegmentPage({ params, route }: EditSegmentPageProps) {
- const dispatch = useDispatch();
- const segmentId = Urls.extractEntityId(params.segmentId);
- const { sendSuccessToast, sendErrorToast } = useMetadataToasts();
-
- const {
- data: segment,
- isLoading: isLoadingSegment,
- error: segmentError,
- } = useGetSegmentQuery(segmentId ?? skipToken);
-
- const {
- table,
- isLoading: isLoadingTable,
- error: tableError,
- } = useLoadTableWithMetadata(segment?.table_id, {
- includeForeignTables: true,
- });
-
- const [updateSegment, { isLoading: isSaving }] = useUpdateSegmentMutation();
- const [deleteSegment, { isLoading: isRemoving }] = useDeleteSegmentMutation();
-
- const handleSave = useCallback(
- async (data: {
- name: string;
- description: string;
- definition: DatasetQuery;
- }) => {
- if (!segment) {
- return;
- }
- const { error } = await updateSegment({
- id: segment.id,
- name: data.name,
- description: data.description || undefined,
- definition: data.definition,
- revision_message: t`Updated from Data Studio`,
- });
-
- if (error) {
- sendErrorToast(t`Failed to update segment`);
- } else {
- sendSuccessToast(t`Segment updated`);
- }
- },
- [segment, updateSegment, sendSuccessToast, sendErrorToast],
- );
-
- const handleRemove = useCallback(async () => {
- if (!segment || !table) {
- return;
- }
- const { error } = await deleteSegment({
- id: segment.id,
- revision_message: t`Removed from Data Studio`,
- });
-
- if (error) {
- sendErrorToast(t`Failed to remove segment`);
- } else {
- sendSuccessToast(t`Segment removed`);
- dispatch(
- push(
- Urls.dataStudioData({
- databaseId: table.db_id,
- schemaName: table.schema,
- tableId: table.id,
- tab: "segments",
- }),
- ),
- );
- }
- }, [
- segment,
- table,
- deleteSegment,
- dispatch,
- sendSuccessToast,
- sendErrorToast,
- ]);
-
- const isLoading = isLoadingSegment || isLoadingTable;
- const error = segmentError || tableError;
-
- if (isLoading || error || !segment || !table) {
- return (
- <Center h="100%">
- <LoadingAndErrorWrapper loading={isLoading} error={error} />
- </Center>
- );
- }
-
- return (
- <SegmentEditorPage
- segment={segment}
- table={table}
- route={route}
- isSaving={isSaving}
- isRemoving={isRemoving}
- onSave={handleSave}
- onRemove={handleRemove}
- testId="edit-segment-page"
- />
- );
-}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/EditSegmentPage/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/EditSegmentPage/index.ts
deleted file mode 100644
index a1225453f8c..00000000000
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/EditSegmentPage/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { EditSegmentPage } from "./EditSegmentPage";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/NewSegmentPage/NewSegmentPage.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/NewSegmentPage/NewSegmentPage.tsx
index 94cef8ab0fe..b9f568c1668 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/NewSegmentPage/NewSegmentPage.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/NewSegmentPage/NewSegmentPage.tsx
@@ -1,95 +1,132 @@
-import type { Location } from "history";
-import { useCallback } from "react";
+import type { ReactNode } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
import type { Route } from "react-router";
import { push } from "react-router-redux";
import { t } from "ttag";
import { useCreateSegmentMutation } from "metabase/api";
-import { LoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper";
-import { useDispatch } from "metabase/lib/redux";
-import * as Urls from "metabase/lib/urls";
+import { LeaveRouteConfirmModal } from "metabase/common/components/LeaveConfirmModal";
+import { useDispatch, useSelector } from "metabase/lib/redux";
import { useMetadataToasts } from "metabase/metadata/hooks";
-import { Center } from "metabase/ui";
-import { useLoadTableWithMetadata } from "metabase-enterprise/data-studio/common/hooks/use-load-table-with-metadata";
-import type { DatasetQuery } from "metabase-types/api";
+import { getMetadata } from "metabase/selectors/metadata";
+import { Button, Flex } from "metabase/ui";
+import * as Lib from "metabase-lib";
+import type { DatasetQuery, Segment, Table } from "metabase-types/api";
-import { SegmentEditorPage } from "../../components/SegmentEditorPage";
+import { NewSegmentHeader } from "../../components/NewSegmentHeader";
+import { SegmentEditor } from "../../components/SegmentEditor";
+import { useSegmentQuery } from "../../hooks/use-segment-query";
+import {
+ createInitialQueryForTable,
+ getPreviewUrl,
+} from "../../utils/segment-query";
type NewSegmentPageProps = {
route: Route;
- location: Location;
+ table: Table;
+ breadcrumbs: ReactNode;
+ getSuccessUrl: (segment: Segment) => string;
};
-export function NewSegmentPage({ route, location }: NewSegmentPageProps) {
+export function NewSegmentPage({
+ route,
+ table,
+ breadcrumbs,
+ getSuccessUrl,
+}: NewSegmentPageProps) {
const dispatch = useDispatch();
+ const metadata = useSelector(getMetadata);
const { sendSuccessToast, sendErrorToast } = useMetadataToasts();
- const tableIdParam = new URLSearchParams(location.search).get("tableId");
- const tableId = tableIdParam ? Number(tableIdParam) : undefined;
+ const [name, setName] = useState("");
+ const [description, setDescription] = useState("");
+ const [definition, setDefinition] = useState<DatasetQuery | null>(null);
- const { table, isLoading, error } = useLoadTableWithMetadata(tableId, {
- includeForeignTables: true,
- });
+ const isInitialized = useRef(false);
- const [createSegment, { isLoading: isSaving }] = useCreateSegmentMutation();
+ useEffect(() => {
+ if (table && !isInitialized.current) {
+ isInitialized.current = true;
+ setDefinition(createInitialQueryForTable(table, metadata));
+ }
+ }, [table, metadata]);
- const handleSave = useCallback(
- async (data: {
- name: string;
- description: string;
- definition: DatasetQuery;
- }) => {
- if (!table) {
- return;
- }
- const { data: segment, error } = await createSegment({
- name: data.name,
- table_id: table.id,
- definition: data.definition,
- description: data.description || undefined,
- });
+ const { query, filters } = useSegmentQuery(definition, metadata);
- if (error) {
- sendErrorToast(t`Failed to create segment`);
- } else if (segment) {
- sendSuccessToast(t`Segment created`);
- dispatch(push(Urls.dataStudioSegment(segment.id)));
- }
- },
- [table, createSegment, dispatch, sendSuccessToast, sendErrorToast],
- );
+ const isDirty =
+ name.trim().length > 0 || description.length > 0 || filters.length > 0;
+ const isValid = name.trim().length > 0 && filters.length > 0;
+ const previewUrl = filters.length > 0 ? getPreviewUrl(definition) : undefined;
+
+ const setQuery = useCallback((newQuery: Lib.Query) => {
+ setDefinition(Lib.toJsQuery(newQuery));
+ }, []);
- const handleCancel = useCallback(() => {
- if (table) {
- dispatch(
- push(
- Urls.dataStudioData({
- databaseId: table.db_id,
- schemaName: table.schema,
- tableId: table.id,
- tab: "segments",
- }),
- ),
- );
+ const [createSegment, { isLoading: isSaving }] = useCreateSegmentMutation();
+
+ const handleSave = useCallback(async () => {
+ if (!table || !definition || !isValid) {
+ return;
}
- }, [table, dispatch]);
+ const { data: segment, error } = await createSegment({
+ name: name.trim(),
+ table_id: table.id,
+ definition: definition,
+ description: description.trim() || undefined,
+ });
- if (isLoading || error || !table) {
- return (
- <Center h="100%">
- <LoadingAndErrorWrapper loading={isLoading} error={error} />
- </Center>
- );
- }
+ if (error) {
+ sendErrorToast(t`Failed to create segment`);
+ } else if (segment) {
+ sendSuccessToast(t`Segment created`);
+ dispatch(push(getSuccessUrl(segment)));
+ }
+ }, [
+ table,
+ definition,
+ name,
+ description,
+ isValid,
+ createSegment,
+ dispatch,
+ getSuccessUrl,
+ sendSuccessToast,
+ sendErrorToast,
+ ]);
return (
- <SegmentEditorPage
- table={table}
- route={route}
- isSaving={isSaving}
- onSave={handleSave}
- onCancel={handleCancel}
- testId="new-segment-page"
- />
+ <Flex
+ direction="column"
+ pos="relative"
+ w="100%"
+ h="100%"
+ bg="bg-white"
+ data-testid="new-segment-page"
+ >
+ <NewSegmentHeader
+ previewUrl={previewUrl}
+ onNameChange={setName}
+ breadcrumbs={breadcrumbs}
+ actions={
+ isDirty && (
+ <Button
+ variant="filled"
+ disabled={!isValid}
+ loading={isSaving}
+ onClick={handleSave}
+ >
+ {t`Save`}
+ </Button>
+ )
+ }
+ />
+ <SegmentEditor
+ query={query}
+ description={description}
+ onQueryChange={setQuery}
+ onDescriptionChange={setDescription}
+ />
+ <LeaveRouteConfirmModal route={route} isEnabled={isDirty && !isSaving} />
+ </Flex>
);
}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/NewSegmentPage/NewSegmentPage.unit.spec.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/NewSegmentPage/NewSegmentPage.unit.spec.tsx
new file mode 100644
index 00000000000..dc0eb3baa94
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/NewSegmentPage/NewSegmentPage.unit.spec.tsx
@@ -0,0 +1,255 @@
+import userEvent from "@testing-library/user-event";
+import fetchMock from "fetch-mock";
+import { Route } from "react-router";
+
+import { setupSchemaEndpoints } from "__support__/server-mocks";
+import { createMockEntitiesState } from "__support__/store";
+import { renderWithProviders, screen, waitFor } from "__support__/ui";
+import type { Table } from "metabase-types/api";
+import {
+ createMockDatabase,
+ createMockField,
+ createMockSegment,
+ createMockTable,
+} from "metabase-types/api/mocks";
+
+import { DataModelSegmentBreadcrumbs } from "../../components/SegmentBreadcrumbs";
+
+import { NewSegmentPage } from "./NewSegmentPage";
+
+const TEST_DATABASE = createMockDatabase({
+ id: 1,
+ name: "Test Database",
+});
+
+const TEST_TABLE = createMockTable({
+ id: 42,
+ db_id: TEST_DATABASE.id,
+ db: TEST_DATABASE,
+ display_name: "Orders",
+ schema: "PUBLIC",
+ fields: [
+ createMockField({
+ id: 1,
+ table_id: 42,
+ name: "ID",
+ display_name: "ID",
+ base_type: "type/Integer",
+ semantic_type: "type/PK",
+ }),
+ createMockField({
+ id: 2,
+ table_id: 42,
+ name: "TOTAL",
+ display_name: "Total",
+ base_type: "type/Float",
+ semantic_type: null,
+ }),
+ ],
+});
+
+type SetupOpts = {
+ table?: Table;
+};
+
+function setup({ table = TEST_TABLE }: SetupOpts = {}) {
+ setupSchemaEndpoints(TEST_DATABASE);
+
+ const successUrl = `/data-studio/data/database/${TEST_DATABASE.id}/schema/${TEST_DATABASE.id}:PUBLIC/table/${table.id}/segments`;
+
+ const getSuccessUrl = (segment: { id: number }) =>
+ `${successUrl}/${segment.id}`;
+
+ const { history } = renderWithProviders(
+ <Route
+ path="/"
+ component={() => (
+ <NewSegmentPage
+ route={{ path: "/" } as never}
+ table={table}
+ breadcrumbs={<DataModelSegmentBreadcrumbs table={table} />}
+ getSuccessUrl={getSuccessUrl}
+ />
+ )}
+ />,
+ {
+ withRouter: true,
+ storeInitialState: {
+ entities: createMockEntitiesState({
+ databases: [TEST_DATABASE],
+ tables: [table],
+ }),
+ },
+ },
+ );
+
+ return { history, successUrl };
+}
+
+async function addFilter() {
+ await userEvent.click(screen.getByText("Add filters to narrow your answer"));
+ await waitFor(() => {
+ expect(screen.getByText("Total")).toBeInTheDocument();
+ });
+ await userEvent.click(screen.getByText("Total"));
+ await waitFor(() => {
+ expect(screen.getByPlaceholderText("Min")).toBeInTheDocument();
+ });
+ await userEvent.type(screen.getByPlaceholderText("Min"), "100");
+ await userEvent.click(screen.getByText("Add filter"));
+ await waitFor(() => {
+ expect(screen.getByText(/Total is greater than/)).toBeInTheDocument();
+ });
+}
+
+describe("NewSegmentPage", () => {
+ it("renders page with empty form and no Save button", async () => {
+ setup();
+
+ expect(screen.getByTestId("new-segment-page")).toBeInTheDocument();
+ expect(screen.getByPlaceholderText("New segment")).toHaveValue("");
+ expect(screen.getByLabelText("Description")).toHaveValue("");
+ expect(
+ screen.queryByRole("button", { name: "Save" }),
+ ).not.toBeInTheDocument();
+ });
+
+ it("renders filter placeholder prompting user to add filters", async () => {
+ setup();
+
+ expect(
+ screen.getByText("Add filters to narrow your answer"),
+ ).toBeInTheDocument();
+ });
+
+ it("shows Save button when name is entered", async () => {
+ setup();
+
+ await userEvent.type(
+ screen.getByPlaceholderText("New segment"),
+ "Test Segment",
+ );
+
+ expect(screen.getByRole("button", { name: "Save" })).toBeInTheDocument();
+ });
+
+ it("shows Save button when description is entered", async () => {
+ setup();
+
+ await userEvent.type(
+ screen.getByLabelText("Description"),
+ "Test description",
+ );
+
+ expect(screen.getByRole("button", { name: "Save" })).toBeInTheDocument();
+ });
+
+ it("hides Save button when form is cleared back to empty", async () => {
+ setup();
+
+ const nameInput = screen.getByPlaceholderText("New segment");
+ await userEvent.type(nameInput, "Test");
+ expect(screen.getByRole("button", { name: "Save" })).toBeInTheDocument();
+
+ await userEvent.clear(nameInput);
+
+ await waitFor(() => {
+ expect(
+ screen.queryByRole("button", { name: "Save" }),
+ ).not.toBeInTheDocument();
+ });
+ });
+
+ it("Save button is disabled when name is provided but no filters defined", async () => {
+ setup();
+
+ await userEvent.type(
+ screen.getByPlaceholderText("New segment"),
+ "Test Segment",
+ );
+
+ const saveButton = screen.getByRole("button", { name: "Save" });
+ expect(saveButton).toBeDisabled();
+ });
+
+ it("does not show Save when name is whitespace only", async () => {
+ setup();
+
+ await userEvent.type(screen.getByPlaceholderText("New segment"), " ");
+
+ await waitFor(() => {
+ expect(
+ screen.queryByRole("button", { name: "Save" }),
+ ).not.toBeInTheDocument();
+ });
+ });
+
+ it("does not show actions menu when no filters are defined", async () => {
+ setup();
+
+ expect(screen.queryByLabelText("Segment actions")).not.toBeInTheDocument();
+ });
+
+ it("shows actions menu with Preview after adding a filter", async () => {
+ setup();
+
+ await addFilter();
+
+ await userEvent.click(screen.getByLabelText("Segment actions"));
+ expect(screen.getByText("Preview")).toBeInTheDocument();
+ });
+
+ it("enables Save button when name and filter are both provided", async () => {
+ setup();
+
+ await userEvent.type(
+ screen.getByPlaceholderText("New segment"),
+ "High Value Orders",
+ );
+
+ await addFilter();
+
+ const saveButton = screen.getByRole("button", { name: "Save" });
+ expect(saveButton).toBeEnabled();
+ });
+
+ it("calls create API and navigates on successful save", async () => {
+ const createdSegment = createMockSegment({
+ id: 123,
+ name: "High Value Orders",
+ table_id: TEST_TABLE.id,
+ });
+
+ fetchMock.post("path:/api/segment", createdSegment);
+
+ const { history, successUrl } = setup();
+
+ await userEvent.type(
+ screen.getByPlaceholderText("New segment"),
+ "High Value Orders",
+ );
+
+ await addFilter();
+
+ const saveButton = screen.getByRole("button", { name: "Save" });
+ expect(saveButton).toBeEnabled();
+
+ await userEvent.click(saveButton);
+
+ await waitFor(() => {
+ const calls = fetchMock.callHistory.calls("path:/api/segment");
+ expect(calls.length).toBeGreaterThan(0);
+ });
+
+ await waitFor(() => {
+ expect(history?.getCurrentLocation().pathname).toBe(
+ `${successUrl}/${createdSegment.id}`,
+ );
+ });
+
+ expect(screen.getByText(/Total is greater than/)).toBeInTheDocument();
+ expect(
+ screen.queryByText("Add filters to narrow your answer"),
+ ).not.toBeInTheDocument();
+ });
+});
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/PublishedTableNewSegmentPage/PublishedTableNewSegmentPage.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/PublishedTableNewSegmentPage/PublishedTableNewSegmentPage.tsx
new file mode 100644
index 00000000000..ef225bdc837
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/PublishedTableNewSegmentPage/PublishedTableNewSegmentPage.tsx
@@ -0,0 +1,50 @@
+import type { ReactNode } from "react";
+import type { Route } from "react-router";
+
+import { LoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper";
+import * as Urls from "metabase/lib/urls";
+import { Center } from "metabase/ui";
+import { useLoadTableWithMetadata } from "metabase-enterprise/data-studio/common/hooks/use-load-table-with-metadata";
+
+import { PublishedTableSegmentBreadcrumbs } from "../../components/SegmentBreadcrumbs";
+import { NewSegmentPage } from "../NewSegmentPage";
+
+type PublishedTableNewSegmentPageParams = {
+ tableId: string;
+};
+
+type PublishedTableNewSegmentPageProps = {
+ params: PublishedTableNewSegmentPageParams;
+ route: Route;
+ children?: ReactNode;
+};
+
+export function PublishedTableNewSegmentPage({
+ params,
+ route,
+}: PublishedTableNewSegmentPageProps) {
+ const tableId = Urls.extractEntityId(params.tableId);
+
+ const { table, isLoading, error } = useLoadTableWithMetadata(tableId, {
+ includeForeignTables: true,
+ });
+
+ if (isLoading || error || !table || tableId == null) {
+ return (
+ <Center h="100%">
+ <LoadingAndErrorWrapper loading={isLoading} error={error} />
+ </Center>
+ );
+ }
+
+ return (
+ <NewSegmentPage
+ route={route}
+ table={table}
+ breadcrumbs={<PublishedTableSegmentBreadcrumbs table={table} />}
+ getSuccessUrl={(segment) =>
+ Urls.dataStudioPublishedTableSegment(tableId, segment.id)
+ }
+ />
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/PublishedTableNewSegmentPage/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/PublishedTableNewSegmentPage/index.ts
new file mode 100644
index 00000000000..78941eaa4fd
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/PublishedTableNewSegmentPage/index.ts
@@ -0,0 +1 @@
+export { PublishedTableNewSegmentPage } from "./PublishedTableNewSegmentPage";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/PublishedTableSegmentDependenciesPage/PublishedTableSegmentDependenciesPage.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/PublishedTableSegmentDependenciesPage/PublishedTableSegmentDependenciesPage.tsx
new file mode 100644
index 00000000000..cb7dabf1e67
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/PublishedTableSegmentDependenciesPage/PublishedTableSegmentDependenciesPage.tsx
@@ -0,0 +1,47 @@
+import type { ReactNode } from "react";
+
+import { LoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper";
+import { Center } from "metabase/ui";
+
+import { PublishedTableSegmentBreadcrumbs } from "../../components/SegmentBreadcrumbs";
+import { usePublishedTableSegmentPage } from "../../hooks";
+import { SegmentDependenciesPage } from "../SegmentDependenciesPage";
+
+type PublishedTableSegmentDependenciesPageParams = {
+ tableId: string;
+ segmentId: string;
+};
+
+type PublishedTableSegmentDependenciesPageProps = {
+ params: PublishedTableSegmentDependenciesPageParams;
+ children?: ReactNode;
+};
+
+export function PublishedTableSegmentDependenciesPage({
+ params,
+ children,
+}: PublishedTableSegmentDependenciesPageProps) {
+ const { isLoading, error, segment, table, tabUrls, onRemove } =
+ usePublishedTableSegmentPage(params);
+
+ if (isLoading || error || !segment || !table || !tabUrls) {
+ return (
+ <Center h="100%">
+ <LoadingAndErrorWrapper loading={isLoading} error={error} />
+ </Center>
+ );
+ }
+
+ return (
+ <SegmentDependenciesPage
+ segment={segment}
+ tabUrls={tabUrls}
+ breadcrumbs={
+ <PublishedTableSegmentBreadcrumbs table={table} segment={segment} />
+ }
+ onRemove={onRemove}
+ >
+ {children}
+ </SegmentDependenciesPage>
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/PublishedTableSegmentDependenciesPage/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/PublishedTableSegmentDependenciesPage/index.ts
new file mode 100644
index 00000000000..756b9119a32
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/PublishedTableSegmentDependenciesPage/index.ts
@@ -0,0 +1 @@
+export { PublishedTableSegmentDependenciesPage } from "./PublishedTableSegmentDependenciesPage";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/PublishedTableSegmentDetailPage/PublishedTableSegmentDetailPage.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/PublishedTableSegmentDetailPage/PublishedTableSegmentDetailPage.tsx
new file mode 100644
index 00000000000..8fd9351243c
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/PublishedTableSegmentDetailPage/PublishedTableSegmentDetailPage.tsx
@@ -0,0 +1,46 @@
+import type { Route } from "react-router";
+
+import { LoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper";
+import { Center } from "metabase/ui";
+
+import { PublishedTableSegmentBreadcrumbs } from "../../components/SegmentBreadcrumbs";
+import { usePublishedTableSegmentPage } from "../../hooks";
+import { SegmentDetailPage } from "../SegmentDetailPage";
+
+type PublishedTableSegmentDetailPageParams = {
+ tableId: string;
+ segmentId: string;
+};
+
+type PublishedTableSegmentDetailPageProps = {
+ params: PublishedTableSegmentDetailPageParams;
+ route: Route;
+};
+
+export function PublishedTableSegmentDetailPage({
+ params,
+ route,
+}: PublishedTableSegmentDetailPageProps) {
+ const { isLoading, error, segment, table, tabUrls, onRemove } =
+ usePublishedTableSegmentPage(params);
+
+ if (isLoading || error || !segment || !table || !tabUrls) {
+ return (
+ <Center h="100%">
+ <LoadingAndErrorWrapper loading={isLoading} error={error} />
+ </Center>
+ );
+ }
+
+ return (
+ <SegmentDetailPage
+ route={route}
+ segment={segment}
+ tabUrls={tabUrls}
+ breadcrumbs={
+ <PublishedTableSegmentBreadcrumbs table={table} segment={segment} />
+ }
+ onRemove={onRemove}
+ />
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/PublishedTableSegmentDetailPage/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/PublishedTableSegmentDetailPage/index.ts
new file mode 100644
index 00000000000..9bca34fd385
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/PublishedTableSegmentDetailPage/index.ts
@@ -0,0 +1 @@
+export { PublishedTableSegmentDetailPage } from "./PublishedTableSegmentDetailPage";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/PublishedTableSegmentRevisionHistoryPage/PublishedTableSegmentRevisionHistoryPage.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/PublishedTableSegmentRevisionHistoryPage/PublishedTableSegmentRevisionHistoryPage.tsx
new file mode 100644
index 00000000000..d48afb83c80
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/PublishedTableSegmentRevisionHistoryPage/PublishedTableSegmentRevisionHistoryPage.tsx
@@ -0,0 +1,41 @@
+import { LoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper";
+import { Center } from "metabase/ui";
+
+import { PublishedTableSegmentBreadcrumbs } from "../../components/SegmentBreadcrumbs";
+import { usePublishedTableSegmentPage } from "../../hooks";
+import { SegmentRevisionHistoryPage } from "../SegmentRevisionHistoryPage";
+
+type PublishedTableSegmentRevisionHistoryPageParams = {
+ tableId: string;
+ segmentId: string;
+};
+
+type PublishedTableSegmentRevisionHistoryPageProps = {
+ params: PublishedTableSegmentRevisionHistoryPageParams;
+};
+
+export function PublishedTableSegmentRevisionHistoryPage({
+ params,
+}: PublishedTableSegmentRevisionHistoryPageProps) {
+ const { isLoading, error, segment, table, tabUrls, onRemove } =
+ usePublishedTableSegmentPage(params);
+
+ if (isLoading || error || !segment || !table || !tabUrls) {
+ return (
+ <Center h="100%">
+ <LoadingAndErrorWrapper loading={isLoading} error={error} />
+ </Center>
+ );
+ }
+
+ return (
+ <SegmentRevisionHistoryPage
+ segment={segment}
+ tabUrls={tabUrls}
+ breadcrumbs={
+ <PublishedTableSegmentBreadcrumbs table={table} segment={segment} />
+ }
+ onRemove={onRemove}
+ />
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/PublishedTableSegmentRevisionHistoryPage/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/PublishedTableSegmentRevisionHistoryPage/index.ts
new file mode 100644
index 00000000000..4ce6e2699e0
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/PublishedTableSegmentRevisionHistoryPage/index.ts
@@ -0,0 +1 @@
+export { PublishedTableSegmentRevisionHistoryPage } from "./PublishedTableSegmentRevisionHistoryPage";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/SegmentDependenciesPage/SegmentDependenciesPage.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/SegmentDependenciesPage/SegmentDependenciesPage.tsx
new file mode 100644
index 00000000000..2a29ae35fc6
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/SegmentDependenciesPage/SegmentDependenciesPage.tsx
@@ -0,0 +1,45 @@
+import type { ReactNode } from "react";
+
+import { PLUGIN_DEPENDENCIES } from "metabase/plugins";
+import { Flex } from "metabase/ui";
+import type { Segment } from "metabase-types/api";
+
+import { SegmentHeader } from "../../components/SegmentHeader";
+import type { SegmentTabUrls } from "../../types";
+import { getSegmentPreviewUrl } from "../../utils/get-segment-preview-url";
+
+type SegmentDependenciesPageProps = {
+ segment: Segment;
+ tabUrls: SegmentTabUrls;
+ breadcrumbs: ReactNode;
+ onRemove: () => Promise<void>;
+ children?: ReactNode;
+};
+
+export function SegmentDependenciesPage({
+ segment,
+ tabUrls,
+ breadcrumbs,
+ onRemove,
+ children,
+}: SegmentDependenciesPageProps) {
+ return (
+ <Flex direction="column" h="100%" data-testid="segment-dependencies-page">
+ <SegmentHeader
+ segment={segment}
+ tabUrls={tabUrls}
+ previewUrl={getSegmentPreviewUrl(segment)}
+ onRemove={onRemove}
+ breadcrumbs={breadcrumbs}
+ />
+ <PLUGIN_DEPENDENCIES.DependencyGraphPageContext.Provider
+ value={{
+ baseUrl: tabUrls.dependencies,
+ defaultEntry: { id: segment.id, type: "segment" },
+ }}
+ >
+ {children}
+ </PLUGIN_DEPENDENCIES.DependencyGraphPageContext.Provider>
+ </Flex>
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/SegmentDependenciesPage/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/SegmentDependenciesPage/index.ts
new file mode 100644
index 00000000000..3389ca32bcd
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/SegmentDependenciesPage/index.ts
@@ -0,0 +1 @@
+export { SegmentDependenciesPage } from "./SegmentDependenciesPage";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/SegmentDetailPage/SegmentDetailPage.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/SegmentDetailPage/SegmentDetailPage.tsx
new file mode 100644
index 00000000000..02d41e46963
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/SegmentDetailPage/SegmentDetailPage.tsx
@@ -0,0 +1,141 @@
+import type { ReactNode } from "react";
+import { useCallback, useMemo, useState } from "react";
+import type { Route } from "react-router";
+import { t } from "ttag";
+
+import { useUpdateSegmentMutation } from "metabase/api";
+import { LeaveRouteConfirmModal } from "metabase/common/components/LeaveConfirmModal";
+import { useSelector } from "metabase/lib/redux";
+import { useMetadataToasts } from "metabase/metadata/hooks";
+import { getMetadata } from "metabase/selectors/metadata";
+import { Button, Flex, Group } from "metabase/ui";
+import * as Lib from "metabase-lib";
+import type { Segment } from "metabase-types/api";
+
+import { SegmentEditor } from "../../components/SegmentEditor";
+import { SegmentHeader } from "../../components/SegmentHeader";
+import { useSegmentQuery } from "../../hooks/use-segment-query";
+import type { SegmentTabUrls } from "../../types";
+import { getPreviewUrl } from "../../utils/segment-query";
+
+type SegmentDetailPageProps = {
+ route: Route;
+ segment: Segment;
+ tabUrls: SegmentTabUrls;
+ breadcrumbs: ReactNode;
+ onRemove: () => Promise<void>;
+};
+
+export function SegmentDetailPage({
+ route,
+ segment,
+ tabUrls,
+ breadcrumbs,
+ onRemove,
+}: SegmentDetailPageProps) {
+ const metadata = useSelector(getMetadata);
+ const { sendSuccessToast, sendErrorToast } = useMetadataToasts();
+
+ const [description, setDescription] = useState(segment.description ?? "");
+ const [definition, setDefinition] = useState(segment.definition);
+ const [savedSegment, setSavedSegment] = useState(segment);
+
+ const { query, filters } = useSegmentQuery(definition, metadata);
+
+ const isDirty = useMemo(
+ () =>
+ description !== (savedSegment.description ?? "") ||
+ !Lib.areLegacyQueriesEqual(definition, savedSegment.definition),
+ [description, definition, savedSegment],
+ );
+
+ const isValid = filters.length > 0;
+ const previewUrl = useMemo(
+ () => (filters.length > 0 ? getPreviewUrl(definition) : undefined),
+ [definition, filters],
+ );
+
+ const setQuery = useCallback((newQuery: Lib.Query) => {
+ setDefinition(Lib.toJsQuery(newQuery));
+ }, []);
+
+ const [updateSegment, { isLoading: isSaving }] = useUpdateSegmentMutation();
+
+ const handleSave = useCallback(async () => {
+ if (!isValid) {
+ return;
+ }
+ const { error } = await updateSegment({
+ id: segment.id,
+ name: segment.name,
+ description: description.trim() || undefined,
+ definition: definition,
+ revision_message: t`Updated from Data Studio`,
+ });
+
+ if (error) {
+ sendErrorToast(t`Failed to update segment`);
+ } else {
+ setSavedSegment({ ...segment, description, definition });
+ sendSuccessToast(t`Segment updated`);
+ }
+ }, [
+ segment,
+ definition,
+ description,
+ isValid,
+ updateSegment,
+ sendSuccessToast,
+ sendErrorToast,
+ ]);
+
+ const handleReset = useCallback(() => {
+ setDescription(savedSegment.description ?? "");
+ setDefinition(savedSegment.definition);
+ }, [savedSegment]);
+
+ return (
+ <Flex
+ direction="column"
+ pos="relative"
+ w="100%"
+ h="100%"
+ bg="bg-white"
+ data-testid="segment-detail-page"
+ >
+ <SegmentHeader
+ segment={segment}
+ tabUrls={tabUrls}
+ previewUrl={previewUrl}
+ onRemove={onRemove}
+ breadcrumbs={breadcrumbs}
+ actions={
+ isDirty && (
+ <Group gap="sm">
+ <Button onClick={handleReset}>{t`Cancel`}</Button>
+ <Button
+ variant="filled"
+ disabled={!isValid}
+ loading={isSaving}
+ onClick={handleSave}
+ >
+ {t`Save`}
+ </Button>
+ </Group>
+ )
+ }
+ />
+ <SegmentEditor
+ query={query}
+ description={description}
+ onQueryChange={setQuery}
+ onDescriptionChange={setDescription}
+ />
+ <LeaveRouteConfirmModal
+ key={segment.id}
+ route={route}
+ isEnabled={isDirty && !isSaving}
+ />
+ </Flex>
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/SegmentDetailPage/SegmentDetailPage.unit.spec.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/SegmentDetailPage/SegmentDetailPage.unit.spec.tsx
new file mode 100644
index 00000000000..e13f1efa3f7
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/SegmentDetailPage/SegmentDetailPage.unit.spec.tsx
@@ -0,0 +1,231 @@
+import userEvent from "@testing-library/user-event";
+import fetchMock from "fetch-mock";
+import { Route } from "react-router";
+
+import {
+ setupSchemaEndpoints,
+ setupSegmentEndpoint,
+} from "__support__/server-mocks";
+import { createMockEntitiesState } from "__support__/store";
+import { renderWithProviders, screen, waitFor } from "__support__/ui";
+import { checkNotNull } from "metabase/lib/types";
+import type { Segment, Table } from "metabase-types/api";
+import {
+ createMockDatabase,
+ createMockField,
+ createMockSegment,
+ createMockStructuredDatasetQuery,
+ createMockTable,
+} from "metabase-types/api/mocks";
+
+import { DataModelSegmentBreadcrumbs } from "../../components/SegmentBreadcrumbs";
+
+import { SegmentDetailPage } from "./SegmentDetailPage";
+
+const TEST_TABLE = createMockTable({
+ id: 42,
+ display_name: "Orders",
+ schema: "PUBLIC",
+ fields: [
+ createMockField({
+ id: 1,
+ table_id: 42,
+ name: "ID",
+ display_name: "ID",
+ base_type: "type/Integer",
+ semantic_type: "type/PK",
+ }),
+ createMockField({
+ id: 2,
+ table_id: 42,
+ name: "TOTAL",
+ display_name: "Total",
+ base_type: "type/Float",
+ semantic_type: null,
+ }),
+ ],
+});
+
+const TEST_DATABASE = createMockDatabase({
+ id: 1,
+ name: "Test Database",
+});
+
+TEST_TABLE.db_id = TEST_DATABASE.id;
+TEST_TABLE.db = TEST_DATABASE;
+
+const TEST_SEGMENT = createMockSegment({
+ id: 1,
+ name: "High Value Orders",
+ description: "Orders with total > 100",
+ table_id: TEST_TABLE.id,
+ definition: createMockStructuredDatasetQuery({
+ database: TEST_DATABASE.id,
+ query: {
+ "source-table": TEST_TABLE.id,
+ filter: [">", ["field", 2, null], 100],
+ },
+ }),
+});
+
+type SetupOpts = {
+ segment?: Segment;
+ table?: Table;
+};
+
+function setup({ segment = TEST_SEGMENT, table = TEST_TABLE }: SetupOpts = {}) {
+ setupSegmentEndpoint(segment);
+ setupSchemaEndpoints(checkNotNull(table.db));
+
+ const baseUrl = `/data-studio/data/database/${TEST_DATABASE.id}/schema/${TEST_DATABASE.id}:PUBLIC/table/${table.id}/segments/${segment.id}`;
+
+ const tabUrls = {
+ definition: baseUrl,
+ revisions: `${baseUrl}/revisions`,
+ dependencies: `${baseUrl}/dependencies`,
+ };
+
+ const onRemove = jest.fn().mockResolvedValue(undefined);
+
+ renderWithProviders(
+ <Route
+ path="/"
+ component={() => (
+ <SegmentDetailPage
+ route={{ path: "/" } as never}
+ segment={segment}
+ tabUrls={tabUrls}
+ breadcrumbs={
+ <DataModelSegmentBreadcrumbs table={table} segment={segment} />
+ }
+ onRemove={onRemove}
+ />
+ )}
+ />,
+ {
+ withRouter: true,
+ storeInitialState: {
+ entities: createMockEntitiesState({
+ databases: [TEST_DATABASE],
+ tables: [table],
+ }),
+ },
+ },
+ );
+
+ return { onRemove };
+}
+
+describe("SegmentDetailPage", () => {
+ it("renders page with segment data, tabs, and actions menu", async () => {
+ setup();
+
+ expect(screen.getByDisplayValue("High Value Orders")).toBeInTheDocument();
+ expect(screen.getByLabelText("Description")).toHaveValue(
+ "Orders with total > 100",
+ );
+ expect(screen.getByText("Definition")).toBeInTheDocument();
+ expect(screen.getByText("Revision history")).toBeInTheDocument();
+ expect(screen.getByLabelText("Segment actions")).toBeInTheDocument();
+ });
+
+ it("does not show Save/Cancel buttons when form is pristine", async () => {
+ setup();
+
+ expect(
+ screen.queryByRole("button", { name: "Save" }),
+ ).not.toBeInTheDocument();
+ expect(
+ screen.queryByRole("button", { name: "Cancel" }),
+ ).not.toBeInTheDocument();
+ });
+
+ it("shows Save/Cancel buttons when description is modified", async () => {
+ setup();
+
+ const descriptionInput = screen.getByLabelText("Description");
+ await userEvent.clear(descriptionInput);
+ await userEvent.type(descriptionInput, "New description");
+
+ expect(screen.getByRole("button", { name: "Save" })).toBeInTheDocument();
+ expect(screen.getByRole("button", { name: "Cancel" })).toBeInTheDocument();
+ });
+
+ it("resets form when Cancel is clicked after modifying description", async () => {
+ setup();
+
+ const descriptionInput = screen.getByLabelText("Description");
+ await userEvent.clear(descriptionInput);
+ await userEvent.type(descriptionInput, "Modified description");
+ expect(descriptionInput).toHaveValue("Modified description");
+
+ await userEvent.click(screen.getByRole("button", { name: "Cancel" }));
+
+ expect(descriptionInput).toHaveValue("Orders with total > 100");
+ expect(
+ screen.queryByRole("button", { name: "Save" }),
+ ).not.toBeInTheDocument();
+ });
+
+ it("calls update API and preserves form state after successful save", async () => {
+ const updatedSegment = {
+ ...TEST_SEGMENT,
+ description: "Updated description",
+ };
+
+ fetchMock.put(`path:/api/segment/${TEST_SEGMENT.id}`, updatedSegment);
+
+ setup();
+
+ const descriptionInput = screen.getByLabelText("Description");
+ await userEvent.clear(descriptionInput);
+ await userEvent.type(descriptionInput, "Updated description");
+
+ const saveButton = screen.getByRole("button", { name: "Save" });
+ expect(saveButton).toBeEnabled();
+
+ await userEvent.click(saveButton);
+
+ await waitFor(() => {
+ const calls = fetchMock.callHistory.calls(
+ `path:/api/segment/${TEST_SEGMENT.id}`,
+ );
+ expect(calls.length).toBeGreaterThan(0);
+ });
+
+ expect(descriptionInput).toHaveValue("Updated description");
+ await waitFor(() => {
+ expect(screen.getByText(/Total is greater than/)).toBeInTheDocument();
+ });
+ });
+
+ it("displays existing filter from segment definition", async () => {
+ setup();
+
+ await waitFor(() => {
+ expect(screen.getByText(/Total is greater than/)).toBeInTheDocument();
+ });
+ });
+
+ it("opens actions menu with Preview and Remove options when clicking menu button", async () => {
+ setup();
+
+ await userEvent.click(screen.getByLabelText("Segment actions"));
+
+ expect(screen.getByText("Preview")).toBeInTheDocument();
+ expect(screen.getByText("Remove segment")).toBeInTheDocument();
+ });
+
+ it("shows confirmation modal when Remove segment is clicked", async () => {
+ setup();
+
+ await userEvent.click(screen.getByLabelText("Segment actions"));
+ await userEvent.click(screen.getByText("Remove segment"));
+
+ expect(screen.getByText("Remove this segment?")).toBeInTheDocument();
+ expect(
+ screen.getByText("This segment will be permanently removed."),
+ ).toBeInTheDocument();
+ expect(screen.getByRole("button", { name: "Remove" })).toBeInTheDocument();
+ });
+});
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/SegmentDetailPage/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/SegmentDetailPage/index.ts
new file mode 100644
index 00000000000..5fb0a49d172
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/SegmentDetailPage/index.ts
@@ -0,0 +1 @@
+export { SegmentDetailPage } from "./SegmentDetailPage";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/SegmentRevisionHistoryPage/SegmentRevisionHistoryPage.module.css b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/SegmentRevisionHistoryPage/SegmentRevisionHistoryPage.module.css
new file mode 100644
index 00000000000..fa3469e028e
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/SegmentRevisionHistoryPage/SegmentRevisionHistoryPage.module.css
@@ -0,0 +1,3 @@
+.scrollable {
+ overflow: auto;
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/SegmentRevisionHistoryPage/SegmentRevisionHistoryPage.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/SegmentRevisionHistoryPage/SegmentRevisionHistoryPage.tsx
new file mode 100644
index 00000000000..29a80eebb03
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/SegmentRevisionHistoryPage/SegmentRevisionHistoryPage.tsx
@@ -0,0 +1,44 @@
+import type { ReactNode } from "react";
+
+import { Flex, Stack } from "metabase/ui";
+import type { Segment } from "metabase-types/api";
+
+import { SegmentHeader } from "../../components/SegmentHeader";
+import { SegmentRevisionHistory } from "../../components/SegmentRevisionHistory";
+import type { SegmentTabUrls } from "../../types";
+import { getSegmentPreviewUrl } from "../../utils/get-segment-preview-url";
+
+import S from "./SegmentRevisionHistoryPage.module.css";
+
+type SegmentRevisionHistoryPageProps = {
+ segment: Segment;
+ tabUrls: SegmentTabUrls;
+ breadcrumbs: ReactNode;
+ onRemove: () => Promise<void>;
+};
+
+export function SegmentRevisionHistoryPage({
+ segment,
+ tabUrls,
+ breadcrumbs,
+ onRemove,
+}: SegmentRevisionHistoryPageProps) {
+ return (
+ <Flex
+ direction="column"
+ h="100%"
+ data-testid="segment-revision-history-page"
+ >
+ <SegmentHeader
+ segment={segment}
+ tabUrls={tabUrls}
+ previewUrl={getSegmentPreviewUrl(segment)}
+ onRemove={onRemove}
+ breadcrumbs={breadcrumbs}
+ />
+ <Stack flex={1} className={S.scrollable}>
+ <SegmentRevisionHistory segment={segment} />
+ </Stack>
+ </Flex>
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/SegmentRevisionHistoryPage/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/SegmentRevisionHistoryPage/index.ts
new file mode 100644
index 00000000000..e60eb1502b8
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/pages/SegmentRevisionHistoryPage/index.ts
@@ -0,0 +1 @@
+export { SegmentRevisionHistoryPage } from "./SegmentRevisionHistoryPage";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/routes.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/routes.tsx
deleted file mode 100644
index f29551181ba..00000000000
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/routes.tsx
+++ /dev/null
@@ -1,13 +0,0 @@
-import { Route } from "react-router";
-
-import { EditSegmentPage } from "./pages/EditSegmentPage";
-import { NewSegmentPage } from "./pages/NewSegmentPage";
-
-export function getDataStudioSegmentRoutes() {
- return (
- <>
- <Route path="segments/new" component={NewSegmentPage} />
- <Route path="segments/:segmentId" component={EditSegmentPage} />
- </>
- );
-}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/types.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/types.ts
new file mode 100644
index 00000000000..44e438612de
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/types.ts
@@ -0,0 +1,34 @@
+import type { ReactNode } from "react";
+import type { Route } from "react-router";
+
+import type { Segment, Table } from "metabase-types/api";
+
+export type SegmentTabUrls = {
+ definition: string;
+ revisions: string;
+ dependencies: string;
+};
+
+export type NewSegmentPageProps = {
+ route: Route;
+ table: Table;
+ breadcrumbs: ReactNode;
+ getSuccessUrl: (segment: Segment) => string;
+};
+
+export type ExistingSegmentPageProps = {
+ segment: Segment;
+ tabUrls: SegmentTabUrls;
+ breadcrumbs: ReactNode;
+ onRemove: () => Promise<void>;
+};
+
+export type SegmentDetailPageProps = ExistingSegmentPageProps & {
+ route: Route;
+};
+
+export type SegmentRevisionHistoryPageProps = ExistingSegmentPageProps;
+
+export type SegmentDependenciesPageProps = ExistingSegmentPageProps & {
+ children?: ReactNode;
+};
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/utils/get-segment-preview-url.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/utils/get-segment-preview-url.ts
new file mode 100644
index 00000000000..4ac939c26f0
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/utils/get-segment-preview-url.ts
@@ -0,0 +1,9 @@
+import * as Urls from "metabase/lib/urls";
+import type { Segment } from "metabase-types/api";
+
+export function getSegmentPreviewUrl(segment: Segment): string | undefined {
+ if (!segment.definition) {
+ return undefined;
+ }
+ return Urls.newQuestion({ dataset_query: segment.definition });
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/segments/utils/segment-query.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/utils/segment-query.ts
new file mode 100644
index 00000000000..fd4bc84a45b
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/segments/utils/segment-query.ts
@@ -0,0 +1,29 @@
+import * as Urls from "metabase/lib/urls";
+import * as Lib from "metabase-lib";
+import type Metadata from "metabase-lib/v1/metadata/Metadata";
+import type { DatasetQuery, Table } from "metabase-types/api";
+
+export function createInitialQueryForTable(
+ table: Table,
+ metadata: Metadata,
+): DatasetQuery | null {
+ const metadataProvider = Lib.metadataProvider(table.db_id, metadata);
+ const tableMetadata = Lib.tableOrCardMetadata(metadataProvider, table.id);
+ if (!tableMetadata) {
+ return null;
+ }
+ const query = Lib.queryFromTableOrCardMetadata(
+ metadataProvider,
+ tableMetadata,
+ );
+ return Lib.toJsQuery(query);
+}
+
+export function getPreviewUrl(
+ definition: DatasetQuery | null,
+): string | undefined {
+ if (!definition) {
+ return undefined;
+ }
+ return Urls.newQuestion({ dataset_query: definition });
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/tables/components/TableHeader/TableTabs/TableTabs.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/tables/components/TableHeader/TableTabs/TableTabs.tsx
index c549fb7ba2c..ca3d846bd6f 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/tables/components/TableHeader/TableTabs/TableTabs.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/tables/components/TableHeader/TableTabs/TableTabs.tsx
@@ -37,6 +37,14 @@ function getTabs(table: Table, location: Location): PaneHeaderTab[] {
),
});
+ tabs.push({
+ label: t`Segments`,
+ to: Urls.dataStudioTableSegments(table.id),
+ isSelected: location.pathname.startsWith(
+ Urls.dataStudioTableSegments(table.id),
+ ),
+ });
+
if (PLUGIN_DEPENDENCIES.isEnabled) {
tabs.push({
label: t`Dependencies`,
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/tables/pages/TableSegmentsPage/TableSegments.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/tables/pages/TableSegmentsPage/TableSegments.tsx
new file mode 100644
index 00000000000..524c7621064
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/tables/pages/TableSegmentsPage/TableSegments.tsx
@@ -0,0 +1,43 @@
+import { t } from "ttag";
+
+import * as Urls from "metabase/lib/urls";
+import { Flex } from "metabase/ui";
+import type { Table } from "metabase-types/api";
+
+import {
+ EntityList,
+ EntityListItem,
+} from "../../../common/components/EntityList";
+
+type TableSegmentsProps = {
+ table: Table;
+};
+
+export function TableSegments({ table }: TableSegmentsProps) {
+ const segments = table.segments ?? [];
+
+ return (
+ <Flex direction="column" p="lg" bg="bg-light" flex={1}>
+ <EntityList
+ items={segments}
+ title={t`Segments`}
+ emptyState={{
+ icon: "segment2",
+ title: t`No segments yet`,
+ message: t`Create a segment to filter rows in this table.`,
+ }}
+ newButtonLabel={t`New segment`}
+ newButtonUrl={Urls.dataStudioPublishedTableSegmentNew(table.id)}
+ renderItem={(segment) => (
+ <EntityListItem
+ key={segment.id}
+ name={segment.name}
+ description={segment.definition_description}
+ icon="segment2"
+ href={Urls.dataStudioPublishedTableSegment(table.id, segment.id)}
+ />
+ )}
+ />
+ </Flex>
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/tables/pages/TableSegmentsPage/TableSegmentsPage.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/tables/pages/TableSegmentsPage/TableSegmentsPage.tsx
new file mode 100644
index 00000000000..22c2be6b04e
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/tables/pages/TableSegmentsPage/TableSegmentsPage.tsx
@@ -0,0 +1,36 @@
+import { LoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper";
+import * as Urls from "metabase/lib/urls";
+import { Center, Flex } from "metabase/ui";
+import { useLoadTableWithMetadata } from "metabase-enterprise/data-studio/common/hooks/use-load-table-with-metadata";
+
+import { TableHeader } from "../../components/TableHeader";
+
+import { TableSegments } from "./TableSegments";
+
+type TableSegmentsPageParams = {
+ tableId: string;
+};
+
+type TableSegmentsPageProps = {
+ params: TableSegmentsPageParams;
+};
+
+export function TableSegmentsPage({ params }: TableSegmentsPageProps) {
+ const tableId = Urls.extractEntityId(params.tableId);
+ const { table, isLoading, error } = useLoadTableWithMetadata(tableId);
+
+ if (isLoading || error != null || table == null) {
+ return (
+ <Center h="100%">
+ <LoadingAndErrorWrapper loading={isLoading} error={error} />
+ </Center>
+ );
+ }
+
+ return (
+ <Flex direction="column" h="100%" data-testid="table-segments-page">
+ <TableHeader table={table} />
+ <TableSegments table={table} />
+ </Flex>
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/tables/pages/TableSegmentsPage/index.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/tables/pages/TableSegmentsPage/index.ts
new file mode 100644
index 00000000000..ea15c747688
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/tables/pages/TableSegmentsPage/index.ts
@@ -0,0 +1 @@
+export { TableSegmentsPage } from "./TableSegmentsPage";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/tables/routes.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/tables/routes.tsx
index 6376598a866..18a6fe9d6f0 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/tables/routes.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/tables/routes.tsx
@@ -1,16 +1,43 @@
import { IndexRoute, Route } from "react-router";
import { PLUGIN_DEPENDENCIES } from "metabase/plugins";
+import { PublishedTableNewSegmentPage } from "metabase-enterprise/data-studio/segments/pages/PublishedTableNewSegmentPage";
+import { PublishedTableSegmentDependenciesPage } from "metabase-enterprise/data-studio/segments/pages/PublishedTableSegmentDependenciesPage";
+import { PublishedTableSegmentDetailPage } from "metabase-enterprise/data-studio/segments/pages/PublishedTableSegmentDetailPage";
+import { PublishedTableSegmentRevisionHistoryPage } from "metabase-enterprise/data-studio/segments/pages/PublishedTableSegmentRevisionHistoryPage";
import { TableDependenciesPage } from "./pages/TableDependenciesPage";
import { TableFieldsPage } from "./pages/TableFieldsPage";
import { TableOverviewPage } from "./pages/TableOverviewPage";
+import { TableSegmentsPage } from "./pages/TableSegmentsPage";
+
export function getDataStudioTableRoutes() {
return (
<Route path="tables">
<Route path=":tableId" component={TableOverviewPage} />
<Route path=":tableId/fields" component={TableFieldsPage} />
<Route path=":tableId/fields/:fieldId" component={TableFieldsPage} />
+ <Route path=":tableId/segments" component={TableSegmentsPage} />
+ <Route
+ path=":tableId/segments/new"
+ component={PublishedTableNewSegmentPage}
+ />
+ <Route
+ path=":tableId/segments/:segmentId"
+ component={PublishedTableSegmentDetailPage}
+ />
+ <Route
+ path=":tableId/segments/:segmentId/revisions"
+ component={PublishedTableSegmentRevisionHistoryPage}
+ />
+ {PLUGIN_DEPENDENCIES.isEnabled && (
+ <Route
+ path=":tableId/segments/:segmentId/dependencies"
+ component={PublishedTableSegmentDependenciesPage}
+ >
+ <IndexRoute component={PLUGIN_DEPENDENCIES.DependencyGraphPage} />
+ </Route>
+ )}
{PLUGIN_DEPENDENCIES.isEnabled && (
<Route path=":tableId/dependencies" component={TableDependenciesPage}>
<IndexRoute component={PLUGIN_DEPENDENCIES.DependencyGraphPage} />
diff --git a/frontend/src/metabase-types/api/mocks/index.ts b/frontend/src/metabase-types/api/mocks/index.ts
index e613615518c..f7a93a7beaf 100644
--- a/frontend/src/metabase-types/api/mocks/index.ts
+++ b/frontend/src/metabase-types/api/mocks/index.ts
@@ -24,6 +24,7 @@ export * from "./performance";
export * from "./permissions";
export * from "./pulse";
export * from "./query";
+export * from "./revision";
export * from "./schema";
export * from "./search";
export * from "./segment";
diff --git a/frontend/src/metabase-types/api/revision.ts b/frontend/src/metabase-types/api/revision.ts
index 69346b20112..f17c2a09ae3 100644
--- a/frontend/src/metabase-types/api/revision.ts
+++ b/frontend/src/metabase-types/api/revision.ts
@@ -1,5 +1,20 @@
export type RevisionId = number;
+export type FieldDiff = { before?: unknown; after?: unknown };
+
+export type SegmentRevisionDiff = {
+ name?: FieldDiff;
+ description?: FieldDiff;
+ definition?: FieldDiff;
+};
+
+export type CardOrDashboardRevisionDiff = {
+ before: Record<string, unknown>;
+ after: Record<string, unknown>;
+};
+
+export type RevisionDiff = SegmentRevisionDiff | CardOrDashboardRevisionDiff;
+
export interface Revision {
id: RevisionId;
description: string;
@@ -8,7 +23,7 @@ export interface Revision {
is_creation: boolean;
is_reversion: boolean;
has_multiple_changes: boolean;
- diff: { before: Record<string, any>; after: Record<string, any> } | null;
+ diff: RevisionDiff | null;
user: {
id: number;
first_name: string;
@@ -18,12 +33,12 @@ export interface Revision {
}
export interface ListRevisionRequest {
- entity: "card" | "dashboard";
+ entity: "card" | "dashboard" | "segment";
id: number | string;
}
export interface RevertRevisionRequest {
- entity: "card" | "dashboard";
+ entity: "card" | "dashboard" | "segment";
id: number | string;
revision_id: number;
}
diff --git a/frontend/src/metabase/api/table.ts b/frontend/src/metabase/api/table.ts
index c072995257c..f9713931960 100644
--- a/frontend/src/metabase/api/table.ts
+++ b/frontend/src/metabase/api/table.ts
@@ -174,6 +174,14 @@ export const {
useDiscardTableFieldValuesMutation,
} = tableApi;
+/**
+ * Fetches metadata for all foreign tables referenced by the given table's foreign key fields.
+ * Dispatches queries to load metadata for each related table.
+ *
+ * @param table - The table containing foreign key fields
+ * @param params - Optional parameters to pass to the metadata query (excluding 'id')
+ * @returns A thunk function that dispatches metadata fetch actions for all foreign tables
+ */
export const fetchForeignTablesMetadata = (
table: Table,
params?: Omit<GetTableQueryMetadataRequest, "id">,
diff --git a/frontend/src/metabase/lib/urls/data-studio.ts b/frontend/src/metabase/lib/urls/data-studio.ts
index 79affacaae2..905fa1cb77b 100644
--- a/frontend/src/metabase/lib/urls/data-studio.ts
+++ b/frontend/src/metabase/lib/urls/data-studio.ts
@@ -110,12 +110,65 @@ export function dataStudioTableSegments(tableId: TableId) {
return `${dataStudioTable(tableId)}/segments`;
}
-export function dataStudioSegment(segmentId: SegmentId) {
- return `${dataStudioLibrary()}/segments/${segmentId}`;
+export function dataStudioPublishedTableSegmentNew(tableId: TableId) {
+ return `${dataStudioTableSegments(tableId)}/new`;
}
-export function newDataStudioSegment(tableId: TableId) {
- return `${dataStudioLibrary()}/segments/new?tableId=${tableId}`;
+export function dataStudioPublishedTableSegment(
+ tableId: TableId,
+ segmentId: SegmentId,
+) {
+ return `${dataStudioTableSegments(tableId)}/${segmentId}`;
+}
+
+export function dataStudioPublishedTableSegmentRevisions(
+ tableId: TableId,
+ segmentId: SegmentId,
+) {
+ return `${dataStudioPublishedTableSegment(tableId, segmentId)}/revisions`;
+}
+
+export function dataStudioPublishedTableSegmentDependencies(
+ tableId: TableId,
+ segmentId: SegmentId,
+) {
+ return `${dataStudioPublishedTableSegment(tableId, segmentId)}/dependencies`;
+}
+
+type DataModelSegmentParams = {
+ databaseId: DatabaseId;
+ schemaName: SchemaName;
+ tableId: TableId;
+ segmentId: SegmentId;
+};
+
+export function dataStudioDataModelSegment({
+ databaseId,
+ schemaName,
+ tableId,
+ segmentId,
+}: DataModelSegmentParams) {
+ return `${dataStudioData({ databaseId, schemaName, tableId, tab: "segments" })}/${segmentId}`;
+}
+
+export function dataStudioDataModelSegmentRevisions(
+ params: DataModelSegmentParams,
+) {
+ return `${dataStudioDataModelSegment(params)}/revisions`;
+}
+
+export function dataStudioDataModelSegmentDependencies(
+ params: DataModelSegmentParams,
+) {
+ return `${dataStudioDataModelSegment(params)}/dependencies`;
+}
+
+export function newDataStudioDataModelSegment({
+ databaseId,
+ schemaName,
+ tableId,
+}: Omit<DataModelSegmentParams, "segmentId">) {
+ return `${dataStudioData({ databaseId, schemaName, tableId, tab: "segments" })}/new`;
}
export type NewDataStudioQueryModelParams = {
diff --git a/frontend/src/metabase/lib/urls/data-studio.unit.spec.ts b/frontend/src/metabase/lib/urls/data-studio.unit.spec.ts
index f1543b0cd85..5880f4bd08e 100644
--- a/frontend/src/metabase/lib/urls/data-studio.unit.spec.ts
+++ b/frontend/src/metabase/lib/urls/data-studio.unit.spec.ts
@@ -1,12 +1,14 @@
import {
dataStudio,
dataStudioData,
+ dataStudioDataModelSegment,
+ dataStudioDataModelSegmentDependencies,
+ dataStudioDataModelSegmentRevisions,
dataStudioLibrary,
- dataStudioSegment,
dataStudioTable,
dataStudioTableFields,
dataStudioTableSegments,
- newDataStudioSegment,
+ newDataStudioDataModelSegment,
} from "./data-studio";
describe("urls > data-studio", () => {
@@ -126,16 +128,72 @@ describe("urls > data-studio", () => {
});
});
- describe("dataStudioSegment", () => {
- it("should return segment edit URL", () => {
- expect(dataStudioSegment(123)).toBe("/data-studio/library/segments/123");
+ describe("dataStudioDataModelSegment", () => {
+ const params = {
+ databaseId: 1,
+ schemaName: "public",
+ tableId: 42,
+ segmentId: 123,
+ };
+
+ it("should return data model segment URL", () => {
+ expect(dataStudioDataModelSegment(params)).toBe(
+ "/data-studio/data/database/1/schema/1:public/table/42/segments/123",
+ );
+ });
+
+ it("should encode schema name with special characters", () => {
+ expect(
+ dataStudioDataModelSegment({
+ ...params,
+ schemaName: "My Schema/Test",
+ }),
+ ).toBe(
+ "/data-studio/data/database/1/schema/1:My%20Schema%2FTest/table/42/segments/123",
+ );
+ });
+ });
+
+ describe("dataStudioDataModelSegmentRevisions", () => {
+ it("should return data model segment revisions URL", () => {
+ expect(
+ dataStudioDataModelSegmentRevisions({
+ databaseId: 1,
+ schemaName: "public",
+ tableId: 42,
+ segmentId: 123,
+ }),
+ ).toBe(
+ "/data-studio/data/database/1/schema/1:public/table/42/segments/123/revisions",
+ );
});
});
- describe("newDataStudioSegment", () => {
- it("should return new segment URL with tableId", () => {
- expect(newDataStudioSegment(42)).toBe(
- "/data-studio/library/segments/new?tableId=42",
+ describe("dataStudioDataModelSegmentDependencies", () => {
+ it("should return data model segment dependencies URL", () => {
+ expect(
+ dataStudioDataModelSegmentDependencies({
+ databaseId: 1,
+ schemaName: "public",
+ tableId: 42,
+ segmentId: 123,
+ }),
+ ).toBe(
+ "/data-studio/data/database/1/schema/1:public/table/42/segments/123/dependencies",
+ );
+ });
+ });
+
+ describe("newDataStudioDataModelSegment", () => {
+ it("should return new data model segment URL", () => {
+ expect(
+ newDataStudioDataModelSegment({
+ databaseId: 1,
+ schemaName: "public",
+ tableId: 42,
+ }),
+ ).toBe(
+ "/data-studio/data/database/1/schema/1:public/table/42/segments/new",
);
});
});
diff --git a/frontend/src/metabase/querying/segments/components/SegmentEditorV2/index.ts b/frontend/src/metabase/querying/segments/components/SegmentEditorV2/index.ts
deleted file mode 100644
index 7a65b053ccb..00000000000
--- a/frontend/src/metabase/querying/segments/components/SegmentEditorV2/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { SegmentEditorV2 } from "./SegmentEditorV2";
diff --git a/frontend/src/metabase/querying/segments/components/SegmentEditorV2/SegmentEditorV2.tsx b/frontend/src/metabase/querying/segments/components/SegmentFilterEditor/SegmentFilterEditor.tsx
similarity index 95%
rename from frontend/src/metabase/querying/segments/components/SegmentEditorV2/SegmentEditorV2.tsx
rename to frontend/src/metabase/querying/segments/components/SegmentFilterEditor/SegmentFilterEditor.tsx
index 5276729a692..f8e6d38eb07 100644
--- a/frontend/src/metabase/querying/segments/components/SegmentEditorV2/SegmentEditorV2.tsx
+++ b/frontend/src/metabase/querying/segments/components/SegmentFilterEditor/SegmentFilterEditor.tsx
@@ -9,17 +9,17 @@ import * as Lib from "metabase-lib";
const STAGE_INDEX = -1;
-type SegmentEditorV2Props = {
+type SegmentFilterEditorProps = {
query: Lib.Query;
onChange: (query: Lib.Query) => void;
readOnly?: boolean;
};
-export function SegmentEditorV2({
+export function SegmentFilterEditor({
query,
onChange,
readOnly = false,
-}: SegmentEditorV2Props) {
+}: SegmentFilterEditorProps) {
const filters = useMemo(() => Lib.filters(query, STAGE_INDEX), [query]);
const renderFilterName = useCallback(
diff --git a/frontend/src/metabase/querying/segments/components/SegmentFilterEditor/index.ts b/frontend/src/metabase/querying/segments/components/SegmentFilterEditor/index.ts
new file mode 100644
index 00000000000..ae6f7b30cce
--- /dev/null
+++ b/frontend/src/metabase/querying/segments/components/SegmentFilterEditor/index.ts
@@ -0,0 +1 @@
+export { SegmentFilterEditor } from "./SegmentFilterEditor";
diff --git a/frontend/src/metabase/querying/segments/index.ts b/frontend/src/metabase/querying/segments/index.ts
index 507335839d4..b052308246e 100644
--- a/frontend/src/metabase/querying/segments/index.ts
+++ b/frontend/src/metabase/querying/segments/index.ts
@@ -1 +1 @@
-export { SegmentEditorV2 } from "./components/SegmentEditorV2";
+export { SegmentFilterEditor } from "./components/SegmentFilterEditor";
diff --git a/frontend/test/__support__/server-mocks/revision.ts b/frontend/test/__support__/server-mocks/revision.ts
index 1779ab9ec22..a1de45f239b 100644
--- a/frontend/test/__support__/server-mocks/revision.ts
+++ b/frontend/test/__support__/server-mocks/revision.ts
@@ -5,3 +5,10 @@ import type { Revision } from "metabase-types/api";
export function setupRevisionsEndpoints(revisions: Revision[]) {
fetchMock.get("path:/api/revision", revisions);
}
+
+export function setupSegmentRevisionsEndpoint(
+ segmentId: number,
+ revisions: Revision[],
+) {
+ fetchMock.get(`path:/api/revision?entity=segment&id=${segmentId}`, revisions);
+}
diff --git a/frontend/test/__support__/server-mocks/segment.ts b/frontend/test/__support__/server-mocks/segment.ts
index 0edb7dd15ab..2b7dc600476 100644
--- a/frontend/test/__support__/server-mocks/segment.ts
+++ b/frontend/test/__support__/server-mocks/segment.ts
@@ -3,10 +3,24 @@ import fetchMock from "fetch-mock";
import type { Segment } from "metabase-types/api";
import { createMockSegment } from "metabase-types/api/mocks";
+export function setupSegmentRevisionsEndpointError(segmentId: number) {
+ fetchMock.get(`path:/api/revision?entity=segment&id=${segmentId}`, {
+ status: 500,
+ body: "Server error",
+ });
+}
+
export function setupSegmentEndpoint(segment: Segment) {
fetchMock.get(`path:/api/segment/${segment.id}`, segment);
}
+export function setupSegmentEndpointError(segmentId: number) {
+ fetchMock.get(`path:/api/segment/${segmentId}`, {
+ status: 500,
+ body: "Segment not found",
+ });
+}
+
export function setupSegmentsEndpoints(segments: Segment[]) {
fetchMock.post("path:/api/segment", async (call) => {
const metric = await fetchMock.callHistory
diff --git a/frontend/test/__support__/server-mocks/table.ts b/frontend/test/__support__/server-mocks/table.ts
index 3363797f7fd..391a4f8393c 100644
--- a/frontend/test/__support__/server-mocks/table.ts
+++ b/frontend/test/__support__/server-mocks/table.ts
@@ -1,6 +1,6 @@
import fetchMock from "fetch-mock";
-import type { ForeignKey, Table } from "metabase-types/api";
+import type { ForeignKey, Table, TableId } from "metabase-types/api";
import { setupFieldEndpoints } from "./field";
@@ -38,6 +38,16 @@ export function setupTableQueryMetadataEndpoint(table: Table) {
fetchMock.get(`path:/api/table/${table.id}/query_metadata`, table);
}
+export function setupTableQueryMetadataEndpointError(
+ tableId: TableId,
+ message = "Table not found",
+) {
+ fetchMock.get(`path:/api/table/${tableId}/query_metadata`, {
+ status: 500,
+ body: message,
+ });
+}
+
export function setupTablesEndpoints(tables: Table[]) {
fetchMock.get("path:/api/table", tables);
tables.forEach((table) => setupTableEndpoints(table));