repluggable-core 1.302.73 → 1.302.75

package/src/appHost.ts

@@ -1,4 +1,3 @@
-
 import _ from 'lodash'
 import { AnyAction, Store } from 'redux'
 import {
@@ -56,7 +55,6 @@ import {
 } from './throttledStore'
 import { INTERNAL_DONT_USE_SHELL_GET_APP_HOST } from './__internal'
 
-
 function isMultiArray<T>(v: T[] | T[][]): v is T[][] {
     return _.every(v, _.isArray)
 }
@@ -212,6 +210,7 @@ export function createAppHost(initialEntryPointsOrPackages: EntryPointOrPackage[
         onShellsChanged,
         onDeclarationsChanged,
         removeShellsChangedCallback,
+        verifyPendingEntryPointsAPIsMismatch,
         getAppHostServicesShell: appHostServicesEntryPoint.getAppHostServicesShell,
         log: options.logger ? options.logger : ConsoleHostLogger,
         options,
@@ -996,6 +995,7 @@ miss: ${memoizedWithMissHit.miss}
             onShellsChanged: host.onShellsChanged,
             onDeclarationsChanged: host.onDeclarationsChanged,
             removeShellsChangedCallback: host.removeShellsChangedCallback,
+            verifyPendingEntryPointsAPIsMismatch: host.verifyPendingEntryPointsAPIsMismatch,
 
             declareSlot<TItem>(key: SlotKey<TItem>): ExtensionSlot<TItem> {
                 return declareSlot<TItem>(key, shell)
@@ -1219,4 +1219,32 @@ miss: ${memoizedWithMissHit.miss}
     function normalizeApiName(name: string) {
         return name.charAt(0).toLowerCase() + name.substring(1).replace(new RegExp(' ', 'g'), '')
     }
+
+    function verifyPendingEntryPointsAPIsMismatch(): void {
+        const pendingEntryPoints = unReadyEntryPointsStore.get()
+
+        for (const entryPoint of pendingEntryPoints) {
+            verifyEntryPointAPIsMismatch(entryPoint)
+        }
+    }
+
+    function verifyEntryPointAPIsMismatch(entryPoint: EntryPoint): void {
+        const dependencies = entryPoint.getDependencyAPIs?.() || []
+
+        const mismatchedAPI = dependencies.find(dependencyAPI => {
+            const isPrivateAPI = !dependencyAPI.public
+            const foundDeclaredAPIKeyWithSameName = slotKeysByName.get(slotKeyToName(dependencyAPI))
+            const isDeclaredAPIReady = foundDeclaredAPIKeyWithSameName ? readyAPIs.has(foundDeclaredAPIKeyWithSameName) : false
+
+            return isPrivateAPI && isDeclaredAPIReady && dependencyAPI !== foundDeclaredAPIKeyWithSameName
+        })
+
+        if (mismatchedAPI) {
+            throw new Error(
+                `Entry point '${entryPoint.name}' is waiting for API '${mismatchedAPI.name}' that will never be available for it to use.\n` +
+                    `This usually happens when trying to consume a private API as a public API.\n` +
+                    `If the API is intended to be public, it should be declared as "public: true" in the API key, and built in both bundles.`
+            )
+        }
+    }
 }

package/test/appHost.spec.ts

@@ -1762,4 +1762,34 @@ describe('App Host', () => {
             expect(spy).toBeCalledTimes(2)
         })
     })
+
+    describe('Host.verifyPendingEntryPointsAPIsMismatch', () => {
+        it("should throw an error on verification if there's a pending entry points that waits for an API that is contributed but is not available", () => {
+            const PrivateAPI = { name: 'PrivateAPI' }
+            const entryPointA: EntryPoint = {
+                name: 'EntryPointA',
+                declareAPIs: () => [PrivateAPI],
+                attach(shell) {
+                    shell.contributeAPI(PrivateAPI, () => ({}))
+                }
+            }
+            const PrivateAPIUsedAsPublicAPI = _.cloneDeep(PrivateAPI)
+            const entryPointB: EntryPoint = {
+                name: 'EntryPointB',
+                getDependencyAPIs: () => [PrivateAPIUsedAsPublicAPI],
+                extend(shell) {
+                    shell.getAPI(PrivateAPIUsedAsPublicAPI)
+                }
+            }
+            const host = createAppHost([entryPointA, entryPointB], testHostOptions)
+
+            expect(() => host.verifyPendingEntryPointsAPIsMismatch()).toThrowError(
+                new RegExp(
+                    `Entry point 'EntryPointB' is waiting for API '${PrivateAPI.name}' that will never be available for it to use.
+This usually happens when trying to consume a private API as a public API.
+If the API is intended to be public, it should be declared as "public: true" in the API key, and built in both bundles.`
+                )
+            )
+        })
+    })
 })