LCOV - code coverage report
Current view: top level - src/platform/updates/common - releaseService.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 75.8 % 33 25
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import type { AxiosError, AxiosResponse } from 'axios'
       2              : import axios from 'axios'
       3              : import { ref } from 'vue'
       4              : 
       5              : import { getComfyApiBaseUrl } from '@/config/comfyApi'
       6              : import type { components, operations } from '@/types/comfyRegistryTypes'
       7              : import { isAbortError } from '@/utils/typeGuardUtil'
       8              : 
       9              : // Use generated types from OpenAPI spec
      10              : export type ReleaseNote = components['schemas']['ReleaseNote']
      11              : type GetReleasesParams = operations['getReleaseNotes']['parameters']['query']
      12              : 
      13              : // Use generated error response type
      14              : type ErrorResponse = components['schemas']['ErrorResponse']
      15              : 
      16         2355 : const releaseApiClient = axios.create({
      17              :   headers: {
      18              :     'Content-Type': 'application/json'
      19              :   }
      20              : })
      21              : 
      22         2355 : export const useReleaseService = () => {
      23         2353 :   const isLoading = ref(false)
      24         2353 :   const error = ref<string | null>(null)
      25              : 
      26         2353 :   const handleApiError = (
      27              :     err: unknown,
      28              :     context: string,
      29              :     routeSpecificErrors?: Record<number, string>
      30              :   ): string => {
      31            2 :     if (!axios.isAxiosError(err))
      32            0 :       return err instanceof Error
      33              :         ? `${context}: ${err.message}`
      34              :         : `${context}: Unknown error occurred`
      35              : 
      36            2 :     const axiosError = err as AxiosError<ErrorResponse>
      37              : 
      38            2 :     if (axiosError.response) {
      39            2 :       const { status, data } = axiosError.response
      40              : 
      41            2 :       if (routeSpecificErrors && routeSpecificErrors[status])
      42            0 :         return routeSpecificErrors[status]
      43              : 
      44            2 :       switch (status) {
      45              :         case 400:
      46            0 :           return `Bad request: ${data.message || 'Invalid input'}`
      47              :         case 401:
      48            0 :           return 'Unauthorized: Authentication required'
      49              :         case 403:
      50            0 :           return `Forbidden: ${data.message || 'Access denied'}`
      51              :         case 404:
      52            0 :           return `Not found: ${data.message || 'Resource not found'}`
      53              :         case 500:
      54            2 :           return `Server error: ${data.message || 'Internal server error'}`
      55              :         default:
      56            0 :           return `${context}: ${data.message || axiosError.message}`
      57              :       }
      58              :     }
      59              : 
      60            0 :     return `${context}: ${axiosError.message}`
      61              :   }
      62              : 
      63         2353 :   const executeApiRequest = async <T>(
      64              :     apiCall: () => Promise<AxiosResponse<T>>,
      65              :     errorContext: string,
      66              :     routeSpecificErrors?: Record<number, string>
      67              :   ): Promise<T | null> => {
      68         4435 :     isLoading.value = true
      69         4435 :     error.value = null
      70              : 
      71         4435 :     try {
      72              :       const response = await apiCall()
      73         4435 :       return response.data
      74              :     } catch (err) {
      75            2 :       if (isAbortError(err)) return null
      76              : 
      77            2 :       error.value = handleApiError(err, errorContext, routeSpecificErrors)
      78            2 :       return null
      79              :     } finally {
      80         4432 :       isLoading.value = false
      81              :     }
      82              :   }
      83              : 
      84         2353 :   const getReleases = async (
      85              :     params: GetReleasesParams,
      86              :     options: { signal?: AbortSignal; deployEnvironment?: string } = {}
      87              :   ): Promise<ReleaseNote[] | null> => {
      88         4435 :     const { signal, deployEnvironment } = options
      89         4435 :     const endpoint = '/releases'
      90              :     const errorContext = 'Failed to get releases'
      91              :     const routeSpecificErrors = {
      92              :       400: 'Invalid project or version parameter'
      93              :     }
      94              : 
      95              :     const apiResponse = await executeApiRequest(
      96              :       () =>
      97              :         releaseApiClient.get<ReleaseNote[]>(endpoint, {
      98              :           baseURL: getComfyApiBaseUrl(),
      99              :           params,
     100              :           signal,
     101              :           headers: deployEnvironment
     102              :             ? { 'Comfy-Env': deployEnvironment }
     103              :             : undefined
     104              :         }),
     105              :       errorContext,
     106              :       routeSpecificErrors
     107              :     )
     108              : 
     109              :     return apiResponse
     110              :   }
     111              : 
     112         2353 :   return {
     113              :     isLoading,
     114              :     error,
     115              :     getReleases
     116              :   }
     117              : }
        

Generated by: LCOV version 2.0-1