Skip to content

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

Prevent showing stale exploration summary documents (#82442)

Kevin Kelleheraf8ca49a2575
diff --git a/frontend/src/metabase/documents/hooks/use-document-editor.ts b/frontend/src/metabase/documents/hooks/use-document-editor.ts
index f873c2eadda..6af13663240 100644
--- a/frontend/src/metabase/documents/hooks/use-document-editor.ts
+++ b/frontend/src/metabase/documents/hooks/use-document-editor.ts
@@ -116,22 +116,39 @@ export function useDocumentEditor({
const [createDocument, { isLoading: isCreating }] =
useCreateDocumentMutation();
- const [updateDocument, { isLoading: isUpdating }] =
- useUpdateDocumentMutation();
+ const [updateDocument, { isLoading: isUpdating }] = useUpdateDocumentMutation(
+ {
+ fixedCacheKey: documentId ? `document:${documentId}` : undefined,
+ },
+ );
const isNewDocument = documentId === "new";
const isSaving = isCreating || isUpdating;
+ const hasLoadedDocumentRef = useRef(false);
+
+ // if the document is updating on mount (due to a previous update with the same fixedCacheKey),
+ // then skip getDocument so we don't show the stale document
+ // this is a little unusual - the standard pattern here would to be use an optimistic update on save
+ // but a document with draft card IDs can't be rendered if Redux state has been cleared, so we need a different approach
+ const isUpdatingOnMount = isUpdating && !hasLoadedDocumentRef.current;
+
let {
data: documentData,
- isLoading: isDocumentLoading,
+ isLoading,
error,
} = useGetDocumentQuery(
- documentId && !isNewDocument ? { id: documentId } : skipToken,
+ documentId && !isNewDocument && !isUpdatingOnMount
+ ? { id: documentId }
+ : skipToken,
);
if (documentId !== documentData?.id) {
documentData = undefined;
}
+ if (documentData) {
+ hasLoadedDocumentRef.current = true;
+ }
+ const isDocumentLoading = isLoading || isUpdatingOnMount;
const canWrite = Boolean(
!documentData?.archived && (isNewDocument || documentData?.can_write),
diff --git a/frontend/src/metabase/documents/hooks/use-document-editor.unit.spec.ts b/frontend/src/metabase/documents/hooks/use-document-editor.unit.spec.ts
new file mode 100644
index 00000000000..a186e9e6990
--- /dev/null
+++ b/frontend/src/metabase/documents/hooks/use-document-editor.unit.spec.ts
@@ -0,0 +1,145 @@
+import { renderHook } from "@testing-library/react";
+import fetchMock from "fetch-mock";
+
+import { act, getTestStoreAndWrapper, waitFor } from "__support__/ui";
+import { documentApi } from "metabase/api/document";
+import type { Document } from "metabase-types/api";
+import {
+ createMockDocument,
+ createMockDocumentContent,
+} from "metabase-types/api/mocks";
+
+import { useDocumentEditor } from "./use-document-editor";
+
+const DOCUMENT_ID = 1;
+const UPDATE_CACHE_KEY = `document:${DOCUMENT_ID}`;
+
+function deferred<T>() {
+ let resolve!: (value: T) => void;
+ const promise = new Promise<T>((res) => {
+ resolve = res;
+ });
+ return { promise, resolve };
+}
+
+function setupEndpoints(doc: Document) {
+ const put = deferred<Document>();
+ let current = doc;
+ fetchMock.get(`path:/api/document/${doc.id}`, () => current);
+ fetchMock.put(`path:/api/document/${doc.id}`, async () => {
+ const saved = await put.promise;
+ current = saved;
+ return saved;
+ });
+ return put;
+}
+
+function renderEditorHook() {
+ const { wrapper, store } = getTestStoreAndWrapper({
+ initialRoute: "/",
+ withRouter: true,
+ withKBar: false,
+ withDND: false,
+ });
+
+ const { result, unmount } = renderHook(
+ () => useDocumentEditor({ documentId: DOCUMENT_ID }),
+ { wrapper },
+ );
+
+ return { result, unmount, store, wrapper };
+}
+
+async function waitForDocument(result: {
+ current: { documentData: Document | undefined };
+}) {
+ await waitFor(() => {
+ expect(result.current.documentData?.id).toBe(DOCUMENT_ID);
+ });
+}
+
+function startUpdate(store: ReturnType<typeof renderEditorHook>["store"]) {
+ act(() => {
+ store.dispatch(
+ documentApi.endpoints.updateDocument.initiate(
+ {
+ id: DOCUMENT_ID,
+ name: "Updated",
+ document: createMockDocumentContent(),
+ },
+ { fixedCacheKey: UPDATE_CACHE_KEY },
+ ),
+ );
+ });
+}
+
+describe("useDocumentEditor", () => {
+ afterEach(() => {
+ fetchMock.removeRoutes().clearHistory();
+ });
+
+ it("does not serve a cached document when remounting onto an in-flight update", async () => {
+ const stale = createMockDocument({
+ id: DOCUMENT_ID,
+ name: "Stale",
+ });
+ const put = setupEndpoints(stale);
+
+ const { result, unmount, store, wrapper } = renderEditorHook();
+ await waitForDocument(result);
+ expect(result.current.isDocumentLoading).toBe(false);
+
+ startUpdate(store);
+ await waitFor(() => {
+ expect(result.current.isSaving).toBe(true);
+ });
+ expect(result.current.documentData?.name).toBe("Stale");
+ expect(result.current.isDocumentLoading).toBe(false);
+
+ const getsBeforeRemount = fetchMock.callHistory.calls(
+ `path:/api/document/${DOCUMENT_ID}`,
+ { method: "GET" },
+ ).length;
+
+ unmount();
+ const { result: remountResult } = renderHook(
+ () => useDocumentEditor({ documentId: DOCUMENT_ID }),
+ { wrapper },
+ );
+
+ expect(remountResult.current.isDocumentLoading).toBe(true);
+ expect(remountResult.current.documentData).toBeUndefined();
+ expect(
+ fetchMock.callHistory.calls(`path:/api/document/${DOCUMENT_ID}`, {
+ method: "GET",
+ }),
+ ).toHaveLength(getsBeforeRemount);
+
+ act(() => {
+ put.resolve({ ...stale, name: "Updated" });
+ });
+
+ await waitFor(() => {
+ expect(remountResult.current.isDocumentLoading).toBe(false);
+ });
+ await waitFor(() => {
+ expect(remountResult.current.documentData?.name).toBe("Updated");
+ });
+ });
+
+ it("keeps the loaded document visible while an update runs on the same mount", async () => {
+ const doc = createMockDocument({ id: DOCUMENT_ID, name: "Current" });
+ setupEndpoints(doc);
+
+ const { result, store } = renderEditorHook();
+ await waitForDocument(result);
+
+ startUpdate(store);
+ await waitFor(() => {
+ expect(result.current.isSaving).toBe(true);
+ });
+
+ expect(result.current.isDocumentLoading).toBe(false);
+ expect(result.current.documentData?.name).toBe("Current");
+ });
+});