Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

fix: only confirm clearing nonempty workflow drafts (#45028)

Joel290590c5a361
diff --git a/oxlint-suppressions.json b/oxlint-suppressions.json
index 1dac14290d6..a58720c35e9 100644
--- a/oxlint-suppressions.json
+++ b/oxlint-suppressions.json
@@ -4334,11 +4334,6 @@
"count": 1
}
},
- "web/app/components/workflow/index.tsx": {
- "better-tailwindcss/enforce-logical-properties": {
- "count": 2
- }
- },
"web/app/components/workflow/nodes/_base/components/add-variable-popup-with-position.tsx": {
"typescript/no-explicit-any": {
"count": 2
diff --git a/web/app/components/workflow-app/components/__tests__/workflow-main.spec.tsx b/web/app/components/workflow-app/components/__tests__/workflow-main.spec.tsx
index 4ea26ea29b9..f56145c51bb 100644
--- a/web/app/components/workflow-app/components/__tests__/workflow-main.spec.tsx
+++ b/web/app/components/workflow-app/components/__tests__/workflow-main.spec.tsx
@@ -390,7 +390,7 @@ it('saves the trusted graph on a directed request and acknowledges the persisted
})
it('replaces the canvas from a workflow update and records its revision', async () => {
- const { store } = await renderMain()
+ const { store } = await renderMain({ initialStoreState: { syncWorkflowDraftIsEmpty: true } })
api.fetchDraft.mockResolvedValue(
draft({
hash: 'remote-hash',
@@ -409,6 +409,23 @@ it('replaces the canvas from a workflow update and records its revision', async
// happy-dom does not measure ReactFlow nodes; verify content in the real renderer.
expect(await screen.findByText('Remote entry')).toBeInTheDocument()
expect(store.getState().syncWorkflowDraftHash).toBe('remote-hash')
+ expect(store.getState().syncWorkflowDraftIsEmpty).toBe(false)
+})
+
+it('records an empty committed graph received from another collaborator', async () => {
+ const { store } = await renderMain({ initialStoreState: { syncWorkflowDraftIsEmpty: false } })
+ api.fetchDraft.mockResolvedValue(
+ draft({ hash: 'empty-remote-hash', graph: { nodes: [], edges: [] } }),
+ )
+
+ await act(async () => {
+ await updateWorkflow()
+ })
+
+ expect(store.getState()).toMatchObject({
+ syncWorkflowDraftHash: 'empty-remote-hash',
+ syncWorkflowDraftIsEmpty: true,
+ })
})
it('saves newly applied features when a follower requests synchronization', async () => {
@@ -841,7 +858,7 @@ it('imports a DSL file and replaces the graph through the real update event', as
)
const { store } = await renderMain({
collaboration: false,
- initialStoreState: { showImportDSLModal: true },
+ initialStoreState: { showImportDSLModal: true, syncWorkflowDraftIsEmpty: true },
})
const dialog = await screen.findByRole('dialog', { name: 'app.importApp' })
// The native file picker is hidden behind the uploader's Browse action.
@@ -854,6 +871,7 @@ it('imports a DSL file and replaces the graph through the real update event', as
expect(await screen.findByText('Imported entry')).toBeInTheDocument()
await waitFor(() => expect(screen.queryByRole('dialog')).not.toBeInTheDocument())
expect(store.getState().syncWorkflowDraftHash).toBe('imported-hash')
+ expect(store.getState().syncWorkflowDraftIsEmpty).toBe(false)
expect(api.importDSL).toHaveBeenCalledExactlyOnceWith({
body: { mode: 'yaml-content', yaml_content: yaml, app_id: 'app-1' },
})
diff --git a/web/app/components/workflow-app/components/workflow-main.tsx b/web/app/components/workflow-app/components/workflow-main.tsx
index 72c479e7fe7..b9578fd05fe 100644
--- a/web/app/components/workflow-app/components/workflow-main.tsx
+++ b/web/app/components/workflow-app/components/workflow-main.tsx
@@ -321,7 +321,8 @@ const WorkflowMain = ({ nodes, edges, viewport }: WorkflowMainProps) => {
try {
const response = await fetchWorkflowDraft(`/apps/${appId}/workflows/draft`)
- if (response.hash) workflowStore.getState().setSyncWorkflowDraftHash(response.hash)
+ if (response.hash)
+ workflowStore.getState().setSyncWorkflowDraftHash(response.hash, response.graph)
// Handle features, variables etc.
handleWorkflowDataUpdate(response)
diff --git a/web/app/components/workflow-app/hooks/__tests__/use-nodes-sync-draft.spec.ts b/web/app/components/workflow-app/hooks/__tests__/use-nodes-sync-draft.spec.ts
index ba303aa51df..463fd0dece5 100644
--- a/web/app/components/workflow-app/hooks/__tests__/use-nodes-sync-draft.spec.ts
+++ b/web/app/components/workflow-app/hooks/__tests__/use-nodes-sync-draft.spec.ts
@@ -1,4 +1,4 @@
-import type { AppMode } from '@dify/contracts/api/console/apps/types.gen'
+import type { AppMode, WorkflowResponse } from '@dify/contracts/api/console/apps/types.gen'
import type { Features } from '@/app/components/base/features/types'
import type { Shape } from '@/app/components/workflow/store/workflow'
import type { Edge, Node } from '@/app/components/workflow/types'
@@ -15,7 +15,9 @@ import { BlockEnum } from '@/app/components/workflow/types'
import { markAppDeletionFailed, markAppDeletionStarted } from '@/service/app-deletion'
import { createHttpError } from '@/service/http-error'
import { createConsoleQueryWrapper, seedAppDetail } from '@/test/console/query-data'
+import { createDeferred } from '@/test/deferred'
import { createAppDetailFixture } from '@/test/fixtures/app'
+import { createWorkflowResponseFixture } from '@/test/fixtures/workflow-response'
import { useNodesSyncDraft } from '../use-nodes-sync-draft'
const mockPostWithKeepalive = vi.fn()
@@ -41,6 +43,7 @@ vi.mock('@/app/components/workflow/collaboration/core/collaboration-manager', ()
}))
const mockSyncWorkflowDraft = vi.fn()
+const mockFetchWorkflowDraft = vi.fn()
// Stand in for the draft sync request at the client boundary. Calls are recorded as the
// request they send (endpoint and body), and rejections pass through the console link's
// contract error validation, as they do in production.
@@ -49,6 +52,13 @@ vi.mock('@/service/console', async (importOriginal) => {
const { apps } = await import('@dify/contracts/api/console/apps/orpc.gen')
const { validateDefinedErrors } = await import('@/service/console/defined-errors')
const validate = validateDefinedErrors({ apps })
+ const get = (input: { params: { app_id: string } }) =>
+ validate({
+ context: {},
+ input,
+ path: ['apps', 'byAppId', 'workflows', 'draft', 'get'],
+ next: () => mockFetchWorkflowDraft(input),
+ })
const post = (input: { params: { app_id: string }; body: unknown }) =>
validate({
context: {},
@@ -60,7 +70,10 @@ vi.mock('@/service/console', async (importOriginal) => {
params: input.body,
}),
})
- return { ...actual, consoleClient: { apps: { byAppId: { workflows: { draft: { post } } } } } }
+ return {
+ ...actual,
+ consoleClient: { apps: { byAppId: { workflows: { draft: { get, post } } } } },
+ }
})
vi.mock('@/service/fetch', async (importOriginal) => {
@@ -142,15 +155,15 @@ const renderSyncDraft = <R>(
const renderUseNodesSyncDraft = (canvas?: SyncDraftCanvas) =>
renderSyncDraft(() => useNodesSyncDraft(), canvas)
-const startEmptySave = (
+const startEmptySave = async (
result: { current: ReturnType<typeof useNodesSyncDraft> },
...args: Parameters<ReturnType<typeof useNodesSyncDraft>['doSyncWorkflowDraft']>
) => {
let syncPromise!: ReturnType<ReturnType<typeof useNodesSyncDraft>['doSyncWorkflowDraft']>
- act(() => {
+ await act(async () => {
syncPromise = result.current.doSyncWorkflowDraft(...args)
})
- return syncPromise
+ return { syncPromise }
}
const draftNotSyncError = () =>
@@ -184,6 +197,9 @@ describe('useNodesSyncDraft', () => {
beforeEach(() => {
vi.resetAllMocks()
mockSyncWorkflowDraft.mockResolvedValue({ hash: 'new', updated_at: 1 })
+ mockFetchWorkflowDraft.mockResolvedValue(
+ createWorkflowResponseFixture({ hash: 'hash-123', graph: { nodes: [startNode], edges: [] } }),
+ )
useCollaborationSession({ connected: false, leader: true })
mockCollaborationRequestWorkflowSync.mockResolvedValue({ hash: 'remote-hash', updatedAt: 2 })
})
@@ -494,10 +510,47 @@ describe('useNodesSyncDraft', () => {
})
describe('empty graph confirmation', () => {
+ it.each([
+ { scenario: 'no nodes', nodes: [] },
+ {
+ scenario: 'only the local start placeholder',
+ nodes: [
+ createNode({ id: 'start-placeholder', data: { type: BlockEnum.StartPlaceholder } }),
+ ],
+ },
+ ])('saves an already empty draft with $scenario without confirmation', async ({ nodes }) => {
+ const callbacks = { onSuccess: vi.fn(), onSettled: vi.fn() }
+ const { result, store } = renderUseNodesSyncDraft({
+ nodes,
+ initialStoreState: { syncWorkflowDraftIsEmpty: true },
+ })
+ const { syncPromise } = await startEmptySave(result, false, callbacks)
+
+ expect(store.getState().showConfirm).toBeUndefined()
+
+ await act(async () => {
+ await expect(syncPromise).resolves.toEqual({ hash: 'new', updatedAt: 1 })
+ })
+
+ expect(mockSyncWorkflowDraft).toHaveBeenCalledExactlyOnceWith(
+ expect.objectContaining({
+ params: expect.objectContaining({
+ graph: expect.objectContaining({ nodes: [], edges: [] }),
+ force: true,
+ }),
+ }),
+ )
+ expect(callbacks.onSuccess).toHaveBeenCalledOnce()
+ expect(callbacks.onSettled).toHaveBeenCalledOnce()
+ })
+
it('waits for confirmation before force-saving an empty graph', async () => {
const callbacks = { onSuccess: vi.fn(), onError: vi.fn(), onSettled: vi.fn() }
- const { result, store } = renderUseNodesSyncDraft({ nodes: [] })
- const syncPromise = startEmptySave(result, false, callbacks)
+ const { result, store } = renderUseNodesSyncDraft({
+ nodes: [],
+ initialStoreState: { syncWorkflowDraftIsEmpty: false },
+ })
+ const { syncPromise } = await startEmptySave(result, false, callbacks)
expect(store.getState().showConfirm).toEqual(
expect.objectContaining({
@@ -527,10 +580,127 @@ describe('useNodesSyncDraft', () => {
expect(callbacks.onSettled).toHaveBeenCalledOnce()
})
+ it('does not confirm again when another hook saves the successfully cleared draft', async () => {
+ const { result, store } = renderSyncDraft(
+ () => [useNodesSyncDraft(), useNodesSyncDraft()] as const,
+ { nodes: [], initialStoreState: { syncWorkflowDraftIsEmpty: false } },
+ )
+ const [first, second] = result.current
+ const { syncPromise: firstSave } = await startEmptySave({ current: first })
+
+ expect(store.getState().showConfirm).toBeDefined()
+
+ await act(async () => {
+ store.getState().showConfirm?.onConfirm()
+ await firstSave
+ })
+
+ const { syncPromise: secondSave } = await startEmptySave({ current: second })
+
+ expect(store.getState().showConfirm).toBeUndefined()
+
+ await act(async () => {
+ await expect(secondSave).resolves.toEqual({ hash: 'new', updatedAt: 1 })
+ })
+
+ expect(mockSyncWorkflowDraft).toHaveBeenCalledTimes(2)
+ })
+
+ it('requires confirmation again when clearing the draft failed to save', async () => {
+ mockSyncWorkflowDraft.mockRejectedValueOnce(
+ createHttpError(new Response(null, { status: 500 })),
+ )
+ const { result, store } = renderUseNodesSyncDraft({
+ nodes: [],
+ initialStoreState: { syncWorkflowDraftIsEmpty: false },
+ })
+ const { syncPromise: firstSave } = await startEmptySave(result)
+
+ await act(async () => {
+ store.getState().showConfirm?.onConfirm()
+ await expect(firstSave).resolves.toBeNull()
+ })
+
+ const { syncPromise: retry } = await startEmptySave(result)
+
+ expect(store.getState().showConfirm).toBeDefined()
+ expect(mockSyncWorkflowDraft).toHaveBeenCalledOnce()
+
+ await act(async () => {
+ store.getState().showConfirm?.onCancel?.()
+ await expect(retry).resolves.toBeNull()
+ })
+ })
+
+ it('confirms clearing a previously empty draft after another hook saved nodes', async () => {
+ const { result, store, setCanvas } = renderSyncDraft(
+ () => [useNodesSyncDraft(), useNodesSyncDraft()] as const,
+ { initialStoreState: { syncWorkflowDraftIsEmpty: true } },
+ )
+ const [first, second] = result.current
+
+ await act(async () => {
+ await first.doSyncWorkflowDraft()
+ })
+ setCanvas({ nodes: [] })
+
+ const { syncPromise } = await startEmptySave({ current: second })
+
+ expect(store.getState().showConfirm).toBeDefined()
+ expect(mockSyncWorkflowDraft).toHaveBeenCalledOnce()
+
+ await act(async () => {
+ store.getState().showConfirm?.onConfirm()
+ await syncPromise
+ })
+
+ expect(mockSyncWorkflowDraft).toHaveBeenCalledTimes(2)
+ })
+
+ it('confirms a queued clear when an earlier save populates an initially empty draft', async () => {
+ let finishEarlierSave!: (response: { hash: string; updated_at: number }) => void
+ mockSyncWorkflowDraft.mockImplementationOnce(
+ () =>
+ new Promise((resolve) => {
+ finishEarlierSave = resolve
+ }),
+ )
+ const { result, store, setCanvas } = renderUseNodesSyncDraft({
+ initialStoreState: { syncWorkflowDraftIsEmpty: true },
+ })
+ const { syncPromise: earlierSave } = await startEmptySave(result)
+ setCanvas({ nodes: [] })
+ const { syncPromise: emptySave } = await startEmptySave(result)
+
+ expect(store.getState().showConfirm).toBeUndefined()
+
+ await act(async () => {
+ await expect(result.current.doSyncWorkflowDraft()).resolves.toBeNull()
+ })
+
+ await act(async () => {
+ finishEarlierSave({ hash: 'populated-draft', updated_at: 1 })
+ await earlierSave
+ })
+
+ expect(store.getState().showConfirm).toBeDefined()
+ expect(mockSyncWorkflowDraft).toHaveBeenCalledOnce()
+
+ await act(async () => {
+ store.getState().showConfirm?.onConfirm()
+ await emptySave
+ })
+
+ expect(mockSyncWorkflowDraft).toHaveBeenCalledTimes(2)
+ })
+
it('settles a canceled empty save without posting or reporting an error', async () => {
const callbacks = { onSuccess: vi.fn(), onError: vi.fn(), onSettled: vi.fn() }
- const { result, store } = renderUseNodesSyncDraft({ nodes: [] })
- const syncPromise = startEmptySave(result, false, callbacks)
+ const { result, store } = renderUseNodesSyncDraft({
+ nodes: [],
+ initialStoreState: { syncWorkflowDraftIsEmpty: false },
+ })
+ const { syncPromise } = await startEmptySave(result, false, callbacks)
await act(async () => {
store.getState().showConfirm?.onCancel?.()
@@ -546,6 +716,7 @@ describe('useNodesSyncDraft', () => {
it('treats a graph with only placeholders and temporary entities as empty', async () => {
const { result, store } = renderUseNodesSyncDraft({
+ initialStoreState: { syncWorkflowDraftIsEmpty: false },
nodes: [
createNode({ id: 'start-placeholder', data: { type: BlockEnum.StartPlaceholder } }),
createNode({
@@ -563,7 +734,7 @@ describe('useNodesSyncDraft', () => {
}),
],
})
- const syncPromise = startEmptySave(result)
+ const { syncPromise } = await startEmptySave(result)
expect(store.getState().showConfirm).toBeDefined()
expect(mockSyncWorkflowDraft).not.toHaveBeenCalled()
@@ -584,7 +755,10 @@ describe('useNodesSyncDraft', () => {
})
it('skips an empty page-close save without opening confirmation', () => {
- const { result, store } = renderUseNodesSyncDraft({ nodes: [] })
+ const { result, store } = renderUseNodesSyncDraft({
+ nodes: [],
+ initialStoreState: { syncWorkflowDraftIsEmpty: false },
+ })
act(() => {
result.current.syncWorkflowDraftWhenPageClose()
@@ -594,16 +768,37 @@ describe('useNodesSyncDraft', () => {
expect(store.getState().showConfirm).toBeUndefined()
})
+ it('skips repeated saves from the same hook while confirmation is open', async () => {
+ const { result, store } = renderUseNodesSyncDraft({
+ nodes: [],
+ initialStoreState: { syncWorkflowDraftIsEmpty: false },
+ })
+ const callbacks = { onSettled: vi.fn() }
+ const { syncPromise: firstSave } = await startEmptySave(result)
+ const { syncPromise: repeatedSave } = await startEmptySave(result, false, callbacks)
+
+ expect(callbacks.onSettled).toHaveBeenCalledOnce()
+
+ await act(async () => {
+ store.getState().showConfirm?.onCancel?.()
+ await expect(firstSave).resolves.toBeNull()
+ await expect(repeatedSave).resolves.toBeNull()
+ })
+
+ expect(store.getState().showConfirm).toBeUndefined()
+ expect(mockSyncWorkflowDraft).not.toHaveBeenCalled()
+ })
+
it('keeps one confirmation when another hook instance tries to save the empty graph', async () => {
const { result, store } = renderSyncDraft(
() => [useNodesSyncDraft(), useNodesSyncDraft()] as const,
- { nodes: [] },
+ { nodes: [], initialStoreState: { syncWorkflowDraftIsEmpty: false } },
)
const [first, second] = result.current
const secondCallbacks = { onError: vi.fn(), onSettled: vi.fn() }
let firstSave!: ReturnType<typeof first.doSyncWorkflowDraft>
- act(() => {
+ await act(async () => {
firstSave = first.doSyncWorkflowDraft()
})
const confirmation = store.getState().showConfirm
@@ -626,8 +821,11 @@ describe('useNodesSyncDraft', () => {
it('does not save the old empty graph when a node is added before confirmation', async () => {
const callbacks = { onError: vi.fn(), onSettled: vi.fn() }
- const { result, setCanvas, store } = renderUseNodesSyncDraft({ nodes: [] })
- const syncPromise = startEmptySave(result, false, callbacks)
+ const { result, setCanvas, store } = renderUseNodesSyncDraft({
+ nodes: [],
+ initialStoreState: { syncWorkflowDraftIsEmpty: false },
+ })
+ const { syncPromise } = await startEmptySave(result, false, callbacks)
setCanvas({ nodes: [createNode({ id: 'new-node', data: { type: BlockEnum.Start } })] })
@@ -641,30 +839,21 @@ describe('useNodesSyncDraft', () => {
expect(callbacks.onSettled).toHaveBeenCalledOnce()
})
- it('rechecks a confirmed empty graph after an earlier save finishes', async () => {
+ it('rechecks the canvas before saving a queued empty graph', async () => {
let finishEarlierSave!: (response: { hash: string; updated_at: number }) => void
- let notifySaveStarted!: () => void
- const saveStarted = new Promise<void>((resolve) => {
- notifySaveStarted = resolve
- })
mockSyncWorkflowDraft.mockImplementationOnce(
() =>
new Promise((resolve) => {
finishEarlierSave = resolve
- notifySaveStarted()
}),
)
const callbacks = { onError: vi.fn(), onSettled: vi.fn() }
- const { result, setCanvas, store } = renderUseNodesSyncDraft()
- const earlierSave = startEmptySave(result)
- await saveStarted
- setCanvas({ nodes: [] })
- const emptySave = startEmptySave(result, false, callbacks)
-
- await act(async () => {
- store.getState().showConfirm?.onConfirm()
+ const { result, setCanvas, store } = renderUseNodesSyncDraft({
+ initialStoreState: { syncWorkflowDraftIsEmpty: false },
})
-
+ const { syncPromise: earlierSave } = await startEmptySave(result)
+ setCanvas({ nodes: [] })
+ const { syncPromise: emptySave } = await startEmptySave(result, false, callbacks)
setCanvas({ nodes: [createNode({ id: 'restored-node', data: { type: BlockEnum.Start } })] })
await act(async () => {
@@ -673,6 +862,7 @@ describe('useNodesSyncDraft', () => {
await expect(emptySave).resolves.toBeNull()
})
+ expect(store.getState().showConfirm).toBeUndefined()
expect(mockSyncWorkflowDraft).toHaveBeenCalledOnce()
expect(callbacks.onError).not.toHaveBeenCalled()
expect(callbacks.onSettled).toHaveBeenCalledOnce()
@@ -680,8 +870,11 @@ describe('useNodesSyncDraft', () => {
it('cancels a pending empty save when its owning hook unmounts', async () => {
const callbacks = { onError: vi.fn(), onSettled: vi.fn() }
- const { result, store, unmount } = renderUseNodesSyncDraft({ nodes: [] })
- const syncPromise = startEmptySave(result, false, callbacks)
+ const { result, store, unmount } = renderUseNodesSyncDraft({
+ nodes: [],
+ initialStoreState: { syncWorkflowDraftIsEmpty: false },
+ })
+ const { syncPromise } = await startEmptySave(result, false, callbacks)
expect(store.getState().showConfirm).toBeDefined()
unmount()
@@ -698,8 +891,9 @@ describe('useNodesSyncDraft', () => {
const { result, store } = renderUseNodesSyncDraft({
nodes: [],
isCollaborationEnabled: true,
+ initialStoreState: { syncWorkflowDraftIsEmpty: false },
})
- const syncPromise = startEmptySave(result)
+ const { syncPromise } = await startEmptySave(result)
expect(store.getState().showConfirm).toBeDefined()
expect(mockSyncWorkflowDraft).not.toHaveBeenCalled()
@@ -821,7 +1015,7 @@ describe('useNodesSyncDraft', () => {
)
const callbacks = { onError: vi.fn(), onSettled: vi.fn() }
const { result } = renderUseNodesSyncDraft()
- const syncPromise = startEmptySave(result, false, callbacks)
+ const { syncPromise } = await startEmptySave(result, false, callbacks)
await started
markAppDeletionStarted('app-1')
@@ -908,6 +1102,170 @@ describe('useNodesSyncDraft', () => {
})
describe('collaboration', () => {
+ it('saves without confirmation after another collaborator has already cleared the draft', async () => {
+ useCollaborationSession({ connected: true, leader: false })
+ const { result, store, setCanvas } = renderUseNodesSyncDraft({
+ isCollaborationEnabled: true,
+ initialStoreState: { syncWorkflowDraftIsEmpty: false },
+ })
+ // The peer's committed clear arrives through CRDT without updating this client's save metadata.
+ mockFetchWorkflowDraft.mockResolvedValue(
+ createWorkflowResponseFixture({ hash: 'peer-empty-hash' }),
+ )
+ setCanvas({ nodes: [] })
+ const { syncPromise } = await startEmptySave(result)
+
+ expect(store.getState().showConfirm).toBeUndefined()
+
+ await act(async () => {
+ await expect(syncPromise).resolves.toEqual({ hash: 'new', updatedAt: 1 })
+ })
+
+ expect(mockFetchWorkflowDraft).toHaveBeenCalledExactlyOnceWith({
+ params: { app_id: 'app-1' },
+ })
+ expect(mockSyncWorkflowDraft).toHaveBeenCalledExactlyOnceWith(
+ draftRequest(
+ expect.objectContaining({
+ hash: 'peer-empty-hash',
+ graph: expect.objectContaining({ nodes: [], edges: [] }),
+ force: true,
+ }),
+ ),
+ )
+ expect(mockCollaborationRequestWorkflowSync).not.toHaveBeenCalled()
+ })
+
+ it('confirms a newly populated server draft even when the last local save was empty', async () => {
+ useCollaborationSession({ connected: true, leader: false })
+ mockFetchWorkflowDraft.mockResolvedValue(
+ createWorkflowResponseFixture({
+ hash: 'peer-populated-hash',
+ graph: { nodes: [startNode], edges: [] },
+ }),
+ )
+ const { result, store } = renderUseNodesSyncDraft({
+ nodes: [],
+ isCollaborationEnabled: true,
+ initialStoreState: { syncWorkflowDraftIsEmpty: true },
+ })
+ const { syncPromise } = await startEmptySave(result)
+
+ expect(store.getState().showConfirm).toBeDefined()
+ expect(mockSyncWorkflowDraft).not.toHaveBeenCalled()
+
+ await act(async () => {
+ store.getState().showConfirm?.onConfirm()
+ await syncPromise
+ })
+
+ // Refreshing persisted metadata must leave the initiating client's empty canvas intact.
+ expect(mockSyncWorkflowDraft).toHaveBeenCalledExactlyOnceWith(
+ draftRequest(
+ expect.objectContaining({
+ hash: 'peer-populated-hash',
+ graph: expect.objectContaining({ nodes: [], edges: [] }),
+ force: true,
+ }),
+ ),
+ )
+ })
+
+ it('does not clear a collaborative draft when its persisted state cannot be refreshed', async () => {
+ useCollaborationSession({ connected: true, leader: false })
+ mockFetchWorkflowDraft.mockRejectedValue(new Error('Draft refresh failed'))
+ const callbacks = { onError: vi.fn(), onSettled: vi.fn() }
+ const { result, store } = renderUseNodesSyncDraft({
+ nodes: [],
+ isCollaborationEnabled: true,
+ initialStoreState: { syncWorkflowDraftIsEmpty: true },
+ })
+
+ await act(async () => {
+ await expect(result.current.doSyncWorkflowDraft(false, callbacks)).resolves.toBeNull()
+ })
+
+ expect(store.getState().showConfirm).toBeUndefined()
+ expect(mockSyncWorkflowDraft).not.toHaveBeenCalled()
+ expect(callbacks.onError).toHaveBeenCalledOnce()
+ expect(callbacks.onSettled).toHaveBeenCalledOnce()
+ })
+
+ it('keeps a newer successful save when another hook finishes an older metadata refresh', async () => {
+ useCollaborationSession({ connected: true, leader: false })
+ const olderRefresh = createDeferred<WorkflowResponse>()
+ const newerRefresh = createDeferred<WorkflowResponse>()
+ mockFetchWorkflowDraft
+ .mockReturnValueOnce(olderRefresh.promise)
+ .mockReturnValueOnce(newerRefresh.promise)
+ const { result, store } = renderSyncDraft(
+ () => [useNodesSyncDraft(), useNodesSyncDraft()] as const,
+ {
+ nodes: [],
+ isCollaborationEnabled: true,
+ initialStoreState: { syncWorkflowDraftIsEmpty: true },
+ },
+ )
+ const [first, second] = result.current
+ const { syncPromise: firstSave } = await startEmptySave({ current: first })
+ const { syncPromise: secondSave } = await startEmptySave({ current: second })
+
+ await act(async () => {
+ newerRefresh.resolve(createWorkflowResponseFixture({ hash: 'peer-empty-hash' }))
+ await secondSave
+ })
+ await act(async () => {
+ olderRefresh.resolve(
+ createWorkflowResponseFixture({
+ hash: 'hash-123',
+ graph: { nodes: [startNode], edges: [] },
+ }),
+ )
+ })
+
+ expect(store.getState().showConfirm).toBeUndefined()
+
+ await act(async () => {
+ await firstSave
+ })
+
+ expect(mockSyncWorkflowDraft).toHaveBeenLastCalledWith(
+ draftRequest(
+ expect.objectContaining({ hash: 'new', graph: expect.objectContaining({ nodes: [] }) }),
+ ),
+ )
+ })
+
+ it.each(['a node is restored', 'the hook unmounts', 'the graph becomes untrusted'] as const)(
+ 'skips a collaborative clear when %s during persisted-state refresh',
+ async (change) => {
+ useCollaborationSession({ connected: true, leader: false })
+ const refresh = createDeferred<WorkflowResponse>()
+ mockFetchWorkflowDraft.mockReturnValue(refresh.promise)
+ const callbacks = { onError: vi.fn(), onSettled: vi.fn() }
+ const { result, store, setCanvas, unmount } = renderUseNodesSyncDraft({
+ nodes: [],
+ isCollaborationEnabled: true,
+ initialStoreState: { syncWorkflowDraftIsEmpty: true },
+ })
+ const { syncPromise } = await startEmptySave(result, false, callbacks)
+
+ if (change === 'a node is restored') setCanvas({ nodes: [startNode] })
+ else if (change === 'the hook unmounts') unmount()
+ else mockCollaborationCanPersistLocalGraph.mockReturnValue(false)
+
+ await act(async () => {
+ refresh.resolve(createWorkflowResponseFixture({ hash: 'peer-empty-hash' }))
+ await expect(syncPromise).resolves.toBeNull()
+ })
+
+ expect(store.getState().showConfirm).toBeUndefined()
+ expect(mockSyncWorkflowDraft).not.toHaveBeenCalled()
+ expect(callbacks.onError).not.toHaveBeenCalled()
+ expect(callbacks.onSettled).toHaveBeenCalledOnce()
+ },
+ )
+
it('waits for the leader save result when the current user is a follower', async () => {
useCollaborationSession({ connected: true, leader: false })
const callbacks = { onSuccess: vi.fn(), onError: vi.fn(), onSettled: vi.fn() }
diff --git a/web/app/components/workflow-app/hooks/__tests__/use-workflow-init.spec.ts b/web/app/components/workflow-app/hooks/__tests__/use-workflow-init.spec.ts
index c747373a17b..eb237e5bd60 100644
--- a/web/app/components/workflow-app/hooks/__tests__/use-workflow-init.spec.ts
+++ b/web/app/components/workflow-app/hooks/__tests__/use-workflow-init.spec.ts
@@ -185,6 +185,7 @@ describe('useWorkflowInit', () => {
}),
)
expect(store.getState().syncWorkflowDraftHash).toBe('new-workflow-hash')
+ expect(store.getState().syncWorkflowDraftIsEmpty).toBe(true)
})
it('should keep creating the first backend draft for advanced chat apps', async () => {
@@ -249,6 +250,7 @@ describe('useWorkflowInit', () => {
conversationVariables: [],
isWorkflowDataLoaded: true,
syncWorkflowDraftHash: '',
+ syncWorkflowDraftIsEmpty: true,
})
expect(result.current.data?.graph.viewport).toBeUndefined()
})
@@ -270,6 +272,7 @@ describe('useWorkflowInit', () => {
expect(mockSyncWorkflowDraft).not.toHaveBeenCalled()
expect(store.getState().syncWorkflowDraftHash).toBe('empty-draft-hash')
+ expect(store.getState().syncWorkflowDraftIsEmpty).toBe(true)
})
it('should preserve existing draft nodes when restoring the local start placeholder', async () => {
@@ -283,7 +286,7 @@ describe('useWorkflowInit', () => {
},
})
- const { result } = renderHook(() => useWorkflowInit())
+ const { result, store } = renderHook(() => useWorkflowInit())
await waitFor(() => {
expect(result.current.data?.graph.nodes).toEqual([
@@ -293,6 +296,7 @@ describe('useWorkflowInit', () => {
})
expect(result.current.data?.graph.edges).toEqual([existingEdge])
+ expect(store.getState().syncWorkflowDraftIsEmpty).toBe(false)
expect(mockSyncWorkflowDraft).not.toHaveBeenCalled()
})
diff --git a/web/app/components/workflow-app/hooks/__tests__/use-workflow-refresh-draft.spec.tsx b/web/app/components/workflow-app/hooks/__tests__/use-workflow-refresh-draft.spec.tsx
index 3061e5f6645..e844900fcfe 100644
--- a/web/app/components/workflow-app/hooks/__tests__/use-workflow-refresh-draft.spec.tsx
+++ b/web/app/components/workflow-app/hooks/__tests__/use-workflow-refresh-draft.spec.tsx
@@ -132,6 +132,7 @@ function setup(mode: AppMode = 'advanced-chat') {
nodes: localNodes,
isWorkflowDataLoaded: true,
syncWorkflowDraftHash: 'local-hash',
+ syncWorkflowDraftIsEmpty: false,
},
},
)
@@ -172,6 +173,7 @@ describe('useWorkflowRefreshDraft', () => {
'refreshes draft metadata and respects notUpdateCanvas=%s',
async (notUpdateCanvas) => {
const { flow, refresh, store } = setup()
+ store.setState({ syncWorkflowDraftIsEmpty: true })
await expectGraph(flow, ['local-start', 'local-code'], ['local-edge'], localViewport)
await act(async () => {
@@ -187,6 +189,7 @@ describe('useWorkflowRefreshDraft', () => {
)
expect(store.getState()).toMatchObject({
syncWorkflowDraftHash: 'server-hash',
+ syncWorkflowDraftIsEmpty: false,
isSyncingWorkflowDraft: false,
isWorkflowDataLoaded: true,
})
@@ -214,6 +217,7 @@ describe('useWorkflowRefreshDraft', () => {
await expectGraph(flow, ['local-start', 'local-code'], ['local-edge'], localViewport)
expect(store.getState()).toMatchObject({
syncWorkflowDraftHash: 'local-hash',
+ syncWorkflowDraftIsEmpty: false,
environmentVariables: [],
conversationVariables: [],
})
@@ -320,7 +324,7 @@ describe('useWorkflowRefreshDraft', () => {
'restores the appropriate empty canvas for %s',
async (mode) => {
fetchDraft.mockResolvedValue({ ...draftResponse, graph: { nodes: [], edges: [] } })
- const { flow, refresh } = setup(mode)
+ const { flow, refresh, store } = setup(mode)
await act(async () => {
await refresh.current!.handleRefreshWorkflowDraft()
@@ -343,6 +347,7 @@ describe('useWorkflowRefreshDraft', () => {
expect(flow.current!.getEdges()).toEqual([])
expect(flow.current!.getViewport()).toEqual({ x: 0, y: 0, zoom: 1 })
})
+ expect(store.getState().syncWorkflowDraftIsEmpty).toBe(true)
},
)
@@ -368,6 +373,7 @@ describe('useWorkflowRefreshDraft', () => {
isWorkflowDataLoaded: true,
isSyncingWorkflowDraft: false,
syncWorkflowDraftHash: 'local-hash',
+ syncWorkflowDraftIsEmpty: false,
})
await expectGraph(flow, ['local-start', 'local-code'], ['local-edge'], localViewport)
})
diff --git a/web/app/components/workflow-app/hooks/use-nodes-sync-draft.ts b/web/app/components/workflow-app/hooks/use-nodes-sync-draft.ts
index 33a6139f52e..b802b15add9 100644
--- a/web/app/components/workflow-app/hooks/use-nodes-sync-draft.ts
+++ b/web/app/components/workflow-app/hooks/use-nodes-sync-draft.ts
@@ -57,6 +57,7 @@ const useNodesSyncDraftBase = (getNodesReadOnly: () => boolean) => {
select: (s) => s.enable_collaboration_mode,
})
const isMountedRef = useRef(false)
+ const emptySyncPendingRef = useRef(false)
const cancelConfirmationRef = useRef<(() => void) | undefined>(undefined)
useEffect(() => {
@@ -173,7 +174,6 @@ const useNodesSyncDraftBase = (getNodesReadOnly: () => boolean) => {
notRefreshWhenSyncError?: boolean,
callback?: SyncDraftCallback,
options?: SyncDraftOptions,
- force?: boolean,
): Promise<SyncDraftResult | null> => {
if (getNodesReadOnly()) return null
const { isWorkflowDataLoaded } = workflowStore.getState()
@@ -187,13 +187,77 @@ const useNodesSyncDraftBase = (getNodesReadOnly: () => boolean) => {
return null
}
- if (force) {
+ const emptyGraph = isEmptyGraph(baseParams.params.graph)
+ const canSaveEmptyGraph = () => {
const currentParams = getPostParams()
- if (
- !currentParams ||
- currentParams.url !== baseParams.url ||
- !isEmptyGraph(currentParams.params.graph)
- ) {
+ return (
+ isMountedRef.current &&
+ !getNodesReadOnly() &&
+ (!isCollaborationEnabled || collaborationManager.canPersistLocalGraph()) &&
+ currentParams?.url === baseParams.url &&
+ isEmptyGraph(currentParams.params.graph)
+ )
+ }
+ if (emptyGraph && !canSaveEmptyGraph()) {
+ callback?.onSettled?.()
+ return null
+ }
+
+ if (emptyGraph && isCollaborationEnabled) {
+ // CRDT updates do not carry the persisted revision from another collaborator's save.
+ const hashBeforeRefresh = workflowStore.getState().syncWorkflowDraftHash
+ const [error, draft] = await safe(
+ consoleClient.apps.byAppId.workflows.draft.get(
+ { params: { app_id: baseParams.appId } },
+ { context: { silent: true } },
+ ),
+ )
+ if (!canSaveEmptyGraph()) {
+ callback?.onSettled?.()
+ return null
+ }
+ if (error || !Array.isArray(draft.graph.nodes) || !Array.isArray(draft.graph.edges)) {
+ callback?.onError?.()
+ callback?.onSettled?.()
+ return null
+ }
+
+ const { syncWorkflowDraftHash, setSyncWorkflowDraftHash } = workflowStore.getState()
+ // Another hook may have saved a newer revision while this request was in flight.
+ if (syncWorkflowDraftHash === hashBeforeRefresh)
+ setSyncWorkflowDraftHash(draft.hash, {
+ nodes: draft.graph.nodes,
+ edges: draft.graph.edges,
+ })
+ }
+
+ // Check after queued saves finish so a newly persisted nonempty draft is protected too.
+ if (emptyGraph && workflowStore.getState().syncWorkflowDraftIsEmpty !== true) {
+ const { showConfirm, setShowConfirm } = workflowStore.getState()
+ if (!isMountedRef.current || showConfirm) {
+ callback?.onSettled?.()
+ return null
+ }
+
+ const confirmed = await new Promise<boolean>((resolve) => {
+ let settled = false
+ const finish = (confirmed: boolean) => {
+ if (settled) return
+ settled = true
+ cancelConfirmationRef.current = undefined
+ setShowConfirm(undefined)
+ resolve(confirmed)
+ }
+ cancelConfirmationRef.current = () => finish(false)
+ setShowConfirm({
+ title: t(($) => $['common.clearCanvasConfirmTitle'], { ns: 'workflow' }),
+ desc: t(($) => $['common.clearCanvasConfirmDescription'], { ns: 'workflow' }),
+ onConfirm: () => finish(true),
+ onCancel: () => finish(false),
+ })
+ })
+
+ if (!confirmed || !canSaveEmptyGraph()) {
callback?.onSettled?.()
return null
}
@@ -207,7 +271,7 @@ const useNodesSyncDraftBase = (getNodesReadOnly: () => boolean) => {
const body = {
...baseParams.params,
hash: latestHash || null,
- ...(force ? { force: true } : {}),
+ ...(emptyGraph ? { force: true } : {}),
...(options?.environmentVariablePatch
? {
environment_variable_patch: {
@@ -235,7 +299,7 @@ const useNodesSyncDraftBase = (getNodesReadOnly: () => boolean) => {
return null
}
- setSyncWorkflowDraftHash(res.hash)
+ setSyncWorkflowDraftHash(res.hash, baseParams.params.graph)
setDraftUpdatedAt(res.updated_at)
callback?.onSuccess?.()
return { hash: res.hash, updatedAt: res.updated_at }
@@ -249,6 +313,7 @@ const useNodesSyncDraftBase = (getNodesReadOnly: () => boolean) => {
getPostParams,
handleRefreshWorkflowDraft,
isCollaborationEnabled,
+ t,
appId,
],
)
@@ -275,39 +340,14 @@ const useNodesSyncDraftBase = (getNodesReadOnly: () => boolean) => {
}
const emptyGraph = isEmptyGraph(baseParams.params.graph)
- if (emptyGraph) {
- const { showConfirm, setShowConfirm } = workflowStore.getState()
- if (
- !isMountedRef.current ||
- showConfirm ||
- (isCollaborationEnabled && !collaborationManager.canPersistLocalGraph())
- ) {
- callback?.onSettled?.()
- return null
- }
-
- const confirmed = await new Promise<boolean>((resolve) => {
- let settled = false
- const finish = (confirmed: boolean) => {
- if (settled) return
- settled = true
- cancelConfirmationRef.current = undefined
- setShowConfirm(undefined)
- resolve(confirmed)
- }
- cancelConfirmationRef.current = () => finish(false)
- setShowConfirm({
- title: t(($) => $['common.clearCanvasConfirmTitle'], { ns: 'workflow' }),
- desc: t(($) => $['common.clearCanvasConfirmDescription'], { ns: 'workflow' }),
- onConfirm: () => finish(true),
- onCancel: () => finish(false),
- })
- })
-
- if (!confirmed) {
- callback?.onSettled?.()
- return null
- }
+ if (
+ emptyGraph &&
+ (!isMountedRef.current ||
+ emptySyncPendingRef.current ||
+ workflowStore.getState().showConfirm)
+ ) {
+ callback?.onSettled?.()
+ return null
}
const shouldRequestLeader =
@@ -318,20 +358,24 @@ const useNodesSyncDraftBase = (getNodesReadOnly: () => boolean) => {
!options?.forceLocal
if (!shouldRequestLeader) {
- // The user grants consent in this tab, so persist a confirmed empty graph here.
- return doSyncWorkflowDraftLocally(
- baseParams,
- notRefreshWhenSyncError,
- callback,
- options,
- emptyGraph,
- )
+ // Empty graphs stay in this tab so any required consent belongs to the initiating user.
+ if (emptyGraph) emptySyncPendingRef.current = true
+ try {
+ return await doSyncWorkflowDraftLocally(
+ baseParams,
+ notRefreshWhenSyncError,
+ callback,
+ options,
+ )
+ } finally {
+ if (emptyGraph) emptySyncPendingRef.current = false
+ }
}
try {
const result = await collaborationManager.requestWorkflowSync()
const { setSyncWorkflowDraftHash, setDraftUpdatedAt } = workflowStore.getState()
- setSyncWorkflowDraftHash(result.hash)
+ setSyncWorkflowDraftHash(result.hash, baseParams.params.graph)
setDraftUpdatedAt(result.updatedAt)
callback?.onSuccess?.()
return result
@@ -348,7 +392,6 @@ const useNodesSyncDraftBase = (getNodesReadOnly: () => boolean) => {
getNodesReadOnly,
getPostParams,
isCollaborationEnabled,
- t,
workflowStore,
appId,
],
diff --git a/web/app/components/workflow-app/hooks/use-workflow-init.ts b/web/app/components/workflow-app/hooks/use-workflow-init.ts
index 71b75e30279..3dc18e86e5d 100644
--- a/web/app/components/workflow-app/hooks/use-workflow-init.ts
+++ b/web/app/components/workflow-app/hooks/use-workflow-init.ts
@@ -120,7 +120,7 @@ export const useWorkflowInit = () => {
conversationVariables: initialData.conversation_variables || [],
isWorkflowDataLoaded: true,
})
- setSyncWorkflowDraftHash(initialData.hash)
+ setSyncWorkflowDraftHash(initialData.hash, res.graph)
setIsLoading(false)
} catch (error: unknown) {
if (error instanceof ORPCError) {
@@ -152,7 +152,7 @@ export const useWorkflowInit = () => {
conversationVariables: [],
isWorkflowDataLoaded: true,
})
- setSyncWorkflowDraftHash(initialData.hash)
+ setSyncWorkflowDraftHash(initialData.hash, initialGraph)
setIsLoading(false)
return
}
@@ -174,7 +174,7 @@ export const useWorkflowInit = () => {
)
.then((res) => {
workflowStore.getState().setDraftUpdatedAt(res.updated_at)
- setSyncWorkflowDraftHash(res.hash)
+ setSyncWorkflowDraftHash(res.hash, initialGraph)
handleGetInitialWorkflowData()
})
}
diff --git a/web/app/components/workflow-app/hooks/use-workflow-refresh-draft.ts b/web/app/components/workflow-app/hooks/use-workflow-refresh-draft.ts
index 2e056dfad41..610b93f067b 100644
--- a/web/app/components/workflow-app/hooks/use-workflow-refresh-draft.ts
+++ b/web/app/components/workflow-app/hooks/use-workflow-refresh-draft.ts
@@ -50,7 +50,7 @@ export const useWorkflowRefreshDraft = () => {
// Ensure we have a valid workflow structure with viewport
if (!notUpdateCanvas)
handleUpdateWorkflowCanvas(getWorkflowDraftGraphForCanvas(response.graph))
- setSyncWorkflowDraftHash(response.hash)
+ setSyncWorkflowDraftHash(response.hash, response.graph)
setEnvSecrets(
(response.environment_variables || [])
.filter((env) => env.value_type === 'secret')
diff --git a/web/app/components/workflow/index.tsx b/web/app/components/workflow/index.tsx
index 7ea9a0aedec..2a16c2111c4 100644
--- a/web/app/components/workflow/index.tsx
+++ b/web/app/components/workflow/index.tsx
@@ -330,7 +330,7 @@ export const Workflow: FC<WorkflowProps> = memo(
if (payload.viewport) reactflow.setViewport(payload.viewport)
- if (payload.hash) setSyncWorkflowDraftHash(payload.hash)
+ if (payload.hash) setSyncWorkflowDraftHash(payload.hash, payload)
onWorkflowDataUpdate?.(payload)
@@ -648,7 +648,7 @@ export const Workflow: FC<WorkflowProps> = memo(
<CandidateNode />
<CommentManager />
<div
- className="pointer-events-none absolute top-0 left-0 z-10 flex w-12 items-center justify-center p-1 pl-2"
+ className="pointer-events-none absolute inset-s-0 top-0 z-10 flex w-12 items-center justify-center p-1 ps-2"
style={{ height: controlHeight }}
>
<Control />
diff --git a/web/app/components/workflow/store/workflow/workflow-draft-slice.ts b/web/app/components/workflow/store/workflow/workflow-draft-slice.ts
index 3bbd7e5d220..cd708e4d25d 100644
--- a/web/app/components/workflow/store/workflow/workflow-draft-slice.ts
+++ b/web/app/components/workflow/store/workflow/workflow-draft-slice.ts
@@ -20,7 +20,8 @@ export type WorkflowDraftSliceShape = {
setBackupDraft: (backupDraft?: WorkflowDraftSliceShape['backupDraft']) => void
debouncedSyncWorkflowDraft: DebouncedFunc
syncWorkflowDraftHash: string
- setSyncWorkflowDraftHash: (hash: string) => void
+ syncWorkflowDraftIsEmpty: boolean | undefined
+ setSyncWorkflowDraftHash: (hash: string, graph?: { nodes: unknown[]; edges: unknown[] }) => void
isSyncingWorkflowDraft: boolean
setIsSyncingWorkflowDraft: (isSyncingWorkflowDraft: boolean) => void
isWorkflowDataLoaded: boolean
@@ -41,7 +42,14 @@ export const createWorkflowDraftSlice: StateCreator<WorkflowDraftSliceShape> = (
setBackupDraft: (backupDraft) => set(() => ({ backupDraft })),
debouncedSyncWorkflowDraft: debouncedFn,
syncWorkflowDraftHash: '',
- setSyncWorkflowDraftHash: (syncWorkflowDraftHash) => set(() => ({ syncWorkflowDraftHash })),
+ syncWorkflowDraftIsEmpty: undefined,
+ setSyncWorkflowDraftHash: (syncWorkflowDraftHash, graph) =>
+ set(() => ({
+ syncWorkflowDraftHash,
+ syncWorkflowDraftIsEmpty: graph
+ ? graph.nodes.length === 0 && graph.edges.length === 0
+ : undefined,
+ })),
isSyncingWorkflowDraft: false,
setIsSyncingWorkflowDraft: (isSyncingWorkflowDraft) => set(() => ({ isSyncingWorkflowDraft })),
isWorkflowDataLoaded: false,