Skip to content

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

Use tree table in data model (#67117)

Aleksandr Lesnenko71c188c09fdf
diff --git a/e2e/test/scenarios/data-studio/data-model/data-studio-bulk-table.cy.spec.ts b/e2e/test/scenarios/data-studio/data-model/data-studio-bulk-table.cy.spec.ts
index fb632d9cbef..edca1dad546 100644
--- a/e2e/test/scenarios/data-studio/data-model/data-studio-bulk-table.cy.spec.ts
+++ b/e2e/test/scenarios/data-studio/data-model/data-studio-bulk-table.cy.spec.ts
@@ -238,16 +238,6 @@ describe("bulk table operations", () => {
});
cy.log("publish and check publish state column");
-
- /**
- * we need to wait a little until TableAttributesEditBulk component is destroyed (see enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/SearchNew.tsx:153)
- * Otherwise, the button will be found, but it will be immediately removed.
- * And then we have to reselect because when there is a filter rows are unselected after a change
- */
- cy.findByRole("button", { name: /Publish/ }).should("not.exist");
-
- TablePicker.getTable("Accounts").find('input[type="checkbox"]').check();
- TablePicker.getTable("Animals").find('input[type="checkbox"]').check();
cy.findByRole("button", { name: /Publish/ }).click();
H.modal().findByText("Publish these tables").click();
cy.wait("@publishTables");
diff --git a/e2e/test/scenarios/data-studio/data-model/datamodel-data-studio.cy.spec.ts b/e2e/test/scenarios/data-studio/data-model/datamodel-data-studio.cy.spec.ts
index 7282b557fc1..3c8655fe934 100644
--- a/e2e/test/scenarios/data-studio/data-model/datamodel-data-studio.cy.spec.ts
+++ b/e2e/test/scenarios/data-studio/data-model/datamodel-data-studio.cy.spec.ts
@@ -394,31 +394,6 @@ describe("scenarios > data studio > datamodel", () => {
`/data-studio/data/database/${WRITABLE_DB_ID}/schema/${WRITABLE_DB_ID}:Domestic/table/`,
);
});
-
- cy.log("databases, schemas, and tables should be links");
- TablePicker.getDatabase("Sample Database").click();
- TablePicker.getDatabase("Writable Postgres12").click();
- TablePicker.getDatabase("Writable Postgres12")
- .should("have.prop", "tagName", "A")
- .and(
- "have.attr",
- "href",
- `/data-studio/data/database/${WRITABLE_DB_ID}`,
- );
- TablePicker.getSchema("Domestic")
- .should("have.prop", "tagName", "A")
- .and(
- "have.attr",
- "href",
- `/data-studio/data/database/${WRITABLE_DB_ID}/schema/${WRITABLE_DB_ID}:Domestic`,
- );
- TablePicker.getTable("Orders")
- .should("have.prop", "tagName", "A")
- .and(
- "have.attr",
- "href",
- `/data-studio/data/database/${SAMPLE_DB_ID}/schema/${SAMPLE_DB_SCHEMA_ID}/table/${ORDERS_ID}`,
- );
});
it("should allow to search for tables", () => {
@@ -458,6 +433,7 @@ describe("scenarios > data studio > datamodel", () => {
"aria-selected",
"true",
);
+
TablePicker.getTable("Birds").find('input[type="checkbox"]').check();
TablePicker.getTable("Birds").should(
"not.have.attr",
@@ -763,30 +739,20 @@ describe("scenarios > data studio > datamodel", () => {
const getSchemaCheckbox = (schemaName: string) =>
TablePicker.getSchema(schemaName).find('input[type="checkbox"]');
const getWpTableCheckbox = (schemaName: string, tableName: string) =>
- getTableCheckbox(
- WRITABLE_DB_ID,
- `${WRITABLE_DB_ID}:${schemaName}`,
- tableName,
- );
+ getTableCheckbox(WRITABLE_DB_ID, schemaName, tableName);
const getSampleTableCheckbox = (tableName: string) =>
- getTableCheckbox(SAMPLE_DB_ID, SAMPLE_DB_SCHEMA_ID, tableName);
+ getTableCheckbox(SAMPLE_DB_ID, "PUBLIC", tableName);
function getTableCheckbox(
databaseId: number,
- schemaFragment: string,
+ schemaName: string,
tableName: string,
) {
return TablePicker.getTables()
- .filter((_, element) => {
- const href = element.getAttribute("href") ?? "";
- const text = element.textContent ?? "";
-
- return (
- href.includes(`/database/${databaseId}/`) &&
- href.includes(`/schema/${schemaFragment}`) &&
- text.toLowerCase().includes(tableName.toLowerCase())
- );
- })
+ .filter(
+ `[data-database-id="${databaseId}"][data-schema-name="${schemaName}"]`,
+ )
+ .filter(`:contains("${tableName}")`)
.find('input[type="checkbox"]');
}
@@ -803,6 +769,7 @@ describe("scenarios > data studio > datamodel", () => {
for (const tableName of domesticTables) {
getWpTableCheckbox(domesticSchema, tableName).should("be.checked");
}
+
for (const tableName of wildTables) {
getWpTableCheckbox(wildSchema, tableName).should("be.checked");
}
@@ -864,8 +831,7 @@ describe("scenarios > data studio > datamodel", () => {
getSchemaCheckbox(wildSchema).should("not.be.checked");
// partially selected now, so clicking twice to make it unchecked
getDatabaseCheckbox().should("not.be.checked");
-
- getDatabaseCheckbox().uncheck();
+ getDatabaseCheckbox().check();
getDatabaseCheckbox().uncheck();
for (const { schema, table } of tablesInDatabase) {
getWpTableCheckbox(schema, table).should("not.be.checked");
@@ -3987,11 +3953,7 @@ function expectTableNotVisible(tableId: TableId) {
}
function findSearchResultByTableId(tableId: TableId) {
- return cy.findAllByTestId("tree-item").filter((_, element) => {
- const href = element.getAttribute("href") ?? "";
- const pattern = new RegExp(`/table/${tableId}(?:/|$)`);
- return pattern.test(href);
- });
+ return cy.findAllByTestId("tree-item").filter(`[data-table-id="${tableId}"]`);
}
function openWritableDomesticSchema(databaseName: string, schemaName: string) {
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/app/pages/LibrarySectionLayout/LibrarySectionLayout.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/app/pages/LibrarySectionLayout/LibrarySectionLayout.tsx
index 924771ce1d4..fb80b940291 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/app/pages/LibrarySectionLayout/LibrarySectionLayout.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/app/pages/LibrarySectionLayout/LibrarySectionLayout.tsx
@@ -21,13 +21,13 @@ import {
Stack,
TextInput,
TreeTable,
+ TreeTableSkeleton,
useTreeTableInstance,
} from "metabase/ui";
import { CreateLibraryModal } from "metabase-enterprise/data-studio/common/components/CreateLibraryModal";
import { DataStudioBreadcrumbs } from "metabase-enterprise/data-studio/common/components/DataStudioBreadcrumbs";
import { PaneHeader } from "metabase-enterprise/data-studio/common/components/PaneHeader";
import { ListEmptyState } from "metabase-enterprise/transforms/components/ListEmptyState";
-import { ListLoadingState } from "metabase-enterprise/transforms/components/ListLoadingState";
import type { Collection, CollectionId } from "metabase-types/api";
import { SectionLayout } from "../../components/SectionLayout";
@@ -116,6 +116,7 @@ export function LibrarySectionLayout() {
header: t`Name`,
enableSorting: true,
accessorKey: "name",
+ minWidth: 600,
cell: ({ row }) => (
<EntityNameCell
data-testid={`${row.original.model}-name`}
@@ -227,7 +228,7 @@ export function LibrarySectionLayout() {
</Flex>
<Card withBorder p={0}>
{isLoading ? (
- <ListLoadingState />
+ <TreeTableSkeleton columnWidths={[0.6, 0.2, 0.05]} />
) : (
<TreeTable
instance={treeTableInstance}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/bulk-selection.utils.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/bulk-selection.utils.ts
index 8a4c49cd869..a7c0d5d6016 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/bulk-selection.utils.ts
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/bulk-selection.utils.ts
@@ -1,20 +1,8 @@
+import type { SelectionState } from "metabase/ui";
import type { DatabaseId, TableId } from "metabase-types/api";
-import type {
- DatabaseNode,
- ExpandedDatabaseItem,
- ExpandedItem,
- ExpandedSchemaItem,
- FlatItem,
- SchemaNode,
- TreeNode,
-} from "./types";
-import {
- isExpandedItem,
- isSchemaNode,
- isTableNode,
- isTableOrSchemaNode,
-} from "./types";
+import type { DatabaseNode, SchemaNode, TreeNode } from "./types";
+import { isSchemaNode, isTableNode } from "./types";
export interface NodeSelection {
tables: Set<TableId>;
@@ -22,41 +10,36 @@ export interface NodeSelection {
databases: Set<DatabaseId>;
}
-type NodeSelectionValues = "yes" | "no" | "some";
-
export function isItemSelected(
node: TreeNode,
selection: NodeSelection,
-): NodeSelectionValues {
- if (!selection) {
- return "no";
- }
+): SelectionState {
if (isTableNode(node)) {
- return selection.tables.has(node.value.tableId) ? "yes" : "no";
+ return selection.tables.has(node.value.tableId) ? "all" : "none";
}
if (isSchemaNode(node)) {
- if (selection.schemas.has(getSchemaId(node) ?? "")) {
- return "yes";
+ if (selection.schemas.has(getSchemaId(node))) {
+ return "all";
}
return areChildTablesSelected(node, selection.tables);
}
if (node.type === "database") {
if (selection.databases.has(node.value.databaseId)) {
- return "yes";
+ return "all";
}
return areChildSchemasSelected(node, selection);
}
- return "no";
+ return "none";
}
function areChildTablesSelected(
node: TreeNode,
selectedTables: Set<TableId>,
-): NodeSelectionValues {
+): SelectionState {
if (node.children.length === 0) {
- return "no";
+ return "none";
}
const selectedTablesCount = node.children.filter(
@@ -65,102 +48,40 @@ function areChildTablesSelected(
).length;
return selectedTablesCount === node.children.length
- ? "yes"
+ ? "all"
: selectedTablesCount > 0
? "some"
- : "no";
+ : "none";
}
function areChildSchemasSelected(
node: TreeNode,
selection: NodeSelection,
-): NodeSelectionValues {
+): SelectionState {
if (node.children.length === 0) {
- return "no";
+ return "none";
}
const selectedSchemasResult = node.children.map((child) =>
isItemSelected(child, selection),
);
- return selectedSchemasResult.every((x) => x === "yes")
- ? "yes"
- : selectedSchemasResult.every((x) => x === "no")
- ? "no"
+ return selectedSchemasResult.every((x) => x === "all")
+ ? "all"
+ : selectedSchemasResult.every((x) => x === "none")
+ ? "none"
: "some";
}
-export function getSchemaId(item: FlatItem | SchemaNode) {
- if (
- "value" in item &&
- item.value &&
- "databaseId" in item.value &&
- "schemaName" in item.value
- ) {
- return `${item.value.databaseId}:${item.value.schemaName}`;
- }
-}
-
-export function isParentSchemaSelected(
- item: FlatItem,
- selectedSchemas: Set<string>,
-) {
- if (!isTableNode(item)) {
- return false;
- }
-
- const parentSchemaId = getSchemaId(item);
-
- if (!parentSchemaId) {
- return false;
- }
-
- return selectedSchemas?.has(parentSchemaId);
-}
-
-export function noManuallySelectedTables(
- schema: FlatItem | undefined,
- items: FlatItem[],
- selectedItems: Set<TableId>,
-) {
- if (!schema) {
- return false;
- }
-
- const children = items.filter((child) => child.parent === schema.key);
-
- return !children.some(
- (child) =>
- child.type === "table" && selectedItems?.has(child.value?.tableId ?? ""),
- );
-}
-
-export function noManuallySelectedSchemas(
- database: { key: string },
- items: FlatItem[],
- selectedSchemas: Set<string>,
-) {
- if (!database) {
- return false;
- }
-
- const children = items.filter((child) => child.parent === database.key);
-
- return !children.some(
- (child) =>
- child.type === "schema" && selectedSchemas.has(getSchemaId(child) ?? ""),
- );
+export function getSchemaId(item: SchemaNode): string {
+ return `${item.value.databaseId}:${item.value.schemaName}`;
}
export function noManuallySelectedDatabaseChildrenTables(
database: DatabaseNode,
selectedTables: Set<TableId>,
-) {
- if (!database) {
- return false;
- }
-
- const answer = !database.children.some(
+): boolean {
+ return !database.children.some(
(schema) =>
schema.type === "schema" &&
schema.children.some(
@@ -168,151 +89,30 @@ export function noManuallySelectedDatabaseChildrenTables(
child.type === "table" && selectedTables.has(child.value.tableId),
),
);
-
- return answer;
}
-export function getParentSchema(tableItem: FlatItem, allItems: FlatItem[]) {
- return allItems.find((item) => {
- return (
- item.type === "schema" && getSchemaId(item) === getSchemaId(tableItem)
- );
- });
-}
-
-export function getSchemaTables(
- schema: FlatItem,
- allItems: ExpandedItem[] | TreeNode[],
-) {
- const result = allItems
- .filter(
- (item) =>
- isTableOrSchemaNode(item) &&
- getSchemaId(schema) === getSchemaId(item) &&
- item.value.tableId,
- )
- .filter(isTableOrSchemaNode);
-
- return result;
-}
-
-export function getSchemaTableIds(schema: FlatItem, allItems: FlatItem[]) {
- const expandedItems = allItems.filter(isExpandedItem);
- return getSchemaTables(schema, expandedItems).map(
- (table) => table.value.tableId,
- );
-}
-
-export function getSchemaChildrenTableIds(schema: TreeNode) {
- return schema.children
- .filter((child) => child.type === "table")
- .map((child) => child.value.tableId);
-}
-
-export function areTablesSelected(
- schema: FlatItem,
- allItems: TreeNode[],
- selectedItems: Set<TableId>,
-): "all" | "some" | "none" {
- const tables = getSchemaTables(schema, allItems);
- if (tables.length === 0) {
- return "none";
- }
- if (tables.every((table) => selectedItems.has(table.value.tableId))) {
- return "all";
- }
- if (tables.some((table) => selectedItems.has(table.value.tableId))) {
- return "some";
- }
- return "none";
-}
-
-export function getSchemas(database: FlatItem, allItems: FlatItem[]) {
- return allItems.filter(
- (item) =>
- item.type === "schema" &&
- item.value &&
- item.value.databaseId === database.value?.databaseId,
- );
-}
-
-export function getChildSchemas(databaseNode: DatabaseNode) {
- return databaseNode.children.filter((x) => x.type === "schema");
-}
-
-export function areSchemasSelected(
- database: FlatItem,
- allItems: FlatItem[],
- selectedSchemas: Set<string>,
- selectedItems: Set<TableId>,
-): "all" | "some" | "none" {
- if (database.type !== "database") {
- return "none";
- }
-
- const schemas = getSchemas(database, allItems);
- if (schemas.length === 0) {
- return "none";
- }
-
- if (
- schemas.every(
- (schema) =>
- selectedSchemas.has(getSchemaId(schema) ?? "") ||
- areTablesSelected(schema, schema.children, selectedItems) === "all",
- )
- ) {
- return "all";
- }
-
- if (
- schemas.some(
- (schema) =>
- selectedSchemas.has(getSchemaId(schema) ?? "") ||
- areTablesSelected(schema, schema.children, selectedItems) !== "none",
- )
- ) {
- return "some";
- }
-
- return "none";
+export function getSchemaChildrenTableIds(schema: SchemaNode): TableId[] {
+ return schema.children.map((child) => child.value.tableId);
}
export function markAllSchemas(
- item: FlatItem,
- targetChecked: "yes" | "no",
+ database: DatabaseNode,
+ targetChecked: "all" | "none",
selection: NodeSelection,
): NodeSelection {
const schemas = new Set(selection.schemas);
const tables = new Set(selection.tables);
- if (item.type !== "database") {
- return {
- tables,
- schemas,
- databases: selection.databases,
- };
- }
-
- const filteredSchemas = item.children.filter(
- (child): child is SchemaNode => child.type === "schema",
- );
- filteredSchemas.forEach((schema) => {
- if (!isSchemaNode(schema)) {
- return;
- }
+ for (const schema of database.children) {
const schemaId = getSchemaId(schema);
- if (!schemaId) {
- return;
- }
if (schema.children.length === 0) {
- targetChecked === "yes"
+ targetChecked === "all"
? schemas.add(schemaId)
: schemas.delete(schemaId);
} else {
markAllTables(schema, targetChecked, tables);
}
- });
+ }
return {
tables,
@@ -323,38 +123,34 @@ export function markAllSchemas(
function markAllTables(
schema: SchemaNode,
- targetChecked: "yes" | "no",
+ targetChecked: "all" | "none",
tablesSelection: Set<TableId>,
) {
- const tables = getSchemaChildrenTableIds(schema);
- tables.forEach((tableId) => {
- if (tableId === -1) {
- return;
- }
- targetChecked === "yes"
+ for (const tableId of getSchemaChildrenTableIds(schema)) {
+ targetChecked === "all"
? tablesSelection.add(tableId)
: tablesSelection.delete(tableId);
- });
+ }
}
export function toggleDatabaseSelection(
- item: ExpandedDatabaseItem,
+ item: DatabaseNode,
selection: NodeSelection,
): NodeSelection {
const isSelected = isItemSelected(item, selection);
- const targetChecked = isSelected === "yes" ? "no" : "yes";
+ const targetChecked = isSelected === "all" ? "none" : "all";
return markAllSchemas(item, targetChecked, selection);
}
export function toggleSchemaSelection(
- item: ExpandedSchemaItem,
+ item: SchemaNode,
selection: NodeSelection,
): NodeSelection {
const isSelected = isItemSelected(item, selection);
const tables = new Set(selection.tables);
- if (isSelected === "yes") {
+ if (isSelected === "all") {
const tableIds = getSchemaChildrenTableIds(item);
tableIds.forEach((x) => {
tables.delete(x);
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/bulk-selection.utils.unit.spec.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/bulk-selection.utils.unit.spec.ts
index e034169fbce..95f86c75ca7 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/bulk-selection.utils.unit.spec.ts
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/bulk-selection.utils.unit.spec.ts
@@ -2,22 +2,12 @@ import type { DatabaseId, TableId } from "metabase-types/api";
import {
type NodeSelection,
- areSchemasSelected,
- areTablesSelected,
- getChildSchemas,
- getParentSchema,
getSchemaChildrenTableIds,
getSchemaId,
- getSchemaTableIds,
- getSchemaTables,
- getSchemas,
isItemSelected,
- isParentSchemaSelected,
noManuallySelectedDatabaseChildrenTables,
- noManuallySelectedSchemas,
- noManuallySelectedTables,
} from "./bulk-selection.utils";
-import type { DatabaseNode, FlatItem, SchemaNode, TableNode } from "./types";
+import type { DatabaseNode, SchemaNode, TableNode } from "./types";
describe("bulk-selection.utils", () => {
const createMockTableNode = (
@@ -55,25 +45,9 @@ describe("bulk-selection.utils", () => {
children: schemas,
});
- const createMockFlatItem = (
- node: TableNode | SchemaNode | DatabaseNode,
- parent?: string,
- level: number = 0,
- ): FlatItem =>
- ({
- type: node.type,
- label: node.label,
- key: node.key,
- value: node.value,
- children: node.children,
- level,
- parent,
- isExpanded: false,
- }) as FlatItem;
-
describe("isItemSelected", () => {
describe("table selection", () => {
- it("should return 'yes' when table is selected", () => {
+ it("should return 'all' when table is selected", () => {
const table = createMockTableNode(1, "public", 101);
const selection: NodeSelection = {
tables: new Set([101]),
@@ -81,10 +55,10 @@ describe("bulk-selection.utils", () => {
databases: new Set(),
};
- expect(isItemSelected(table, selection)).toBe("yes");
+ expect(isItemSelected(table, selection)).toBe("all");
});
- it("should return 'no' when table is not selected", () => {
+ it("should return 'none' when table is not selected", () => {
const table = createMockTableNode(1, "public", 101);
const selection: NodeSelection = {
tables: new Set([102]),
@@ -92,12 +66,12 @@ describe("bulk-selection.utils", () => {
databases: new Set(),
};
- expect(isItemSelected(table, selection)).toBe("no");
+ expect(isItemSelected(table, selection)).toBe("none");
});
});
describe("schema selection", () => {
- it("should return 'yes' when schema is directly selected", () => {
+ it("should return 'all' when schema is directly selected", () => {
const table1 = createMockTableNode(1, "public", 101);
const table2 = createMockTableNode(1, "public", 102);
const schema = createMockSchemaNode(1, "public", [table1, table2]);
@@ -107,10 +81,10 @@ describe("bulk-selection.utils", () => {
databases: new Set(),
};
- expect(isItemSelected(schema, selection)).toBe("yes");
+ expect(isItemSelected(schema, selection)).toBe("all");
});
- it("should return 'yes' when all tables in schema are selected", () => {
+ it("should return 'all' when all tables in schema are selected", () => {
const table1 = createMockTableNode(1, "public", 101);
const table2 = createMockTableNode(1, "public", 102);
const schema = createMockSchemaNode(1, "public", [table1, table2]);
@@ -120,7 +94,7 @@ describe("bulk-selection.utils", () => {
databases: new Set(),
};
- expect(isItemSelected(schema, selection)).toBe("yes");
+ expect(isItemSelected(schema, selection)).toBe("all");
});
it("should return 'some' when only some tables in schema are selected", () => {
@@ -136,7 +110,7 @@ describe("bulk-selection.utils", () => {
expect(isItemSelected(schema, selection)).toBe("some");
});
- it("should return 'no' when no tables in schema are selected", () => {
+ it("should return 'none' when no tables in schema are selected", () => {
const table1 = createMockTableNode(1, "public", 101);
const table2 = createMockTableNode(1, "public", 102);
const schema = createMockSchemaNode(1, "public", [table1, table2]);
@@ -146,10 +120,10 @@ describe("bulk-selection.utils", () => {
databases: new Set(),
};
- expect(isItemSelected(schema, selection)).toBe("no");
+ expect(isItemSelected(schema, selection)).toBe("none");
});
- it("should return 'no' when schema has no children", () => {
+ it("should return 'none' when schema has no children", () => {
const schema = createMockSchemaNode(1, "public", []);
const selection: NodeSelection = {
tables: new Set(),
@@ -157,12 +131,12 @@ describe("bulk-selection.utils", () => {
databases: new Set(),
};
- expect(isItemSelected(schema, selection)).toBe("no");
+ expect(isItemSelected(schema, selection)).toBe("none");
});
});
describe("database selection", () => {
- it("should return 'yes' when database is directly selected", () => {
+ it("should return 'all' when database is directly selected", () => {
const schema = createMockSchemaNode(1, "public", []);
const database = createMockDatabaseNode(1, [schema]);
const selection: NodeSelection = {
@@ -171,10 +145,10 @@ describe("bulk-selection.utils", () => {
databases: new Set([1]),
};
- expect(isItemSelected(database, selection)).toBe("yes");
+ expect(isItemSelected(database, selection)).toBe("all");
});
- it("should return 'yes' when all schemas in database are selected", () => {
+ it("should return 'all' when all schemas in database are selected", () => {
const table1 = createMockTableNode(1, "public", 101);
const table2 = createMockTableNode(1, "public", 102);
const table3 = createMockTableNode(1, "private", 103);
@@ -187,10 +161,10 @@ describe("bulk-selection.utils", () => {
databases: new Set(),
};
- expect(isItemSelected(database, selection)).toBe("yes");
+ expect(isItemSelected(database, selection)).toBe("all");
});
- it("should return 'yes' when all tables in all schemas are selected", () => {
+ it("should return 'all' when all tables in all schemas are selected", () => {
const table1 = createMockTableNode(1, "public", 101);
const table2 = createMockTableNode(1, "public", 102);
const table3 = createMockTableNode(1, "private", 103);
@@ -203,7 +177,7 @@ describe("bulk-selection.utils", () => {
databases: new Set(),
};
- expect(isItemSelected(database, selection)).toBe("yes");
+ expect(isItemSelected(database, selection)).toBe("all");
});
it("should return 'some' when only some schemas are selected", () => {
@@ -235,7 +209,7 @@ describe("bulk-selection.utils", () => {
expect(isItemSelected(database, selection)).toBe("some");
});
- it("should return 'no' when database has no children", () => {
+ it("should return 'none' when database has no children", () => {
const database = createMockDatabaseNode(1, []);
const selection: NodeSelection = {
tables: new Set(),
@@ -243,125 +217,23 @@ describe("bulk-selection.utils", () => {
databases: new Set(),
};
- expect(isItemSelected(database, selection)).toBe("no");
+ expect(isItemSelected(database, selection)).toBe("none");
});
});
-
- it("should return 'no' when selection is null/undefined", () => {
- const table = createMockTableNode(1, "public", 101);
-
- expect(isItemSelected(table, null as any)).toBe("no");
- });
});
describe("getSchemaId", () => {
- it("should return schema ID for table item", () => {
- const table = createMockTableNode(1, "public", 101);
- const flatItem = createMockFlatItem(table);
-
- expect(getSchemaId(flatItem)).toBe("1:public");
- });
-
- it("should return schema ID for schema item with table children", () => {
+ it("should return schema ID for schema node", () => {
const table1 = createMockTableNode(1, "public", 101);
const schema = createMockSchemaNode(1, "public", [table1]);
- const flatItem = createMockFlatItem(schema);
-
- expect(getSchemaId(flatItem)).toBe("1:public");
- });
-
- it("should return undefined for loading item", () => {
- const loadingItem: FlatItem = {
- isLoading: true,
- type: "table",
- key: "loading",
- level: 0,
- children: [],
- };
-
- expect(getSchemaId(loadingItem)).toBeUndefined();
- });
-
- it("should return undefined for database item", () => {
- const database = createMockDatabaseNode(1, []);
- const flatItem = createMockFlatItem(database);
-
- expect(getSchemaId(flatItem)).toBeUndefined();
- });
-
- it("should return schema ID for schema item with no children", () => {
- const schema = createMockSchemaNode(1, "public", []);
- const flatItem = createMockFlatItem(schema);
-
- expect(getSchemaId(flatItem)).toBe("1:public");
- });
- });
-
- describe("isParentSchemaSelected", () => {
- it("should return true when parent schema is selected", () => {
- const table = createMockTableNode(1, "public", 101);
- const flatItem = createMockFlatItem(table);
- const selectedSchemas = new Set(["1:public"]);
-
- expect(isParentSchemaSelected(flatItem, selectedSchemas)).toBe(true);
- });
-
- it("should return false when parent schema is not selected", () => {
- const table = createMockTableNode(1, "public", 101);
- const flatItem = createMockFlatItem(table);
- const selectedSchemas = new Set(["1:private"]);
- expect(isParentSchemaSelected(flatItem, selectedSchemas)).toBe(false);
+ expect(getSchemaId(schema)).toBe("1:public");
});
- it("should return false for non-table items", () => {
+ it("should return schema ID for schema node with no children", () => {
const schema = createMockSchemaNode(1, "public", []);
- const flatItem = createMockFlatItem(schema);
- const selectedSchemas = new Set(["1:public"]);
- expect(isParentSchemaSelected(flatItem, selectedSchemas)).toBe(false);
- });
- });
-
- describe("getSchemaTables", () => {
- it("should return all tables in a schema", () => {
- const table1 = createMockTableNode(1, "public", 101);
- const table2 = createMockTableNode(1, "public", 102);
- const table3 = createMockTableNode(1, "private", 103);
- const schema = createMockSchemaNode(1, "public", [table1, table2]);
- const allItems = [table1, table2, table3];
-
- const tables = getSchemaTables(createMockFlatItem(schema), allItems);
-
- expect(tables).toHaveLength(2);
- expect(tables.map((t) => t.value.tableId)).toEqual([101, 102]);
- });
-
- it("should return empty array when no tables match schema", () => {
- const table = createMockTableNode(1, "private", 101);
- const schema = createMockSchemaNode(1, "public", []);
- const allItems = [table];
-
- const tables = getSchemaTables(createMockFlatItem(schema), allItems);
-
- expect(tables).toHaveLength(0);
- });
- });
-
- describe("getSchemaTableIds", () => {
- it("should return table IDs for all tables in a schema", () => {
- const table1 = createMockTableNode(1, "public", 101);
- const table2 = createMockTableNode(1, "public", 102);
- const schema = createMockSchemaNode(1, "public", [table1, table2]);
- const flatItems = [
- createMockFlatItem(table1),
- createMockFlatItem(table2),
- createMockFlatItem(schema),
- ];
-
- const tableIds = getSchemaTableIds(createMockFlatItem(schema), flatItems);
-
- expect(tableIds).toEqual([101, 102]);
+ expect(getSchemaId(schema)).toBe("1:public");
});
});
@@ -385,347 +257,6 @@ describe("bulk-selection.utils", () => {
});
});
- describe("getParentSchema", () => {
- it("should find parent schema for a table", () => {
- const table = createMockTableNode(1, "public", 101);
- const schema = createMockSchemaNode(1, "public", [table]);
- const flatItems = [createMockFlatItem(table), createMockFlatItem(schema)];
-
- const parentSchema = getParentSchema(
- createMockFlatItem(table),
- flatItems,
- );
-
- expect(parentSchema).toBeDefined();
- expect(parentSchema?.type).toBe("schema");
- expect((parentSchema?.value as any).schemaName).toBe("public");
- });
-
- it("should return undefined when parent schema not found", () => {
- const table = createMockTableNode(1, "public", 101);
- const schema = createMockSchemaNode(1, "private", []);
- const flatItems = [createMockFlatItem(table), createMockFlatItem(schema)];
-
- const parentSchema = getParentSchema(
- createMockFlatItem(table),
- flatItems,
- );
-
- expect(parentSchema).toBeUndefined();
- });
- });
-
- describe("areTablesSelected", () => {
- it("should return 'all' when all tables are selected", () => {
- const table1 = createMockTableNode(1, "public", 101);
- const table2 = createMockTableNode(1, "public", 102);
- const schema = createMockSchemaNode(1, "public", [table1, table2]);
- const allItems = [table1, table2];
- const selectedItems = new Set([101, 102]);
-
- const result = areTablesSelected(
- createMockFlatItem(schema),
- allItems,
- selectedItems,
- );
-
- expect(result).toBe("all");
- });
-
- it("should return 'some' when some tables are selected", () => {
- const table1 = createMockTableNode(1, "public", 101);
- const table2 = createMockTableNode(1, "public", 102);
- const schema = createMockSchemaNode(1, "public", [table1, table2]);
- const allItems = [table1, table2];
- const selectedItems = new Set([101]);
-
- const result = areTablesSelected(
- createMockFlatItem(schema),
- allItems,
- selectedItems,
- );
-
- expect(result).toBe("some");
- });
-
- it("should return 'none' when no tables are selected", () => {
- const table1 = createMockTableNode(1, "public", 101);
- const table2 = createMockTableNode(1, "public", 102);
- const schema = createMockSchemaNode(1, "public", [table1, table2]);
- const allItems = [table1, table2];
- const selectedItems = new Set<TableId>();
-
- const result = areTablesSelected(
- createMockFlatItem(schema),
- allItems,
- selectedItems,
- );
-
- expect(result).toBe("none");
- });
-
- it("should return 'none' when schema has no tables", () => {
- const schema = createMockSchemaNode(1, "public", []);
- const allItems: any[] = [];
- const selectedItems = new Set([101]);
-
- const result = areTablesSelected(
- createMockFlatItem(schema),
- allItems,
- selectedItems,
- );
-
- expect(result).toBe("none");
- });
- });
-
- describe("getSchemas", () => {
- it("should return all schemas in a database", () => {
- const database = createMockDatabaseNode(1, []);
- const schema1 = createMockSchemaNode(1, "public", []);
- const schema2 = createMockSchemaNode(1, "private", []);
- const schema3 = createMockSchemaNode(2, "public", []);
- const flatItems = [
- createMockFlatItem(database),
- createMockFlatItem(schema1),
- createMockFlatItem(schema2),
- createMockFlatItem(schema3),
- ];
-
- const schemas = getSchemas(createMockFlatItem(database), flatItems);
-
- expect(schemas).toHaveLength(2);
- expect(schemas.map((s) => (s.value as any).schemaName)).toEqual([
- "public",
- "private",
- ]);
- });
- });
-
- describe("getChildSchemas", () => {
- it("should return child schemas of a database", () => {
- const schema1 = createMockSchemaNode(1, "public", []);
- const schema2 = createMockSchemaNode(1, "private", []);
- const database = createMockDatabaseNode(1, [schema1, schema2]);
-
- const schemas = getChildSchemas(database);
-
- expect(schemas).toHaveLength(2);
- expect(schemas).toEqual([schema1, schema2]);
- });
- });
-
- describe("areSchemasSelected", () => {
- it("should return 'all' when all schemas are directly selected", () => {
- const table1 = createMockTableNode(1, "public", 101);
- const table2 = createMockTableNode(1, "private", 102);
- const schema1 = createMockSchemaNode(1, "public", [table1]);
- const schema2 = createMockSchemaNode(1, "private", [table2]);
- const database = createMockDatabaseNode(1, [schema1, schema2]);
- const flatItems = [
- createMockFlatItem(database),
- createMockFlatItem(schema1),
- createMockFlatItem(schema2),
- ];
- const selectedSchemas = new Set(["1:public", "1:private"]);
- const selectedTables = new Set<TableId>();
-
- const result = areSchemasSelected(
- createMockFlatItem(database),
- flatItems,
- selectedSchemas,
- selectedTables,
- );
-
- expect(result).toBe("all");
- });
-
- it("should return 'all' when all tables in all schemas are selected", () => {
- const table1 = createMockTableNode(1, "public", 101);
- const table2 = createMockTableNode(1, "private", 102);
- const schema1 = createMockSchemaNode(1, "public", [table1]);
- const schema2 = createMockSchemaNode(1, "private", [table2]);
- const database = createMockDatabaseNode(1, [schema1, schema2]);
- const flatItems = [
- createMockFlatItem(database),
- createMockFlatItem(schema1),
- createMockFlatItem(schema2),
- ];
- const selectedSchemas = new Set<string>();
- const selectedTables = new Set([101, 102]);
-
- const result = areSchemasSelected(
- createMockFlatItem(database),
- flatItems,
- selectedSchemas,
- selectedTables,
- );
-
- expect(result).toBe("all");
- });
-
- it("should return 'some' when only some schemas are selected", () => {
- const table1 = createMockTableNode(1, "public", 101);
- const table2 = createMockTableNode(1, "private", 102);
- const schema1 = createMockSchemaNode(1, "public", [table1]);
- const schema2 = createMockSchemaNode(1, "private", [table2]);
- const database = createMockDatabaseNode(1, [schema1, schema2]);
- const flatItems = [
- createMockFlatItem(database),
- createMockFlatItem(schema1),
- createMockFlatItem(schema2),
- ];
- const selectedSchemas = new Set(["1:public"]);
- const selectedTables = new Set<TableId>();
-
- const result = areSchemasSelected(
- createMockFlatItem(database),
- flatItems,
- selectedSchemas,
- selectedTables,
- );
-
- expect(result).toBe("some");
- });
-
- it("should return 'none' when no schemas are selected", () => {
- const schema1 = createMockSchemaNode(1, "public", []);
- const schema2 = createMockSchemaNode(1, "private", []);
- const database = createMockDatabaseNode(1, [schema1, schema2]);
- const flatItems = [
- createMockFlatItem(database),
- createMockFlatItem(schema1),
- createMockFlatItem(schema2),
- ];
- const selectedSchemas = new Set<string>();
- const selectedTables = new Set<TableId>();
-
- const result = areSchemasSelected(
- createMockFlatItem(database),
- flatItems,
- selectedSchemas,
- selectedTables,
- );
-
- expect(result).toBe("none");
- });
-
- it("should return 'none' for non-database item", () => {
- const schema = createMockSchemaNode(1, "public", []);
- const flatItems = [createMockFlatItem(schema)];
- const selectedSchemas = new Set<string>();
- const selectedTables = new Set<TableId>();
-
- const result = areSchemasSelected(
- createMockFlatItem(schema),
- flatItems,
- selectedSchemas,
- selectedTables,
- );
-
- expect(result).toBe("none");
- });
- });
-
- describe("noManuallySelectedTables", () => {
- it("should return true when no tables in schema are manually selected", () => {
- const table1 = createMockTableNode(1, "public", 101);
- const table2 = createMockTableNode(1, "public", 102);
- const schema = createMockSchemaNode(1, "public", []);
- const flatItems = [
- createMockFlatItem(schema),
- createMockFlatItem(table1, schema.key),
- createMockFlatItem(table2, schema.key),
- ];
- const selectedTables = new Set<TableId>();
-
- const result = noManuallySelectedTables(
- createMockFlatItem(schema),
- flatItems,
- selectedTables,
- );
-
- expect(result).toBe(true);
- });
-
- it("should return false when some tables in schema are manually selected", () => {
- const table1 = createMockTableNode(1, "public", 101);
- const table2 = createMockTableNode(1, "public", 102);
- const schema = createMockSchemaNode(1, "public", []);
- const flatItems = [
- createMockFlatItem(schema),
- createMockFlatItem(table1, schema.key),
- createMockFlatItem(table2, schema.key),
- ];
- const selectedTables = new Set([101]);
-
- const result = noManuallySelectedTables(
- createMockFlatItem(schema),
- flatItems,
- selectedTables,
- );
-
- expect(result).toBe(false);
- });
-
- it("should return false when schema is undefined", () => {
- const flatItems: FlatItem[] = [];
- const selectedTables = new Set<TableId>();
-
- const result = noManuallySelectedTables(
- undefined,
- flatItems,
- selectedTables,
- );
-
- expect(result).toBe(false);
- });
- });
-
- describe("noManuallySelectedSchemas", () => {
- it("should return true when no schemas in database are manually selected", () => {
- const table1 = createMockTableNode(1, "public", 101);
- const schema1 = createMockSchemaNode(1, "public", [table1]);
- const schema2 = createMockSchemaNode(1, "private", []);
- const database = createMockDatabaseNode(1, []);
- const flatItems = [
- createMockFlatItem(database),
- createMockFlatItem(schema1, database.key),
- createMockFlatItem(schema2, database.key),
- ];
- const selectedSchemas = new Set<string>();
-
- const result = noManuallySelectedSchemas(
- database,
- flatItems,
- selectedSchemas,
- );
-
- expect(result).toBe(true);
- });
-
- it("should return false when some schemas in database are manually selected", () => {
- const table1 = createMockTableNode(1, "public", 101);
- const schema1 = createMockSchemaNode(1, "public", [table1]);
- const schema2 = createMockSchemaNode(1, "private", []);
- const database = createMockDatabaseNode(1, []);
- const flatItems = [
- createMockFlatItem(database),
- createMockFlatItem(schema1, database.key),
- createMockFlatItem(schema2, database.key),
- ];
- const selectedSchemas = new Set(["1:public"]);
-
- const result = noManuallySelectedSchemas(
- database,
- flatItems,
- selectedSchemas,
- );
-
- expect(result).toBe(false);
- });
- });
-
describe("noManuallySelectedDatabaseChildrenTables", () => {
it("should return true when no tables in database schemas are selected", () => {
const table1 = createMockTableNode(1, "public", 101);
@@ -774,7 +305,7 @@ describe("bulk-selection.utils", () => {
databases: new Set([1]),
};
- expect(isItemSelected(database, selection)).toBe("yes");
+ expect(isItemSelected(database, selection)).toBe("all");
});
it("selecting a schema selects all tables in it", () => {
@@ -787,9 +318,9 @@ describe("bulk-selection.utils", () => {
databases: new Set(),
};
- expect(isItemSelected(schema, selection)).toBe("yes");
- expect(isItemSelected(table1, selection)).toBe("no");
- expect(isItemSelected(table2, selection)).toBe("no");
+ expect(isItemSelected(schema, selection)).toBe("all");
+ expect(isItemSelected(table1, selection)).toBe("none");
+ expect(isItemSelected(table2, selection)).toBe("none");
});
it("selecting all tables in a schema selects the schema", () => {
@@ -802,7 +333,7 @@ describe("bulk-selection.utils", () => {
databases: new Set(),
};
- expect(isItemSelected(schema, selection)).toBe("yes");
+ expect(isItemSelected(schema, selection)).toBe("all");
});
it("selecting all schemas in a database selects the database", () => {
@@ -817,7 +348,7 @@ describe("bulk-selection.utils", () => {
databases: new Set(),
};
- expect(isItemSelected(database, selection)).toBe("yes");
+ expect(isItemSelected(database, selection)).toBe("all");
});
it("selecting all tables in a database selects the database", () => {
@@ -833,9 +364,9 @@ describe("bulk-selection.utils", () => {
databases: new Set(),
};
- expect(isItemSelected(database, selection)).toBe("yes");
- expect(isItemSelected(schema1, selection)).toBe("yes");
- expect(isItemSelected(schema2, selection)).toBe("yes");
+ expect(isItemSelected(database, selection)).toBe("all");
+ expect(isItemSelected(schema1, selection)).toBe("all");
+ expect(isItemSelected(schema2, selection)).toBe("all");
});
it("deselecting a database deselects all schemas and tables", () => {
@@ -848,9 +379,9 @@ describe("bulk-selection.utils", () => {
databases: new Set(),
};
- expect(isItemSelected(database, selection)).toBe("no");
- expect(isItemSelected(schema1, selection)).toBe("no");
- expect(isItemSelected(table1, selection)).toBe("no");
+ expect(isItemSelected(database, selection)).toBe("none");
+ expect(isItemSelected(schema1, selection)).toBe("none");
+ expect(isItemSelected(table1, selection)).toBe("none");
});
it("deselecting a schema deselects all tables in it", () => {
@@ -863,9 +394,9 @@ describe("bulk-selection.utils", () => {
databases: new Set(),
};
- expect(isItemSelected(schema, selection)).toBe("no");
- expect(isItemSelected(table1, selection)).toBe("no");
- expect(isItemSelected(table2, selection)).toBe("no");
+ expect(isItemSelected(schema, selection)).toBe("none");
+ expect(isItemSelected(table1, selection)).toBe("none");
+ expect(isItemSelected(table2, selection)).toBe("none");
});
it("deselecting one table in a schema changes schema to 'some'", () => {
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/Results.module.css b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/Results.module.css
deleted file mode 100644
index f3b68fe7741..00000000000
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/Results.module.css
+++ /dev/null
@@ -1,191 +0,0 @@
-.root {
- --owner-column-width: 140px;
- --rows-column-width: 80px;
- --published-column-width: 80px;
-
- height: 100%;
-}
-
-.header {
- display: flex;
- align-items: center;
- padding-left: var(--mantine-spacing-md);
- padding-bottom: var(--mantine-spacing-xs);
- border-bottom: 1px solid var(--mb-color-border);
- font-size: 0.75rem;
- font-weight: 700;
-}
-
-.headerCell {
- color: var(--mb-color-text-primary);
- font-size: rem(12px);
- font-weight: 700;
- align-items: center;
- flex: 0 0 auto;
-}
-
-.results {
- position: relative;
- overflow: auto;
- flex: 1 1 auto;
- min-height: 0;
-}
-
-.item {
- --item-top-border-color: transparent;
-
- position: absolute;
- cursor: pointer;
- border-bottom: 1px solid var(--mb-color-border);
-
- &:focus-visible,
- &.selected {
- outline: 2px solid var(--mb-color-focus);
-
- --item-top-border-color: var(--mb-color-border);
- }
-
- &:hover {
- background-color: var(--mb-color-brand-lighter);
-
- --item-top-border-color: var(--mb-color-border);
- }
-
- &.active {
- color: var(--mb-color-brand);
- background-color: var(--mb-color-brand-light);
-
- --item-top-border-color: var(--mb-color-border);
-
- .icon {
- opacity: 1;
- }
- }
-
- &:last-child {
- border-bottom: none;
- }
-}
-
-.icon {
- opacity: 0.5;
- flex-shrink: 0;
-}
-
-.database,
-.schema,
-.table,
-.field {
- .icon {
- opacity: 1;
- color: var(--mb-color-text-dark);
- }
-}
-
-.checkbox {
- flex-shrink: 0;
- width: 40px;
- max-height: 40px;
- height: 100%;
- display: flex;
- align-items: center;
- justify-content: center;
-}
-
-.checkboxColumn {
- flex: 0 0 rem(40px);
- display: flex;
- align-items: center;
- justify-content: flex-start;
- padding-right: var(--mantine-spacing-sm);
-}
-
-.chevronSlot {
- display: flex;
- align-items: center;
- justify-content: center;
-
- &.hasChildren {
- cursor: pointer;
- }
-}
-
-.chevron {
- transition: transform 100ms ease-in-out;
- opacity: 0.35;
- flex-shrink: 0;
-
- &.expanded {
- transform: rotate(90deg);
- }
-}
-
-.label {
- user-select: none;
- overflow-wrap: anywhere;
- white-space: nowrap;
- overflow-x: hidden;
- text-overflow: ellipsis;
- flex: 1 1 0;
-}
-
-.content {
- flex: 1;
- min-width: 0;
-}
-
-.column {
- color: var(--mb-color-text-light);
- font-size: 0.875rem;
- white-space: nowrap;
- text-overflow: ellipsis;
- overflow: hidden;
- display: flex;
- align-items: center;
- flex: 0 0 auto;
-}
-
-.tableColumn {
- justify-content: flex-start;
-}
-
-.ownerColumn {
- flex-basis: var(--owner-column-width);
-}
-
-.rowsColumn {
- font-variant-numeric: tabular-nums;
- flex-basis: var(--rows-column-width);
-}
-
-.publishedColumn {
- flex-basis: var(--published-column-width);
-}
-
-.hidden {
- opacity: 0;
-}
-
-.visibilityToggle {
- flex-shrink: 0;
-
- &:focus,
- .item:hover &,
- .item:focus &,
- .item.selected &,
- .item.active & {
- opacity: 0.75;
- }
-}
-
-.massVisibilityToggle {
- flex-shrink: 0;
- opacity: 0;
-
- &:focus,
- .item:hover &,
- .item:focus &,
- .item.selected {
- opacity: 0.75;
- }
-}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/Results.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/Results.tsx
deleted file mode 100644
index 90e7dedd246..00000000000
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/Results.tsx
+++ /dev/null
@@ -1,671 +0,0 @@
-import { useVirtualizer } from "@tanstack/react-virtual";
-import cx from "classnames";
-import {
- type KeyboardEvent,
- type MouseEvent,
- useEffect,
- useMemo,
- useRef,
-} from "react";
-import { Link } from "react-router";
-import { useLatest } from "react-use";
-import { t } from "ttag";
-
-import { useListUsersQuery } from "metabase/api";
-import {
- type NumberFormatter,
- useNumberFormatter,
-} from "metabase/common/hooks/use-number-formatter";
-import * as Urls from "metabase/lib/urls";
-import { Box, Checkbox, Flex, Icon, Skeleton, Stack, rem } from "metabase/ui";
-import type { UserId } from "metabase-types/api";
-
-import { useSelection } from "../../../pages/DataModel/contexts/SelectionContext";
-import { TYPE_ICONS } from "../constants";
-import { type FlatItem, type TreePath, isTableNode } from "../types";
-import { hasChildren } from "../utils";
-
-import S from "./Results.module.css";
-
-const VIRTUAL_OVERSCAN = 5;
-const ITEM_MIN_HEIGHT = 40; // items can vary in size because of text wrapping
-const INDENT_OFFSET = 18;
-
-interface Props {
- items: FlatItem[];
- path: TreePath;
- selectedIndex?: number;
- toggle?: (key: string, value?: boolean) => void;
- onItemClick?: (path: TreePath) => void;
- onSelectedIndexChange?: (index: number) => void;
- onItemToggle?: (item: FlatItem) => void;
- onRangeSelect?: (items: FlatItem[], targetItem: FlatItem) => void;
-}
-
-export function TablePickerResults({
- items,
- path,
- selectedIndex,
- toggle,
- onItemClick,
- onSelectedIndexChange,
- onItemToggle,
- onRangeSelect,
-}: Props) {
- const ref = useRef<HTMLDivElement>(null);
- const { selectedItemsCount } = useSelection();
- const lastSelectedTableIndex = useRef<number | null>(null);
-
- const virtual = useVirtualizer({
- count: items.length,
- getScrollElement: () => ref.current,
- overscan: VIRTUAL_OVERSCAN,
- estimateSize: () => ITEM_MIN_HEIGHT,
- measureElement: (element) =>
- element?.getBoundingClientRect().height ?? ITEM_MIN_HEIGHT,
- });
-
- const latestItems = useLatest(items);
- const latestVirtual = useLatest(virtual);
-
- const virtualItems = virtual.getVirtualItems();
-
- const { data: usersData } = useListUsersQuery();
- const ownerNameById = useMemo(() => {
- const users = usersData?.data ?? [];
- return new Map<UserId, string>(
- users.map((user) => [user.id, user.common_name]),
- );
- }, [usersData]);
-
- useEffect(
- function scrollActiveTableIntoView() {
- if (path.tableId === undefined) {
- return;
- }
- const index = latestItems.current.findIndex(
- (item) => isTableNode(item) && item.value?.tableId === path.tableId,
- );
- if (index === -1) {
- return;
- }
-
- const visibleIndices = latestVirtual.current
- .getVirtualItems()
- .map((virtualItem) => virtualItem.index);
- if (visibleIndices.includes(index)) {
- return;
- }
-
- latestVirtual.current.scrollToIndex(index, {
- align: "start",
- behavior: "auto",
- });
- },
- [path.tableId, latestItems, latestVirtual],
- );
-
- useEffect(() => {
- // sync the selected index by focusing the corresponding item,
- // but only when the user is not currently typing in the search input
- if (document.activeElement?.tagName !== "INPUT") {
- document
- .querySelector<HTMLAnchorElement>(`[data-index='${selectedIndex}']`)
- ?.focus();
- }
- }, [selectedIndex]);
-
- // reset last selected table when there are no selected items
- useEffect(() => {
- if (selectedItemsCount === 0) {
- lastSelectedTableIndex.current = null;
- }
- }, [selectedItemsCount]);
-
- const handleCheckboxToggle = (
- item: FlatItem,
- itemIndex: number,
- options?: { isShiftPressed?: boolean },
- ) => {
- if (!onItemToggle) {
- return;
- }
-
- const isShiftPressed = Boolean(options?.isShiftPressed);
- const isTable = isTableNode(item);
- const hasRangeAnchor =
- lastSelectedTableIndex.current != null && onRangeSelect != null;
- const isRangeSelection = isShiftPressed && isTable && hasRangeAnchor;
-
- if (isRangeSelection) {
- if (!lastSelectedTableIndex.current) {
- return;
- }
-
- const start = Math.min(lastSelectedTableIndex.current, itemIndex);
- const end = Math.max(lastSelectedTableIndex.current, itemIndex);
- const rangeItems = items.slice(start, end + 1).filter((rangeItem) => {
- return !rangeItem.disabled && !rangeItem.isLoading;
- });
-
- if (rangeItems.length > 0) {
- onRangeSelect?.(rangeItems, item);
- lastSelectedTableIndex.current = itemIndex;
- return;
- }
- }
-
- onItemToggle(item);
- lastSelectedTableIndex.current = isTable ? itemIndex : null;
- };
-
- return (
- <Stack className={S.root} gap={0}>
- <Flex className={S.header} gap="sm" justify="flex-end">
- <Box className={cx(S.headerCell, S.ownerColumn)}>{t`Owner`}</Box>
- <Box className={cx(S.headerCell, S.rowsColumn)}>{t`Rows`}</Box>
- <Box
- className={cx(S.headerCell, S.publishedColumn)}
- >{t`Published`}</Box>
- </Flex>
- <Box ref={ref} className={S.results}>
- <Box style={{ height: virtual.getTotalSize() }}>
- {virtualItems.map(({ start, index }) => {
- const item = items[index];
- const parentIndex = items.findIndex(
- (item) => item.key === item.parent,
- );
-
- return (
- <ResultsItem
- key={item.key}
- item={item}
- parentIndex={parentIndex}
- path={path}
- start={start}
- index={index}
- selectedIndex={selectedIndex}
- toggle={toggle}
- onItemClick={onItemClick}
- onSelectedIndexChange={onSelectedIndexChange}
- onCheckboxToggle={handleCheckboxToggle}
- rootRef={ref}
- ownerNameById={ownerNameById}
- />
- );
- })}
- </Box>
- </Box>
- </Stack>
- );
-}
-
-function ElementCheckbox({
- item,
- index,
- disabled = false,
- onCheckboxToggle,
-}: {
- item: FlatItem;
- index: number;
- onCheckboxToggle?: (
- item: FlatItem,
- index: number,
- options?: { isShiftPressed?: boolean },
- ) => void;
- disabled?: boolean;
-}) {
- if (item.isLoading) {
- return null;
- }
-
- const indeterminate = item.isSelected === "some";
-
- const { isSelected } = item;
-
- return (
- <Checkbox
- size="sm"
- checked={isSelected !== "no"}
- className={S.checkbox}
- disabled={disabled}
- onClick={(event) => {
- event.stopPropagation();
- if (disabled) {
- return;
- }
- onCheckboxToggle?.(item, index, {
- isShiftPressed: Boolean(
- (event.nativeEvent as { shiftKey?: boolean }).shiftKey,
- ),
- });
- }}
- wrapperProps={{
- onClick(event) {
- event.preventDefault();
- event.stopPropagation();
-
- if ((event.target as HTMLElement).tagName.toLowerCase() === "input") {
- // it's already handled in onClick
- return;
- }
-
- if (disabled) {
- return;
- }
-
- onCheckboxToggle?.(item, index, {
- isShiftPressed: event.shiftKey,
- });
- },
- }}
- onChange={() => {}}
- indeterminate={indeterminate}
- />
- );
-}
-
-function Loading() {
- const width = useMemo(() => 100 + Math.random() * 100, []);
-
- return (
- <Skeleton
- data-testid="loading-placeholder"
- height={rem(16)}
- width={width}
- radius="sm"
- />
- );
-}
-
-interface ResultsItemProps {
- item: FlatItem;
- path: TreePath;
- parentIndex: number;
- start: number;
- index: number;
- selectedIndex?: number;
- toggle?: (key: string, value?: boolean) => void;
- onItemClick?: (path: TreePath) => void;
- onSelectedIndexChange?: (index: number) => void;
- onCheckboxToggle?: (
- item: FlatItem,
- index: number,
- options?: { isShiftPressed?: boolean },
- ) => void;
- rootRef: React.RefObject<HTMLDivElement>;
- ownerNameById: Map<UserId, string>;
-}
-
-function isDatabaseActive(
- item: FlatItem,
- path: TreePath,
- selectedItemsCount: number,
-): boolean {
- return (
- selectedItemsCount === 0 &&
- item.type === "database" &&
- item.value?.databaseId === path.databaseId &&
- path.tableId == null &&
- (path.schemaName == null || item.children.length === 1)
- );
-}
-
-function isSchemaActive(
- item: FlatItem,
- path: TreePath,
- selectedItemsCount: number,
-): boolean {
- return (
- selectedItemsCount === 0 &&
- item.type === "schema" &&
- item.value?.databaseId === path.databaseId &&
- item.value?.schemaName === path.schemaName &&
- path.tableId == null
- );
-}
-
-function isTableActive(
- item: FlatItem,
- path: TreePath,
- selectedItemsCount: number,
-): boolean {
- return (
- selectedItemsCount === 0 &&
- isTableNode(item) &&
- item.value?.tableId === path.tableId
- );
-}
-
-function isItemActive(
- item: FlatItem,
- path: TreePath,
- selectedItemsCount: number,
-): boolean {
- return (
- isDatabaseActive(item, path, selectedItemsCount) ||
- isSchemaActive(item, path, selectedItemsCount) ||
- isTableActive(item, path, selectedItemsCount)
- );
-}
-
-const ResultsItem = ({
- item,
- path,
- start,
- index,
- selectedIndex,
- parentIndex,
- toggle,
- onItemClick,
- onSelectedIndexChange,
- onCheckboxToggle,
- rootRef,
- ownerNameById,
-}: ResultsItemProps) => {
- const { selectedItemsCount } = useSelection();
- const { value, label, type, isExpanded, isLoading, key, level, disabled } =
- item;
- const formatNumber = useNumberFormatter({ maximumFractionDigits: 0 });
- const ownerDisplay = getOwnerDisplay(item, ownerNameById);
- const expectedRowsDisplay = getExpectedRowsDisplay(item, formatNumber);
- const publishedDisplay = getPublishedDisplay(item);
-
- const isActive = isItemActive(item, path, selectedItemsCount);
- const indent = level * INDENT_OFFSET;
- const itemHasChildren = hasChildren(type);
-
- const handleItemSelect = (open?: boolean, event?: React.MouseEvent) => {
- if (disabled) {
- return;
- }
-
- // In multi-select mode, prevent navigation and allow toggling for items with children
- if (selectedItemsCount > 0) {
- if (itemHasChildren) {
- // Toggle expansion for items with children
- if (open !== undefined) {
- toggle?.(key, open);
- } else {
- toggle?.(key);
- }
- }
- // Prevent Link navigation in multi-select mode
- if (event) {
- event.preventDefault();
- }
- return;
- }
-
- // In single-select mode:
- // If the item is already active, toggle its expansion state
- // Otherwise, navigate to make it active
- if (isActive && itemHasChildren) {
- // Second click on active item: toggle expansion
- if (open !== undefined) {
- toggle?.(key, open);
- } else {
- toggle?.(key);
- }
-
- // Prevent Link navigation when toggling
- if (event) {
- event.preventDefault();
- }
- } else {
- // First click or clicking on a field: navigate
- if (open !== undefined) {
- toggle?.(key, open);
- }
-
- if (value) {
- // Expand collapsed items when navigating to them
- if (!isExpanded && itemHasChildren) {
- toggle?.(key, true);
- }
-
- onItemClick?.(value);
- }
- }
- };
-
- function itemByIndex(index: number) {
- return rootRef.current?.querySelector<HTMLAnchorElement>(
- `[data-index='${index}']`,
- );
- }
-
- const handleKeyDown = (event: KeyboardEvent<HTMLElement>) => {
- if (typeof selectedIndex === "number") {
- // If there is a selected index externally
- // don't handle the key events
- return;
- }
- if (event.code === "ArrowDown") {
- // focus the next item in the list
- // does not wrap at around
- itemByIndex(index + 1)?.focus();
- event.preventDefault();
- }
- if (event.code === "ArrowUp") {
- // focus the previous item in the list
- // does not wrap at around
- itemByIndex(index - 1)?.focus();
- event.preventDefault();
- }
- if (event.code === "ArrowLeft") {
- if (isExpanded) {
- // when expanded, close the item
- toggle?.(key, false);
- } else {
- // when already closed, go to parent node
- itemByIndex(parentIndex)?.focus();
- }
- event.preventDefault();
- }
- if (event.code === "ArrowRight") {
- if (!isExpanded) {
- // expand the item
- handleItemSelect(true);
- } else {
- // go to first child
- itemByIndex(index + 1)?.focus();
- }
- event.preventDefault();
- }
-
- if (!disabled && (event.code === "Space" || event.code === "Enter")) {
- // toggle the current item
- handleItemSelect();
- event.preventDefault();
- }
- };
-
- // Dedicated toggle target: always toggles expansion without navigating
- // regardless of whether the item is currently active.
- const handleChevronClick = (e: MouseEvent<HTMLDivElement>) => {
- if (disabled || !itemHasChildren) {
- return;
- }
- e.preventDefault();
- e.stopPropagation();
- toggle?.(key);
- };
-
- return (
- <Flex
- component={Link}
- key={key}
- aria-selected={isActive}
- align="center"
- justify="flex-start"
- gap={0}
- w="100%"
- mih={ITEM_MIN_HEIGHT}
- className={cx(S.item, S[type], {
- [S.active]: isActive,
- [S.selected]: selectedIndex === index,
- })}
- data-index={index}
- data-open={isExpanded}
- tabIndex={disabled ? -1 : 0}
- style={{
- transform: `translateY(${start}px)`,
- pointerEvents: disabled ? "none" : undefined,
- }}
- to={Urls.dataStudioData({
- databaseId: value?.databaseId,
- schemaName:
- type === "schema" || isTableNode(item)
- ? item.value?.schemaName
- : undefined,
- tableId: isTableNode(item) ? item.value?.tableId : undefined,
- })}
- data-testid="tree-item"
- data-type={type}
- onKeyDown={handleKeyDown}
- onClick={(e) => {
- handleItemSelect(undefined, e);
- }}
- onFocus={() => onSelectedIndexChange?.(index)}
- >
- <Box className={S.checkboxColumn}>
- <ElementCheckbox
- item={item}
- index={index}
- disabled={disabled}
- onCheckboxToggle={onCheckboxToggle}
- />
- </Box>
-
- <Flex
- align="center"
- py="xs"
- pl={indent}
- gap="sm"
- flex={1}
- style={{ overflow: "hidden" }}
- >
- <Flex align="flex-start" gap="xs" className={S.content}>
- <Flex align="center" gap="xs">
- <Box
- className={cx(S.chevronSlot, {
- [S.hasChildren]: itemHasChildren,
- })}
- w={INDENT_OFFSET}
- aria-expanded={Boolean(isExpanded)}
- onClick={handleChevronClick}
- >
- {itemHasChildren && (
- <Icon
- name="chevronright"
- size={16}
- color="var(--mb-color-text-light)"
- className={cx(S.chevron, {
- [S.expanded]: isExpanded,
- })}
- />
- )}
- </Box>
-
- <Icon name={TYPE_ICONS[type]} className={S.icon} />
- </Flex>
-
- {isLoading ? (
- <Loading />
- ) : (
- <Box
- className={S.label}
- c={
- isTableNode(item) &&
- item.table &&
- item.table.visibility_type != null &&
- !isActive
- ? "text-secondary"
- : undefined
- }
- data-testid="tree-item-label"
- pl="sm"
- >
- {label}
- </Box>
- )}
- </Flex>
-
- {isTableNode(item) && (
- <>
- <Box
- className={cx(S.column, S.ownerColumn)}
- data-testid="table-owner"
- >
- {ownerDisplay}
- </Box>
-
- <Box
- className={cx(S.column, S.rowsColumn)}
- data-testid="table-expected-rows"
- >
- {expectedRowsDisplay}
- </Box>
-
- <Box
- className={cx(S.column, S.publishedColumn)}
- pl="md"
- data-testid="table-published"
- >
- {publishedDisplay}
- </Box>
- </>
- )}
- </Flex>
- </Flex>
- );
-};
-
-function getOwnerDisplay(
- item: FlatItem,
- ownerNameById: Map<UserId, string>,
-): string {
- if (!isTableNode(item) || item.isLoading || !item.table) {
- return "";
- }
-
- const ownerId = item.table.owner_user_id;
- if (ownerId != null && ownerNameById.has(ownerId)) {
- return ownerNameById.get(ownerId) ?? "";
- }
-
- if (item.table.owner_email) {
- return item.table.owner_email;
- }
-
- return "";
-}
-
-function getExpectedRowsDisplay(
- item: FlatItem,
- formatNumber: NumberFormatter,
-): string | null {
- if (!isTableNode(item) || item.isLoading || !item.table) {
- return null;
- }
-
- const expectedRows = item.table.estimated_row_count;
-
- if (!expectedRows) {
- return null;
- }
-
- const formatted = formatNumber(expectedRows);
- return formatted;
-}
-
-function getPublishedDisplay(item: FlatItem): React.ReactNode {
- if (!isTableNode(item) || item.isLoading || !item.table) {
- return null;
- }
-
- return item.table.is_published ? (
- <Icon name="verified_round" aria-label={t`Published`} />
- ) : null;
-}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/SearchNew.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/SearchNew.tsx
index a40213fac76..1406771955a 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/SearchNew.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/SearchNew.tsx
@@ -9,28 +9,24 @@ import type { Table } from "metabase-types/api";
import { useSelection } from "../../../pages/DataModel/contexts/SelectionContext";
import type { RouteParams } from "../../../pages/DataModel/types";
-import {
- toggleDatabaseSelection,
- toggleSchemaSelection,
-} from "../bulk-selection.utils";
import { useExpandedState } from "../hooks";
import type {
DatabaseNode,
FilterState,
- FlatItem,
RootNode,
SchemaNode,
TableNode,
+ TreePath,
} from "../types";
-import { isDatabaseItem, isSchemaItem, isTableNode } from "../types";
-import { flatten, rootNode, toKey } from "../utils";
+import { rootNode, toKey } from "../utils";
-import { TablePickerResults } from "./Results";
+import { TablePickerTreeTable } from "./TablePickerTreeTable";
interface SearchNewProps {
query: string;
params: RouteParams;
filters: FilterState;
+ onChange?: (path: TreePath) => void;
}
function buildResultTree(tables: Table[]): RootNode {
@@ -94,14 +90,13 @@ function buildResultTree(tables: Table[]): RootNode {
return root;
}
-export function SearchNew({ query, params, filters }: SearchNewProps) {
- const {
- selectedTables,
- setSelectedTables,
- selectedSchemas,
- selectedDatabases,
- resetSelection,
- } = useSelection();
+export function SearchNew({
+ query,
+ params,
+ filters,
+ onChange,
+}: SearchNewProps) {
+ const { resetSelection } = useSelection();
const routeParams = parseRouteParams(params);
const { data: tables, isLoading: isLoadingTables } = useListTablesQuery({
term: query,
@@ -120,10 +115,10 @@ export function SearchNew({ query, params, filters }: SearchNewProps) {
});
const { data: databases, isLoading: isLoadingDatabases } =
useListDatabasesQuery({ include_editable_data_model: true });
- const { isExpanded: getIsExpanded, toggle } = useExpandedState(
- {}, // we expand all nodes, so need to pass path to expand specific branch
+ const { isExpanded, toggle } = useExpandedState(
+ {},
{
- defaultClosed: false,
+ defaultExpanded: true,
},
);
@@ -147,63 +142,9 @@ export function SearchNew({ query, params, filters }: SearchNewProps) {
[filteredTables],
);
- // clear the selection when tables changes, to make sure that bulk operations
- // are performed on the intended tables
useEffect(() => {
resetSelection();
- }, [tables, resetSelection]);
-
- const flatItems = flatten(resultTree, {
- isExpanded: getIsExpanded,
- addLoadingNodes: false,
- canFlattenSingleSchema: true,
- selection: {
- tables: selectedTables,
- schemas: selectedSchemas,
- databases: selectedDatabases,
- },
- });
-
- const handleItemToggle = (item: FlatItem) => {
- const selection = {
- tables: selectedTables,
- schemas: selectedSchemas,
- databases: selectedDatabases,
- };
-
- if (isDatabaseItem(item)) {
- setSelectedTables(toggleDatabaseSelection(item, selection).tables);
- }
-
- if (isSchemaItem(item)) {
- setSelectedTables(toggleSchemaSelection(item, selection).tables);
- }
- if (isTableNode(item)) {
- setSelectedTables((prev) => {
- const newSet = new Set(prev);
- if (newSet.has(item.value.tableId)) {
- newSet.delete(item.value.tableId);
- } else {
- newSet.add(item.value.tableId);
- }
- return newSet;
- });
- }
- };
-
- const handleRangeSelect = (items: FlatItem[]) => {
- const tableItems = items.filter((item) => isTableNode(item) && item.table);
-
- setSelectedTables((prev) => {
- const newSet = new Set(prev);
- tableItems.forEach((item) => {
- if (isTableNode(item) && item.table) {
- newSet.add(item.table.id);
- }
- });
- return newSet;
- });
- };
+ }, [query, filters, resetSelection]);
if (isLoading) {
return (
@@ -222,12 +163,12 @@ export function SearchNew({ query, params, filters }: SearchNewProps) {
}
return (
- <TablePickerResults
- items={flatItems}
+ <TablePickerTreeTable
+ tree={resultTree}
path={routeParams}
- onItemToggle={handleItemToggle}
- toggle={toggle}
- onRangeSelect={handleRangeSelect}
+ isExpanded={isExpanded}
+ onToggle={toggle}
+ onChange={onChange}
/>
);
}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/TablePicker.module.css b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/TablePicker.module.css
new file mode 100644
index 00000000000..ee28f3049a8
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/TablePicker.module.css
@@ -0,0 +1,3 @@
+.treeContainer {
+ overflow: hidden;
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/TablePicker.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/TablePicker.tsx
index 63395404b8f..3ac7da4438e 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/TablePicker.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/TablePicker.tsx
@@ -24,6 +24,7 @@ import { getFiltersCount } from "../utils";
import { FilterPopover } from "./FilterPopover";
import { SearchNew } from "./SearchNew";
+import S from "./TablePicker.module.css";
import { Tree } from "./Tree";
interface TablePickerProps {
@@ -71,7 +72,7 @@ export function TablePicker({
className={className}
style={{ overflow: "hidden" }}
>
- <Group gap="sm" p={0}>
+ <Group gap="sm">
<Input
flex="1"
leftSection={<Icon name="search" />}
@@ -136,17 +137,24 @@ export function TablePicker({
</Popover>
</Group>
- <Card mih={0} flex="1 1 auto" withBorder px={0} pb={0}>
- {deferredQuery === "" && filtersCount === 0 ? (
- <Tree
- path={path}
- onChange={onChange}
- setOnUpdateCallback={setOnUpdateCallback}
- />
- ) : (
- <SearchNew query={deferredQuery} params={params} filters={filters} />
- )}
- </Card>
+ <Box mih={0} flex="0 1 auto" display="flex" className={S.treeContainer}>
+ <Card withBorder p={0} flex={1} mih={0} display="flex">
+ {deferredQuery === "" && filtersCount === 0 ? (
+ <Tree
+ path={path}
+ onChange={onChange}
+ setOnUpdateCallback={setOnUpdateCallback}
+ />
+ ) : (
+ <SearchNew
+ query={deferredQuery}
+ params={params}
+ filters={filters}
+ onChange={onChange}
+ />
+ )}
+ </Card>
+ </Box>
</Stack>
);
}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/TablePicker.unit.spec.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/TablePicker.unit.spec.tsx
index 8c8043274c7..73791c2cdf9 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/TablePicker.unit.spec.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/TablePicker.unit.spec.tsx
@@ -31,8 +31,7 @@ function nextId() {
}
beforeEach(() => {
- // so the virtual list renders correctly in the tests
- mockGetBoundingClientRect();
+ mockGetBoundingClientRect({ height: 40, width: 800 });
});
afterEach(() => {
@@ -299,52 +298,85 @@ describe("TablePicker", () => {
await userEvent.click(await screen.findByRole("textbox"));
- // focus the first item - need to tab twice to skip the filter button
+ // tab to the tree container (skips filter button)
await userEvent.keyboard("{Tab}");
await userEvent.keyboard("{Tab}");
- expect(item(DATABASE_WITH_SINGLE_SCHEMA)).toHaveFocus();
+ expect(screen.getByRole("treegrid")).toHaveFocus();
- // arrow down moves focus down
+ // first arrow down activates the first row
await userEvent.keyboard("{ArrowDown}");
- expect(item(DATABASE_WITH_MULTIPLE_SCHEMAS)).toHaveFocus();
+ expect(item(DATABASE_WITH_SINGLE_SCHEMA)).toHaveAttribute(
+ "data-keyboard-active",
+ "true",
+ );
- // arrow up moves focus up
+ // arrow down moves active indicator down
+ await userEvent.keyboard("{ArrowDown}");
+ expect(item(DATABASE_WITH_MULTIPLE_SCHEMAS)).toHaveAttribute(
+ "data-keyboard-active",
+ "true",
+ );
+ expect(item(DATABASE_WITH_SINGLE_SCHEMA)).not.toHaveAttribute(
+ "data-keyboard-active",
+ );
+
+ // arrow up moves active indicator up
await userEvent.keyboard("{ArrowUp}");
- expect(item(DATABASE_WITH_SINGLE_SCHEMA)).toHaveFocus();
+ expect(item(DATABASE_WITH_SINGLE_SCHEMA)).toHaveAttribute(
+ "data-keyboard-active",
+ "true",
+ );
// right arrow opens the node (auto-expands since single schema)
await userEvent.keyboard("{ArrowRight}");
- expect(item(DATABASE_WITH_SINGLE_SCHEMA)?.dataset.open).toBe("true");
+ expect(item(DATABASE_WITH_SINGLE_SCHEMA)).toHaveAttribute(
+ "aria-expanded",
+ "true",
+ );
- // arrow down moves focus down to first table (QUU)
+ // arrow down moves to first table (QUU)
await userEvent.keyboard("{ArrowDown}");
- expect(item(QUU)).toHaveFocus();
+ expect(item(QUU)).toHaveAttribute("data-keyboard-active", "true");
// arrow down again to move to next table (QUX)
await userEvent.keyboard("{ArrowDown}");
- expect(item(QUX)).toHaveFocus();
+ expect(item(QUX)).toHaveAttribute("data-keyboard-active", "true");
// arrow up returns to first table
await userEvent.keyboard("{ArrowUp}");
- expect(item(QUU)).toHaveFocus();
+ expect(item(QUU)).toHaveAttribute("data-keyboard-active", "true");
// arrow up again moves to parent database
await userEvent.keyboard("{ArrowUp}");
- expect(item(DATABASE_WITH_SINGLE_SCHEMA)).toHaveFocus();
+ expect(item(DATABASE_WITH_SINGLE_SCHEMA)).toHaveAttribute(
+ "data-keyboard-active",
+ "true",
+ );
// left arrow closes the node
await userEvent.keyboard("{ArrowLeft}");
- expect(item(DATABASE_WITH_SINGLE_SCHEMA)?.dataset.open).toBe(undefined);
+ await waitFor(() => {
+ expect(item(DATABASE_WITH_SINGLE_SCHEMA)).toHaveAttribute(
+ "aria-expanded",
+ "false",
+ );
+ });
// space toggles the node
await userEvent.keyboard(" ");
- expect(item(DATABASE_WITH_SINGLE_SCHEMA)?.dataset.open).toBe("true");
+ expect(item(DATABASE_WITH_SINGLE_SCHEMA)).toHaveAttribute(
+ "aria-expanded",
+ "true",
+ );
- // space toggles the node
+ // space toggles the node again
await userEvent.keyboard(" ");
- expect(item(DATABASE_WITH_SINGLE_SCHEMA)?.dataset.open).toBe(undefined);
+ expect(item(DATABASE_WITH_SINGLE_SCHEMA)).toHaveAttribute(
+ "aria-expanded",
+ "false",
+ );
- // enter selects the node
+ // enter selects the node (triggers onChange)
await userEvent.keyboard("{Enter}");
expect(onChange).toHaveBeenCalledWith({
databaseId: DATABASE_WITH_SINGLE_SCHEMA.id,
@@ -494,8 +526,12 @@ function item(input: string | { display_name?: string; name: string } | null) {
const name =
typeof input === "string" ? input : (input.display_name ?? input.name);
- return (screen.queryByText(name)?.parentNode?.parentNode?.parentNode ??
- null) as HTMLAnchorElement | null;
+ const textElement = screen.queryByText(name);
+ if (!textElement) {
+ return null;
+ }
+ return (textElement.closest('[data-testid="tree-item"]') ??
+ null) as HTMLElement | null;
}
async function clickItem(
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/TablePickerTreeTable.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/TablePickerTreeTable.tsx
new file mode 100644
index 00000000000..974ba33005c
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/TablePickerTreeTable.tsx
@@ -0,0 +1,531 @@
+import type { ExpandedState, OnChangeFn, Row } from "@tanstack/react-table";
+import {
+ type MouseEvent,
+ useCallback,
+ useEffect,
+ useMemo,
+ useRef,
+} from "react";
+import { t } from "ttag";
+
+import { useListUsersQuery } from "metabase/api";
+import { useNumberFormatter } from "metabase/common/hooks/use-number-formatter";
+import type { SelectionState, TreeTableColumnDef } from "metabase/ui";
+import {
+ Box,
+ EntityNameCell,
+ Icon,
+ TreeTable,
+ useTreeTableInstance,
+} from "metabase/ui";
+import type { TableId, UserId } from "metabase-types/api";
+
+import { useSelection } from "../../../pages/DataModel/contexts/SelectionContext";
+import {
+ type NodeSelection,
+ getSchemaId,
+ isItemSelected,
+ toggleDatabaseSelection,
+ toggleSchemaSelection,
+} from "../bulk-selection.utils";
+import { TYPE_ICONS } from "../constants";
+import type {
+ ChangeOptions,
+ RootNode,
+ TablePickerTreeNode,
+ TreePath,
+} from "../types";
+import {
+ getDatabases,
+ getSchemas,
+ getTables,
+ nodeToTreePath,
+ transformToTreeTableFormat,
+} from "../utils";
+
+const NUMBER_FORMAT_OPTIONS = { maximumFractionDigits: 0 };
+
+interface Props {
+ tree: RootNode;
+ path: TreePath;
+ isExpanded: (key: string) => boolean;
+ onToggle: (key: string, value?: boolean) => void;
+ onChange?: (path: TreePath, options?: ChangeOptions) => void;
+ reload?: (path: TreePath) => void;
+}
+
+export function TablePickerTreeTable({
+ tree,
+ path,
+ isExpanded,
+ onToggle,
+ onChange,
+ reload,
+}: Props) {
+ const {
+ selectedTables,
+ setSelectedTables,
+ selectedSchemas,
+ setSelectedSchemas,
+ selectedDatabases,
+ setSelectedDatabases,
+ selectedItemsCount,
+ } = useSelection();
+
+ const formatNumber = useNumberFormatter(NUMBER_FORMAT_OPTIONS);
+ const lastSelectedTableIndex = useRef<number | null>(null);
+ const instanceRef = useRef<ReturnType<
+ typeof useTreeTableInstance<TablePickerTreeNode>
+ > | null>(null);
+
+ const { data: usersData } = useListUsersQuery();
+ const ownerNameById = useMemo(() => {
+ const users = usersData?.data ?? [];
+ return new Map<UserId, string>(
+ users.map((user) => [user.id, user.common_name]),
+ );
+ }, [usersData]);
+
+ const treeData = useMemo(() => transformToTreeTableFormat(tree), [tree]);
+
+ const nodeKeyToId = useMemo(() => {
+ const map = new Map<string, string>();
+ const traverse = (nodes: TablePickerTreeNode[]) => {
+ for (const node of nodes) {
+ map.set(node.nodeKey, node.id);
+ if (node.children) {
+ traverse(node.children);
+ }
+ }
+ };
+ traverse(treeData);
+ return map;
+ }, [treeData]);
+
+ const nodeKeyToOriginal = useMemo(() => {
+ return new Map(
+ [...getDatabases(tree), ...getSchemas(tree), ...getTables(tree)].map(
+ (n) => [n.key, n],
+ ),
+ );
+ }, [tree]);
+
+ const expandedIds = useMemo(() => {
+ const ids = new Set<string>();
+ for (const [key, id] of nodeKeyToId) {
+ if (isExpanded(key)) {
+ ids.add(id);
+ }
+ }
+ return ids;
+ }, [nodeKeyToId, isExpanded]);
+
+ const selectionStateByKey = useMemo(() => {
+ const map = new Map<string, SelectionState>();
+ const selection: NodeSelection = {
+ tables: selectedTables,
+ schemas: selectedSchemas,
+ databases: selectedDatabases,
+ };
+
+ for (const [key, originalNode] of nodeKeyToOriginal) {
+ map.set(key, isItemSelected(originalNode, selection));
+ }
+ return map;
+ }, [nodeKeyToOriginal, selectedTables, selectedSchemas, selectedDatabases]);
+
+ const handleExpandedChange = useCallback(
+ (newExpandedIds: Set<string>) => {
+ for (const [key, id] of nodeKeyToId) {
+ const wasExpanded = isExpanded(key);
+ const isNowExpanded = newExpandedIds.has(id);
+
+ if (wasExpanded && !isNowExpanded) {
+ onToggle(key, false);
+ } else if (!wasExpanded && isNowExpanded) {
+ onToggle(key, true);
+ }
+ }
+ },
+ [nodeKeyToId, isExpanded, onToggle],
+ );
+
+ const getSelectionState = useCallback(
+ (row: Row<TablePickerTreeNode>): SelectionState => {
+ return selectionStateByKey.get(row.original.nodeKey) ?? "none";
+ },
+ [selectionStateByKey],
+ );
+
+ const handleCheckboxToggle = useCallback(
+ (row: Row<TablePickerTreeNode>, index: number, isShiftPressed: boolean) => {
+ const selection: NodeSelection = {
+ tables: selectedTables,
+ schemas: selectedSchemas,
+ databases: selectedDatabases,
+ };
+
+ const isTable = row.original.type === "table";
+ const lastIndex = lastSelectedTableIndex.current;
+
+ if (isShiftPressed && isTable && lastIndex != null) {
+ const rows = instanceRef.current?.rows ?? [];
+ const start = Math.min(lastIndex, index);
+ const end = Math.max(lastIndex, index);
+ const rangeRows = rows
+ .slice(start, end + 1)
+ .filter((r) => !r.original.isDisabled && r.original.type === "table");
+
+ const tableIds = rangeRows
+ .map((r) => r.original.tableId)
+ .filter((id): id is TableId => id != null);
+
+ if (tableIds.length > 0) {
+ setSelectedTables((prev) => {
+ const newSet = new Set(prev);
+ tableIds.forEach((id) => newSet.add(id));
+ return newSet;
+ });
+ lastSelectedTableIndex.current = index;
+
+ if (row.original.tableId != null) {
+ onChange?.(nodeToTreePath(row.original));
+ }
+ return;
+ }
+ }
+
+ if (row.original.type === "table") {
+ const tableId = row.original.tableId;
+ if (tableId == null) {
+ return;
+ }
+
+ setSelectedTables((prev) => {
+ const newSet = new Set(prev);
+ newSet.has(tableId) ? newSet.delete(tableId) : newSet.add(tableId);
+ return newSet;
+ });
+ lastSelectedTableIndex.current = index;
+
+ onChange?.(nodeToTreePath(row.original));
+ } else if (row.original.type === "database") {
+ const originalNode = nodeKeyToOriginal.get(row.original.nodeKey);
+ if (!originalNode || originalNode.type !== "database") {
+ return;
+ }
+
+ if (originalNode.children.length > 0) {
+ const { schemas, tables, databases } = toggleDatabaseSelection(
+ originalNode,
+ selection,
+ );
+ setSelectedSchemas(schemas);
+ setSelectedTables(tables);
+ setSelectedDatabases(databases);
+ } else {
+ const databaseId = row.original.databaseId;
+ if (databaseId) {
+ setSelectedDatabases((prev) => {
+ const newSet = new Set(prev);
+ newSet.has(databaseId)
+ ? newSet.delete(databaseId)
+ : newSet.add(databaseId);
+ return newSet;
+ });
+ }
+ }
+ } else if (row.original.type === "schema") {
+ const originalNode = nodeKeyToOriginal.get(row.original.nodeKey);
+ if (!originalNode || originalNode.type !== "schema") {
+ return;
+ }
+
+ if (originalNode.children.length > 0) {
+ const { tables } = toggleSchemaSelection(originalNode, selection);
+ setSelectedTables(tables);
+ } else {
+ const schemaId = getSchemaId(originalNode);
+ setSelectedSchemas((prev) => {
+ const newSet = new Set(prev);
+ newSet.has(schemaId)
+ ? newSet.delete(schemaId)
+ : newSet.add(schemaId);
+ return newSet;
+ });
+ }
+ }
+ },
+ [
+ nodeKeyToOriginal,
+ selectedTables,
+ selectedSchemas,
+ selectedDatabases,
+ setSelectedTables,
+ setSelectedSchemas,
+ setSelectedDatabases,
+ onChange,
+ ],
+ );
+
+ const handleCheckboxClick = useCallback(
+ (row: Row<TablePickerTreeNode>, index: number, event: MouseEvent) => {
+ handleCheckboxToggle(row, index, event.shiftKey);
+ },
+ [handleCheckboxToggle],
+ );
+
+ const columns: TreeTableColumnDef<TablePickerTreeNode>[] = useMemo(
+ () => [
+ {
+ id: "name",
+ header: t`Name`,
+ cell: ({ row }) => (
+ <EntityNameCell
+ icon={TYPE_ICONS[row.original.type]}
+ name={row.original.name}
+ />
+ ),
+ },
+ {
+ id: "owner",
+ header: t`Owner`,
+ width: 140,
+ cell: ({ row }) => {
+ if (row.original.type !== "table" || !row.original.table) {
+ return null;
+ }
+ const ownerId = row.original.table.owner_user_id;
+ const ownerName =
+ ownerId != null && ownerNameById.has(ownerId)
+ ? ownerNameById.get(ownerId)
+ : (row.original.table.owner_email ?? null);
+ return ownerName ? (
+ <Box data-testid="table-owner">{ownerName}</Box>
+ ) : null;
+ },
+ },
+ {
+ id: "rows",
+ header: t`Rows`,
+ width: "auto",
+ cell: ({ row }) => {
+ if (row.original.type !== "table" || !row.original.table) {
+ return null;
+ }
+ const rowCount = row.original.table.estimated_row_count;
+ return rowCount != null ? (
+ <Box w="100%" ta="center" data-testid="table-expected-rows">
+ {formatNumber(rowCount)}
+ </Box>
+ ) : null;
+ },
+ },
+ {
+ id: "published",
+ header: t`Published`,
+ width: "auto",
+ cell: ({ row }) => {
+ if (row.original.type !== "table" || !row.original.table) {
+ return null;
+ }
+ return row.original.table.is_published ? (
+ <Box w="100%" ta="center" data-testid="table-published">
+ <Icon
+ name="verified_round"
+ c="success"
+ aria-label={t`Published`}
+ />
+ </Box>
+ ) : null;
+ },
+ },
+ ],
+ [ownerNameById, formatNumber],
+ );
+
+ const expandedState = useMemo(
+ () => Object.fromEntries([...expandedIds].map((id) => [id, true])),
+ [expandedIds],
+ );
+
+ const handleExpandedStateChange: OnChangeFn<ExpandedState> = useCallback(
+ (updater) => {
+ const newState =
+ typeof updater === "function" ? updater(expandedState) : updater;
+
+ if (typeof newState === "boolean") {
+ return;
+ }
+
+ const newIds = new Set(
+ Object.entries(newState)
+ .filter(([, expanded]) => expanded)
+ .map(([id]) => id),
+ );
+ handleExpandedChange(newIds);
+ },
+ [expandedState, handleExpandedChange],
+ );
+
+ const selectedRowId = useMemo(() => {
+ if (selectedItemsCount > 0) {
+ return null;
+ }
+ if (path.tableId != null) {
+ return `table:${path.tableId}`;
+ }
+ if (path.schemaName != null && path.databaseId != null) {
+ return `schema:${path.databaseId}:${path.schemaName}`;
+ }
+ if (path.databaseId != null) {
+ return `db:${path.databaseId}`;
+ }
+ return null;
+ }, [path, selectedItemsCount]);
+
+ const handleRowActivate = useCallback(
+ (row: Row<TablePickerTreeNode>) => {
+ if (!row.original.isDisabled) {
+ onChange?.(nodeToTreePath(row.original));
+ }
+ },
+ [onChange],
+ );
+
+ const instance = useTreeTableInstance({
+ data: treeData,
+ columns,
+ getSubRows: (node) => node.children,
+ getNodeId: (node) => node.id,
+ getRowCanExpand: (row) => row.original.type !== "table",
+ expanded: expandedState,
+ onExpandedChange: handleExpandedStateChange,
+ enableRowSelection: false,
+ selectedRowId,
+ onRowActivate: handleRowActivate,
+ });
+
+ instanceRef.current = instance;
+
+ useEffect(() => {
+ if (selectedItemsCount === 0) {
+ lastSelectedTableIndex.current = null;
+ }
+ }, [selectedItemsCount]);
+
+ useEffect(() => {
+ if (!reload) {
+ return;
+ }
+ for (const row of instance.rows) {
+ if (
+ row.getIsExpanded() &&
+ row.getCanExpand() &&
+ row.original.children?.length === 0
+ ) {
+ const nodePath = nodeToTreePath(row.original);
+ reload(nodePath);
+ }
+ }
+ }, [instance.rows, reload]);
+
+ const handleRowClick = useCallback(
+ (row: Row<TablePickerTreeNode>) => {
+ if (row.original.isDisabled) {
+ return;
+ }
+
+ const isActive = isNodeActive(row.original, path);
+ const hasChildren = row.original.type !== "table";
+
+ if (selectedItemsCount > 0) {
+ if (hasChildren) {
+ onToggle(row.original.nodeKey);
+ }
+ return;
+ }
+
+ if (hasChildren) {
+ if (isActive) {
+ onToggle(row.original.nodeKey);
+ } else {
+ if (!row.getIsExpanded()) {
+ onToggle(row.original.nodeKey, true);
+ }
+ onChange?.(nodeToTreePath(row.original));
+ }
+ } else {
+ onChange?.(nodeToTreePath(row.original));
+ }
+ },
+ [path, selectedItemsCount, onToggle, onChange],
+ );
+
+ const getRowProps = useCallback(
+ (row: Row<TablePickerTreeNode>) => ({
+ "data-testid": "tree-item",
+ "data-type": row.original.type,
+ ...(row.original.databaseId != null && {
+ "data-database-id": row.original.databaseId,
+ }),
+ ...(row.original.schemaName != null && {
+ "data-schema-name": row.original.schemaName,
+ }),
+ ...(row.original.tableId != null && {
+ "data-table-id": row.original.tableId,
+ }),
+ }),
+ [],
+ );
+
+ return (
+ <TreeTable
+ instance={instance}
+ showCheckboxes
+ onRowClick={handleRowClick}
+ getSelectionState={getSelectionState}
+ onCheckboxClick={handleCheckboxClick}
+ isChildrenLoading={isChildrenLoading}
+ isRowDisabled={isRowDisabled}
+ getRowProps={getRowProps}
+ ariaLabel={t`Tables`}
+ />
+ );
+}
+
+function isChildrenLoading(row: Row<TablePickerTreeNode>): boolean {
+ return (
+ row.getIsExpanded() &&
+ row.getCanExpand() &&
+ row.original.children?.length === 0
+ );
+}
+
+function isRowDisabled(row: Row<TablePickerTreeNode>): boolean {
+ return Boolean(row.original.isDisabled);
+}
+
+function isNodeActive(node: TablePickerTreeNode, path: TreePath): boolean {
+ if (node.type === "database") {
+ return (
+ node.databaseId === path.databaseId &&
+ path.tableId == null &&
+ path.schemaName == null
+ );
+ }
+
+ if (node.type === "schema") {
+ return (
+ node.databaseId === path.databaseId &&
+ node.schemaName === path.schemaName &&
+ path.tableId == null
+ );
+ }
+
+ if (node.type === "table") {
+ return node.tableId === path.tableId;
+ }
+
+ return false;
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/Tree.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/Tree.tsx
index b9b09b82cbe..8544ae3b2a0 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/Tree.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/Tree.tsx
@@ -1,42 +1,25 @@
-import { useCallback, useEffect, useMemo } from "react";
+import { useCallback, useEffect } from "react";
import { t } from "ttag";
-import type { TableId } from "metabase-types/api";
+import { TreeTableSkeleton } from "metabase/ui";
import { useSelection } from "../../../pages/DataModel/contexts/SelectionContext";
import {
getSchemaId,
- getSchemaTableIds,
- isItemSelected,
noManuallySelectedDatabaseChildrenTables,
- noManuallySelectedSchemas,
- noManuallySelectedTables,
- toggleDatabaseSelection,
- toggleSchemaSelection,
} from "../bulk-selection.utils";
import { useExpandedState, useTableLoader } from "../hooks";
-import type {
- ChangeOptions,
- DatabaseNode,
- ExpandedItem,
- ExpandedSchemaItem,
- FlatItem,
- SchemaItem,
- TreeNode,
- TreePath,
-} from "../types";
+import type { ChangeOptions, TreePath } from "../types";
import {
- isDatabaseItem,
- isDatabaseNode,
- isSchemaItem,
- isSchemaNode,
- isTableNode,
- isTableOrSchemaNode,
-} from "../types";
-import { flatten } from "../utils";
+ findSelectedTableNodes,
+ getExpandedSelectedDatabases,
+ getExpandedSelectedSchemas,
+ hasManuallySelectedSchemas,
+ hasManuallySelectedTables,
+} from "../utils";
import { EmptyState } from "./EmptyState";
-import { TablePickerResults } from "./Results";
+import { TablePickerTreeTable } from "./TablePickerTreeTable";
interface Props {
path: TreePath;
@@ -55,42 +38,18 @@ export function Tree({ path, onChange, setOnUpdateCallback }: Props) {
} = useSelection();
const { databaseId, schemaName } = path;
const { isExpanded, toggle } = useExpandedState(path);
- const { tree, reload } = useTableLoader();
+ const { tree, reload, isLoading } = useTableLoader();
- /**
- * onUpdateCallback depends on the items, and they are changing very often.
- * We don't want to re-register it each time items changed.
- * Otherwise, it causes an infinity loop.
- */
- const items = useMemo(
- () =>
- flatten(tree, {
- isExpanded,
- addLoadingNodes: true,
- canFlattenSingleSchema: true,
- selection: {
- tables: selectedTables,
- schemas: selectedSchemas,
- databases: selectedDatabases,
- },
- }),
- [tree, isExpanded, selectedTables, selectedSchemas, selectedDatabases],
- );
-
- /**
- * Initial loading of all databases, schemas, tables for the current path
- */
useEffect(() => {
reload(path);
}, [reload, path]);
const refetchSelectedTables = useCallback(() => {
- const selectedTableNodes = items
- .filter((item) => isTableNode(item))
- .filter((tableNode) => selectedTables.has(tableNode.value.tableId));
-
- selectedTableNodes.forEach((tableNode) => reload(tableNode.value));
- }, [items, reload, selectedTables]);
+ const selectedTableNodes = findSelectedTableNodes(tree, selectedTables);
+ selectedTableNodes.forEach((tableNode) => {
+ reload(tableNode.value);
+ });
+ }, [tree, reload, selectedTables]);
useEffect(() => {
setOnUpdateCallback(() => refetchSelectedTables);
@@ -98,45 +57,11 @@ export function Tree({ path, onChange, setOnUpdateCallback }: Props) {
}, [refetchSelectedTables, setOnUpdateCallback]);
useEffect(() => {
- const expandedDatabases = items.filter(
- (item) =>
- isDatabaseItem(item) && item.isExpanded && item.children.length === 0,
- );
-
- expandedDatabases.forEach((database) => {
- const databaseId = database.value?.databaseId;
- if (databaseId) {
- reload({ databaseId });
- }
- });
- }, [items, reload]);
-
- useEffect(() => {
- // Load tables when schemas are expanded
- const expandedSchemas = items.filter(
- (item) =>
- item.type === "schema" && item.isExpanded && item.children.length === 0,
- ) as SchemaItem[];
-
- expandedSchemas.forEach((schema) => {
- const { databaseId, schemaName } = schema.value ?? {};
- if (databaseId && schemaName) {
- reload({ databaseId, schemaName });
- }
- });
- }, [items, reload]);
-
- const isEmpty = items.length === 0;
-
- useEffect(() => {
- // When we detect only one database, we automatically select and expand it.
- const databases = tree.children.filter((node) => isDatabaseNode(node));
-
- if (databases.length !== 1) {
+ if (tree.children.length !== 1) {
return;
}
- const [database] = databases;
+ const [database] = tree.children;
if (
!isExpanded({ databaseId: database.value.databaseId }) &&
@@ -148,10 +73,8 @@ export function Tree({ path, onChange, setOnUpdateCallback }: Props) {
}, [databaseId, schemaName, tree, toggle, isExpanded, onChange]);
useEffect(() => {
- // When we detect a database with just one schema, we automatically
- // select and expand that schema.
const database = tree.children.find(
- (node) => isDatabaseNode(node) && node.value.databaseId === databaseId,
+ (node) => node.value.databaseId === databaseId,
);
if (
databaseId &&
@@ -160,25 +83,21 @@ export function Tree({ path, onChange, setOnUpdateCallback }: Props) {
schemaName == null
) {
const schema = database.children[0];
- if (isSchemaNode(schema)) {
- toggle(schema.key, true);
- onChange(schema.value, { isAutomatic: true });
- }
+ toggle(schema.key, true);
+ onChange(schema.value, { isAutomatic: true });
}
}, [databaseId, schemaName, tree, toggle, isExpanded, onChange]);
useEffect(() => {
- const expandedSelectedSchemaItems = items.filter(
- (item) =>
- isSchemaItem(item) &&
- selectedSchemas.has(getSchemaId(item) ?? "") &&
- item.children.length > 0,
- ) as ExpandedSchemaItem[];
+ const expandedSelectedSchemas = getExpandedSelectedSchemas(
+ tree,
+ selectedSchemas,
+ isExpanded,
+ );
- expandedSelectedSchemaItems.forEach((schemaItem) => {
- if (noManuallySelectedTables(schemaItem, items, selectedTables)) {
- // when expanding a schema, let's select all the tables in that schema
- const tableIds = getSchemaTableIds(schemaItem, items);
+ expandedSelectedSchemas.forEach((schema) => {
+ if (!hasManuallySelectedTables(schema, selectedTables)) {
+ const tableIds = schema.children.map((table) => table.value.tableId);
if (tableIds.length === 0) {
return;
}
@@ -193,72 +112,61 @@ export function Tree({ path, onChange, setOnUpdateCallback }: Props) {
setSelectedSchemas((prev) => {
const newSet = new Set(prev);
- newSet.delete(getSchemaId(schemaItem) ?? "");
+ newSet.delete(getSchemaId(schema));
return newSet;
});
}
});
}, [
+ tree,
isExpanded,
selectedSchemas,
- items,
selectedTables,
setSelectedTables,
setSelectedSchemas,
]);
useEffect(() => {
- const expandedSelectedDatabaseItems = items.filter(
- (item) =>
- isDatabaseItem(item) &&
- selectedDatabases.has(item.value?.databaseId ?? -1) &&
- item.children.length > 0,
- ) as DatabaseNode[];
+ const expandedSelectedDatabases = getExpandedSelectedDatabases(
+ tree,
+ selectedDatabases,
+ isExpanded,
+ );
- expandedSelectedDatabaseItems.forEach((dbNode) => {
+ expandedSelectedDatabases.forEach((dbNode) => {
if (
- noManuallySelectedSchemas(dbNode, items, selectedSchemas) &&
+ !hasManuallySelectedSchemas(dbNode, selectedSchemas) &&
noManuallySelectedDatabaseChildrenTables(dbNode, selectedTables)
) {
- // single schema that's not rendered and it's not part of flattened list
if (dbNode.children.length === 1) {
setSelectedTables((prev) => {
const newSet = new Set(prev);
- dbNode.children[0].children.forEach((y) => {
- newSet.add(y.value?.tableId ?? -1);
+ dbNode.children[0].children.forEach((table) => {
+ newSet.add(table.value.tableId);
});
return newSet;
});
- } else {
- // when expanding a db, let's select all the schemas in that db
- const schemaIds = dbNode.children.map((schemaNode) =>
- getSchemaId(schemaNode),
- );
-
- if (schemaIds.length === 0) {
- return;
- }
-
+ } else if (dbNode.children.length > 0) {
setSelectedSchemas((prev) => {
const newSet = new Set(prev);
- schemaIds.forEach((schemaId) => {
- newSet.add(schemaId ?? "");
- });
+ for (const schema of dbNode.children) {
+ newSet.add(getSchemaId(schema));
+ }
return newSet;
});
}
setSelectedDatabases((prev) => {
const newSet = new Set(prev);
- newSet.delete(dbNode.value?.databaseId ?? -1);
+ newSet.delete(dbNode.value.databaseId);
return newSet;
});
}
});
}, [
+ tree,
isExpanded,
selectedDatabases,
- items,
selectedSchemas,
selectedTables,
setSelectedDatabases,
@@ -266,121 +174,24 @@ export function Tree({ path, onChange, setOnUpdateCallback }: Props) {
setSelectedSchemas,
]);
- if (isEmpty) {
- return <EmptyState title={t`No data to show`} />;
- }
-
- function onItemToggle(item: FlatItem) {
- const selection = {
- tables: selectedTables,
- schemas: selectedSchemas,
- databases: selectedDatabases,
- };
- const isSelected = isItemSelected(item as TreeNode, selection);
-
- if (isTableNode(item)) {
- const tableId = item.value?.tableId ?? -1;
- if (tableId === -1) {
- return;
- }
- setSelectedTables((prev) => {
- const newSet = new Set(prev);
- isSelected === "yes" ? newSet.delete(tableId) : newSet.add(tableId);
-
- // Navigate to the table when checking/unchecking in multi-select mode
- // This keeps it active in the URL without expanding it
- if (item.value) {
- onChange(item.value);
- }
-
- return newSet;
- });
- }
- if (isDatabaseItem(item)) {
- if (item.children.length > 0) {
- const { schemas, tables, databases } = toggleDatabaseSelection(
- item,
- selection,
- );
- setSelectedSchemas(schemas);
- setSelectedTables(tables);
- setSelectedDatabases(databases);
- } else {
- const databaseId = item.value?.databaseId;
- if (databaseId) {
- setSelectedDatabases((prev) => toggleInSet(prev, databaseId));
- }
- }
- }
- if (isSchemaItem(item)) {
- if (item.children.length > 0) {
- const { tables } = toggleSchemaSelection(item, selection);
- setSelectedTables(tables);
- } else {
- setSelectedSchemas((prev) => {
- const newSet = new Set(prev);
- const schemaId = getSchemaId(item);
- if (!schemaId) {
- return newSet;
- }
- if (schemaId && newSet.has(schemaId)) {
- newSet.delete(schemaId);
- } else {
- newSet.add(schemaId);
- }
- return newSet;
- });
- }
- }
+ if (isLoading) {
+ return (
+ <TreeTableSkeleton showCheckboxes columnWidths={[0.5, 0.15, 0.1, 0.1]} />
+ );
}
- function onItemRangeSelect(rangeItems: FlatItem[], targetItem: FlatItem) {
- const tableIds = rangeItems
- .filter(
- (rangeItem): rangeItem is ExpandedItem =>
- rangeItem.isLoading === undefined,
- )
- .filter(isTableOrSchemaNode)
- .map((rangeItem) =>
- rangeItem.value?.tableId ? rangeItem.value.tableId : null,
- )
- .filter((tableId): tableId is TableId => tableId != null);
-
- if (tableIds.length === 0) {
- return;
- }
-
- setSelectedTables((prev) => {
- const newSet = new Set(prev);
- tableIds.forEach((tableId) => {
- newSet.add(tableId);
- });
- return newSet;
- });
-
- if (isTableNode(targetItem) && targetItem.value) {
- onChange(targetItem.value);
- }
+ if (tree.children.length === 0) {
+ return <EmptyState title={t`No data to show`} />;
}
return (
- <TablePickerResults
- items={items}
+ <TablePickerTreeTable
+ tree={tree}
path={path}
- toggle={toggle}
- onItemClick={onChange}
- onItemToggle={onItemToggle}
- onRangeSelect={onItemRangeSelect}
+ isExpanded={isExpanded}
+ onToggle={toggle}
+ onChange={onChange}
+ reload={reload}
/>
);
}
-
-function toggleInSet<T>(set: Set<T>, item: T) {
- const newSet = new Set(set);
- if (newSet.has(item)) {
- newSet.delete(item);
- } else {
- newSet.add(item);
- }
- return newSet;
-}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/constants.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/constants.ts
index 414a10d38c0..4bbe51bc671 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/constants.ts
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/constants.ts
@@ -4,12 +4,6 @@ import type { ItemType } from "./types";
export const UNNAMED_SCHEMA_NAME = "";
-export const CHILD_TYPES = {
- database: "schema",
- schema: "table",
- table: null,
-} as const;
-
export const TYPE_ICONS: Record<ItemType, IconName> = {
table: "table2",
schema: "folder",
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/hooks/useExpandedState.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/hooks/useExpandedState.ts
index 297463e02e7..052177f759a 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/hooks/useExpandedState.ts
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/hooks/useExpandedState.ts
@@ -5,37 +5,41 @@ import { expandPath, toKey } from "../utils";
/**
* Returns a state object that indicates which nodes are expanded in the tree.
+ * State directly stores expanded status: true = expanded, false = collapsed.
+ * Keys not in state fall back to defaultExpanded.
*/
export function useExpandedState(
path: TreePath,
- options: { defaultClosed?: boolean } = {},
+ options: { defaultExpanded?: boolean } = {},
) {
- const defaultClosed = options.defaultClosed ?? true;
- const [state, setState] = useState(expandPath({}, path));
+ const defaultExpanded = options.defaultExpanded ?? false;
+ const [state, setState] = useState<Record<string, boolean>>(() =>
+ expandPath({}, path),
+ );
const { databaseId, schemaName, tableId } = path;
useEffect(() => {
- // When the path changes, this means a user has navigated through the browser back
- // button, ensure the path is completely expanded.
setState((state) => expandPath(state, { databaseId, schemaName, tableId }));
}, [databaseId, schemaName, tableId]);
const isExpanded = useCallback(
(path: string | TreePath) => {
const key = typeof path === "string" ? path : toKey(path);
- const isToggled = Boolean(state[key]);
- return defaultClosed ? isToggled : !isToggled;
+ return state[key] ?? defaultExpanded;
},
- [state, defaultClosed],
+ [state, defaultExpanded],
);
- const toggle = useCallback((key: string, value?: boolean) => {
- setState((current) => ({
- ...current,
- [key]: value ?? !current[key],
- }));
- }, []);
+ const toggle = useCallback(
+ (key: string, value?: boolean) => {
+ setState((current) => ({
+ ...current,
+ [key]: value ?? !(current[key] ?? defaultExpanded),
+ }));
+ },
+ [defaultExpanded],
+ );
return {
isExpanded,
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/hooks/useTableLoader.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/hooks/useTableLoader.ts
index 911d2cf5659..dc9b0e8f10c 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/hooks/useTableLoader.ts
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/hooks/useTableLoader.ts
@@ -13,9 +13,9 @@ import type { DatabaseId, SchemaName } from "metabase-types/api";
import { UNNAMED_SCHEMA_NAME } from "../constants";
import type {
DatabaseNode,
+ RootNode,
SchemaNode,
TableNode,
- TreeNode,
TreePath,
} from "../types";
import { merge, node, rootNode, toKey } from "../utils";
@@ -39,7 +39,8 @@ export function useTableLoader() {
const schemasRef = useLatest(schemas);
const tablesRef = useLatest(tables);
- const [tree, setTree] = useState<TreeNode>(rootNode());
+ const [tree, setTree] = useState<RootNode>(rootNode());
+ const [isInitialLoading, setIsInitialLoading] = useState(true);
const getDatabases = useCallback(async () => {
const response = await fetchDatabases(
@@ -170,7 +171,7 @@ export function useTableLoader() {
getTables(path.databaseId, path.schemaName),
]);
- const newTree: TreeNode = rootNode(
+ const newTree = rootNode(
databases.map((database) => ({
...database,
children:
@@ -190,6 +191,7 @@ export function useTableLoader() {
const merged = merge(current, newTree);
return _.isEqual(current, merged) ? current : merged;
});
+ setIsInitialLoading(false);
} finally {
pendingPathsRef.current.delete(key);
}
@@ -197,5 +199,5 @@ export function useTableLoader() {
[getDatabases, getSchemas, getTables],
);
- return { tree, reload: load };
+ return { tree, reload: load, isLoading: isInitialLoading };
}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/types.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/types.ts
index a734d073d40..6714101f7a9 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/types.ts
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/types.ts
@@ -1,3 +1,4 @@
+import type { TreeNodeData } from "metabase/ui";
import type {
DatabaseId,
SchemaName,
@@ -10,6 +11,19 @@ import type {
export type NodeKey = string;
+export interface TablePickerTreeNode extends TreeNodeData {
+ id: string;
+ type: "database" | "schema" | "table";
+ name: string;
+ nodeKey: string;
+ databaseId?: DatabaseId;
+ schemaName?: SchemaName;
+ tableId?: TableId;
+ table?: Table;
+ isDisabled?: boolean;
+ children?: TablePickerTreeNode[];
+}
+
export type TreePath = {
databaseId?: DatabaseId;
schemaName?: SchemaName;
@@ -60,40 +74,6 @@ export type Item = DatabaseItem | SchemaItem | TableItem;
export type ItemType = Item["type"];
-export type FlatItem = LoadingItem | ExpandedItem;
-
-interface ExpandedItemBase<TChild = TreeNode> {
- isExpanded?: boolean;
- isLoading?: false;
- parent?: NodeKey;
- level: number;
- disabled?: boolean;
- isSelected?: "yes" | "no" | "some";
- children: TChild[];
-}
-
-export type ExpandedItem = Item & ExpandedItemBase;
-
-export type ExpandedSchemaItem = SchemaItem & ExpandedItemBase<TableNode>;
-
-export type ExpandedDatabaseItem = DatabaseItem & ExpandedItemBase<SchemaNode>;
-
-export type ExpandedTableItem = TableItem & ExpandedItemBase;
-
-type LoadingItem = {
- isLoading: true;
- type: ItemType;
- key: string;
- level: number;
- isExpanded?: boolean;
- value?: TreePath;
- label?: string;
- parent?: NodeKey;
- table?: undefined;
- disabled?: never;
- children: [];
-};
-
export type ExpandedState = {
[key: NodeKey]: boolean;
};
@@ -110,52 +90,14 @@ export interface FilterState {
unusedOnly: boolean | null;
}
-export function isExpandedItem(node: FlatItem): node is ExpandedItem {
- return node.isLoading === undefined;
-}
-
-export function isDatabaseItem(node: FlatItem): node is ExpandedDatabaseItem {
- if ("isLoading" in node && node.isLoading === true) {
- return false;
- }
- return node.type === "database";
-}
-
export function isDatabaseNode(node: TreeNode): node is DatabaseNode {
return node.type === "database";
}
export function isSchemaNode(node: TreeNode): node is SchemaNode {
- if ("isLoading" in node && node.isLoading === true) {
- return false;
- }
return node.type === "schema";
}
-export function isSchemaItem(node: FlatItem): node is ExpandedSchemaItem {
- if ("isLoading" in node && node.isLoading === true) {
- return false;
- }
- return node.type === "schema";
-}
-
-export function isTableOrSchemaNode(
- node: ExpandedItem | TreeNode,
-): node is ExpandedTableItem {
- return (
- node.type === "table" ||
- (node.type === "schema" &&
- node.children.every((child) => child.type === "table"))
- );
-}
-
-export function isTableNode(node: FlatItem): node is ExpandedTableItem;
-export function isTableNode(node: TreeNode): node is TableNode;
-export function isTableNode(
- node: FlatItem | TreeNode,
-): node is ExpandedTableItem | TableNode {
- if ("isLoading" in node && node.isLoading === true) {
- return false;
- }
+export function isTableNode(node: TreeNode): node is TableNode {
return node.type === "table";
}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/utils.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/utils.ts
index 725ccc241ce..ddec8c661b4 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/utils.ts
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/utils.ts
@@ -1,19 +1,29 @@
-import { type NodeSelection, isItemSelected } from "./bulk-selection.utils";
-import { CHILD_TYPES, UNNAMED_SCHEMA_NAME } from "./constants";
+import type { DatabaseId, TableId } from "metabase-types/api";
+
+import { getSchemaId } from "./bulk-selection.utils";
+import { UNNAMED_SCHEMA_NAME } from "./constants";
import type {
DatabaseNode,
ExpandedState,
FilterState,
- FlatItem,
- ItemType,
- NodeKey,
RootNode,
+ SchemaNode,
+ TableNode,
+ TablePickerTreeNode,
TreeNode,
TreePath,
} from "./types";
-export function hasChildren(type: ItemType): boolean {
- return type !== "table";
+export function getDatabases(tree: RootNode): DatabaseNode[] {
+ return tree.children;
+}
+
+export function getSchemas(tree: RootNode): SchemaNode[] {
+ return getDatabases(tree).flatMap((db) => db.children);
+}
+
+export function getTables(tree: RootNode): TableNode[] {
+ return getSchemas(tree).flatMap((schema) => schema.children);
}
// Returns a new state object with all the nodes along the path expanded.
@@ -43,102 +53,18 @@ export function expandPath(
};
}
-/**
- * Convert a TreeNode into a flat list of items
- * that can easily be rendered using virtualization.
- *
- * This does other things like removing nameless schemas
- * from the tree and adding loading nodes.
- */
-export function flatten(
- node: TreeNode,
- opts: {
- addLoadingNodes?: boolean;
- isExpanded?: (key: string) => boolean;
- isSingleSchema?: boolean;
- level?: number;
- parent?: NodeKey;
- canFlattenSingleSchema?: boolean;
- selection?: NodeSelection;
- } = {},
-): FlatItem[] {
- const {
- addLoadingNodes,
- isExpanded,
- isSingleSchema,
- canFlattenSingleSchema,
- level = 0,
- parent,
- selection,
- } = opts;
- if (node.type === "root") {
- // root node doesn't render a title and is always expanded
- if (addLoadingNodes && node.children.length === 0) {
- return [
- loadingItem("database", level),
- loadingItem("database", level),
- loadingItem("database", level),
- ];
- }
- return sort(node.children).flatMap((child) => flatten(child, opts));
- }
-
- const isSelected = selection ? isItemSelected(node, selection) : "no";
-
- if (
- node.type === "schema" &&
- (node.label === UNNAMED_SCHEMA_NAME ||
- (isSingleSchema && canFlattenSingleSchema))
- ) {
- // Hide nameless schemas in the tree
- return [
- ...sort(node.children).flatMap((child) =>
- flatten(child, {
- ...opts,
- level,
- parent,
- }),
- ),
- ];
- }
-
- if (typeof isExpanded === "function" && !isExpanded(node.key)) {
- return [{ ...node, level, parent, isSelected }];
- }
-
- if (addLoadingNodes && node.children.length === 0) {
- const childType = CHILD_TYPES[node.type];
- if (!childType) {
- return [{ ...node, level, parent, isSelected }];
- }
- return [
- { ...node, isExpanded: true, level, parent, isSelected },
- loadingItem(childType, level + 1, node),
- ];
- }
-
- return [
- { ...node, isExpanded: true, level, parent, isSelected },
- ...sort(node.children).flatMap((child) =>
- flatten(child, {
- ...opts,
- level: level + 1,
- parent: node.key,
- isSingleSchema: node.type === "database" && node.children.length === 1,
- }),
- ),
- ];
-}
-
-export function sort(nodes: TreeNode[]): TreeNode[] {
- return Array.from(nodes).sort((a, b) => {
- return a.label.localeCompare(b.label);
- });
+export function sort<T extends TreeNode>(nodes: readonly T[]): T[] {
+ return [...nodes].sort((a, b) => a.label.localeCompare(b.label));
}
/**
* Merge two TreeNodes together.
*/
+export function merge(a: RootNode, b: RootNode): RootNode;
+export function merge(
+ a: TreeNode | undefined,
+ b: TreeNode | undefined,
+): TreeNode;
export function merge(
a: TreeNode | undefined,
b: TreeNode | undefined,
@@ -157,18 +83,14 @@ export function merge(
const children = [];
for (let index = 0; index < len; index++) {
- const aa = a.children?.[index];
- const bb = b.children?.[index];
- children.push(merge(aa, bb));
+ const childA = a.children?.[index];
+ const childB = b.children?.[index];
+ children.push(merge(childA, childB));
}
- return {
- ...a,
- ...b,
- // @ts-expect-error: we can't type the child node here correctly
- // without checking all the combinations, just assume we are right.
- children,
- };
+ const merged = { ...a, ...b };
+ (merged as { children: TreeNode[] }).children = children;
+ return merged;
}
/**
@@ -199,40 +121,142 @@ export function rootNode(children: DatabaseNode[] = []): RootNode {
});
}
-export function loadingItem(
- type: ItemType,
- level: number,
- parent?: TreeNode,
-): FlatItem {
+export function getFiltersCount(filters: FilterState): number {
+ return [
+ filters.dataSource != null,
+ filters.dataLayer != null,
+ filters.ownerEmail != null || filters.ownerUserId != null,
+ filters.unusedOnly === true,
+ ].filter(Boolean).length;
+}
+
+export function transformToTreeTableFormat(
+ tree: RootNode,
+ canFlattenSingleSchema = true,
+): TablePickerTreeNode[] {
+ return sort(tree.children).map((database) =>
+ transformDatabaseNode(database, canFlattenSingleSchema),
+ );
+}
+
+function transformDatabaseNode(
+ database: DatabaseNode,
+ canFlattenSingleSchema: boolean,
+): TablePickerTreeNode {
+ const { databaseId } = database.value;
+ const isSingleSchema = database.children.length === 1;
+ const shouldFlattenSingleSchema = canFlattenSingleSchema && isSingleSchema;
+
+ let children: TablePickerTreeNode[];
+ if (shouldFlattenSingleSchema) {
+ children = sort(database.children[0].children).map(transformTableNode);
+ } else {
+ children = sort(database.children).flatMap((schema) => {
+ if (schema.label === UNNAMED_SCHEMA_NAME) {
+ return sort(schema.children).map(transformTableNode);
+ }
+ return [transformSchemaNode(schema)];
+ });
+ }
+
+ return {
+ id: `db:${databaseId}`,
+ type: "database",
+ name: database.label,
+ nodeKey: database.key,
+ databaseId,
+ children,
+ };
+}
+
+function transformSchemaNode(schema: SchemaNode): TablePickerTreeNode {
+ const { databaseId, schemaName } = schema.value;
+
+ return {
+ id: `schema:${databaseId}:${schemaName}`,
+ type: "schema",
+ name: schema.label,
+ nodeKey: schema.key,
+ databaseId,
+ schemaName,
+ children: sort(schema.children).map(transformTableNode),
+ };
+}
+
+function transformTableNode(table: TableNode): TablePickerTreeNode {
+ const { databaseId, schemaName, tableId } = table.value;
+
return {
- type,
- level,
- value: parent?.type === "root" ? undefined : parent?.value,
- parent: parent?.type === "root" ? undefined : parent?.key,
- isLoading: true,
- key: Math.random().toString(),
+ id: `table:${tableId}`,
+ type: "table",
+ name: table.label,
+ nodeKey: table.key,
+ databaseId,
+ schemaName,
+ tableId,
+ table: table.table,
+ isDisabled: table.disabled,
children: [],
};
}
-export function getFiltersCount(filters: FilterState): number {
- let count = 0;
+export function nodeToTreePath(node: TablePickerTreeNode): TreePath {
+ return {
+ databaseId: node.databaseId,
+ schemaName: node.schemaName,
+ tableId: node.tableId,
+ };
+}
- if (filters.dataSource != null) {
- ++count;
- }
+export function findSelectedTableNodes(
+ tree: RootNode,
+ selectedTables: Set<TableId>,
+): TableNode[] {
+ return getTables(tree).filter((table) =>
+ selectedTables.has(table.value.tableId),
+ );
+}
- if (filters.dataLayer != null) {
- ++count;
- }
+export function getExpandedSelectedSchemas(
+ tree: RootNode,
+ selectedSchemas: Set<string>,
+ isExpanded: (key: string) => boolean,
+): SchemaNode[] {
+ return getSchemas(tree).filter(
+ (schema) =>
+ selectedSchemas.has(getSchemaId(schema)) &&
+ isExpanded(schema.key) &&
+ schema.children.length > 0,
+ );
+}
- if (filters.ownerEmail != null || filters.ownerUserId != null) {
- ++count;
- }
+export function getExpandedSelectedDatabases(
+ tree: RootNode,
+ selectedDatabases: Set<DatabaseId>,
+ isExpanded: (key: string) => boolean,
+): DatabaseNode[] {
+ return getDatabases(tree).filter(
+ (db) =>
+ selectedDatabases.has(db.value.databaseId) &&
+ isExpanded(db.key) &&
+ db.children.length > 0,
+ );
+}
- if (filters.unusedOnly === true) {
- ++count;
- }
+export function hasManuallySelectedTables(
+ schema: SchemaNode,
+ selectedTables: Set<TableId>,
+): boolean {
+ return schema.children.some((table) =>
+ selectedTables.has(table.value.tableId),
+ );
+}
- return count;
+export function hasManuallySelectedSchemas(
+ database: DatabaseNode,
+ selectedSchemas: Set<string>,
+): boolean {
+ return database.children.some((schema) =>
+ selectedSchemas.has(getSchemaId(schema)),
+ );
}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/wrappers.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/wrappers.tsx
index 02dc5639c87..b9a1060a8d9 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/wrappers.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/wrappers.tsx
@@ -30,16 +30,9 @@ export function RouterTablePicker({
const onChange = useCallback(
(value: TreePath) => {
setValue(value);
-
- // Update URL only when either opening a table or no table has been opened yet.
- // We want to keep user looking at a table when navigating databases/schemas.
- const canUpdateUrl = value.tableId != null || propTableId == null;
-
- if (canUpdateUrl) {
- dispatch(replace(Urls.dataStudioData(value)));
- }
+ dispatch(replace(Urls.dataStudioData(value)));
},
- [dispatch, propTableId],
+ [dispatch],
);
useEffect(() => {
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/pages/DataModel/DataModel.unit.spec.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/pages/DataModel/DataModel.unit.spec.tsx
index 8e196f665a8..450ddf07049 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/pages/DataModel/DataModel.unit.spec.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/pages/DataModel/DataModel.unit.spec.tsx
@@ -431,12 +431,7 @@ describe("DataModel", () => {
const disabledTable = await findTablePickerTable(
ORDERS_TABLE_INITIAL_SYNC_INCOMPLETE.display_name,
);
- expect(disabledTable).toHaveStyle({ pointerEvents: "none" });
-
- // This click should not cause a change, as the table should be disabled
- await expect(userEvent.click(disabledTable)).rejects.toThrow(
- /pointer-events: none/,
- );
+ expect(disabledTable).toHaveAttribute("data-disabled", "true");
expect(screen.queryByTestId("table-section")).not.toBeInTheDocument();
});
diff --git a/enterprise/frontend/src/metabase-enterprise/transforms/pages/JobListPage/JobListPage.tsx b/enterprise/frontend/src/metabase-enterprise/transforms/pages/JobListPage/JobListPage.tsx
index 08d4be09a26..3c652a0ca75 100644
--- a/enterprise/frontend/src/metabase-enterprise/transforms/pages/JobListPage/JobListPage.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/transforms/pages/JobListPage/JobListPage.tsx
@@ -16,6 +16,7 @@ import {
Stack,
TextInput,
TreeTable,
+ TreeTableSkeleton,
useTreeTableInstance,
} from "metabase/ui";
import { useListTransformJobsQuery } from "metabase-enterprise/api";
@@ -23,7 +24,6 @@ import { DataStudioBreadcrumbs } from "metabase-enterprise/data-studio/common/co
import { PageContainer } from "metabase-enterprise/data-studio/common/components/PageContainer";
import { PaneHeader } from "metabase-enterprise/data-studio/common/components/PaneHeader";
import { ListEmptyState } from "metabase-enterprise/transforms/components/ListEmptyState";
-import { ListLoadingState } from "metabase-enterprise/transforms/components/ListLoadingState";
import type { TransformJob } from "metabase-types/api";
export const JobListPage = () => {
@@ -110,10 +110,10 @@ export const JobListPage = () => {
</Flex>
<Flex direction="column" flex={1} mih={0}>
- {isLoading ? (
- <ListLoadingState />
- ) : (
- <Card withBorder p={0}>
+ <Card withBorder p={0}>
+ {isLoading ? (
+ <TreeTableSkeleton columnWidths={[0.6, 0.3]} />
+ ) : (
<TreeTable
instance={treeTableInstance}
emptyState={
@@ -121,8 +121,8 @@ export const JobListPage = () => {
}
onRowClick={handleRowActivate}
/>
- </Card>
- )}
+ )}
+ </Card>
</Flex>
</Stack>
</PageContainer>
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 e3b3e08485b..a8c2b97c783 100644
--- a/enterprise/frontend/src/metabase-enterprise/transforms/pages/TransformListPage/TransformListPage.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/transforms/pages/TransformListPage/TransformListPage.tsx
@@ -25,6 +25,7 @@ import {
Stack,
TextInput,
TreeTable,
+ TreeTableSkeleton,
useTreeTableInstance,
} from "metabase/ui";
import { useListTransformsQuery } from "metabase-enterprise/api";
@@ -33,7 +34,6 @@ import { PageContainer } from "metabase-enterprise/data-studio/common/components
import { PaneHeader } from "metabase-enterprise/data-studio/common/components/PaneHeader";
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 { SHARED_LIB_IMPORT_PATH } from "metabase-enterprise/transforms-python/constants";
import { CollectionRowMenu } from "./CollectionRowMenu";
@@ -281,7 +281,7 @@ export const TransformListPage = ({ location }: WithRouterProps) => {
<Card withBorder p={0}>
{isLoading ? (
- <ListLoadingState />
+ <TreeTableSkeleton columnWidths={[0.4, 0.2, 0.25, 0.05]} />
) : (
<TreeTable
instance={treeTableInstance}
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
index 4731146610d..92f67edff6a 100644
--- a/frontend/src/metabase/ui/components/data-display/TreeTable/ExpandButton/ExpandButton.tsx
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/ExpandButton/ExpandButton.tsx
@@ -44,6 +44,7 @@ export const ExpandButton = memo(function ExpandButton({
className={cx(S.wrapper, S.button, className)}
onClick={onClick}
aria-label={isExpanded ? t`Collapse` : t`Expand`}
+ aria-expanded={isExpanded}
tabIndex={-1}
>
<Icon
diff --git a/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTable.tsx b/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTable.tsx
index 00ee3c7ae18..cdc787031e6 100644
--- a/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTable.tsx
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTable.tsx
@@ -1,6 +1,8 @@
+import type { Row } from "@tanstack/react-table";
import cx from "classnames";
import {
type KeyboardEvent,
+ type MouseEvent,
useCallback,
useEffect,
useMemo,
@@ -26,6 +28,8 @@ export function TreeTable<TData extends TreeNodeData>({
getSelectionState,
onCheckboxClick,
isChildrenLoading,
+ isRowDisabled,
+ getRowProps,
classNames,
styles,
ariaLabel,
@@ -43,6 +47,8 @@ export function TreeTable<TData extends TreeNodeData>({
setContainerWidth,
handleKeyDown,
activeRowId,
+ setActiveRowId,
+ selectedRowId,
} = instance;
const rootRef = useRef<HTMLDivElement>(null);
@@ -69,15 +75,12 @@ export function TreeTable<TData extends TreeNodeData>({
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);
- }
+ const observer = new ResizeObserver(() => {
+ const width = container.clientWidth - 1;
+ const adjustedWidth = showCheckboxes
+ ? width - CHECKBOX_COLUMN_WIDTH
+ : width;
+ setContainerWidth(adjustedWidth);
});
observer.observe(container);
@@ -99,11 +102,21 @@ export function TreeTable<TData extends TreeNodeData>({
const measureElement = useCallback(
(element: HTMLElement | null) => {
- virtualizer.measureElement(element);
+ if (element?.isConnected) {
+ virtualizer.measureElement(element);
+ }
},
[virtualizer],
);
+ const handleRowClick = useCallback(
+ (row: Row<TData>, event: MouseEvent) => {
+ setActiveRowId(row.id);
+ onRowClick?.(row, event);
+ },
+ [setActiveRowId, onRowClick],
+ );
+
const showEmptyState = rows.length === 0 && emptyState;
return (
@@ -112,7 +125,8 @@ export function TreeTable<TData extends TreeNodeData>({
className={cx(S.root, classNames?.root)}
style={styles?.root}
direction="column"
- h="100%"
+ flex={1}
+ mih={0}
w="100%"
role="treegrid"
tabIndex={0}
@@ -132,7 +146,7 @@ export function TreeTable<TData extends TreeNodeData>({
</Center>
) : (
<>
- <TreeTableHeader
+ <TreeTableHeader<TData>
table={table}
columnWidths={columnWidths}
showCheckboxes={showCheckboxes}
@@ -153,7 +167,7 @@ export function TreeTable<TData extends TreeNodeData>({
}
return (
- <TreeTableRow
+ <TreeTableRow<TData>
key={row.id}
row={row}
rowIndex={virtualItem.index}
@@ -164,14 +178,19 @@ export function TreeTable<TData extends TreeNodeData>({
showExpandButtons={hasExpandableNodes}
indentWidth={indentWidth}
activeRowId={activeRowId}
+ selectedRowId={selectedRowId}
+ isExpanded={row.getIsExpanded()}
+ canExpand={row.getCanExpand()}
measureElement={measureElement}
- onRowClick={onRowClick}
+ onRowClick={handleRowClick}
onRowDoubleClick={onRowDoubleClick}
+ isDisabled={isRowDisabled?.(row)}
isChildrenLoading={isChildrenLoading?.(row)}
getSelectionState={getSelectionState}
onCheckboxClick={onCheckboxClick}
classNames={classNames}
styles={styles}
+ getRowProps={getRowProps}
/>
);
})}
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
index d4e58988e8b..a0bf2df5623 100644
--- 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
@@ -1,3 +1,5 @@
+import { memo } from "react";
+
import { Flex, Icon, SortableHeaderPill } from "metabase/ui";
import type { TreeTableHeaderVariant } from "../../types";
@@ -8,7 +10,11 @@ interface HeaderCellProps {
variant: TreeTableHeaderVariant;
}
-export function HeaderCell({ name, sort, variant }: HeaderCellProps) {
+export const HeaderCell = memo(function HeaderCell({
+ name,
+ sort,
+ variant,
+}: HeaderCellProps) {
if (variant === "pill") {
return <SortableHeaderPill name={name} sort={sort} />;
}
@@ -28,4 +34,4 @@ export function HeaderCell({ name, sort, variant }: HeaderCellProps) {
)}
</Flex>
);
-}
+});
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
index 66468a2bfda..ba1aab7d442 100644
--- 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
@@ -7,10 +7,11 @@
flex-shrink: 0;
font-size: 12.5px;
background-color: var(--mb-color-background);
+ border-bottom: 1px solid var(--mb-color-border);
}
-.row {
- border-bottom: 1px solid var(--mb-color-border);
+.cell {
+ overflow: hidden;
}
.cell:first-child {
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
index 6a50a0a2b79..adac6bd4d66 100644
--- a/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableHeader/TreeTableHeader.tsx
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableHeader/TreeTableHeader.tsx
@@ -1,5 +1,6 @@
import { flexRender } from "@tanstack/react-table";
import cx from "classnames";
+import { memo } from "react";
import { Flex } from "metabase/ui";
@@ -10,7 +11,7 @@ import { getColumnStyle } from "../utils";
import { HeaderCell } from "./HeaderCell";
import S from "./TreeTableHeader.module.css";
-export function TreeTableHeader<TData extends TreeNodeData>({
+function TreeTableHeaderInner<TData extends TreeNodeData>({
table,
columnWidths,
showCheckboxes,
@@ -34,7 +35,7 @@ export function TreeTableHeader<TData extends TreeNodeData>({
{headerGroups.map((headerGroup) => (
<Flex
key={headerGroup.id}
- className={cx(S.row, classNames?.headerRow)}
+ className={classNames?.headerRow}
w="100%"
style={{ minWidth: totalContentWidth, ...styles?.headerRow }}
>
@@ -111,3 +112,9 @@ export function TreeTableHeader<TData extends TreeNodeData>({
</Flex>
);
}
+
+export const TreeTableHeader = memo(TreeTableHeaderInner) as <
+ TData extends TreeNodeData,
+>(
+ props: TreeTableHeaderProps<TData>,
+) => JSX.Element;
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
index 5ce09c02bea..0aba23603a4 100644
--- 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
@@ -1,5 +1,16 @@
.root {
- border-bottom: 1px solid var(--mb-color-border);
+ position: absolute;
+ top: 0;
+ left: 0;
+ width: 100%;
+
+ &:not(:last-child) .content {
+ border-bottom: 1px solid var(--mb-color-border);
+ }
+}
+
+.content {
+ display: flex;
cursor: pointer;
&:hover {
@@ -14,10 +25,6 @@
&:focus-visible {
box-shadow: inset 0 0 0 2px var(--mb-color-focus);
}
-
- &:last-child {
- border-bottom: none;
- }
}
.active {
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
index 6ddb600b476..6e789ea2889 100644
--- a/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableRow/TreeTableRow.tsx
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableRow/TreeTableRow.tsx
@@ -1,37 +1,74 @@
+import type { Row, Table } from "@tanstack/react-table";
import { flexRender } from "@tanstack/react-table";
import cx from "classnames";
+import type { MouseEvent } from "react";
+import { memo, useMemo } from "react";
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 { DEFAULT_ROW_HEIGHT, TREE_CELL_BASE_PADDING } from "../constants";
+import type {
+ SelectionState,
+ TreeNodeData,
+ TreeTableRowProps,
+ TreeTableStylesProps,
+} from "../types";
import { getColumnStyle } from "../utils";
import S from "./TreeTableRow.module.css";
-export function TreeTableRow<TData extends TreeNodeData>({
+interface TreeTableRowContentProps<TData extends TreeNodeData>
+ extends TreeTableStylesProps {
+ row: Row<TData>;
+ rowIndex: number;
+ table: Table<TData>;
+ columnWidths: Record<string, number>;
+ showCheckboxes: boolean;
+ showExpandButtons: boolean;
+ indentWidth: number;
+ activeRowId: string | null;
+ selectedRowId: string | null;
+ isDisabled?: boolean;
+ isChildrenLoading?: boolean;
+ isExpanded: boolean;
+ canExpand: boolean;
+ getSelectionState?: (row: Row<TData>) => SelectionState;
+ onCheckboxClick?: (row: Row<TData>, index: number, event: MouseEvent) => void;
+ onRowClick?: (row: Row<TData>, event: MouseEvent) => void;
+ onRowDoubleClick?: (row: Row<TData>, event: MouseEvent) => void;
+ rowProps?: Record<string, unknown>;
+}
+
+// Memoized component that does not depend on virtualItem for performance reasons
+const TreeTableRowContent = memo(function TreeTableRowContent<
+ TData extends TreeNodeData,
+>({
row,
rowIndex,
- virtualItem,
table,
columnWidths,
showCheckboxes,
showExpandButtons,
indentWidth,
activeRowId,
- measureElement,
- onRowClick,
- onRowDoubleClick,
+ selectedRowId,
isDisabled,
isChildrenLoading,
+ isExpanded,
+ canExpand,
getSelectionState,
onCheckboxClick,
+ onRowClick,
+ onRowDoubleClick,
classNames,
styles,
-}: TreeTableRowProps<TData>) {
- const isActive = activeRowId === row.id;
+ rowProps,
+}: TreeTableRowContentProps<TData>) {
+ const isKeyboardFocused = activeRowId === row.id;
+ const isSelected = selectedRowId === row.id;
+ const isActive = isKeyboardFocused || isSelected;
const indent = row.depth * indentWidth;
const visibleCells = row.getVisibleCells();
@@ -45,30 +82,25 @@ export function TreeTableRow<TData extends TreeNodeData>({
return (
<Flex
+ {...rowProps}
role="row"
- tabIndex={isDisabled ? -1 : isActive ? 0 : -1}
- data-index={virtualItem.index}
- ref={measureElement}
- className={cx(S.root, classNames?.row, {
+ tabIndex={isDisabled ? -1 : isKeyboardFocused ? 0 : -1}
+ data-keyboard-active={isKeyboardFocused ? true : undefined}
+ data-disabled={isDisabled ? true : undefined}
+ className={cx(S.content, 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"
+ h={DEFAULT_ROW_HEIGHT}
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"}
+ style={styles?.row}
+ aria-expanded={canExpand ? isExpanded : undefined}
+ aria-selected={isSelected}
aria-level={row.depth + 1}
onClick={(e) => onRowClick?.(row, e)}
onDoubleClick={(e) => onRowDoubleClick?.(row, e)}
@@ -116,8 +148,8 @@ export function TreeTableRow<TData extends TreeNodeData>({
>
{showExpandButtons && (
<ExpandButton
- canExpand={row.getCanExpand()}
- isExpanded={row.getIsExpanded()}
+ canExpand={canExpand}
+ isExpanded={isExpanded}
isLoading={isChildrenLoading}
onClick={(e) => {
e.stopPropagation();
@@ -158,4 +190,66 @@ export function TreeTableRow<TData extends TreeNodeData>({
})}
</Flex>
);
+}) as <TData extends TreeNodeData>(
+ props: TreeTableRowContentProps<TData>,
+) => JSX.Element;
+
+// Thin wrapper that handles positioning only
+export function TreeTableRow<TData extends TreeNodeData>({
+ row,
+ rowIndex,
+ virtualItem,
+ table,
+ columnWidths,
+ showCheckboxes,
+ showExpandButtons,
+ indentWidth,
+ activeRowId,
+ selectedRowId,
+ isExpanded,
+ canExpand,
+ measureElement,
+ onRowClick,
+ onRowDoubleClick,
+ isDisabled,
+ isChildrenLoading,
+ getSelectionState,
+ onCheckboxClick,
+ classNames,
+ styles,
+ getRowProps,
+}: TreeTableRowProps<TData>) {
+ const rowProps = useMemo(() => getRowProps?.(row), [getRowProps, row]);
+
+ return (
+ <div
+ ref={measureElement}
+ data-index={virtualItem.index}
+ className={S.root}
+ style={{ transform: `translateY(${virtualItem.start}px)` }}
+ >
+ <TreeTableRowContent
+ row={row}
+ rowIndex={rowIndex}
+ table={table}
+ columnWidths={columnWidths}
+ showCheckboxes={showCheckboxes}
+ showExpandButtons={showExpandButtons}
+ indentWidth={indentWidth}
+ activeRowId={activeRowId ?? null}
+ selectedRowId={selectedRowId ?? null}
+ isDisabled={isDisabled}
+ isChildrenLoading={isChildrenLoading}
+ isExpanded={isExpanded}
+ canExpand={canExpand}
+ getSelectionState={getSelectionState}
+ onCheckboxClick={onCheckboxClick}
+ onRowClick={onRowClick}
+ onRowDoubleClick={onRowDoubleClick}
+ classNames={classNames}
+ styles={styles}
+ rowProps={rowProps}
+ />
+ </div>
+ );
}
diff --git a/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableSkeleton/TreeTableSkeleton.module.css b/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableSkeleton/TreeTableSkeleton.module.css
new file mode 100644
index 00000000000..6536ed04247
--- /dev/null
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableSkeleton/TreeTableSkeleton.module.css
@@ -0,0 +1,12 @@
+.header {
+ background-color: var(--mb-color-background);
+ border-bottom: 1px solid var(--mb-color-border);
+}
+
+.row:not(:last-child) {
+ border-bottom: 1px solid var(--mb-color-border);
+}
+
+.checkboxColumn {
+ flex-shrink: 0;
+}
diff --git a/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableSkeleton/TreeTableSkeleton.tsx b/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableSkeleton/TreeTableSkeleton.tsx
new file mode 100644
index 00000000000..45e576cb088
--- /dev/null
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableSkeleton/TreeTableSkeleton.tsx
@@ -0,0 +1,65 @@
+import { Box, Flex, Skeleton, Stack } from "metabase/ui";
+
+import { CHECKBOX_COLUMN_WIDTH, DEFAULT_ROW_HEIGHT } from "../constants";
+
+import S from "./TreeTableSkeleton.module.css";
+
+const DEFAULT_ROWS_COUNT = 8;
+const HEADER_HEIGHT = 48;
+
+interface TreeTableSkeletonProps {
+ rowsCount?: number;
+ showCheckboxes?: boolean;
+ columnWidths?: number[];
+}
+
+export function TreeTableSkeleton({
+ rowsCount = DEFAULT_ROWS_COUNT,
+ showCheckboxes = false,
+ columnWidths = [0.4, 0.15, 0.1, 0.1],
+}: TreeTableSkeletonProps) {
+ const getColumnWidth = (index: number) => `${columnWidths[index] * 100}%`;
+
+ return (
+ <Stack gap={0} flex={1} mih={0}>
+ <Flex h={HEADER_HEIGHT} align="center" className={S.header}>
+ {showCheckboxes && (
+ <Box w={CHECKBOX_COLUMN_WIDTH} className={S.checkboxColumn} />
+ )}
+ {columnWidths.map((_, i) => (
+ <Flex
+ key={i}
+ align="center"
+ px="sm"
+ style={{ width: getColumnWidth(i) }}
+ >
+ <Skeleton h={12} natural />
+ </Flex>
+ ))}
+ </Flex>
+ {Array.from({ length: rowsCount }).map((_, i) => (
+ <Flex key={i} h={DEFAULT_ROW_HEIGHT} align="center" className={S.row}>
+ {showCheckboxes && (
+ <Flex
+ w={CHECKBOX_COLUMN_WIDTH}
+ justify="center"
+ className={S.checkboxColumn}
+ >
+ <Skeleton h={16} w={16} />
+ </Flex>
+ )}
+ {columnWidths.map((_, j) => (
+ <Flex
+ key={j}
+ align="center"
+ px="sm"
+ style={{ width: getColumnWidth(j) }}
+ >
+ <Skeleton h={14} natural />
+ </Flex>
+ ))}
+ </Flex>
+ ))}
+ </Stack>
+ );
+}
diff --git a/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableSkeleton/index.ts b/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableSkeleton/index.ts
new file mode 100644
index 00000000000..99c38382e4f
--- /dev/null
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/TreeTableSkeleton/index.ts
@@ -0,0 +1 @@
+export { TreeTableSkeleton } from "./TreeTableSkeleton";
diff --git a/frontend/src/metabase/ui/components/data-display/TreeTable/constants.ts b/frontend/src/metabase/ui/components/data-display/TreeTable/constants.ts
index d3d4196c643..09e58add4d4 100644
--- a/frontend/src/metabase/ui/components/data-display/TreeTable/constants.ts
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/constants.ts
@@ -1,4 +1,4 @@
-export const DEFAULT_ROW_HEIGHT = 40;
+export const DEFAULT_ROW_HEIGHT = 44;
export const DEFAULT_INDENT_WIDTH = 20;
export const DEFAULT_OVERSCAN = 5;
export const CHECKBOX_COLUMN_WIDTH = 32;
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
index af9a904f064..b0e08d9cfb4 100644
--- a/frontend/src/metabase/ui/components/data-display/TreeTable/hooks/useColumnSizing.tsx
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/hooks/useColumnSizing.tsx
@@ -8,6 +8,7 @@ import {
removeMeasurementContainer,
} from "metabase/data-grid/utils/measure-utils";
import { renderRoot } from "metabase/lib/react-compat";
+import { SortableHeaderPill } from "metabase/ui";
import {
CELL_HORIZONTAL_PADDING,
@@ -101,6 +102,7 @@ export function calculateColumnWidths<TData extends TreeNodeData>(
const widths: Record<string, number> = {};
+ // Calculate fixed widths: numeric width or "auto" (measured from content)
const fixedWidth = columns
.filter((col) => col.width != null)
.reduce((sum, col) => {
@@ -112,10 +114,12 @@ export function calculateColumnWidths<TData extends TreeNodeData>(
let remainingSpace = containerWidth - fixedWidth;
+ // Columns without width are stretching columns
const stretchingColumnIds = new Set(
columns.filter((col) => col.width == null).map((col) => col.id),
);
+ // Set fixed widths
columns.forEach((column) => {
if (column.width != null) {
if (column.width === "auto") {
@@ -258,7 +262,7 @@ function MeasureContent<TData extends TreeNodeData>({
>
{typeof column.header === "string" && (
<div data-measure-header style={{ whiteSpace: "nowrap" }}>
- {column.header}
+ <SortableHeaderPill name={column.header} />
</div>
)}
{rowsToMeasure.map((row) => {
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
index 26d80fa383e..7039c824780 100644
--- 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
@@ -29,6 +29,10 @@ describe("needsMeasurement", () => {
expect(needsMeasurement(createColumn({ minWidth: 100 }))).toBe(false);
expect(needsMeasurement(createColumn({}))).toBe(false);
});
+
+ it("returns false when width is a number", () => {
+ expect(needsMeasurement(createColumn({ width: 100 }))).toBe(false);
+ });
});
describe("getMinConstraint", () => {
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
index b6f1a15e0b1..9f7c212105a 100644
--- a/frontend/src/metabase/ui/components/data-display/TreeTable/hooks/useTreeTableInstance.ts
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/hooks/useTreeTableInstance.ts
@@ -48,6 +48,7 @@ export function useTreeTableInstance<TData extends TreeNodeData>(
defaultRowHeight = DEFAULT_ROW_HEIGHT,
overscan = DEFAULT_OVERSCAN,
onRowActivate,
+ selectedRowId,
} = options;
const containerRef = useRef<HTMLDivElement>(null);
@@ -258,5 +259,6 @@ export function useTreeTableInstance<TData extends TreeNodeData>(
activeRowId: keyboard.activeRowId,
setActiveRowId: keyboard.setActiveRowId,
handleKeyDown: keyboard.handleKeyDown,
+ selectedRowId: selectedRowId ?? null,
};
}
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
index ee6ee12e00d..2432aed51ee 100644
--- a/frontend/src/metabase/ui/components/data-display/TreeTable/hooks/useTreeTableKeyboard.ts
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/hooks/useTreeTableKeyboard.ts
@@ -83,18 +83,16 @@ export function useTreeTableKeyboard<TData extends TreeNodeData>({
case "Enter": {
event.preventDefault();
if (currentRow) {
- if (currentRow.getCanExpand()) {
- currentRow.toggleExpanded();
- } else {
- onRowActivate?.(currentRow);
- }
+ onRowActivate?.(currentRow);
}
break;
}
case " ": {
event.preventDefault();
- if (enableRowSelection && currentRow?.getCanSelect()) {
+ if (currentRow?.getCanExpand()) {
+ currentRow.toggleExpanded();
+ } else if (enableRowSelection && currentRow?.getCanSelect()) {
currentRow.toggleSelected();
}
break;
diff --git a/frontend/src/metabase/ui/components/data-display/TreeTable/index.ts b/frontend/src/metabase/ui/components/data-display/TreeTable/index.ts
index b7018c32207..8ca133eb7ea 100644
--- a/frontend/src/metabase/ui/components/data-display/TreeTable/index.ts
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/index.ts
@@ -1,5 +1,6 @@
export { EntityNameCell } from "./EntityNameCell";
export { TreeTable } from "./TreeTable";
+export { TreeTableSkeleton } from "./TreeTableSkeleton";
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
index f1484393ac4..50e3fc46ea2 100644
--- a/frontend/src/metabase/ui/components/data-display/TreeTable/types.ts
+++ b/frontend/src/metabase/ui/components/data-display/TreeTable/types.ts
@@ -97,6 +97,12 @@ export interface UseTreeTableInstanceOptions<TData extends TreeNodeData> {
* Use this to navigate to the item or perform the primary action.
*/
onRowActivate?: (row: Row<TData>) => void;
+
+ /**
+ * ID of the currently selected row.
+ * Independent from keyboard navigation focus.
+ */
+ selectedRowId?: string | null;
}
/**
@@ -134,6 +140,8 @@ export interface TreeTableInstance<TData extends TreeNodeData> {
activeRowId: string | null;
setActiveRowId: (id: string | null) => void;
handleKeyDown: (event: KeyboardEvent<HTMLElement>) => void;
+
+ selectedRowId: string | null;
}
export type TreeTableStylesNames =
@@ -198,6 +206,18 @@ export interface TreeTableProps<TData extends TreeNodeData>
*/
isChildrenLoading?: (row: Row<TData>) => boolean;
+ /**
+ * Callback to determine if a row is disabled.
+ * Disabled rows have pointer-events: none and reduced opacity.
+ */
+ isRowDisabled?: (row: Row<TData>) => boolean;
+
+ /**
+ * Callback to get additional props for each row element.
+ * Useful for adding test IDs or custom data attributes.
+ */
+ getRowProps?: (row: Row<TData>) => Record<string, unknown>;
+
ariaLabel?: string;
ariaLabelledBy?: string;
}
@@ -216,6 +236,9 @@ export interface TreeTableRowProps<TData extends TreeNodeData>
showExpandButtons: boolean;
indentWidth: number;
activeRowId: string | null;
+ selectedRowId?: string | null;
+ isExpanded: boolean;
+ canExpand: boolean;
measureElement: (element: HTMLElement | null) => void;
onRowClick?: (row: Row<TData>, event: MouseEvent) => void;
onRowDoubleClick?: (row: Row<TData>, event: MouseEvent) => void;
@@ -223,6 +246,7 @@ export interface TreeTableRowProps<TData extends TreeNodeData>
isChildrenLoading?: boolean;
getSelectionState?: (row: Row<TData>) => SelectionState;
onCheckboxClick?: (row: Row<TData>, index: number, event: MouseEvent) => void;
+ getRowProps?: (row: Row<TData>) => Record<string, unknown>;
}
/**