diff --git a/src/platform/customNodes/manager/components/manager/ManagerDialog.vue b/src/platform/customNodes/manager/components/manager/ManagerDialog.vue index fceba8861a8..65bb440e949 100644 --- a/src/platform/customNodes/manager/components/manager/ManagerDialog.vue +++ b/src/platform/customNodes/manager/components/manager/ManagerDialog.vue @@ -469,6 +469,7 @@ const { displayPacks, isSortable, isLoading: isTabLoading, + hasUpdateError, workflowPacks } = useManagerDisplayPacks( selectedNavId, @@ -511,7 +512,11 @@ const isManagerErrorRelevant = computed(() => { }) const emptyStateTitle = computed(() => { - if (isManagerErrorRelevant.value || isSearchFailed.value) + if ( + isManagerErrorRelevant.value || + isSearchFailed.value || + hasUpdateError.value + ) return t('manager.errorConnecting') if (trimmedSearchQuery.value) return t('manager.noResultsFound') @@ -524,7 +529,11 @@ const emptyStateTitle = computed(() => { }) const emptyStateMessage = computed(() => { - if (isManagerErrorRelevant.value || isSearchFailed.value) + if ( + isManagerErrorRelevant.value || + isSearchFailed.value || + hasUpdateError.value + ) return t('manager.tryAgainLater') if (trimmedSearchQuery.value) return t('manager.tryDifferentSearch') diff --git a/src/platform/customNodes/manager/composables/nodePack/packUpdateStatus.test.ts b/src/platform/customNodes/manager/composables/nodePack/packUpdateStatus.test.ts index 89bee6d59d8..0ffa5b796fa 100644 --- a/src/platform/customNodes/manager/composables/nodePack/packUpdateStatus.test.ts +++ b/src/platform/customNodes/manager/composables/nodePack/packUpdateStatus.test.ts @@ -8,7 +8,10 @@ import { } from '@/platform/customNodes/manager/composables/nodePack/packUpdateStatus' type NodePack = components['schemas']['Node'] -type ComfyManagerStore = ReturnType +type ComfyManagerStore = Pick< + ReturnType, + 'isPackInstalled' | 'getInstalledPackVersion' +> const createPack = ( id: string | undefined, @@ -16,17 +19,18 @@ const createPack = ( ): NodePack => ({ id, name: `Pack ${id}`, - latest_version: latestVersion ? { version: latestVersion } : undefined + latest_version: latestVersion + ? { version: latestVersion, status: 'NodeVersionStatusActive' } + : undefined }) const createStore = ( installed: Record -): ComfyManagerStore => - ({ - isPackInstalled: (id: string | undefined) => - id !== undefined && id in installed, - getInstalledPackVersion: (id: string) => installed[id] - }) as unknown as ComfyManagerStore +): ComfyManagerStore => ({ + isPackInstalled: (id: string | undefined) => + id !== undefined && id in installed, + getInstalledPackVersion: (id: string) => installed[id] +}) describe('isNightlyVersion', () => { it('is true for a non-semver git hash version', () => { @@ -103,4 +107,43 @@ describe('getPackUpdateStatus', () => { expect(status.latestVersion).toBeUndefined() expect(status.isUpdateAvailable).toBe(false) }) + it.for([ + 'NodeVersionStatusPending', + 'NodeVersionStatusFlagged', + 'NodeVersionStatusBanned' + ] as const)( + 'does not advertise a %s release as a default update', + (status) => { + const pack = createPack('pack-1', '3.0.0') + pack.latest_version = { version: '3.0.0', status } + expect( + getPackUpdateStatus(pack, createStore({ 'pack-1': '2.0.0' })) + .isUpdateAvailable + ).toBe(false) + } + ) + + it.for([ + ['1.0.0', true], + ['2.0.0', false], + ['2.5.0', false] + ] as const)( + 'compares installed %s with the resolved Active release', + ([installed, expected]) => { + const pack: NodePack = { + id: 'pack-1', + latest_version: { version: '3.0.0', status: 'NodeVersionStatusFlagged' } + } + const status = getPackUpdateStatus( + pack, + createStore({ 'pack-1': installed }), + { + version: '2.0.0', + status: 'NodeVersionStatusActive' + } + ) + expect(status.latestVersion).toBe('2.0.0') + expect(status.isUpdateAvailable).toBe(expected) + } + ) }) diff --git a/src/platform/customNodes/manager/composables/nodePack/packUpdateStatus.ts b/src/platform/customNodes/manager/composables/nodePack/packUpdateStatus.ts index 0a3411e83e8..ae5680d6fc7 100644 --- a/src/platform/customNodes/manager/composables/nodePack/packUpdateStatus.ts +++ b/src/platform/customNodes/manager/composables/nodePack/packUpdateStatus.ts @@ -4,7 +4,10 @@ import type { components } from '@/types/comfyRegistryTypes' import type { useComfyManagerStore } from '@/platform/customNodes/manager/stores/comfyManagerStore' type NodePack = components['schemas']['Node'] -type ComfyManagerStore = ReturnType +type ComfyManagerStore = Pick< + ReturnType, + 'isPackInstalled' | 'getInstalledPackVersion' +> interface PackUpdateStatus { isInstalled: boolean @@ -22,18 +25,17 @@ export function isNightlyVersion(version: string | undefined): boolean { return !!version && !valid(version) } -/** - * Derives the update status of a pack from its installed version and the - * latest release version advertised by the registry. A nightly build is never - * "outdated" since git hashes cannot be ordered. - */ export function getPackUpdateStatus( pack: NodePack | undefined, - managerStore: ComfyManagerStore + managerStore: ComfyManagerStore, + updateVersion = pack?.latest_version ): PackUpdateStatus { const isInstalled = managerStore.isPackInstalled(pack?.id) const installedVersion = managerStore.getInstalledPackVersion(pack?.id ?? '') - const latestVersion = pack?.latest_version?.version + const latestVersion = + updateVersion?.status === 'NodeVersionStatusActive' + ? updateVersion.version + : undefined const isNightly = isNightlyVersion(installedVersion) const isUpdateAvailable = diff --git a/src/platform/customNodes/manager/composables/nodePack/usePackUpdateStatus.test.ts b/src/platform/customNodes/manager/composables/nodePack/usePackUpdateStatus.test.ts index b2aff35f0ab..1da796aad72 100644 --- a/src/platform/customNodes/manager/composables/nodePack/usePackUpdateStatus.test.ts +++ b/src/platform/customNodes/manager/composables/nodePack/usePackUpdateStatus.test.ts @@ -11,7 +11,7 @@ function makePack(overrides: Partial = {}): NodePack { return { id: 'pack-1', name: 'Pack', - latest_version: { version: '2.0.0' }, + latest_version: { version: '2.0.0', status: 'NodeVersionStatusActive' }, ...overrides } } @@ -85,12 +85,18 @@ describe('usePackUpdateStatus', () => { }) it('recomputes when the source pack changes', async () => { - const source = ref(makePack({ latest_version: { version: '1.0.0' } })) + const source = ref( + makePack({ + latest_version: { version: '1.0.0', status: 'NodeVersionStatusActive' } + }) + ) const { isUpdateAvailable } = usePackUpdateStatus(source) expect(isUpdateAvailable.value).toBe(false) - source.value = makePack({ latest_version: { version: '3.0.0' } }) + source.value = makePack({ + latest_version: { version: '3.0.0', status: 'NodeVersionStatusActive' } + }) await nextTick() expect(isUpdateAvailable.value).toBe(true) diff --git a/src/platform/customNodes/manager/composables/nodePack/usePackUpdateStatus.ts b/src/platform/customNodes/manager/composables/nodePack/usePackUpdateStatus.ts index 5be7e61b520..b79f61bcc50 100644 --- a/src/platform/customNodes/manager/composables/nodePack/usePackUpdateStatus.ts +++ b/src/platform/customNodes/manager/composables/nodePack/usePackUpdateStatus.ts @@ -3,19 +3,17 @@ import { computed, toValue } from 'vue' import type { components } from '@/types/comfyRegistryTypes' import { useComfyManagerStore } from '@/platform/customNodes/manager/stores/comfyManagerStore' -import { getPackUpdateStatus } from '@/platform/customNodes/manager/composables/nodePack/packUpdateStatus' +import { usePackUpdateStatuses } from '@/platform/customNodes/manager/composables/nodePack/usePackUpdateStatuses' export const usePackUpdateStatus = ( nodePackSource: MaybeRefOrGetter ) => { const managerStore = useComfyManagerStore() - // Use toValue to unwrap the source reactively inside computeds const nodePack = computed(() => toValue(nodePackSource)) - const status = computed(() => - getPackUpdateStatus(nodePack.value, managerStore) - ) + const { getStatus } = usePackUpdateStatuses(() => [nodePack.value]) + const status = computed(() => getStatus(nodePack.value)) const isInstalled = computed(() => status.value.isInstalled) const isEnabled = computed(() => @@ -26,11 +24,6 @@ export const usePackUpdateStatus = ( const isNightlyPack = computed(() => status.value.isNightly) const isUpdateAvailable = computed(() => status.value.isUpdateAvailable) - /** - * Nightly packs can always "try update" since we cannot compare git hashes - * to determine if an update is actually available. This allows users to - * pull the latest changes from the repository. - */ const canTryNightlyUpdate = computed( () => isInstalled.value && isEnabled.value && isNightlyPack.value ) diff --git a/src/platform/customNodes/manager/composables/nodePack/usePackUpdateStatuses.test.ts b/src/platform/customNodes/manager/composables/nodePack/usePackUpdateStatuses.test.ts new file mode 100644 index 00000000000..20ceb9ad41f --- /dev/null +++ b/src/platform/customNodes/manager/composables/nodePack/usePackUpdateStatuses.test.ts @@ -0,0 +1,199 @@ +import { beforeEach, expect, it, onTestFinished, vi } from 'vitest' +import { effectScope, nextTick, ref } from 'vue' + +import * as registry from '@/services/comfyRegistryService' +import { useComfyRegistryStore } from '@/stores/comfyRegistryStore' +import type { components } from '@/types/comfyRegistryTypes' +import { useComfyManagerStore } from '@/platform/customNodes/manager/stores/comfyManagerStore' +import { usePackUpdateStatuses } from '@/platform/customNodes/manager/composables/nodePack/usePackUpdateStatuses' +import { usePackUpdateStatus } from '@/platform/customNodes/manager/composables/nodePack/usePackUpdateStatus' + +type NodePack = components['schemas']['Node'] +type NodeVersion = components['schemas']['NodeVersion'] + +const flaggedPack: NodePack = { + id: 'sample-pack', + latest_version: { version: '3.0.0', status: 'NodeVersionStatusFlagged' } +} + +function deferred() { + let resolve: (value: T) => void = () => {} + const promise = new Promise((settle) => { + resolve = settle + }) + return { promise, resolve } +} + +function setupVersions() { + const service = registry.useComfyRegistryService() + vi.spyOn(registry, 'useComfyRegistryService').mockReturnValue(service) + return vi.spyOn(service, 'getPackVersions') +} + +function scoped(create: () => T) { + const scope = effectScope() + onTestFinished(() => scope.stop()) + const result = scope.run(create) + if (!result) throw new Error('Scope did not initialize') + return { result, stop: () => scope.stop() } +} + +beforeEach(() => { + vi.mocked(useComfyManagerStore().isPackInstalled).mockReturnValue(true) + vi.mocked(useComfyManagerStore().getInstalledPackVersion).mockReturnValue( + '1.0.0' + ) +}) + +it.for([ + { version: '1.0.0', available: false }, + { version: '2.0.0', available: true }, + { version: '2.1.0-beta.1', available: true }, + { version: undefined, available: false } +])( + 'uses the default update target $version beneath a flagged release', + async ({ version, available }) => { + const getVersions = setupVersions().mockResolvedValue( + version ? [{ version, status: 'NodeVersionStatusActive' }] : [] + ) + const { result } = scoped(() => usePackUpdateStatuses([flaggedPack])) + const { result: badge } = scoped(() => usePackUpdateStatus(flaggedPack)) + + expect(result.isLoading.value).toBe(true) + expect(badge.isUpdateAvailable.value).toBe(false) + await vi.waitFor(() => expect(result.isLoading.value).toBe(false)) + + expect(result.getStatus(flaggedPack).isUpdateAvailable).toBe(available) + expect(badge.isUpdateAvailable.value).toBe(available) + expect(badge.latestVersion.value).toBe(version) + expect(getVersions).toHaveBeenCalledExactlyOnceWith( + 'sample-pack', + { + statuses: ['NodeVersionStatusActive'] + }, + expect.any(AbortSignal) + ) + expect(flaggedPack.latest_version?.status).toBe('NodeVersionStatusFlagged') + } +) + +it('does not request versions for Active, uninstalled or nightly packs', () => { + const getVersions = setupVersions() + const activePack: NodePack = { + id: 'active', + latest_version: { version: '2.0.0', status: 'NodeVersionStatusActive' } + } + vi.mocked(useComfyManagerStore().isPackInstalled).mockImplementation( + (id) => id !== 'uninstalled' + ) + vi.mocked(useComfyManagerStore().getInstalledPackVersion).mockImplementation( + (id) => (id === 'nightly' ? 'abc1234' : '1.0.0') + ) + const { result } = scoped(() => + usePackUpdateStatuses([ + activePack, + { ...flaggedPack, id: 'uninstalled' }, + { ...flaggedPack, id: 'nightly' } + ]) + ) + expect(result.getStatus(activePack).isUpdateAvailable).toBe(true) + expect(result.isLoading.value).toBe(false) + expect(getVersions).not.toHaveBeenCalled() +}) + +it('reports lookup failures and retries when the view is reopened', async () => { + const getVersions = setupVersions() + .mockResolvedValueOnce(null) + .mockResolvedValueOnce([ + { version: '2.0.0', status: 'NodeVersionStatusActive' } + ]) + const first = scoped(() => usePackUpdateStatuses([flaggedPack])) + await vi.waitFor(() => expect(first.result.hasError.value).toBe(true)) + expect(first.result.getStatus(flaggedPack).isUpdateAvailable).toBe(false) + first.stop() + + const second = scoped(() => usePackUpdateStatuses([flaggedPack])) + await vi.waitFor(() => expect(second.result.isLoading.value).toBe(false)) + expect(second.result.hasError.value).toBe(false) + expect(second.result.getStatus(flaggedPack).isUpdateAvailable).toBe(true) + expect(getVersions).toHaveBeenCalledTimes(2) +}) + +it('preserves successful update lookups when another pack fails', async () => { + const failedPack = { ...flaggedPack, id: 'unavailable-pack' } + const responses = new Map([ + ['sample-pack', [{ version: '2.0.0', status: 'NodeVersionStatusActive' }]], + ['unavailable-pack', null] + ]) + setupVersions().mockImplementation( + async (id) => responses.get(id ?? '') ?? null + ) + const { result } = scoped(() => + usePackUpdateStatuses([flaggedPack, failedPack]) + ) + + await vi.waitFor(() => expect(result.isLoading.value).toBe(false)) + + expect(result.hasError.value).toBe(true) + expect(result.getStatus(flaggedPack).isUpdateAvailable).toBe(true) + expect(result.getStatus(failedPack).isUpdateAvailable).toBe(false) +}) + +it('does not let a closed view cancel a shared version request', async () => { + const pending = deferred() + const getVersions = setupVersions().mockReturnValue(pending.promise) + const first = scoped(() => usePackUpdateStatuses([flaggedPack])) + const second = scoped(() => usePackUpdateStatuses([flaggedPack])) + first.stop() + pending.resolve([{ version: '2.0.0', status: 'NodeVersionStatusActive' }]) + await vi.waitFor(() => expect(second.result.isLoading.value).toBe(false)) + expect(second.result.getStatus(flaggedPack).isUpdateAvailable).toBe(true) + expect(getVersions).toHaveBeenCalledTimes(1) +}) + +it('ignores an old lookup after the source pack changes', async () => { + vi.useFakeTimers() + const pending = deferred() + setupVersions() + .mockReturnValueOnce(pending.promise) + .mockResolvedValueOnce([ + { version: '1.0.0', status: 'NodeVersionStatusActive' } + ]) + const packs = ref([flaggedPack]) + const { result } = scoped(() => usePackUpdateStatuses(packs)) + packs.value = [{ ...flaggedPack, id: 'other-pack' }] + await nextTick() + await vi.waitFor(() => expect(result.isLoading.value).toBe(false)) + pending.resolve([{ version: '2.0.0', status: 'NodeVersionStatusActive' }]) + await pending.promise + await nextTick() + await vi.advanceTimersByTimeAsync(0) + expect(result.getStatus(flaggedPack).isUpdateAvailable).toBe(false) +}) + +it('refreshes the target when advertised metadata changes or caches are cleared', async () => { + const getVersions = setupVersions().mockResolvedValue([ + { version: '1.0.0', status: 'NodeVersionStatusActive' } + ]) + const packs = ref([flaggedPack]) + const { result } = scoped(() => usePackUpdateStatuses(packs)) + await vi.waitFor(() => expect(result.isLoading.value).toBe(false)) + getVersions.mockResolvedValue([ + { version: '2.0.0', status: 'NodeVersionStatusActive' } + ]) + packs.value = [ + { + ...flaggedPack, + latest_version: { version: '4.0.0', status: 'NodeVersionStatusPending' } + } + ] + await nextTick() + await vi.waitFor(() => + expect(result.getStatus(packs.value[0]).isUpdateAvailable).toBe(true) + ) + expect(getVersions).toHaveBeenCalledTimes(2) + useComfyRegistryStore().clearCache() + const reopened = scoped(() => usePackUpdateStatuses(packs)) + await vi.waitFor(() => expect(reopened.result.isLoading.value).toBe(false)) + expect(getVersions).toHaveBeenCalledTimes(3) +}) diff --git a/src/platform/customNodes/manager/composables/nodePack/usePackUpdateStatuses.ts b/src/platform/customNodes/manager/composables/nodePack/usePackUpdateStatuses.ts new file mode 100644 index 00000000000..79612419130 --- /dev/null +++ b/src/platform/customNodes/manager/composables/nodePack/usePackUpdateStatuses.ts @@ -0,0 +1,90 @@ +import { computed, shallowRef, toValue, watch } from 'vue' +import type { MaybeRefOrGetter } from 'vue' + +import { useComfyRegistryStore } from '@/stores/comfyRegistryStore' +import type { components } from '@/types/comfyRegistryTypes' +import { useComfyManagerStore } from '@/platform/customNodes/manager/stores/comfyManagerStore' +import { getPackUpdateStatus } from '@/platform/customNodes/manager/composables/nodePack/packUpdateStatus' + +type NodePack = components['schemas']['Node'] +type NodeVersion = components['schemas']['NodeVersion'] +type LookupState = + | { status: 'loading' } + | { + status: 'ready' | 'error' + versions: Map + } + +export function usePackUpdateStatuses(packs: MaybeRefOrGetter) { + const manager = useComfyManagerStore() + const registry = useComfyRegistryStore() + const state = shallowRef({ + status: 'ready', + versions: new Map() + }) + const unresolvedPacks = computed(() => + toValue(packs).filter((pack) => { + const status = getPackUpdateStatus(pack, manager) + return ( + pack.id && + status.isInstalled && + !status.isNightly && + pack.latest_version && + pack.latest_version.status !== 'NodeVersionStatusActive' + ) + }) + ) + + watch( + unresolvedPacks, + async (candidates, _, onCleanup) => { + const controller = new AbortController() + onCleanup(() => controller.abort()) + if (!candidates.length) { + state.value = { status: 'ready', versions: new Map() } + return + } + state.value = { status: 'loading' } + const versions = new Map() + const results = await Promise.all( + candidates.map(async (pack) => { + if (!pack.id) return true + const params = { + id: pack.id, + advertisedVersion: pack.latest_version?.version, + advertisedStatus: pack.latest_version?.status + } + const releases = await registry.getActivePackVersions.call(params) + if (releases === null) { + registry.getActivePackVersions.evict(params) + return false + } + versions.set(pack.id, releases[0]) + return true + }) + ) + if (!controller.signal.aborted) { + state.value = { + status: results.every(Boolean) ? 'ready' : 'error', + versions + } + } + }, + { immediate: true } + ) + + return { + getStatus: (pack: NodePack) => + getPackUpdateStatus( + pack, + manager, + pack.latest_version?.status === 'NodeVersionStatusActive' + ? pack.latest_version + : state.value.status === 'loading' + ? undefined + : state.value.versions.get(pack.id ?? '') + ), + isLoading: computed(() => state.value.status === 'loading'), + hasError: computed(() => state.value.status === 'error') + } +} diff --git a/src/platform/customNodes/manager/composables/nodePack/useUpdateAvailableNodes.test.ts b/src/platform/customNodes/manager/composables/nodePack/useUpdateAvailableNodes.test.ts index feb49b68ac4..b3c45122eac 100644 --- a/src/platform/customNodes/manager/composables/nodePack/useUpdateAvailableNodes.test.ts +++ b/src/platform/customNodes/manager/composables/nodePack/useUpdateAvailableNodes.test.ts @@ -62,17 +62,17 @@ describe('useUpdateAvailableNodes', () => { { id: 'pack-1', name: 'Outdated Pack', - latest_version: { version: '2.0.0' } + latest_version: { version: '2.0.0', status: 'NodeVersionStatusActive' } } as components['schemas']['Node'], { id: 'pack-2', name: 'Up to Date Pack', - latest_version: { version: '1.0.0' } + latest_version: { version: '1.0.0', status: 'NodeVersionStatusActive' } } as components['schemas']['Node'], { id: 'pack-3', name: 'Nightly Pack', - latest_version: { version: '1.5.0' } + latest_version: { version: '1.5.0', status: 'NodeVersionStatusActive' } } as components['schemas']['Node'], { id: 'pack-4', diff --git a/src/platform/customNodes/manager/composables/nodePack/useUpdateAvailableNodes.ts b/src/platform/customNodes/manager/composables/nodePack/useUpdateAvailableNodes.ts index af5670340f3..b83597196ba 100644 --- a/src/platform/customNodes/manager/composables/nodePack/useUpdateAvailableNodes.ts +++ b/src/platform/customNodes/manager/composables/nodePack/useUpdateAvailableNodes.ts @@ -3,7 +3,7 @@ import { computed, onMounted } from 'vue' import type { components } from '@/types/comfyRegistryTypes' import { useInstalledPacks } from '@/platform/customNodes/manager/composables/nodePack/useInstalledPacks' import { useComfyManagerStore } from '@/platform/customNodes/manager/stores/comfyManagerStore' -import { getPackUpdateStatus } from '@/platform/customNodes/manager/composables/nodePack/packUpdateStatus' +import { usePackUpdateStatuses } from '@/platform/customNodes/manager/composables/nodePack/usePackUpdateStatuses' /** * Composable to find NodePacks that have updates available @@ -14,31 +14,33 @@ export const useUpdateAvailableNodes = () => { const { installedPacks, isLoading, error, startFetchInstalled } = useInstalledPacks() + const { + getStatus, + isLoading: isLoadingVersions, + hasError + } = usePackUpdateStatuses(installedPacks) + const isOutdatedPack = (pack: components['schemas']['Node']) => - getPackUpdateStatus(pack, comfyManagerStore).isUpdateAvailable + getStatus(pack).isUpdateAvailable const filterOutdatedPacks = (packs: components['schemas']['Node'][]) => packs.filter(isOutdatedPack) - // Filter only outdated packs from installed packs const updateAvailableNodePacks = computed(() => { if (!installedPacks.value.length) return [] return filterOutdatedPacks(installedPacks.value) }) - // Filter only enabled outdated packs const enabledUpdateAvailableNodePacks = computed(() => { return updateAvailableNodePacks.value.filter((pack) => comfyManagerStore.isPackEnabled(pack.id) ) }) - // Check if there are any enabled outdated packs const hasUpdateAvailable = computed(() => { return enabledUpdateAvailableNodePacks.value.length > 0 }) - // Check if there are disabled packs with updates const hasDisabledUpdatePacks = computed(() => { return ( updateAvailableNodePacks.value.length > @@ -46,7 +48,6 @@ export const useUpdateAvailableNodes = () => { ) }) - // Automatically fetch installed pack data when composable is used onMounted(async () => { if (!installedPacks.value.length && !isLoading.value) { await startFetchInstalled() @@ -58,7 +59,11 @@ export const useUpdateAvailableNodes = () => { enabledUpdateAvailableNodePacks, hasUpdateAvailable, hasDisabledUpdatePacks, - isLoading, - error + isLoading: computed(() => isLoading.value || isLoadingVersions.value), + error: computed( + () => + error.value ?? + (hasError.value ? 'Failed to load update versions' : null) + ) } } diff --git a/src/platform/customNodes/manager/composables/useManagerDisplayPacks.ts b/src/platform/customNodes/manager/composables/useManagerDisplayPacks.ts index 71ed94d027f..ea0454e3230 100644 --- a/src/platform/customNodes/manager/composables/useManagerDisplayPacks.ts +++ b/src/platform/customNodes/manager/composables/useManagerDisplayPacks.ts @@ -13,7 +13,7 @@ import { PACK_SORTABLE_FIELDS, getPackSortValue } from '@/platform/customNodes/manager/utils/nodePackSort' -import { getPackUpdateStatus } from '@/platform/customNodes/manager/composables/nodePack/packUpdateStatus' +import { usePackUpdateStatuses } from '@/platform/customNodes/manager/composables/nodePack/usePackUpdateStatuses' type NodePack = components['schemas']['Node'] @@ -59,7 +59,6 @@ export function useManagerDisplayPacks( ) } - // Filter functions const filterNotInstalled = (packs: NodePack[]) => packs.filter((p) => !comfyManagerStore.isPackInstalled(p.id)) @@ -72,12 +71,21 @@ export function useManagerDisplayPacks( ) ) + const { + getStatus, + isLoading: isLoadingVersions, + hasError: hasUpdateError + } = usePackUpdateStatuses(() => + tabType.value === ManagerTab.UpdateAvailable + ? isEmptySearch.value + ? installedPacks.value + : toValue(searchResults) + : [] + ) + const filterOutdated = (packs: NodePack[]) => - packs.filter( - (p) => getPackUpdateStatus(p, comfyManagerStore).isUpdateAvailable - ) + packs.filter((p) => getStatus(p).isUpdateAvailable) - // Data fetching triggers using whenever const needsInstalledPacks = computed(() => [ ManagerTab.AllInstalled, @@ -92,8 +100,6 @@ export function useManagerDisplayPacks( ) ) - // Sorting only applies to fully-fetched tabs with no active search; paged - // search/listing results (All, NotInstalled) are shown in the API's order. const isSortable = computed( () => isEmptySearch.value && @@ -116,7 +122,6 @@ export function useManagerDisplayPacks( () => startFetchWorkflowPacks() ) - // For Missing tab, also need installed packs to determine what's missing whenever( () => tabType.value === ManagerTab.Missing && @@ -125,7 +130,6 @@ export function useManagerDisplayPacks( () => startFetchInstalled() ) - // Single computed for display packs - replaces 7 watches const displayPacks = computed(() => { const tab = tabType.value const hasSearch = !isEmptySearch.value @@ -171,7 +175,6 @@ export function useManagerDisplayPacks( } }) - // Loading state - single computed const isLoading = computed(() => { const tab = tabType.value if ( @@ -181,7 +184,10 @@ export function useManagerDisplayPacks( ManagerTab.Conflicting ].includes(tab as ManagerTab) ) { - return isLoadingInstalled.value + return ( + isLoadingInstalled.value || + (tab === ManagerTab.UpdateAvailable && isLoadingVersions.value) + ) } if ([ManagerTab.Workflow, ManagerTab.Missing].includes(tab as ManagerTab)) { return isLoadingWorkflow.value @@ -195,6 +201,7 @@ export function useManagerDisplayPacks( return { displayPacks, + hasUpdateError, isSortable, isLoading, isLoadingInstalled, diff --git a/src/stores/comfyRegistryStore.ts b/src/stores/comfyRegistryStore.ts index 8d65c3e8e84..63095423544 100644 --- a/src/stores/comfyRegistryStore.ts +++ b/src/stores/comfyRegistryStore.ts @@ -34,17 +34,11 @@ export const useComfyRegistryStore = defineStore('comfyRegistry', () => { maxSize: PACK_BY_ID_CACHE_SIZE }) - /** - * Get a list of all node packs from the registry - */ const listAllPacks = useCachedRequest( registryService.listAllPacks, { maxSize: PACK_LIST_CACHE_SIZE } ) - /** - * Get a pack by its ID from the registry - */ const getPackById = useCachedRequest( async (params) => { if (!params) return null @@ -53,9 +47,6 @@ export const useComfyRegistryStore = defineStore('comfyRegistry', () => { { maxSize: PACK_BY_ID_CACHE_SIZE } ) - /** - * Get a list of packs by their IDs from the registry - */ const getPacksByIds = async (ids: NodePack['id'][]): Promise => { const [cachedPacksIds, uncachedPacksIds] = partition(ids, (id) => getPacksByIdCache.has(id) @@ -88,47 +79,44 @@ export const useComfyRegistryStore = defineStore('comfyRegistry', () => { return resolvedPacks } - /** - * Get the node definitions for a pack - */ + const getActivePackVersions = useCachedRequest< + { id: string; advertisedVersion?: string; advertisedStatus?: string }, + components['schemas']['NodeVersion'][] + >( + ({ id }, signal) => + registryService.getPackVersions( + id, + { statuses: ['NodeVersionStatusActive'] }, + signal + ), + { maxSize: PACK_BY_ID_CACHE_SIZE } + ) + const getNodeDefs = useCachedRequest< GetNodeDefsParams, operations['ListComfyNodes']['responses'][200]['content']['application/json'] >(registryService.getNodeDefs, { maxSize: PACK_BY_ID_CACHE_SIZE }) - /** - * Search for packs by pack name or node names - */ const search = useCachedRequest< operations['searchNodes']['parameters']['query'], ListPacksResult >(registryService.search, { maxSize: PACK_LIST_CACHE_SIZE }) - /** - * Get the node pack that contains a specific ComfyUI node by its name. - * Results are cached to avoid redundant API calls. - * - * @see {@link useComfyRegistryService.inferPackFromNodeName} for details on the ranking algorithm - */ const inferPackFromNodeName = useCachedRequest< operations['getNodeByComfyNodeName']['parameters']['path']['comfyNodeName'], NodePack >(registryService.inferPackFromNodeName, { maxSize: PACK_BY_ID_CACHE_SIZE }) - /** - * Clear all cached data - */ const clearCache = () => { + getActivePackVersions.clear() getNodeDefs.clear() listAllPacks.clear() getPackById.clear() inferPackFromNodeName.clear() } - /** - * Cancel all any in-flight requests. - */ const cancelRequests = () => { + getActivePackVersions.cancel() getNodeDefs.cancel() listAllPacks.cancel() getPackById.cancel() @@ -143,6 +131,7 @@ export const useComfyRegistryStore = defineStore('comfyRegistry', () => { call: getPacksByIds, cancel: () => getPacksByIdController?.abort() }, + getActivePackVersions, getNodeDefs, search, inferPackFromNodeName,