LCOV - code coverage report
Current view: top level - src/platform/workflow/sharing/composables - useSharedWorkflowUrlLoader.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 46.8 % 77 36
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import { useToast } from '@/components/ui/toast/toastStore'
       2              : import { useI18n } from 'vue-i18n'
       3              : import { useRoute, useRouter } from 'vue-router'
       4              : 
       5              : import { useCurrentUser } from '@/composables/auth/useCurrentUser'
       6              : import { useAppMode } from '@/composables/useAppMode'
       7              : import { useWorkflowTemplateSelectorDialog } from '@/platform/workflow/templates/composables/useWorkflowTemplateSelectorDialog'
       8              : import { useTelemetry } from '@comfyorg/telemetry'
       9              : import OpenSharedWorkflowDialogContent from '@/platform/workflow/sharing/components/OpenSharedWorkflowDialogContent.vue'
      10              : import type { SharedWorkflowPayload } from '@/platform/workflow/sharing/types/shareTypes'
      11              : import {
      12              :   clearPreservedQuery,
      13              :   hydratePreservedQuery,
      14              :   mergePreservedQueryIntoQuery
      15              : } from '@/platform/navigation/preservedQueryManager'
      16              : import { PRESERVED_QUERY_NAMESPACES } from '@/platform/navigation/preservedQueryNamespaces'
      17              : import { useWorkflowShareService } from '@/platform/workflow/sharing/services/workflowShareService'
      18              : import { isValidShareId } from '@/platform/workflow/sharing/utils/shareAuthAttribution'
      19              : import { app } from '@/scripts/app'
      20              : import { useDialogService } from '@/services/dialogService'
      21              : import { useDialogStore } from '@/stores/dialogStore'
      22              : 
      23              : export type SharedWorkflowUrlLoadStatus =
      24              :   | 'not-present'
      25              :   | 'loaded'
      26              :   | 'loaded-without-assets'
      27              :   | 'cancelled'
      28              :   | 'failed'
      29              : 
      30              : type DialogResult =
      31              :   | { action: 'copy-and-open'; payload: SharedWorkflowPayload }
      32              :   | { action: 'open-only'; payload: SharedWorkflowPayload }
      33              :   | { action: 'cancel' }
      34              : 
      35              : type OpeningAction = Exclude<DialogResult['action'], 'cancel'>
      36              : 
      37         2355 : const OPEN_SHARED_WORKFLOW_DIALOG_KEY = 'open-shared-workflow'
      38              : 
      39         2355 : export function useSharedWorkflowUrlLoader() {
      40         2355 :   const route = useRoute()
      41         2355 :   const router = useRouter()
      42         2355 :   const toast = useToast()
      43         2355 :   const { t } = useI18n()
      44         2355 :   const workflowShareService = useWorkflowShareService()
      45         2355 :   const dialogService = useDialogService()
      46         2355 :   const dialogStore = useDialogStore()
      47         2355 :   const templateSelectorDialog = useWorkflowTemplateSelectorDialog()
      48         2355 :   const { isLoggedIn } = useCurrentUser()
      49         2355 :   const { mode, isAppMode } = useAppMode()
      50         2355 :   const SHARE_NAMESPACE = PRESERVED_QUERY_NAMESPACES.SHARE
      51              : 
      52         2355 :   async function ensureShareQueryFromIntent() {
      53         2355 :     hydratePreservedQuery(SHARE_NAMESPACE)
      54         2355 :     const mergedQuery = mergePreservedQueryIntoQuery(
      55              :       SHARE_NAMESPACE,
      56              :       route.query
      57              :     )
      58              : 
      59         2355 :     if (mergedQuery) {
      60            0 :       await router.replace({ query: mergedQuery })
      61              :     }
      62              : 
      63         2355 :     return mergedQuery ?? route.query
      64              :   }
      65              : 
      66            0 :   function cleanupUrlParams() {
      67            0 :     const newQuery = { ...route.query }
      68            0 :     delete newQuery.share
      69            0 :     void router.replace({ query: newQuery })
      70              :   }
      71              : 
      72            0 :   function clearShareIntent() {
      73            0 :     cleanupUrlParams()
      74            0 :     clearPreservedQuery(SHARE_NAMESPACE)
      75              :   }
      76              : 
      77            2 :   function showOpenSharedWorkflowDialog(
      78              :     shareId: string
      79              :   ): Promise<DialogResult> {
      80            0 :     function setOpeningAction(openingAction: OpeningAction) {
      81            0 :       dialogStore.updateDialog({
      82              :         key: OPEN_SHARED_WORKFLOW_DIALOG_KEY,
      83              :         contentProps: { openingAction }
      84              :       })
      85              :     }
      86              : 
      87            2 :     return new Promise<DialogResult>((resolve) => {
      88            2 :       dialogService.showLayoutDialog({
      89              :         key: OPEN_SHARED_WORKFLOW_DIALOG_KEY,
      90              :         component: OpenSharedWorkflowDialogContent,
      91              :         props: {
      92              :           shareId,
      93              :           openingAction: null,
      94              :           onConfirm: (payload: SharedWorkflowPayload) => {
      95            0 :             setOpeningAction('copy-and-open')
      96            0 :             resolve({ action: 'copy-and-open', payload })
      97              :           },
      98              :           onOpenWithoutImporting: (payload: SharedWorkflowPayload) => {
      99            0 :             setOpeningAction('open-only')
     100            0 :             resolve({ action: 'open-only', payload })
     101              :           },
     102              :           onCancel: () => {
     103            0 :             resolve({ action: 'cancel' })
     104            0 :             dialogStore.closeDialog({ key: OPEN_SHARED_WORKFLOW_DIALOG_KEY })
     105              :           }
     106              :         },
     107              :         dialogComponentProps: {
     108              :           onClose: () => resolve({ action: 'cancel' })
     109              :         }
     110              :       })
     111              :     })
     112              :   }
     113              : 
     114         2355 :   async function loadSharedWorkflowFromUrl(): Promise<SharedWorkflowUrlLoadStatus> {
     115              :     const query = await ensureShareQueryFromIntent()
     116         2355 :     const shareParam = query.share
     117              : 
     118         2355 :     if (shareParam == null) {
     119         2353 :       return 'not-present'
     120              :     }
     121              : 
     122            2 :     if (typeof shareParam !== 'string') {
     123            0 :       clearShareIntent()
     124            0 :       return 'not-present'
     125              :     }
     126              : 
     127            2 :     if (!isValidShareId(shareParam)) {
     128            0 :       console.warn(
     129              :         `[useSharedWorkflowUrlLoader] Invalid share parameter format: ${shareParam}`
     130              :       )
     131            0 :       toast.error(t('g.error'), { description: t('shareWorkflow.loadFailed') })
     132            0 :       clearShareIntent()
     133            0 :       return 'failed'
     134              :     }
     135              : 
     136         2355 :     useTelemetry()?.trackShareLinkOpened({
     137              :       share_id: shareParam,
     138              :       is_authenticated: isLoggedIn.value,
     139              :       view_mode: mode.value,
     140              :       is_app_mode: isAppMode.value
     141              :     })
     142              : 
     143         2355 :     const result = await showOpenSharedWorkflowDialog(shareParam)
     144              : 
     145            0 :     if (result.action === 'cancel') {
     146            0 :       clearPreservedQuery(PRESERVED_QUERY_NAMESPACES.SHARE_AUTH)
     147            0 :       clearShareIntent()
     148            0 :       return 'cancelled'
     149              :     }
     150              : 
     151            0 :     templateSelectorDialog.hide()
     152              : 
     153         2355 :     try {
     154            0 :       const { payload } = result
     155         2355 :       const workflowName = payload.name || t('openSharedWorkflow.dialogTitle')
     156         2355 :       const nonOwnedAssets = payload.assets.filter((a) => !a.in_library)
     157         2355 :       let importFailed = false
     158              : 
     159         2355 :       if (result.action === 'copy-and-open' && nonOwnedAssets.length > 0) {
     160            0 :         try {
     161            0 :           await workflowShareService.importPublishedAssets(
     162              :             nonOwnedAssets.map((a) => a.id),
     163              :             payload.shareId
     164              :           )
     165              :         } catch (importError) {
     166            0 :           importFailed = true
     167            0 :           console.error(
     168              :             '[useSharedWorkflowUrlLoader] Failed to import assets:',
     169              :             importError
     170              :           )
     171            0 :           toast.error(t('g.error'), {
     172              :             description: t('openSharedWorkflow.importFailed')
     173              :           })
     174              :         }
     175              :       }
     176              : 
     177            0 :       try {
     178            0 :         await app.loadGraphData(
     179              :           payload.workflowJson,
     180              :           true,
     181              :           true,
     182              :           workflowName,
     183              :           {
     184              :             openSource: 'shared_url',
     185              :             shareId: payload.shareId
     186              :           }
     187              :         )
     188              :       } catch (error) {
     189            0 :         console.error(
     190              :           '[useSharedWorkflowUrlLoader] Failed to load workflow graph:',
     191              :           error
     192              :         )
     193            0 :         toast.error(t('g.error'), {
     194              :           description: t('shareWorkflow.loadFailed')
     195              :         })
     196            0 :         clearShareIntent()
     197            0 :         return 'failed'
     198              :       }
     199              : 
     200            0 :       clearShareIntent()
     201         2355 :       return importFailed ? 'loaded-without-assets' : 'loaded'
     202              :     } finally {
     203            0 :       dialogStore.closeDialog({ key: OPEN_SHARED_WORKFLOW_DIALOG_KEY })
     204              :     }
     205              :   }
     206              : 
     207         2355 :   return {
     208              :     loadSharedWorkflowFromUrl
     209              :   }
     210              : }
        

Generated by: LCOV version 2.0-1