LCOV - code coverage report
Current view: top level - src/platform/workspace/api - partnerNodePolicyApi.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 20.0 % 25 5
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import { z } from 'zod'
       2              : 
       3              : import { api } from '@/scripts/api'
       4              : 
       5         2355 : const partnerProviderSchema = z.object({
       6              :   provider_id: z.string(),
       7              :   display_name: z.string(),
       8              :   node_categories: z.array(z.string())
       9              : })
      10              : 
      11         2355 : const partnerProviderCatalogResponseSchema = z.object({
      12              :   providers: z.array(partnerProviderSchema)
      13              : })
      14              : 
      15         2355 : const partnerProviderPolicyEntrySchema = z.object({
      16              :   provider_id: z.string(),
      17              :   enabled: z.boolean()
      18              : })
      19              : 
      20         2355 : const partnerNodePolicyResponseSchema = z.object({
      21              :   enforcement_enabled: z.boolean(),
      22              :   providers: z.array(partnerProviderPolicyEntrySchema)
      23              : })
      24              : 
      25              : export interface PartnerProvider {
      26              :   id: string
      27              :   displayName: string
      28              :   nodeCategories: readonly string[]
      29              : }
      30              : 
      31              : export interface PartnerProviderPolicyEntry {
      32              :   providerId: string
      33              :   enabled: boolean
      34              : }
      35              : 
      36              : export interface PartnerNodePolicy {
      37              :   enforcementEnabled: boolean
      38              :   providers: readonly PartnerProviderPolicyEntry[]
      39              : }
      40              : 
      41         2355 : export class PartnerNodePolicyApiError extends Error {
      42              :   constructor(
      43            0 :     public readonly status: number,
      44              :     message: string
      45              :   ) {
      46            0 :     super(message)
      47            0 :     this.name = 'PartnerNodePolicyApiError'
      48              :   }
      49              : }
      50              : 
      51            0 : function normalizePolicy(
      52              :   data: z.infer<typeof partnerNodePolicyResponseSchema>
      53              : ): PartnerNodePolicy {
      54            0 :   return {
      55              :     enforcementEnabled: data.enforcement_enabled,
      56              :     providers: data.providers.map(({ provider_id, enabled }) => ({
      57              :       providerId: provider_id,
      58              :       enabled
      59              :     }))
      60              :   }
      61              : }
      62              : 
      63            0 : function throwResponseError(response: Response): never {
      64            0 :   throw new PartnerNodePolicyApiError(response.status, response.statusText)
      65              : }
      66              : 
      67            0 : export async function getPartnerProviders(): Promise<PartnerProvider[]> {
      68            0 :   const response = await api.fetchApi('/providers', { cache: 'no-store' })
      69            0 :   if (!response.ok) throwResponseError(response)
      70              : 
      71              :   const data = partnerProviderCatalogResponseSchema.parse(await response.json())
      72            0 :   return data.providers.map(
      73              :     ({ provider_id, display_name, node_categories }) => ({
      74              :       id: provider_id,
      75              :       displayName: display_name,
      76              :       nodeCategories: node_categories
      77              :     })
      78              :   )
      79              : }
      80              : 
      81            0 : export async function getPartnerNodePolicy(): Promise<PartnerNodePolicy | null> {
      82            0 :   const response = await api.fetchApi('/workspace/provider-policy', {
      83              :     cache: 'no-store'
      84              :   })
      85            0 :   if (response.status === 404) return null
      86            0 :   if (!response.ok) throwResponseError(response)
      87              : 
      88            0 :   return normalizePolicy(
      89              :     partnerNodePolicyResponseSchema.parse(await response.json())
      90              :   )
      91              : }
      92              : 
      93            0 : export async function updatePartnerNodePolicy(
      94              :   policy: PartnerNodePolicy
      95              : ): Promise<PartnerNodePolicy> {
      96            0 :   const response = await api.fetchApi('/workspace/provider-policy', {
      97              :     method: 'PUT',
      98              :     headers: { 'Content-Type': 'application/json' },
      99              :     body: JSON.stringify({
     100              :       enforcement_enabled: policy.enforcementEnabled,
     101              :       providers: policy.providers.map(({ providerId, enabled }) => ({
     102              :         provider_id: providerId,
     103              :         enabled
     104              :       }))
     105              :     })
     106              :   })
     107            0 :   if (!response.ok) throwResponseError(response)
     108              : 
     109            0 :   return normalizePolicy(
     110              :     partnerNodePolicyResponseSchema.parse(await response.json())
     111              :   )
     112              : }
        

Generated by: LCOV version 2.0-1