LCOV - code coverage report
Current view: top level - src/platform/workflow/templates/utils - templateModelMetadata.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 9.4 % 32 3
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import { fetchModelMetadataWithStatus } from '@/platform/workflowErrors/missingModel/missingModelDownload'
       2              : import type {
       3              :   ModelMetadata,
       4              :   ModelMetadataFetchOutcome
       5              : } from '@/platform/workflowErrors/missingModel/missingModelDownload'
       6              : import type { ModelFile } from '@comfyorg/graph-model/workflowSchema'
       7              : 
       8         2355 : const MAX_CONCURRENT_METADATA_REQUESTS = 6
       9         2355 : const METADATA_REQUEST_TIMEOUT_MS = 10_000
      10         2355 : const failedMetadata: ModelMetadataFetchOutcome = {
      11              :   metadata: { fileSize: null, gatedRepoUrl: null },
      12              :   resolution: 'failed'
      13              : }
      14              : 
      15              : export type TemplateModelMetadataEntry = ModelMetadata & {
      16              :   model: ModelFile
      17              : }
      18              : 
      19              : export type TemplateModelMetadataBatchResult =
      20              :   | {
      21              :       status: 'completed'
      22              :       entries: readonly TemplateModelMetadataEntry[]
      23              :     }
      24              :   | { status: 'aborted' }
      25              : 
      26              : type TemplateModelMetadataOptions = {
      27              :   signal?: AbortSignal
      28              : }
      29              : 
      30            0 : async function fetchMetadataWithTimeout(
      31              :   url: string,
      32              :   signal?: AbortSignal
      33              : ): Promise<ModelMetadataFetchOutcome> {
      34            0 :   const requestController = new AbortController()
      35            0 :   const abortRequest = () => requestController.abort()
      36            0 :   const aborted = new Promise<ModelMetadataFetchOutcome>((resolve) => {
      37            0 :     requestController.signal.addEventListener(
      38              :       'abort',
      39              :       () => resolve(failedMetadata),
      40              :       { once: true }
      41              :     )
      42              :   })
      43              : 
      44            0 :   if (signal?.aborted) abortRequest()
      45            0 :   else signal?.addEventListener('abort', abortRequest, { once: true })
      46              : 
      47            0 :   const timeout = setTimeout(abortRequest, METADATA_REQUEST_TIMEOUT_MS)
      48            0 :   const request = (() => {
      49            0 :     try {
      50            0 :       return requestController.signal.aborted
      51              :         ? Promise.resolve(failedMetadata)
      52              :         : fetchModelMetadataWithStatus(url, {
      53              :             signal: requestController.signal
      54              :           })
      55              :     } catch {
      56            0 :       return Promise.resolve(failedMetadata)
      57              :     }
      58              :   })().catch(() => failedMetadata)
      59              : 
      60            0 :   try {
      61            0 :     return await Promise.race([request, aborted])
      62              :   } finally {
      63            0 :     clearTimeout(timeout)
      64            0 :     signal?.removeEventListener('abort', abortRequest)
      65              :   }
      66              : }
      67              : 
      68            0 : export async function resolveTemplateModelMetadata(
      69              :   models: readonly ModelFile[],
      70              :   { signal }: TemplateModelMetadataOptions = {}
      71              : ): Promise<TemplateModelMetadataBatchResult> {
      72            0 :   if (signal?.aborted) return { status: 'aborted' }
      73              : 
      74            0 :   const urls = [...new Set(models.map((model) => model.url))]
      75            0 :   const metadataByUrl = new Map<string, ModelMetadataFetchOutcome>()
      76            0 :   let nextUrlIndex = 0
      77              : 
      78            0 :   async function resolveNextUrl(): Promise<void> {
      79            0 :     while (!signal?.aborted && nextUrlIndex < urls.length) {
      80            0 :       const url = urls[nextUrlIndex++]
      81            0 :       metadataByUrl.set(url, await fetchMetadataWithTimeout(url, signal))
      82              :     }
      83              :   }
      84              : 
      85            0 :   await Promise.all(
      86              :     Array.from(
      87              :       { length: Math.min(MAX_CONCURRENT_METADATA_REQUESTS, urls.length) },
      88              :       () => resolveNextUrl()
      89              :     )
      90              :   )
      91              : 
      92            0 :   if (signal?.aborted) return { status: 'aborted' }
      93              : 
      94              :   const entries = models.map((model): TemplateModelMetadataEntry => {
      95              :     const outcome = metadataByUrl.get(model.url) ?? failedMetadata
      96            0 :     return { model, ...outcome.metadata }
      97              :   })
      98              : 
      99            0 :   return { status: 'completed', entries }
     100              : }
        

Generated by: LCOV version 2.0-1