LCOV - code coverage report
Current view: top level - src/platform/workflow/templates/composables - useTemplateWorkflows.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 78.2 % 165 129
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import type { ComfyTemplateInputAsset } from '@comfyorg/comfyui-desktop-bridge-types'
       2              : import { computed, onScopeDispose, ref } from 'vue'
       3              : import { useI18n } from 'vue-i18n'
       4              : 
       5              : import { useToast } from '@/components/ui/toast/toastStore'
       6              : import { createToastId } from '@/types/toastId'
       7              : import { isCloud } from '@/platform/distribution/types'
       8              : import { isLocalDesktopHost } from '@/utils/envUtil'
       9              : import { useSettingStore } from '@/platform/settings/settingStore'
      10              : import { useSurveyFeatureTracking } from '@/platform/surveys/useSurveyFeatureTracking'
      11              : import { useTelemetry } from '@comfyorg/telemetry'
      12              : import { reportError } from '@comfyorg/telemetry/reportError'
      13              : import type { TemplateInput } from '@comfyorg/api-client/templateSchema'
      14              : import { syncCompletedTemplateInputsWithCurrentGraph } from '@/platform/workflow/templates/composables/useTemplateInputDownloadGraphSync'
      15              : import { useWorkflowTemplatesStore } from '@/platform/workflow/templates/repositories/workflowTemplatesStore'
      16              : import { usePartnerNodesEducationStore } from '@/platform/workflow/templates/stores/partnerNodesEducationStore'
      17              : import type {
      18              :   TemplateGroup,
      19              :   TemplateInfo,
      20              :   WorkflowTemplates
      21              : } from '@comfyorg/api-client/templateTypes'
      22              : import {
      23              :   getPendingTemplateSampleInputs,
      24              :   resolveTemplateInputAssets,
      25              :   startMissingTemplateInputDownloads
      26              : } from '@/platform/workflow/templates/utils/templateInputAssets'
      27              : import type {
      28              :   ComfyWorkflowJSON,
      29              :   LegacyLoadableWorkflow
      30              : } from '@comfyorg/graph-model/workflowSchema'
      31              : import {
      32              :   validateComfyWorkflow,
      33              :   zLegacyLoadableWorkflow
      34              : } from '@comfyorg/graph-model/workflowSchema'
      35              : import { api } from '@/scripts/api'
      36              : import { app } from '@/scripts/app'
      37              : import { useAssetsStore } from '@/stores/assetsStore'
      38              : import { useDialogStore } from '@/stores/dialogStore'
      39              : 
      40              : import { prepareTemplateInputs } from '@/platform/workflow/templates/services/templateInputService'
      41              : 
      42              : type TemplateLoadResult = 'loaded' | 'graph-failed' | 'not-started'
      43              : 
      44              : type FetchedTemplate =
      45              :   | { strict: true; json: ComfyWorkflowJSON }
      46              :   | { strict: false; json: LegacyLoadableWorkflow }
      47              : 
      48              : export type PreparedWorkflowTemplate = {
      49              :   id: string
      50              :   sourceModule: string
      51              :   workflowName: string
      52              :   controller: AbortController
      53              :   data: FetchedTemplate & {
      54              :     template:
      55              :       | ReturnType<
      56              :           typeof useWorkflowTemplatesStore
      57              :         >['enhancedTemplates'][number]
      58              :       | undefined
      59              :   }
      60              : }
      61              : 
      62            9 : function updateTemplateEducation(
      63              :   isPartnerNode: boolean | undefined,
      64              :   loadedWorkflow: Awaited<ReturnType<typeof app.loadGraphData>>
      65              : ) {
      66            9 :   const educationStore = usePartnerNodesEducationStore()
      67            9 :   if (isPartnerNode && typeof loadedWorkflow === 'object') {
      68            3 :     educationStore.requestCard(loadedWorkflow.key)
      69              :   } else {
      70            6 :     educationStore.retireCard()
      71              :   }
      72              : }
      73              : 
      74         2381 : export function useTemplateWorkflows() {
      75         2381 :   const { t } = useI18n()
      76         2381 :   const workflowTemplatesStore = useWorkflowTemplatesStore()
      77         2381 :   const dialogStore = useDialogStore()
      78         2381 :   const { trackFeatureUsed } = useSurveyFeatureTracking('example-workflows')
      79              : 
      80              :   // State
      81         2381 :   const selectedTemplate = ref<WorkflowTemplates | null>(null)
      82         2381 :   let ownedLoadController: AbortController | undefined
      83         2381 :   const loadingTemplateId = computed(
      84              :     () => workflowTemplatesStore.loadingTemplateId
      85              :   )
      86         2381 :   onScopeDispose(() => {
      87            8 :     workflowTemplatesStore.cancelTemplateLoad(ownedLoadController)
      88              :   })
      89              : 
      90              :   // Computed
      91         2381 :   const isTemplatesLoaded = computed(() => workflowTemplatesStore.isLoaded)
      92         2381 :   const allTemplateGroups = computed<TemplateGroup[]>(
      93              :     () => workflowTemplatesStore.groupedTemplates
      94              :   )
      95              : 
      96              :   /**
      97              :    * Loads all template workflows from the API
      98              :    */
      99         2381 :   const loadTemplates = async () => {
     100           28 :     if (!workflowTemplatesStore.isLoaded) {
     101           26 :       await workflowTemplatesStore.loadWorkflowTemplates()
     102              :     }
     103           26 :     return workflowTemplatesStore.isLoaded
     104              :   }
     105              : 
     106              :   /**
     107              :    * Selects the first template category as default
     108              :    */
     109         2381 :   const selectFirstTemplateCategory = () => {
     110            0 :     if (allTemplateGroups.value.length > 0) {
     111            0 :       const firstCategory = allTemplateGroups.value[0].modules[0]
     112            0 :       selectTemplateCategory(firstCategory)
     113              :     }
     114              :   }
     115              : 
     116              :   /**
     117              :    * Selects a template category
     118              :    */
     119         2381 :   const selectTemplateCategory = (category: WorkflowTemplates | null) => {
     120            0 :     selectedTemplate.value = category
     121            0 :     return category !== null
     122              :   }
     123              : 
     124              :   /**
     125              :    * Gets template thumbnail URL
     126              :    */
     127         2381 :   const getTemplateThumbnailUrl = (
     128              :     template: TemplateInfo,
     129              :     sourceModule: string,
     130              :     index = '1'
     131              :   ) => {
     132              :     const basePath =
     133              :       sourceModule === 'default'
     134              :         ? api.fileURL(`/templates/${template.name}`)
     135              :         : api.apiURL(`/workflow_templates/${sourceModule}/${template.name}`)
     136              : 
     137              :     const indexSuffix = sourceModule === 'default' && index ? `-${index}` : ''
     138         1446 :     return `${basePath}${indexSuffix}.${template.mediaSubtype}`
     139              :   }
     140              : 
     141              :   /**
     142              :    * Gets formatted template title
     143              :    */
     144         2381 :   const getTemplateTitle = (template: TemplateInfo, sourceModule: string) => {
     145         1909 :     const fallback = template.title ?? template.name
     146         1909 :     return sourceModule === 'default'
     147              :       ? (template.localizedTitle ?? fallback)
     148              :       : fallback
     149              :   }
     150              : 
     151              :   /**
     152              :    * Gets formatted template description
     153              :    */
     154         2381 :   const getTemplateDescription = (template: TemplateInfo) => {
     155            0 :     return (template.localizedDescription || template.description)
     156              :       .replace(/[-_]/g, ' ')
     157              :       .trim()
     158              :   }
     159              : 
     160           10 :   function resolveTemplateSource(id: string, sourceModule: string) {
     161           10 :     if (sourceModule !== 'all') return sourceModule
     162              : 
     163              :     const group = allTemplateGroups.value.find(
     164              :       (group) =>
     165              :         group.label ===
     166              :         t('templateWorkflows.category.ComfyUI Examples', 'ComfyUI Examples')
     167              :     )
     168              :     const category = group?.modules.find(
     169              :       (module) => module.moduleName === 'all'
     170              :     )
     171              :     const template = category?.templates.find(
     172              :       (template) => template.name === id
     173              :     )
     174           10 :     return template?.sourceModule
     175              :   }
     176              : 
     177            9 :   function startTemplateInputDownloads(id: string, sourceModule: string) {
     178            9 :     if (!isLocalDesktopHost() || sourceModule !== 'default') return
     179              : 
     180            0 :     void resolveTemplateInputAssets(id, () => window.__comfyDesktop2).then(
     181              :       (assets) => {
     182            0 :         startMissingTemplateInputDownloads(id, assets, {
     183              :           getBridge: () => window.__comfyDesktop2,
     184              :           reportError: (error) => {
     185            0 :             reportError(error, {
     186              :               surface: 'graph',
     187              :               errorType: 'workflow_template_input_download_failed',
     188              :               level: 'warning'
     189              :             })
     190              :           }
     191              :         })
     192              :       }
     193              :     )
     194              :   }
     195              : 
     196           10 :   function releasePreparedLoad(controller: AbortController) {
     197           10 :     workflowTemplatesStore.finishTemplateLoad(controller)
     198           10 :     if (ownedLoadController === controller) ownedLoadController = undefined
     199              :   }
     200              : 
     201            1 :   function showTemplateError(detail: string) {
     202            1 :     useToast().error(t('g.error'), { description: detail })
     203              :   }
     204              : 
     205            0 :   function reportTemplateError(error: unknown) {
     206            0 :     reportError(error, {
     207              :       surface: 'graph',
     208              :       errorType: 'error_loading_template'
     209              :     })
     210            0 :     showTemplateError(t('templateWorkflows.error.loading'))
     211              :   }
     212              : 
     213            3 :   async function withPreparedSampleInputs(
     214              :     workflow: ComfyWorkflowJSON,
     215              :     inputs: TemplateInput[],
     216              :     signal: AbortSignal
     217              :   ) {
     218            3 :     const toast = useToast()
     219            3 :     const progressToastId = createToastId()
     220            3 :     let preparedJson = workflow
     221            3 :     const errors: unknown[] = []
     222            3 :     try {
     223            3 :       const result = await prepareTemplateInputs(workflow, inputs, signal, {
     224              :         restoreNamed: useSettingStore().get(
     225              :           'Comfy.Workflow.NamedValuesRestore'
     226              :         ),
     227              :         onStart: () => {
     228            3 :           toast.loading(t('templateWorkflows.preparingMedia'), {
     229              :             id: progressToastId
     230              :           })
     231              :         }
     232              :       })
     233            3 :       errors.push(...result.errors)
     234            3 :       preparedJson = result.workflow
     235            3 :       if (result.uploadedCount > 0) {
     236            3 :         await useAssetsStore().inputAssets.invalidate()
     237            3 :         await app.reloadNodeDefs()
     238              :       }
     239            3 :       signal.throwIfAborted()
     240              :     } catch (error) {
     241            0 :       signal.throwIfAborted()
     242            0 :       errors.push(error)
     243              :     } finally {
     244            3 :       toast.dismiss(progressToastId)
     245              :     }
     246            3 :     if (errors.length) {
     247            0 :       reportError(
     248              :         new AggregateError(errors, 'Template sample preparation failed'),
     249              :         {
     250              :           surface: 'graph',
     251              :           errorType: 'error_loading_template_media'
     252              :         }
     253              :       )
     254            0 :       toast.warning(t('g.warning'), {
     255              :         description: t('templateWorkflows.error.preparingMedia'),
     256              :         duration: 8000
     257              :       })
     258              :     }
     259            3 :     return preparedJson
     260              :   }
     261              : 
     262           10 :   async function loadTemplateData(
     263              :     id: string,
     264              :     sourceModule: string,
     265              :     signal: AbortSignal
     266              :   ) {
     267           10 :     const fetched = await fetchTemplateJson(id, sourceModule, signal)
     268           10 :     signal.throwIfAborted()
     269           10 :     if (!fetched) return null
     270            9 :     const template = workflowTemplatesStore.enhancedTemplates.find(
     271              :       (template) =>
     272              :         template.name === id && template.sourceModule === sourceModule
     273              :     )
     274            9 :     return { ...fetched, template }
     275              :   }
     276              : 
     277            9 :   async function loadTemplateGraph(
     278              :     {
     279              :       json,
     280              :       template
     281              :     }: Pick<PreparedWorkflowTemplate['data'], 'json' | 'template'>,
     282              :     workflowName: string,
     283              :     sourceModule: string
     284              :   ): Promise<TemplateLoadResult> {
     285            9 :     try {
     286            9 :       const loadedWorkflow = await app.loadGraphData(
     287              :         json as ComfyWorkflowJSON,
     288              :         true,
     289              :         true,
     290              :         workflowName,
     291              :         { openSource: 'template' }
     292              :       )
     293            9 :       if (loadedWorkflow === false) return 'graph-failed'
     294            9 :       if (loadedWorkflow === undefined) return 'not-started'
     295              : 
     296            9 :       updateTemplateEducation(template?.isPartnerNode, loadedWorkflow)
     297            9 :       await syncCompletedTemplateInputsWithCurrentGraph()
     298            9 :       if (sourceModule === 'default') trackFeatureUsed()
     299            9 :       return 'loaded'
     300              :     } catch (error) {
     301            0 :       reportTemplateError(error)
     302            0 :       return 'graph-failed'
     303              :     }
     304              :   }
     305              : 
     306           10 :   async function resolveTemplatePayload(
     307              :     id: string,
     308              :     sourceModule: string,
     309              :     signal: AbortSignal
     310              :   ) {
     311           10 :     const source = resolveTemplateSource(id, sourceModule)
     312           10 :     if (!source) {
     313            0 :       showTemplateError(
     314              :         t('templateWorkflows.error.templateNotFound', { templateName: id })
     315              :       )
     316            0 :       return null
     317              :     }
     318           10 :     const data = await loadTemplateData(id, source, signal)
     319           10 :     signal.throwIfAborted()
     320           10 :     if (!data) {
     321            1 :       showTemplateError(t('templateWorkflows.error.loading'))
     322            1 :       return null
     323              :     }
     324            9 :     return { source, data }
     325              :   }
     326              : 
     327           10 :   async function prepareWorkflowTemplate(
     328              :     id: string,
     329              :     sourceModule: string
     330              :   ): Promise<PreparedWorkflowTemplate | null> {
     331           10 :     if (!isTemplatesLoaded.value) {
     332            0 :       showTemplateError(t('templateWorkflows.error.loading'))
     333            0 :       return null
     334              :     }
     335           10 :     const controller = workflowTemplatesStore.startTemplateLoad(id)
     336           10 :     if (!controller) return null
     337           10 :     ownedLoadController = controller
     338           10 :     try {
     339           10 :       const payload = await resolveTemplatePayload(
     340              :         id,
     341              :         sourceModule,
     342              :         controller.signal
     343              :       )
     344           10 :       if (!payload) {
     345            1 :         releasePreparedLoad(controller)
     346            1 :         return null
     347              :       }
     348           10 :       return {
     349              :         id,
     350              :         sourceModule: payload.source,
     351              :         workflowName:
     352              :           payload.source === 'default'
     353              :             ? t(`templateWorkflows.template.${id}`, id)
     354              :             : id,
     355              :         controller,
     356              :         data: payload.data
     357              :       }
     358              :     } catch (error) {
     359            0 :       if (!controller.signal.aborted) reportTemplateError(error)
     360            0 :       releasePreparedLoad(controller)
     361            0 :       return null
     362              :     }
     363              :   }
     364              : 
     365            9 :   async function prepareWorkflowTemplateInputs(
     366              :     data: PreparedWorkflowTemplate['data'],
     367              :     sourceModule: string,
     368              :     signal: AbortSignal,
     369              :     inputAssets: readonly ComfyTemplateInputAsset[]
     370              :   ) {
     371            9 :     const inputs = data.template?.io?.inputs
     372            9 :     if (
     373              :       isCloud ||
     374              :       sourceModule !== 'default' ||
     375              :       !data.strict ||
     376              :       !inputs?.length
     377              :     )
     378            6 :       return data
     379              : 
     380            3 :     return {
     381              :       ...data,
     382              :       json: await withPreparedSampleInputs(
     383              :         data.json,
     384              :         getPendingTemplateSampleInputs(inputs, inputAssets),
     385              :         signal
     386              :       )
     387              :     }
     388              :   }
     389              : 
     390            9 :   async function openPreparedWorkflowTemplate(
     391              :     prepared: PreparedWorkflowTemplate,
     392              :     {
     393              :       downloadAssets,
     394              :       inputAssets = []
     395              :     }: {
     396              :       downloadAssets?: boolean
     397              :       inputAssets?: readonly ComfyTemplateInputAsset[]
     398              :     } = {}
     399              :   ): Promise<TemplateLoadResult> {
     400            9 :     const { id, sourceModule, workflowName, controller, data } = prepared
     401            9 :     try {
     402            9 :       controller.signal.throwIfAborted()
     403            9 :       const shouldDownloadAssets = downloadAssets ?? !isLocalDesktopHost()
     404            9 :       const preparedData = shouldDownloadAssets
     405              :         ? await prepareWorkflowTemplateInputs(
     406              :             data,
     407              :             sourceModule,
     408              :             controller.signal,
     409              :             inputAssets
     410              :           )
     411              :         : data
     412            9 :       controller.signal.throwIfAborted()
     413            9 :       if (!workflowTemplatesStore.startTemplateGraphLoad(controller))
     414            0 :         return 'not-started'
     415              : 
     416            9 :       useTelemetry()?.trackTemplate({
     417              :         workflow_name: id,
     418              :         template_source: sourceModule
     419              :       })
     420              : 
     421            9 :       dialogStore.closeDialog()
     422            9 :       if (shouldDownloadAssets) startTemplateInputDownloads(id, sourceModule)
     423            9 :       return await loadTemplateGraph(preparedData, workflowName, sourceModule)
     424              :     } catch (error) {
     425            0 :       if (!controller.signal.aborted) reportTemplateError(error)
     426            0 :       return 'not-started'
     427              :     } finally {
     428            9 :       releasePreparedLoad(controller)
     429              :     }
     430              :   }
     431              : 
     432          133 :   function discardPreparedWorkflowTemplate(
     433              :     prepared: PreparedWorkflowTemplate | null
     434              :   ) {
     435          133 :     if (!prepared) return
     436            8 :     workflowTemplatesStore.cancelTemplateLoad(prepared.controller)
     437            8 :     if (ownedLoadController === prepared.controller)
     438            8 :       ownedLoadController = undefined
     439              :   }
     440              : 
     441            2 :   async function loadWorkflowTemplate(
     442              :     id: string,
     443              :     sourceModule: string
     444              :   ): Promise<TemplateLoadResult> {
     445            2 :     const prepared = await prepareWorkflowTemplate(id, sourceModule)
     446            2 :     if (!prepared) return 'not-started'
     447            1 :     return openPreparedWorkflowTemplate(prepared)
     448              :   }
     449              : 
     450           10 :   async function fetchTemplateJson(
     451              :     id: string,
     452              :     sourceModule: string,
     453              :     signal: AbortSignal
     454              :   ): Promise<FetchedTemplate | null> {
     455              :     // Default templates provided by frontend are served on this separate endpoint
     456           10 :     const url =
     457              :       sourceModule === 'default'
     458              :         ? api.fileURL(`/templates/${id}.json`)
     459              :         : api.apiURL(`/workflow_templates/${sourceModule}/${id}.json`)
     460              : 
     461           10 :     const response = await fetch(url, { signal })
     462           10 :     if (!response.ok) {
     463            1 :       reportError(`Failed to fetch workflow template ${id}`, {
     464              :         surface: 'graph',
     465              :         errorType: 'error_fetching_workflow_template'
     466              :       })
     467            1 :       return null
     468              :     }
     469              : 
     470            9 :     const json: unknown = await response.json()
     471            9 :     let schemaMismatch: string | undefined
     472            9 :     const validated = await validateComfyWorkflow(json, (detail) => {
     473            0 :       schemaMismatch = detail
     474              :     })
     475            9 :     if (validated) return { strict: true, json: validated }
     476              : 
     477            0 :     const legacy = zLegacyLoadableWorkflow.safeParse(json)
     478            0 :     if (!legacy.success) {
     479            0 :       reportError(`Workflow template ${id} is not a loadable workflow`, {
     480              :         surface: 'graph',
     481              :         errorType: 'error_validating_workflow_template'
     482              :       })
     483            0 :       return null
     484              :     }
     485            0 :     if (schemaMismatch) {
     486            0 :       reportError(new Error(schemaMismatch), {
     487              :         surface: 'graph',
     488              :         errorType: 'error_validating_workflow_template_schema',
     489              :         level: 'warning'
     490              :       })
     491              :     }
     492            0 :     return { strict: false, json: legacy.data }
     493              :   }
     494              : 
     495         2381 :   return {
     496              :     // State
     497              :     selectedTemplate,
     498              :     loadingTemplateId,
     499              : 
     500              :     // Computed
     501              :     isTemplatesLoaded,
     502              :     allTemplateGroups,
     503              : 
     504              :     // Methods
     505              :     loadTemplates,
     506              :     selectFirstTemplateCategory,
     507              :     selectTemplateCategory,
     508              :     getTemplateThumbnailUrl,
     509              :     getTemplateTitle,
     510              :     getTemplateDescription,
     511              :     prepareWorkflowTemplate,
     512              :     openPreparedWorkflowTemplate,
     513              :     discardPreparedWorkflowTemplate,
     514              :     loadWorkflowTemplate
     515              :   }
     516              : }
        

Generated by: LCOV version 2.0-1