repluggable-core 0.0.0-pr351.71 → 0.0.0-pr351.73

package/src/repluggableAppDebug/index.ts

@@ -1 +1 @@
-export { setupDebugInfo, RootUnreadyAPIInfo, UnreadyEntryPointsReport } from './repluggableAppDebug'
+export { setupDebugInfo } from './repluggableAppDebug'

package/src/repluggableAppDebug/repluggableAppDebug.ts

@@ -36,77 +36,6 @@ function mapApiToEntryPoint(allPackages: EntryPoint[]) {
     return apiToEntryPoint
 }
 
-export interface RootUnreadyAPIInfo {
-    key: AnySlotKey
-    /**
-     * 'nobody'  -> not declared by any entry point in the host (missing package / pact)
-     * otherwise -> declared by an INSTALLED shell whose contributeAPI never completed (hung async contribution)
-     */
-    declaredBy: 'nobody' | { entryPointName: string }
-    /** names of unready entry points directly blocked on this API */
-    requiredBy: string[]
-}
-
-export interface UnreadyEntryPointsReport {
-    unreadyEntryPoints: EntryPoint[]
-    rootUnreadyAPIs: RootUnreadyAPIInfo[]
-    /** unready entry points directly blocked on a root unready API */
-    rootUnreadyEntryPoints: EntryPoint[]
-    /** true when entry points are unready but no root unready API exists - their dependencies form a cycle */
-    probableDependencyCycle: boolean
-}
-
-type UnreadyReportParams = Pick<SetupDebugInfoParams, 'readyAPIs' | 'getOwnSlotKey' | 'getUnreadyEntryPoints' | 'addedShells'>
-
-/**
- * Computes all root unready APIs at once: dependencies of unready entry points that are neither ready
- * nor declared by another unready entry point (i.e. the APIs actually blocking the host from loading).
- */
-const createGetUnreadyEntryPointsReport = ({ readyAPIs, getOwnSlotKey, getUnreadyEntryPoints, addedShells }: UnreadyReportParams) => {
-    return (): UnreadyEntryPointsReport => {
-        const unreadyEntryPoints = getUnreadyEntryPoints()
-        const isReady = (key: AnySlotKey) => readyAPIs.has(getOwnSlotKey(key as SlotKey<any>))
-
-        const declaredByUnready = new Set<string>()
-        unreadyEntryPoints.forEach(entryPoint => entryPoint.declareAPIs?.().forEach(key => declaredByUnready.add(key.name)))
-
-        const declaredByInstalled = new Map<string, string>()
-        for (const shell of addedShells.values()) {
-            shell.entryPoint.declareAPIs?.().forEach(key => declaredByInstalled.set(key.name, shell.entryPoint.name))
-        }
-
-        const rootByName = new Map<string, RootUnreadyAPIInfo>()
-        unreadyEntryPoints.forEach(entryPoint => {
-            entryPoint.getDependencyAPIs?.().forEach(key => {
-                if (isReady(key) || declaredByUnready.has(key.name)) {
-                    return
-                }
-                const declarerName = declaredByInstalled.get(key.name)
-                const info = rootByName.get(key.name) ?? {
-                    key,
-                    declaredBy: declarerName ? { entryPointName: declarerName } : ('nobody' as const),
-                    requiredBy: []
-                }
-                info.requiredBy.push(entryPoint.name)
-                rootByName.set(key.name, info)
-            })
-        })
-
-        const rootUnreadyAPIs = [...rootByName.values()]
-        const rootAPINames = new Set(rootByName.keys())
-        const rootUnreadyEntryPoints = unreadyEntryPoints.filter(entryPoint =>
-            entryPoint.getDependencyAPIs?.().some(key => rootAPINames.has(key.name))
-        )
-
-        return {
-            unreadyEntryPoints,
-            rootUnreadyAPIs,
-            rootUnreadyEntryPoints,
-            probableDependencyCycle: unreadyEntryPoints.length > 0 && rootUnreadyAPIs.length === 0
-        }
-    }
-}
-
 export type DependencyTree = {
     entryPoint: string
     deps: Array<{ api: string; subtree: DependencyTree | null }>
@@ -227,9 +156,22 @@ export function setupDebugInfo({
                 }
             })
         },
-        getUnreadyEntryPointsReport: createGetUnreadyEntryPointsReport({ readyAPIs, getOwnSlotKey, getUnreadyEntryPoints, addedShells }),
-        /** @deprecated use getUnreadyEntryPointsReport() - this returns only the first of possibly many root unready APIs */
-        getRootUnreadyAPI: (): AnySlotKey | undefined => utils.getUnreadyEntryPointsReport().rootUnreadyAPIs[0]?.key,
+        /**
+         * dependencies of unready entry points that are neither ready nor declared by another
+         * unready entry point - the APIs actually blocking the host from loading
+         * (missing entry point / pact, or a contribution that never completed)
+         */
+        getRootUnreadyAPIs: (): AnySlotKey[] => {
+            const unreadyEntryPoints = getUnreadyEntryPoints()
+            const declaredByUnready = new Set(unreadyEntryPoints.flatMap(ep => (ep.declareAPIs?.() || []).map(key => key.name)))
+            return _.uniqBy(
+                unreadyEntryPoints
+                    .flatMap(ep => ep.getDependencyAPIs?.() || [])
+                    .filter(key => !readyAPIs.has(getOwnSlotKey(key)) && !declaredByUnready.has(key.name)),
+                'name'
+            )
+        },
+        getRootUnreadyAPI: () => utils.getRootUnreadyAPIs()[0],
         unReadyEntryPoints: (): EntryPoint[] => getUnreadyEntryPoints(),
         whyEntryPointUnready: (name: string) => {
             const unreadyEntryPoint = _.find(

package/test/repluggableAppDebug.spec.ts

@@ -246,53 +246,8 @@ describe('RepluggableAppDebug', () => {
         })
     })
 
-    describe('getUnreadyEntryPointsReport', () => {
-        const getReport = async () => {
-            await new Promise(resolve => setTimeout(resolve, 0))
-            return globalThis.repluggableAppDebug.utils.getUnreadyEntryPointsReport()
-        }
-
-        it('should report no unready entry points when all are loaded', async () => {
-            createAppHost([
-                {
-                    name: 'entryPoint',
-                    declareAPIs: () => []
-                }
-            ])
-
-            const report = await getReport()
-
-            expect(report).toEqual({
-                unreadyEntryPoints: [],
-                rootUnreadyAPIs: [],
-                rootUnreadyEntryPoints: [],
-                probableDependencyCycle: false
-            })
-        })
-
-        it('should report all root unready APIs of independent unready clusters', async () => {
-            createAppHost([
-                {
-                    name: 'entryPoint A',
-                    getDependencyAPIs: () => [{ name: 'missing A' }]
-                },
-                {
-                    name: 'entryPoint B',
-                    getDependencyAPIs: () => [{ name: 'missing B' }]
-                }
-            ])
-
-            const report = await getReport()
-
-            expect(report.rootUnreadyAPIs).toEqual([
-                { key: { name: 'missing A' }, declaredBy: 'nobody', requiredBy: ['entryPoint A'] },
-                { key: { name: 'missing B' }, declaredBy: 'nobody', requiredBy: ['entryPoint B'] }
-            ])
-            expect(report.rootUnreadyEntryPoints.map(entryPoint => entryPoint.name)).toEqual(['entryPoint A', 'entryPoint B'])
-            expect(report.probableDependencyCycle).toBe(false)
-        })
-
-        it('should report only the root API of a transitively blocked chain', async () => {
+    describe('getRootUnreadyAPIs', () => {
+        it('should return all root unready APIs, excluding transitively blocked ones', async () => {
             createAppHost([
                 {
                     name: 'entryPoint A',
@@ -301,98 +256,16 @@ describe('RepluggableAppDebug', () => {
                 {
                     name: 'entryPoint B',
                     declareAPIs: () => [{ name: 'API B' }],
-                    getDependencyAPIs: () => [unreadAPI]
-                }
-            ])
-
-            const report = await getReport()
-
-            expect(report.rootUnreadyAPIs).toEqual([{ key: unreadAPI, declaredBy: 'nobody', requiredBy: ['entryPoint B'] }])
-            expect(report.rootUnreadyEntryPoints.map(entryPoint => entryPoint.name)).toEqual(['entryPoint B'])
-            expect(report.unreadyEntryPoints.map(entryPoint => entryPoint.name)).toEqual(['entryPoint A', 'entryPoint B'])
-        })
-
-        it('should report roots of sibling branches, including APIs declared by an installed shell that never contributed them', async () => {
-            createAppHost([
-                {
-                    name: 'entryPoint 0',
-                    getDependencyAPIs: () => [{ name: 'missing API' }, { name: 'API B' }]
-                },
-                {
-                    name: 'entryPoint 1',
-                    declareAPIs: () => [{ name: 'API B' }]
-                }
-            ])
-
-            const report = await getReport()
-
-            expect(report.rootUnreadyAPIs).toEqual([
-                { key: { name: 'missing API' }, declaredBy: 'nobody', requiredBy: ['entryPoint 0'] },
-                { key: { name: 'API B' }, declaredBy: { entryPointName: 'entryPoint 1' }, requiredBy: ['entryPoint 0'] }
-            ])
-        })
-
-        it('should aggregate all entry points blocked on the same root API', async () => {
-            createAppHost([
-                {
-                    name: 'entryPoint A',
-                    getDependencyAPIs: () => [unreadAPI]
+                    getDependencyAPIs: () => [{ name: 'missing B' }]
                 },
                 {
-                    name: 'entryPoint B',
-                    getDependencyAPIs: () => [unreadAPI]
+                    name: 'entryPoint C',
+                    getDependencyAPIs: () => [{ name: 'missing C' }]
                 }
             ])
+            await new Promise(resolve => setTimeout(resolve, 0))
 
-            const report = await getReport()
-
-            expect(report.rootUnreadyAPIs).toEqual([{ key: unreadAPI, declaredBy: 'nobody', requiredBy: ['entryPoint A', 'entryPoint B'] }])
-        })
-
-        it('should flag a probable dependency cycle when unready entry points have no root unready API', async () => {
-            createAppHost(
-                [
-                    {
-                        name: 'entryPoint A',
-                        declareAPIs: () => [{ name: 'API X' }],
-                        getDependencyAPIs: () => [{ name: 'API Y' }]
-                    },
-                    {
-                        name: 'entryPoint B',
-                        declareAPIs: () => [{ name: 'API Y' }],
-                        getDependencyAPIs: () => [{ name: 'API X' }]
-                    }
-                ],
-                { monitoring: {}, disableCheckCircularDependencies: true }
-            )
-
-            const report = await getReport()
-
-            expect(report.rootUnreadyAPIs).toEqual([])
-            expect(report.unreadyEntryPoints.map(entryPoint => entryPoint.name)).toEqual(['entryPoint A', 'entryPoint B'])
-            expect(report.probableDependencyCycle).toBe(true)
+            expect(globalThis.repluggableAppDebug.utils.getRootUnreadyAPIs()).toEqual([{ name: 'missing B' }, { name: 'missing C' }])
         })
-
-        it('should not hang getRootUnreadyAPI on a dependency cycle', async () => {
-            createAppHost(
-                [
-                    {
-                        name: 'entryPoint A',
-                        declareAPIs: () => [{ name: 'API X' }],
-                        getDependencyAPIs: () => [{ name: 'API Y' }]
-                    },
-                    {
-                        name: 'entryPoint B',
-                        declareAPIs: () => [{ name: 'API Y' }],
-                        getDependencyAPIs: () => [{ name: 'API X' }]
-                    }
-                ],
-                { monitoring: {}, disableCheckCircularDependencies: true }
-            )
-
-            const unreadyAPIs = await getUnreadyAPIs()
-
-            expect(unreadyAPIs).toBeUndefined()
-        }, 3000)
     })
 })

package/test/testKit.spec.tsx

@@ -12,8 +12,7 @@ import {
     asyncLoadMockPackage,
     dependsOnMockPackageEntryPoint,
     MockPublicAPI,
-    createAppHostAndWaitForLoading,
-    AppHostLoadingTimeoutError
+    createAppHostAndWaitForLoading
 } from '../testKit'
 
 interface APIKeys {
@@ -148,10 +147,10 @@ describe('App Host TestKit', () => {
         it('should throw if failed to load all packages', async () => {
             const hostPromise = createAppHostAndWaitForLoading([dependsOnMockPackageEntryPoint], [])
             jest.runAllTimers()
-            await expect(hostPromise).rejects.toThrow(new RegExp(MockAPI.name))
+            await expect(hostPromise).rejects.toThrow(new RegExp(MockPublicAPI.name))
         })
 
-        it('should reject with a structured report of all root unready APIs', async () => {
+        it('should report all root unready APIs of independent unready entry points', async () => {
             const hostPromise = createAppHostAndWaitForLoading(
                 [
                     {
@@ -168,24 +167,20 @@ describe('App Host TestKit', () => {
                 []
             )
             jest.runAllTimers()
-            const error: AppHostLoadingTimeoutError = await hostPromise.then(
+            const error: Error = await hostPromise.then(
                 () => {
                     throw new Error('expected hostPromise to reject')
                 },
                 e => e
             )
 
-            expect(error).toBeInstanceOf(AppHostLoadingTimeoutError)
-            expect(error.report.rootUnreadyAPIs.map(info => info.key.name)).toEqual(['missing A', 'missing B'])
             expect(error.message).toContain('"missing A"')
             expect(error.message).toContain('"missing B"')
-            expect(error.message).toContain('required by: entryPoint A')
-            expect(error.message).toContain('required by: entryPoint B')
         })
 
         it('should respect a custom loading timeout', async () => {
             let settled = false
-            const hostPromise = createAppHostAndWaitForLoading([dependsOnMockPackageEntryPoint], [], { timeout: 10000 })
+            const hostPromise = createAppHostAndWaitForLoading([dependsOnMockPackageEntryPoint], [], 10000)
             hostPromise.catch(() => (settled = true))
 
             jest.advanceTimersByTime(9999)
@@ -194,15 +189,7 @@ describe('App Host TestKit', () => {
             expect(settled).toBe(false)
 
             jest.advanceTimersByTime(1)
-            await expect(hostPromise).rejects.toBeInstanceOf(AppHostLoadingTimeoutError)
-        })
-
-        it('should not leave a pending timeout after successful loading', async () => {
-            const hostPromise = createAppHostAndWaitForLoading([dependsOnMockPackageEntryPoint, asyncLoadMockPackage], [])
-            jest.advanceTimersByTime(500)
-            const host = await hostPromise
-            expect(host.getAPI(MockPublicAPI)).toBeDefined()
-            expect(jest.getTimerCount()).toBe(0)
+            await expect(hostPromise).rejects.toThrow('timed out after 10000ms')
         })
     })
 })

package/testKit/index.ts

@@ -1,7 +1,6 @@
 import _ from 'lodash'
 import { EntryPoint, ObservableState } from '../src/API'
 import { AnySlotKey, AppHost, createAppHost as _createAppHost, EntryPointOrPackage, Shell, SlotKey } from '../src/index'
-import { UnreadyEntryPointsReport } from '../src/repluggableAppDebug'
 import { createShellLogger } from '../src/loggers'
 import { emptyLoggerOptions } from './emptyLoggerOptions'
 
@@ -82,60 +81,10 @@ export function createAppHostWithPacts(packages: EntryPointOrPackage[], pacts: P
     })
 }
 
-export interface WaitForLoadingOptions {
-    /** milliseconds to wait for host loading before rejecting with an unready entry points report (default: 3000) */
-    timeout?: number
-}
-
-export class AppHostLoadingTimeoutError extends Error {
-    constructor(message: string, public readonly report: UnreadyEntryPointsReport) {
-        super(message)
-        this.name = 'AppHostLoadingTimeoutError'
-    }
-}
-
-const WAIT_FOR_LOADING_PROBE_SHELL = 'Depends on all declared APIs'
-
-const formatUnreadyReport = (timeout: number, report: UnreadyEntryPointsReport): string => {
-    const { utils } = globalThis.repluggableAppDebug
-    const isProbeShell = (name: string) => name === WAIT_FOR_LOADING_PROBE_SHELL
-    const header = `createAppHostAndWaitForLoading - host not ready within ${timeout}ms.`
-    const unreadyEntryPoints = report.unreadyEntryPoints.filter(entryPoint => !isProbeShell(entryPoint.name))
-    const rootUnreadyEntryPoints = report.rootUnreadyEntryPoints.filter(entryPoint => !isProbeShell(entryPoint.name))
-
-    if (report.probableDependencyCycle) {
-        const names = unreadyEntryPoints.map(entryPoint => `"${entryPoint.name}"`).join(', ')
-        return `${header}
-No root unready API found while ${unreadyEntryPoints.length} entry points are unready - probable dependency cycle between: ${names}`
-    }
-
-    const roots = report.rootUnreadyAPIs.map((info, index) => {
-        const declaredBy =
-            info.declaredBy === 'nobody'
-                ? 'declared by NO entry point (missing package or pact?)'
-                : `declared by "${info.declaredBy.entryPointName}" (installed, but its contribution never completed - hung async contributeAPI?)`
-        const requiredBy = info.requiredBy.filter(name => !isProbeShell(name))
-        const lines = [`${index + 1}. "${info.key.name}" - ${declaredBy}`]
-        if (requiredBy.length) {
-            lines.push(`   required by: ${requiredBy.join(', ')}`)
-            const tree = utils.visualizeDependencyTree(utils.traceAPIDependency(requiredBy[0], info.key.name))
-            lines.push(...tree.split('\n').map(line => `   ${line}`))
-        }
-        return lines.join('\n')
-    })
-
-    return `${header}
-
-Root unready APIs (${report.rootUnreadyAPIs.length}):
-${roots.join('\n')}
-
-Unready entry points: ${rootUnreadyEntryPoints.length} blocked directly on root APIs, ${unreadyEntryPoints.length} total.`
-}
-
 export async function createAppHostAndWaitForLoading(
     packages: EntryPointOrPackage[],
     pacts: PactAPIBase[],
-    { timeout = 3000 }: WaitForLoadingOptions = {}
+    timeout: number = 3000
 ): Promise<AppHost> {
     const appHost = createAppHostWithPacts(packages, pacts)
     const declaredAPIs = _(packages)
@@ -143,18 +92,29 @@ export async function createAppHostAndWaitForLoading(
         .value()
         .flatMap((entryPoint: EntryPoint) => (entryPoint.declareAPIs ? entryPoint.declareAPIs() : []))
 
-    let timer: ReturnType<typeof setTimeout> | undefined
-    const timeoutPromise = new Promise<never>((resolve, reject) => {
-        timer = setTimeout(() => {
-            const report = globalThis.repluggableAppDebug.utils.getUnreadyEntryPointsReport()
-            reject(new AppHostLoadingTimeoutError(formatUnreadyReport(timeout, report), report))
+    const timeoutPromise = new Promise((resolve, reject) => {
+        setTimeout(() => {
+            const readyAPIs = Array.from(globalThis.repluggableAppDebug.readyAPIs)
+            const unreadyAPIs = declaredAPIs.filter(api => !readyAPIs.some(readyAPI => readyAPI.name === api.name))
+            const rootUnreadyAPIs = globalThis.repluggableAppDebug.utils.getRootUnreadyAPIs()
+
+            reject(
+                new Error(
+                    `createAppHostAndWaitForLoading - waiting for loading timed out after ${timeout}ms.
+these root unready APIs are most likely the reason - unready entry points require them but nothing declares them (missing entry point or pact?): ${JSON.stringify(
+                        rootUnreadyAPIs
+                    )}
+
+in addition here's the full list of declared APIs that have not been contributed: ${JSON.stringify(unreadyAPIs)}`
+                )
+            )
         }, timeout)
     })
 
     const loadingPromise = new Promise<void>(async resolve => {
         await appHost.addShells([
             {
-                name: WAIT_FOR_LOADING_PROBE_SHELL,
+                name: 'Depends on all declared APIs',
                 getDependencyAPIs() {
                     return declaredAPIs
                 },
@@ -165,14 +125,7 @@ export async function createAppHostAndWaitForLoading(
         ])
     })
 
-    try {
-        await Promise.race([timeoutPromise, loadingPromise])
-        return appHost
-    } finally {
-        if (timer) {
-            clearTimeout(timer)
-        }
-    }
+    return Promise.race([timeoutPromise, loadingPromise]).then(() => appHost)
 }
 
 type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>