Skip to content

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

fix(sdk): sdk crashes when resizing column (#78794)

Nicolò Pretto24720615ab8f
diff --git a/enterprise/frontend/src/metabase-enterprise/transforms-python/components/PythonTransformEditor/PythonEditorResults/ExecutionOutputTable.tsx b/enterprise/frontend/src/metabase-enterprise/transforms-python/components/PythonTransformEditor/PythonEditorResults/ExecutionOutputTable.tsx
index 6dd62ea9bf3..2b824d8a8db 100644
--- a/enterprise/frontend/src/metabase-enterprise/transforms-python/components/PythonTransformEditor/PythonEditorResults/ExecutionOutputTable.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/transforms-python/components/PythonTransformEditor/PythonEditorResults/ExecutionOutputTable.tsx
@@ -1,34 +1,53 @@
-import { DataGrid, useDataGridInstance } from "metabase/data-grid";
+import { useMemo } from "react";
+
+import {
+ type ColumnOptions,
+ DataGrid,
+ useDataGridInstance,
+} from "metabase/data-grid";
import { formatValue } from "metabase/visualizations/lib/formatting";
import type { RowValue, TestPythonTransformResponse } from "metabase-types/api";
export type Row = Record<string, RowValue>;
+type Output = NonNullable<TestPythonTransformResponse["output"]>;
+
+// Stable identities: useDataGridInstance re-syncs its sorted rows whenever
+// `data` changes identity, so a fresh [] on every render loops (metabase#78557)
+const NO_COLS: Output["cols"] = [];
+const NO_ROWS: Output["rows"] = [];
+
export function ExecutionOutputTable({
output,
}: {
output?: TestPythonTransformResponse["output"];
}) {
- const { cols = [], rows = [] } = output ?? {};
+ const { cols = NO_COLS, rows = NO_ROWS } = output ?? {};
+
+ const columnsOptions = useMemo<ColumnOptions<Row, unknown>[]>(
+ () =>
+ cols.map((column) => {
+ // Convert name to string since DataFrames can haven non-string column names
+ const name = (column.name ?? "None").toString();
+ return {
+ id: name,
+ name,
+ accessorFn: (row) => row[column.name],
+ formatter: (value) => {
+ return formatValue(value, {
+ type: "cell",
+ jsx: true,
+ rich: true,
+ });
+ },
+ };
+ }),
+ [cols],
+ );
const tableProps = useDataGridInstance<Row, unknown>({
data: rows,
- columnsOptions: cols.map((column) => {
- // Convert name to string since DataFrames can haven non-string column names
- const name = (column.name ?? "None").toString();
- return {
- id: name,
- name,
- accessorFn: (row) => row[column.name],
- formatter: (value) => {
- return formatValue(value, {
- type: "cell",
- jsx: true,
- rich: true,
- });
- },
- };
- }),
+ columnsOptions,
});
if (!output || cols.length === 0) {
diff --git a/enterprise/frontend/src/metabase-enterprise/transforms-python/components/PythonTransformEditor/PythonEditorResults/ExecutionOutputTable.unit.spec.tsx b/enterprise/frontend/src/metabase-enterprise/transforms-python/components/PythonTransformEditor/PythonEditorResults/ExecutionOutputTable.unit.spec.tsx
new file mode 100644
index 00000000000..b4ff0e704e0
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/transforms-python/components/PythonTransformEditor/PythonEditorResults/ExecutionOutputTable.unit.spec.tsx
@@ -0,0 +1,41 @@
+import {
+ mockGetBoundingClientRect,
+ renderWithProviders,
+ screen,
+ within,
+} from "__support__/ui";
+import type { TestPythonTransformResponse } from "metabase-types/api";
+
+import { ExecutionOutputTable } from "./ExecutionOutputTable";
+
+const OUTPUT: NonNullable<TestPythonTransformResponse["output"]> = {
+ cols: [{ name: "value" }],
+ rows: [{ value: "test" }],
+};
+
+const getBodyCell = () =>
+ within(screen.getByRole("gridcell")).getByTestId("body-cell-container");
+
+describe("ExecutionOutputTable", () => {
+ beforeEach(() => {
+ mockGetBoundingClientRect();
+ });
+
+ it("renders nothing when there is no output (metabase#78557)", () => {
+ expect(() =>
+ renderWithProviders(<ExecutionOutputTable output={undefined} />),
+ ).not.toThrow();
+ });
+
+ it("does not remount cells when re-rendered with the same output (metabase#78557)", () => {
+ const { rerender } = renderWithProviders(
+ <ExecutionOutputTable output={OUTPUT} />,
+ );
+ const cell = getBodyCell();
+
+ rerender(<ExecutionOutputTable output={OUTPUT} />);
+
+ // A remounted cell is a new DOM node; a re-rendered one keeps its node
+ expect(getBodyCell()).toBe(cell);
+ });
+});
diff --git a/frontend/src/metabase/data-grid/hooks/use-data-grid-instance.tsx b/frontend/src/metabase/data-grid/hooks/use-data-grid-instance.tsx
index 143137721bb..7604b61e210 100644
--- a/frontend/src/metabase/data-grid/hooks/use-data-grid-instance.tsx
+++ b/frontend/src/metabase/data-grid/hooks/use-data-grid-instance.tsx
@@ -1,4 +1,5 @@
import {
+ type ColumnMeta,
type ColumnSizingState,
type PaginationState,
type Row,
@@ -7,7 +8,6 @@ import {
getSortedRowModel,
useReactTable,
} from "@tanstack/react-table";
-import type React from "react";
import {
useCallback,
useEffect,
@@ -37,10 +37,14 @@ import type {
DataGridInstance,
DataGridOptions,
DataGridRowType,
+ ExpandColumnHandler,
ExpandedColumnsState,
ScrollToDestinations,
} from "metabase/data-grid/types";
-import { getDataColumn } from "metabase/data-grid/utils/columns/data-column";
+import {
+ getDataColumn,
+ getIsColumnTruncated,
+} from "metabase/data-grid/utils/columns/data-column";
import { getRowIdColumn } from "metabase/data-grid/utils/columns/row-id-column";
import { getScrollBarSize } from "metabase/utils/dom";
import { isNotNull } from "metabase/utils/types";
@@ -154,19 +158,19 @@ export const useDataGridInstance = <TData, TValue>({
);
// Handler for expand button click - expands column and adjusts width
- const handleExpandButtonClick = useCallback(
- (columnName: string, content: React.ReactNode) => {
+ const handleExpandButtonClick = useCallback<ExpandColumnHandler>(
+ (columnId, formattedValue) => {
const newColumnWidth = Math.max(
- measureBodyCellDimensions(content).width,
- measuredColumnSizingMap[columnName],
+ measureBodyCellDimensions(formattedValue).width,
+ measuredColumnSizingMap[columnId],
);
const newColumnSizing = {
...columnSizingMap,
- [columnName]: newColumnWidth,
+ [columnId]: newColumnWidth,
};
setColumnSizingMap(newColumnSizing);
- handleUpdateColumnExpanded(columnName);
+ handleUpdateColumnExpanded(columnId);
},
[
columnSizingMap,
@@ -176,20 +180,36 @@ export const useDataGridInstance = <TData, TValue>({
],
);
+ // Memoized dataColumns without column width dependent values, so that this
+ // doesn't change when resizing a column. Needed to not re-create the `header`
+ // and `cell` components on each drag frame, which remounts every cell and
+ // may crash the grid in react 19(metabase#78557).
+ const unsizedDataColumns = useMemo(
+ () =>
+ columnsOptions.map((options) => getDataColumn<TData, TValue>(options)),
+ [columnsOptions],
+ );
+
+ // Everything that changes while resizing goes through meta, which does not
+ // affect `header` and `cell` component identity
const dataColumns = useMemo(
() =>
- columnsOptions.map((options) =>
- getDataColumn<TData, TValue>(
- options,
- columnSizingMap,
- measuredColumnSizingMap,
- expandedColumnsMap,
- truncateLongCellWidth,
- handleExpandButtonClick,
- ),
- ),
+ unsizedDataColumns.map((column) => ({
+ ...column,
+ meta: {
+ ...column.meta,
+ isTruncated: getIsColumnTruncated({
+ columnId: column.id,
+ columnSizing: columnSizingMap,
+ measuredColumnSizing: measuredColumnSizingMap,
+ expandedColumns: expandedColumnsMap,
+ truncateWidth: truncateLongCellWidth,
+ }),
+ onExpand: handleExpandButtonClick,
+ } satisfies ColumnMeta<TData, TValue>,
+ })),
[
- columnsOptions,
+ unsizedDataColumns,
columnSizingMap,
measuredColumnSizingMap,
expandedColumnsMap,
diff --git a/frontend/src/metabase/data-grid/hooks/use-data-grid-instance.unit.spec.tsx b/frontend/src/metabase/data-grid/hooks/use-data-grid-instance.unit.spec.tsx
new file mode 100644
index 00000000000..a00d2f0d409
--- /dev/null
+++ b/frontend/src/metabase/data-grid/hooks/use-data-grid-instance.unit.spec.tsx
@@ -0,0 +1,61 @@
+import { act, renderHook } from "@testing-library/react";
+
+import { useDataGridInstance } from "./use-data-grid-instance";
+
+type TestRow = { value: string };
+
+// Module scope so the hook sees a stable reference across renders, which is
+// what the fix relies on
+const DATA: TestRow[] = [{ value: "value" }];
+const COLUMNS_OPTIONS = [
+ {
+ id: "value",
+ name: "Value",
+ accessorFn: (row: TestRow) => row.value,
+ },
+];
+
+describe("useDataGridInstance", () => {
+ describe("issue 78557", () => {
+ it("keeps cell and header component identity across a column resize", () => {
+ const { result } = renderHook(() =>
+ useDataGridInstance<TestRow, string>({
+ data: DATA,
+ columnsOptions: COLUMNS_OPTIONS,
+ }),
+ );
+
+ const before = result.current.table.getColumn("value")?.columnDef;
+ // Without this the assertions below pass when both sides are undefined
+ expect(before?.cell).toBeDefined();
+ expect(before?.header).toBeDefined();
+
+ act(() => {
+ result.current.table.setColumnSizing({ value: 200 });
+ });
+
+ const after = result.current.table.getColumn("value")?.columnDef;
+
+ // A new component type per resize tick makes React remount every cell
+ // instead of re-rendering it, which ends in "Maximum update depth exceeded"
+ expect(after?.cell).toBe(before?.cell);
+ expect(after?.header).toBe(before?.header);
+ });
+
+ it("puts values that depend on the column width on meta, to avoid remounting cells on resize", () => {
+ const { result } = renderHook(() =>
+ useDataGridInstance<TestRow, string>({
+ data: DATA,
+ columnsOptions: COLUMNS_OPTIONS,
+ }),
+ );
+
+ const meta = result.current.table.getColumn("value")?.columnDef.meta;
+
+ expect(meta).toMatchObject({
+ isTruncated: false,
+ onExpand: expect.any(Function),
+ });
+ });
+ });
+});
diff --git a/frontend/src/metabase/data-grid/types.ts b/frontend/src/metabase/data-grid/types.ts
index 1deff08182f..b60f2ed0644 100644
--- a/frontend/src/metabase/data-grid/types.ts
+++ b/frontend/src/metabase/data-grid/types.ts
@@ -31,6 +31,10 @@ declare module "@tanstack/react-table" {
clipboardFormatter?: PlainCellFormatter<TValue>;
width?: "auto";
isUtilityColumn?: boolean;
+ // Values that change while a column is resized live here rather than in the
+ // cell/header closures, so component identity stays stable (metabase#78557)
+ isTruncated?: boolean;
+ onExpand?: ExpandColumnHandler;
}
}
@@ -52,7 +56,7 @@ export type BodyCellBaseProps<TValue> = {
isSelected?: boolean;
className?: string;
style?: React.CSSProperties;
- onExpand?: (id: string, formattedValue: React.ReactNode) => void;
+ onExpand?: ExpandColumnHandler;
};
/**
@@ -196,7 +200,10 @@ export interface DataGridOptions<TData = any, TValue = any> {
/** Default row height in pixels */
defaultRowHeight?: number;
- /** Configuration for columns */
+ /**
+ * Configuration for columns. Must be memoized: cell and header components are
+ * built from it, so an unstable array remounts every cell on each render
+ * (metabase#78557) */
columnsOptions: ColumnOptions<TData, TValue>[];
/**
@@ -265,6 +272,11 @@ export type PlainCellFormatter<TValue> = (
columnId: string,
) => string;
+export type ExpandColumnHandler = (
+ columnId: string,
+ formattedValue: React.ReactNode,
+) => void;
+
export type ExpandedColumnsState = Record<string, boolean>;
export type DataGridSelection = {
diff --git a/frontend/src/metabase/data-grid/utils/columns/data-column.tsx b/frontend/src/metabase/data-grid/utils/columns/data-column.tsx
index 86d2a6e90f0..6d8416faec9 100644
--- a/frontend/src/metabase/data-grid/utils/columns/data-column.tsx
+++ b/frontend/src/metabase/data-grid/utils/columns/data-column.tsx
@@ -3,7 +3,6 @@ import type {
ColumnDef,
ColumnSizingState,
} from "@tanstack/react-table";
-import type React from "react";
import { memo } from "react";
import { BodyCell } from "metabase/data-grid/components/BodyCell/BodyCell";
@@ -14,29 +13,28 @@ import type {
ExpandedColumnsState,
} from "metabase/data-grid/types";
-const getDefaultCellTemplate = <TRow, TValue>(
- {
- id,
- align,
- getBackgroundColor,
- formatter,
- cellVariant,
- wrap,
- getCellClassName,
- getCellStyle,
- getIsEditing,
- editingCell: EditingCellComponent,
- }: ColumnOptions<TRow, TValue>,
- isTruncated: boolean,
- onExpand: (columnName: string, content: React.ReactNode) => void,
-) => {
+const getDefaultCellTemplate = <TRow, TValue>({
+ id,
+ align,
+ getBackgroundColor,
+ formatter,
+ cellVariant,
+ wrap,
+ getCellClassName,
+ getCellStyle,
+ getIsEditing,
+ editingCell: EditingCellComponent,
+}: ColumnOptions<TRow, TValue>) => {
return function Cell(
props: CellContext<TRow, TValue> & { isSelected?: boolean },
) {
- const { getValue, row, isSelected } = props;
+ const { getValue, row, column, isSelected } = props;
const value = getValue();
const backgroundColor = getBackgroundColor?.(value, row?.index);
const isEditing = getIsEditing?.(id, row.index);
+ // Read from column meta so the component identity can stay stable across
+ // column width changes (metabase#78557)
+ const { isTruncated = false, onExpand } = column.columnDef.meta ?? {};
if (isEditing && EditingCellComponent) {
return <EditingCellComponent {...props} />;
@@ -80,14 +78,39 @@ const getDefaultHeaderTemplate = <TRow, TValue>({
};
};
+// getDataColumn always sets the id, unlike tanstack's ColumnDef where it is optional
+export type DataColumnDef<TRow, TValue> = ColumnDef<TRow, TValue> & {
+ id: string;
+};
+
+type ColumnTruncationOptions = {
+ columnId: string;
+ columnSizing: ColumnSizingState;
+ measuredColumnSizing: ColumnSizingState;
+ expandedColumns: ExpandedColumnsState;
+ truncateWidth: number;
+};
+
+export const getIsColumnTruncated = ({
+ columnId,
+ columnSizing,
+ measuredColumnSizing,
+ expandedColumns,
+ truncateWidth,
+}: ColumnTruncationOptions) => {
+ const columnWidth = columnSizing[columnId] ?? 0;
+ const measuredColumnWidth = measuredColumnSizing[columnId] ?? 0;
+
+ return (
+ !expandedColumns[columnId] &&
+ columnWidth < measuredColumnWidth &&
+ measuredColumnWidth > truncateWidth
+ );
+};
+
export const getDataColumn = <TRow, TValue>(
columnOptions: ColumnOptions<TRow, TValue>,
- columnSizing: ColumnSizingState,
- measuredColumnSizing: ColumnSizingState,
- expandedColumns: ExpandedColumnsState,
- truncateWidth: number,
- onExpand: (columnName: string, content: React.ReactNode) => void,
-): ColumnDef<TRow, TValue> => {
+): DataColumnDef<TRow, TValue> => {
const {
id,
accessorFn,
@@ -97,15 +120,8 @@ export const getDataColumn = <TRow, TValue>(
headerClickTargetSelector,
sortingFn,
} = columnOptions;
- const columnWidth = columnSizing[id] ?? 0;
- const measuredColumnWidth = measuredColumnSizing[id] ?? 0;
-
- const isTruncated =
- !expandedColumns[id] &&
- columnWidth < measuredColumnWidth &&
- measuredColumnWidth > truncateWidth;
- const columnDefinition: ColumnDef<TRow, TValue> = {
+ const columnDefinition: DataColumnDef<TRow, TValue> = {
accessorFn,
id,
...(sortingFn != null ? { sortingFn } : {}),
@@ -115,10 +131,7 @@ export const getDataColumn = <TRow, TValue>(
: header,
cell:
typeof cell !== "string"
- ? memo(
- cell ??
- getDefaultCellTemplate(columnOptions, isTruncated, onExpand),
- )
+ ? memo(cell ?? getDefaultCellTemplate(columnOptions))
: cell,
minSize: MIN_COLUMN_WIDTH,
enableResizing: true,
diff --git a/frontend/src/metabase/data-grid/utils/columns/data-column.unit.spec.tsx b/frontend/src/metabase/data-grid/utils/columns/data-column.unit.spec.tsx
index ebb91d42544..604c9150ef7 100644
--- a/frontend/src/metabase/data-grid/utils/columns/data-column.unit.spec.tsx
+++ b/frontend/src/metabase/data-grid/utils/columns/data-column.unit.spec.tsx
@@ -1,8 +1,10 @@
+import type { ColumnDef } from "@tanstack/react-table";
import { screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
import { renderWithProviders } from "__support__/ui";
-import { getDataColumn } from "./data-column";
+import { getDataColumn, getIsColumnTruncated } from "./data-column";
const setup = ({
columnSize,
@@ -18,32 +20,46 @@ const setup = ({
columnWrap?: boolean;
}) => {
const onExpand = jest.fn();
- const column = getDataColumn(
- {
- id: "test-column",
- name: "Test Column",
- accessorFn: (row: { value: string }) => row.value,
- wrap: columnWrap,
+ const columnOptions = {
+ id: "test-column",
+ name: "Test Column",
+ accessorFn: (row: { value: string }) => row.value,
+ wrap: columnWrap,
+ };
+ const dataColumn = getDataColumn(columnOptions);
+
+ // Mirrors how the hook overlays width-dependent values onto meta
+ const column: ColumnDef<{ value: string }, string> = {
+ ...dataColumn,
+ meta: {
+ ...dataColumn.meta,
+ isTruncated: getIsColumnTruncated({
+ columnId: columnOptions.id,
+ columnSizing: { "test-column": columnSize },
+ measuredColumnSizing: { "test-column": measuredColumnSize },
+ expandedColumns: { "test-column": expandColumn },
+ truncateWidth,
+ }),
+ onExpand,
},
- { "test-column": columnSize },
- { "test-column": measuredColumnSize },
- { "test-column": expandColumn },
- truncateWidth,
- onExpand,
- );
+ };
// Unjustified type cast. FIXME
const CellComponent = column.cell as React.ComponentType<{
getValue: () => string;
row: { index: number; original: { value: string } };
+ column: { columnDef: typeof column };
}>;
renderWithProviders(
<CellComponent
getValue={() => "test value"}
row={{ index: 0, original: { value: "test value" } }}
+ column={{ columnDef: column }}
/>,
);
+
+ return { onExpand };
};
describe("getDataColumn", () => {
@@ -104,5 +120,16 @@ describe("getDataColumn", () => {
expect(screen.queryByTestId("expand-column")).not.toBeInTheDocument();
});
+
+ it("calls onExpand when the expand button is clicked", async () => {
+ const { onExpand } = setup({
+ columnSize: 150,
+ measuredColumnSize: 300,
+ });
+
+ await userEvent.click(screen.getByTestId("expand-column"));
+
+ expect(onExpand).toHaveBeenCalledWith("test-column", "test value");
+ });
});
});