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 : }
|