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

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,37 @@ 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 unreadyEntryPoints = globalThis.repluggableAppDebug.utils.unReadyEntryPoints()
+            const readyNames = new Set(readyAPIs.map(api => api.name))
+            const declaredByUnready = new Set(unreadyEntryPoints.flatMap(ep => (ep.declareAPIs?.() || []).map(key => key.name)))
+            const rootUnreadyAPIs = _.uniqBy(
+                unreadyEntryPoints
+                    .flatMap(ep => ep.getDependencyAPIs?.() || [])
+                    .filter(key => !readyNames.has(key.name) && !declaredByUnready.has(key.name)),
+                'name'
+            )
+
+            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 +133,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>>