repluggable-core 0.0.0-pr349.66 → 0.0.0-pr351.71

package/testKit/index.ts

@@ -1,6 +1,7 @@
 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'
 
@@ -81,34 +82,79 @@ export function createAppHostWithPacts(packages: EntryPointOrPackage[], pacts: P
     })
 }
 
-export async function createAppHostAndWaitForLoading(packages: EntryPointOrPackage[], pacts: PactAPIBase[]): Promise<AppHost> {
+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 = {}
+): Promise<AppHost> {
     const appHost = createAppHostWithPacts(packages, pacts)
     const declaredAPIs = _(packages)
         .flatten()
         .value()
         .flatMap((entryPoint: EntryPoint) => (entryPoint.declareAPIs ? entryPoint.declareAPIs() : []))
 
-    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 rootUnreadyAPI = globalThis.repluggableAppDebug.utils.getRootUnreadyAPI()
-
-            reject(
-                new Error(
-                    `createAppHostAndWaitForLoading - waiting for loading timed out.
-there's a high chance this missing API is the main reason for it: ${JSON.stringify(rootUnreadyAPI)}
-
-in addition here's the full list of declared APIs that have not been contributed: ${JSON.stringify(unreadyAPIs)}`
-                )
-            )
-        }, 3000)
+    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))
+        }, timeout)
     })
 
     const loadingPromise = new Promise<void>(async resolve => {
         await appHost.addShells([
             {
-                name: 'Depends on all declared APIs',
+                name: WAIT_FOR_LOADING_PROBE_SHELL,
                 getDependencyAPIs() {
                     return declaredAPIs
                 },
@@ -119,7 +165,14 @@ in addition here's the full list of declared APIs that have not been contributed
         ])
     })
 
-    return Promise.race([timeoutPromise, loadingPromise]).then(() => appHost)
+    try {
+        await Promise.race([timeoutPromise, loadingPromise])
+        return appHost
+    } finally {
+        if (timer) {
+            clearTimeout(timer)
+        }
+    }
 }
 
 type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>