Skip to content

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

Refactor - Organize TablePicker (#64617)

Kamil Mielnik1d88be213509
diff --git a/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/TablePicker.tsx b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/TablePicker.tsx
deleted file mode 100644
index 49469036e76..00000000000
--- a/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/TablePicker.tsx
+++ /dev/null
@@ -1,197 +0,0 @@
-import { useDeferredValue, useEffect, useState } from "react";
-import { useKeyPressEvent } from "react-use";
-import { t } from "ttag";
-
-import { useDebouncedValue } from "metabase/common/hooks/use-debounced-value";
-import { Box, Flex, Icon, Input, Stack, rem } from "metabase/ui";
-
-import { Results } from "./Results";
-import S from "./TablePicker.module.css";
-import type { ChangeOptions, TreePath } from "./types";
-import { flatten, useExpandedState, useSearch, useTableLoader } from "./utils";
-
-export function TablePicker({
- path,
- onChange,
-}: {
- path: TreePath;
- onChange: (path: TreePath, options?: ChangeOptions) => void;
-}) {
- const [query, setQuery] = useState("");
- const deferredQuery = useDeferredValue(query);
-
- return (
- <Stack data-testid="table-picker" mih={rem(200)}>
- <Box p="xl" pb={0}>
- <Input
- leftSection={<Icon name="search" />}
- placeholder={t`Search tables`}
- value={query}
- onChange={(event) => setQuery(event.target.value)}
- />
- </Box>
-
- {deferredQuery === "" ? (
- <Tree path={path} onChange={onChange} />
- ) : (
- <Search query={deferredQuery} path={path} onChange={onChange} />
- )}
- </Stack>
- );
-}
-
-function Tree({
- path,
- onChange,
-}: {
- path: TreePath;
- onChange: (path: TreePath, options?: ChangeOptions) => void;
-}) {
- const { databaseId, schemaName } = path;
- const { isExpanded, toggle } = useExpandedState(path);
- const { tree, reload } = useTableLoader(path);
-
- const items = flatten(tree, {
- isExpanded,
- addLoadingNodes: true,
- canFlattenSingleSchema: true,
- });
- const isEmpty = items.length === 0;
-
- useEffect(() => {
- // When we detect only one database, we automatically select and expand it.
- const databases = tree.children.filter((node) => node.type === "database");
-
- if (databases.length !== 1) {
- return;
- }
-
- const [database] = databases;
-
- if (
- !isExpanded({ databaseId: database.value.databaseId }) &&
- databaseId == null
- ) {
- toggle(database.key, true);
- onChange(database.value, { isAutomatic: true });
- }
- }, [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) =>
- node.type === "database" && node.value.databaseId === databaseId,
- );
- if (
- databaseId &&
- isExpanded({ databaseId }) &&
- database?.children.length === 1 &&
- schemaName == null
- ) {
- const schema = database.children[0];
- if (schema.type === "schema") {
- toggle(schema.key, true);
- onChange(schema.value, { isAutomatic: true });
- }
- }
- }, [databaseId, schemaName, tree, toggle, isExpanded, onChange]);
-
- if (isEmpty) {
- return <EmptyState title={t`No data to show`} />;
- }
-
- return (
- <Results
- items={items}
- path={path}
- reload={reload}
- toggle={toggle}
- withMassToggle
- onItemClick={onChange}
- />
- );
-}
-
-function Search({
- query,
- path,
- onChange,
-}: {
- query: string;
- path: TreePath;
- onChange: (path: TreePath) => void;
-}) {
- const debouncedQuery = useDebouncedValue(query, 300);
- const { tree, isLoading } = useSearch(debouncedQuery);
- const [selectedIndex, setSelectedIndex] = useState(-1);
-
- const items = flatten(tree);
- const isEmpty = !isLoading && items.length === 0;
-
- // search results need their own keypress handling logic
- // because we want to keep the focus on the search input
- useKeyPressEvent("ArrowDown", (event) => {
- setSelectedIndex((selectedIndex) => {
- const nextTableIndex = items.findIndex(
- (item, index) => item.type === "table" && index > selectedIndex,
- );
- if (nextTableIndex >= 0) {
- return nextTableIndex;
- }
- const firstTableIndex = items.findIndex((item) => item.type === "table");
- return firstTableIndex;
- });
- event.preventDefault();
- });
-
- useKeyPressEvent("ArrowUp", (event) => {
- setSelectedIndex((selectedIndex) => {
- const previousTableIndex = items.findLastIndex(
- (item, index) => item.type === "table" && index < selectedIndex,
- );
- if (previousTableIndex >= 0) {
- return previousTableIndex;
- }
- const lastTableIndex = items.findLastIndex(
- (item) => item.type === "table",
- );
- return lastTableIndex;
- });
- event.preventDefault();
- });
-
- useKeyPressEvent("Enter", (event) => {
- const item = items[selectedIndex];
- if (item?.value) {
- onChange?.(item.value);
- event.preventDefault();
- }
- });
-
- if (isEmpty) {
- return <EmptyState title={t`No results.`} />;
- }
-
- return (
- <Results
- items={items}
- path={path}
- onItemClick={onChange}
- selectedIndex={selectedIndex}
- onSelectedIndexChange={setSelectedIndex}
- />
- );
-}
-
-function EmptyState({ title }: { title: string }) {
- return (
- <Stack py="xl" align="center" className={S.emptyState} gap="md">
- <Flex className={S.empyIcon} p="lg" align="center" justify="center">
- <Icon name="table2" />
- </Flex>
- <Box>{title}</Box>
- </Stack>
- );
-}
diff --git a/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/BulkTableVisibilityToggle.tsx b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/components/BulkTableVisibilityToggle.tsx
similarity index 100%
rename from frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/BulkTableVisibilityToggle.tsx
rename to frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/components/BulkTableVisibilityToggle.tsx
diff --git a/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/TablePicker.module.css b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/components/EmptyState.module.css
similarity index 100%
rename from frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/TablePicker.module.css
rename to frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/components/EmptyState.module.css
diff --git a/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/components/EmptyState.tsx b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/components/EmptyState.tsx
new file mode 100644
index 00000000000..9f1607309fe
--- /dev/null
+++ b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/components/EmptyState.tsx
@@ -0,0 +1,18 @@
+import { Box, Flex, Icon, Stack } from "metabase/ui";
+
+import S from "./EmptyState.module.css";
+
+interface Props {
+ title: string;
+}
+
+export function EmptyState({ title }: Props) {
+ return (
+ <Stack py="xl" align="center" className={S.emptyState} gap="md">
+ <Flex className={S.empyIcon} p="lg" align="center" justify="center">
+ <Icon name="table2" />
+ </Flex>
+ <Box>{title}</Box>
+ </Stack>
+ );
+}
diff --git a/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/Results.module.css b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/components/Results.module.css
similarity index 100%
rename from frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/Results.module.css
rename to frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/components/Results.module.css
diff --git a/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/Results.tsx b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/components/Results.tsx
similarity index 98%
rename from frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/Results.tsx
rename to frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/components/Results.tsx
index 793ac290667..2791aa1a822 100644
--- a/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/Results.tsx
+++ b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/components/Results.tsx
@@ -5,13 +5,14 @@ import { Link } from "react-router";
import { Box, Flex, Icon, Skeleton, rem } from "metabase/ui";
-import { getUrl } from "../../utils";
+import { getUrl } from "../../../utils";
+import { TYPE_ICONS } from "../constants";
+import type { FlatItem, TreePath } from "../types";
+import { hasChildren } from "../utils";
import { BulkTableVisibilityToggle } from "./BulkTableVisibilityToggle";
import S from "./Results.module.css";
import { TableVisibilityToggle } from "./TableVisibilityToggle";
-import type { FlatItem, TreePath } from "./types";
-import { TYPE_ICONS, hasChildren } from "./utils";
const VIRTUAL_OVERSCAN = 5;
const ITEM_MIN_HEIGHT = 32; // items can vary in size because of text wrapping
diff --git a/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/components/Search.tsx b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/components/Search.tsx
new file mode 100644
index 00000000000..386a465e4a1
--- /dev/null
+++ b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/components/Search.tsx
@@ -0,0 +1,81 @@
+import { useState } from "react";
+import { useKeyPressEvent } from "react-use";
+import { t } from "ttag";
+
+import { useDebouncedValue } from "metabase/common/hooks/use-debounced-value";
+
+import { useSearch } from "../hooks";
+import type { TreePath } from "../types";
+import { flatten } from "../utils";
+
+import { EmptyState } from "./EmptyState";
+import { Results } from "./Results";
+
+interface Props {
+ query: string;
+ path: TreePath;
+ onChange: (path: TreePath) => void;
+}
+
+export function Search({ query, path, onChange }: Props) {
+ const debouncedQuery = useDebouncedValue(query, 300);
+ const { tree, isLoading } = useSearch(debouncedQuery);
+ const [selectedIndex, setSelectedIndex] = useState(-1);
+
+ const items = flatten(tree);
+ const isEmpty = !isLoading && items.length === 0;
+
+ // search results need their own keypress handling logic
+ // because we want to keep the focus on the search input
+ useKeyPressEvent("ArrowDown", (event) => {
+ setSelectedIndex((selectedIndex) => {
+ const nextTableIndex = items.findIndex(
+ (item, index) => item.type === "table" && index > selectedIndex,
+ );
+ if (nextTableIndex >= 0) {
+ return nextTableIndex;
+ }
+ const firstTableIndex = items.findIndex((item) => item.type === "table");
+ return firstTableIndex;
+ });
+ event.preventDefault();
+ });
+
+ useKeyPressEvent("ArrowUp", (event) => {
+ setSelectedIndex((selectedIndex) => {
+ const previousTableIndex = items.findLastIndex(
+ (item, index) => item.type === "table" && index < selectedIndex,
+ );
+ if (previousTableIndex >= 0) {
+ return previousTableIndex;
+ }
+ const lastTableIndex = items.findLastIndex(
+ (item) => item.type === "table",
+ );
+ return lastTableIndex;
+ });
+ event.preventDefault();
+ });
+
+ useKeyPressEvent("Enter", (event) => {
+ const item = items[selectedIndex];
+ if (item?.value) {
+ onChange?.(item.value);
+ event.preventDefault();
+ }
+ });
+
+ if (isEmpty) {
+ return <EmptyState title={t`No results.`} />;
+ }
+
+ return (
+ <Results
+ items={items}
+ path={path}
+ onItemClick={onChange}
+ selectedIndex={selectedIndex}
+ onSelectedIndexChange={setSelectedIndex}
+ />
+ );
+}
diff --git a/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/components/TablePicker.tsx b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/components/TablePicker.tsx
new file mode 100644
index 00000000000..1dc9e3823e2
--- /dev/null
+++ b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/components/TablePicker.tsx
@@ -0,0 +1,38 @@
+import { useDeferredValue, useState } from "react";
+import { t } from "ttag";
+
+import { Box, Icon, Input, Stack, rem } from "metabase/ui";
+
+import type { ChangeOptions, TreePath } from "../types";
+
+import { Search } from "./Search";
+import { Tree } from "./Tree";
+
+interface Props {
+ path: TreePath;
+ onChange: (path: TreePath, options?: ChangeOptions) => void;
+}
+
+export function TablePicker({ path, onChange }: Props) {
+ const [query, setQuery] = useState("");
+ const deferredQuery = useDeferredValue(query);
+
+ return (
+ <Stack data-testid="table-picker" mih={rem(200)}>
+ <Box p="xl" pb={0}>
+ <Input
+ leftSection={<Icon name="search" />}
+ placeholder={t`Search tables`}
+ value={query}
+ onChange={(event) => setQuery(event.target.value)}
+ />
+ </Box>
+
+ {deferredQuery === "" ? (
+ <Tree path={path} onChange={onChange} />
+ ) : (
+ <Search query={deferredQuery} path={path} onChange={onChange} />
+ )}
+ </Stack>
+ );
+}
diff --git a/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/TablePicker.unit.spec.tsx b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/components/TablePicker.unit.spec.tsx
similarity index 99%
rename from frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/TablePicker.unit.spec.tsx
rename to frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/components/TablePicker.unit.spec.tsx
index 430f7624ca7..b75f58e122b 100644
--- a/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/TablePicker.unit.spec.tsx
+++ b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/components/TablePicker.unit.spec.tsx
@@ -18,9 +18,8 @@ import {
createMockTable,
} from "metabase-types/api/mocks";
-import type { TreePath } from "./types";
-
-import { UncontrolledTablePicker } from ".";
+import type { TreePath } from "../types";
+import { UncontrolledTablePicker } from "../wrappers";
let id = 1000;
function nextId() {
diff --git a/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/TableVisibilityToggle.tsx b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/components/TableVisibilityToggle.tsx
similarity index 100%
rename from frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/TableVisibilityToggle.tsx
rename to frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/components/TableVisibilityToggle.tsx
diff --git a/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/TableVisibilityToggle.unit.spec.tsx b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/components/TableVisibilityToggle.unit.spec.tsx
similarity index 100%
rename from frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/TableVisibilityToggle.unit.spec.tsx
rename to frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/components/TableVisibilityToggle.unit.spec.tsx
diff --git a/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/components/Tree.tsx b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/components/Tree.tsx
new file mode 100644
index 00000000000..04c44dbca83
--- /dev/null
+++ b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/components/Tree.tsx
@@ -0,0 +1,82 @@
+import { useEffect } from "react";
+import { t } from "ttag";
+
+import { useExpandedState, useTableLoader } from "../hooks";
+import type { ChangeOptions, TreePath } from "../types";
+import { flatten } from "../utils";
+
+import { EmptyState } from "./EmptyState";
+import { Results } from "./Results";
+
+interface Props {
+ path: TreePath;
+ onChange: (path: TreePath, options?: ChangeOptions) => void;
+}
+
+export function Tree({ path, onChange }: Props) {
+ const { databaseId, schemaName } = path;
+ const { isExpanded, toggle } = useExpandedState(path);
+ const { tree, reload } = useTableLoader(path);
+
+ const items = flatten(tree, {
+ isExpanded,
+ addLoadingNodes: true,
+ canFlattenSingleSchema: true,
+ });
+ const isEmpty = items.length === 0;
+
+ useEffect(() => {
+ // When we detect only one database, we automatically select and expand it.
+ const databases = tree.children.filter((node) => node.type === "database");
+
+ if (databases.length !== 1) {
+ return;
+ }
+
+ const [database] = databases;
+
+ if (
+ !isExpanded({ databaseId: database.value.databaseId }) &&
+ databaseId == null
+ ) {
+ toggle(database.key, true);
+ onChange(database.value, { isAutomatic: true });
+ }
+ }, [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) =>
+ node.type === "database" && node.value.databaseId === databaseId,
+ );
+ if (
+ databaseId &&
+ isExpanded({ databaseId }) &&
+ database?.children.length === 1 &&
+ schemaName == null
+ ) {
+ const schema = database.children[0];
+ if (schema.type === "schema") {
+ toggle(schema.key, true);
+ onChange(schema.value, { isAutomatic: true });
+ }
+ }
+ }, [databaseId, schemaName, tree, toggle, isExpanded, onChange]);
+
+ if (isEmpty) {
+ return <EmptyState title={t`No data to show`} />;
+ }
+
+ return (
+ <Results
+ items={items}
+ path={path}
+ reload={reload}
+ toggle={toggle}
+ withMassToggle
+ onItemClick={onChange}
+ />
+ );
+}
diff --git a/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/components/index.ts b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/components/index.ts
new file mode 100644
index 00000000000..0be6cdf2bd9
--- /dev/null
+++ b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/components/index.ts
@@ -0,0 +1 @@
+export * from "./TablePicker";
diff --git a/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/constants.ts b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/constants.ts
new file mode 100644
index 00000000000..414a10d38c0
--- /dev/null
+++ b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/constants.ts
@@ -0,0 +1,17 @@
+import type { IconName } from "metabase/ui";
+
+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",
+ database: "database",
+};
diff --git a/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/hooks/index.ts b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/hooks/index.ts
new file mode 100644
index 00000000000..198d9c570ff
--- /dev/null
+++ b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/hooks/index.ts
@@ -0,0 +1,3 @@
+export * from "./useExpandedState";
+export * from "./useSearch";
+export * from "./useTableLoader";
diff --git a/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/hooks/useExpandedState.ts b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/hooks/useExpandedState.ts
new file mode 100644
index 00000000000..4a9eb7f7d98
--- /dev/null
+++ b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/hooks/useExpandedState.ts
@@ -0,0 +1,39 @@
+import { useCallback, useEffect, useState } from "react";
+
+import type { TreePath } from "../types";
+import { expandPath, toKey } from "../utils";
+
+/**
+ * Returns a state object that indicates which nodes are expanded in the tree.
+ */
+export function useExpandedState(path: TreePath) {
+ const [state, setState] = useState(expandPath({}, path));
+
+ const { databaseId, schemaName, tableId } = path;
+
+ useEffect(() => {
+ // When the path changes, this means a user has navigated throught 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);
+ return Boolean(state[key]);
+ },
+ [state],
+ );
+
+ const toggle = useCallback((key: string, value?: boolean) => {
+ setState((current) => ({
+ ...current,
+ [key]: value ?? !current[key],
+ }));
+ }, []);
+
+ return {
+ isExpanded,
+ toggle,
+ };
+}
diff --git a/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/hooks/useSearch.ts b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/hooks/useSearch.ts
new file mode 100644
index 00000000000..832e2da0d2b
--- /dev/null
+++ b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/hooks/useSearch.ts
@@ -0,0 +1,89 @@
+import { useMemo } from "react";
+
+import { skipToken, useSearchQuery } from "metabase/api";
+import { isSyncCompleted } from "metabase/lib/syncing";
+
+import type { DatabaseNode, SchemaNode, TableNode, TreeNode } from "../types";
+import { node, rootNode } from "../utils";
+
+/**
+ * Fetch items from the search API and renders them as a TreeNode so we can use the same
+ * data structure for the tree and the search results and render them in a consistent way.
+ */
+export function useSearch(query: string) {
+ const { data, isLoading } = useSearchQuery(
+ query === ""
+ ? skipToken
+ : {
+ q: query,
+ models: ["table"],
+ },
+ );
+
+ const tree = useMemo(() => {
+ const tree: TreeNode = rootNode();
+
+ data?.data.forEach((result) => {
+ const { model, database_name, database_id, table_schema, id, name } =
+ result;
+ const tableSchema = table_schema ?? "";
+
+ if (model !== "table" || database_name === null) {
+ return;
+ }
+
+ let databaseNode = tree.children.find(
+ (node) =>
+ node.type === "database" && node.value.databaseId === database_id,
+ );
+ if (!databaseNode) {
+ databaseNode = node<DatabaseNode>({
+ type: "database",
+ label: database_name,
+ value: {
+ databaseId: database_id,
+ },
+ });
+ tree.children.push(databaseNode);
+ }
+
+ let schemaNode = databaseNode.children.find((node) => {
+ return node.type === "schema" && node.value.schemaName === tableSchema;
+ });
+ if (!schemaNode) {
+ schemaNode = node<SchemaNode>({
+ type: "schema",
+ label: tableSchema,
+ value: {
+ databaseId: database_id,
+ schemaName: tableSchema,
+ },
+ });
+ databaseNode.children.push(schemaNode);
+ }
+
+ let tableNode = schemaNode.children.find(
+ (node) => node.type === "table" && node.value.tableId === id,
+ );
+ if (!tableNode) {
+ tableNode = node<TableNode>({
+ type: "table",
+ label: name,
+ value: {
+ databaseId: database_id,
+ schemaName: tableSchema,
+ tableId: id,
+ },
+ disabled: !isSyncCompleted(result),
+ });
+ schemaNode.children.push(tableNode);
+ }
+ });
+ return tree;
+ }, [data]);
+
+ return {
+ isLoading,
+ tree,
+ };
+}
diff --git a/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/hooks/useTableLoader.ts b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/hooks/useTableLoader.ts
new file mode 100644
index 00000000000..21441947568
--- /dev/null
+++ b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/hooks/useTableLoader.ts
@@ -0,0 +1,195 @@
+import { useCallback, useState } from "react";
+import { useDeepCompareEffect, useLatest } from "react-use";
+import _ from "underscore";
+
+import {
+ useLazyListDatabaseSchemaTablesQuery,
+ useLazyListDatabaseSchemasQuery,
+ useLazyListDatabasesQuery,
+} from "metabase/api";
+import { isSyncCompleted } from "metabase/lib/syncing";
+import type { DatabaseId, SchemaName } from "metabase-types/api";
+
+import { UNNAMED_SCHEMA_NAME } from "../constants";
+import type {
+ DatabaseNode,
+ SchemaNode,
+ TableNode,
+ TreeNode,
+ TreePath,
+} from "../types";
+import { merge, node, rootNode } from "../utils";
+
+/**
+ * For the currently view path, fetches the database, schema and table (or any subset that applies to the path).
+ *
+ * This state is managed at the top-level so we can generate a flat list of all nodes in the tree,
+ * which makes virtualization possible.
+ *
+ * This also makes it easier to do state transformations which needs more information than is available
+ * locally at any node in the path.
+ *
+ * This works by fetching the data and then recursively merging the results into the tree of data that was already fetched.
+ */
+export function useTableLoader(path: TreePath) {
+ const [fetchDatabases, databases] = useLazyListDatabasesQuery();
+ const [fetchSchemas, schemas] = useLazyListDatabaseSchemasQuery();
+ const [fetchTables, tables] = useLazyListDatabaseSchemaTablesQuery();
+ const databasesRef = useLatest(databases);
+ const schemasRef = useLatest(schemas);
+ const tablesRef = useLatest(tables);
+
+ const [tree, setTree] = useState<TreeNode>(rootNode());
+
+ const getDatabases = useCallback(async () => {
+ const response = await fetchDatabases(
+ { include_editable_data_model: true },
+ true,
+ );
+
+ if (databasesRef.current.isError) {
+ // Do not refetch when this call failed previously.
+ // This is to prevent infinite data-loading loop as RTK query does not cache error responses.
+ return [];
+ }
+
+ return (
+ response.data?.data.map((database) =>
+ node<DatabaseNode>({
+ type: "database",
+ label: database.name,
+ value: { databaseId: database.id },
+ }),
+ ) ?? []
+ );
+ }, [fetchDatabases, databasesRef]);
+
+ const getTables = useCallback(
+ async (
+ databaseId: DatabaseId | undefined,
+ schemaName: SchemaName | undefined,
+ ) => {
+ if (databaseId === undefined || schemaName === undefined) {
+ return [];
+ }
+
+ const newArgs = {
+ id: databaseId,
+ schema: schemaName,
+ include_hidden: true,
+ include_editable_data_model: true,
+ };
+
+ if (
+ tablesRef.current.isError &&
+ _.isEqual(tablesRef.current.originalArgs, newArgs)
+ ) {
+ // Do not refetch when this call failed previously.
+ // This is to prevent infinite data-loading loop as RTK query does not cache error responses.
+ return [];
+ }
+
+ const response = await fetchTables(newArgs, true);
+
+ return (
+ response?.data?.map((table) =>
+ node<TableNode>({
+ type: "table",
+ label: table.display_name,
+ value: { databaseId, schemaName, tableId: table.id },
+ table,
+ disabled: !isSyncCompleted(table),
+ }),
+ ) ?? []
+ );
+ },
+ [fetchTables, tablesRef],
+ );
+
+ const getSchemas = useCallback(
+ async (databaseId: DatabaseId | undefined) => {
+ if (databaseId === undefined) {
+ return [];
+ }
+
+ const newArgs = {
+ id: databaseId,
+ include_hidden: true,
+ include_editable_data_model: true,
+ };
+
+ if (
+ schemasRef.current.isError &&
+ _.isEqual(schemasRef.current.originalArgs, newArgs)
+ ) {
+ // Do not refetch when this call failed previously.
+ // This is to prevent infinite data-loading loop as RTK query does not cache error responses.
+ return [];
+ }
+
+ const response = await fetchSchemas(newArgs, true);
+ return Promise.all(
+ response.data?.map(async (schemaName, _, schemas) => {
+ const schema = node<SchemaNode>({
+ type: "schema",
+ label: schemaName,
+ value: { databaseId, schemaName },
+ });
+
+ // If the schema is unnamed, or if it's the only schema in the database,
+ // fetch the tables immediately so we can render a flattened tree.
+ if (schemaName === UNNAMED_SCHEMA_NAME || schemas.length === 1) {
+ schema.children = await getTables(databaseId, schemaName);
+ }
+ return schema;
+ }) ?? [],
+ );
+ },
+ [fetchSchemas, getTables, schemasRef],
+ );
+
+ const load = useCallback(
+ async function (path: TreePath) {
+ const { databaseId, schemaName } = path;
+ const [databases, schemas, tables] = await Promise.all([
+ getDatabases(),
+ getSchemas(path.databaseId),
+ getTables(path.databaseId, path.schemaName),
+ ]);
+
+ const newTree: TreeNode = rootNode(
+ databases.map((database) => ({
+ ...database,
+ children:
+ database.value.databaseId !== databaseId
+ ? database.children
+ : schemas.map((schema) => ({
+ ...schema,
+ children:
+ schema.value.schemaName !== schemaName
+ ? schema.children
+ : tables,
+ })),
+ })),
+ );
+ setTree((current) => {
+ const merged = merge(current, newTree);
+ return _.isEqual(current, merged) ? current : merged;
+ });
+ },
+ [getDatabases, getSchemas, getTables],
+ );
+
+ useDeepCompareEffect(() => {
+ load(path);
+ }, [
+ load,
+ path,
+ // When a table is modified, e.g. we change display_name with PUT /api/table/:id
+ // we need to manually call the lazy RTK hooks, so that the the updated table
+ // is refetched here. We detect this modification with tables.isFetching.
+ tables.isFetching,
+ ]);
+
+ return { tree, reload: load };
+}
diff --git a/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/index.ts b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/index.ts
index 0bd13034721..c383cef74b7 100644
--- a/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/index.ts
+++ b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/index.ts
@@ -1,2 +1,2 @@
-export * from "./TablePicker";
+export { TablePicker } from "./components";
export * from "./wrappers";
diff --git a/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/utils.ts b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/utils.ts
index 934ebbc5c8c..2d5be4dfd47 100644
--- a/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/utils.ts
+++ b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/utils.ts
@@ -1,20 +1,6 @@
-import { useCallback, useEffect, useMemo, useState } from "react";
-import { useDeepCompareEffect, useLatest } from "react-use";
-import _ from "underscore";
-
-import {
- skipToken,
- useLazyListDatabaseSchemaTablesQuery,
- useLazyListDatabaseSchemasQuery,
- useLazyListDatabasesQuery,
- useSearchQuery,
-} from "metabase/api";
-import { isSyncCompleted } from "metabase/lib/syncing";
-import type { IconName } from "metabase/ui";
-import type { DatabaseId, SchemaName } from "metabase-types/api";
-
import { getUrl as getUrl_ } from "../../utils";
+import { CHILD_TYPES, UNNAMED_SCHEMA_NAME } from "./constants";
import type {
DatabaseNode,
ExpandedState,
@@ -22,25 +8,10 @@ import type {
ItemType,
NodeKey,
RootNode,
- SchemaNode,
- TableNode,
TreeNode,
TreePath,
} from "./types";
-const UNNAMED_SCHEMA_NAME = "";
-const CHILD_TYPES = {
- database: "schema",
- schema: "table",
- table: null,
-} as const;
-
-export const TYPE_ICONS: Record<ItemType, IconName> = {
- table: "table2",
- schema: "folder",
- database: "database",
-};
-
export function hasChildren(type: ItemType): boolean {
return type !== "table";
}
@@ -55,299 +26,11 @@ export function getUrl(value: TreePath) {
});
}
-/**
- * For the currently view path, fetches the database, schema and table (or any subset that applies to the path).
- *
- * This state is managed at the top-level so we can generate a flat list of all nodes in the tree,
- * which makes virtualization possible.
- *
- * This also makes it easier to do state transformations which needs more information than is available
- * locally at any node in the path.
- *
- * This works by fetching the data and then recursively merging the results into the tree of data that was already fetched.
- */
-export function useTableLoader(path: TreePath) {
- const [fetchDatabases, databases] = useLazyListDatabasesQuery();
- const [fetchSchemas, schemas] = useLazyListDatabaseSchemasQuery();
- const [fetchTables, tables] = useLazyListDatabaseSchemaTablesQuery();
- const databasesRef = useLatest(databases);
- const schemasRef = useLatest(schemas);
- const tablesRef = useLatest(tables);
-
- const [tree, setTree] = useState<TreeNode>(rootNode());
-
- const getDatabases = useCallback(async () => {
- const response = await fetchDatabases(
- { include_editable_data_model: true },
- true,
- );
-
- if (databasesRef.current.isError) {
- // Do not refetch when this call failed previously.
- // This is to prevent infinite data-loading loop as RTK query does not cache error responses.
- return [];
- }
-
- return (
- response.data?.data.map((database) =>
- node<DatabaseNode>({
- type: "database",
- label: database.name,
- value: { databaseId: database.id },
- }),
- ) ?? []
- );
- }, [fetchDatabases, databasesRef]);
-
- const getTables = useCallback(
- async (
- databaseId: DatabaseId | undefined,
- schemaName: SchemaName | undefined,
- ) => {
- if (databaseId === undefined || schemaName === undefined) {
- return [];
- }
-
- const newArgs = {
- id: databaseId,
- schema: schemaName,
- include_hidden: true,
- include_editable_data_model: true,
- };
-
- if (
- tablesRef.current.isError &&
- _.isEqual(tablesRef.current.originalArgs, newArgs)
- ) {
- // Do not refetch when this call failed previously.
- // This is to prevent infinite data-loading loop as RTK query does not cache error responses.
- return [];
- }
-
- const response = await fetchTables(newArgs, true);
-
- return (
- response?.data?.map((table) =>
- node<TableNode>({
- type: "table",
- label: table.display_name,
- value: { databaseId, schemaName, tableId: table.id },
- table,
- disabled: !isSyncCompleted(table),
- }),
- ) ?? []
- );
- },
- [fetchTables, tablesRef],
- );
-
- const getSchemas = useCallback(
- async (databaseId: DatabaseId | undefined) => {
- if (databaseId === undefined) {
- return [];
- }
-
- const newArgs = {
- id: databaseId,
- include_hidden: true,
- include_editable_data_model: true,
- };
-
- if (
- schemasRef.current.isError &&
- _.isEqual(schemasRef.current.originalArgs, newArgs)
- ) {
- // Do not refetch when this call failed previously.
- // This is to prevent infinite data-loading loop as RTK query does not cache error responses.
- return [];
- }
-
- const response = await fetchSchemas(newArgs, true);
- return Promise.all(
- response.data?.map(async (schemaName, _, schemas) => {
- const schema = node<SchemaNode>({
- type: "schema",
- label: schemaName,
- value: { databaseId, schemaName },
- });
-
- // If the schema is unnamed, or if it's the only schema in the database,
- // fetch the tables immediately so we can render a flattened tree.
- if (schemaName === UNNAMED_SCHEMA_NAME || schemas.length === 1) {
- schema.children = await getTables(databaseId, schemaName);
- }
- return schema;
- }) ?? [],
- );
- },
- [fetchSchemas, getTables, schemasRef],
- );
-
- const load = useCallback(
- async function (path: TreePath) {
- const { databaseId, schemaName } = path;
- const [databases, schemas, tables] = await Promise.all([
- getDatabases(),
- getSchemas(path.databaseId),
- getTables(path.databaseId, path.schemaName),
- ]);
-
- const newTree: TreeNode = rootNode(
- databases.map((database) => ({
- ...database,
- children:
- database.value.databaseId !== databaseId
- ? database.children
- : schemas.map((schema) => ({
- ...schema,
- children:
- schema.value.schemaName !== schemaName
- ? schema.children
- : tables,
- })),
- })),
- );
- setTree((current) => {
- const merged = merge(current, newTree);
- return _.isEqual(current, merged) ? current : merged;
- });
- },
- [getDatabases, getSchemas, getTables],
- );
-
- useDeepCompareEffect(() => {
- load(path);
- }, [
- load,
- path,
- // When a table is modified, e.g. we change display_name with PUT /api/table/:id
- // we need to manually call the lazy RTK hooks, so that the the updated table
- // is refetched here. We detect this modification with tables.isFetching.
- tables.isFetching,
- ]);
-
- return { tree, reload: load };
-}
-
-/**
- * Fetch items from the search API and renders them as a TreeNode so we can use the same
- * data structure for the tree and the search results and render them in a consistent way.
- */
-export function useSearch(query: string) {
- const { data, isLoading } = useSearchQuery(
- query === ""
- ? skipToken
- : {
- q: query,
- models: ["table"],
- },
- );
-
- const tree = useMemo(() => {
- const tree: TreeNode = rootNode();
-
- data?.data.forEach((result) => {
- const { model, database_name, database_id, table_schema, id, name } =
- result;
- const tableSchema = table_schema ?? "";
-
- if (model !== "table" || database_name === null) {
- return;
- }
-
- let databaseNode = tree.children.find(
- (node) =>
- node.type === "database" && node.value.databaseId === database_id,
- );
- if (!databaseNode) {
- databaseNode = node<DatabaseNode>({
- type: "database",
- label: database_name,
- value: {
- databaseId: database_id,
- },
- });
- tree.children.push(databaseNode);
- }
-
- let schemaNode = databaseNode.children.find((node) => {
- return node.type === "schema" && node.value.schemaName === tableSchema;
- });
- if (!schemaNode) {
- schemaNode = node<SchemaNode>({
- type: "schema",
- label: tableSchema,
- value: {
- databaseId: database_id,
- schemaName: tableSchema,
- },
- });
- databaseNode.children.push(schemaNode);
- }
-
- let tableNode = schemaNode.children.find(
- (node) => node.type === "table" && node.value.tableId === id,
- );
- if (!tableNode) {
- tableNode = node<TableNode>({
- type: "table",
- label: name,
- value: {
- databaseId: database_id,
- schemaName: tableSchema,
- tableId: id,
- },
- disabled: !isSyncCompleted(result),
- });
- schemaNode.children.push(tableNode);
- }
- });
- return tree;
- }, [data]);
-
- return {
- isLoading,
- tree,
- };
-}
-
-/**
- * Returns a state object that indicates which nodes are expanded in the tree.
- */
-export function useExpandedState(path: TreePath) {
- const [state, setState] = useState(expandPath({}, path));
-
- const { databaseId, schemaName, tableId } = path;
-
- useEffect(() => {
- // When the path changes, this means a user has navigated throught 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);
- return Boolean(state[key]);
- },
- [state],
- );
-
- const toggle = useCallback((key: string, value?: boolean) => {
- setState((current) => ({
- ...current,
- [key]: value ?? !current[key],
- }));
- }, []);
-
- return {
- isExpanded,
- toggle,
- };
-}
-
// Returns a new state object with all the nodes along the path expanded.
-function expandPath(state: ExpandedState, path: TreePath): ExpandedState {
+export function expandPath(
+ state: ExpandedState,
+ path: TreePath,
+): ExpandedState {
return {
...state,
[toKey({
@@ -451,7 +134,7 @@ export function flatten(
];
}
-function sort(nodes: TreeNode[]): TreeNode[] {
+export function sort(nodes: TreeNode[]): TreeNode[] {
return Array.from(nodes).sort((a, b) => {
return a.label.localeCompare(b.label);
});
@@ -460,7 +143,10 @@ function sort(nodes: TreeNode[]): TreeNode[] {
/**
* Merge two TreeNodes together.
*/
-function merge(a: TreeNode | undefined, b: TreeNode | undefined): TreeNode {
+export function merge(
+ a: TreeNode | undefined,
+ b: TreeNode | undefined,
+): TreeNode {
if (!a) {
if (!b) {
throw new Error("Both a and b are undefined");
@@ -492,13 +178,15 @@ function merge(a: TreeNode | undefined, b: TreeNode | undefined): TreeNode {
/**
* Create a unique key for a TreePath
*/
-function toKey({ databaseId, schemaName, tableId }: TreePath) {
+export function toKey({ databaseId, schemaName, tableId }: TreePath) {
return JSON.stringify([databaseId, schemaName, tableId]);
}
type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
-function node<T extends TreeNode>(x: Optional<T, "key" | "children">): T {
+export function node<T extends TreeNode>(
+ x: Optional<T, "key" | "children">,
+): T {
return {
...x,
key: toKey(x.value),
@@ -506,7 +194,7 @@ function node<T extends TreeNode>(x: Optional<T, "key" | "children">): T {
} as T;
}
-function rootNode(children: DatabaseNode[] = []): RootNode {
+export function rootNode(children: DatabaseNode[] = []): RootNode {
return node<RootNode>({
type: "root",
label: "",
@@ -515,7 +203,7 @@ function rootNode(children: DatabaseNode[] = []): RootNode {
});
}
-function loadingItem(
+export function loadingItem(
type: ItemType,
level: number,
parent?: TreeNode,
diff --git a/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/wrappers.tsx b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/wrappers.tsx
index 3854bc77665..950f19237f3 100644
--- a/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/wrappers.tsx
+++ b/frontend/src/metabase/metadata/pages/DataModel/components/TablePicker/wrappers.tsx
@@ -4,7 +4,7 @@ import { push, replace } from "react-router-redux";
import { useDispatch, useSelector } from "metabase/lib/redux";
import { getLocation } from "metabase/selectors/routing";
-import { TablePicker } from "./TablePicker";
+import { TablePicker } from "./components";
import type { ChangeOptions, TreePath } from "./types";
import { getUrl } from "./utils";