Line data Source code
1 : /**
2 : * V2 Workflow Persistence Composable
3 : *
4 : * Key changes from V1:
5 : * - Uses V2 draft store with per-draft keys
6 : * - Uses tab state composable for session pointers
7 : * - Adds 512ms debounce on graph change persistence
8 : */
9 :
10 : import { debounce } from 'es-toolkit'
11 : import { useToast } from '@/components/ui/toast/toastStore'
12 : import { tryOnScopeDispose, until, whenever } from '@vueuse/core'
13 : import { computed, nextTick, ref, watch } from 'vue'
14 : import { useI18n } from 'vue-i18n'
15 : import { useRoute, useRouter } from 'vue-router'
16 :
17 : import { useCurrentUser } from '@/composables/auth/useCurrentUser'
18 : import { useFeatureFlags } from '@/composables/useFeatureFlags'
19 : import {
20 : hydratePreservedQuery,
21 : mergePreservedQueryIntoQuery
22 : } from '@/platform/navigation/preservedQueryManager'
23 : import { PRESERVED_QUERY_NAMESPACES } from '@/platform/navigation/preservedQueryNamespaces'
24 : import { isCloud } from '@/platform/distribution/types'
25 : import { LOCAL_HANDOFF_PARAM } from '@/platform/openOnCloud/localHandoffProtocol'
26 : import { useSettingStore } from '@/platform/settings/settingStore'
27 : import { useLinkedWorkflowUrlLoader } from '@/platform/workflow/management/composables/useLinkedWorkflowUrlLoader'
28 : import { useTeamWorkspaceStore } from '@/platform/workspace/stores/teamWorkspaceStore'
29 : import { useWorkflowService } from '@/platform/workflow/core/services/workflowService'
30 : import {
31 : ComfyWorkflow,
32 : useWorkflowStore
33 : } from '@/platform/workflow/management/stores/workflowStore'
34 : import { PERSIST_DEBOUNCE_MS } from '@/platform/workflow/persistence/base/draftTypes'
35 : import type { StartupOutcome } from '@/platform/workflow/persistence/base/draftTypes'
36 : import {
37 : clearAllWorkspaceStorage,
38 : clearWorkflowRestoreState,
39 : completeWorkflowLogoutTransition,
40 : prepareWorkflowLogoutTransition,
41 : registerWorkflowPersistenceFlush
42 : } from '@/platform/workflow/persistence/base/storageIO'
43 : import { useWorkflowDraftStoreV2 } from '@/platform/workflow/persistence/stores/workflowDraftStoreV2'
44 : import { useWorkflowTabState } from './useWorkflowTabState'
45 : import { useSharedWorkflowUrlLoader } from '@/platform/workflow/sharing/composables/useSharedWorkflowUrlLoader'
46 : import { useTemplateUrlLoader } from '@/platform/workflow/templates/composables/useTemplateUrlLoader'
47 : import { api } from '@/scripts/api'
48 : import { app as comfyApp } from '@/scripts/app'
49 : import type { ComfyWorkflowJSON } from '@comfyorg/graph-model/workflowSchema'
50 : import { isValidUuid } from '@/utils/formatUtil'
51 :
52 2355 : export function useWorkflowPersistenceV2() {
53 2355 : const { t } = useI18n()
54 2355 : const workflowStore = useWorkflowStore()
55 2355 : const settingStore = useSettingStore()
56 2355 : const route = useRoute()
57 2355 : const router = useRouter()
58 2355 : const sharedWorkflowUrlLoader = useSharedWorkflowUrlLoader()
59 2355 : const templateUrlLoader = useTemplateUrlLoader()
60 2355 : const linkedWorkflowUrlLoader = useLinkedWorkflowUrlLoader()
61 2355 : let openedLinkedWorkflow = false
62 2355 : const TEMPLATE_NAMESPACE = PRESERVED_QUERY_NAMESPACES.TEMPLATE
63 2355 : const SHARE_NAMESPACE = PRESERVED_QUERY_NAMESPACES.SHARE
64 2355 : const LOCAL_HANDOFF_NAMESPACE = PRESERVED_QUERY_NAMESPACES.LOCAL_HANDOFF
65 2355 : const { flags } = useFeatureFlags()
66 2355 : const draftStore = useWorkflowDraftStoreV2()
67 2355 : draftStore.setAuthSubject(isCloud ? null : undefined)
68 2355 : const tabState = useWorkflowTabState()
69 2355 : const toast = useToast()
70 2355 : const { isAuthInitialized, onUserLogout, onUserResolved } = useCurrentUser()
71 2355 : const teamWorkspaceStore = useTeamWorkspaceStore()
72 2355 : let stopWorkspaceReadinessWatcher: (() => void) | undefined
73 : let resolvedAuthSubject: string | null = null
74 : let authTransitionVersion = 0
75 2355 : let authTransition = Promise.resolve()
76 :
77 0 : function stopPendingWorkspaceReadinessWatcher(): void {
78 0 : stopWorkspaceReadinessWatcher?.()
79 0 : stopWorkspaceReadinessWatcher = undefined
80 : }
81 :
82 2355 : const ensureTemplateQueryFromIntent = async () => {
83 2355 : hydratePreservedQuery(TEMPLATE_NAMESPACE)
84 2355 : const mergedQuery = mergePreservedQueryIntoQuery(
85 : TEMPLATE_NAMESPACE,
86 : route.query
87 : )
88 :
89 2355 : if (mergedQuery) {
90 0 : await router.replace({ query: mergedQuery })
91 : }
92 :
93 2355 : return mergedQuery ?? route.query
94 : }
95 :
96 2355 : const workflowPersistenceEnabled = computed(() =>
97 : settingStore.get('Comfy.Workflow.Persist')
98 : )
99 :
100 2355 : const lastSavedJsonByPath = ref<Record<string, string>>({})
101 :
102 2355 : watch(workflowPersistenceEnabled, (enabled) => {
103 2340 : if (!enabled) {
104 0 : draftStore.reset()
105 0 : lastSavedJsonByPath.value = {}
106 : }
107 : })
108 :
109 2355 : const persistCurrentWorkflow = () => {
110 4191 : if (!workflowPersistenceEnabled.value) return
111 4190 : const activeWorkflow = workflowStore.activeWorkflow
112 4190 : if (!activeWorkflow) return
113 :
114 4190 : const graphData = comfyApp.rootGraph.serialize()
115 4190 : const workflowJson = JSON.stringify(graphData)
116 4190 : const workflowPath = activeWorkflow.path
117 :
118 : // Skip if unchanged
119 4190 : if (workflowJson === lastSavedJsonByPath.value[workflowPath]) return
120 :
121 : // Save to V2 draft store
122 : const saved = draftStore.saveDraft(workflowPath, workflowJson, {
123 : name: activeWorkflow.key,
124 : isTemporary: activeWorkflow.isTemporary
125 : })
126 :
127 4190 : if (!saved) {
128 0 : toast.error(t('g.error'), {
129 : description: t('toastMessages.failedToSaveDraft')
130 : })
131 0 : return
132 : }
133 :
134 : // Update session pointer
135 3976 : tabState.setActivePath(workflowPath)
136 :
137 3976 : lastSavedJsonByPath.value[workflowPath] = workflowJson
138 :
139 : // Clean up draft if workflow is saved and unmodified
140 4191 : if (!activeWorkflow.isTemporary && !activeWorkflow.isModified) {
141 49 : draftStore.removeDraft(workflowPath)
142 : }
143 : }
144 :
145 : // Debounced version for graphChanged events
146 2355 : const debouncedPersist = debounce(persistCurrentWorkflow, PERSIST_DEBOUNCE_MS)
147 :
148 98 : function flushPendingPersistence() {
149 98 : debouncedPersist.flush()
150 : }
151 :
152 2355 : const unregisterPersistenceFlush = registerWorkflowPersistenceFlush(
153 : flushPendingPersistence
154 : )
155 2355 : window.addEventListener('pagehide', flushPendingPersistence)
156 :
157 : const isWorkspaceInitConcluded = () =>
158 : (teamWorkspaceStore.initState === 'ready' &&
159 : teamWorkspaceStore.activeWorkspaceId !== null) ||
160 : teamWorkspaceStore.initState === 'error'
161 :
162 : function resumePersistenceWhenWorkspaceIsReady(): void {
163 : if (isWorkspaceInitConcluded()) {
164 : completeWorkflowLogoutTransition()
165 : return
166 : }
167 :
168 : stopWorkspaceReadinessWatcher = whenever(
169 : isWorkspaceInitConcluded,
170 : () => {
171 : stopWorkspaceReadinessWatcher = undefined
172 : completeWorkflowLogoutTransition()
173 : },
174 : { once: true }
175 : )
176 : }
177 :
178 4708 : async function waitForRestoreIdentity(): Promise<() => boolean> {
179 : if (isCloud && !isAuthInitialized.value)
180 : await until(isAuthInitialized).toBe(true)
181 : const restoreVersion = authTransitionVersion
182 : if (isCloud) await authTransition
183 4708 : return () => restoreVersion === authTransitionVersion
184 : }
185 :
186 : async function waitForWorkspaceInitialization(): Promise<void> {
187 : if (isWorkspaceInitConcluded()) return
188 : await until(isWorkspaceInitConcluded).toBe(true)
189 : }
190 :
191 2355 : onUserLogout(() => {
192 : if (!isCloud) return
193 : authTransitionVersion++
194 : resolvedAuthSubject = null
195 : draftStore.setAuthSubject(null)
196 : stopPendingWorkspaceReadinessWatcher()
197 : debouncedPersist.cancel()
198 : prepareWorkflowLogoutTransition()
199 : clearAllWorkspaceStorage()
200 : })
201 2355 : onUserResolved((user) => {
202 : if (!isCloud) return
203 : stopPendingWorkspaceReadinessWatcher()
204 : const previousSubject = resolvedAuthSubject
205 : resolvedAuthSubject = user.id
206 :
207 : if (!previousSubject || previousSubject === user.id) {
208 : draftStore.setAuthSubject(user.id)
209 : resumePersistenceWhenWorkspaceIsReady()
210 : return
211 : }
212 :
213 : const transitionVersion = ++authTransitionVersion
214 :
215 : debouncedPersist.cancel()
216 : prepareWorkflowLogoutTransition()
217 : clearWorkflowRestoreState()
218 : authTransition = authTransition
219 : .then(async () => {
220 : if (transitionVersion !== authTransitionVersion) return
221 : workflowStore.activeWorkflow = null
222 : try {
223 : await useWorkflowService().loadBlankWorkflow()
224 : if (transitionVersion !== authTransitionVersion) return
225 : draftStore.setAuthSubject(user.id)
226 : await waitForWorkspaceInitialization()
227 : if (transitionVersion !== authTransitionVersion) return
228 : await draftStore.loadPersistedWorkflow({
229 : fallbackToLatestDraft: true
230 : })
231 : } finally {
232 : if (transitionVersion === authTransitionVersion) {
233 : draftStore.setAuthSubject(user.id)
234 : completeWorkflowLogoutTransition()
235 : }
236 : }
237 : })
238 : .catch((error: unknown) => {
239 : console.error('Error switching workflow persistence identity', error)
240 : })
241 : })
242 :
243 2355 : const loadPreviousWorkflowFromStorage = async (isCurrent: () => boolean) => {
244 2299 : const sessionPath = tabState.getActivePath()
245 :
246 2299 : if (
247 : sessionPath &&
248 : (await draftStore.loadPersistedWorkflow({
249 : preferredPath: sessionPath,
250 : isCurrent
251 : }))
252 : )
253 4 : return true
254 :
255 2295 : if (!isCurrent()) return false
256 2295 : if (sessionPath) {
257 0 : const saved = workflowStore.getWorkflowByPath(sessionPath)
258 0 : if (
259 : saved &&
260 : (await useWorkflowService().openWorkflow(saved, { isCurrent }))
261 : )
262 0 : return true
263 : }
264 :
265 2295 : return await draftStore.loadPersistedWorkflow({
266 : fallbackToLatestDraft: true,
267 : isCurrent
268 : })
269 : }
270 :
271 : /**
272 : * The blank canvas startup opens for itself is not the user's work, but the
273 : * active-workflow watcher has already saved it. Drop the draft and the
274 : * pointer to it, or the next boot restores it and reports `restored`.
275 : */
276 2355 : const discardStartupBlankDraft = () => {
277 3 : const blank = workflowStore.activeWorkflow
278 3 : if (!blank?.isTemporary || blank.isModified) return
279 :
280 3 : debouncedPersist.cancel()
281 3 : draftStore.removeDraft(blank.path)
282 3 : delete lastSavedJsonByPath.value[blank.path]
283 3 : tabState.clearActivePathPointer()
284 : }
285 :
286 2355 : const hasPreservedIntent = (namespace: string, key: string) => {
287 5 : if (typeof route.query[key] === 'string') return true
288 3 : hydratePreservedQuery(namespace)
289 : const merged = mergePreservedQueryIntoQuery(namespace, route.query)
290 5 : return typeof merged?.[key] === 'string'
291 : }
292 :
293 2355 : const hasSharedWorkflowIntent = () =>
294 : hasPreservedIntent(SHARE_NAMESPACE, 'share')
295 :
296 2355 : const hasTemplateUrlIntent = () =>
297 : hasPreservedIntent(TEMPLATE_NAMESPACE, 'template')
298 :
299 2355 : const hasLocalHandoffIntent = () =>
300 : flags.openOnCloudEnabled &&
301 : hasPreservedIntent(LOCAL_HANDOFF_NAMESPACE, LOCAL_HANDOFF_PARAM)
302 :
303 2355 : const resolveStartupOutcome = async (
304 : workflowLinkPending = false
305 : ): Promise<StartupOutcome> => {
306 2256 : if (settingStore.get('Comfy.TutorialCompleted')) {
307 2253 : await comfyApp.loadGraphData()
308 2253 : return 'restored'
309 : }
310 :
311 3 : await useWorkflowService().loadBlankWorkflow()
312 3 : await nextTick()
313 3 : discardStartupBlankDraft()
314 2256 : return workflowLinkPending ||
315 : hasSharedWorkflowIntent() ||
316 : hasTemplateUrlIntent() ||
317 : hasLocalHandoffIntent()
318 : ? 'url-intent'
319 : : 'fresh'
320 : }
321 :
322 2355 : const getRestorableTabState = () => {
323 4708 : const storedTabState = tabState.getOpenPaths()
324 4708 : const paths = storedTabState?.paths ?? []
325 4708 : const activeIndex = storedTabState?.activeIndex ?? -1
326 :
327 4708 : if (paths.length === 0 || activeIndex < 0 || activeIndex >= paths.length) {
328 4598 : return null
329 : }
330 :
331 110 : return { paths, activeIndex }
332 : }
333 :
334 2355 : const initializeWorkflow = async (): Promise<StartupOutcome> => {
335 2355 : const linkedWorkflow =
336 : await linkedWorkflowUrlLoader.openLinkedWorkflowFromUrl()
337 2355 : const workflowLinkPending = linkedWorkflow === 'pending'
338 2355 : openedLinkedWorkflow = linkedWorkflow === 'opened'
339 2355 : if (openedLinkedWorkflow) return 'restored'
340 :
341 2355 : if (!workflowPersistenceEnabled.value) {
342 1 : return await resolveStartupOutcome(workflowLinkPending)
343 : }
344 :
345 2354 : const isRestoreCurrent = await waitForRestoreIdentity()
346 :
347 2355 : try {
348 2354 : if (getRestorableTabState()) {
349 55 : return 'restored'
350 : }
351 :
352 2299 : await workflowStore.loadWorkflows()
353 2299 : if (!isRestoreCurrent()) return 'restored'
354 2299 : const restored = await loadPreviousWorkflowFromStorage(isRestoreCurrent)
355 2299 : if (!isRestoreCurrent()) return 'restored'
356 2355 : return restored
357 : ? 'restored'
358 : : await resolveStartupOutcome(workflowLinkPending)
359 : } catch (err) {
360 0 : console.error('Error loading previous workflow', err)
361 0 : return await resolveStartupOutcome(workflowLinkPending)
362 : }
363 : }
364 :
365 2355 : const loadTemplateFromUrlIfPresent = async () => {
366 2355 : const query = await ensureTemplateQueryFromIntent()
367 : const hasTemplateUrl = query.template && typeof query.template === 'string'
368 :
369 2355 : return hasTemplateUrl
370 : ? await templateUrlLoader.loadTemplateFromUrl()
371 : : undefined
372 : }
373 :
374 2355 : const loadSharedWorkflowFromUrlIfPresent = async () => {
375 2355 : return await sharedWorkflowUrlLoader.loadSharedWorkflowFromUrl()
376 : }
377 :
378 : // Setup watchers
379 2355 : watch(
380 : () => workflowStore.activeWorkflow?.key,
381 : (activeWorkflowKey) => {
382 3894 : if (!activeWorkflowKey) return
383 : // Flush any pending persistence from the previous workflow
384 3894 : debouncedPersist.flush()
385 : // Persist the new workflow immediately
386 3894 : persistCurrentWorkflow()
387 : }
388 : )
389 :
390 : // Debounced persistence on graph changes
391 2355 : api.addEventListener('graphChanged', debouncedPersist)
392 :
393 : // Clean up event listener when component unmounts
394 2355 : tryOnScopeDispose(() => {
395 0 : api.removeEventListener('graphChanged', debouncedPersist)
396 0 : window.removeEventListener('pagehide', flushPendingPersistence)
397 0 : unregisterPersistenceFlush()
398 0 : debouncedPersist.cancel()
399 0 : stopPendingWorkspaceReadinessWatcher()
400 : })
401 :
402 : // Restore workflow tabs states
403 2355 : const openWorkflows = computed(() => workflowStore.openWorkflows)
404 2355 : const activeWorkflow = computed(() => workflowStore.activeWorkflow)
405 2355 : const restoreState = computed<{ paths: string[]; activeIndex: number }>(
406 : () => {
407 7933 : const active = getActiveWorkflow()
408 7933 : if (!active) return { paths: [], activeIndex: -1 }
409 5578 : const paths = openWorkflows.value
410 : .map((workflow) => workflow.path)
411 : .filter(
412 : (path): path is string =>
413 : typeof path === 'string' && path.startsWith(ComfyWorkflow.basePath)
414 : )
415 : const activeIndex = paths.indexOf(active.path)
416 :
417 5578 : return { paths, activeIndex }
418 : }
419 : )
420 :
421 7933 : function getActiveWorkflow(): ComfyWorkflow | null {
422 7933 : return activeWorkflow.value
423 : }
424 :
425 : // Track whether tab state has been properly restored to avoid
426 : // overwriting with stale data during initialization
427 2355 : let tabStateRestored = false
428 :
429 2355 : watch(restoreState, ({ paths, activeIndex }) => {
430 : // Only persist after tab state has been restored to avoid
431 : // writing leaked data from wrong workspace during init
432 5578 : if (workflowPersistenceEnabled.value && tabStateRestored) {
433 3278 : tabState.setOpenPaths(paths, activeIndex)
434 : }
435 : })
436 :
437 : /**
438 : * Restores saved workflow tabs after initializeWorkflow skips the single-workflow fallback.
439 : * GraphCanvas must call this during startup when workflow persistence is enabled.
440 : */
441 2355 : const restoreWorkflowTabsState = async () => {
442 2355 : try {
443 2355 : await restoreSavedTabs()
444 : } finally {
445 2355 : workflowStore.markTabsRestored()
446 : }
447 : }
448 :
449 2355 : const stampWithDraftTime = (
450 : restored: ComfyWorkflow,
451 : draftPath: string,
452 : draftData: ComfyWorkflowJSON,
453 : draftUpdatedAt: number
454 : ) => {
455 : const builtFromThisDraft =
456 : restored.path === draftPath && isValidUuid(draftData.id)
457 78 : if (builtFromThisDraft) restored.lastModified = draftUpdatedAt
458 : }
459 :
460 2355 : const restoreSavedTabs = async () => {
461 2355 : if (!workflowPersistenceEnabled.value) {
462 1 : tabStateRestored = true
463 1 : return
464 : }
465 :
466 2354 : const isRestoreCurrent = await waitForRestoreIdentity()
467 :
468 2354 : try {
469 2354 : await workflowStore.loadWorkflows()
470 : } catch (err) {
471 0 : console.error('Error loading workflows for tab restore', err)
472 0 : await resolveStartupOutcome()
473 0 : tabStateRestored = true
474 0 : return
475 : }
476 :
477 2355 : const restorableTabState = isRestoreCurrent()
478 : ? getRestorableTabState()
479 : : null
480 2355 : if (!restorableTabState) {
481 2299 : tabStateRestored = true
482 2299 : return
483 : }
484 55 : const { paths: storedWorkflows, activeIndex: storedActiveIndex } =
485 : restorableTabState
486 :
487 55 : storedWorkflows.forEach((path: string) => {
488 113 : if (workflowStore.getWorkflowByPath(path)) return
489 79 : const draft = draftStore.getDraft(path)
490 113 : if (!draft?.isTemporary) return
491 99 : try {
492 78 : const workflowData = JSON.parse(draft.data)
493 78 : const restored = workflowStore.createTemporary(draft.name, workflowData)
494 78 : stampWithDraftTime(restored, path, workflowData, draft.updatedAt)
495 : } catch (err) {
496 0 : console.warn(
497 : 'Failed to parse workflow draft, creating with default',
498 : err
499 : )
500 0 : draftStore.removeDraft(path)
501 0 : workflowStore.createTemporary(draft.name)
502 : }
503 : })
504 :
505 55 : workflowStore.openWorkflowsInBackground({
506 : left: storedWorkflows.slice(0, storedActiveIndex),
507 : right: storedWorkflows.slice(storedActiveIndex)
508 : })
509 :
510 55 : tabStateRestored = true
511 55 : if (openedLinkedWorkflow) return
512 :
513 55 : const activePath = storedWorkflows[storedActiveIndex]
514 2355 : const workflow = activePath
515 : ? workflowStore.getWorkflowByPath(activePath)
516 : : null
517 2355 : if (workflow) {
518 54 : await useWorkflowService().openWorkflow(workflow)
519 : }
520 : }
521 :
522 2355 : return {
523 : initializeWorkflow,
524 : loadSharedWorkflowFromUrlIfPresent,
525 : loadTemplateFromUrlIfPresent,
526 : restoreWorkflowTabsState
527 : }
528 : }
|