Skip to content

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

Transforms collection tree (#66893)

Aleksandr Lesnenko218518570125
diff --git a/.clj-kondo/config/modules/config.edn b/.clj-kondo/config/modules/config.edn
index ab2ecd65629..a9b773a1f2c 100644
--- a/.clj-kondo/config/modules/config.edn
+++ b/.clj-kondo/config/modules/config.edn
@@ -2283,6 +2283,7 @@
:uses #{analytics
api
app-db
+ collections
driver
events
lib
diff --git a/e2e/support/helpers/api/createTransform.ts b/e2e/support/helpers/api/createTransform.ts
index 25e87c2e60d..fb5130d6e8d 100644
--- a/e2e/support/helpers/api/createTransform.ts
+++ b/e2e/support/helpers/api/createTransform.ts
@@ -1,4 +1,4 @@
-import type { Transform } from "metabase-types/api";
+import type { CollectionId, Transform } from "metabase-types/api";
export type TransformDetails = Pick<
Transform,
@@ -6,6 +6,7 @@ export type TransformDetails = Pick<
> & {
name?: string;
description?: string | null;
+ collection_id?: CollectionId | null;
};
export type CreateTransformOptions = {
@@ -21,6 +22,7 @@ export function createTransform(
source,
target,
tag_ids,
+ collection_id,
}: TransformDetails,
{
wrapId = false,
@@ -35,6 +37,7 @@ export function createTransform(
source,
target,
tag_ids,
+ collection_id,
})
.then(({ body }) => {
if (wrapId) {
diff --git a/e2e/support/helpers/e2e-transform-helpers.ts b/e2e/support/helpers/e2e-transform-helpers.ts
index db02a8faa9f..5d9757b1d32 100644
--- a/e2e/support/helpers/e2e-transform-helpers.ts
+++ b/e2e/support/helpers/e2e-transform-helpers.ts
@@ -1,5 +1,7 @@
import { WRITABLE_DB_ID } from "e2e/support/cypress_data";
import type {
+ Collection,
+ CollectionId,
ListTransformRunsResponse,
PythonTransformTableAliases,
TransformId,
@@ -10,6 +12,21 @@ import type {
import { createTransform } from "./api";
import { getTableId } from "./e2e-qa-databases-helpers";
+export function createTransformCollection({
+ name,
+ parent_id = null,
+}: {
+ name: string;
+ parent_id?: CollectionId | null;
+}): Cypress.Chainable<Cypress.Response<Collection>> {
+ cy.log(`Create a transform collection: ${name}`);
+ return cy.request("POST", "/api/collection", {
+ name,
+ parent_id,
+ namespace: "transforms",
+ });
+}
+
export function visitTransform(transformId: TransformId) {
cy.visit(`/data-studio/transforms/${transformId}`);
}
@@ -50,6 +67,7 @@ export function createMbqlTransform({
databaseId,
name,
visitTransform,
+ collectionId,
}: {
sourceTable: string;
targetTable: string;
@@ -58,6 +76,7 @@ export function createMbqlTransform({
name: string;
databaseId?: number;
visitTransform?: boolean;
+ collectionId?: CollectionId | null;
}) {
return getTableId({ databaseId, name: sourceTable }).then((tableId) => {
return createTransform(
@@ -81,6 +100,7 @@ export function createMbqlTransform({
schema: targetSchema,
},
tag_ids: tagIds,
+ collection_id: collectionId,
},
{ visitTransform },
);
diff --git a/e2e/support/helpers/e2e-visual-tests-helpers.js b/e2e/support/helpers/e2e-visual-tests-helpers.js
index d1fc7edcbd5..685aac7d094 100644
--- a/e2e/support/helpers/e2e-visual-tests-helpers.js
+++ b/e2e/support/helpers/e2e-visual-tests-helpers.js
@@ -1,6 +1,6 @@
import { popover } from "e2e/support/helpers/e2e-ui-elements-helpers";
import { color as getColor } from "metabase/lib/colors";
-import { Icons } from "metabase/ui";
+import { Icons } from "metabase/ui/components/icons/Icon/icons";
import { GOAL_LINE_DASH } from "metabase/visualizations/echarts/cartesian/option/goal-line.ts";
import { TREND_LINE_DASH } from "metabase/visualizations/echarts/cartesian/option/trend-line.ts";
import {
diff --git a/e2e/test/scenarios/data-studio/transforms.cy.spec.ts b/e2e/test/scenarios/data-studio/transforms.cy.spec.ts
index 43e2f739a49..facca52fd10 100644
--- a/e2e/test/scenarios/data-studio/transforms.cy.spec.ts
+++ b/e2e/test/scenarios/data-studio/transforms.cy.spec.ts
@@ -7,6 +7,7 @@ import { SAMPLE_DATABASE } from "e2e/support/cypress_sample_database";
import { createLibraryWithItems } from "e2e/support/test-library-data";
import type {
CardType,
+ CollectionId,
PythonTransformTableAliases,
TransformTagId,
} from "metabase-types/api";
@@ -786,7 +787,7 @@ LIMIT
cy.log("Navigate to transform B");
H.DataStudio.nav().findByRole("link", { name: "Transforms" }).click();
- cy.findByRole("table").findByText("Transform B").click();
+ cy.findByRole("treegrid").findByText("Transform B").click();
cy.log("Remove the new tag from transform B");
H.DataStudio.Transforms.runTab().click();
@@ -803,7 +804,7 @@ LIMIT
cy.log("Navigate to transform A");
getTransformsNavLink().click();
- cy.findByRole("table").findByText("Transform A").click();
+ cy.findByRole("treegrid").findByText("Transform A").click();
cy.log("The tag should be gone");
H.DataStudio.Transforms.runTab().click();
@@ -1627,6 +1628,285 @@ LIMIT
return cy.findByTestId("python-library-header");
}
});
+
+ describe("collections", () => {
+ it("should create collections and save transforms to them", () => {
+ cy.log("create a collection from the transforms list");
+ visitTransformListPage();
+ cy.button("Create a transform").click();
+ H.popover().findByText("New collection").click();
+
+ H.modal().within(() => {
+ cy.findByLabelText("Name").type("Marketing Transforms");
+ cy.button("Create").click();
+ });
+
+ getTransformsList().within(() => {
+ cy.findByText("Marketing Transforms").should("be.visible");
+ });
+
+ cy.log("create a nested collection");
+ cy.button("Create a transform").click();
+ H.popover().findByText("New collection").click();
+
+ H.modal().within(() => {
+ cy.findByLabelText("Name").type("Q4 Reports");
+ cy.findByTestId("collection-picker-button").click();
+ });
+
+ cy.findByRole("dialog", { name: "Select a collection" }).within(() => {
+ cy.findByText("Marketing Transforms").click();
+ cy.findByRole("button", { name: "Select" }).click();
+ });
+
+ H.modal().findByRole("button", { name: "Create" }).click();
+
+ getTransformsList().within(() => {
+ // Expand the collection to see the nested collection
+ cy.findByText("Marketing Transforms").click();
+ cy.findByText("Q4 Reports").should("be.visible");
+ });
+
+ cy.log("create a transform and save it to a collection");
+ cy.button("Create a transform").click();
+ H.popover().findByText("Query builder").click();
+
+ H.miniPicker().within(() => {
+ cy.findByText(DB_NAME).click();
+ cy.findByText(TARGET_SCHEMA).click();
+ cy.findByText(SOURCE_TABLE).click();
+ });
+
+ getQueryEditor().button("Save").click();
+
+ H.modal().within(() => {
+ cy.findByLabelText("Name").clear().type("Sales Summary");
+ cy.findByLabelText("Table name").clear().type("sales_summary");
+ cy.findByTestId("collection-picker-button").click();
+ });
+
+ cy.findByRole("dialog", { name: "Select a collection" }).within(() => {
+ cy.findByText("Marketing Transforms").click();
+ cy.findByRole("button", { name: "Select" }).click();
+ });
+
+ H.modal().findByRole("button", { name: "Save" }).click();
+ cy.wait("@createTransform");
+
+ cy.log("verify breadcrumbs show the collection path");
+ cy.findByTestId("data-studio-breadcrumbs").within(() => {
+ cy.findByText("Marketing Transforms").should("be.visible");
+ cy.findByText("Sales Summary").should("be.visible");
+ });
+
+ cy.log("navigate back to list via breadcrumb");
+ cy.findByTestId("data-studio-breadcrumbs").within(() => {
+ cy.findByRole("link", { name: "Marketing Transforms" }).click();
+ });
+
+ cy.url().should("include", "collectionId=");
+ getTransformsList().within(() => {
+ cy.findByText("Sales Summary").should("be.visible");
+ cy.findByText("Q4 Reports").should("be.visible");
+ });
+ });
+
+ it("should move transforms between collections", () => {
+ H.createTransformCollection({ name: "Target Collection" });
+
+ createMbqlTransform({
+ name: "Movable Transform",
+ targetTable: "movable_transform",
+ visitTransform: true,
+ });
+
+ cy.log("move transform to collection");
+ H.DataStudio.Transforms.header().icon("ellipsis").click();
+ H.popover().findByText("Move").click();
+
+ H.modal().within(() => {
+ cy.findByText("Target Collection").click();
+ cy.findByRole("button", { name: "Select" }).click();
+ });
+
+ H.undoToast().findByText("Transform moved").should("be.visible");
+
+ cy.log("verify breadcrumbs show collection path");
+ cy.findByTestId("data-studio-breadcrumbs").within(() => {
+ cy.findByText("Target Collection").should("be.visible");
+ cy.findByText("Movable Transform").should("be.visible");
+ });
+
+ cy.log("move transform back to root");
+ H.DataStudio.Transforms.header().icon("ellipsis").click();
+ H.popover().findByText("Move").click();
+
+ H.modal().within(() => {
+ cy.findByText("Transforms").click();
+ cy.findByRole("button", { name: "Select" }).click();
+ });
+
+ H.undoToastList().findByText("Transform moved").should("be.visible");
+
+ cy.log("verify breadcrumbs no longer show collection");
+ cy.findByTestId("data-studio-breadcrumbs").within(() => {
+ cy.findByText("Target Collection").should("not.exist");
+ cy.findByText("Movable Transform").should("be.visible");
+ });
+ });
+
+ it("should support search in the transforms list", () => {
+ H.createTransformCollection({ name: "Analytics" }).then((collection) => {
+ createMbqlTransform({
+ name: "Alpha Transform",
+ targetTable: "alpha_output",
+ });
+
+ createMbqlTransform({
+ name: "Beta Transform",
+ targetTable: "beta_output",
+ collectionId: collection.body.id,
+ });
+ });
+
+ visitTransformListPage();
+
+ cy.log("search should find transforms by name");
+ cy.findByPlaceholderText("Search...").type("alpha");
+
+ getTransformsList().within(() => {
+ cy.findAllByRole("row").should("have.length", 1);
+ cy.findByText("Alpha Transform").should("be.visible");
+ cy.findByText("Beta Transform").should("not.exist");
+ });
+
+ cy.log("search should find transforms by output table name");
+ cy.findByPlaceholderText("Search...").clear().type("beta_output");
+
+ getTransformsList().within(() => {
+ cy.findByText("Beta Transform").should("be.visible");
+ cy.findByText("Alpha Transform").should("not.exist");
+ cy.findByText("Analytics").should("be.visible");
+ });
+
+ cy.findByPlaceholderText("Search...").clear();
+ });
+
+ it("should create a new collection from the collection picker while saving a transform", () => {
+ visitTransformListPage();
+ cy.button("Create a transform").click();
+ H.popover().findByText("Query builder").click();
+
+ H.miniPicker().within(() => {
+ cy.findByText(DB_NAME).click();
+ cy.findByText(TARGET_SCHEMA).click();
+ cy.findByText(SOURCE_TABLE).click();
+ });
+
+ getQueryEditor().button("Save").click();
+
+ cy.log("open collection picker and create new collection inline");
+ H.modal().within(() => {
+ cy.findByLabelText("Name").clear().type("Analytics Transform");
+ cy.findByLabelText("Table name").clear().type("analytics_transform");
+ cy.findByTestId("collection-picker-button").click();
+ });
+
+ cy.findByRole("dialog", { name: "Select a collection" }).within(() => {
+ cy.findByRole("button", { name: /New collection/ }).click();
+ });
+
+ cy.findByRole("dialog", { name: "Create a new collection" }).within(
+ () => {
+ cy.findByLabelText("Give it a name").type("Analytics");
+ cy.button("Create").click();
+ },
+ );
+
+ cy.findByRole("dialog", { name: "Select a collection" }).within(() => {
+ cy.findByText("Analytics").should("be.visible");
+ cy.findByRole("button", { name: "Select" }).click();
+ });
+
+ H.modal().findByRole("button", { name: "Save" }).click();
+ cy.wait("@createTransform");
+
+ cy.log("verify transform is in the new collection");
+ cy.findByTestId("data-studio-breadcrumbs").within(() => {
+ cy.findByText("Analytics").should("be.visible");
+ cy.findByText("Analytics Transform").should("be.visible");
+ });
+
+ getTransformsNavLink().click();
+ getTransformsList().within(() => {
+ cy.findByText("Analytics").should("be.visible");
+ cy.findByText("Analytics").click();
+ cy.findByText("Analytics Transform").should("be.visible");
+ });
+ });
+
+ it("should sort transforms by all columns", () => {
+ H.createTransformCollection({ name: "Reports" }).then((collection) => {
+ createMbqlTransform({
+ name: "Zebra Transform",
+ targetTable: "zebra_output",
+ });
+
+ createMbqlTransform({
+ name: "Alpha Transform",
+ targetTable: "alpha_output",
+ collectionId: collection.body.id,
+ });
+
+ createMbqlTransform({
+ name: "Middle Transform",
+ targetTable: "middle_output",
+ });
+ });
+
+ visitTransformListPage();
+
+ cy.log("expand Reports collection to see all transforms");
+ getTransformsList().findByText("Reports").click();
+
+ cy.log("verify sorting by name column ascending");
+ getTransformsList().findByText("Name").click();
+
+ getRowNames().should("deep.equal", [
+ "Middle Transform",
+ "Reports",
+ "Alpha Transform",
+ "Zebra Transform",
+ ]);
+
+ cy.log("verify sorting by name column descending");
+ getTransformsList().findByText("Name").click();
+ getRowNames().should("deep.equal", [
+ "Zebra Transform",
+ "Reports",
+ "Alpha Transform",
+ "Middle Transform",
+ ]);
+
+ cy.log("verify sorting by output table column ascending");
+ getTransformsList().findByText("Output table").click();
+ getRowNames().should("deep.equal", [
+ "Reports",
+ "Alpha Transform",
+ "Middle Transform",
+ "Zebra Transform",
+ ]);
+
+ cy.log("verify sorting by output table column descending");
+ getTransformsList().findByText("Output table").click();
+ getRowNames().should("deep.equal", [
+ "Zebra Transform",
+ "Middle Transform",
+ "Reports",
+ "Alpha Transform",
+ ]);
+ });
+ });
});
describe("scenarios > admin > transforms > databases without :schemas", () => {
@@ -2495,6 +2775,7 @@ function createMbqlTransform(
name?: string;
databaseId?: number;
visitTransform?: boolean;
+ collectionId?: CollectionId | null;
} = {},
) {
return H.createMbqlTransform({
@@ -2603,3 +2884,9 @@ function setPythonRunnerSettings() {
);
H.updateEnterpriseSetting("python-storage-s-3-path-style-access", true);
}
+
+function getRowNames(): Cypress.Chainable<string[]> {
+ return getTransformsList()
+ .findAllByTestId("tree-node-name")
+ .then(($rows) => $rows.get().map((row) => row.textContent.trim()));
+}
diff --git a/enterprise/backend/src/metabase_enterprise/transforms/api.clj b/enterprise/backend/src/metabase_enterprise/transforms/api.clj
index 7c9f598b5d2..38c7cdfa679 100644
--- a/enterprise/backend/src/metabase_enterprise/transforms/api.clj
+++ b/enterprise/backend/src/metabase_enterprise/transforms/api.clj
@@ -123,7 +123,8 @@
[:source ::transforms.schema/transform-source]
[:target ::transforms.schema/transform-target]
[:run_trigger {:optional true} ::run-trigger]
- [:tag_ids {:optional true} [:sequential ms/PositiveInt]]]]
+ [:tag_ids {:optional true} [:sequential ms/PositiveInt]]
+ [:collection_id {:optional true} [:maybe ms/PositiveInt]]]]
(api/check-superuser)
(check-database-feature body)
(check-feature-enabled! body)
@@ -135,7 +136,7 @@
(let [tag-ids (:tag_ids body)
transform (t2/insert-returning-instance!
:model/Transform
- (assoc (select-keys body [:name :description :source :target :run_trigger])
+ (assoc (select-keys body [:name :description :source :target :run_trigger :collection_id])
:creator_id api/*current-user-id*))]
;; Add tag associations if provided
(when (seq tag-ids)
@@ -224,7 +225,8 @@
[:source {:optional true} ::transforms.schema/transform-source]
[:target {:optional true} ::transforms.schema/transform-target]
[:run_trigger {:optional true} ::run-trigger]
- [:tag_ids {:optional true} [:sequential ms/PositiveInt]]]]
+ [:tag_ids {:optional true} [:sequential ms/PositiveInt]]
+ [:collection_id {:optional true} [:maybe ms/PositiveInt]]]]
(api/check-superuser)
(let [transform (t2/with-transaction [_]
;; Cycle detection should occur within the transaction to avoid race
diff --git a/enterprise/backend/src/metabase_enterprise/transforms/models/transform.clj b/enterprise/backend/src/metabase_enterprise/transforms/models/transform.clj
index 5088b912630..9643ffcc860 100644
--- a/enterprise/backend/src/metabase_enterprise/transforms/models/transform.clj
+++ b/enterprise/backend/src/metabase_enterprise/transforms/models/transform.clj
@@ -5,6 +5,7 @@
[metabase-enterprise.transforms.interface :as transforms.i]
[metabase-enterprise.transforms.models.transform-run :as transform-run]
[metabase-enterprise.transforms.util :as transforms.util]
+ [metabase.collections.models.collection :as collection]
[metabase.events.core :as events]
[metabase.lib-be.core :as lib-be]
[metabase.lib.core :as lib]
@@ -48,12 +49,22 @@
:target mi/transform-json
:run_trigger mi/transform-keyword})
+(defmethod collection/allowed-namespaces :model/Transform
+ [_]
+ #{:transforms})
+
(t2/define-before-insert :model/Transform
- [{:keys [source] :as transform}]
+ [{:keys [source collection_id] :as transform}]
+ (collection/check-collection-namespace :model/Transform collection_id)
+ (when collection_id
+ (collection/check-allowed-content :model/Transform collection_id))
(assoc transform :source_type (transforms.util/transform-source-type source)))
(t2/define-before-update :model/Transform
[{:keys [source] :as transform}]
+ (when-let [new-collection (:collection_id (t2/changes transform))]
+ (collection/check-collection-namespace :model/Transform new-collection)
+ (collection/check-allowed-content :model/Transform new-collection))
(if source
(assoc transform :source_type (transforms.util/transform-source-type source))
transform))
@@ -221,14 +232,15 @@
(defmethod serdes/make-spec "Transform"
[_model-name opts]
- {:copy [:name :description :entity_id]
- :skip [:dependency_analysis_version :source_type]
- :transform {:created_at (serdes/date)
- :creator_id (serdes/fk :model/User)
- :source {:export #(update % :query serdes/export-mbql)
- :import #(update % :query serdes/import-mbql)}
- :target {:export serdes/export-mbql :import serdes/import-mbql}
- :tags (serdes/nested :model/TransformTransformTag :transform_id opts)}})
+ {:copy [:name :description :entity_id]
+ :skip [:dependency_analysis_version :source_type]
+ :transform {:created_at (serdes/date)
+ :creator_id (serdes/fk :model/User)
+ :collection_id (serdes/fk :model/Collection)
+ :source {:export #(update % :query serdes/export-mbql)
+ :import #(update % :query serdes/import-mbql)}
+ :target {:export serdes/export-mbql :import serdes/import-mbql}
+ :tags (serdes/nested :model/TransformTransformTag :transform_id opts)}})
(defmethod serdes/dependencies "Transform"
[{:keys [source tags]}]
diff --git a/enterprise/backend/test/metabase_enterprise/transforms/models_test.clj b/enterprise/backend/test/metabase_enterprise/transforms/models_test.clj
index cca4863ec9b..3c501aa8660 100644
--- a/enterprise/backend/test/metabase_enterprise/transforms/models_test.clj
+++ b/enterprise/backend/test/metabase_enterprise/transforms/models_test.clj
@@ -5,6 +5,7 @@
[metabase-enterprise.transforms.models.transform :as transform.model]
[metabase-enterprise.transforms.models.transform-job :as transform-job]
[metabase-enterprise.transforms.models.transform-tag :as transform-tag]
+ [metabase.collections.models.collection :as collection]
[metabase.config.core :as config]
[metabase.test :as mt]
[metabase.test.fixtures :as fixtures]
@@ -271,3 +272,15 @@
(is (=? (assoc user2-data :id user2-id)
(:creator (second hydrated)))
"Second hydrated should match the second user's data")))))))
+
+(deftest check-allowed-content-transforms
+ (mt/with-premium-features #{:data-studio}
+ (mt/with-temp [:model/Collection transforms {:name "Test Transforms" :namespace collection/transforms-ns}
+ :model/Collection regular-col {:name "Test Regular"}]
+ (mt/with-model-cleanup [:model/Transform :model/Card]
+ (testing "Can only add allowed content types"
+ (is (some? (t2/insert! :model/Transform (assoc (mt/with-temp-defaults :model/Transform) :collection_id (:id transforms)))))
+ (is (thrown-with-msg? clojure.lang.ExceptionInfo #"A Card can only go in Collections in the.*"
+ (t2/insert! :model/Card (merge (mt/with-temp-defaults :model/Card) {:type :model :collection_id (:id transforms)}))))
+ (is (thrown-with-msg? clojure.lang.ExceptionInfo #"A Transform can only go in Collections in the :transforms namespace."
+ (t2/insert! :model/Transform (assoc (mt/with-temp-defaults :model/Transform) :collection_id (:id regular-col))))))))))
diff --git a/enterprise/frontend/src/metabase-enterprise/api/transform.ts b/enterprise/frontend/src/metabase-enterprise/api/transform.ts
index 92e29222e4a..e5f5b2bfa53 100644
--- a/enterprise/frontend/src/metabase-enterprise/api/transform.ts
+++ b/enterprise/frontend/src/metabase-enterprise/api/transform.ts
@@ -159,8 +159,13 @@ export const transformApi = EnterpriseApi.injectEndpoints({
url: `/api/ee/transform/${id}`,
body,
}),
- invalidatesTags: (_, error, { id }) =>
- invalidateTags(error, [listTag("transform"), idTag("transform", id)]),
+ invalidatesTags: (_, error, { id, collection_id }) => {
+ const tags = [listTag("transform"), idTag("transform", id)];
+ if (collection_id != null) {
+ tags.push(idTag("collection", collection_id));
+ }
+ return invalidateTags(error, tags);
+ },
onQueryStarted: async (
{ id, ...patch },
{ dispatch, queryFulfilled },
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/common/hooks/use-collection-path/useCollectionPath.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/common/hooks/use-collection-path/useCollectionPath.ts
index d1e625372d4..1622db2224b 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/common/hooks/use-collection-path/useCollectionPath.ts
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/common/hooks/use-collection-path/useCollectionPath.ts
@@ -1,18 +1,24 @@
import { skipToken } from "metabase/api/api";
import { useGetCollectionQuery } from "metabase/api/collection";
import { isRootCollection } from "metabase/collections/utils";
-import type { CollectionId } from "metabase-types/api/collection";
+import type {
+ CollectionId,
+ CollectionNamespace,
+} from "metabase-types/api/collection";
interface UseCollectionPathOptions {
collectionId: CollectionId | null;
+ namespace?: CollectionNamespace;
}
export const useCollectionPath = ({
collectionId,
+ namespace,
}: UseCollectionPathOptions) => {
- const { data: collection, isLoading: isLoadingPath } = useGetCollectionQuery(
- !collectionId ? skipToken : { id: collectionId },
- );
+ const { currentData: collection, isLoading: isLoadingPath } =
+ useGetCollectionQuery(
+ collectionId == null ? skipToken : { id: collectionId, namespace },
+ );
const ancestors =
collection?.effective_ancestors?.filter((c) => !isRootCollection(c)) ?? [];
diff --git a/enterprise/frontend/src/metabase-enterprise/transforms/components/CreateTransformFolderModal/CreateTransformFolderModal.tsx b/enterprise/frontend/src/metabase-enterprise/transforms/components/CreateTransformFolderModal/CreateTransformFolderModal.tsx
new file mode 100644
index 00000000000..f1b7048389d
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/transforms/components/CreateTransformFolderModal/CreateTransformFolderModal.tsx
@@ -0,0 +1,99 @@
+import { useCallback, useMemo } from "react";
+import { t } from "ttag";
+import * as Yup from "yup";
+
+import { useCreateCollectionMutation } from "metabase/api";
+import { getErrorMessage } from "metabase/api/utils";
+import FormCollectionPicker from "metabase/collections/containers/FormCollectionPicker";
+import { useToast } from "metabase/common/hooks";
+import {
+ Form,
+ FormErrorMessage,
+ FormProvider,
+ FormSubmitButton,
+ FormTextInput,
+} from "metabase/forms";
+import * as Errors from "metabase/lib/errors";
+import { Button, Group, Modal, Stack } from "metabase/ui";
+import type { Collection } from "metabase-types/api";
+
+const COLLECTION_SCHEMA = Yup.object({
+ name: Yup.string()
+ .required(Errors.required)
+ .max(100, Errors.maxLength)
+ .default(""),
+ parent_id: Yup.number().nullable().default(null),
+});
+
+type CollectionFormValues = Yup.InferType<typeof COLLECTION_SCHEMA>;
+
+type CreateTransformFolderModalProps = {
+ onClose: () => void;
+ onCreate?: (collection: Collection) => void;
+};
+
+export function CreateTransformFolderModal({
+ onClose,
+ onCreate,
+}: CreateTransformFolderModalProps) {
+ const [sendToast] = useToast();
+ const [createCollection] = useCreateCollectionMutation();
+
+ const initialValues = useMemo<CollectionFormValues>(
+ () => COLLECTION_SCHEMA.getDefault(),
+ [],
+ );
+
+ const handleSubmit = useCallback(
+ async (values: CollectionFormValues) => {
+ try {
+ const collection = await createCollection({
+ name: values.name,
+ parent_id: values.parent_id,
+ namespace: "transforms",
+ }).unwrap();
+ onCreate?.(collection);
+ onClose();
+ } catch (error) {
+ sendToast({
+ message: getErrorMessage(error, t`Failed to create collection`),
+ icon: "warning",
+ });
+ }
+ },
+ [createCollection, onCreate, onClose, sendToast],
+ );
+
+ return (
+ <Modal title={t`New collection`} opened onClose={onClose} padding="xl">
+ <FormProvider
+ initialValues={initialValues}
+ validationSchema={COLLECTION_SCHEMA}
+ onSubmit={handleSubmit}
+ >
+ <Form>
+ <Stack gap="lg" mt="sm">
+ <FormTextInput
+ name="name"
+ label={t`Name`}
+ placeholder={t`My collection`}
+ data-autofocus
+ />
+ <FormCollectionPicker
+ name="parent_id"
+ title={t`Parent collection`}
+ type="transform-collections"
+ />
+ <Group justify="flex-end">
+ <FormErrorMessage />
+ <Button variant="subtle" onClick={onClose}>
+ {t`Cancel`}
+ </Button>
+ <FormSubmitButton label={t`Create`} variant="filled" />
+ </Group>
+ </Stack>
+ </Form>
+ </FormProvider>
+ </Modal>
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/transforms/components/CreateTransformFolderModal/index.ts b/enterprise/frontend/src/metabase-enterprise/transforms/components/CreateTransformFolderModal/index.ts
new file mode 100644
index 00000000000..96896e0fe90
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/transforms/components/CreateTransformFolderModal/index.ts
@@ -0,0 +1 @@
+export { CreateTransformFolderModal } from "./CreateTransformFolderModal";
diff --git a/enterprise/frontend/src/metabase-enterprise/transforms/components/CreateTransformMenu/CreateTransformMenu.tsx b/enterprise/frontend/src/metabase-enterprise/transforms/components/CreateTransformMenu/CreateTransformMenu.tsx
index f92fe1d0896..500b416aedd 100644
--- a/enterprise/frontend/src/metabase-enterprise/transforms/components/CreateTransformMenu/CreateTransformMenu.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/transforms/components/CreateTransformMenu/CreateTransformMenu.tsx
@@ -10,6 +10,7 @@ import { PLUGIN_TRANSFORMS_PYTHON } from "metabase/plugins";
import { Button, Center, Icon, Loader, Menu, Tooltip } from "metabase/ui";
import { trackTransformCreate } from "../../analytics";
+import { CreateTransformFolderModal } from "../CreateTransformFolderModal";
import { shouldDisableItem } from "./utils";
@@ -17,6 +18,10 @@ export const CreateTransformMenu = () => {
const dispatch = useDispatch();
const [isPickerOpened, { open: openPicker, close: closePicker }] =
useDisclosure();
+ const [
+ isFolderModalOpened,
+ { open: openFolderModal, close: closeFolderModal },
+ ] = useDisclosure();
const { data: databases, isLoading } = useListDatabasesQuery({
include_analytics: true,
@@ -71,7 +76,7 @@ export const CreateTransformMenu = () => {
</Menu.Item>
)}
<Menu.Item
- leftSection={<Icon name="folder" />}
+ leftSection={<Icon name="insight" />}
onClick={() => {
trackTransformCreate({ creationType: "saved-question" });
openPicker();
@@ -79,6 +84,13 @@ export const CreateTransformMenu = () => {
>
{t`Copy of a saved question`}
</Menu.Item>
+ <Menu.Divider />
+ <Menu.Item
+ leftSection={<Icon name="folder" />}
+ onClick={openFolderModal}
+ >
+ {t`New collection`}
+ </Menu.Item>
</>
)}
</Menu.Dropdown>
@@ -98,6 +110,10 @@ export const CreateTransformMenu = () => {
onClose={closePicker}
/>
)}
+
+ {isFolderModalOpened && (
+ <CreateTransformFolderModal onClose={closeFolderModal} />
+ )}
</>
);
};
diff --git a/enterprise/frontend/src/metabase-enterprise/transforms/components/TransformHeader/TransformHeader.tsx b/enterprise/frontend/src/metabase-enterprise/transforms/components/TransformHeader/TransformHeader.tsx
index 8904e3ddad6..ee5f2dd8cec 100644
--- a/enterprise/frontend/src/metabase-enterprise/transforms/components/TransformHeader/TransformHeader.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/transforms/components/TransformHeader/TransformHeader.tsx
@@ -6,6 +6,7 @@ import * as Urls from "metabase/lib/urls";
import type { StackProps } from "metabase/ui";
import { DataStudioBreadcrumbs } from "metabase-enterprise/data-studio/common/components/DataStudioBreadcrumbs";
import { PaneHeader } from "metabase-enterprise/data-studio/common/components/PaneHeader";
+import { useCollectionPath } from "metabase-enterprise/data-studio/common/hooks/use-collection-path/useCollectionPath";
import type { Transform } from "metabase-types/api";
import { TransformMoreMenu } from "./TransformMoreMenu";
@@ -26,6 +27,11 @@ export function TransformHeader({
isEditMode = false,
...restProps
}: TransformHeaderProps) {
+ const { path, isLoadingPath } = useCollectionPath({
+ collectionId: transform.collection_id,
+ namespace: "transforms",
+ });
+
return (
<PaneHeader
title={<TransformNameInput transform={transform} />}
@@ -35,8 +41,16 @@ export function TransformHeader({
actions={actions}
data-testid="transforms-header"
breadcrumbs={
- <DataStudioBreadcrumbs>
+ <DataStudioBreadcrumbs loading={isLoadingPath}>
<Link to={Urls.transformList()}>{t`Transforms`}</Link>
+ {path?.map((folder) => (
+ <Link
+ key={folder.id}
+ to={`${Urls.transformList()}?collectionId=${folder.id}`}
+ >
+ {folder.name}
+ </Link>
+ ))}
{transform.name}
</DataStudioBreadcrumbs>
}
diff --git a/enterprise/frontend/src/metabase-enterprise/transforms/components/TransformHeader/TransformMoreMenu/MoveTransformModal.tsx b/enterprise/frontend/src/metabase-enterprise/transforms/components/TransformHeader/TransformMoreMenu/MoveTransformModal.tsx
new file mode 100644
index 00000000000..5eb606d1b46
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/transforms/components/TransformHeader/TransformMoreMenu/MoveTransformModal.tsx
@@ -0,0 +1,67 @@
+import { useCallback, useMemo } from "react";
+import { c } from "ttag";
+
+import { canonicalCollectionId } from "metabase/collections/utils";
+import {
+ type CollectionPickerItem,
+ CollectionPickerModal,
+ type CollectionPickerOptions,
+} from "metabase/common/components/Pickers/CollectionPicker";
+import { useUpdateTransformMutation } from "metabase-enterprise/api";
+import type { Transform } from "metabase-types/api";
+
+const TRANSFORM_COLLECTION_PICKER_OPTIONS: CollectionPickerOptions = {
+ namespace: "transforms",
+ showPersonalCollections: false,
+ showRootCollection: true,
+ showSearch: false,
+ hasConfirmButtons: true,
+ allowCreateNew: true,
+ hasRecents: false,
+ showLibrary: false,
+};
+
+type MoveTransformModalProps = {
+ transform: Transform;
+ onMove: () => void;
+ onClose: () => void;
+};
+
+export function MoveTransformModal({
+ transform,
+ onMove,
+ onClose,
+}: MoveTransformModalProps) {
+ const [updateTransform] = useUpdateTransformMutation();
+
+ const handleChange = useCallback(
+ async ({ id }: CollectionPickerItem) => {
+ const collectionId = canonicalCollectionId(id);
+ await updateTransform({
+ id: transform.id,
+ collection_id: collectionId,
+ }).unwrap();
+ onMove();
+ },
+ [transform.id, updateTransform, onMove],
+ );
+
+ const pickerValue = useMemo(
+ () => ({
+ id: transform.collection_id ?? "root",
+ model: "collection" as const,
+ }),
+ [transform.collection_id],
+ );
+
+ return (
+ <CollectionPickerModal
+ title={c("dialog title for moving a transform to another collection")
+ .t`Move "${transform.name}"`}
+ value={pickerValue}
+ onChange={handleChange}
+ onClose={onClose}
+ options={TRANSFORM_COLLECTION_PICKER_OPTIONS}
+ />
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/transforms/components/TransformHeader/TransformMoreMenu/TransformMoreMenu.tsx b/enterprise/frontend/src/metabase-enterprise/transforms/components/TransformHeader/TransformMoreMenu/TransformMoreMenu.tsx
index 27a78342aca..d962e8130a5 100644
--- a/enterprise/frontend/src/metabase-enterprise/transforms/components/TransformHeader/TransformMoreMenu/TransformMoreMenu.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/transforms/components/TransformHeader/TransformMoreMenu/TransformMoreMenu.tsx
@@ -9,6 +9,7 @@ import { ActionIcon, Icon, Menu } from "metabase/ui";
import type { Transform } from "metabase-types/api";
import { DeleteTransformModal } from "./DeleteTransformModal";
+import { MoveTransformModal } from "./MoveTransformModal";
import type { TransformMoreMenuModalType } from "./types";
type TransformMoreMenuProps = {
@@ -50,6 +51,12 @@ function TransformMenu({ onOpenModal }: TransformMenuProps) {
</ActionIcon>
</Menu.Target>
<Menu.Dropdown>
+ <Menu.Item
+ leftSection={<Icon name="move" />}
+ onClick={() => onOpenModal("move")}
+ >
+ {t`Move`}
+ </Menu.Item>
<Menu.Item
leftSection={<Icon name="trash" />}
onClick={() => onOpenModal("delete")}
@@ -81,6 +88,11 @@ function TransformModal({
onClose();
};
+ const handleMove = () => {
+ sendSuccessToast(t`Transform moved`);
+ onClose();
+ };
+
switch (modalType) {
case "delete":
return (
@@ -90,6 +102,14 @@ function TransformModal({
onClose={onClose}
/>
);
+ case "move":
+ return (
+ <MoveTransformModal
+ transform={transform}
+ onMove={handleMove}
+ onClose={onClose}
+ />
+ );
default:
return null;
}
diff --git a/enterprise/frontend/src/metabase-enterprise/transforms/components/TransformHeader/TransformMoreMenu/types.ts b/enterprise/frontend/src/metabase-enterprise/transforms/components/TransformHeader/TransformMoreMenu/types.ts
index 8513a09d14a..239c69d1a5d 100644
--- a/enterprise/frontend/src/metabase-enterprise/transforms/components/TransformHeader/TransformMoreMenu/types.ts
+++ b/enterprise/frontend/src/metabase-enterprise/transforms/components/TransformHeader/TransformMoreMenu/types.ts
@@ -1,6 +1,6 @@
import type { TransformId } from "metabase-types/api";
-export type TransformMoreMenuModalType = "delete";
+export type TransformMoreMenuModalType = "delete" | "move";
export type TransformMoreMenuModalState = {
transformId: TransformId;
diff --git a/enterprise/frontend/src/metabase-enterprise/transforms/pages/NewTransformPage/CreateTransformModal/CreateTransformModal.tsx b/enterprise/frontend/src/metabase-enterprise/transforms/pages/NewTransformPage/CreateTransformModal/CreateTransformModal.tsx
index 25c64bb9f2b..193f1dee37d 100644
--- a/enterprise/frontend/src/metabase-enterprise/transforms/pages/NewTransformPage/CreateTransformModal/CreateTransformModal.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/transforms/pages/NewTransformPage/CreateTransformModal/CreateTransformModal.tsx
@@ -9,6 +9,7 @@ import {
useListDatabaseSchemasQuery,
} from "metabase/api";
import { getErrorMessage } from "metabase/api/utils";
+import FormCollectionPicker from "metabase/collections/containers/FormCollectionPicker";
import { LoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper";
import { useToast } from "metabase/common/hooks";
import {
@@ -39,6 +40,7 @@ function getValidationSchema() {
name: Yup.string().required(Errors.required),
targetName: Yup.string().required(Errors.required),
targetSchema: Yup.string().nullable().defined(),
+ collection_id: Yup.number().nullable().defined(),
incremental: Yup.boolean().required(),
// For native queries, use checkpointFilter (plain string)
checkpointFilter: Yup.string().nullable(),
@@ -165,6 +167,10 @@ function CreateTransformForm({
/>
)}
<TargetNameInput />
+ <FormCollectionPicker
+ name="collection_id"
+ type="transform-collections"
+ />
<IncrementalTransformSettings source={source} />
<Group>
<Box flex={1}>
@@ -186,6 +192,7 @@ function getInitialValues(
return {
name: "",
targetSchema: schemas?.[0] || null,
+ collection_id: null,
...defaultValues,
targetName: defaultValues.targetName
? defaultValues.targetName
@@ -206,6 +213,7 @@ function getCreateRequest(
name,
targetName,
targetSchema,
+ collection_id,
incremental,
checkpointFilter,
checkpointFilterUniqueKey,
@@ -258,5 +266,6 @@ function getCreateRequest(
name,
source: transformSource,
target: transformTarget,
+ collection_id: collection_id ?? null,
};
}
diff --git a/enterprise/frontend/src/metabase-enterprise/transforms/pages/TransformListPage/TransformListPage.tsx b/enterprise/frontend/src/metabase-enterprise/transforms/pages/TransformListPage/TransformListPage.tsx
index 86132eb38b5..e62de87b1cf 100644
--- a/enterprise/frontend/src/metabase-enterprise/transforms/pages/TransformListPage/TransformListPage.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/transforms/pages/TransformListPage/TransformListPage.tsx
@@ -1,140 +1,251 @@
-import { useDebouncedValue } from "@mantine/hooks";
-import type { ColumnDef } from "@tanstack/react-table";
-import { type ReactNode, useMemo, useState } from "react";
+import type { Row } from "@tanstack/react-table";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import type { WithRouterProps } from "react-router";
import { push } from "react-router-redux";
import { t } from "ttag";
+import {
+ skipToken,
+ useGetCollectionQuery,
+ useListCollectionsTreeQuery,
+} from "metabase/api";
import DateTime from "metabase/common/components/DateTime";
+import { Ellipsified } from "metabase/common/components/Ellipsified";
import { LoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper";
+import CS from "metabase/css/core/index.css";
import { useDispatch } from "metabase/lib/redux";
import * as Urls from "metabase/lib/urls";
-import { Card, Flex, Group, Icon, Stack, TextInput } from "metabase/ui";
+import type { TreeTableColumnDef } from "metabase/ui";
+import {
+ Card,
+ EntityNameCell,
+ Flex,
+ Icon,
+ Stack,
+ TextInput,
+ TreeTable,
+ useTreeTableInstance,
+} from "metabase/ui";
import { useListTransformsQuery } from "metabase-enterprise/api";
import { DataStudioBreadcrumbs } from "metabase-enterprise/data-studio/common/components/DataStudioBreadcrumbs";
import { PageContainer } from "metabase-enterprise/data-studio/common/components/PageContainer";
import { PaneHeader } from "metabase-enterprise/data-studio/common/components/PaneHeader";
-import { Table } from "metabase-enterprise/data-studio/common/components/Table";
import { CreateTransformMenu } from "metabase-enterprise/transforms/components/CreateTransformMenu";
import { ListEmptyState } from "metabase-enterprise/transforms/components/ListEmptyState";
import { ListLoadingState } from "metabase-enterprise/transforms/components/ListLoadingState";
-import type { Transform } from "metabase-types/api";
-export const TransformListPage = () => {
+import { type TreeNode, getCollectionNodeId } from "./types";
+import { buildTreeData, getDefaultExpandedIds } from "./utils";
+
+const getNodeId = (node: TreeNode) => node.id;
+const getSubRows = (node: TreeNode) => node.children;
+const isFilterable = (node: TreeNode) => node.nodeType === "transform";
+
+const globalFilterFn = (
+ row: { original: TreeNode },
+ _columnId: string,
+ filterValue: string,
+) => {
+ if (row.original.nodeType !== "transform") {
+ return false;
+ }
+ const query = String(filterValue).toLowerCase();
+ return (
+ row.original.name.toLowerCase().includes(query) ||
+ (row.original.target?.name.toLowerCase().includes(query) ?? false)
+ );
+};
+
+export const TransformListPage = ({ location }: WithRouterProps) => {
const dispatch = useDispatch();
+ const targetCollectionId =
+ Urls.extractEntityId(location.query?.collectionId) ?? null;
+ const hasScrolledRef = useRef(false);
const [searchQuery, setSearchQuery] = useState("");
- const [debouncedSearchQuery] = useDebouncedValue(searchQuery, 300);
- const { data: transforms, error, isLoading } = useListTransformsQuery({});
+ const { data: targetCollection } = useGetCollectionQuery(
+ targetCollectionId
+ ? { id: targetCollectionId, namespace: "transforms" }
+ : skipToken,
+ );
- const filteredTransforms = useMemo(() => {
- if (!transforms) {
- return [];
- }
+ const {
+ data: collections,
+ error: collectionsError,
+ isLoading: isLoadingCollections,
+ } = useListCollectionsTreeQuery({
+ namespace: "transforms",
+ "exclude-archived": true,
+ });
- if (!debouncedSearchQuery) {
- return transforms;
- }
+ const {
+ data: transforms,
+ error: transformsError,
+ isLoading: isLoadingTransforms,
+ } = useListTransformsQuery({});
+
+ const isLoading = isLoadingCollections || isLoadingTransforms;
+ const error = collectionsError ?? transformsError;
+
+ const treeData = useMemo(
+ () => buildTreeData(collections, transforms),
+ [collections, transforms],
+ );
- const query = debouncedSearchQuery.toLowerCase();
- return transforms.filter(
- (transform) =>
- transform.name.toLowerCase().includes(query) ||
- transform.target.name.toLowerCase().includes(query),
- );
- }, [transforms, debouncedSearchQuery]);
+ const defaultExpanded = useMemo(
+ () => getDefaultExpandedIds(targetCollectionId, targetCollection),
+ [targetCollectionId, targetCollection],
+ );
- const transformColumnDef = useMemo<ColumnDef<Transform, ReactNode>[]>(
+ const columnDefs = useMemo<TreeTableColumnDef<TreeNode>[]>(
() => [
{
+ id: "name",
accessorKey: "name",
- meta: {
- width: "auto",
- },
header: t`Name`,
- cell: ({ getValue }) => (
- <Group data-testid="transform-name" gap="sm">
- <Icon name="transform" c="brand" />
- {getValue()}
- </Group>
+ minWidth: 320,
+ enableSorting: true,
+ cell: ({ row }) => (
+ <EntityNameCell
+ data-testid="tree-node-name"
+ icon={row.original.icon}
+ iconColor={
+ row.original.nodeType === "folder" ? "text-medium" : "brand"
+ }
+ name={row.original.name}
+ />
),
},
{
+ id: "updated_at",
accessorKey: "updated_at",
- cell: ({ getValue }) => {
- const value = getValue() as string;
- return value && <DateTime value={value} />;
- },
- meta: {
- width: "auto",
- },
header: t`Last Modified`,
+ maxWidth: 260,
+ minWidth: "auto",
+ enableSorting: true,
+ sortingFn: "datetime",
+ sortDescFirst: true,
+ cell: ({ row }) =>
+ row.original.updated_at ? (
+ <DateTime value={row.original.updated_at} />
+ ) : null,
},
{
- accessorFn: (transform: Transform) => transform.target.name,
+ id: "output_table",
+ accessorFn: (node) => node.target?.name ?? "",
header: t`Output table`,
+ minWidth: 240,
+ enableSorting: true,
+ cell: ({ row }) =>
+ row.original.target?.name ? (
+ <Ellipsified>{row.original.target.name}</Ellipsified>
+ ) : null,
},
],
[],
);
+ const navigateToTransform = useCallback(
+ (transformId: number) => {
+ dispatch(push(Urls.transform(transformId)));
+ },
+ [dispatch],
+ );
+
+ const handleRowActivate = useCallback(
+ (row: Row<TreeNode>) => {
+ if (row.original.nodeType === "transform" && row.original.transformId) {
+ navigateToTransform(row.original.transformId);
+ }
+ },
+ [navigateToTransform],
+ );
+
+ const treeTableInstance = useTreeTableInstance({
+ data: treeData,
+ columns: columnDefs,
+ getNodeId,
+ getSubRows,
+ defaultExpanded,
+ expanded: searchQuery ? true : undefined,
+ globalFilter: searchQuery,
+ onGlobalFilterChange: setSearchQuery,
+ globalFilterFn,
+ isFilterable,
+ onRowActivate: handleRowActivate,
+ });
+
+ const handleRowClick = useCallback(
+ (row: Row<TreeNode>) => {
+ if (row.getCanExpand()) {
+ row.toggleExpanded();
+ } else if (
+ row.original.nodeType === "transform" &&
+ row.original.transformId
+ ) {
+ navigateToTransform(row.original.transformId);
+ }
+ },
+ [navigateToTransform],
+ );
+
+ useEffect(() => {
+ if (targetCollectionId && !hasScrolledRef.current && !isLoading) {
+ const nodeId = getCollectionNodeId(targetCollectionId);
+ treeTableInstance.scrollToNode(nodeId);
+ hasScrolledRef.current = true;
+ }
+ }, [targetCollectionId, isLoading, treeTableInstance]);
+
if (error) {
return <LoadingAndErrorWrapper loading={false} error={error} />;
}
- const handleSelect = (item: Transform) => {
- if (typeof item.id === "number") {
- dispatch(push(Urls.transform(item.id)));
- }
- };
+ const hasNoData = treeData.length === 0;
+ const hasNoResults = !hasNoData && treeTableInstance.rows.length === 0;
+
+ const emptyMessage = hasNoData
+ ? t`No transforms yet`
+ : hasNoResults && searchQuery
+ ? t`No transforms found`
+ : null;
return (
- <>
- <PageContainer data-testid="transforms-list" gap={0}>
- <PaneHeader
- breadcrumbs={
- <DataStudioBreadcrumbs>{t`Transforms`}</DataStudioBreadcrumbs>
- }
- showMetabotButton
- py={0}
- />
- <Stack style={{ overflow: "hidden" }}>
- <Flex gap="md">
- <TextInput
- placeholder={t`Search...`}
- leftSection={<Icon name="search" />}
- bdrs="md"
- flex="1"
- value={searchQuery}
- onChange={(e) => setSearchQuery(e.target.value)}
+ <PageContainer data-testid="transforms-list" gap={0}>
+ <PaneHeader
+ breadcrumbs={
+ <DataStudioBreadcrumbs>{t`Transforms`}</DataStudioBreadcrumbs>
+ }
+ showMetabotButton
+ py={0}
+ />
+ <Stack className={CS.overflowHidden}>
+ <Flex gap="md">
+ <TextInput
+ placeholder={t`Search...`}
+ leftSection={<Icon name="search" />}
+ bdrs="md"
+ flex="1"
+ value={searchQuery}
+ onChange={(e) => setSearchQuery(e.target.value)}
+ />
+ <CreateTransformMenu />
+ </Flex>
+
+ <Card withBorder p={0}>
+ {isLoading ? (
+ <ListLoadingState />
+ ) : (
+ <TreeTable
+ instance={treeTableInstance}
+ emptyState={
+ emptyMessage ? <ListEmptyState label={emptyMessage} /> : null
+ }
+ onRowClick={handleRowClick}
/>
- <CreateTransformMenu />
- </Flex>
-
- <Card withBorder p={0}>
- {isLoading ? (
- <ListLoadingState />
- ) : filteredTransforms.length === 0 ? (
- <ListEmptyState
- label={
- debouncedSearchQuery
- ? t`No transforms found`
- : t`No transforms yet`
- }
- />
- ) : (
- <Table
- data={filteredTransforms.map((t) => ({
- ...t,
- out_table: t.target.name,
- last_modified: new Date(t.updated_at).toDateString(),
- }))}
- columns={transformColumnDef}
- onSelect={handleSelect}
- />
- )}
- </Card>
- </Stack>
- </PageContainer>
- </>
+ )}
+ </Card>
+ </Stack>
+ </PageContainer>
);
};
diff --git a/enterprise/frontend/src/metabase-enterprise/transforms/pages/TransformListPage/types.ts b/enterprise/frontend/src/metabase-enterprise/transforms/pages/TransformListPage/types.ts
new file mode 100644
index 00000000000..98df2f3d6b3
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/transforms/pages/TransformListPage/types.ts
@@ -0,0 +1,23 @@
+import type { IconName } from "metabase/ui";
+import type { Transform } from "metabase-types/api";
+
+export type TreeNodeType = "folder" | "transform";
+
+export type TreeNode = {
+ id: string;
+ name: string;
+ nodeType: TreeNodeType;
+ icon: IconName;
+ updated_at?: string;
+ target?: Transform["target"];
+ children?: TreeNode[];
+ transformId?: number;
+};
+
+export function getCollectionNodeId(collectionId: number): string {
+ return `collection-${collectionId}`;
+}
+
+export function getTransformNodeId(transformId: number): string {
+ return `transform-${transformId}`;
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/transforms/pages/TransformListPage/utils.ts b/enterprise/frontend/src/metabase-enterprise/transforms/pages/TransformListPage/utils.ts
new file mode 100644
index 00000000000..bdac5ff02bb
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/transforms/pages/TransformListPage/utils.ts
@@ -0,0 +1,79 @@
+import { getCollectionIcon } from "metabase/entities/collections/utils";
+import type { Collection, Transform } from "metabase-types/api";
+
+import {
+ type TreeNode,
+ getCollectionNodeId,
+ getTransformNodeId,
+} from "./types";
+
+export function buildTreeData(
+ collections: Collection[] | undefined,
+ transforms: Transform[] | undefined,
+): TreeNode[] {
+ if (!collections && !transforms) {
+ return [];
+ }
+
+ const transformsByCollectionId = new Map<number | null, Transform[]>();
+ for (const transform of transforms ?? []) {
+ const collectionId = transform.collection_id;
+ if (!transformsByCollectionId.has(collectionId)) {
+ transformsByCollectionId.set(collectionId, []);
+ }
+ transformsByCollectionId.get(collectionId)!.push(transform);
+ }
+
+ function buildCollectionNode(collection: Collection): TreeNode {
+ const childFolders = (collection.children ?? []).map(buildCollectionNode);
+ const childTransforms = (
+ transformsByCollectionId.get(collection.id as number) ?? []
+ ).map(buildTransformNode);
+
+ return {
+ id: getCollectionNodeId(collection.id as number),
+ name: collection.name,
+ nodeType: "folder",
+ icon: getCollectionIcon(collection).name,
+ children: [...childFolders, ...childTransforms],
+ };
+ }
+
+ function buildTransformNode(transform: Transform): TreeNode {
+ return {
+ id: getTransformNodeId(transform.id),
+ name: transform.name,
+ nodeType: "transform",
+ icon: "transform",
+ updated_at: transform.updated_at,
+ target: transform.target,
+ transformId: transform.id,
+ };
+ }
+
+ const rootFolders = (collections ?? []).map(buildCollectionNode);
+ const rootTransforms = (transformsByCollectionId.get(null) ?? []).map(
+ buildTransformNode,
+ );
+
+ return [...rootFolders, ...rootTransforms];
+}
+
+export function getDefaultExpandedIds(
+ targetCollectionId: number | null,
+ targetCollection: Collection | undefined,
+): Record<string, boolean> | undefined {
+ if (!targetCollectionId || !targetCollection) {
+ return undefined;
+ }
+
+ const expandedIds: Record<string, boolean> = {};
+ const ancestors = targetCollection.effective_ancestors ?? [];
+
+ for (const ancestor of ancestors.slice(1)) {
+ expandedIds[getCollectionNodeId(ancestor.id as number)] = true;
+ }
+ expandedIds[getCollectionNodeId(targetCollectionId)] = true;
+
+ return expandedIds;
+}
diff --git a/frontend/src/metabase-types/api/collection.ts b/frontend/src/metabase-types/api/collection.ts
index ca7d9c5122c..aeff3775342 100644
--- a/frontend/src/metabase-types/api/collection.ts
+++ b/frontend/src/metabase-types/api/collection.ts
@@ -19,6 +19,7 @@ import type { UserId, UserInfo } from "./user";
export type CollectionNamespace =
| null
| "snippets"
+ | "transforms"
| "tenant-specific"
| "shared-tenant-collection";
@@ -86,7 +87,7 @@ export interface Collection {
authority_level?: CollectionAuthorityLevel;
type?: CollectionType;
is_remote_synced?: boolean;
- namespace: CollectionNamespace;
+ namespace: CollectionNamespace | null;
parent_id?: CollectionId | null;
personal_owner_id?: UserId;
diff --git a/frontend/src/metabase-types/api/mocks/transform.ts b/frontend/src/metabase-types/api/mocks/transform.ts
index 27312d6fdd1..dcf0cdbe049 100644
--- a/frontend/src/metabase-types/api/mocks/transform.ts
+++ b/frontend/src/metabase-types/api/mocks/transform.ts
@@ -71,6 +71,7 @@ export function createMockTransform(opts?: Partial<Transform>): Transform {
description: null,
source: createMockTransformSource(),
target: createMockTransformTarget(),
+ collection_id: null,
created_at: "2000-01-01T00:00:00Z",
updated_at: "2000-01-01T00:00:00Z",
...opts,
diff --git a/frontend/src/metabase-types/api/transform.ts b/frontend/src/metabase-types/api/transform.ts
index 86a5788f813..7430d7fdf9b 100644
--- a/frontend/src/metabase-types/api/transform.ts
+++ b/frontend/src/metabase-types/api/transform.ts
@@ -15,6 +15,7 @@ export type Transform = {
description: string | null;
source: TransformSource;
target: TransformTarget;
+ collection_id: number | null;
created_at: string;
updated_at: string;
@@ -144,6 +145,7 @@ export type CreateTransformRequest = {
source: TransformSource;
target: TransformTarget;
tag_ids?: TransformTagId[];
+ collection_id?: number | null;
};
export type UpdateTransformRequest = {
@@ -153,6 +155,7 @@ export type UpdateTransformRequest = {
source?: TransformSource;
target?: TransformTarget;
tag_ids?: TransformTagId[];
+ collection_id?: number | null;
};
export type CreateTransformJobRequest = {
diff --git a/frontend/src/metabase/collections/containers/FormCollectionPicker/FormCollectionPicker.tsx b/frontend/src/metabase/collections/containers/FormCollectionPicker/FormCollectionPicker.tsx
index e3590655c8c..f6486ca5c1f 100644
--- a/frontend/src/metabase/collections/containers/FormCollectionPicker/FormCollectionPicker.tsx
+++ b/frontend/src/metabase/collections/containers/FormCollectionPicker/FormCollectionPicker.tsx
@@ -19,6 +19,7 @@ import {
type CollectionPickerOptions,
} from "metabase/common/components/Pickers/CollectionPicker";
import SnippetCollectionName from "metabase/common/components/SnippetCollectionName";
+import { TransformCollectionName } from "metabase/common/components/TransformCollectionName";
import { useUniqueId } from "metabase/common/hooks/use-unique-id";
import { Collections } from "metabase/entities/collections";
import { useSelector } from "metabase/lib/redux";
@@ -26,11 +27,16 @@ import { PLUGIN_TENANTS } from "metabase/plugins";
import { Button, Icon } from "metabase/ui";
import type { CollectionId, CollectionNamespace } from "metabase-types/api";
+const NAMESPACE_BY_TYPE: Record<string, "snippets" | "transforms"> = {
+ "snippet-collections": "snippets",
+ "transform-collections": "transforms",
+};
+
interface FormCollectionPickerProps extends HTMLAttributes<HTMLDivElement> {
name: string;
title?: string;
placeholder?: string;
- type?: "collections" | "snippet-collections";
+ type?: "collections" | "snippet-collections" | "transform-collections";
initialOpenCollectionId?: CollectionId;
onOpenCollectionChange?: (collectionId: CollectionId) => void;
filterPersonalCollections?: FilterItemsInPersonalCollection;
@@ -50,13 +56,17 @@ function ItemName({
namespace = null,
}: {
id: CollectionId;
- type?: "collections" | "snippet-collections";
+ type?: "collections" | "snippet-collections" | "transform-collections";
namespace?: string | null;
}) {
if (type === "snippet-collections") {
return <SnippetCollectionName id={id} />;
}
+ if (type === "transform-collections") {
+ return <TransformCollectionName id={id} />;
+ }
+
// Check for tenant namespace display name via plugin
if (id === null) {
const namespaceDisplayName = PLUGIN_TENANTS.getNamespaceDisplayName(
@@ -121,21 +131,24 @@ function FormCollectionPicker({
filterPersonalCollections !== "only" ||
isOpenCollectionInPersonalCollection;
+ const namespace = NAMESPACE_BY_TYPE[type];
+
const options = useMemo<CollectionPickerOptions>(
() => ({
- showPersonalCollections: filterPersonalCollections !== "exclude",
- showRootCollection: filterPersonalCollections !== "only",
- // Search API doesn't support collection namespaces yet
- showSearch: type === "collections",
+ showPersonalCollections:
+ !namespace && filterPersonalCollections !== "exclude",
+ showRootCollection: !!namespace || filterPersonalCollections !== "only",
+ showSearch: !namespace,
hasConfirmButtons: true,
- namespace: type === "snippet-collections" ? "snippets" : undefined,
+ namespace,
allowCreateNew: showCreateNewCollectionOption,
- hasRecents: type !== "snippet-collections",
+ hasRecents: !namespace,
+ showLibrary: !namespace,
savingModel,
}),
[
filterPersonalCollections,
- type,
+ namespace,
showCreateNewCollectionOption,
savingModel,
],
diff --git a/frontend/src/metabase/common/components/Breadcrumbs/Breadcrumbs.jsx b/frontend/src/metabase/common/components/Breadcrumbs/Breadcrumbs.jsx
index abb375b398e..949a5b03fdf 100644
--- a/frontend/src/metabase/common/components/Breadcrumbs/Breadcrumbs.jsx
+++ b/frontend/src/metabase/common/components/Breadcrumbs/Breadcrumbs.jsx
@@ -51,7 +51,7 @@ export default class Breadcrumbs extends Component {
<Ellipsified
key={index}
tooltip={breadcrumb[0]}
- tooltipMaxWidth="auto"
+ tooltipProps={{ w: "auto" }}
className={cx(
breadcrumbClass,
breadcrumb.length > 1 ? S.breadcrumbPath : S.breadcrumbPage,
diff --git a/frontend/src/metabase/common/components/Ellipsified/Ellipsified.tsx b/frontend/src/metabase/common/components/Ellipsified/Ellipsified.tsx
index bc4c6801763..0e2da77ab6b 100644
--- a/frontend/src/metabase/common/components/Ellipsified/Ellipsified.tsx
+++ b/frontend/src/metabase/common/components/Ellipsified/Ellipsified.tsx
@@ -1,19 +1,16 @@
-import type { FloatingPosition } from "@mantine/core/lib";
import type { ReactNode } from "react";
import { useIsTruncated } from "metabase/common/hooks/use-is-truncated";
-import { Text, type TextProps, Tooltip } from "metabase/ui";
+import { Text, type TextProps, Tooltip, type TooltipProps } from "metabase/ui";
interface EllipsifiedProps extends TextProps {
showTooltip?: boolean;
alwaysShowTooltip?: boolean;
tooltip?: ReactNode;
children?: ReactNode;
- tooltipMaxWidth?: number | "auto";
lines?: number;
- multiline?: boolean;
- placement?: FloatingPosition;
ignoreHeightTruncation?: boolean;
+ tooltipProps?: Partial<TooltipProps>;
}
export const Ellipsified = ({
@@ -21,11 +18,9 @@ export const Ellipsified = ({
alwaysShowTooltip,
tooltip,
children,
- tooltipMaxWidth,
lines = 1,
- multiline = false,
- placement = "top",
ignoreHeightTruncation = false,
+ tooltipProps,
...textProps
}: EllipsifiedProps) => {
const canSkipTooltipRendering = !showTooltip && !alwaysShowTooltip;
@@ -44,9 +39,8 @@ export const Ellipsified = ({
data-testid="ellipsified-tooltip"
disabled={!isEnabled}
label={canSkipTooltipRendering ? undefined : tooltip || children || " "}
- position={placement}
- w={tooltipMaxWidth}
- multiline={multiline}
+ position="top"
+ {...tooltipProps}
>
<Text
c="inherit"
diff --git a/frontend/src/metabase/common/components/Pickers/CollectionPicker/hooks.ts b/frontend/src/metabase/common/components/Pickers/CollectionPicker/hooks.ts
index d02c6dfd850..7c70209d5ed 100644
--- a/frontend/src/metabase/common/components/Pickers/CollectionPicker/hooks.ts
+++ b/frontend/src/metabase/common/components/Pickers/CollectionPicker/hooks.ts
@@ -116,7 +116,8 @@ export const useRootCollectionPickerItems = (
if (
options.showLibrary &&
libraryCollection &&
- options.namespace !== "snippets"
+ options.namespace !== "snippets" &&
+ options.namespace !== "transforms"
) {
collectionItems.push({
...libraryCollection,
@@ -137,7 +138,11 @@ export const useRootCollectionPickerItems = (
});
}
- if (options?.showRootCollection || options?.namespace === "snippets") {
+ if (
+ options?.showRootCollection ||
+ options?.namespace === "snippets" ||
+ options?.namespace === "transforms"
+ ) {
if (rootCollection && !rootCollectionError) {
collectionItems.push({
...rootCollection,
@@ -147,7 +152,9 @@ export const useRootCollectionPickerItems = (
name:
options.namespace === "snippets"
? t`SQL snippets`
- : rootCollection.name,
+ : options.namespace === "transforms"
+ ? t`Transforms`
+ : rootCollection.name,
});
} else if (rootCollectionError) {
collectionItems.push({
@@ -165,6 +172,7 @@ export const useRootCollectionPickerItems = (
if (
options?.showPersonalCollections &&
options?.namespace !== "snippets" &&
+ options?.namespace !== "transforms" &&
currentUser &&
!!personalCollection
) {
diff --git a/frontend/src/metabase/common/components/TransformCollectionName.tsx b/frontend/src/metabase/common/components/TransformCollectionName.tsx
new file mode 100644
index 00000000000..107be8a68aa
--- /dev/null
+++ b/frontend/src/metabase/common/components/TransformCollectionName.tsx
@@ -0,0 +1,23 @@
+import { t } from "ttag";
+
+import { skipToken, useGetCollectionQuery } from "metabase/api";
+import { isRootCollection } from "metabase/collections/utils";
+import type { CollectionId } from "metabase-types/api";
+
+export function TransformCollectionName({ id }: { id: CollectionId }) {
+ const { data: collection } = useGetCollectionQuery(
+ !isRootCollection({ id }) && Number.isSafeInteger(id)
+ ? { id: id as number, namespace: "transforms" }
+ : skipToken,
+ );
+
+ if (isRootCollection({ id })) {
+ return <span>{t`Transforms`}</span>;
+ }
+
+ if (!Number.isSafeInteger(id)) {
+ return null;
+ }
+
+ return <span>{collection?.name ?? ""}</span>;
+}
diff --git a/frontend/src/metabase/data-grid/components/HeaderCell/HeaderCell.module.css b/frontend/src/metabase/data-grid/components/HeaderCell/HeaderCell.module.css
index 8362bec13b7..3591ac1709d 100644
--- a/frontend/src/metabase/data-grid/components/HeaderCell/HeaderCell.module.css
+++ b/frontend/src/metabase/data-grid/components/HeaderCell/HeaderCell.module.css
@@ -11,36 +11,15 @@
}
.content {
- display: flex;
- align-items: center;
- padding: 0.25rem 0.625em;
- white-space: nowrap;
- text-overflow: ellipsis;
- color: var(--mb-color-brand);
- border-radius: 5px;
overflow: auto;
outline: none;
- gap: 0.25rem;
-}
-
-.alignRight {
- flex-direction: row-reverse;
-}
-
-.light .content {
- transition: background-color 200ms ease-in-out;
- background-color: color-mix(in srgb, var(--mb-color-brand), transparent 92%);
- cursor: pointer;
-}
-
-.light .content:hover {
- background-color: color-mix(in srgb, var(--mb-color-brand), transparent 82%);
}
.outline .content {
+ background-color: transparent;
border: 1px solid var(--mb-color-border);
}
-.sortIndicator {
- flex-shrink: 0;
+.outline .content:hover {
+ background-color: transparent;
}
diff --git a/frontend/src/metabase/data-grid/components/HeaderCell/HeaderCell.tsx b/frontend/src/metabase/data-grid/components/HeaderCell/HeaderCell.tsx
index 293de28f675..1e82bc9196b 100644
--- a/frontend/src/metabase/data-grid/components/HeaderCell/HeaderCell.tsx
+++ b/frontend/src/metabase/data-grid/components/HeaderCell/HeaderCell.tsx
@@ -1,13 +1,12 @@
import cx from "classnames";
import { type ReactNode, forwardRef, memo } from "react";
-import { Ellipsified } from "metabase/common/components/Ellipsified";
import { BaseCell } from "metabase/data-grid/components/BaseCell/BaseCell";
import type {
HeaderCellBaseProps,
HeaderCellVariant,
} from "metabase/data-grid/types";
-import { Icon } from "metabase/ui";
+import { SortableHeaderPill } from "metabase/ui";
import S from "./HeaderCell.module.css";
@@ -33,26 +32,19 @@ export const HeaderCellPill = forwardRef<HTMLDivElement, HeaderCellBaseProps>(
{ name, sort, align }: HeaderCellBaseProps,
ref,
) {
+ const pillAlign = align === "right" ? "right" : "left";
+
return (
- <div
+ <SortableHeaderPill
ref={ref}
+ name={typeof name === "string" ? name : ""}
+ sort={sort}
+ align={pillAlign}
+ className={S.content}
data-grid-header-cell-content
data-header-click-target
- className={cx(S.content, {
- [S.alignRight]: align === "right",
- })}
data-testid="cell-data"
- >
- <Ellipsified tooltip={name}>{name}</Ellipsified>
- {sort != null ? (
- <Icon
- className={S.sortIndicator}
- data-testid="header-sort-indicator"
- name={sort === "asc" ? "chevronup" : "chevrondown"}
- size={10}
- />
- ) : null}
- </div>
+ />
);
},
);
@@ -71,7 +63,6 @@ export const HeaderCellWrapper = ({
return (
<BaseCell
className={cx(S.root, className, {
- [S.light]: variant === "light",
[S.outline]: variant === "outline",
})}
hasHover={false}
diff --git a/frontend/src/metabase/data-grid/hooks/use-measure-column-widths.tsx b/frontend/src/metabase/data-grid/hooks/use-measure-column-widths.tsx
index ed944d6d026..0977a5c9ed1 100644
--- a/frontend/src/metabase/data-grid/hooks/use-measure-column-widths.tsx
+++ b/frontend/src/metabase/data-grid/hooks/use-measure-column-widths.tsx
@@ -8,12 +8,12 @@ import type { Root } from "react-dom/client";
import type { ColumnOptions, DataGridTheme } from "metabase/data-grid/types";
import { pickRowsToMeasure } from "metabase/data-grid/utils/column-sizing";
-import { renderRoot } from "metabase/lib/react-compat";
+import {
+ MeasurementProviders,
+ createMeasurementContainer,
+} from "metabase/data-grid/utils/measure-utils";
+import { renderRoot, unmountRoot } from "metabase/lib/react-compat";
import { isNotNull } from "metabase/lib/types";
-import { EmotionCacheProvider } from "metabase/styled-components/components/EmotionCacheProvider";
-import { ThemeProvider } from "metabase/ui";
-
-import { DEFAULT_FONT_SIZE } from "../constants";
import { DataGridThemeProvider } from "./use-table-theme";
@@ -45,17 +45,8 @@ export const useMeasureColumnWidths = <TData, TValue>(
onMeasured: (columnSizingState: ColumnSizingState) => void,
skipColumnIds: string[] = [],
) => {
- // Create hidden container for measurement rendering
- const measureRoot = document.createElement("div");
+ const measureRoot = createMeasurementContainer();
let measureRootTree: Root | undefined = undefined;
- measureRoot.style.position = "absolute";
- measureRoot.style.top = "-9999px";
- measureRoot.style.left = "-9999px";
- measureRoot.style.visibility = "hidden";
- measureRoot.style.pointerEvents = "none";
- measureRoot.style.zIndex = "-999";
- measureRoot.style.fontSize = DEFAULT_FONT_SIZE;
- document.body.appendChild(measureRoot);
const skipColumnIdsSet = new Set(skipColumnIds);
@@ -64,7 +55,6 @@ export const useMeasureColumnWidths = <TData, TValue>(
return;
}
- // Extract width measurements from rendered elements
const elementsMeasures = Array.from(
div.querySelectorAll("[data-measure-id]"),
)
@@ -81,7 +71,6 @@ export const useMeasureColumnWidths = <TData, TValue>(
})
.filter(isNotNull);
- // Calculate column widths based on measurements
const measuredColumnSizingMap =
elementsMeasures.reduce<ColumnSizingState>(
(acc, { columnId, width, type }) => {
@@ -89,7 +78,6 @@ export const useMeasureColumnWidths = <TData, TValue>(
acc[columnId] = 0;
}
- // Add appropriate spacing based on element type
if (type === "header") {
const headerWidth = width + CELL_BORDER_WIDTHS;
acc[columnId] = Math.max(acc[columnId], headerWidth);
@@ -105,9 +93,8 @@ export const useMeasureColumnWidths = <TData, TValue>(
onMeasured(measuredColumnSizingMap);
- // Asynchronously unmount the root after the current render has completed to avoid race conditions.
setTimeout(() => {
- measureRootTree?.unmount();
+ unmountRoot(measureRootTree, measureRoot);
document.body.removeChild(measureRoot);
}, 0);
};
@@ -115,7 +102,6 @@ export const useMeasureColumnWidths = <TData, TValue>(
const rows = table.getRowModel().rows;
const rowsData = rows.map((row) => row.original);
- // Render hidden elements for measurement
const measureContent = (
<div style={{ display: "flex" }} ref={onMeasureHeaderRender}>
{table
@@ -178,15 +164,12 @@ export const useMeasureColumnWidths = <TData, TValue>(
</div>
);
- // Wrap measurement content with necessary providers
const wrappedContent = (
- <EmotionCacheProvider>
- <ThemeProvider>
- <DataGridThemeProvider theme={theme}>
- {measureContent}
- </DataGridThemeProvider>
- </ThemeProvider>
- </EmotionCacheProvider>
+ <MeasurementProviders>
+ <DataGridThemeProvider theme={theme}>
+ {measureContent}
+ </DataGridThemeProvider>
+ </MeasurementProviders>
);
const content = measurementRenderWrapper
diff --git a/frontend/src/metabase/data-grid/utils/measure-utils.tsx b/frontend/src/metabase/data-grid/utils/measure-utils.tsx
new file mode 100644
index 00000000000..e00eeacb442
--- /dev/null
+++ b/frontend/src/metabase/data-grid/utils/measure-utils.tsx
@@ -0,0 +1,53 @@
+import type { ReactNode } from "react";
+import type { Root } from "react-dom/client";
+
+import { unmountRoot } from "metabase/lib/react-compat";
+import { EmotionCacheProvider } from "metabase/styled-components/components/EmotionCacheProvider";
+import { ThemeProvider } from "metabase/ui";
+
+import { DEFAULT_FONT_SIZE } from "../constants";
+
+interface MeasurementContainerOptions {
+ fontSize?: string;
+}
+
+export function createMeasurementContainer(
+ options: MeasurementContainerOptions = {},
+): HTMLDivElement {
+ const { fontSize = DEFAULT_FONT_SIZE } = options;
+
+ const container = document.createElement("div");
+ container.style.position = "absolute";
+ container.style.top = "-9999px";
+ container.style.left = "-9999px";
+ container.style.visibility = "hidden";
+ container.style.pointerEvents = "none";
+ container.style.zIndex = "-999";
+ container.style.fontSize = fontSize;
+ container.style.lineHeight = "1";
+ document.body.appendChild(container);
+
+ return container;
+}
+
+export function removeMeasurementContainer(
+ container: HTMLDivElement,
+ tree: Root | undefined,
+): void {
+ setTimeout(() => {
+ unmountRoot(tree, container);
+ document.body.removeChild(container);
+ }, 0);
+}
+
+interface MeasurementProvidersProps {
+ children: ReactNode;
+}
+
+export function MeasurementProviders({ children }: MeasurementProvidersProps) {
+ return (
+ <EmotionCacheProvider>
+ <ThemeProvider>{children}</ThemeProvider>
+ </EmotionCacheProvider>
+ );
+}
diff --git a/frontend/src/metabase/lib/resize-observer.ts b/frontend/src/metabase/lib/resize-observer.ts
index 725b7b1029d..432f1977fdb 100644
--- a/frontend/src/metabase/lib/resize-observer.ts
+++ b/frontend/src/metabase/lib/resize-observer.ts
@@ -14,7 +14,9 @@ type ResizeObserverCallback = (
// This comes with some tradeoffs. On the SDK, there will be issues with scalars
// not rendering properly on the first render, as we rely on rapid resize observer
// updates to resize the text.
-const ResizeObserverImpl = process.env.IS_EMBEDDING_SDK
+const isEmbeddingSdk =
+ typeof process !== "undefined" && process.env?.IS_EMBEDDING_SDK === "true";
+const ResizeObserverImpl = isEmbeddingSdk
? JuggleResizeObserver
: window.ResizeObserver;
diff --git a/frontend/src/metabase/parameters/components/FormattedParameterValue/FormattedParameterValue.tsx b/frontend/src/metabase/parameters/components/FormattedParameterValue/FormattedParameterValue.tsx
index fc01b4533bf..f0a66a04664 100644
--- a/frontend/src/metabase/parameters/components/FormattedParameterValue/FormattedParameterValue.tsx
+++ b/frontend/src/metabase/parameters/components/FormattedParameterValue/FormattedParameterValue.tsx
@@ -86,8 +86,10 @@ function FormattedParameterValue({
return (
<Ellipsified
showTooltip={!isPopoverOpen}
- multiline
- tooltipMaxWidth={hasLongValue ? 450 : undefined}
+ tooltipProps={{
+ multiline: true,
+ w: hasLongValue ? 450 : undefined,
+ }}
>
{renderContent()}
</Ellipsified>
diff --git a/frontend/src/metabase/reference/components/EditableReferenceHeader.jsx b/frontend/src/metabase/reference/components/EditableReferenceHeader.jsx
index b6c43303af5..f3c92ad394a 100644
--- a/frontend/src/metabase/reference/components/EditableReferenceHeader.jsx
+++ b/frontend/src/metabase/reference/components/EditableReferenceHeader.jsx
@@ -63,7 +63,7 @@ const EditableReferenceHeader = ({
<Ellipsified
key="1"
className={!headerLink && CS.flexFull}
- tooltipMaxWidth="auto"
+ tooltipProps={{ w: "auto" }}
>
{name === "Details"
? hasDisplayName
diff --git a/frontend/src/metabase/reference/components/ReferenceHeader.jsx b/frontend/src/metabase/reference/components/ReferenceHeader.jsx
index 16e9e4a19f0..ea81f16e9d2 100644
--- a/frontend/src/metabase/reference/components/ReferenceHeader.jsx
+++ b/frontend/src/metabase/reference/components/ReferenceHeader.jsx
@@ -30,7 +30,7 @@ const ReferenceHeader = ({
<Ellipsified
key="1"
className={!headerLink && CS.flexFull}
- tooltipMaxWidth="auto"
+ tooltipProps={{ w: "auto" }}
>
{name}
</Ellipsified>
diff --git a/frontend/src/metabase/timelines/common/components/ModalHeader/ModalHeader.styled.tsx b/frontend/src/metabase/timelines/common/components/ModalHeader/ModalHeader.styled.tsx
index e76ca772a00..6b760894723 100644
--- a/frontend/src/metabase/timelines/common/components/ModalHeader/ModalHeader.styled.tsx
+++ b/frontend/src/metabase/timelines/common/components/ModalHeader/ModalHeader.styled.tsx
@@ -19,11 +19,7 @@ export const HeaderLink = styled.div`
}
`;
-interface HeaderTitleProps {
- tooltipMaxWidth?: string;
-}
-
-export const HeaderTitle = styled(Ellipsified)<HeaderTitleProps>`
+export const HeaderTitle = styled(Ellipsified)`
font-size: 1.25rem;
line-height: 1.5rem;
font-weight: bold;
diff --git a/frontend/src/metabase/timelines/common/components/ModalHeader/ModalHeader.tsx b/frontend/src/metabase/timelines/common/components/ModalHeader/ModalHeader.tsx
index 7b35c7e9cb0..97c7e1a73e2 100644
--- a/frontend/src/metabase/timelines/common/components/ModalHeader/ModalHeader.tsx
+++ b/frontend/src/metabase/timelines/common/components/ModalHeader/ModalHeader.tsx
@@ -34,7 +34,7 @@ const ModalHeader = ({
<Flex align="center">
<HeaderLink onClick={onGoBack}>
{onGoBack && <HeaderBackIcon name="chevronleft" />}
- <HeaderTitle tooltipMaxWidth="auto">{title}</HeaderTitle>
+ <HeaderTitle tooltipProps={{ w: "auto" }}>{title}</HeaderTitle>
</HeaderLink>
{children && <HeaderMenu>{children}</HeaderMenu>}
{onClose && (
diff --git a/frontend/src/metabase/timelines/questions/components/TimelineCard/TimelineCard.tsx b/frontend/src/metabase/timelines/questions/components/TimelineCard/TimelineCard.tsx
index 7d0a619c846..63ea009c609 100644
--- a/frontend/src/metabase/timelines/questions/components/TimelineCard/TimelineCard.tsx
+++ b/frontend/src/metabase/timelines/questions/components/TimelineCard/TimelineCard.tsx
@@ -95,7 +95,7 @@ const TimelineCard = ({
onChange={handleChangeVisibility}
/>
<CardLabel>
- <Ellipsified tooltipMaxWidth="auto">
+ <Ellipsified tooltipProps={{ w: "auto" }}>
{getTimelineName(timeline)}
</Ellipsified>
</CardLabel>
diff --git a/frontend/src/metabase/ui/components/data-display/SortableHeaderPill/SortableHeaderPill.module.css b/frontend/src/metabase/ui/components/data-display/SortableHeaderPill/SortableHeaderPill.module.css
new file mode 100644
index 00000000000..f7514d61be7
--- /dev/null
+++ b/frontend/src/metabase/ui/components/data-display/SortableHeaderPill/SortableHeaderPill.module.css
@@ -0,0 +1,25 @@
+.pill {
+ display: flex;
+ align-items: center;
+ gap: 0.25rem;
+ padding: 0.25rem 0.625em;
+ font-weight: 700;
+ color: var(--mb-color-brand);
+ white-space: nowrap;
+ border-radius: 5px;
+ background-color: color-mix(in srgb, var(--mb-color-brand), transparent 92%);
+ cursor: pointer;
+ transition: background-color 200ms ease-in-out;
+}
+
+.pill:hover {
+ background-color: color-mix(in srgb, var(--mb-color-brand), transparent 82%);
+}
+
+.alignRight {
+ flex-direction: row-reverse;
+}
+
+.sortIcon {
+ flex-shrink: 0;
+}
diff --git a/frontend/src/metabase/ui/components/data-display/SortableHeaderPill/SortableHeaderPill.tsx b/frontend/src/metabase/ui/components/data-display/SortableHeaderPill/SortableHeaderPill.tsx
new file mode 100644
index 00000000000..d453410966c
--- /dev/null
+++ b/frontend/src/metabase/ui/components/data-display/SortableHeaderPill/SortableHeaderPill.tsx
@@ -0,0 +1,36 @@
+import cx from "classnames";
+import { type ComponentPropsWithoutRef, forwardRef } from "react";
+
+import { Ellipsified } from "metabase/common/components/Ellipsified";
+import { Icon } from "metabase/ui";
+
+import S from "./SortableHeaderPill.module.css";
+
+interface SortableHeaderPillProps extends ComponentPropsWithoutRef<"div"> {
+ name: string;
+ sort?: "asc" | "desc";
+ align?: "left" | "right";
+}
+
+export const SortableHeaderPill = forwardRef<
+ HTMLDivElement,
+ SortableHeaderPillProps
+>(function SortableHeaderPill({ name, sort, align, className, ...props }, ref) {
+ return (
+ <div
+ ref={ref}
+ className={cx(S.pill, className, { [S.alignRight]: align === "right" })}
+ {...props}
+ >
+ <Ellipsified tooltip={name}>{name}</Ellipsified>
+ {sort && (
+ <Icon
+ name={sort === "asc" ? "chevronup" : "chevrondown"}
+ size={10}
+ className={S.sortIcon}
+ data-testid="header-sort-indicator"
+ />
+ )}
+ </div>
+ );
+});
diff --git a/frontend/src/metabase/ui/components/data-display/SortableHeaderPill/index.ts b/frontend/src/metabase/ui/components/data-display/SortableHeaderPill/index.ts
new file mode 100644
index 00000000000..f243bfe4825
--- /dev/null
+++ b/frontend/src/metabase/ui/components/data-display/SortableHeaderPill/index.ts
@@ -0,0 +1 @@
+export { SortableHeaderPill } from "./SortableHeaderPill";
diff --git a/frontend/src/metabase/ui/components/data-display/TreeTable/EntityNameCell/EntityNameCell.tsx b/frontend/src/metabase/ui/components/data-display/TreeTable/EntityNameCell/EntityNameCell.tsx
new file mode 100644
index 00000000000..dfdd29d788b
--- /dev/null
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/EntityNameCell/EntityNameCell.tsx
@@ -0,0 +1,41 @@
+import { Ellipsified } from "metabase/common/components/Ellipsified";
+import CS from "metabase/css/core/index.css";
+import type { IconName } from "metabase/ui";
+import { Group, Icon, Text } from "metabase/ui";
+
+interface EntityNameCellProps {
+ icon?: IconName;
+ name: string;
+ iconColor?: string;
+ wrap?: boolean;
+ tooltipOpenDelay?: number;
+ "data-testid"?: string;
+}
+
+export function EntityNameCell({
+ icon,
+ name,
+ iconColor = "brand",
+ wrap = false,
+ tooltipOpenDelay = 600,
+ "data-testid": testId,
+}: EntityNameCellProps) {
+ return (
+ <Group data-testid={testId} gap="sm" wrap="nowrap" miw={0}>
+ {icon && <Icon name={icon} c={iconColor} className={CS.flexNoShrink} />}
+ {wrap ? (
+ <Text flex={1} miw={0}>
+ {name}
+ </Text>
+ ) : (
+ <Ellipsified
+ flex={1}
+ miw={0}
+ tooltipProps={{ openDelay: tooltipOpenDelay }}
+ >
+ {name}
+ </Ellipsified>
+ )}
+ </Group>
+ );
+}
diff --git a/frontend/src/metabase/ui/components/data-display/TreeTable/EntityNameCell/index.ts b/frontend/src/metabase/ui/components/data-display/TreeTable/EntityNameCell/index.ts
new file mode 100644
index 00000000000..bf3ce3c1531
--- /dev/null
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/EntityNameCell/index.ts
@@ -0,0 +1 @@
+export { EntityNameCell } from "./EntityNameCell";
diff --git a/frontend/src/metabase/ui/components/data-display/TreeTable/ExpandButton/ExpandButton.module.css b/frontend/src/metabase/ui/components/data-display/TreeTable/ExpandButton/ExpandButton.module.css
new file mode 100644
index 00000000000..8d5e24e26e9
--- /dev/null
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/ExpandButton/ExpandButton.module.css
@@ -0,0 +1,27 @@
+.wrapper {
+ flex-shrink: 0;
+}
+
+.hidden {
+ visibility: hidden;
+}
+
+.button {
+ border: none;
+ background: transparent;
+ cursor: pointer;
+
+ &:focus-visible {
+ outline: 2px solid var(--mb-color-focus);
+ outline-offset: 1px;
+ border-radius: 2px;
+ }
+}
+
+.icon {
+ transition: transform 0.15s ease;
+}
+
+.iconExpanded {
+ transform: rotate(90deg);
+}
diff --git a/frontend/src/metabase/ui/components/data-display/TreeTable/ExpandButton/ExpandButton.tsx b/frontend/src/metabase/ui/components/data-display/TreeTable/ExpandButton/ExpandButton.tsx
new file mode 100644
index 00000000000..9e867942d04
--- /dev/null
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/ExpandButton/ExpandButton.tsx
@@ -0,0 +1,55 @@
+import cx from "classnames";
+import { t } from "ttag";
+
+import { Center, Icon, Loader } from "metabase/ui";
+
+import type { ExpandButtonProps } from "../types";
+
+import S from "./ExpandButton.module.css";
+
+export function ExpandButton({
+ canExpand,
+ isExpanded,
+ isLoading,
+ onClick,
+ className,
+}: ExpandButtonProps) {
+ if (isLoading) {
+ return (
+ <Center w={16} h={16} className={S.wrapper} aria-hidden="true">
+ <Loader size="xs" color="brand" aria-label={t`Loading`} />
+ </Center>
+ );
+ }
+
+ if (!canExpand) {
+ return (
+ <Center
+ w={16}
+ h={16}
+ className={cx(S.wrapper, S.hidden, className)}
+ aria-hidden="true"
+ />
+ );
+ }
+
+ return (
+ <Center
+ component="button"
+ type="button"
+ w={16}
+ h={16}
+ p={0}
+ className={cx(S.wrapper, S.button, className)}
+ onClick={onClick}
+ aria-label={isExpanded ? t`Collapse` : t`Expand`}
+ tabIndex={-1}
+ >
+ <Icon
+ name="chevronright"
+ size={10}
+ className={cx(S.icon, { [S.iconExpanded]: isExpanded })}
+ />
+ </Center>
+ );
+}
diff --git a/frontend/src/metabase/ui/components/data-display/TreeTable/ExpandButton/index.ts b/frontend/src/metabase/ui/components/data-display/TreeTable/ExpandButton/index.ts
new file mode 100644
index 00000000000..77246c3840b
--- /dev/null
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/ExpandButton/index.ts
@@ -0,0 +1 @@
+export { ExpandButton } from "./ExpandButton";
diff --git a/frontend/src/metabase/ui/components/data-display/TreeTable/SelectionCheckbox/SelectionCheckbox.tsx b/frontend/src/metabase/ui/components/data-display/TreeTable/SelectionCheckbox/SelectionCheckbox.tsx
new file mode 100644
index 00000000000..09a2fe101c7
--- /dev/null
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/SelectionCheckbox/SelectionCheckbox.tsx
@@ -0,0 +1,36 @@
+import { t } from "ttag";
+
+import { Checkbox } from "metabase/ui";
+
+import type { SelectionCheckboxProps } from "../types";
+
+function getAriaLabel(isSelected: boolean, isSomeSelected: boolean): string {
+ if (isSelected) {
+ return t`Deselect row`;
+ }
+ if (isSomeSelected) {
+ return t`Select all in group`;
+ }
+ return t`Select row`;
+}
+
+export function SelectionCheckbox({
+ isSelected,
+ isSomeSelected,
+ disabled,
+ onClick,
+ className,
+}: SelectionCheckboxProps) {
+ return (
+ <Checkbox
+ size="sm"
+ checked={isSelected}
+ indeterminate={isSomeSelected && !isSelected}
+ disabled={disabled}
+ className={className}
+ readOnly
+ onClick={onClick}
+ aria-label={getAriaLabel(isSelected, isSomeSelected)}
+ />
+ );
+}
diff --git a/frontend/src/metabase/ui/components/data-display/TreeTable/SelectionCheckbox/index.ts b/frontend/src/metabase/ui/components/data-display/TreeTable/SelectionCheckbox/index.ts
new file mode 100644
index 00000000000..d67616b5219
--- /dev/null
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/SelectionCheckbox/index.ts
@@ -0,0 +1 @@
+export { SelectionCheckbox } from "./SelectionCheckbox";
diff --git a/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTable.module.css b/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTable.module.css
new file mode 100644
index 00000000000..dc6c5ed2891
--- /dev/null
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTable.module.css
@@ -0,0 +1,11 @@
+.root:focus {
+ outline: none;
+}
+
+.measuring {
+ visibility: hidden;
+}
+
+.body {
+ overflow: auto;
+}
diff --git a/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTable.stories.tsx b/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTable.stories.tsx
new file mode 100644
index 00000000000..80b4ca00e5c
--- /dev/null
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTable.stories.tsx
@@ -0,0 +1,271 @@
+import { useMemo } from "react";
+
+import { Box, Icon, type IconName, Text } from "metabase/ui";
+
+import { EntityNameCell } from "./EntityNameCell";
+import { TreeTable } from "./TreeTable";
+import { useTreeTableInstance } from "./hooks";
+import type { TreeNodeData, TreeTableColumnDef } from "./types";
+
+export default {
+ title: "Components/Data display/TreeTable",
+ component: TreeTable,
+};
+
+type ItemType =
+ | "collection"
+ | "question"
+ | "model"
+ | "dashboard"
+ | "metric"
+ | "database"
+ | "schema"
+ | "table";
+
+interface CollectionItem extends TreeNodeData {
+ id: string;
+ name: string;
+ type: ItemType;
+ owner?: string;
+ lastEdited?: string;
+ children?: CollectionItem[];
+}
+
+const ITEM_ICONS: Record<ItemType, IconName> = {
+ collection: "folder",
+ question: "table2",
+ model: "model",
+ dashboard: "dashboard",
+ metric: "metric",
+ database: "database",
+ schema: "folder",
+ table: "table2",
+};
+
+const mockData: CollectionItem[] = [
+ {
+ id: "1",
+ name: "Marketing",
+ type: "collection",
+ children: [
+ {
+ id: "1-1",
+ name: "Campaign Reports",
+ type: "collection",
+ children: [
+ {
+ id: "1-1-1",
+ name: "Q4 Campaign Performance",
+ type: "dashboard",
+ owner: "Alice Chen",
+ lastEdited: "2024-01-15",
+ },
+ {
+ id: "1-1-2",
+ name: "Email Open Rates",
+ type: "question",
+ owner: "Bob Smith",
+ lastEdited: "2024-01-10",
+ },
+ ],
+ },
+ {
+ id: "1-2",
+ name: "Website Traffic",
+ type: "question",
+ owner: "Carol Davis",
+ lastEdited: "2024-01-20",
+ },
+ ],
+ },
+ {
+ id: "2",
+ name: "Sales",
+ type: "collection",
+ children: [
+ {
+ id: "2-1",
+ name: "Revenue by Region",
+ type: "model",
+ owner: "Dan Wilson",
+ lastEdited: "2024-01-18",
+ },
+ {
+ id: "2-2",
+ name: "Monthly Targets",
+ type: "dashboard",
+ owner: "Eve Johnson",
+ lastEdited: "2024-01-19",
+ },
+ {
+ id: "2-3",
+ name: "Customer LTV",
+ type: "metric",
+ owner: "Frank Lee",
+ lastEdited: "2024-01-17",
+ },
+ ],
+ },
+ {
+ id: "3",
+ name: "Active Users Overview",
+ type: "dashboard",
+ owner: "Grace Kim",
+ lastEdited: "2024-01-01",
+ },
+];
+
+const detailedColumns: TreeTableColumnDef<CollectionItem>[] = [
+ {
+ id: "name",
+ header: "Name",
+ cell: ({ row }) => (
+ <EntityNameCell
+ icon={ITEM_ICONS[row.original.type]}
+ name={row.original.name}
+ />
+ ),
+ },
+ {
+ id: "type",
+ header: "Type",
+ width: 100,
+ cell: ({ row }) => (
+ <Text c="text-medium" size="sm" tt="capitalize">
+ {row.original.type}
+ </Text>
+ ),
+ },
+ {
+ id: "owner",
+ header: "Owner",
+ width: 140,
+ cell: ({ row }) =>
+ row.original.owner ? (
+ <Text c="text-medium" size="sm">
+ {row.original.owner}
+ </Text>
+ ) : null,
+ },
+ {
+ id: "lastEdited",
+ header: "Last edited",
+ width: 120,
+ cell: ({ row }) =>
+ row.original.lastEdited ? (
+ <Text c="text-medium" size="sm">
+ {row.original.lastEdited}
+ </Text>
+ ) : null,
+ },
+];
+
+export const WithColumnsAndSelection = {
+ render: function WithColumnsAndSelectionStory() {
+ const instance = useTreeTableInstance({
+ data: mockData,
+ columns: detailedColumns,
+ getSubRows: (node) => node.children,
+ getNodeId: (node) => node.id,
+ enableRowSelection: true,
+ enableMultiRowSelection: true,
+ });
+
+ return (
+ <Box h={400}>
+ <TreeTable
+ instance={instance}
+ showCheckboxes
+ onRowClick={(row) => {
+ if (row.getCanExpand()) {
+ row.toggleExpanded();
+ }
+ }}
+ />
+ </Box>
+ );
+ },
+};
+
+const itemTypes: ItemType[] = ["question", "dashboard", "model", "metric"];
+const owners = [
+ "Alice Chen",
+ "Bob Smith",
+ "Carol Davis",
+ "Dan Wilson",
+ "Eve Johnson",
+];
+
+function generateLargeDataset(count: number): CollectionItem[] {
+ const collections: CollectionItem[] = [];
+ for (let i = 0; i < count; i++) {
+ const collectionId = `collection-${i}`;
+ collections.push({
+ id: collectionId,
+ name: `Project ${i + 1}`,
+ type: "collection",
+ children: Array.from({ length: 5 }, (_, j) => ({
+ id: `${collectionId}-item-${j}`,
+ name: `${["Weekly Report", "User Analysis", "Revenue Model", "Growth Metrics", "Performance Dashboard"][j]} ${i + 1}`,
+ type: itemTypes[j % itemTypes.length],
+ owner: owners[j % owners.length],
+ lastEdited: `2024-01-${String((i % 28) + 1).padStart(2, "0")}`,
+ })),
+ });
+ }
+ return collections;
+}
+
+export const LargeDataset = {
+ render: function LargeDatasetStory() {
+ const largeData = useMemo(() => generateLargeDataset(200), []);
+
+ const instance = useTreeTableInstance({
+ data: largeData,
+ columns: detailedColumns,
+ getSubRows: (node) => node.children,
+ getNodeId: (node) => node.id,
+ defaultExpanded: true,
+ });
+
+ return (
+ <Box h={500}>
+ <TreeTable
+ instance={instance}
+ onRowClick={(row) => {
+ if (row.getCanExpand()) {
+ row.toggleExpanded();
+ }
+ }}
+ />
+ </Box>
+ );
+ },
+};
+
+export const EmptyState = {
+ render: function EmptyStateStory() {
+ const instance = useTreeTableInstance({
+ data: [] as CollectionItem[],
+ columns: detailedColumns,
+ getSubRows: (node) => node.children,
+ getNodeId: (node) => node.id,
+ });
+
+ return (
+ <Box h={400}>
+ <TreeTable
+ instance={instance}
+ emptyState={
+ <Box ta="center" py="xl">
+ <Icon name="folder" size={48} c="text-light" />
+ <Text c="text-medium" mt="md">
+ This collection is empty
+ </Text>
+ </Box>
+ }
+ />
+ </Box>
+ );
+ },
+};
diff --git a/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTable.tsx b/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTable.tsx
new file mode 100644
index 00000000000..00ee3c7ae18
--- /dev/null
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTable.tsx
@@ -0,0 +1,184 @@
+import cx from "classnames";
+import {
+ type KeyboardEvent,
+ useCallback,
+ useEffect,
+ useMemo,
+ useRef,
+} from "react";
+
+import { Box, Center, Flex } from "metabase/ui";
+
+import S from "./TreeTable.module.css";
+import { TreeTableHeader } from "./TreeTableHeader";
+import { TreeTableRow } from "./TreeTableRow";
+import { CHECKBOX_COLUMN_WIDTH, DEFAULT_INDENT_WIDTH } from "./constants";
+import type { TreeNodeData, TreeTableProps } from "./types";
+
+export function TreeTable<TData extends TreeNodeData>({
+ instance,
+ showCheckboxes = false,
+ indentWidth = DEFAULT_INDENT_WIDTH,
+ headerVariant = "pill",
+ emptyState,
+ onRowClick,
+ onRowDoubleClick,
+ getSelectionState,
+ onCheckboxClick,
+ isChildrenLoading,
+ classNames,
+ styles,
+ ariaLabel,
+ ariaLabelledBy,
+}: TreeTableProps<TData>) {
+ const {
+ table,
+ rows,
+ virtualRows,
+ totalSize,
+ virtualizer,
+ containerRef,
+ columnWidths,
+ isMeasured,
+ setContainerWidth,
+ handleKeyDown,
+ activeRowId,
+ } = instance;
+
+ const rootRef = useRef<HTMLDivElement>(null);
+
+ const handleKeyDownWithFocus = useCallback(
+ (event: KeyboardEvent<HTMLElement>) => {
+ handleKeyDown(event);
+ // Ensure focus stays on root after keyboard navigation
+ if (
+ event.key === "ArrowDown" ||
+ event.key === "ArrowUp" ||
+ event.key === "Home" ||
+ event.key === "End"
+ ) {
+ rootRef.current?.focus();
+ }
+ },
+ [handleKeyDown],
+ );
+
+ useEffect(() => {
+ const container = containerRef.current;
+ if (!container) {
+ return;
+ }
+
+ const observer = new ResizeObserver((entries) => {
+ const entry = entries[0];
+ if (entry) {
+ const width = entry.contentRect.width;
+ const adjustedWidth = showCheckboxes
+ ? width - CHECKBOX_COLUMN_WIDTH
+ : width;
+ setContainerWidth(adjustedWidth);
+ }
+ });
+
+ observer.observe(container);
+ return () => observer.disconnect();
+ }, [containerRef, setContainerWidth, showCheckboxes]);
+
+ const hasExpandableNodes = useMemo(
+ () => rows.some((row) => row.getCanExpand()),
+ [rows],
+ );
+
+ const totalContentWidth = useMemo(() => {
+ const columnsWidth = Object.values(columnWidths).reduce(
+ (sum, w) => sum + w,
+ 0,
+ );
+ return showCheckboxes ? columnsWidth + CHECKBOX_COLUMN_WIDTH : columnsWidth;
+ }, [columnWidths, showCheckboxes]);
+
+ const measureElement = useCallback(
+ (element: HTMLElement | null) => {
+ virtualizer.measureElement(element);
+ },
+ [virtualizer],
+ );
+
+ const showEmptyState = rows.length === 0 && emptyState;
+
+ return (
+ <Flex
+ ref={rootRef}
+ className={cx(S.root, classNames?.root)}
+ style={styles?.root}
+ direction="column"
+ h="100%"
+ w="100%"
+ role="treegrid"
+ tabIndex={0}
+ aria-label={ariaLabel}
+ aria-labelledby={ariaLabelledBy}
+ onKeyDown={handleKeyDownWithFocus}
+ >
+ <Box
+ ref={containerRef}
+ className={cx(S.body, classNames?.body, { [S.measuring]: !isMeasured })}
+ flex={1}
+ style={styles?.body}
+ >
+ {showEmptyState ? (
+ <Center h="100%" p="xl" c="text-light">
+ {emptyState}
+ </Center>
+ ) : (
+ <>
+ <TreeTableHeader
+ table={table}
+ columnWidths={columnWidths}
+ showCheckboxes={showCheckboxes}
+ headerVariant={headerVariant}
+ classNames={classNames}
+ styles={styles}
+ isMeasured={isMeasured}
+ totalContentWidth={totalContentWidth}
+ />
+ <Box
+ pos="relative"
+ style={{ height: totalSize, minWidth: totalContentWidth }}
+ >
+ {virtualRows.map((virtualItem) => {
+ const row = rows[virtualItem.index];
+ if (!row) {
+ return null;
+ }
+
+ return (
+ <TreeTableRow
+ key={row.id}
+ row={row}
+ rowIndex={virtualItem.index}
+ virtualItem={virtualItem}
+ table={table}
+ columnWidths={columnWidths}
+ showCheckboxes={showCheckboxes}
+ showExpandButtons={hasExpandableNodes}
+ indentWidth={indentWidth}
+ activeRowId={activeRowId}
+ measureElement={measureElement}
+ onRowClick={onRowClick}
+ onRowDoubleClick={onRowDoubleClick}
+ isChildrenLoading={isChildrenLoading?.(row)}
+ getSelectionState={getSelectionState}
+ onCheckboxClick={onCheckboxClick}
+ classNames={classNames}
+ styles={styles}
+ />
+ );
+ })}
+ </Box>
+ </>
+ )}
+ </Box>
+ </Flex>
+ );
+}
diff --git a/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableHeader/HeaderCell/HeaderCell.tsx b/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableHeader/HeaderCell/HeaderCell.tsx
new file mode 100644
index 00000000000..d4e58988e8b
--- /dev/null
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableHeader/HeaderCell/HeaderCell.tsx
@@ -0,0 +1,31 @@
+import { Flex, Icon, SortableHeaderPill } from "metabase/ui";
+
+import type { TreeTableHeaderVariant } from "../../types";
+
+interface HeaderCellProps {
+ name: string;
+ sort?: "asc" | "desc";
+ variant: TreeTableHeaderVariant;
+}
+
+export function HeaderCell({ name, sort, variant }: HeaderCellProps) {
+ if (variant === "pill") {
+ return <SortableHeaderPill name={name} sort={sort} />;
+ }
+
+ return (
+ <Flex
+ component="span"
+ align="center"
+ gap="0.25rem"
+ fz="0.75rem"
+ fw={700}
+ c="text-medium"
+ >
+ {name}
+ {sort && (
+ <Icon name={sort === "asc" ? "chevronup" : "chevrondown"} size={10} />
+ )}
+ </Flex>
+ );
+}
diff --git a/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableHeader/HeaderCell/index.ts b/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableHeader/HeaderCell/index.ts
new file mode 100644
index 00000000000..c928eac132e
--- /dev/null
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableHeader/HeaderCell/index.ts
@@ -0,0 +1 @@
+export { HeaderCell } from "./HeaderCell";
diff --git a/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableHeader/TreeTableHeader.module.css b/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableHeader/TreeTableHeader.module.css
new file mode 100644
index 00000000000..66468a2bfda
--- /dev/null
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableHeader/TreeTableHeader.module.css
@@ -0,0 +1,18 @@
+.measuring {
+ visibility: hidden;
+}
+
+.header {
+ z-index: 1;
+ flex-shrink: 0;
+ font-size: 12.5px;
+ background-color: var(--mb-color-background);
+}
+
+.row {
+ border-bottom: 1px solid var(--mb-color-border);
+}
+
+.cell:first-child {
+ padding-left: 1rem;
+}
diff --git a/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableHeader/TreeTableHeader.tsx b/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableHeader/TreeTableHeader.tsx
new file mode 100644
index 00000000000..6a50a0a2b79
--- /dev/null
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableHeader/TreeTableHeader.tsx
@@ -0,0 +1,113 @@
+import { flexRender } from "@tanstack/react-table";
+import cx from "classnames";
+
+import { Flex } from "metabase/ui";
+
+import { CHECKBOX_COLUMN_WIDTH } from "../constants";
+import type { TreeNodeData, TreeTableHeaderProps } from "../types";
+import { getColumnStyle } from "../utils";
+
+import { HeaderCell } from "./HeaderCell";
+import S from "./TreeTableHeader.module.css";
+
+export function TreeTableHeader<TData extends TreeNodeData>({
+ table,
+ columnWidths,
+ showCheckboxes,
+ classNames,
+ styles,
+ isMeasured = true,
+ totalContentWidth,
+ headerVariant = "pill",
+}: TreeTableHeaderProps<TData>) {
+ const headerGroups = table.getHeaderGroups();
+
+ return (
+ <Flex
+ className={cx(S.header, classNames?.header, {
+ [S.measuring]: !isMeasured,
+ })}
+ pos="sticky"
+ top={0}
+ style={styles?.header}
+ >
+ {headerGroups.map((headerGroup) => (
+ <Flex
+ key={headerGroup.id}
+ className={cx(S.row, classNames?.headerRow)}
+ w="100%"
+ style={{ minWidth: totalContentWidth, ...styles?.headerRow }}
+ >
+ {showCheckboxes && (
+ <Flex
+ className={cx(S.cell, classNames?.headerCell)}
+ align="center"
+ p="0.75rem"
+ style={{ width: CHECKBOX_COLUMN_WIDTH, ...styles?.headerCell }}
+ />
+ )}
+ {headerGroup.headers.map((header, index) => {
+ const column = header.column;
+ const isSortable = column.getCanSort();
+ const sortDirection = column.getIsSorted();
+ const isFirstColumn = index === 0;
+
+ const columnStyle = {
+ ...getColumnStyle(columnWidths, column.id, isFirstColumn),
+ ...styles?.headerCell,
+ };
+
+ const headerContent = header.isPlaceholder
+ ? null
+ : flexRender(column.columnDef.header, header.getContext());
+
+ if (!headerContent) {
+ return (
+ <Flex
+ key={header.id}
+ className={cx(S.cell, classNames?.headerCell)}
+ align="center"
+ p="0.75rem"
+ style={columnStyle}
+ />
+ );
+ }
+
+ const sortValue = sortDirection || undefined;
+
+ return (
+ <Flex
+ key={header.id}
+ className={cx(S.cell, classNames?.headerCell)}
+ align="center"
+ p="0.75rem"
+ style={columnStyle}
+ role={isSortable ? "columnheader" : undefined}
+ aria-sort={
+ sortDirection
+ ? sortDirection === "asc"
+ ? "ascending"
+ : "descending"
+ : undefined
+ }
+ onClick={
+ isSortable ? column.getToggleSortingHandler() : undefined
+ }
+ >
+ {typeof headerContent === "string" ? (
+ <HeaderCell
+ name={headerContent}
+ sort={sortValue}
+ variant={headerVariant}
+ />
+ ) : (
+ headerContent
+ )}
+ </Flex>
+ );
+ })}
+ </Flex>
+ ))}
+ </Flex>
+ );
+}
diff --git a/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableHeader/index.ts b/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableHeader/index.ts
new file mode 100644
index 00000000000..5f59a355c66
--- /dev/null
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableHeader/index.ts
@@ -0,0 +1 @@
+export { TreeTableHeader } from "./TreeTableHeader";
diff --git a/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableRow/TreeTableRow.module.css b/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableRow/TreeTableRow.module.css
new file mode 100644
index 00000000000..5ce09c02bea
--- /dev/null
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableRow/TreeTableRow.module.css
@@ -0,0 +1,49 @@
+.root {
+ border-bottom: 1px solid var(--mb-color-border);
+ cursor: pointer;
+
+ &:hover {
+ background-color: var(--mb-color-brand-light);
+ }
+
+ &:focus {
+ outline: none;
+ background-color: var(--mb-color-brand-light);
+ }
+
+ &:focus-visible {
+ box-shadow: inset 0 0 0 2px var(--mb-color-focus);
+ }
+
+ &:last-child {
+ border-bottom: none;
+ }
+}
+
+.active {
+ background-color: var(--mb-color-brand-light);
+
+ &:hover {
+ background-color: var(--mb-color-brand-light);
+ }
+}
+
+.disabled {
+ opacity: 0.5;
+ cursor: not-allowed;
+ pointer-events: none;
+}
+
+.checkboxWrapper {
+ flex-shrink: 0;
+}
+
+.treeCell {
+ overflow: hidden;
+}
+
+.cell {
+ overflow: hidden;
+ text-overflow: ellipsis;
+ white-space: nowrap;
+}
diff --git a/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableRow/TreeTableRow.tsx b/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableRow/TreeTableRow.tsx
new file mode 100644
index 00000000000..6ddb600b476
--- /dev/null
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableRow/TreeTableRow.tsx
@@ -0,0 +1,161 @@
+import { flexRender } from "@tanstack/react-table";
+import cx from "classnames";
+
+import { Flex } from "metabase/ui";
+
+import { ExpandButton } from "../ExpandButton";
+import { SelectionCheckbox } from "../SelectionCheckbox";
+import { TREE_CELL_BASE_PADDING } from "../constants";
+import type { TreeNodeData, TreeTableRowProps } from "../types";
+import { getColumnStyle } from "../utils";
+
+import S from "./TreeTableRow.module.css";
+
+export function TreeTableRow<TData extends TreeNodeData>({
+ row,
+ rowIndex,
+ virtualItem,
+ table,
+ columnWidths,
+ showCheckboxes,
+ showExpandButtons,
+ indentWidth,
+ activeRowId,
+ measureElement,
+ onRowClick,
+ onRowDoubleClick,
+ isDisabled,
+ isChildrenLoading,
+ getSelectionState,
+ onCheckboxClick,
+ classNames,
+ styles,
+}: TreeTableRowProps<TData>) {
+ const isActive = activeRowId === row.id;
+ const indent = row.depth * indentWidth;
+ const visibleCells = row.getVisibleCells();
+
+ const selectionState = getSelectionState
+ ? getSelectionState(row)
+ : row.getIsSelected()
+ ? "all"
+ : row.getIsSomeSelected()
+ ? "some"
+ : "none";
+
+ return (
+ <Flex
+ role="row"
+ tabIndex={isDisabled ? -1 : isActive ? 0 : -1}
+ data-index={virtualItem.index}
+ ref={measureElement}
+ className={cx(S.root, classNames?.row, {
+ [S.active]: isActive,
+ [classNames?.rowActive ?? ""]: isActive && classNames?.rowActive,
+ [S.disabled]: isDisabled,
+ [classNames?.rowDisabled ?? ""]: isDisabled && classNames?.rowDisabled,
+ })}
+ pos="absolute"
+ top={0}
+ left={0}
+ w="100%"
+ align="stretch"
+ fz="0.875rem"
+ lh="1.25rem"
+ c="text-dark"
+ style={{
+ transform: `translateY(${virtualItem.start}px)`,
+ ...styles?.row,
+ }}
+ aria-expanded={row.getCanExpand() ? row.getIsExpanded() : undefined}
+ aria-selected={selectionState !== "none"}
+ aria-level={row.depth + 1}
+ onClick={(e) => onRowClick?.(row, e)}
+ onDoubleClick={(e) => onRowDoubleClick?.(row, e)}
+ >
+ {showCheckboxes && (
+ <Flex align="center" pl="0.75rem" className={S.checkboxWrapper}>
+ <SelectionCheckbox
+ isSelected={selectionState === "all"}
+ isSomeSelected={selectionState === "some"}
+ disabled={isDisabled || (!getSelectionState && !row.getCanSelect())}
+ onClick={(e) => {
+ e.stopPropagation();
+ if (onCheckboxClick) {
+ onCheckboxClick(row, rowIndex, e);
+ } else {
+ row.toggleSelected();
+ }
+ }}
+ className={classNames?.checkbox}
+ />
+ </Flex>
+ )}
+ {visibleCells.map((cell, colIndex) => {
+ const column = table.getColumn(cell.column.id);
+ const columnDef = column?.columnDef;
+
+ const cellContent = flexRender(columnDef?.cell, cell.getContext());
+
+ if (colIndex === 0) {
+ return (
+ <Flex
+ key={cell.id}
+ role="gridcell"
+ className={cx(S.treeCell, classNames?.treeCell)}
+ align="center"
+ gap="0.25rem"
+ miw={0}
+ py="0.75rem"
+ pr="0.5rem"
+ style={{
+ paddingLeft: TREE_CELL_BASE_PADDING + indent,
+ ...getColumnStyle(columnWidths, cell.column.id, true),
+ ...styles?.treeCell,
+ }}
+ >
+ {showExpandButtons && (
+ <ExpandButton
+ canExpand={row.getCanExpand()}
+ isExpanded={row.getIsExpanded()}
+ isLoading={isChildrenLoading}
+ onClick={(e) => {
+ e.stopPropagation();
+ row.toggleExpanded();
+ }}
+ className={classNames?.expandButton}
+ />
+ )}
+ <Flex
+ className={classNames?.treeCellContent}
+ align="center"
+ gap="0.5rem"
+ miw={0}
+ flex={1}
+ >
+ {cellContent}
+ </Flex>
+ </Flex>
+ );
+ }
+
+ return (
+ <Flex
+ key={cell.id}
+ role="gridcell"
+ className={cx(S.cell, classNames?.cell)}
+ align="center"
+ gap="0.5rem"
+ p="0.75rem"
+ style={{
+ ...getColumnStyle(columnWidths, cell.column.id, false),
+ ...styles?.cell,
+ }}
+ >
+ {cellContent}
+ </Flex>
+ );
+ })}
+ </Flex>
+ );
+}
diff --git a/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableRow/index.ts b/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableRow/index.ts
new file mode 100644
index 00000000000..fb6c22f4d58
--- /dev/null
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableRow/index.ts
@@ -0,0 +1 @@
+export { TreeTableRow } from "./TreeTableRow";
diff --git a/frontend/src/metabase/ui/components/data-display/TreeTable/constants.ts b/frontend/src/metabase/ui/components/data-display/TreeTable/constants.ts
new file mode 100644
index 00000000000..d3d4196c643
--- /dev/null
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/constants.ts
@@ -0,0 +1,9 @@
+export const DEFAULT_ROW_HEIGHT = 40;
+export const DEFAULT_INDENT_WIDTH = 20;
+export const DEFAULT_OVERSCAN = 5;
+export const CHECKBOX_COLUMN_WIDTH = 32;
+export const EXPAND_BUTTON_WIDTH = 24;
+export const MIN_COLUMN_WIDTH = 50;
+export const MEASUREMENT_ROW_COUNT = 10;
+export const CELL_HORIZONTAL_PADDING = 24;
+export const TREE_CELL_BASE_PADDING = 16;
diff --git a/frontend/src/metabase/ui/components/data-display/TreeTable/hooks/index.ts b/frontend/src/metabase/ui/components/data-display/TreeTable/hooks/index.ts
new file mode 100644
index 00000000000..de6e8188c50
--- /dev/null
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/hooks/index.ts
@@ -0,0 +1,3 @@
+export { useTreeTableInstance } from "./useTreeTableInstance";
+export { useColumnSizing } from "./useColumnSizing";
+export { useTreeTableKeyboard } from "./useTreeTableKeyboard";
diff --git a/frontend/src/metabase/ui/components/data-display/TreeTable/hooks/useColumnSizing.tsx b/frontend/src/metabase/ui/components/data-display/TreeTable/hooks/useColumnSizing.tsx
new file mode 100644
index 00000000000..79fe327840e
--- /dev/null
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/hooks/useColumnSizing.tsx
@@ -0,0 +1,405 @@
+import { type Row, type Table, flexRender } from "@tanstack/react-table";
+import { useCallback, useLayoutEffect, useMemo, useRef, useState } from "react";
+import type { Root } from "react-dom/client";
+
+import {
+ MeasurementProviders,
+ createMeasurementContainer,
+ removeMeasurementContainer,
+} from "metabase/data-grid/utils/measure-utils";
+import { renderRoot } from "metabase/lib/react-compat";
+
+import {
+ CELL_HORIZONTAL_PADDING,
+ DEFAULT_INDENT_WIDTH,
+ EXPAND_BUTTON_WIDTH,
+ MEASUREMENT_ROW_COUNT,
+ MIN_COLUMN_WIDTH,
+ TREE_CELL_BASE_PADDING,
+} from "../constants";
+import type {
+ TreeNodeData,
+ TreeTableColumnDef,
+ TreeTableColumnSizing,
+} from "../types";
+
+interface UseColumnSizingOptions<TData extends TreeNodeData> {
+ columns: TreeTableColumnDef<TData>[];
+ table: Table<TData>;
+ indentWidth?: number;
+}
+
+export function needsMeasurement<TData extends TreeNodeData>(
+ column: TreeTableColumnDef<TData>,
+): boolean {
+ return column.minWidth === "auto";
+}
+
+function pickTreeRowsToMeasure<TData>(
+ rows: Row<TData>[],
+ columnId: string,
+ count: number = MEASUREMENT_ROW_COUNT,
+): Row<TData>[] {
+ const result: Row<TData>[] = [];
+ for (const row of rows) {
+ if (row.getValue(columnId) != null) {
+ result.push(row);
+ if (result.length >= count) {
+ break;
+ }
+ }
+ }
+ return result;
+}
+
+export function getMinConstraint<TData extends TreeNodeData>(
+ column: TreeTableColumnDef<TData>,
+ colIndex: number,
+ contentWidths: Record<string, number>,
+ maxDepth: number,
+ indentWidth: number,
+): number {
+ let minConstraint: number;
+ if (column.minWidth === "auto") {
+ minConstraint = contentWidths[column.id] ?? MIN_COLUMN_WIDTH;
+ } else if (typeof column.minWidth === "number") {
+ minConstraint = column.minWidth;
+ } else {
+ minConstraint = MIN_COLUMN_WIDTH;
+ }
+
+ if (colIndex === 0) {
+ const maxIndentPadding = maxDepth * indentWidth;
+ minConstraint = Math.max(
+ minConstraint,
+ MIN_COLUMN_WIDTH + maxIndentPadding,
+ );
+ }
+
+ return minConstraint;
+}
+
+export function calculateColumnWidths<TData extends TreeNodeData>(
+ columns: TreeTableColumnDef<TData>[],
+ containerWidth: number,
+ contentWidths: Record<string, number>,
+ maxDepth: number,
+ indentWidth: number,
+): Record<string, number> {
+ if (containerWidth <= 0) {
+ return {};
+ }
+
+ const widths: Record<string, number> = {};
+
+ const fixedWidth = columns
+ .filter((col) => col.width != null)
+ .reduce((sum, col) => sum + col.width!, 0);
+
+ let remainingSpace = containerWidth - fixedWidth;
+
+ const stretchingColumnIds = new Set(
+ columns.filter((col) => col.width == null).map((col) => col.id),
+ );
+
+ columns.forEach((column) => {
+ if (column.width != null) {
+ widths[column.id] = column.width;
+ }
+ });
+
+ while (stretchingColumnIds.size > 0) {
+ const baseWidth = Math.floor(remainingSpace / stretchingColumnIds.size);
+ let anyConstrained = false;
+
+ for (const colId of stretchingColumnIds) {
+ const colIndex = columns.findIndex((c) => c.id === colId);
+ const column = columns[colIndex];
+ const minConstraint = getMinConstraint(
+ column,
+ colIndex,
+ contentWidths,
+ maxDepth,
+ indentWidth,
+ );
+
+ if (baseWidth < minConstraint) {
+ widths[colId] = minConstraint;
+ remainingSpace -= minConstraint;
+ stretchingColumnIds.delete(colId);
+ anyConstrained = true;
+ break;
+ }
+
+ if (column.maxWidth != null && baseWidth > column.maxWidth) {
+ widths[colId] = column.maxWidth;
+ remainingSpace -= column.maxWidth;
+ stretchingColumnIds.delete(colId);
+ anyConstrained = true;
+ break;
+ }
+ }
+
+ if (!anyConstrained) {
+ for (const colId of stretchingColumnIds) {
+ widths[colId] = baseWidth;
+ }
+ break;
+ }
+ }
+
+ return widths;
+}
+
+interface MeasureContentProps<TData extends TreeNodeData> {
+ columns: TreeTableColumnDef<TData>[];
+ rows: Row<TData>[];
+ table: Table<TData>;
+ hasExpandableNodes: boolean;
+ indentWidth: number;
+ onMeasured: (widths: Record<string, number>, maxDepth: number) => void;
+}
+
+function MeasureContent<TData extends TreeNodeData>({
+ columns,
+ rows,
+ table,
+ hasExpandableNodes,
+ indentWidth,
+ onMeasured,
+}: MeasureContentProps<TData>) {
+ const handleRef = useCallback(
+ (div: HTMLDivElement | null) => {
+ if (!div) {
+ return;
+ }
+
+ const widths: Record<string, number> = {};
+ let maxDepth = 0;
+
+ for (const row of rows) {
+ maxDepth = Math.max(maxDepth, row.depth);
+ }
+
+ columns.forEach((column, colIndex) => {
+ const columnEl = div.querySelector(
+ `[data-measure-column="${column.id}"]`,
+ );
+ if (!columnEl) {
+ return;
+ }
+
+ const cellEls = columnEl.querySelectorAll("[data-measure-cell]");
+ let maxWidth = 0;
+
+ cellEls.forEach((cellEl) => {
+ const depth = parseInt(cellEl.getAttribute("data-depth") ?? "0", 10);
+ let cellWidth = (cellEl as HTMLElement).offsetWidth;
+
+ cellWidth += CELL_HORIZONTAL_PADDING;
+
+ if (colIndex === 0) {
+ cellWidth += TREE_CELL_BASE_PADDING;
+ if (hasExpandableNodes) {
+ cellWidth += EXPAND_BUTTON_WIDTH;
+ }
+ cellWidth += depth * indentWidth;
+ }
+
+ maxWidth = Math.max(maxWidth, cellWidth);
+ });
+
+ const headerEl = columnEl.querySelector("[data-measure-header]");
+ if (headerEl) {
+ const headerWidth =
+ (headerEl as HTMLElement).offsetWidth + CELL_HORIZONTAL_PADDING;
+ maxWidth = Math.max(maxWidth, headerWidth);
+ }
+
+ widths[column.id] = maxWidth;
+ });
+
+ onMeasured(widths, maxDepth);
+ },
+ [columns, rows, hasExpandableNodes, indentWidth, onMeasured],
+ );
+
+ const columnsToMeasure = columns.filter(needsMeasurement);
+
+ return (
+ <div ref={handleRef} style={{ display: "flex" }}>
+ {columnsToMeasure.map((column) => {
+ const colIndex = columns.findIndex((c) => c.id === column.id);
+ const rowsToMeasure = pickTreeRowsToMeasure(rows, column.id);
+
+ return (
+ <div
+ key={column.id}
+ data-measure-column={column.id}
+ style={{ display: "flex", flexDirection: "column" }}
+ >
+ {typeof column.header === "string" && (
+ <div data-measure-header style={{ whiteSpace: "nowrap" }}>
+ {column.header}
+ </div>
+ )}
+ {rowsToMeasure.map((row) => {
+ const cell = row
+ .getVisibleCells()
+ .find((c) => c.column.id === column.id);
+ if (!cell) {
+ return null;
+ }
+
+ const tanstackColumn = table.getColumn(column.id);
+ const columnDef = tanstackColumn?.columnDef;
+
+ const cellContent = columnDef?.cell
+ ? flexRender(columnDef.cell, cell.getContext())
+ : String(cell.getValue() ?? "");
+
+ return (
+ <div
+ key={row.id}
+ data-measure-cell
+ data-depth={colIndex === 0 ? row.depth : 0}
+ style={{ whiteSpace: "nowrap", width: "fit-content" }}
+ >
+ {cellContent}
+ </div>
+ );
+ })}
+ </div>
+ );
+ })}
+ </div>
+ );
+}
+
+export function useColumnSizing<TData extends TreeNodeData>({
+ columns,
+ table,
+ indentWidth = DEFAULT_INDENT_WIDTH,
+}: UseColumnSizingOptions<TData>): TreeTableColumnSizing {
+ const [containerWidth, setContainerWidth] = useState(0);
+ const [contentWidths, setContentWidths] = useState<Record<string, number>>(
+ {},
+ );
+ const [maxDepth, setMaxDepth] = useState(0);
+ const [isMeasured, setIsMeasured] = useState(false);
+ const measureRootRef = useRef<{
+ element: HTMLDivElement;
+ tree: Root | undefined;
+ } | null>(null);
+
+ const allRows = table.getRowModel().flatRows;
+
+ const hasExpandableNodes = useMemo(() => {
+ return allRows.some((row) => row.getCanExpand());
+ }, [allRows]);
+
+ const columnsRef = useRef(columns);
+ const allRowsRef = useRef(allRows);
+ const tableRef = useRef(table);
+ columnsRef.current = columns;
+ allRowsRef.current = allRows;
+ tableRef.current = table;
+
+ const columnsNeedingMeasurement = useMemo(
+ () => columns.filter(needsMeasurement),
+ [columns],
+ );
+
+ const measurementColumnsKey = columnsNeedingMeasurement
+ .map((c) => c.id)
+ .join(",");
+ const rowsLength = allRows.length;
+
+ const handleMeasured = useCallback(
+ (widths: Record<string, number>, depth: number) => {
+ setContentWidths(widths);
+ setMaxDepth(depth);
+ setIsMeasured(true);
+
+ if (measureRootRef.current) {
+ const { element, tree } = measureRootRef.current;
+ removeMeasurementContainer(element, tree);
+ measureRootRef.current = null;
+ }
+ },
+ [],
+ );
+
+ useLayoutEffect(() => {
+ const currentRows = allRowsRef.current;
+ const currentColumns = columnsRef.current;
+ const currentTable = tableRef.current;
+ const columnsToMeasure = currentColumns.filter(needsMeasurement);
+
+ if (columnsToMeasure.length === 0) {
+ let depth = 0;
+ for (const row of currentRows) {
+ depth = Math.max(depth, row.depth);
+ }
+ setMaxDepth(depth);
+ setIsMeasured(true);
+ return;
+ }
+
+ if (currentRows.length === 0) {
+ setIsMeasured(true);
+ return;
+ }
+
+ const measureElement = createMeasurementContainer({ fontSize: "14px" });
+
+ const content = (
+ <MeasurementProviders>
+ <MeasureContent
+ columns={currentColumns}
+ rows={currentRows}
+ table={currentTable}
+ hasExpandableNodes={hasExpandableNodes}
+ indentWidth={indentWidth}
+ onMeasured={handleMeasured}
+ />
+ </MeasurementProviders>
+ );
+
+ const tree = renderRoot(content, measureElement);
+ measureRootRef.current = { element: measureElement, tree };
+ }, [
+ measurementColumnsKey,
+ rowsLength,
+ hasExpandableNodes,
+ indentWidth,
+ handleMeasured,
+ ]);
+
+ useLayoutEffect(() => {
+ return () => {
+ if (measureRootRef.current) {
+ const { element, tree } = measureRootRef.current;
+ removeMeasurementContainer(element, tree);
+ measureRootRef.current = null;
+ }
+ };
+ }, []);
+
+ const columnWidths = useMemo(() => {
+ return calculateColumnWidths(
+ columns,
+ containerWidth,
+ contentWidths,
+ maxDepth,
+ indentWidth,
+ );
+ }, [columns, containerWidth, contentWidths, maxDepth, indentWidth]);
+
+ const hasStretchingColumns = columns.some((col) => col.width == null);
+ const isFullyMeasured = hasStretchingColumns
+ ? isMeasured && containerWidth > 0
+ : isMeasured;
+
+ return { columnWidths, setContainerWidth, isMeasured: isFullyMeasured };
+}
diff --git a/frontend/src/metabase/ui/components/data-display/TreeTable/hooks/useColumnSizing.unit.spec.ts b/frontend/src/metabase/ui/components/data-display/TreeTable/hooks/useColumnSizing.unit.spec.ts
new file mode 100644
index 00000000000..306877bc8b0
--- /dev/null
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/hooks/useColumnSizing.unit.spec.ts
@@ -0,0 +1,90 @@
+import { MIN_COLUMN_WIDTH } from "../constants";
+import type { TreeTableColumnDef } from "../types";
+
+import {
+ calculateColumnWidths,
+ getMinConstraint,
+ needsMeasurement,
+} from "./useColumnSizing";
+
+type TestNode = { id: string; name: string };
+
+const createColumn = (
+ overrides: Partial<TreeTableColumnDef<TestNode>> = {},
+): TreeTableColumnDef<TestNode> => ({
+ id: "test",
+ ...overrides,
+});
+
+describe("needsMeasurement", () => {
+ it("returns true when minWidth is auto", () => {
+ expect(needsMeasurement(createColumn({ minWidth: "auto" }))).toBe(true);
+ });
+
+ it("returns false when minWidth is a number or undefined", () => {
+ expect(needsMeasurement(createColumn({ minWidth: 100 }))).toBe(false);
+ expect(needsMeasurement(createColumn({}))).toBe(false);
+ });
+});
+
+describe("getMinConstraint", () => {
+ it("uses content width when minWidth is auto", () => {
+ const column = createColumn({ id: "name", minWidth: "auto" });
+ expect(getMinConstraint(column, 1, { name: 200 }, 0, 20)).toBe(200);
+ });
+
+ it("falls back to MIN_COLUMN_WIDTH when content width is missing", () => {
+ const column = createColumn({ id: "name", minWidth: "auto" });
+ expect(getMinConstraint(column, 1, {}, 0, 20)).toBe(MIN_COLUMN_WIDTH);
+ });
+
+ it("adds indent padding for first column based on maxDepth", () => {
+ const column = createColumn({ id: "name", minWidth: 100 });
+ // maxDepth=3, indentWidth=20 -> MIN_COLUMN_WIDTH + 60 = 110
+ expect(getMinConstraint(column, 0, {}, 3, 20)).toBe(MIN_COLUMN_WIDTH + 60);
+ });
+});
+
+describe("calculateColumnWidths", () => {
+ it("returns empty object when containerWidth is 0", () => {
+ const columns = [createColumn({ id: "name" })];
+ expect(calculateColumnWidths(columns, 0, {}, 0, 20)).toEqual({});
+ });
+
+ it("uses fixed width for columns with explicit width", () => {
+ const columns = [
+ createColumn({ id: "name", width: 200 }),
+ createColumn({ id: "date", width: 100 }),
+ ];
+ expect(calculateColumnWidths(columns, 500, {}, 0, 20)).toEqual({
+ name: 200,
+ date: 100,
+ });
+ });
+
+ it("distributes remaining space evenly among stretching columns", () => {
+ const columns = [
+ createColumn({ id: "fixed", width: 100 }),
+ createColumn({ id: "stretch1" }),
+ createColumn({ id: "stretch2" }),
+ ];
+ // 500 - 100 = 400 remaining, split evenly = 200 each
+ expect(calculateColumnWidths(columns, 500, {}, 0, 20)).toEqual({
+ fixed: 100,
+ stretch1: 200,
+ stretch2: 200,
+ });
+ });
+
+ it("respects min and max width constraints", () => {
+ const columns = [
+ createColumn({ id: "col1", minWidth: 300 }),
+ createColumn({ id: "col2", maxWidth: 50 }),
+ ];
+ // col1 gets 300 (min), col2 gets 50 (max), remaining 50 goes to col1
+ expect(calculateColumnWidths(columns, 400, {}, 0, 20)).toEqual({
+ col1: 300,
+ col2: 50,
+ });
+ });
+});
diff --git a/frontend/src/metabase/ui/components/data-display/TreeTable/hooks/useTreeTableInstance.ts b/frontend/src/metabase/ui/components/data-display/TreeTable/hooks/useTreeTableInstance.ts
new file mode 100644
index 00000000000..b6f1a15e0b1
--- /dev/null
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/hooks/useTreeTableInstance.ts
@@ -0,0 +1,262 @@
+import type { ExpandedState } from "@tanstack/react-table";
+import {
+ getCoreRowModel,
+ getExpandedRowModel,
+ getFilteredRowModel,
+ getSortedRowModel,
+ useReactTable,
+} from "@tanstack/react-table";
+import { useVirtualizer } from "@tanstack/react-virtual";
+import { useCallback, useMemo, useRef, useState } from "react";
+
+import { DEFAULT_OVERSCAN, DEFAULT_ROW_HEIGHT } from "../constants";
+import type {
+ TreeNodeData,
+ TreeTableInstance,
+ UseTreeTableInstanceOptions,
+} from "../types";
+
+import { useColumnSizing } from "./useColumnSizing";
+import { useTreeTableKeyboard } from "./useTreeTableKeyboard";
+
+export function useTreeTableInstance<TData extends TreeNodeData>(
+ options: UseTreeTableInstanceOptions<TData>,
+): TreeTableInstance<TData> {
+ const {
+ data,
+ columns,
+ getNodeId,
+ getSubRows,
+ getRowCanExpand,
+ expanded: controlledExpanded,
+ onExpandedChange,
+ defaultExpanded,
+ autoExpandSingleChild = false,
+ enableRowSelection = false,
+ enableMultiRowSelection = true,
+ enableSubRowSelection = false,
+ rowSelection: controlledRowSelection,
+ onRowSelectionChange,
+ enableSorting = true,
+ sorting: controlledSorting,
+ onSortingChange,
+ manualSorting = false,
+ globalFilter: controlledGlobalFilter,
+ onGlobalFilterChange,
+ globalFilterFn,
+ isFilterable,
+ defaultRowHeight = DEFAULT_ROW_HEIGHT,
+ overscan = DEFAULT_OVERSCAN,
+ onRowActivate,
+ } = options;
+
+ const containerRef = useRef<HTMLDivElement>(null);
+
+ const [internalExpanded, setInternalExpanded] = useState<ExpandedState>(
+ () => {
+ if (defaultExpanded === true) {
+ return true;
+ }
+ if (defaultExpanded) {
+ return defaultExpanded;
+ }
+ if (autoExpandSingleChild && data.length === 1) {
+ const nodeId = getNodeId(data[0]);
+ return { [nodeId]: true };
+ }
+ return {};
+ },
+ );
+
+ const [internalRowSelection, setInternalRowSelection] = useState<
+ Record<string, boolean>
+ >({});
+ const [internalSorting, setInternalSorting] = useState(
+ controlledSorting ?? [],
+ );
+ const [internalGlobalFilter, setInternalGlobalFilter] = useState(
+ controlledGlobalFilter ?? "",
+ );
+
+ const expanded = controlledExpanded ?? internalExpanded;
+ const rowSelection = controlledRowSelection ?? internalRowSelection;
+ const sorting = controlledSorting ?? internalSorting;
+ const globalFilter = controlledGlobalFilter ?? internalGlobalFilter;
+
+ const handleExpandedChange = useCallback(
+ (updater: ExpandedState | ((old: ExpandedState) => ExpandedState)) => {
+ const newValue =
+ typeof updater === "function" ? updater(expanded) : updater;
+ if (onExpandedChange) {
+ onExpandedChange(newValue);
+ } else {
+ setInternalExpanded(newValue);
+ }
+ },
+ [expanded, onExpandedChange],
+ );
+
+ const handleRowSelectionChange = useCallback(
+ (
+ updater:
+ | Record<string, boolean>
+ | ((old: Record<string, boolean>) => Record<string, boolean>),
+ ) => {
+ const newValue =
+ typeof updater === "function" ? updater(rowSelection) : updater;
+ if (onRowSelectionChange) {
+ onRowSelectionChange(newValue);
+ } else {
+ setInternalRowSelection(newValue);
+ }
+ },
+ [rowSelection, onRowSelectionChange],
+ );
+
+ const handleSortingChange = useCallback(
+ (
+ updater:
+ | { id: string; desc: boolean }[]
+ | ((
+ old: { id: string; desc: boolean }[],
+ ) => { id: string; desc: boolean }[]),
+ ) => {
+ const newValue =
+ typeof updater === "function" ? updater(sorting) : updater;
+ if (onSortingChange) {
+ onSortingChange(newValue);
+ } else {
+ setInternalSorting(newValue);
+ }
+ },
+ [sorting, onSortingChange],
+ );
+
+ const handleGlobalFilterChange = useCallback(
+ (updater: string | ((old: string) => string)) => {
+ const newValue =
+ typeof updater === "function" ? updater(globalFilter) : updater;
+ if (onGlobalFilterChange) {
+ onGlobalFilterChange(newValue);
+ } else {
+ setInternalGlobalFilter(newValue);
+ }
+ },
+ [globalFilter, onGlobalFilterChange],
+ );
+
+ const effectiveFilterFn = useMemo(() => {
+ if (globalFilterFn) {
+ return globalFilterFn;
+ }
+ if (isFilterable) {
+ return (
+ row: { original: TData; getValue: (id: string) => unknown },
+ columnId: string,
+ filterValue: string,
+ ) => {
+ if (!isFilterable(row.original)) {
+ // Return false for non-filterable nodes (collections).
+ // filterFromLeafRows will include them if any children match.
+ return false;
+ }
+ const value = row.getValue(columnId);
+ return String(value ?? "")
+ .toLowerCase()
+ .includes(String(filterValue).toLowerCase());
+ };
+ }
+ return "includesString" as const;
+ }, [globalFilterFn, isFilterable]);
+
+ const table = useReactTable({
+ data,
+ columns,
+ state: {
+ expanded,
+ rowSelection,
+ sorting,
+ globalFilter,
+ },
+ getRowId: (row) => getNodeId(row),
+ getSubRows,
+ getRowCanExpand,
+ onExpandedChange: handleExpandedChange,
+ onRowSelectionChange: handleRowSelectionChange,
+ onSortingChange: handleSortingChange,
+ onGlobalFilterChange: handleGlobalFilterChange,
+ enableRowSelection,
+ enableMultiRowSelection,
+ enableSubRowSelection,
+ enableSorting,
+ manualSorting,
+ getCoreRowModel: getCoreRowModel(),
+ getExpandedRowModel: getExpandedRowModel(),
+ getSortedRowModel: manualSorting ? undefined : getSortedRowModel(),
+ getFilteredRowModel: getFilteredRowModel(),
+ filterFromLeafRows: true,
+ globalFilterFn: effectiveFilterFn,
+ });
+
+ const rows = table.getRowModel().rows;
+
+ const virtualizer = useVirtualizer({
+ count: rows.length,
+ getScrollElement: () => containerRef.current,
+ estimateSize: () => defaultRowHeight,
+ overscan,
+ getItemKey: (index) => rows[index]?.id ?? index,
+ });
+
+ const virtualRows = virtualizer.getVirtualItems();
+ const totalSize = virtualizer.getTotalSize();
+
+ const columnSizing = useColumnSizing({
+ columns,
+ table,
+ });
+
+ const keyboard = useTreeTableKeyboard({
+ table,
+ virtualizer,
+ enableRowSelection: Boolean(enableRowSelection),
+ onRowActivate,
+ });
+
+ const scrollToRow = useCallback(
+ (
+ rowId: string,
+ options?: { align?: "start" | "center" | "end" | "auto" },
+ ) => {
+ const index = rows.findIndex((r) => r.id === rowId);
+ if (index >= 0) {
+ virtualizer.scrollToIndex(index, options);
+ }
+ },
+ [rows, virtualizer],
+ );
+
+ const scrollToNode = useCallback(
+ (nodeId: string) => {
+ scrollToRow(nodeId, { align: "auto" });
+ },
+ [scrollToRow],
+ );
+
+ return {
+ table,
+ rows,
+ virtualizer,
+ containerRef,
+ virtualRows,
+ totalSize,
+ columnWidths: columnSizing.columnWidths,
+ isMeasured: columnSizing.isMeasured,
+ setContainerWidth: columnSizing.setContainerWidth,
+ scrollToRow,
+ scrollToNode,
+ activeRowId: keyboard.activeRowId,
+ setActiveRowId: keyboard.setActiveRowId,
+ handleKeyDown: keyboard.handleKeyDown,
+ };
+}
diff --git a/frontend/src/metabase/ui/components/data-display/TreeTable/hooks/useTreeTableKeyboard.ts b/frontend/src/metabase/ui/components/data-display/TreeTable/hooks/useTreeTableKeyboard.ts
new file mode 100644
index 00000000000..ee6ee12e00d
--- /dev/null
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/hooks/useTreeTableKeyboard.ts
@@ -0,0 +1,136 @@
+import type { Row, Table } from "@tanstack/react-table";
+import type { Virtualizer } from "@tanstack/react-virtual";
+import type { KeyboardEvent } from "react";
+import { useCallback, useState } from "react";
+
+import type { TreeNodeData } from "../types";
+
+interface UseTreeTableKeyboardOptions<TData extends TreeNodeData> {
+ table: Table<TData>;
+ virtualizer: Virtualizer<HTMLDivElement, Element>;
+ enableRowSelection?: boolean;
+ onRowActivate?: (row: Row<TData>) => void;
+}
+
+interface UseTreeTableKeyboardResult {
+ activeRowId: string | null;
+ setActiveRowId: (id: string | null) => void;
+ handleKeyDown: (event: KeyboardEvent<HTMLElement>) => void;
+}
+
+export function useTreeTableKeyboard<TData extends TreeNodeData>({
+ table,
+ virtualizer,
+ enableRowSelection,
+ onRowActivate,
+}: UseTreeTableKeyboardOptions<TData>): UseTreeTableKeyboardResult {
+ const [activeRowId, setActiveRowId] = useState<string | null>(null);
+
+ const handleKeyDown = useCallback(
+ (event: KeyboardEvent<HTMLElement>) => {
+ const rows = table.getRowModel().rows;
+ const currentIndex = rows.findIndex((r) => r.id === activeRowId);
+ const currentRow: Row<TData> | undefined = rows[currentIndex];
+
+ switch (event.key) {
+ case "ArrowDown": {
+ event.preventDefault();
+ const nextIndex = Math.min(currentIndex + 1, rows.length - 1);
+ const nextRow = rows[nextIndex];
+ if (nextRow) {
+ setActiveRowId(nextRow.id);
+ virtualizer.scrollToIndex(nextIndex);
+ }
+ break;
+ }
+
+ case "ArrowUp": {
+ event.preventDefault();
+ const prevIndex = Math.max(currentIndex - 1, 0);
+ const prevRow = rows[prevIndex];
+ if (prevRow) {
+ setActiveRowId(prevRow.id);
+ virtualizer.scrollToIndex(prevIndex);
+ }
+ break;
+ }
+
+ case "ArrowRight": {
+ event.preventDefault();
+ if (currentRow?.getCanExpand() && !currentRow.getIsExpanded()) {
+ currentRow.toggleExpanded(true);
+ }
+ break;
+ }
+
+ case "ArrowLeft": {
+ event.preventDefault();
+ if (currentRow?.getIsExpanded()) {
+ currentRow.toggleExpanded(false);
+ } else if (currentRow?.parentId) {
+ const parentRow = rows.find((r) => r.id === currentRow.parentId);
+ if (parentRow) {
+ setActiveRowId(parentRow.id);
+ const parentIndex = rows.indexOf(parentRow);
+ if (parentIndex >= 0) {
+ virtualizer.scrollToIndex(parentIndex);
+ }
+ }
+ }
+ break;
+ }
+
+ case "Enter": {
+ event.preventDefault();
+ if (currentRow) {
+ if (currentRow.getCanExpand()) {
+ currentRow.toggleExpanded();
+ } else {
+ onRowActivate?.(currentRow);
+ }
+ }
+ break;
+ }
+
+ case " ": {
+ event.preventDefault();
+ if (enableRowSelection && currentRow?.getCanSelect()) {
+ currentRow.toggleSelected();
+ }
+ break;
+ }
+
+ case "Home": {
+ event.preventDefault();
+ const firstRow = rows[0];
+ if (firstRow) {
+ setActiveRowId(firstRow.id);
+ virtualizer.scrollToIndex(0);
+ }
+ break;
+ }
+
+ case "End": {
+ event.preventDefault();
+ const lastRow = rows[rows.length - 1];
+ if (lastRow) {
+ setActiveRowId(lastRow.id);
+ virtualizer.scrollToIndex(rows.length - 1);
+ }
+ break;
+ }
+
+ case "Escape": {
+ event.preventDefault();
+ if (enableRowSelection) {
+ table.resetRowSelection();
+ }
+ break;
+ }
+ }
+ },
+ [table, virtualizer, activeRowId, enableRowSelection, onRowActivate],
+ );
+
+ return { activeRowId, setActiveRowId, handleKeyDown };
+}
diff --git a/frontend/src/metabase/ui/components/data-display/TreeTable/index.ts b/frontend/src/metabase/ui/components/data-display/TreeTable/index.ts
new file mode 100644
index 00000000000..b7018c32207
--- /dev/null
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/index.ts
@@ -0,0 +1,5 @@
+export { EntityNameCell } from "./EntityNameCell";
+export { TreeTable } from "./TreeTable";
+export { useTreeTableInstance } from "./hooks";
+
+export type * from "./types";
diff --git a/frontend/src/metabase/ui/components/data-display/TreeTable/types.ts b/frontend/src/metabase/ui/components/data-display/TreeTable/types.ts
new file mode 100644
index 00000000000..2578c9f45a0
--- /dev/null
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/types.ts
@@ -0,0 +1,259 @@
+import type {
+ ColumnDef,
+ ExpandedState,
+ FilterFn,
+ OnChangeFn,
+ Row,
+ RowSelectionState,
+ SortingState,
+ Table,
+} from "@tanstack/react-table";
+import type { VirtualItem, Virtualizer } from "@tanstack/react-virtual";
+import type {
+ CSSProperties,
+ KeyboardEvent,
+ MouseEvent,
+ ReactNode,
+ RefObject,
+} from "react";
+
+/**
+ * Base interface that all tree node data must extend.
+ * IDs can be strings or numbers - getNodeId converts them to strings for TanStack Table.
+ */
+export interface TreeNodeData {
+ id: string | number;
+}
+
+/**
+ * Column sizing extensions for TreeTable.
+ */
+export interface TreeTableColumnSizingDef {
+ /** Column ID is required for TreeTable columns. */
+ id: string;
+ /** Fixed width in pixels. Column does NOT stretch. */
+ width?: number;
+ /** Minimum width: pixels or 'auto' (measures content via DOM). */
+ minWidth?: number | "auto";
+ /** Maximum width in pixels. Only applies to stretching columns. */
+ maxWidth?: number;
+}
+
+/**
+ * Column definition for TreeTable.
+ * Extends TanStack Table's ColumnDef with tree-specific sizing options.
+ * Requires `id` to be specified on all columns.
+ */
+export type TreeTableColumnDef<TData extends TreeNodeData> = ColumnDef<
+ TData,
+ unknown
+> &
+ TreeTableColumnSizingDef;
+
+/**
+ * Options for useTreeTableInstance hook.
+ */
+export interface UseTreeTableInstanceOptions<TData extends TreeNodeData> {
+ data: TData[];
+ columns: TreeTableColumnDef<TData>[];
+ getNodeId: (node: TData) => string;
+
+ getSubRows?: (node: TData) => TData[] | undefined;
+ getRowCanExpand?: (row: Row<TData>) => boolean;
+
+ expanded?: ExpandedState;
+ onExpandedChange?: OnChangeFn<ExpandedState>;
+ defaultExpanded?: ExpandedState | true;
+ autoExpandSingleChild?: boolean;
+
+ enableRowSelection?: boolean | ((row: Row<TData>) => boolean);
+ enableMultiRowSelection?: boolean;
+ enableSubRowSelection?: boolean;
+ rowSelection?: RowSelectionState;
+ onRowSelectionChange?: OnChangeFn<RowSelectionState>;
+
+ enableSorting?: boolean;
+ sorting?: SortingState;
+ onSortingChange?: OnChangeFn<SortingState>;
+ manualSorting?: boolean;
+
+ globalFilter?: string;
+ onGlobalFilterChange?: OnChangeFn<string>;
+ globalFilterFn?: FilterFn<TData>;
+ /**
+ * Determines which nodes should be filtered. Return true for leaf nodes
+ * that should be searchable, false for parent/collection nodes.
+ * Parents returning false will only appear if children match the filter.
+ */
+ isFilterable?: (node: TData) => boolean;
+
+ defaultRowHeight?: number;
+ overscan?: number;
+
+ /**
+ * Called when Enter is pressed on a non-expandable row.
+ * Use this to navigate to the item or perform the primary action.
+ */
+ onRowActivate?: (row: Row<TData>) => void;
+}
+
+/**
+ * Column sizing state and controls.
+ */
+export interface TreeTableColumnSizing {
+ columnWidths: Record<string, number>;
+ setContainerWidth: (width: number) => void;
+ isMeasured: boolean;
+}
+
+/**
+ * Instance returned by useTreeTableInstance.
+ */
+export interface TreeTableInstance<TData extends TreeNodeData> {
+ table: Table<TData>;
+
+ rows: Row<TData>[];
+
+ virtualizer: Virtualizer<HTMLDivElement, Element>;
+ containerRef: RefObject<HTMLDivElement>;
+ virtualRows: VirtualItem[];
+ totalSize: number;
+
+ columnWidths: Record<string, number>;
+ isMeasured: boolean;
+ setContainerWidth: (width: number) => void;
+
+ scrollToRow: (
+ rowId: string,
+ options?: { align?: "start" | "center" | "end" | "auto" },
+ ) => void;
+ scrollToNode: (nodeId: string) => void;
+
+ activeRowId: string | null;
+ setActiveRowId: (id: string | null) => void;
+ handleKeyDown: (event: KeyboardEvent<HTMLElement>) => void;
+}
+
+export type TreeTableStylesNames =
+ | "root"
+ | "header"
+ | "headerRow"
+ | "headerCell"
+ | "body"
+ | "row"
+ | "rowActive"
+ | "rowDisabled"
+ | "cell"
+ | "treeCell"
+ | "treeCellContent"
+ | "expandButton"
+ | "checkbox";
+
+export type TreeTableHeaderVariant = "pill" | "plain";
+
+/**
+ * Selection state for tri-state checkboxes.
+ */
+export type SelectionState = "all" | "some" | "none";
+
+export interface TreeTableStylesProps {
+ classNames?: Partial<Record<TreeTableStylesNames, string>>;
+ styles?: Partial<Record<TreeTableStylesNames, CSSProperties>>;
+}
+
+/**
+ * Props for TreeTable component.
+ */
+export interface TreeTableProps<TData extends TreeNodeData>
+ extends TreeTableStylesProps {
+ instance: TreeTableInstance<TData>;
+
+ showCheckboxes?: boolean;
+ indentWidth?: number;
+ headerVariant?: TreeTableHeaderVariant;
+
+ emptyState?: ReactNode;
+
+ onRowClick?: (row: Row<TData>, event: MouseEvent) => void;
+ onRowDoubleClick?: (row: Row<TData>, event: MouseEvent) => void;
+
+ /**
+ * Custom selection state callback. When provided, bypasses TanStack selection
+ * and uses this to determine checkbox state for each row.
+ */
+ getSelectionState?: (row: Row<TData>) => SelectionState;
+
+ /**
+ * Custom checkbox click handler. When provided, called instead of
+ * row.toggleSelected(). Receives row, visible index, and MouseEvent
+ * (for detecting shift+click).
+ */
+ onCheckboxClick?: (row: Row<TData>, index: number, event: MouseEvent) => void;
+
+ /**
+ * Callback to determine if a row's children are currently loading.
+ * When true, shows a loading spinner instead of expand button.
+ */
+ isChildrenLoading?: (row: Row<TData>) => boolean;
+
+ ariaLabel?: string;
+ ariaLabelledBy?: string;
+}
+
+/**
+ * Props for TreeTableRow component.
+ */
+export interface TreeTableRowProps<TData extends TreeNodeData>
+ extends TreeTableStylesProps {
+ row: Row<TData>;
+ rowIndex: number;
+ virtualItem: VirtualItem;
+ table: Table<TData>;
+ columnWidths: Record<string, number>;
+ showCheckboxes: boolean;
+ showExpandButtons: boolean;
+ indentWidth: number;
+ activeRowId: string | null;
+ measureElement: (element: HTMLElement | null) => void;
+ onRowClick?: (row: Row<TData>, event: MouseEvent) => void;
+ onRowDoubleClick?: (row: Row<TData>, event: MouseEvent) => void;
+ isDisabled?: boolean;
+ isChildrenLoading?: boolean;
+ getSelectionState?: (row: Row<TData>) => SelectionState;
+ onCheckboxClick?: (row: Row<TData>, index: number, event: MouseEvent) => void;
+}
+
+/**
+ * Props for TreeTableHeader component.
+ */
+export interface TreeTableHeaderProps<TData extends TreeNodeData>
+ extends TreeTableStylesProps {
+ table: Table<TData>;
+ columnWidths: Record<string, number>;
+ showCheckboxes: boolean;
+ isMeasured?: boolean;
+ totalContentWidth?: number;
+ headerVariant?: TreeTableHeaderVariant;
+}
+
+/**
+ * Props for ExpandButton component.
+ */
+export interface ExpandButtonProps {
+ canExpand: boolean;
+ isExpanded: boolean;
+ isLoading?: boolean;
+ onClick: (event: MouseEvent) => void;
+ className?: string;
+}
+
+/**
+ * Props for SelectionCheckbox component.
+ */
+export interface SelectionCheckboxProps {
+ isSelected: boolean;
+ isSomeSelected: boolean;
+ disabled?: boolean;
+ onClick: (event: MouseEvent) => void;
+ className?: string;
+}
diff --git a/frontend/src/metabase/ui/components/data-display/TreeTable/utils.ts b/frontend/src/metabase/ui/components/data-display/TreeTable/utils.ts
new file mode 100644
index 00000000000..08edabe1c8c
--- /dev/null
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/utils.ts
@@ -0,0 +1,16 @@
+import type { CSSProperties } from "react";
+
+export function getColumnStyle(
+ columnWidths: Record<string, number>,
+ columnId: string,
+ isFirstColumn: boolean,
+): CSSProperties {
+ const measuredWidth = columnWidths[columnId];
+ const hasMeasuredWidth = measuredWidth != null && measuredWidth > 0;
+
+ if (hasMeasuredWidth) {
+ return { width: measuredWidth, flex: "none" };
+ }
+
+ return isFirstColumn ? { flex: 1, minWidth: 0 } : { flex: "none" };
+}
diff --git a/frontend/src/metabase/ui/components/data-display/index.ts b/frontend/src/metabase/ui/components/data-display/index.ts
index 54ef31d7bf2..96fa7786acc 100644
--- a/frontend/src/metabase/ui/components/data-display/index.ts
+++ b/frontend/src/metabase/ui/components/data-display/index.ts
@@ -5,5 +5,7 @@ export * from "./Card";
export * from "./Image";
export * from "./Indicator";
export * from "./Kbd";
+export * from "./SortableHeaderPill";
export * from "./Stepper";
export * from "./Timeline";
+export * from "./TreeTable";
diff --git a/frontend/src/metabase/visualizations/visualizations/SmartScalar/ScalarPeriod.tsx b/frontend/src/metabase/visualizations/visualizations/SmartScalar/ScalarPeriod.tsx
index d32db1340f9..00feb399af9 100644
--- a/frontend/src/metabase/visualizations/visualizations/SmartScalar/ScalarPeriod.tsx
+++ b/frontend/src/metabase/visualizations/visualizations/SmartScalar/ScalarPeriod.tsx
@@ -19,7 +19,11 @@ export function ScalarPeriod({ period, onClick }: ScalarPeriodProps) {
className={DashboardS.fullscreenNormalText}
onClick={onClick}
>
- <Ellipsified tooltip={period} lines={1} placement="bottom">
+ <Ellipsified
+ tooltip={period}
+ lines={1}
+ tooltipProps={{ position: "bottom" }}
+ >
{period}
</Ellipsified>
</Text>
diff --git a/resources/migrations/058_update_migrations.yaml b/resources/migrations/058_update_migrations.yaml
index d44da8492ab..a12a12dc3f7 100644
--- a/resources/migrations/058_update_migrations.yaml
+++ b/resources/migrations/058_update_migrations.yaml
@@ -1095,6 +1095,43 @@ databaseChangeLog:
constraints:
nullable: false
+ - changeSet:
+ id: v58.2025-12-03T17:08:36
+ author: nvoxland
+ comment: Add collection_id column to transform table
+ changes:
+ - addColumn:
+ tableName: transform
+ columns:
+ - column:
+ name: collection_id
+ type: int
+ remarks: The collection the transform is in
+
+ - changeSet:
+ id: v58.2025-12-03T17:08:37
+ author: nvoxland
+ comment: Add index on transform.collection_id
+ changes:
+ - createIndex:
+ tableName: transform
+ indexName: idx_transform_collection_id
+ columns:
+ - column:
+ name: collection_id
+
+ - changeSet:
+ id: v58.2025-12-03T17:08:38
+ author: nvoxland
+ comment: Add fk_transform_collection_id
+ changes:
+ - addForeignKeyConstraint:
+ baseTableName: transform
+ baseColumnNames: collection_id
+ referencedTableName: collection
+ referencedColumnNames: id
+ constraintName: fk_transform_collection_id
+
- changeSet:
id: v58.2025-12-05T17:41:51
author: ranquild
diff --git a/src/metabase/collections/models/collection.clj b/src/metabase/collections/models/collection.clj
index 94588ec05d3..68598bca4ae 100644
--- a/src/metabase/collections/models/collection.clj
+++ b/src/metabase/collections/models/collection.clj
@@ -75,6 +75,14 @@
"The value of the `:type` field for collections that only allow metrics."
"library-metrics")
+(def transforms-ns
+ "Namespace for transforms"
+ :transforms)
+
+(def snippets-ns
+ "Namespace for snippets"
+ :snippets)
+
(defn- trash-collection* []
(t2/select-one :model/Collection :type trash-collection-type))
diff --git a/src/metabase/collections/models/collection/root.clj b/src/metabase/collections/models/collection/root.clj
index 8110deb5d39..b155682403a 100644
--- a/src/metabase/collections/models/collection/root.clj
+++ b/src/metabase/collections/models/collection/root.clj
@@ -57,6 +57,7 @@
:name (case (keyword collection-namespace)
:shared-tenant-collections (tru "Shared collections")
:snippets (tru "SQL snippets")
+ :transforms (tru "Transforms")
(tru "Our analytics"))
:namespace collection-namespace
:is_personal false
diff --git a/src/metabase/collections_rest/api.clj b/src/metabase/collections_rest/api.clj
index ce1738c33dd..e356d57b809 100644
--- a/src/metabase/collections_rest/api.clj
+++ b/src/metabase/collections_rest/api.clj
@@ -476,6 +476,14 @@
[:= :collection_id (:id collection)]
[:= :archived (boolean archived?)]]})
+(defmethod collection-children-query :transform
+ [_model collection {:keys [pinned-state]}]
+ {:select [:id :collection_id :name [(h2x/literal "transform") :model] :description :entity_id]
+ :from [[:transform :transform]]
+ :where [:and
+ (poison-when-pinned-clause pinned-state)
+ [:= :collection_id (:id collection)]]})
+
(defmethod post-process-collection-children :timeline
[_ _options _collection rows]
(for [row rows]
@@ -884,7 +892,8 @@
:pulse :model/Pulse
:snippet :model/NativeQuerySnippet
:table :model/Table
- :timeline :model/Timeline))
+ :timeline :model/Timeline
+ :transform :model/Transform))
(defn post-process-rows
"Post process any data. Have a chance to process all of the same type at once using
@@ -1072,7 +1081,7 @@
"Fetch a sequence of 'child' objects belonging to a Collection, filtered using `options`."
[{collection-namespace :namespace, :as collection} :- collection/CollectionWithLocationAndIDOrRoot
{:keys [models], :as options} :- CollectionChildrenOptions]
- (let [valid-models (for [model-kw (cond-> [:collection :dataset :metric :card :dashboard :pulse :snippet :timeline :document]
+ (let [valid-models (for [model-kw (cond-> [:collection :dataset :metric :card :dashboard :pulse :snippet :timeline :document :transform]
;; Tables in collections are an EE feature (data-studio)
(premium-features/has-feature? :data-studio) (conj :table))
;; only fetch models that are specified by the `model` param; or everything if it's empty
diff --git a/test_resources/serialization_baseline/transforms/2HzIFwJ6720JAx07UMavl_test_transform.yaml b/test_resources/serialization_baseline/transforms/2HzIFwJ6720JAx07UMavl_test_transform.yaml
index d342af853c5..fe29f530b56 100644
--- a/test_resources/serialization_baseline/transforms/2HzIFwJ6720JAx07UMavl_test_transform.yaml
+++ b/test_resources/serialization_baseline/transforms/2HzIFwJ6720JAx07UMavl_test_transform.yaml
@@ -1,3 +1,4 @@
+collection_id: null
created_at: '2025-10-06T20:41:45.536727Z'
creator_id: [email protected]
description: A test transform for serialization