fix: preserve locked flow saves

Author: erichare

src/frontend/src/hooks/flows/__tests__/use-save-flow.test.ts

@@ -1,3 +1,4 @@
+// biome-ignore-all lint/suspicious/noExplicitAny: store mocks intentionally accept multiple selector shapes
 import { renderHook } from "@testing-library/react";
 import useSaveFlow from "../use-save-flow";
 
@@ -129,6 +130,82 @@ describe("useSaveFlow", () => {
     expect(mockSetCurrentFlow).toHaveBeenCalled();
   });
 
+  it("does not autosave hydrated data while the persisted flow is locked", async () => {
+    const persistedFlow = {
+      ...flowsManagerState.currentFlow,
+      locked: true,
+    };
+    flowsManagerState.currentFlow = persistedFlow;
+    flowsManagerState.flows = [persistedFlow];
+    flowStoreState.currentFlow = {
+      ...persistedFlow,
+      data: {
+        ...persistedFlow.data,
+        nodes: [{ id: "old-node", data: { is_refresh: true } }],
+        viewport: { x: 10, y: 20, zoom: 0.75 },
+      },
+    };
+
+    const { result } = renderHook(() => useSaveFlow());
+
+    await expect(result.current()).resolves.toBeUndefined();
+
+    expect(mockMutate).not.toHaveBeenCalled();
+    expect(mockSetSaveLoading).not.toHaveBeenCalled();
+  });
+
+  it("unlocks a persisted flow before saving other settings changes", async () => {
+    const persistedFlow = {
+      ...flowsManagerState.currentFlow,
+      locked: true,
+    };
+    const requestedFlow = {
+      ...persistedFlow,
+      name: "Renamed after unlock",
+      locked: false,
+      data: {
+        ...persistedFlow.data,
+        nodes: [{ id: "old-node", data: { is_refresh: true } }],
+      },
+    };
+    flowsManagerState.currentFlow = persistedFlow;
+    flowsManagerState.flows = [persistedFlow];
+    flowStoreState.currentFlow = persistedFlow;
+
+    mockMutate.mockImplementation((payload, options) => {
+      options.onSuccess({
+        ...requestedFlow,
+        ...payload,
+      });
+    });
+
+    const { result } = renderHook(() => useSaveFlow());
+
+    await expect(result.current(requestedFlow)).resolves.toBeUndefined();
+
+    expect(mockMutate).toHaveBeenCalledTimes(2);
+    expect(mockMutate.mock.calls[0][0]).toEqual({
+      id: "flow-1",
+      locked: false,
+    });
+    expect(mockMutate.mock.calls[1][0]).toEqual(
+      expect.objectContaining({
+        id: "flow-1",
+        name: "Renamed after unlock",
+        locked: false,
+        data: requestedFlow.data,
+      }),
+    );
+    expect(mockSetSaveLoading).toHaveBeenCalledWith(true);
+    expect(mockSetSaveLoading).toHaveBeenCalledWith(false);
+    expect(mockSetCurrentFlow).toHaveBeenCalledWith(
+      expect.objectContaining({
+        name: "Renamed after unlock",
+        locked: false,
+      }),
+    );
+  });
+
   it("should_update_store_flow_folder_id_when_moved_via_drag_drop_from_dashboard", async () => {
     // Arrange — dashboard scenario: no flow open in the editor, the
     // global flows store is populated from `header_flows=true`, so the

src/frontend/src/hooks/flows/use-save-flow.ts

@@ -21,9 +21,21 @@ const useSaveFlow = () => {
   const saveFlow = async (flow?: FlowType): Promise<void> => {
     const currentFlow = useFlowStore.getState().currentFlow;
     const currentSavedFlow = useFlowsManagerStore.getState().currentFlow;
-    if (
-      customStringify(flow || currentFlow) !== customStringify(currentSavedFlow)
-    ) {
+    const requestedFlow = flow || currentFlow;
+    const isPersistedFlowLocked =
+      currentSavedFlow?.id === requestedFlow?.id &&
+      currentSavedFlow?.locked === true;
+    const isUnlockingPersistedFlow =
+      isPersistedFlowLocked && requestedFlow?.locked === false;
+
+    // Hydrating a flow can change client-only node metadata and the viewport.
+    // Do not let those differences trigger saves while the persisted flow is
+    // locked. Unlocking is handled separately below.
+    if (isPersistedFlowLocked && !isUnlockingPersistedFlow) {
+      return;
+    }
+
+    if (customStringify(requestedFlow) !== customStringify(currentSavedFlow)) {
       setSaveLoading(true);
 
       const flowData = currentFlow?.data;
@@ -72,17 +84,28 @@ const useSaveFlow = () => {
             endpoint_name,
             locked,
           } = flow;
-          mutate(
-            {
-              id,
-              name,
-              data: data!,
-              description,
-              folder_id,
-              endpoint_name,
-              locked,
-            },
-            {
+          const updatePayload = {
+            id,
+            name,
+            data: data!,
+            description,
+            folder_id,
+            endpoint_name,
+            locked,
+          };
+          // biome-ignore lint/suspicious/noExplicitAny: legacy
+          const handleError = (e: any) => {
+            const detail =
+              e.response?.data?.detail || e.message || "Unknown error";
+            setErrorData({
+              title: t("errors.failedToSaveFlow"),
+              list: [detail],
+            });
+            setSaveLoading(false);
+            reject(e);
+          };
+          const persistFlow = () => {
+            mutate(updatePayload, {
               onSuccess: (updatedFlow) => {
                 const flows = useFlowsManagerStore.getState().flows;
                 setSaveLoading(false);
@@ -112,19 +135,23 @@ const useSaveFlow = () => {
                   reject(new Error("Flows variable undefined"));
                 }
               },
-              // biome-ignore lint/suspicious/noExplicitAny: legacy
-              onError: (e: any) => {
-                const detail =
-                  e.response?.data?.detail || e.message || "Unknown error";
-                setErrorData({
-                  title: t("errors.failedToSaveFlow"),
-                  list: [detail],
-                });
-                setSaveLoading(false);
-                reject(e);
+              onError: handleError,
+            });
+          };
+
+          if (isUnlockingPersistedFlow) {
+            mutate(
+              { id, locked: false },
+              {
+                // Preserve any settings edits by applying them only after the
+                // backend has committed the unlock-only request.
+                onSuccess: persistFlow,
+                onError: handleError,
               },
-            },
-          );
+            );
+          } else {
+            persistFlow();
+          }
         } else {
           setErrorData({
             title: t("errors.failedToSaveFlow"),