LCOV - code coverage report
Current view: top level - src/platform/billing/composables - usePartnerNodesRunGate.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 100.0 % 24 24
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import { createSharedComposable } from '@vueuse/core'
       2              : import { computed, watch } from 'vue'
       3              : 
       4              : import { useCurrentUser } from '@/composables/auth/useCurrentUser'
       5              : import {
       6              :   scanPartnerNodesInGraph,
       7              :   usePartnerNodesInGraph
       8              : } from '@/composables/node/usePartnerNodesInGraph'
       9              : import { useFeatureFlags } from '@/composables/useFeatureFlags'
      10              : import { firebaseIdentity } from '@/platform/auth/firebaseIdentity'
      11              : import { isCloud } from '@/platform/distribution/types'
      12              : import { reportError } from '@comfyorg/telemetry/reportError'
      13              : import { useApiKeyAuthStore } from '@/stores/apiKeyAuthStore'
      14              : import { useAuthStore } from '@/stores/authStore'
      15              : 
      16              : import type { PartnerNodeInfo } from '@/composables/node/usePartnerNodesInGraph'
      17              : 
      18              : type PartnerRunGate = 'sign-in' | 'none'
      19              : type ApiKeyAuthStore = ReturnType<typeof useApiKeyAuthStore>
      20              : 
      21              : /**
      22              :  * A gate block has no server backstop, so every one is reported. The gate only
      23              :  * blocks when isLoggedIn is false, so the tags read the raw sessions instead:
      24              :  * either being true means a signed-in user was blocked (Sentry alert #16504).
      25              :  */
      26           35 : function reportGateBlocked(
      27              :   trigger: 'run-button' | 'auto-queue',
      28              :   partnerNodes: PartnerNodeInfo[],
      29              :   apiKeyStore: ApiKeyAuthStore
      30              : ) {
      31           35 :   reportError(new Error(`Partner run gate blocked ${trigger}`), {
      32              :     surface: 'billing',
      33              :     errorType: 'partner_run_gate_blocked',
      34              :     level: 'warning',
      35              :     tags: {
      36              :       trigger,
      37              :       hasFirebaseSession: firebaseIdentity.currentUser() !== null,
      38              :       hasStoredApiKey: Boolean(apiKeyStore.getApiKey()),
      39              :       partnerNodeCount: partnerNodes.length
      40              :     },
      41              :     context: { partnerNodeTypes: partnerNodes.map((n) => n.nodeName) }
      42              :   })
      43              : }
      44              : 
      45              : /**
      46              :  * A signed-in user reads as logged-out until Firebase resolves and a stored
      47              :  * API key validates; never gate on that transient state.
      48              :  */
      49         7181 : function isAuthResolving(apiKeyStore: ApiKeyAuthStore): boolean {
      50         7181 :   return (
      51              :     !useAuthStore().isInitialized ||
      52              :     (Boolean(apiKeyStore.getApiKey()) && !apiKeyStore.isAuthenticated)
      53              :   )
      54              : }
      55              : 
      56              : /**
      57              :  * Synchronous, unthrottled gate for the queue boundary: true when a local
      58              :  * signed-out user's current graph contains partner nodes they cannot run.
      59              :  * Every auto-queue path consults this before submitting, so no throttled
      60              :  * reactive snapshot can let a gated graph slip through.
      61              :  */
      62           78 : export function partnerRunGateBlocksAutoQueue(): boolean {
      63              :   if (isCloud) return false
      64           78 :   if (!useFeatureFlags().flags.partnerRunGateEnabled) return false
      65           78 :   const apiKeyStore = useApiKeyAuthStore()
      66           78 :   if (isAuthResolving(apiKeyStore)) return false
      67           78 :   const { isLoggedIn } = useCurrentUser()
      68           78 :   if (isLoggedIn.value) return false
      69           78 :   const partnerNodes = scanPartnerNodesInGraph()
      70           78 :   if (partnerNodes.length === 0) return false
      71            2 :   reportGateBlocked('auto-queue', partnerNodes, apiKeyStore)
      72            2 :   return true
      73              : }
      74              : 
      75              : /**
      76              :  * Decides whether the local/desktop Run button must be replaced because the
      77              :  * graph contains partner nodes the user cannot run yet. Cloud has its own
      78              :  * billing-driven gating (CloudRunButtonWrapper) and always resolves 'none'.
      79              :  */
      80         2356 : export const usePartnerNodesRunGate = createSharedComposable(() => {
      81              :   if (isCloud) {
      82              :     return {
      83              :       gate: computed<PartnerRunGate>(() => 'none'),
      84              :       partnerNodes: computed<PartnerNodeInfo[]>(() => [])
      85              :     }
      86              :   }
      87              : 
      88         2355 :   const { partnerNodes, hasPartnerNodes } = usePartnerNodesInGraph()
      89         2355 :   const { isLoggedIn } = useCurrentUser()
      90         2355 :   const { flags } = useFeatureFlags()
      91         2355 :   const apiKeyStore = useApiKeyAuthStore()
      92              : 
      93         2355 :   const gate = computed<PartnerRunGate>(() =>
      94              :     flags.partnerRunGateEnabled &&
      95              :     !isAuthResolving(apiKeyStore) &&
      96              :     hasPartnerNodes.value &&
      97              :     !isLoggedIn.value
      98              :       ? 'sign-in'
      99              :       : 'none'
     100              :   )
     101              : 
     102         2355 :   watch(
     103              :     gate,
     104              :     (value) => {
     105         2392 :       if (value !== 'sign-in') return
     106           33 :       reportGateBlocked('run-button', partnerNodes.value, apiKeyStore)
     107              :     },
     108              :     { immediate: true }
     109              :   )
     110              : 
     111         2355 :   return { gate, partnerNodes }
     112              : })
        

Generated by: LCOV version 2.0-1