LCOV - code coverage report
Current view: top level - src/platform/assets/utils - resolveModelNodeFromAsset.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 0.0 % 25 0
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import {
       2              :   assetItemSchema,
       3              :   assetFilenameSchema
       4              : } from '@/platform/assets/schemas/assetSchema'
       5              : import type { ModelBrowserAsset } from '@/platform/assets/schemas/assetSchema'
       6              : import {
       7              :   MISSING_TAG,
       8              :   MODELS_TAG
       9              : } from '@/platform/assets/services/assetService'
      10              : import {
      11              :   getAssetFilename,
      12              :   getAssetNodeCategoryCandidates
      13              : } from '@/platform/assets/utils/assetMetadataUtils'
      14              : import { useFeatureFlags } from '@/composables/useFeatureFlags'
      15              : import { useModelToNodeStore } from '@/stores/modelToNodeStore'
      16              : import type { ModelNodeProvider } from '@/stores/modelToNodeStore'
      17              : 
      18              : type ResolveErrorCode = 'INVALID_ASSET' | 'NO_PROVIDER'
      19              : 
      20              : export interface ResolveModelNodeError {
      21              :   code: ResolveErrorCode
      22              :   message: string
      23              :   assetId: string
      24              :   details?: Record<string, unknown>
      25              : }
      26              : 
      27              : interface ResolvedModelNode {
      28              :   provider: ModelNodeProvider
      29              :   filename: string
      30              : }
      31              : 
      32              : type Result<T, E> = { success: true; value: T } | { success: false; error: E }
      33              : 
      34              : /**
      35              :  * Resolves an asset item to the node provider and filename needed to add a
      36              :  * model loader node. Validation failures return error results rather than
      37              :  * throwing, so callers can degrade gracefully in UI contexts.
      38              :  */
      39            0 : export function resolveModelNodeFromAsset(
      40              :   asset: ModelBrowserAsset
      41              : ): Result<ResolvedModelNode, ResolveModelNodeError> {
      42            0 :   const validatedAsset = assetItemSchema.safeParse(asset)
      43              : 
      44            0 :   if (!validatedAsset.success) {
      45            0 :     const errorMessage = validatedAsset.error.issues
      46              :       .map((e) => `${e.path.join('.')}: ${e.message}`)
      47              :       .join(', ')
      48            0 :     console.error('Invalid asset item:', errorMessage)
      49            0 :     return {
      50              :       success: false,
      51              :       error: {
      52              :         code: 'INVALID_ASSET',
      53              :         message: 'Asset schema validation failed',
      54              :         assetId: typeof asset.id === 'string' ? asset.id : 'unknown',
      55              :         details: { validationErrors: errorMessage }
      56              :       }
      57              :     }
      58              :   }
      59              : 
      60            0 :   const validAsset = validatedAsset.data
      61              : 
      62            0 :   const filename = validAsset.loader_path ?? getAssetFilename(validAsset)
      63            0 :   if (
      64              :     filename.length === 0 ||
      65              :     (validAsset.loader_path != null &&
      66              :       !assetFilenameSchema.safeParse(validAsset.loader_path).success)
      67              :   ) {
      68            0 :     console.error(`Asset ${validAsset.id} has an invalid loader filename`)
      69            0 :     return {
      70              :       success: false,
      71              :       error: {
      72              :         code: 'INVALID_ASSET',
      73              :         message:
      74              :           'Invalid filename (expected non-empty string and a safe relative loader path)',
      75              :         assetId: validAsset.id
      76              :       }
      77              :     }
      78              :   }
      79              : 
      80            0 :   if (validAsset.tags.length === 0) {
      81            0 :     console.error(
      82              :       `Asset ${validAsset.id} has no tags defined (expected at least one category tag)`
      83              :     )
      84            0 :     return {
      85              :       success: false,
      86              :       error: {
      87              :         code: 'INVALID_ASSET',
      88              :         message: 'Asset has no tags defined',
      89              :         assetId: validAsset.id
      90              :       }
      91              :     }
      92              :   }
      93              : 
      94            0 :   const { flags } = useFeatureFlags()
      95            0 :   const candidates = getAssetNodeCategoryCandidates(
      96              :     { ...validAsset, browserCategories: asset.browserCategories },
      97              :     flags.supportsModelTypeTags
      98              :   )
      99            0 :   if (candidates.length === 0) {
     100            0 :     console.error(
     101              :       `Asset ${validAsset.id} has no valid category tag. Available tags: ${validAsset.tags.join(', ')} (expected tag other than '${MODELS_TAG}' or '${MISSING_TAG}')`
     102              :     )
     103            0 :     return {
     104              :       success: false,
     105              :       error: {
     106              :         code: 'INVALID_ASSET',
     107              :         message: 'Asset has no valid category tag',
     108              :         assetId: validAsset.id,
     109              :         details: { availableTags: validAsset.tags }
     110              :       }
     111              :     }
     112              :   }
     113              : 
     114            0 :   const modelToNodeStore = useModelToNodeStore()
     115            0 :   const resolved = candidates
     116              :     .map((category) => ({
     117              :       category,
     118              :       provider: modelToNodeStore.getNodeProvider(category)
     119              :     }))
     120              :     .find((candidate) => candidate.provider !== undefined)
     121              : 
     122            0 :   if (!resolved?.provider) {
     123            0 :     console.error(
     124              :       `No node provider registered for category: ${candidates.join(', ')}`
     125              :     )
     126            0 :     return {
     127              :       success: false,
     128              :       error: {
     129              :         code: 'NO_PROVIDER',
     130              :         message: `No node provider registered for category: ${candidates.join(', ')}`,
     131              :         assetId: validAsset.id,
     132              :         details: { candidates }
     133              :       }
     134              :     }
     135              :   }
     136              : 
     137            0 :   return { success: true, value: { provider: resolved.provider, filename } }
     138              : }
        

Generated by: LCOV version 2.0-1