Skip to content

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

Restore the changes #82405 reverted (#82463)

Romeo Van Snick98486ccd5605
diff --git a/e2e/support/helpers/e2e-data-studio-helpers.ts b/e2e/support/helpers/e2e-data-studio-helpers.ts
index 2054e815c17..06ee45ce369 100644
--- a/e2e/support/helpers/e2e-data-studio-helpers.ts
+++ b/e2e/support/helpers/e2e-data-studio-helpers.ts
@@ -21,6 +21,12 @@ const editSnippetPage = () => cy.findByTestId("edit-snippet-page");
export const DataStudio = {
nav: () => cy.findByTestId("data-studio-nav"),
breadcrumbs: () => cy.findByTestId("data-studio-breadcrumbs"),
+ visit: () => {
+ cy.visit("/data-studio");
+ // The target is only known once the `hasSeenGuide` request comes back.
+ cy.location("pathname").should("match", /^\/data-studio\/.+/);
+ DataStudio.nav().should("be.visible");
+ },
Transforms: {
// The transform page shows a loader until the transform, databases and the
// lazy editor chunk have loaded, which can take longer than the default 4s
diff --git a/e2e/test/scenarios/data-studio/data-studio-library.cy.spec.ts b/e2e/test/scenarios/data-studio/data-studio-library.cy.spec.ts
index b30edbbd275..5a766efdb32 100644
--- a/e2e/test/scenarios/data-studio/data-studio-library.cy.spec.ts
+++ b/e2e/test/scenarios/data-studio/data-studio-library.cy.spec.ts
@@ -41,6 +41,8 @@ describe("scenarios > data studio > library", () => {
H.popover()
.findByText(/Data studio/)
.click();
+ // Let the Data Studio index redirect settle.
+ cy.location("pathname").should("not.eq", "/data-studio");
cy.log(
"Verify tracking event when opening Data Studio from the profile menu",
diff --git a/e2e/test/scenarios/data-studio/transforms/transforms.cy.spec.ts b/e2e/test/scenarios/data-studio/transforms/transforms.cy.spec.ts
index a571856a73e..3f154b09fcd 100644
--- a/e2e/test/scenarios/data-studio/transforms/transforms.cy.spec.ts
+++ b/e2e/test/scenarios/data-studio/transforms/transforms.cy.spec.ts
@@ -4356,8 +4356,7 @@ describe("scenarios > data studio > transforms > permissions > oss", () => {
cy.findByRole("columnheader", { name: /Transforms/ }).should("not.exist");
cy.log("Visit data studio page");
- cy.visit("/data-studio");
- H.DataStudio.nav().should("be.visible");
+ H.DataStudio.visit();
cy.log("Verify Transforms menu item is visible");
H.DataStudio.nav()
@@ -4430,8 +4429,7 @@ describe(
);
cy.log("Visit data studio page");
- cy.visit("/data-studio");
- H.DataStudio.nav().should("be.visible");
+ H.DataStudio.visit();
cy.log("Verify Transforms menu item is visible");
H.DataStudio.nav()
diff --git a/e2e/test/scenarios/schema-viewer/schema-viewer.cy.spec.ts b/e2e/test/scenarios/schema-viewer/schema-viewer.cy.spec.ts
index 13dff09eccc..0ed91ba3156 100644
--- a/e2e/test/scenarios/schema-viewer/schema-viewer.cy.spec.ts
+++ b/e2e/test/scenarios/schema-viewer/schema-viewer.cy.spec.ts
@@ -506,7 +506,7 @@ describe("scenarios > schema-viewer (entry points + loader/error states)", () =>
cy.log(
"Click 'Schema viewer' tab in the Data Studio sidebar — opens the bare schema viewer URL",
);
- cy.visit("/data-studio");
+ H.DataStudio.visit();
H.DataStudio.nav().findByText("Schema viewer").click();
cy.url().should("include", "/data-studio/schema-viewer");
cy.findByTestId("schema-picker-button")
diff --git a/frontend/src/metabase/common/components/MetadataInfo/TableInfo/ColumnCount.tsx b/frontend/src/metabase/common/components/MetadataInfo/TableInfo/ColumnCount.tsx
index 7eea32b080d..e7c3c9dd832 100644
--- a/frontend/src/metabase/common/components/MetadataInfo/TableInfo/ColumnCount.tsx
+++ b/frontend/src/metabase/common/components/MetadataInfo/TableInfo/ColumnCount.tsx
@@ -1,11 +1,8 @@
import { msgid, ngettext } from "ttag";
-import type Table from "metabase-lib/v1/metadata/Table";
-
import { Label, LabelContainer } from "../MetadataInfo.styled";
-export function ColumnCount({ table }: { table: Table }) {
- const fieldCount = table.numFields();
+export function ColumnCount({ fieldCount }: { fieldCount: number }) {
return (
<LabelContainer color="text-primary">
<Label>
diff --git a/frontend/src/metabase/common/components/MetadataInfo/TableInfo/ColumnCount.unit.spec.tsx b/frontend/src/metabase/common/components/MetadataInfo/TableInfo/ColumnCount.unit.spec.tsx
index e8ea28f2e97..bf59fc7a2cf 100644
--- a/frontend/src/metabase/common/components/MetadataInfo/TableInfo/ColumnCount.unit.spec.tsx
+++ b/frontend/src/metabase/common/components/MetadataInfo/TableInfo/ColumnCount.unit.spec.tsx
@@ -1,53 +1,22 @@
-import { createMockState } from "__support__/state";
-import { createMockEntitiesState } from "__support__/store";
import { renderWithProviders, screen } from "__support__/ui";
-import { getMetadata } from "metabase/metadata-store";
-import { checkNotNull } from "metabase/utils/types";
-import type { Table } from "metabase-types/api";
-import { createMockField, createMockTable } from "metabase-types/api/mocks";
import { ColumnCount } from "./ColumnCount";
-interface SetupOpts {
- table: Table;
-}
-
-function setup({ table }: SetupOpts) {
- const state = createMockState({
- entities: createMockEntitiesState({
- tables: [table],
- }),
- });
- const metadata = getMetadata(state);
-
- renderWithProviders(
- <ColumnCount table={checkNotNull(metadata.table(table.id))} />,
- );
-}
-
describe("ColumnCount", () => {
it("should show a non-plural label for a table with a single field", () => {
- setup({
- table: createMockTable({
- fields: [createMockField()],
- }),
- });
+ renderWithProviders(<ColumnCount fieldCount={1} />);
expect(screen.getByText("1 column")).toBeInTheDocument();
});
it("should show a plural label for a table with multiple fields", () => {
- setup({
- table: createMockTable({
- fields: [createMockField(), createMockField()],
- }),
- });
+ renderWithProviders(<ColumnCount fieldCount={2} />);
expect(screen.getByText("2 columns")).toBeInTheDocument();
});
- it("should handle a scenario where a table has no fields property", () => {
- setup({ table: createMockTable() });
+ it("should show a plural label for a table with no fields", () => {
+ renderWithProviders(<ColumnCount fieldCount={0} />);
expect(screen.getByText("0 columns")).toBeInTheDocument();
});
diff --git a/frontend/src/metabase/common/components/MetadataInfo/TableInfo/ConnectedTables.tsx b/frontend/src/metabase/common/components/MetadataInfo/TableInfo/ConnectedTables.tsx
index 534ecd75729..1bca96d3f83 100644
--- a/frontend/src/metabase/common/components/MetadataInfo/TableInfo/ConnectedTables.tsx
+++ b/frontend/src/metabase/common/components/MetadataInfo/TableInfo/ConnectedTables.tsx
@@ -1,7 +1,8 @@
import { t } from "ttag";
+import { useQuestionFromOpts } from "metabase/metadata-store";
import * as Urls from "metabase/urls";
-import type Table from "metabase-lib/v1/metadata/Table";
+import type { NormalizedTable } from "metabase-types/api";
import { Container, Label, LabelContainer } from "../MetadataInfo.styled";
@@ -11,20 +12,23 @@ import {
LabelLink,
} from "./ConnectedTables.styled";
+export type ConnectedTable = Pick<
+ NormalizedTable,
+ "id" | "db_id" | "display_name"
+>;
+
type Props = {
- table: Table;
- onConnectedTableClick?: (table: Table) => void;
+ tables: ConnectedTable[];
+ onConnectedTableClick?: (table: ConnectedTable) => void;
};
-export function ConnectedTables({ table, onConnectedTableClick }: Props) {
- const fkTables = table.connectedTables();
-
- return fkTables.length ? (
+export function ConnectedTables({ tables, onConnectedTableClick }: Props) {
+ return tables.length ? (
<Container>
<LabelContainer color="text-primary">
<Label>{t`Connected to these tables`}</Label>
</LabelContainer>
- {fkTables.slice(0, 8).map((fkTable) => {
+ {tables.slice(0, 8).map((fkTable) => {
return onConnectedTableClick ? (
<ConnectedTableButton
key={fkTable.id}
@@ -43,8 +47,8 @@ function ConnectedTableButton({
table,
onClick,
}: {
- table: Table;
- onClick: (table: Table) => void;
+ table: ConnectedTable;
+ onClick: (table: ConnectedTable) => void;
}) {
return (
<LabelButton key={table.id} onClick={() => onClick(table)}>
@@ -53,9 +57,18 @@ function ConnectedTableButton({
);
}
-function ConnectedTableLink({ table }: { table: Table }) {
+function ConnectedTableLink({ table }: { table: ConnectedTable }) {
+ const buildQuestion = useQuestionFromOpts();
+ const question = buildQuestion({
+ dataset_query: {
+ database: table.db_id,
+ type: "query",
+ query: { "source-table": table.id },
+ },
+ }).setDefaultDisplay();
+
return (
- <LabelLink to={Urls.question(table.newQuestion())}>
+ <LabelLink to={Urls.question(question)}>
<InteractiveTableLabel table={table} />
</LabelLink>
);
diff --git a/frontend/src/metabase/common/components/MetadataInfo/TableInfo/ConnectedTables.unit.spec.tsx b/frontend/src/metabase/common/components/MetadataInfo/TableInfo/ConnectedTables.unit.spec.tsx
index 6f26b5ac827..a30ac2c20d4 100644
--- a/frontend/src/metabase/common/components/MetadataInfo/TableInfo/ConnectedTables.unit.spec.tsx
+++ b/frontend/src/metabase/common/components/MetadataInfo/TableInfo/ConnectedTables.unit.spec.tsx
@@ -2,101 +2,72 @@ import { createMockState } from "__support__/state";
import { createMockEntitiesState } from "__support__/store";
import { renderWithProviders, screen } from "__support__/ui";
import { getMetadata } from "metabase/metadata-store";
+import * as Urls from "metabase/urls";
import { checkNotNull } from "metabase/utils/types";
-import type { Table } from "metabase-types/api";
+import { createMockTable } from "metabase-types/api/mocks";
import {
- createMockField,
- createMockForeignKey,
- createMockTable,
-} from "metabase-types/api/mocks";
+ PRODUCTS_ID,
+ createProductsTable,
+ createSampleDatabase,
+} from "metabase-types/api/mocks/presets";
-import { ConnectedTables } from "./ConnectedTables";
+import { type ConnectedTable, ConnectedTables } from "./ConnectedTables";
-const EMPTY_TABLE = createMockTable();
-
-const TABLE_WITH_FKS = createMockTable({
- id: 1,
- fks: [
- createMockForeignKey({
- origin_id: 1,
- origin: createMockField({
- id: 1,
- table_id: 2,
- table: createMockTable({
- id: 2,
- display_name: "Foo",
- }),
- }),
- }),
- createMockForeignKey({
- origin_id: 2,
- origin: createMockField({
- id: 2,
- table_id: 3,
- table: createMockTable({
- id: 3,
- display_name: "Bar",
- }),
- }),
- }),
- ],
-});
-
-interface SetupOpts {
- table: Table;
-}
-
-function setup({ table }: SetupOpts) {
+function setup({ tables }: { tables: ConnectedTable[] }) {
const state = createMockState({
entities: createMockEntitiesState({
- tables: [table],
+ databases: [createSampleDatabase()],
}),
});
- const metadata = getMetadata(state);
- return renderWithProviders(
+ renderWithProviders(
<div data-testid="test-container">
- <ConnectedTables table={checkNotNull(metadata.table(table.id))} />
+ <ConnectedTables tables={tables} />
</div>,
+ { storeInitialState: state },
);
+
+ return { state };
}
describe("ConnectedTables", () => {
- it("should show nothing when the table has no fks", () => {
- setup({ table: EMPTY_TABLE });
+ it("should show nothing when there are no connected tables", () => {
+ setup({ tables: [] });
const container = screen.getByTestId("test-container");
expect(container).toBeEmptyDOMElement();
});
it("should show a label for each connected table", () => {
- setup({ table: TABLE_WITH_FKS });
+ setup({
+ tables: [
+ createMockTable({ id: 2, display_name: "Foo" }),
+ createMockTable({ id: 3, display_name: "Bar" }),
+ ],
+ });
expect(screen.getByText("Foo")).toBeInTheDocument();
expect(screen.getByText("Bar")).toBeInTheDocument();
});
it("should limit the number of connected tables to 8", () => {
- const fks = Array.from({ length: 20 }).map((_, idx) =>
- createMockForeignKey({
- origin_id: idx,
- origin: createMockField({
- id: idx,
- table_id: 21 + idx,
- table: createMockTable({
- id: 21 + idx,
- display_name: `Bar-${idx + 1}`,
- }),
- }),
- }),
- );
-
setup({
- table: {
- ...TABLE_WITH_FKS,
- fks,
- },
+ tables: Array.from({ length: 20 }).map((_, idx) =>
+ createMockTable({ id: 21 + idx, display_name: `Bar-${idx + 1}` }),
+ ),
});
expect(screen.getAllByText(/Bar-\d/)).toHaveLength(8);
});
+
+ it("should link each table to a new question on it", () => {
+ const { state } = setup({ tables: [createProductsTable()] });
+ const newQuestion = checkNotNull(
+ getMetadata(state).table(PRODUCTS_ID),
+ ).newQuestion();
+
+ expect(screen.getByRole("link", { name: /Products/ })).toHaveAttribute(
+ "href",
+ Urls.question(newQuestion),
+ );
+ });
});
diff --git a/frontend/src/metabase/common/components/MetadataInfo/TableInfo/TableInfo.tsx b/frontend/src/metabase/common/components/MetadataInfo/TableInfo/TableInfo.tsx
index 998e249c2b2..618e6c9da22 100644
--- a/frontend/src/metabase/common/components/MetadataInfo/TableInfo/TableInfo.tsx
+++ b/frontend/src/metabase/common/components/MetadataInfo/TableInfo/TableInfo.tsx
@@ -1,8 +1,13 @@
+import { createSelector } from "@reduxjs/toolkit";
import { useEffect, useState } from "react";
import { useAsyncFn } from "react-use";
import { t } from "ttag";
-import { getMetadata } from "metabase/metadata-store";
+import {
+ getShallowTableFieldIds,
+ getShallowTableForeignKeys,
+ getShallowTables,
+} from "metabase/metadata-store";
import { connect } from "metabase/redux";
import type { Dispatch, State } from "metabase/redux/store";
import {
@@ -10,35 +15,57 @@ import {
fetchTableMetadata,
} from "metabase/redux/tables";
import { Loader } from "metabase/ui";
-import type Table from "metabase-lib/v1/metadata/Table";
+import { isNotNull } from "metabase/utils/types";
+import type { NormalizedTable, TableId } from "metabase-types/api";
import { Description, EmptyDescription } from "../MetadataInfo";
import { AbsoluteContainer, Fade } from "../MetadataInfo.styled";
import { ColumnCount } from "./ColumnCount";
-import { ConnectedTables } from "./ConnectedTables";
+import { type ConnectedTable, ConnectedTables } from "./ConnectedTables";
import { InfoContainer, MetadataContainer } from "./TableInfo.styled";
export type TableInfoProps = {
className?: string;
- tableId: Table["id"];
- onConnectedTableClick?: (table: Table) => void;
+ tableId: TableId;
+ onConnectedTableClick?: (table: ConnectedTable) => void;
};
+/**
+ * The tables whose foreign keys point at this one. `undefined` until the
+ * table's foreign keys are loaded.
+ */
+const getConnectedTables = createSelector(
+ [
+ (state: State, tableId: TableId) =>
+ getShallowTableForeignKeys(state, tableId),
+ (state: State) => getShallowTables(state),
+ ],
+ (foreignKeys, tables) =>
+ foreignKeys
+ ?.map((foreignKey) => tables[foreignKey.origin.table_id])
+ .filter(isNotNull),
+);
+
const mapStateToProps = (
state: State,
props: TableInfoProps,
-): { table?: Table } => {
+): {
+ table?: NormalizedTable;
+ fieldCount: number;
+ connectedTables?: NormalizedTable[];
+} => {
return {
- table: getMetadata(state).table(props.tableId) ?? undefined,
+ table: getShallowTables(state)[props.tableId],
+ fieldCount: getShallowTableFieldIds(state, props.tableId).length,
+ connectedTables: getConnectedTables(state, props.tableId),
};
};
const mapDispatchToProps = (dispatch: Dispatch) => ({
- fetchForeignKeys: (args: { id: Table["id"] }) =>
+ fetchForeignKeys: (args: { id: TableId }) =>
dispatch(fetchTableForeignKeys(args)),
- fetchMetadata: (args: { id: Table["id"] }) =>
- dispatch(fetchTableMetadata(args)),
+ fetchMetadata: (args: { id: TableId }) => dispatch(fetchTableMetadata(args)),
});
type AllProps = TableInfoProps &
@@ -47,12 +74,20 @@ type AllProps = TableInfoProps &
function useDependentTableMetadata({
tableId,
- table,
+ fieldCount,
+ connectedTables,
fetchForeignKeys,
fetchMetadata,
-}: Pick<AllProps, "tableId" | "table" | "fetchForeignKeys" | "fetchMetadata">) {
- const isMissingFields = !table?.numFields();
- const isMissingFks = table?.fks === undefined;
+}: Pick<
+ AllProps,
+ | "tableId"
+ | "fieldCount"
+ | "connectedTables"
+ | "fetchForeignKeys"
+ | "fetchMetadata"
+>) {
+ const isMissingFields = fieldCount === 0;
+ const isMissingFks = connectedTables === undefined;
const shouldFetchMetadata = isMissingFields || isMissingFks;
const [hasFetchedMetadata, setHasFetchedMetadata] =
useState(!shouldFetchMetadata);
@@ -78,6 +113,8 @@ export function TableInfoInner({
className,
tableId,
table,
+ fieldCount,
+ connectedTables,
fetchForeignKeys,
fetchMetadata,
onConnectedTableClick,
@@ -85,7 +122,8 @@ export function TableInfoInner({
const description = table?.description;
const hasFetchedMetadata = useDependentTableMetadata({
tableId,
- table,
+ fieldCount,
+ connectedTables,
fetchForeignKeys,
fetchMetadata,
});
@@ -104,12 +142,12 @@ export function TableInfoInner({
</AbsoluteContainer>
</Fade>
<Fade visible={hasFetchedMetadata}>
- {table && <ColumnCount table={table} />}
+ {table && <ColumnCount fieldCount={fieldCount} />}
</Fade>
<Fade visible={hasFetchedMetadata}>
{table && (
<ConnectedTables
- table={table}
+ tables={connectedTables ?? []}
onConnectedTableClick={onConnectedTableClick}
/>
)}
diff --git a/frontend/src/metabase/common/components/MetadataInfo/TableInfo/TableInfo.unit.spec.tsx b/frontend/src/metabase/common/components/MetadataInfo/TableInfo/TableInfo.unit.spec.tsx
index 27ad7bfd3c9..2091d1a89aa 100644
--- a/frontend/src/metabase/common/components/MetadataInfo/TableInfo/TableInfo.unit.spec.tsx
+++ b/frontend/src/metabase/common/components/MetadataInfo/TableInfo/TableInfo.unit.spec.tsx
@@ -1,7 +1,8 @@
+import fetchMock from "fetch-mock";
+
import { createMockState } from "__support__/state";
import { createMockEntitiesState } from "__support__/store";
-import { renderWithProviders, screen } from "__support__/ui";
-import { getMetadata } from "metabase/metadata-store";
+import { renderWithProviders, screen, waitFor } from "__support__/ui";
import type { Table, TableId } from "metabase-types/api";
import {
createMockField,
@@ -9,11 +10,12 @@ import {
createMockTable,
} from "metabase-types/api/mocks";
-import { TableInfoInner } from "./TableInfo";
+import { TableInfo } from "./TableInfo";
const TABLE_ID = 1;
const TABLE_FK = createMockForeignKey({
+ origin_id: 1,
origin: createMockField({
id: 1,
table_id: 2,
@@ -25,6 +27,7 @@ const TABLE_FK = createMockForeignKey({
});
const TABLE_FIELD = createMockField({
+ id: 10,
table_id: TABLE_ID,
});
@@ -57,98 +60,99 @@ interface SetupOpts {
table?: Table;
}
-function setup({ id, table }: SetupOpts) {
+const QUERY_METADATA_URL = `path:/api/table/${TABLE_ID}/query_metadata`;
+const FOREIGN_KEYS_URL = `path:/api/table/${TABLE_ID}/fks`;
+
+async function setup({ id, table }: SetupOpts) {
const state = createMockState({
entities: createMockEntitiesState({
tables: table ? [table] : [],
}),
});
- const metadata = getMetadata(state);
-
- const fetchMetadata = jest.fn();
- const fetchForeignKeys = jest.fn();
-
- renderWithProviders(
- <TableInfoInner
- tableId={id}
- table={metadata.table(table?.id) ?? undefined}
- fetchMetadata={fetchMetadata}
- fetchForeignKeys={fetchForeignKeys}
- />,
- { storeInitialState: state },
- );
-
- return { fetchMetadata, fetchForeignKeys };
+ fetchMock.get(QUERY_METADATA_URL, TABLE);
+ fetchMock.get(FOREIGN_KEYS_URL, [TABLE_FK]);
+
+ renderWithProviders(<TableInfo tableId={id} />, {
+ storeInitialState: state,
+ });
+
+ // The loader fades out once every missing piece has loaded.
+ await waitFor(() => expect(screen.getByText("1 column")).toBeVisible());
+
+ return {
+ hasFetchedMetadata: () => fetchMock.callHistory.called(QUERY_METADATA_URL),
+ hasFetchedForeignKeys: () => fetchMock.callHistory.called(FOREIGN_KEYS_URL),
+ };
}
describe("TableInfo", () => {
- it("should fetch table metadata if fields are missing", () => {
- const { fetchMetadata, fetchForeignKeys } = setup({
+ it("should fetch table metadata if fields are missing", async () => {
+ const { hasFetchedMetadata, hasFetchedForeignKeys } = await setup({
id: TABLE_ID,
table: TABLE_WITH_FKS,
});
- expect(fetchMetadata).toHaveBeenCalledWith({
- id: TABLE_ID,
- });
- expect(fetchForeignKeys).not.toHaveBeenCalled();
+
+ expect(hasFetchedMetadata()).toBe(true);
+ expect(hasFetchedForeignKeys()).toBe(false);
});
- it("should fetch table metadata if the table is undefined", () => {
- const { fetchMetadata, fetchForeignKeys } = setup({
+ it("should fetch table metadata if the table is undefined", async () => {
+ const { hasFetchedMetadata, hasFetchedForeignKeys } = await setup({
id: TABLE_ID,
table: undefined,
});
- expect(fetchMetadata).toHaveBeenCalledWith({
- id: TABLE_ID,
- });
- expect(fetchForeignKeys).toHaveBeenCalledWith({
- id: TABLE_ID,
- });
+ expect(hasFetchedMetadata()).toBe(true);
+ expect(hasFetchedForeignKeys()).toBe(true);
});
- it("should fetch fks if fks are undefined on table", () => {
- const { fetchMetadata, fetchForeignKeys } = setup({
+ it("should fetch fks if fks are undefined on table", async () => {
+ const { hasFetchedMetadata, hasFetchedForeignKeys } = await setup({
id: TABLE_ID,
table: TABLE_WITH_FIELDS,
});
- expect(fetchMetadata).not.toHaveBeenCalled();
- expect(fetchForeignKeys).toHaveBeenCalledWith({ id: TABLE_ID });
+ expect(hasFetchedMetadata()).toBe(false);
+ expect(hasFetchedForeignKeys()).toBe(true);
});
- it("should not send requests fetching table metadata when metadata is already present", () => {
- const { fetchMetadata, fetchForeignKeys } = setup({
+ it("should not send requests fetching table metadata when metadata is already present", async () => {
+ const { hasFetchedMetadata, hasFetchedForeignKeys } = await setup({
id: TABLE_ID,
table: TABLE,
});
- expect(fetchMetadata).not.toHaveBeenCalled();
- expect(fetchForeignKeys).not.toHaveBeenCalled();
+ expect(hasFetchedMetadata()).toBe(false);
+ expect(hasFetchedForeignKeys()).toBe(false);
});
it("should display a placeholder if table has no description", async () => {
- setup({
- id: TABLE_ID,
- table: TABLE_WITHOUT_DESCRIPTION,
+ fetchMock.get(QUERY_METADATA_URL, TABLE_WITHOUT_DESCRIPTION);
+ fetchMock.get(FOREIGN_KEYS_URL, []);
+ renderWithProviders(<TableInfo tableId={TABLE_ID} />, {
+ storeInitialState: createMockState({
+ entities: createMockEntitiesState({
+ tables: [TABLE_WITHOUT_DESCRIPTION],
+ }),
+ }),
});
expect(await screen.findByText("No description")).toBeInTheDocument();
});
describe("after metadata has been fetched", () => {
- it("should display the given table's description", () => {
- setup({ id: TABLE_ID, table: TABLE });
+ it("should display the given table's description", async () => {
+ await setup({ id: TABLE_ID, table: TABLE });
expect(screen.getByText(TABLE.description ?? "")).toBeInTheDocument();
});
- it("should show a count of columns on the table", () => {
- setup({ id: TABLE_ID, table: TABLE });
+ it("should show a count of columns on the table", async () => {
+ await setup({ id: TABLE_ID, table: TABLE });
expect(screen.getByText("1 column")).toBeInTheDocument();
});
- it("should list connected tables", () => {
- setup({ id: TABLE_ID, table: TABLE });
+ it("should list connected tables", async () => {
+ await setup({ id: TABLE_ID, table: TABLE });
expect(screen.getByText("Connected Table")).toBeInTheDocument();
});
});
diff --git a/frontend/src/metabase/common/components/MetadataInfo/TableLabel/TableLabel.tsx b/frontend/src/metabase/common/components/MetadataInfo/TableLabel/TableLabel.tsx
index 0e1d16c43b5..86297e34b90 100644
--- a/frontend/src/metabase/common/components/MetadataInfo/TableLabel/TableLabel.tsx
+++ b/frontend/src/metabase/common/components/MetadataInfo/TableLabel/TableLabel.tsx
@@ -1,4 +1,4 @@
-import type Table from "metabase-lib/v1/metadata/Table";
+import type { NormalizedTable } from "metabase-types/api";
import { Label, LabelContainer } from "../MetadataInfo.styled";
@@ -9,12 +9,12 @@ export function TableLabel({
table,
}: {
className?: string;
- table: Table;
+ table: Pick<NormalizedTable, "display_name">;
}) {
return (
<LabelContainer className={className}>
<TableIcon name="table" />
- <Label>{table.displayName()}</Label>
+ <Label>{table.display_name}</Label>
</LabelContainer>
);
}
diff --git a/frontend/src/metabase/data-studio/routes.tsx b/frontend/src/metabase/data-studio/routes.tsx
index 75a162ef737..10941584f30 100644
--- a/frontend/src/metabase/data-studio/routes.tsx
+++ b/frontend/src/metabase/data-studio/routes.tsx
@@ -13,6 +13,7 @@ import {
Route,
type RouteComponent,
redirect,
+ useIsNavigating,
} from "metabase/router";
import { getDataStudioTransformRoutes } from "metabase/transforms/routes";
import { canAccessTransforms } from "metabase/transforms/selectors";
@@ -154,13 +155,14 @@ export function getDataStudioDependencyDiagnosticsRedirects() {
export function DataStudioIndexRedirect() {
const indexPath = useSelector(getIndexPath);
+ const isNavigating = useIsNavigating();
const { value: hasSeenGuide, isLoading } = useUserKeyValue({
namespace: "data_studio",
key: "hasSeenGuide",
defaultValue: false,
});
- if (isLoading) {
+ if (isLoading || isNavigating) {
return <LoadingAndErrorWrapper loading />;
}
diff --git a/frontend/src/metabase/data-studio/routes.unit.spec.tsx b/frontend/src/metabase/data-studio/routes.unit.spec.tsx
index 1e7c37f82d2..c1b4f192938 100644
--- a/frontend/src/metabase/data-studio/routes.unit.spec.tsx
+++ b/frontend/src/metabase/data-studio/routes.unit.spec.tsx
@@ -1,8 +1,12 @@
+import fetchMock from "fetch-mock";
+
import { lazyLoaders } from "__support__/lazy-routes";
import { setupUserKeyValueEndpoints } from "__support__/server-mocks";
import { createMockState } from "__support__/state";
-import { renderWithProviders, screen } from "__support__/ui";
+import { act, renderWithProviders, screen } from "__support__/ui";
+import { delay } from "__support__/utils";
import { Route } from "metabase/router";
+import { defer } from "metabase/utils/promise";
import { createMockUser } from "metabase-types/api/mocks";
import { DataStudioIndexRedirect, getDataStudioRoutes } from "./routes";
@@ -25,27 +29,52 @@ describe("data-studio routes", () => {
function setupIndexRedirect({
hasSeenGuide,
isAdmin = false,
+ transformsLoading,
}: {
- hasSeenGuide: boolean;
+ hasSeenGuide: boolean | Promise<boolean>;
isAdmin?: boolean;
+ transformsLoading?: Promise<void>;
}) {
- setupUserKeyValueEndpoints({
- namespace: "data_studio",
- key: "hasSeenGuide",
- value: hasSeenGuide,
- });
+ if (typeof hasSeenGuide === "boolean") {
+ setupUserKeyValueEndpoints({
+ namespace: "data_studio",
+ key: "hasSeenGuide",
+ value: hasSeenGuide,
+ });
+ } else {
+ fetchMock.get(
+ "path:/api/user-key-value/namespace/data_studio/key/hasSeenGuide",
+ async () =>
+ new Response(JSON.stringify(await hasSeenGuide), {
+ status: 200,
+ headers: { "Content-Type": "application/json" },
+ }),
+ );
+ }
- renderWithProviders(
+ return renderWithProviders(
<Route path="/">
<Route path="data-studio">
<Route index element={<DataStudioIndexRedirect />} />
<Route path="guide" element={<div data-testid="guide-page" />} />
<Route path="data" element={<div data-testid="data-index" />} />
<Route path="library" element={<div data-testid="library-index" />} />
- <Route
- path="transforms"
- element={<div data-testid="transforms-index" />}
- />
+ {transformsLoading ? (
+ <Route
+ path="transforms"
+ lazy={async () => {
+ await transformsLoading;
+ return {
+ Component: () => <div data-testid="transforms-index" />,
+ };
+ }}
+ />
+ ) : (
+ <Route
+ path="transforms"
+ element={<div data-testid="transforms-index" />}
+ />
+ )}
</Route>
</Route>,
{
@@ -79,4 +108,25 @@ describe("Data Studio index redirect", () => {
expect(await screen.findByTestId("library-index")).toBeInTheDocument();
expect(screen.queryByTestId("guide-page")).not.toBeInTheDocument();
});
+
+ it("lets a navigation the user already started finish", async () => {
+ const hasSeenGuide = defer<boolean>();
+ const transformsModule = defer<void>();
+ const { router } = setupIndexRedirect({
+ hasSeenGuide: hasSeenGuide.promise,
+ isAdmin: true,
+ transformsLoading: transformsModule.promise,
+ });
+
+ act(() => router?.navigate("/data-studio/transforms"));
+
+ // The redirect resolves while the lazy route is still loading.
+ hasSeenGuide.resolve(false);
+ await delay(0);
+
+ transformsModule.resolve();
+
+ expect(await screen.findByTestId("transforms-index")).toBeInTheDocument();
+ expect(screen.queryByTestId("guide-page")).not.toBeInTheDocument();
+ });
});
diff --git a/frontend/src/metabase/metadata-store/index.ts b/frontend/src/metabase/metadata-store/index.ts
index d880dbe5eaa..c39e497b417 100644
--- a/frontend/src/metabase/metadata-store/index.ts
+++ b/frontend/src/metabase/metadata-store/index.ts
@@ -13,12 +13,14 @@ export {
getShallowQuestions,
getShallowSchemaTables,
getShallowSchemas,
+ getShallowTableFieldIds,
getShallowTableFields,
+ getShallowTableForeignKeys,
getShallowTableSchema,
getShallowSegments,
getShallowTables,
} from "./selectors";
-export type { MetadataSelectorOpts } from "./selectors";
+export type { MetadataSelectorOpts, ShallowForeignKey } from "./selectors";
export {
selectMetadataProvider,
diff --git a/frontend/src/metabase/metadata-store/selectors.ts b/frontend/src/metabase/metadata-store/selectors.ts
index 5e43e154800..b4a007fe416 100644
--- a/frontend/src/metabase/metadata-store/selectors.ts
+++ b/frontend/src/metabase/metadata-store/selectors.ts
@@ -20,6 +20,7 @@ import {
} from "metabase-lib/v1/queries/utils/field";
import { isNumeric } from "metabase-lib/v1/types/utils/isa";
import type {
+ Field as ApiField,
Table as ApiTable,
Card,
DatabaseId,
@@ -130,6 +131,54 @@ export const getShallowSegments = getNormalizedSegments;
export const getShallowSchemas = getNormalizedSchemas;
export const getShallowQuestions = getNormalizedQuestions;
+const getVisibleTable = (state: MetadataState, tableId: TableId) =>
+ getNormalizedTables(state)[tableId];
+
+const getVisibleFields = (state: MetadataState) => getNormalizedFields(state);
+
+// Field values can arrive before the field itself, which leaves a stub record
+// with no `uniqueId`. `getMetadata` drops those.
+const isResolvedField = (
+ field: NormalizedField | undefined,
+): field is NormalizedField => field?.uniqueId != null;
+
+/**
+ * The ids of a table's fields, as `getMetadata` resolves `Table.fields`: the
+ * table's `original_fields` when it has them, otherwise its visible fields.
+ */
+export const getShallowTableFieldIds = createSelector(
+ [getVisibleTable, getVisibleFields],
+ (table, fields): ApiField["id"][] => {
+ if (table == null) {
+ return [];
+ }
+ if (table.original_fields) {
+ return table.original_fields.map((field) => field.id);
+ }
+ return (table.fields ?? [])
+ .map((fieldKey) => fields[fieldKey])
+ .filter(isResolvedField)
+ .map((field) => field.id);
+ },
+);
+
+export type ShallowForeignKey = Omit<NormalizedForeignKey, "origin"> & {
+ origin: NormalizedField;
+};
+
+/**
+ * A table's foreign keys whose origin field is visible, with that field in
+ * place of its id. `undefined` until the table's foreign keys are loaded.
+ */
+export const getShallowTableForeignKeys = createSelector(
+ [getVisibleTable, getVisibleFields],
+ (table, fields): ShallowForeignKey[] | undefined =>
+ table?.fks?.flatMap((foreignKey) => {
+ const origin = fields[foreignKey.origin_id];
+ return isResolvedField(origin) ? [{ ...foreignKey, origin }] : [];
+ }),
+);
+
// The relations between the store's records need the same resolving the v1
// `Metadata` object does: a table that arrived without its ids still belongs to
// its schema, and `original_fields` outranks a table's field ids. Each selector
diff --git a/frontend/src/metabase/metadata-store/selectors.unit.spec.ts b/frontend/src/metabase/metadata-store/selectors.unit.spec.ts
index ebf90a35f44..dad44269164 100644
--- a/frontend/src/metabase/metadata-store/selectors.unit.spec.ts
+++ b/frontend/src/metabase/metadata-store/selectors.unit.spec.ts
@@ -1,11 +1,15 @@
import { createMockSettingsState, createMockState } from "__support__/state";
import { createMockEntitiesState } from "__support__/store";
+import type { EntitiesState } from "metabase/redux/store";
import { checkNotNull } from "metabase/utils/types";
import Metadata from "metabase-lib/v1/metadata/Metadata";
import {
createMockDatabase,
+ createMockField,
+ createMockForeignKey,
createMockSegment,
createMockSettings,
+ createMockTable,
} from "metabase-types/api/mocks";
import {
ORDERS,
@@ -14,7 +18,11 @@ import {
createSampleDatabase,
} from "metabase-types/api/mocks/presets";
-import { getMetadata } from "./selectors";
+import {
+ getMetadata,
+ getShallowTableFieldIds,
+ getShallowTableForeignKeys,
+} from "./selectors";
function setup() {
const sampleDatabase = createSampleDatabase();
@@ -81,3 +89,122 @@ describe("getMetadata", () => {
});
});
});
+
+describe("table relations", () => {
+ const TABLE_ID = 1;
+ const CONNECTED_TABLE_ID = 2;
+ const HIDDEN_TABLE_ID = 3;
+
+ const entities = createMockEntitiesState({
+ tables: [
+ createMockTable({
+ id: TABLE_ID,
+ fields: [
+ createMockField({ id: 10, table_id: TABLE_ID }),
+ createMockField({
+ id: 11,
+ table_id: TABLE_ID,
+ visibility_type: "sensitive",
+ }),
+ ],
+ fks: [
+ createMockForeignKey({
+ origin_id: 20,
+ origin: createMockField({ id: 20, table_id: CONNECTED_TABLE_ID }),
+ }),
+ createMockForeignKey({
+ origin_id: 30,
+ origin: createMockField({ id: 30, table_id: HIDDEN_TABLE_ID }),
+ }),
+ ],
+ }),
+ createMockTable({ id: CONNECTED_TABLE_ID, fks: undefined }),
+ createMockTable({ id: HIDDEN_TABLE_ID, visibility_type: "hidden" }),
+ ],
+ });
+
+ // A field updated on its own drops the table's `original_fields`, which
+ // leaves only the table's field ids to resolve.
+ const entitiesWithoutOriginalFields: EntitiesState = {
+ ...entities,
+ tables: {
+ ...entities.tables,
+ [TABLE_ID]: { ...entities.tables[TABLE_ID], original_fields: undefined },
+ },
+ };
+
+ const v1FieldIds = (state: ReturnType<typeof createMockState>) =>
+ getMetadata(state)
+ .table(TABLE_ID)
+ ?.fields?.map((field) => field.id);
+
+ describe("getShallowTableFieldIds", () => {
+ it("should list every original field, sensitive ones included, like getMetadata", () => {
+ const state = createMockState({ entities });
+
+ expect(getShallowTableFieldIds(state, TABLE_ID)).toEqual([10, 11]);
+ expect(getShallowTableFieldIds(state, TABLE_ID)).toEqual(
+ v1FieldIds(state),
+ );
+ });
+
+ it("should list only visible fields without original fields, like getMetadata", () => {
+ const state = createMockState({
+ entities: entitiesWithoutOriginalFields,
+ });
+
+ expect(getShallowTableFieldIds(state, TABLE_ID)).toEqual([10]);
+ expect(getShallowTableFieldIds(state, TABLE_ID)).toEqual(
+ v1FieldIds(state),
+ );
+ });
+
+ it("should list nothing for a hidden table, which getMetadata leaves out", () => {
+ const state = createMockState({ entities });
+
+ expect(getShallowTableFieldIds(state, HIDDEN_TABLE_ID)).toEqual([]);
+ expect(getMetadata(state).table(HIDDEN_TABLE_ID)).toBeNull();
+ });
+
+ it("should return the same array until the table or its fields change", () => {
+ const state = createMockState({ entities });
+ const nextState = createMockState({ entities });
+
+ expect(getShallowTableFieldIds(nextState, TABLE_ID)).toBe(
+ getShallowTableFieldIds(state, TABLE_ID),
+ );
+ });
+ });
+
+ describe("getShallowTableForeignKeys", () => {
+ it("should keep only foreign keys from visible tables, like getMetadata", () => {
+ const state = createMockState({ entities });
+ const v1OriginIds = getMetadata(state)
+ .table(TABLE_ID)
+ ?.fks?.filter((foreignKey) => foreignKey.origin != null)
+ .map((foreignKey) => foreignKey.origin_id);
+
+ const foreignKeys = getShallowTableForeignKeys(state, TABLE_ID);
+
+ expect(foreignKeys?.map((foreignKey) => foreignKey.origin_id)).toEqual([
+ 20,
+ ]);
+ expect(foreignKeys?.map((foreignKey) => foreignKey.origin_id)).toEqual(
+ v1OriginIds,
+ );
+ expect(foreignKeys?.[0].origin).toMatchObject({
+ id: 20,
+ table_id: CONNECTED_TABLE_ID,
+ });
+ });
+
+ it("should be undefined before the table's foreign keys load", () => {
+ const state = createMockState({ entities });
+
+ expect(
+ getShallowTableForeignKeys(state, CONNECTED_TABLE_ID),
+ ).toBeUndefined();
+ expect(getMetadata(state).table(CONNECTED_TABLE_ID)?.fks).toBeUndefined();
+ });
+ });
+});
diff --git a/frontend/src/metabase/query_builder/actions/object-detail.ts b/frontend/src/metabase/query_builder/actions/object-detail.ts
index 5b85602a09f..b9938afce05 100644
--- a/frontend/src/metabase/query_builder/actions/object-detail.ts
+++ b/frontend/src/metabase/query_builder/actions/object-detail.ts
@@ -3,6 +3,7 @@ import _ from "underscore";
import { datasetApi } from "metabase/api";
import { runRtkEndpoint } from "metabase/api/utils/run-rtk-endpoint";
import {
+ type ShallowForeignKey,
selectMetadataProvider,
selectQuestionFromCard,
selectQuestionFromOpts,
@@ -11,8 +12,13 @@ import { createThunkAction } from "metabase/redux";
import type { Dispatch, GetState } from "metabase/redux/store";
import type { ObjectId } from "metabase/visualizations/components/ObjectDetail/types";
import * as Lib from "metabase-lib";
-import type ForeignKey from "metabase-lib/v1/metadata/ForeignKey";
-import type { Card, DatasetColumn, Field, FieldId } from "metabase-types/api";
+import type {
+ Card,
+ DatasetColumn,
+ Field,
+ FieldId,
+ NormalizedField,
+} from "metabase-types/api";
import {
CLEAR_OBJECT_DETAIL_FK_REFERENCES,
@@ -41,7 +47,7 @@ export const resetRowZoom = () => (dispatch: Dispatch) => {
function filterByFk(
query: Lib.Query,
- field: DatasetColumn | Field,
+ field: DatasetColumn | Field | NormalizedField,
objectId: ObjectId,
) {
const stageIndex = -1;
@@ -125,14 +131,14 @@ export const loadObjectDetailFKReferences = createThunkAction(
async function getFKCount(
card: Card,
- fk: ForeignKey,
+ fk: ShallowForeignKey,
): Promise<FKInfo | undefined> {
const databaseId = selectQuestionFromCard(
getState(),
card,
).databaseId();
- const tableId = fk.origin?.table_id;
- if (!tableId || !databaseId || !fk.origin) {
+ const tableId = fk.origin.table_id;
+ if (!tableId || !databaseId) {
return;
}
const metadataProvider = selectMetadataProvider(getState(), databaseId);
@@ -145,12 +151,7 @@ export const loadObjectDetailFKReferences = createThunkAction(
table,
);
const aggregatedQuery = Lib.aggregateByCount(baseQuery, -1);
- const query = filterByFk(
- aggregatedQuery,
- // Unjustified type cast. FIXME
- fk.origin.getPlainObject() as Field,
- objectId,
- );
+ const query = filterByFk(aggregatedQuery, fk.origin, objectId);
const finalCard = selectQuestionFromOpts(getState(), {
dataset_query: Lib.toJsQuery(query),
}).datasetQuery();
diff --git a/frontend/src/metabase/query_builder/containers/QueryBuilder.tsx b/frontend/src/metabase/query_builder/containers/QueryBuilder.tsx
index f1502a90001..a318a88c708 100644
--- a/frontend/src/metabase/query_builder/containers/QueryBuilder.tsx
+++ b/frontend/src/metabase/query_builder/containers/QueryBuilder.tsx
@@ -156,7 +156,6 @@ import {
getShouldShowUnsavedChangesWarning,
getSnippetCollectionId,
getTableForeignKeyReferences,
- getTableForeignKeys,
getTimeseriesXDomain,
getUiControls,
getVisibleTimelineEventIds,
@@ -183,7 +182,6 @@ const mapStateToProps = (state: State) => {
parameterValues: getParameterValues(state),
- tableForeignKeys: getTableForeignKeys(state),
tableForeignKeyReferences: getTableForeignKeyReferences(state),
card: getCard(state),
diff --git a/frontend/src/metabase/query_builder/store/selectors.ts b/frontend/src/metabase/query_builder/store/selectors.ts
index 1619a9d2748..57379a3f965 100644
--- a/frontend/src/metabase/query_builder/store/selectors.ts
+++ b/frontend/src/metabase/query_builder/store/selectors.ts
@@ -11,7 +11,9 @@ import { getSortedTimelines } from "metabase/common/utils/timelines";
import { dayjs } from "metabase/dayjs";
import { getEmbedOptions } from "metabase/embedding/interactive-embedding";
import {
- getMetadata,
+ getShallowTableFieldIds,
+ getShallowTableForeignKeys,
+ getShallowTables,
selectQuestionFromCardBuilder,
} from "metabase/metadata-store";
import {
@@ -36,7 +38,6 @@ import {
} from "metabase/viz-core";
import * as Lib from "metabase-lib";
import type Question from "metabase-lib/v1/Question";
-import type Table from "metabase-lib/v1/metadata/Table";
import {
normalizeParameterValue,
normalizeParameters,
@@ -312,21 +313,23 @@ export const getTableId = createSelector([getQuestion], (question) => {
});
export const getTableMetadata = createSelector(
- [getTableId, getMetadata],
- (tableId, metadata) => metadata.table(tableId),
+ [getTableId, getShallowTables],
+ (tableId, tables) => (tableId != null ? tables[tableId] : undefined),
);
-export const getTableForeignKeys = createSelector(
- [getTableMetadata],
- (table) => {
- const tableForeignKeys = table?.fks ?? [];
- const tableForeignKeysWithoutHiddenTables = tableForeignKeys.filter(
- (tableForeignKey) => tableForeignKey.origin != null,
- );
+const NO_FIELD_IDS: Field["id"][] = [];
- return tableForeignKeysWithoutHiddenTables;
- },
-);
+const getTableFieldIds = (state: QueryBuilderStoreState) => {
+ const tableId = getTableId(state);
+ return tableId != null
+ ? getShallowTableFieldIds(state, tableId)
+ : NO_FIELD_IDS;
+};
+
+export const getTableForeignKeys = (state: QueryBuilderStoreState) => {
+ const tableId = getTableId(state);
+ return (tableId != null && getShallowTableForeignKeys(state, tableId)) || [];
+};
export const getPKColumnIndex = createSelector(
[getFirstQueryResult, getTableId],
@@ -397,7 +400,7 @@ export const getRowIndexToPKMap = createSelector(
function areLegacyQueriesEqual(
queryA: DatasetQuery | undefined,
queryB: DatasetQuery | undefined,
- tableMetadata?: Table | null,
+ tableFieldIds: Field["id"][],
) {
if (queryA == null || queryB == null) {
return false;
@@ -405,9 +408,7 @@ function areLegacyQueriesEqual(
return Lib.areLegacyQueriesEqual(
queryA,
queryB,
- tableMetadata?.fields
- ?.map(({ id }) => id)
- ?.filter((id): id is number => typeof id === "number") ?? [],
+ tableFieldIds.filter((id): id is number => typeof id === "number"),
);
}
@@ -419,12 +420,12 @@ function areComposedEntitiesEquivalent({
originalQuestion,
lastRunQuestion,
currentQuestion,
- tableMetadata,
+ tableFieldIds,
}: {
originalQuestion?: Question | null;
lastRunQuestion?: Question | null;
currentQuestion?: Question | null;
- tableMetadata?: Table | null;
+ tableFieldIds: Field["id"][];
}) {
const isQuestion = originalQuestion?.type() === "question";
if (!originalQuestion || !lastRunQuestion || !currentQuestion || isQuestion) {
@@ -436,12 +437,12 @@ function areComposedEntitiesEquivalent({
const isLastRunComposed = areLegacyQueriesEqual(
lastRunQuestion.datasetQuery(),
composedOriginal.datasetQuery(),
- tableMetadata,
+ tableFieldIds,
);
const isCurrentComposed = areLegacyQueriesEqual(
currentQuestion.datasetQuery(),
composedOriginal.datasetQuery(),
- tableMetadata,
+ tableFieldIds,
);
const isLastRunEquivalentToCurrent =
@@ -449,7 +450,7 @@ function areComposedEntitiesEquivalent({
areLegacyQueriesEqual(
currentQuestion.datasetQuery(),
originalQuestion.datasetQuery(),
- tableMetadata,
+ tableFieldIds,
);
const isCurrentEquivalentToLastRun =
@@ -457,7 +458,7 @@ function areComposedEntitiesEquivalent({
areLegacyQueriesEqual(
lastRunQuestion.datasetQuery(),
originalQuestion.datasetQuery(),
- tableMetadata,
+ tableFieldIds,
);
return isLastRunEquivalentToCurrent || isCurrentEquivalentToLastRun;
@@ -467,24 +468,24 @@ export function areQueriesEquivalent({
originalQuestion,
lastRunQuestion,
currentQuestion,
- tableMetadata,
+ tableFieldIds,
}: {
originalQuestion?: Question | null;
lastRunQuestion?: Question | null;
currentQuestion?: Question | null;
- tableMetadata?: Table | null;
+ tableFieldIds: Field["id"][];
}) {
return (
areLegacyQueriesEqual(
lastRunQuestion?.datasetQuery(),
currentQuestion?.datasetQuery(),
- tableMetadata,
+ tableFieldIds,
) ||
areComposedEntitiesEquivalent({
originalQuestion,
lastRunQuestion,
currentQuestion,
- tableMetadata,
+ tableFieldIds,
})
);
}
@@ -496,7 +497,7 @@ export const getIsResultDirty = createSelector(
getLastRunQuestion,
getLastRunParameterValues,
getNextRunParameterValues,
- getTableMetadata,
+ getTableFieldIds,
],
(
currentQuestion,
@@ -504,7 +505,7 @@ export const getIsResultDirty = createSelector(
lastRunQuestion,
lastParameters,
nextParameters,
- tableMetadata,
+ tableFieldIds,
) => {
const haveParametersChanged = !_.isEqual(lastParameters, nextParameters);
const isEditable =
@@ -517,7 +518,7 @@ export const getIsResultDirty = createSelector(
originalQuestion,
lastRunQuestion,
currentQuestion,
- tableMetadata,
+ tableFieldIds,
})),
);
},
diff --git a/frontend/src/metabase/query_builder/store/state.ts b/frontend/src/metabase/query_builder/store/state.ts
index 6fae3915dd7..c44fb2201f0 100644
--- a/frontend/src/metabase/query_builder/store/state.ts
+++ b/frontend/src/metabase/query_builder/store/state.ts
@@ -1,6 +1,6 @@
import type { timelineApi } from "metabase/api";
import type { getEmbedOptions } from "metabase/embedding/interactive-embedding";
-import type { getMetadata } from "metabase/metadata-store";
+import type { selectQuestionFromCardBuilder } from "metabase/metadata-store";
import type { QueryBuilderState } from "metabase/redux/store/qb";
import type { getSetting } from "metabase/settings";
@@ -11,7 +11,7 @@ import type { getSetting } from "metabase/settings";
* stop reading the global `State`.
*/
export type QueryBuilderStoreState = { qb: QueryBuilderState } & Parameters<
- typeof getMetadata
+ typeof selectQuestionFromCardBuilder
>[0] &
Parameters<typeof getSetting>[0] &
Parameters<typeof getEmbedOptions>[0] &
diff --git a/frontend/src/metabase/visualizations/components/ObjectDetail/utils.ts b/frontend/src/metabase/visualizations/components/ObjectDetail/utils.ts
index 619bdb01600..55971483cf4 100644
--- a/frontend/src/metabase/visualizations/components/ObjectDetail/utils.ts
+++ b/frontend/src/metabase/visualizations/components/ObjectDetail/utils.ts
@@ -14,6 +14,7 @@ import type {
Table as ApiTable,
DatasetColumn,
DatasetData,
+ NormalizedTable,
TableId,
VisualizationSettings,
} from "metabase-types/api";
@@ -134,7 +135,7 @@ export const getSinglePKIndex = (cols: DatasetColumn[]) => {
};
export function getApiTable(
- table: Table | undefined | null,
+ table: NormalizedTable | undefined | null,
): ApiTable | undefined {
if (!table) {
return undefined;
@@ -142,7 +143,7 @@ export function getApiTable(
// Unjustified type cast. FIXME
const apiTable: ApiTable = {
- ...table.getPlainObject(),
+ ...table,
fields: table.original_fields,
} as ApiTable;