The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:
TypeScript analyticsbibusiness-intelligencebusinessintelligenceclojuredashboarddatadata-analysisdata-visualizationdatabasemetabasemysqlpostgrespostgresqlreportingslacksql-editorvisualization
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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsnew file mode 100644index 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.tsxindex 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.tsxindex 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}><Stackdiff --git a/frontend/src/metabase/metadata/hooks/index.ts b/frontend/src/metabase/metadata/hooks/index.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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,