LCOV - code coverage report
Current view: top level - src/platform/workflow/sharing/services - workflowShareService.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 30.2 % 106 32
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import type {
       2              :   HubWorkflowDetail,
       3              :   ImportPublishedAssetsRequest,
       4              :   AssetInfo
       5              : } from '@comfyorg/ingest-types'
       6              : import { zGetHubWorkflowResponse } from '@comfyorg/ingest-types/zod'
       7              : 
       8              : import type {
       9              :   PublishPrefill,
      10              :   SharedWorkflowPayload,
      11              :   WorkflowPublishResult,
      12              :   WorkflowPublishStatus
      13              : } from '@/platform/workflow/sharing/types/shareTypes'
      14              : import { useAssetsStore } from '@/stores/assetsStore'
      15              : import type { ThumbnailType } from '@/platform/workflow/sharing/types/comfyHubTypes'
      16              : import type { ComfyWorkflowJSON } from '@comfyorg/graph-model/workflowSchema'
      17              : import {
      18              :   zPublishRecordResponse,
      19              :   zSharedWorkflowResponse
      20              : } from '@/platform/workflow/sharing/schemas/shareSchemas'
      21              : import { api } from '@/scripts/api'
      22              : import { app } from '@/scripts/app'
      23              : 
      24         2355 : class SharedWorkflowLoadError extends Error {
      25              :   readonly status: number | null
      26              : 
      27              :   constructor(status: number | null, message?: string) {
      28            0 :     super(message ?? `Failed to load shared workflow: ${status ?? 'unknown'}`)
      29            0 :     this.name = 'SharedWorkflowLoadError'
      30            0 :     this.status = status
      31              :   }
      32              : 
      33              :   get isRetryable(): boolean {
      34            0 :     if (this.status === null) return true
      35            0 :     return this.status >= 500 || this.status === 408 || this.status === 429
      36              :   }
      37              : }
      38              : 
      39            0 : function mapApiThumbnailType(
      40              :   value: 'image' | 'video' | 'image_comparison' | null | undefined
      41              : ): ThumbnailType | undefined {
      42            0 :   if (!value) return undefined
      43            0 :   if (value === 'image_comparison') return 'imageComparison'
      44            0 :   return value
      45              : }
      46              : 
      47            0 : function extractPrefill(fields: HubWorkflowDetail): PublishPrefill | null {
      48            0 :   const name = fields.name
      49            0 :   const description = fields.description
      50            0 :   const tags = fields.tags?.map((tag) => tag.display_name)
      51            0 :   const models = fields.models?.map((model) => model.name)
      52            0 :   const customNodes = fields.custom_nodes?.map((node) => node.name)
      53            0 :   const thumbnailType = mapApiThumbnailType(fields.thumbnail_type)
      54            0 :   const thumbnailUrl = fields.thumbnail_url
      55            0 :   const thumbnailComparisonUrl = fields.thumbnail_comparison_url
      56            0 :   const sampleImageUrls = fields.sample_image_urls
      57            0 :   const tutorialUrl = fields.tutorial_url
      58            0 :   const metadata =
      59              :     fields.metadata && Object.keys(fields.metadata).length > 0
      60              :       ? fields.metadata
      61              :       : undefined
      62              : 
      63            0 :   if (
      64              :     !name &&
      65              :     !description &&
      66              :     !tags?.length &&
      67              :     !models?.length &&
      68              :     !customNodes?.length &&
      69              :     !thumbnailType &&
      70              :     !thumbnailUrl &&
      71              :     !thumbnailComparisonUrl &&
      72              :     !sampleImageUrls?.length &&
      73              :     !tutorialUrl &&
      74              :     !metadata
      75              :   ) {
      76            0 :     return null
      77              :   }
      78              : 
      79            0 :   return {
      80              :     name,
      81              :     description,
      82              :     tags,
      83              :     models,
      84              :     customNodes,
      85              :     thumbnailType,
      86              :     thumbnailUrl,
      87              :     thumbnailComparisonUrl,
      88              :     sampleImageUrls,
      89              :     tutorialUrl,
      90              :     metadata
      91              :   }
      92              : }
      93              : 
      94            0 : function decodeHubWorkflowPrefill(payload: unknown): PublishPrefill | null {
      95            0 :   const result = zGetHubWorkflowResponse.safeParse(payload)
      96            0 :   if (!result.success) return null
      97            0 :   return extractPrefill(result.data)
      98              : }
      99              : 
     100            0 : function decodePublishRecord(payload: unknown) {
     101            0 :   const result = zPublishRecordResponse.safeParse(payload)
     102            0 :   if (!result.success) return null
     103            0 :   const r = result.data
     104            0 :   return {
     105              :     workflowId: r.workflow_id,
     106              :     shareId: r.share_id ?? undefined,
     107              :     listed: r.listed,
     108              :     publishedAt: parsePublishedAt(r.publish_time),
     109              :     shareUrl: r.share_id ? normalizeShareUrl(r.share_id) : undefined,
     110              :     prefill: null
     111              :   }
     112              : }
     113              : 
     114            2 : function parsePublishedAt(value: string | null | undefined): Date | null {
     115            2 :   if (!value) return null
     116              : 
     117            2 :   const parsed = new Date(value)
     118            2 :   return Number.isNaN(parsed.getTime()) ? null : parsed
     119              : }
     120              : 
     121            0 : function normalizeShareUrl(shareId: string): string {
     122            0 :   const queryString = `share=${encodeURIComponent(shareId)}`
     123            0 :   if (typeof window === 'undefined' || !window.location.origin) {
     124            0 :     return `/?${queryString}`
     125              :   }
     126              : 
     127            0 :   const normalizedUrl = new URL(window.location.href)
     128            0 :   normalizedUrl.search = queryString
     129            0 :   normalizedUrl.hash = ''
     130            0 :   return normalizedUrl.toString()
     131              : }
     132              : 
     133            2 : function decodeSharedWorkflowPayload(
     134              :   payload: unknown
     135              : ): SharedWorkflowPayload | null {
     136            2 :   const result = zSharedWorkflowResponse.safeParse(payload)
     137            2 :   if (!result.success) return null
     138            2 :   const r = result.data
     139            2 :   return {
     140              :     shareId: r.share_id,
     141              :     workflowId: r.workflow_id,
     142              :     name: r.name,
     143              :     listed: r.listed,
     144              :     publishedAt: r.publish_time ? parsePublishedAt(r.publish_time) : null,
     145              :     workflowJson: r.workflow_json as ComfyWorkflowJSON,
     146              :     assets: r.assets
     147              :   }
     148              : }
     149              : 
     150         2355 : const UNPUBLISHED = {
     151              :   isPublished: false,
     152              :   shareId: null,
     153              :   shareUrl: null,
     154              :   publishedAt: null,
     155              :   prefill: null
     156              : } as const satisfies WorkflowPublishStatus
     157              : 
     158         2425 : export function useWorkflowShareService() {
     159            0 :   async function fetchHubWorkflowPrefill(
     160              :     shareId: string
     161              :   ): Promise<PublishPrefill | null> {
     162            0 :     const response = await api.fetchApi(
     163              :       `/hub/workflows/${encodeURIComponent(shareId)}`
     164              :     )
     165            0 :     if (!response.ok) {
     166            0 :       throw new Error(
     167              :         `Failed to fetch hub workflow details: ${response.status}`
     168              :       )
     169              :     }
     170              : 
     171              :     const prefill = decodeHubWorkflowPrefill(await response.json())
     172            0 :     return prefill
     173              :   }
     174              : 
     175            0 :   async function publishWorkflow(
     176              :     workflowPath: string,
     177              :     shareableAssets: AssetInfo[]
     178              :   ): Promise<WorkflowPublishResult> {
     179            0 :     const assetIds = shareableAssets.map((a) => a.id)
     180            0 :     const response = await api.fetchApi(
     181              :       `/userdata/${encodeURIComponent(workflowPath)}/publish`,
     182              :       {
     183              :         method: 'POST',
     184              :         headers: { 'Content-Type': 'application/json' },
     185              :         body: JSON.stringify({ asset_ids: assetIds })
     186              :       }
     187              :     )
     188              : 
     189            0 :     if (!response.ok) {
     190            0 :       throw new Error(`Failed to publish workflow: ${response.status}`)
     191              :     }
     192              : 
     193            0 :     const record = decodePublishRecord(await response.json())
     194            0 :     if (!record?.shareId || !record.publishedAt) {
     195            0 :       throw new Error('Failed to publish workflow: invalid response')
     196              :     }
     197              : 
     198            0 :     return {
     199              :       shareId: record.shareId,
     200              :       shareUrl: normalizeShareUrl(record.shareId),
     201              :       publishedAt: record.publishedAt
     202              :     }
     203              :   }
     204              : 
     205           30 :   async function getPublishStatus(
     206              :     workflowPath: string
     207              :   ): Promise<WorkflowPublishStatus> {
     208           30 :     const response = await api.fetchApi(
     209              :       `/userdata/${encodeURIComponent(workflowPath)}/publish`
     210              :     )
     211           30 :     if (!response.ok) {
     212           30 :       if (response.status === 404) return UNPUBLISHED
     213            0 :       throw new Error(
     214              :         `Failed to fetch publish status: ${response.status} ${response.statusText}`
     215              :       )
     216              :     }
     217              : 
     218              :     const json = await response.json()
     219            0 :     const record = decodePublishRecord(json)
     220           30 :     if (!record || !record.shareId || !record.publishedAt) return UNPUBLISHED
     221              : 
     222            0 :     let prefill: PublishPrefill | null = record.prefill
     223            0 :     if (shouldFetchPrefill(record.listed, prefill)) {
     224            0 :       try {
     225            0 :         prefill = await fetchHubWorkflowPrefill(record.shareId)
     226              :       } catch {
     227            0 :         prefill = null
     228              :       }
     229              :     }
     230              : 
     231            0 :     return {
     232              :       isPublished: true,
     233              :       shareId: record.shareId,
     234              :       shareUrl: normalizeShareUrl(record.shareId),
     235              :       publishedAt: record.publishedAt,
     236              :       prefill
     237              :     }
     238              :   }
     239              : 
     240           11 :   async function getShareableAssets(
     241              :     includingPublic = false
     242              :   ): Promise<AssetInfo[]> {
     243           11 :     if (!app.isGraphReady) return []
     244              : 
     245           11 :     const graph = app.rootGraph
     246           11 :     const { output } = await app.graphToPrompt(graph)
     247           11 :     const { assets } = await api.getShareableAssets(output)
     248              : 
     249           11 :     return includingPublic ? assets : assets.filter((asset) => !asset.public)
     250              :   }
     251              : 
     252            2 :   async function getSharedWorkflow(
     253              :     shareId: string
     254              :   ): Promise<SharedWorkflowPayload> {
     255            2 :     let response: Response
     256            2 :     try {
     257            2 :       response = await api.fetchApi(
     258              :         `/workflows/published/${encodeURIComponent(shareId)}`
     259              :       )
     260              :     } catch {
     261            0 :       throw new SharedWorkflowLoadError(
     262              :         null,
     263              :         'Failed to load shared workflow: network error'
     264              :       )
     265              :     }
     266              : 
     267            2 :     if (!response.ok) {
     268            0 :       throw new SharedWorkflowLoadError(response.status)
     269              :     }
     270              : 
     271            2 :     const workflow = decodeSharedWorkflowPayload(await response.json())
     272            2 :     if (!workflow) {
     273            0 :       throw new Error('Failed to load shared workflow: invalid response')
     274              :     }
     275              : 
     276            2 :     return workflow
     277              :   }
     278              : 
     279            0 :   async function importPublishedAssets(
     280              :     assetIds: string[],
     281              :     shareId?: string
     282              :   ): Promise<void> {
     283            0 :     const body: ImportPublishedAssetsRequest = {
     284              :       published_asset_ids: assetIds,
     285              :       ...(shareId ? { share_id: shareId } : {})
     286              :     }
     287              : 
     288            0 :     const response = await api.fetchApi('/assets/import', {
     289              :       method: 'POST',
     290              :       headers: { 'Content-Type': 'application/json' },
     291              :       body: JSON.stringify(body)
     292              :     })
     293              : 
     294            0 :     if (!response.ok) {
     295            0 :       throw new Error(`Failed to import assets: ${response.status}`)
     296              :     }
     297              : 
     298            0 :     await useAssetsStore().inputAssets.invalidate()
     299              :   }
     300              : 
     301         2425 :   return {
     302              :     publishWorkflow,
     303              :     getPublishStatus,
     304              :     getShareableAssets,
     305              :     getSharedWorkflow,
     306              :     importPublishedAssets
     307              :   }
     308              : }
     309              : 
     310            0 : function shouldFetchPrefill(listed: boolean, prefill: PublishPrefill | null) {
     311            0 :   return listed && !prefill
     312              : }
        

Generated by: LCOV version 2.0-1