Skip to content

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

Fix flaky 'admin > allows to undo every action' test (#81020)

Anderson35c9ea0a296d
diff --git a/frontend/src/metabase/api/field.ts b/frontend/src/metabase/api/field.ts
index 2f9b9380f59..1ec045a3483 100644
--- a/frontend/src/metabase/api/field.ts
+++ b/frontend/src/metabase/api/field.ts
@@ -15,6 +15,7 @@ import type {
} from "metabase-types/api";
import { Api } from "./api";
+import { patchCachedTableMetadata, selectCachedTableMetadata } from "./table";
import {
idTag,
invalidateTags,
@@ -24,6 +25,7 @@ import {
provideRemappedFieldValuesTags,
tag,
} from "./tags";
+import { rollbackOnError } from "./utils/rollback-on-error";
export const fieldApi = Api.injectEndpoints({
endpoints: (builder) => ({
@@ -89,6 +91,28 @@ export const fieldApi = Api.injectEndpoints({
tag("card"),
tag("dataset"),
]),
+ onQueryStarted: async (
+ { id, ...body },
+ { dispatch, getState, queryFulfilled },
+ ) => {
+ const patches = selectCachedTableMetadata(getState(), [
+ idTag("field", id),
+ ]).map(({ originalArgs }) =>
+ dispatch(
+ patchCachedTableMetadata(originalArgs, (table) => {
+ const field = table.fields?.find(
+ ({ id: fieldId }) => fieldId === id,
+ );
+
+ if (field) {
+ Object.assign(field, body);
+ }
+ }),
+ ),
+ );
+
+ await rollbackOnError(queryFulfilled, patches);
+ },
}),
updateFieldValues: builder.mutation<void, UpdateFieldValuesRequest>({
query: ({ id, ...body }) => ({
diff --git a/frontend/src/metabase/api/index.ts b/frontend/src/metabase/api/index.ts
index ceadad3425f..997018ea5e5 100644
--- a/frontend/src/metabase/api/index.ts
+++ b/frontend/src/metabase/api/index.ts
@@ -32,6 +32,7 @@ export * from "./persist";
export * from "./premium-features";
export * from "./public";
export * from "./pulse";
+export * from "./retry-dropped-refetch";
export * from "./revision";
export * from "./search";
export * from "./security-center";
diff --git a/frontend/src/metabase/api/retry-dropped-refetch.ts b/frontend/src/metabase/api/retry-dropped-refetch.ts
new file mode 100644
index 00000000000..4976577e448
--- /dev/null
+++ b/frontend/src/metabase/api/retry-dropped-refetch.ts
@@ -0,0 +1,81 @@
+import type {
+ Middleware,
+ ThunkDispatch,
+ UnknownAction,
+} from "@reduxjs/toolkit";
+import { isFulfilled, isRejected } from "@reduxjs/toolkit";
+
+import { Api } from "./api";
+
+type QueryThunkArg = {
+ forceRefetch?: boolean;
+ queryCacheKey: string;
+};
+
+function isQueryThunkArg(arg: unknown): arg is QueryThunkArg {
+ return (
+ typeof arg === "object" &&
+ arg !== null &&
+ "type" in arg &&
+ arg.type === "query" &&
+ "queryCacheKey" in arg &&
+ typeof arg.queryCacheKey === "string"
+ );
+}
+
+function getQueryThunkArg(action: unknown): QueryThunkArg | undefined {
+ if (!isFulfilled(action) && !isRejected(action)) {
+ return undefined;
+ }
+
+ const { arg } = action.meta;
+
+ return isQueryThunkArg(arg) ? arg : undefined;
+}
+
+/**
+ * RTK Query drops an invalidation's refetch while another request for the same
+ * cache entry is in flight, so the older response wins and the cache keeps data
+ * the server has already replaced. Nothing re-queues it, so hold on to the
+ * request that displaced it and refetch once it settles.
+ * Works around https://github.com/reduxjs/redux-toolkit/issues/5405.
+ */
+export const retryDroppedRefetches: Middleware<
+ object,
+ unknown,
+ ThunkDispatch<unknown, unknown, UnknownAction>
+> = ({ dispatch }) => {
+ const displacedBy = new Map<string, { refetch: () => void }>();
+
+ return (next) => (action) => {
+ const result = next(action);
+ const arg = getQueryThunkArg(action);
+
+ if (!arg) {
+ return result;
+ }
+
+ if (isRejected(action) && action.meta.condition) {
+ if (arg.forceRefetch && !displacedBy.has(arg.queryCacheKey)) {
+ const inFlight = dispatch(Api.util.getRunningQueriesThunk()).find(
+ (query) => query.queryCacheKey === arg.queryCacheKey,
+ );
+
+ if (inFlight) {
+ displacedBy.set(arg.queryCacheKey, inFlight);
+ }
+ }
+
+ return result;
+ }
+
+ const dropped = displacedBy.get(arg.queryCacheKey);
+
+ if (dropped) {
+ displacedBy.delete(arg.queryCacheKey);
+ dropped.refetch();
+ }
+
+ return result;
+ };
+};
diff --git a/frontend/src/metabase/api/retry-dropped-refetch.unit.spec.ts b/frontend/src/metabase/api/retry-dropped-refetch.unit.spec.ts
new file mode 100644
index 00000000000..91a6bc81382
--- /dev/null
+++ b/frontend/src/metabase/api/retry-dropped-refetch.unit.spec.ts
@@ -0,0 +1,141 @@
+import { waitFor } from "@testing-library/react";
+import fetchMock from "fetch-mock";
+
+import { getStore } from "__support__/entities-store";
+import { createMockField, createMockTable } from "metabase-types/api/mocks";
+
+import { Api } from "./api";
+import { fieldApi } from "./field";
+import { retryDroppedRefetches } from "./retry-dropped-refetch";
+import { tableApi } from "./table";
+
+const TABLE_ID = 1;
+const FIELD_ID = 10;
+
+let activeStore: ReturnType<typeof getStore> | undefined;
+
+function setup({ withMiddleware }: { withMiddleware: boolean }) {
+ let releaseRefetch = () => {};
+ const heldRefetch = new Promise<void>((resolve) => {
+ releaseRefetch = () => resolve();
+ });
+ const makeTable = (fieldName: string) =>
+ createMockTable({
+ id: TABLE_ID,
+ fields: [createMockField({ id: FIELD_ID, display_name: fieldName })],
+ });
+
+ let metadataCalls = 0;
+ fetchMock.get(`path:/api/table/${TABLE_ID}/query_metadata`, () => {
+ metadataCalls += 1;
+ if (metadataCalls === 1) {
+ return makeTable("Initial");
+ }
+ if (metadataCalls === 2) {
+ return heldRefetch.then(() => makeTable("AfterChange"));
+ }
+ return makeTable("AfterUndo");
+ });
+ fetchMock.put(`path:/api/field/${FIELD_ID}`, { id: FIELD_ID });
+
+ const store = getStore({ [Api.reducerPath]: Api.reducer }, {}, [
+ Api.middleware,
+ ...(withMiddleware ? [retryDroppedRefetches] : []),
+ ]);
+ activeStore = store;
+
+ const cachedFieldName = () => {
+ const queries =
+ // The store is typed from its reducers, so the RTK Query slice is opaque.
+ (
+ store.getState() as unknown as Record<
+ string,
+ {
+ queries: Record<
+ string,
+ { data?: { id: number; fields?: { display_name: string }[] } }
+ >;
+ }
+ >
+ )[Api.reducerPath].queries;
+
+ return Object.values(queries).find((entry) => entry.data?.id === TABLE_ID)
+ ?.data?.fields?.[0].display_name;
+ };
+
+ const subscribe = () =>
+ store.dispatch(
+ tableApi.endpoints.getTableQueryMetadata.initiate({ id: TABLE_ID }),
+ );
+
+ const renameField = (name: string) =>
+ store.dispatch(
+ fieldApi.endpoints.updateField.initiate({
+ id: FIELD_ID,
+ display_name: name,
+ }),
+ );
+
+ return {
+ cachedFieldName,
+ metadataCalls: () => metadataCalls,
+ releaseRefetch,
+ renameField,
+ subscribe,
+ };
+}
+
+/**
+ * Reproduces the refetch RTK Query drops: a re-subscribe during a change's
+ * in-flight refetch is condition-rejected, so the undo's invalidation flushes
+ * early, its refetch is rejected too, and the stale response stays cached.
+ */
+async function runDroppedRefetchScenario(withMiddleware: boolean) {
+ const {
+ cachedFieldName,
+ metadataCalls,
+ releaseRefetch,
+ renameField,
+ subscribe,
+ } = setup({ withMiddleware });
+
+ subscribe();
+ await waitFor(() => expect(cachedFieldName()).toBe("Initial"));
+
+ await renameField("AfterChange");
+ await waitFor(() => expect(metadataCalls()).toBe(2));
+
+ subscribe();
+ await renameField("AfterUndo");
+ releaseRefetch();
+
+ return { cachedFieldName, metadataCalls };
+}
+
+describe("retryDroppedRefetches", () => {
+ afterEach(() => {
+ activeStore?.dispatch(Api.util.resetApiState());
+ activeStore = undefined;
+ fetchMock.removeRoutes().clearHistory();
+ });
+
+ it("re-runs the refetch RTK Query dropped, so the cache converges on the undone value", async () => {
+ const { cachedFieldName, metadataCalls } =
+ await runDroppedRefetchScenario(true);
+
+ await waitFor(() => expect(cachedFieldName()).toBe("AfterUndo"));
+ expect(metadataCalls()).toBe(3);
+ });
+
+ // Asserts the RTK bug itself (https://github.com/reduxjs/redux-toolkit/issues/5405).
+ // If an RTK upgrade makes this fail, the middleware and this spec can be deleted.
+ it("without the middleware the stale in-flight response wins permanently", async () => {
+ const { cachedFieldName, metadataCalls } =
+ await runDroppedRefetchScenario(false);
+
+ await waitFor(() => expect(cachedFieldName()).toBe("AfterChange"));
+ await new Promise((resolve) => setTimeout(resolve, 50));
+ expect(cachedFieldName()).toBe("AfterChange");
+ expect(metadataCalls()).toBe(2);
+ });
+});
diff --git a/frontend/src/metabase/api/table-metadata-cache.unit.spec.ts b/frontend/src/metabase/api/table-metadata-cache.unit.spec.ts
new file mode 100644
index 00000000000..215d1f90bbd
--- /dev/null
+++ b/frontend/src/metabase/api/table-metadata-cache.unit.spec.ts
@@ -0,0 +1,108 @@
+import { waitFor } from "@testing-library/react";
+import fetchMock from "fetch-mock";
+
+import { getStore } from "__support__/entities-store";
+import { createMockField, createMockTable } from "metabase-types/api/mocks";
+
+import { Api } from "./api";
+import { fieldApi } from "./field";
+import { tableApi } from "./table";
+
+let activeStore: ReturnType<typeof getStore> | undefined;
+
+type SetupOpts = {
+ fieldId: number;
+ tableId: number;
+ updateFails?: boolean;
+};
+
+function setup({ fieldId, tableId, updateFails = false }: SetupOpts) {
+ const field = createMockField({ id: fieldId, display_name: "Quantity" });
+ const table = createMockTable({ id: tableId, fields: [field] });
+
+ fetchMock.get(`path:/api/table/${tableId}/query_metadata`, table);
+ fetchMock.put(
+ `path:/api/field/${fieldId}`,
+ updateFails ? 500 : { ...field, display_name: "Quantity a" },
+ );
+
+ const store = getStore({ [Api.reducerPath]: Api.reducer }, {}, [
+ Api.middleware,
+ ]);
+
+ activeStore = store;
+
+ const cachedFieldName = () => {
+ const queries =
+ // The store is typed from its reducers, so the RTK Query slice is opaque.
+ (
+ store.getState() as unknown as Record<
+ string,
+ {
+ queries: Record<
+ string,
+ { data?: { id: number; fields?: { display_name: string }[] } }
+ >;
+ }
+ >
+ )[Api.reducerPath].queries;
+
+ return Object.values(queries).find((entry) => entry.data?.id === tableId)
+ ?.data?.fields?.[0].display_name;
+ };
+
+ const loadTable = async () => {
+ store.dispatch(
+ tableApi.endpoints.getTableQueryMetadata.initiate({ id: tableId }),
+ );
+ await waitFor(() => {
+ expect(cachedFieldName()).toBe("Quantity");
+ });
+ };
+
+ const renameField = () =>
+ store.dispatch(
+ fieldApi.endpoints.updateField.initiate({
+ id: fieldId,
+ display_name: "Quantity a",
+ }),
+ );
+
+ return { cachedFieldName, loadTable, renameField };
+}
+
+describe("cached table metadata", () => {
+ afterEach(() => {
+ activeStore?.dispatch(Api.util.resetApiState());
+ activeStore = undefined;
+ fetchMock.removeRoutes().clearHistory();
+ });
+
+ it("writes an updated field into cached table metadata before the request resolves", async () => {
+ const { cachedFieldName, loadTable, renameField } = setup({
+ fieldId: 10,
+ tableId: 1,
+ });
+
+ await loadTable();
+ renameField();
+
+ expect(cachedFieldName()).toBe("Quantity a");
+ });
+
+ it("rolls the write back when the request fails", async () => {
+ const { cachedFieldName, loadTable, renameField } = setup({
+ fieldId: 20,
+ tableId: 2,
+ updateFails: true,
+ });
+
+ await loadTable();
+ renameField();
+ expect(cachedFieldName()).toBe("Quantity a");
+
+ await waitFor(() => {
+ expect(cachedFieldName()).toBe("Quantity");
+ });
+ });
+});
diff --git a/frontend/src/metabase/api/table.ts b/frontend/src/metabase/api/table.ts
index 8aa14dfd14e..78a224aa3a8 100644
--- a/frontend/src/metabase/api/table.ts
+++ b/frontend/src/metabase/api/table.ts
@@ -1,3 +1,5 @@
+import type { ThunkAction, UnknownAction } from "@reduxjs/toolkit";
+
import type {
BulkTableRequest,
BulkTableSelectionInfo,
@@ -28,6 +30,7 @@ import {
provideTableTags,
tag,
} from "./tags";
+import { rollbackOnError } from "./utils/rollback-on-error";
export const tableApi = Api.injectEndpoints({
endpoints: (builder) => ({
@@ -81,6 +84,24 @@ export const tableApi = Api.injectEndpoints({
tag("dataset"),
listTag("erd"),
]),
+ onQueryStarted: async (
+ { id, ...body },
+ { dispatch, getState, queryFulfilled },
+ ) => {
+ const patches = selectCachedTableMetadata(getState(), [
+ idTag("table", id),
+ ]).map(({ originalArgs }) =>
+ dispatch(
+ patchCachedTableMetadata(originalArgs, (table) => {
+ if (table.id === id) {
+ Object.assign(table, body);
+ }
+ }),
+ ),
+ );
+
+ await rollbackOnError(queryFulfilled, patches);
+ },
}),
updateTableList: builder.mutation<Table[], UpdateTableListRequest>({
query: (body) => ({
@@ -301,3 +322,30 @@ export const fetchForeignTablesMetadata = (
);
};
};
+
+export type TableMetadataPatch = {
+ undo: () => void;
+};
+
+/**
+ * `updateQueryData` is generic over every endpoint in this file, and TypeScript
+ * can only instantiate that from inside the `injectEndpoints` call above
+ * (TS2589 anywhere else). Pinning the single endpoint we patch keeps the call
+ * sites, including the one in `field.ts`, fully checked.
+ */
+export const patchCachedTableMetadata = tableApi.util.updateQueryData.bind(
+ null,
+ "getTableQueryMetadata",
+) as (
+ args: GetTableQueryMetadataRequest,
+ recipe: (table: Table) => void,
+) => ThunkAction<TableMetadataPatch, unknown, unknown, UnknownAction>;
+
+export function selectCachedTableMetadata(
+ state: Parameters<typeof tableApi.util.selectInvalidatedBy>[0],
+ tags: Parameters<typeof tableApi.util.selectInvalidatedBy>[1],
+) {
+ return tableApi.util
+ .selectInvalidatedBy(state, tags)
+ .filter(({ endpointName }) => endpointName === "getTableQueryMetadata");
+}
diff --git a/frontend/src/metabase/api/utils/rollback-on-error.ts b/frontend/src/metabase/api/utils/rollback-on-error.ts
new file mode 100644
index 00000000000..8ea150f0441
--- /dev/null
+++ b/frontend/src/metabase/api/utils/rollback-on-error.ts
@@ -0,0 +1,15 @@
+type Patch = {
+ undo: () => void;
+};
+
+/** Undoes optimistic cache patches when the mutation they anticipated fails. */
+export async function rollbackOnError(
+ queryFulfilled: Promise<unknown>,
+ patches: Patch[],
+) {
+ try {
+ await queryFulfilled;
+ } catch {
+ patches.forEach((patch) => patch.undo());
+ }
+}
diff --git a/frontend/src/metabase/data-studio/data-model/components/TableSection/TableSection.tsx b/frontend/src/metabase/data-studio/data-model/components/TableSection/TableSection.tsx
index b3d54c5cb16..305b57eb19c 100644
--- a/frontend/src/metabase/data-studio/data-model/components/TableSection/TableSection.tsx
+++ b/frontend/src/metabase/data-studio/data-model/components/TableSection/TableSection.tsx
@@ -1,14 +1,9 @@
import { memo, useCallback, useState } from "react";
import { t } from "ttag";
-import {
- useUpdateTableFieldsOrderMutation,
- useUpdateTableMutation,
-} from "metabase/api";
import { EmptyState } from "metabase/common/components/EmptyState";
import { ForwardRefLink } from "metabase/common/components/Link";
import { trackDependencyEntitySelected } from "metabase/common/data-studio/analytics";
-import { useMetadataToasts } from "metabase/common/hooks";
import {
FieldOrderPicker,
NameDescriptionInput,
@@ -16,7 +11,7 @@ import {
import { ResponsiveButton } from "metabase/metadata/components/ResponsiveButton";
import { TableFieldList } from "metabase/metadata/components/TableFieldList";
import { TableSortableFieldList } from "metabase/metadata/components/TableSortableFieldList";
-import { getRawTableFieldId } from "metabase/metadata/utils/field";
+import { useTableUpdateHandlers } from "metabase/metadata/hooks";
import {
PLUGIN_DEPENDENCIES,
PLUGIN_LIBRARY,
@@ -40,7 +35,6 @@ import { dependencyGraph } from "metabase/urls/dependencies";
import {
type FieldId,
type Table,
- type TableFieldOrder,
isConcreteTableId,
} from "metabase-types/api";
@@ -72,13 +66,14 @@ const TableSectionBase = ({
hasLibrary,
onUpdate,
}: Props) => {
- const [updateTable] = useUpdateTableMutation();
- const [updateTableSorting, { isLoading: isUpdatingSorting }] =
- useUpdateTableMutation();
- const [updateTableFieldsOrder] = useUpdateTableFieldsOrderMutation();
+ const {
+ handleNameChange,
+ handleDescriptionChange,
+ handleFieldOrderTypeChange,
+ handleCustomFieldOrderChange,
+ isUpdatingSorting,
+ } = useTableUpdateHandlers({ table, onNameUpdated: onUpdate });
const [modalType, setModalType] = useState<TableModalType>();
- const { sendErrorToast, sendSuccessToast, sendUndoToast } =
- useMetadataToasts();
const [isSorting, setIsSorting] = useState(false);
const hasFields = Boolean(table.fields && table.fields.length > 0);
const isLibraryEnabled = PLUGIN_LIBRARY.isEnabled;
@@ -117,89 +112,6 @@ const TableSectionBase = ({
[table.db_id, table.schema, table.id, navigate],
);
- const handleNameChange = async (name: string) => {
- const { error } = await updateTable({
- id: table.id,
- display_name: name,
- });
-
- if (error) {
- sendErrorToast(t`Failed to update table name`);
- } else {
- onUpdate();
- sendSuccessToast(t`Table name updated`, async () => {
- const { error } = await updateTable({
- id: table.id,
- display_name: table.display_name,
- });
- sendUndoToast(error);
- });
- }
- };
-
- const handleDescriptionChange = async (description: string) => {
- const { error } = await updateTable({ id: table.id, description });
-
- if (error) {
- sendErrorToast(t`Failed to update table description`);
- } else {
- sendSuccessToast(t`Table description updated`, async () => {
- const { error } = await updateTable({
- id: table.id,
- description: table.description ?? "",
- });
- sendUndoToast(error);
- });
- }
- };
-
- const handleFieldOrderTypeChange = async (fieldOrder: TableFieldOrder) => {
- const { error } = await updateTableSorting({
- id: table.id,
- field_order: fieldOrder,
- });
-
- if (error) {
- sendErrorToast(t`Failed to update field order`);
- } else {
- sendSuccessToast(t`Field order updated`, async () => {
- const { error } = await updateTable({
- id: table.id,
- field_order: table.field_order,
- });
- sendUndoToast(error);
- });
- }
- };
-
- const handleCustomFieldOrderChange = async (fieldOrder: FieldId[]) => {
- const { error } = await updateTableFieldsOrder({
- id: table.id,
- field_order: fieldOrder,
- });
-
- if (error) {
- sendErrorToast(t`Failed to update field order`);
- } else {
- sendSuccessToast(t`Field order updated`, async () => {
- const { error: fieldsOrderError } = await updateTableFieldsOrder({
- id: table.id,
- field_order: table.fields?.map(getRawTableFieldId) ?? [],
- });
-
- if (table.field_order !== "custom") {
- const { error: tableError } = await updateTable({
- id: table.id,
- field_order: table.field_order,
- });
- sendUndoToast(fieldsOrderError ?? tableError);
- } else {
- sendUndoToast(fieldsOrderError);
- }
- });
- }
- };
-
const handlePublishToggle = () => {
if (!hasLibrary) {
setModalType("library");
diff --git a/frontend/src/metabase/metadata/components/TableSection/TableSection.tsx b/frontend/src/metabase/metadata/components/TableSection/TableSection.tsx
index ec01fb069b5..22fa31c59a9 100644
--- a/frontend/src/metabase/metadata/components/TableSection/TableSection.tsx
+++ b/frontend/src/metabase/metadata/components/TableSection/TableSection.tsx
@@ -1,14 +1,9 @@
import { memo, useState } from "react";
import { t } from "ttag";
-import {
- useUpdateTableFieldsOrderMutation,
- useUpdateTableMutation,
-} from "metabase/api";
import { EmptyState } from "metabase/common/components/EmptyState";
import { Link } from "metabase/common/components/Link";
-import { useMetadataToasts } from "metabase/common/hooks";
-import { getRawTableFieldId } from "metabase/metadata/utils/field";
+import { useTableUpdateHandlers } from "metabase/metadata/hooks";
import {
ActionIcon,
Group,
@@ -20,7 +15,7 @@ import {
Tooltip,
} from "metabase/ui";
import * as Urls from "metabase/urls";
-import type { FieldId, Table, TableFieldOrder } from "metabase-types/api";
+import type { FieldId, Table } from "metabase-types/api";
import { FieldOrderPicker } from "../FieldOrderPicker";
import { NameDescriptionInput } from "../NameDescriptionInput";
@@ -47,12 +42,13 @@ const TableSectionBase = ({
onSyncOptionsClick,
...props
}: TableSectionBaseProps) => {
- const [updateTable] = useUpdateTableMutation();
- const [updateTableSorting, { isLoading: isUpdatingSorting }] =
- useUpdateTableMutation();
- const [updateTableFieldsOrder] = useUpdateTableFieldsOrderMutation();
- const { sendErrorToast, sendSuccessToast, sendUndoToast } =
- useMetadataToasts();
+ const {
+ handleNameChange,
+ handleDescriptionChange,
+ handleFieldOrderTypeChange,
+ handleCustomFieldOrderChange,
+ isUpdatingSorting,
+ } = useTableUpdateHandlers({ table });
const [isSorting, setIsSorting] = useState(false);
const hasFields = Boolean(table.fields && table.fields.length > 0);
const {
@@ -67,88 +63,6 @@ const TableSectionBase = ({
isUpdatingSorting,
});
- const handleNameChange = async (name: string) => {
- const { error } = await updateTable({
- id: table.id,
- display_name: name,
- });
-
- if (error) {
- sendErrorToast(t`Failed to update table name`);
- } else {
- sendSuccessToast(t`Table name updated`, async () => {
- const { error } = await updateTable({
- id: table.id,
- display_name: table.display_name,
- });
- sendUndoToast(error);
- });
- }
- };
-
- const handleDescriptionChange = async (description: string) => {
- const { error } = await updateTable({ id: table.id, description });
-
- if (error) {
- sendErrorToast(t`Failed to update table description`);
- } else {
- sendSuccessToast(t`Table description updated`, async () => {
- const { error } = await updateTable({
- id: table.id,
- description: table.description ?? "",
- });
- sendUndoToast(error);
- });
- }
- };
-
- const handleFieldOrderTypeChange = async (fieldOrder: TableFieldOrder) => {
- const { error } = await updateTableSorting({
- id: table.id,
- field_order: fieldOrder,
- });
-
- if (error) {
- sendErrorToast(t`Failed to update field order`);
- } else {
- sendSuccessToast(t`Field order updated`, async () => {
- const { error } = await updateTable({
- id: table.id,
- field_order: table.field_order,
- });
- sendUndoToast(error);
- });
- }
- };
-
- const handleCustomFieldOrderChange = async (fieldOrder: FieldId[]) => {
- const { error } = await updateTableFieldsOrder({
- id: table.id,
- field_order: fieldOrder,
- });
-
- if (error) {
- sendErrorToast(t`Failed to update field order`);
- } else {
- sendSuccessToast(t`Field order updated`, async () => {
- const { error: fieldsOrderError } = await updateTableFieldsOrder({
- id: table.id,
- field_order: table.fields?.map(getRawTableFieldId) ?? [],
- });
-
- if (table.field_order !== "custom") {
- const { error: tableError } = await updateTable({
- id: table.id,
- field_order: table.field_order,
- });
- sendUndoToast(fieldsOrderError ?? tableError);
- } else {
- sendUndoToast(fieldsOrderError);
- }
- });
- }
- };
-
return (
<Stack data-testid="table-section" gap={0} pb="xl" px="xl" {...props}>
<Stack
diff --git a/frontend/src/metabase/metadata/hooks/index.ts b/frontend/src/metabase/metadata/hooks/index.ts
new file mode 100644
index 00000000000..6315a764e81
--- /dev/null
+++ b/frontend/src/metabase/metadata/hooks/index.ts
@@ -0,0 +1 @@
+export * from "./use-table-update-handlers";
diff --git a/frontend/src/metabase/metadata/hooks/use-table-update-handlers.ts b/frontend/src/metabase/metadata/hooks/use-table-update-handlers.ts
new file mode 100644
index 00000000000..b372e34e587
--- /dev/null
+++ b/frontend/src/metabase/metadata/hooks/use-table-update-handlers.ts
@@ -0,0 +1,119 @@
+import { t } from "ttag";
+
+import {
+ useUpdateTableFieldsOrderMutation,
+ useUpdateTableMutation,
+} from "metabase/api";
+import { useMetadataToasts } from "metabase/common/hooks";
+import { getRawTableFieldId } from "metabase/metadata/utils/field";
+import type { FieldId, Table, TableFieldOrder } from "metabase-types/api";
+
+type UseTableUpdateHandlersOpts = {
+ table: Table;
+ onNameUpdated?: () => void;
+};
+
+export function useTableUpdateHandlers({
+ table,
+ onNameUpdated,
+}: UseTableUpdateHandlersOpts) {
+ const [updateTable] = useUpdateTableMutation();
+ const [updateTableSorting, { isLoading: isUpdatingSorting }] =
+ useUpdateTableMutation();
+ const [updateTableFieldsOrder] = useUpdateTableFieldsOrderMutation();
+ const { sendErrorToast, sendSuccessToast, sendUndoToast } =
+ useMetadataToasts();
+
+ const handleNameChange = async (name: string) => {
+ const { error } = await updateTable({
+ id: table.id,
+ display_name: name,
+ });
+
+ if (error) {
+ sendErrorToast(t`Failed to update table name`);
+ } else {
+ onNameUpdated?.();
+ sendSuccessToast(t`Table name updated`, async () => {
+ const { error } = await updateTable({
+ id: table.id,
+ display_name: table.display_name,
+ });
+ sendUndoToast(error);
+ });
+ }
+ };
+
+ const handleDescriptionChange = async (description: string) => {
+ const { error } = await updateTable({ id: table.id, description });
+
+ if (error) {
+ sendErrorToast(t`Failed to update table description`);
+ } else {
+ sendSuccessToast(t`Table description updated`, async () => {
+ const { error } = await updateTable({
+ id: table.id,
+ description: table.description ?? "",
+ });
+ sendUndoToast(error);
+ });
+ }
+ };
+
+ const handleFieldOrderTypeChange = async (fieldOrder: TableFieldOrder) => {
+ const { error } = await updateTableSorting({
+ id: table.id,
+ field_order: fieldOrder,
+ });
+
+ if (error) {
+ sendErrorToast(t`Failed to update field order`);
+ } else {
+ sendSuccessToast(t`Field order updated`, async () => {
+ const { error } = await updateTable({
+ id: table.id,
+ field_order: table.field_order,
+ });
+ sendUndoToast(error);
+ });
+ }
+ };
+
+ const handleCustomFieldOrderChange = async (fieldOrder: FieldId[]) => {
+ const { error } = await updateTableFieldsOrder({
+ id: table.id,
+ field_order: fieldOrder,
+ });
+
+ if (error) {
+ sendErrorToast(t`Failed to update field order`);
+ } else {
+ sendSuccessToast(t`Field order updated`, async () => {
+ // A single request per undo: restoring a non-custom order through
+ // PUT /api/table recomputes every field position server-side, and
+ // restoring a custom order only needs the positions themselves.
+ if (table.field_order === "custom") {
+ const { error: undoError } = await updateTableFieldsOrder({
+ id: table.id,
+ field_order: table.fields?.map(getRawTableFieldId) ?? [],
+ });
+ sendUndoToast(undoError);
+ } else {
+ const { error: undoError } = await updateTable({
+ id: table.id,
+ field_order: table.field_order,
+ });
+ sendUndoToast(undoError);
+ }
+ });
+ }
+ };
+
+ return {
+ handleNameChange,
+ handleDescriptionChange,
+ handleFieldOrderTypeChange,
+ handleCustomFieldOrderChange,
+ isUpdatingSorting,
+ };
+}
diff --git a/frontend/src/metabase/store.ts b/frontend/src/metabase/store.ts
index 61de6510ad4..c523fbed8db 100644
--- a/frontend/src/metabase/store.ts
+++ b/frontend/src/metabase/store.ts
@@ -6,7 +6,7 @@ import {
configureStore,
} from "@reduxjs/toolkit";
-import { Api } from "metabase/api";
+import { Api, retryDroppedRefetches } from "metabase/api";
import { metadataHydrationMiddleware } from "metabase/metadata-store";
import { PLUGIN_REDUX_MIDDLEWARES } from "metabase/plugins";
import type { State } from "metabase/redux/store";
@@ -28,6 +28,7 @@ export function getStore(
const middlewares: Middleware[] = [
Api.middleware,
+ retryDroppedRefetches,
metadataHydrationMiddleware,
...PLUGIN_REDUX_MIDDLEWARES,
...extraMiddlewares,