repluggable-core 0.0.0-pr340.39 → 0.0.0-pr342.44

package/dist/test/appHost.spec.js

@@ -17,6 +17,7 @@ const appHost_1 = require("../src/appHost");
 const testKit_1 = require("../testKit");
 const appHostServices_1 = require("../src/appHostServices");
 const loggers_1 = require("../src/loggers");
+const mockPackage_1 = require("../testKit/mockPackage");
 const appHost_mock_1 = require("./appHost.mock");
 const createSignalItemsDataStructure_1 = require("./createSignalItemsDataStructure");
 const testHostOptions = {
@@ -1542,5 +1543,487 @@ If the API is intended to be public, it should be declared as "public: true" in
             expect(itemsSpy).toBeCalledTimes(4);
         }));
     });
+    describe('Cold Dependencies', () => {
+        it('should allow entry point to load without waiting for cold dependencies', () => __awaiter(void 0, void 0, void 0, function* () {
+            const host = (0, appHost_1.createAppHost)([], testHostOptions);
+            host.addShells([mockPackage_1.mockPackageWithColdDependency]);
+            expect(host.hasShell(mockPackage_1.mockPackageWithColdDependency.name)).toBe(true);
+        }));
+        it('should return false for hasAPI when cold dependency is not ready', () => __awaiter(void 0, void 0, void 0, function* () {
+            const host = (0, appHost_1.createAppHost)([], testHostOptions);
+            host.addShells([mockPackage_1.mockPackageWithColdDependency]);
+            expect(host.hasAPI(testKit_1.MockAPI)).toBe(false);
+        }));
+        it('should throw when accessing cold dependency that is not ready', () => __awaiter(void 0, void 0, void 0, function* () {
+            const host = (0, appHost_1.createAppHost)([], testHostOptions);
+            host.addShells([mockPackage_1.mockPackageWithColdDependency]);
+            expect(() => host.getAPI(testKit_1.MockAPI)).toThrow();
+        }));
+        it('should throw when accessing cold dependency during entry point attach', () => __awaiter(void 0, void 0, void 0, function* () {
+            const coldDependencyEntryPoint = {
+                name: 'COLD_DEPENDENCY_ENTRY_POINT',
+                getColdDependencyAPIs() {
+                    return [testKit_1.MockAPI];
+                },
+                declareAPIs() {
+                    return [testKit_1.MockPublicAPI];
+                },
+                attach(shell) {
+                    shell.contributeAPI(testKit_1.MockPublicAPI, () => {
+                        const mockAPI = shell.getAPI(testKit_1.MockAPI);
+                        return {
+                            stubTrue: () => mockAPI.stubTrue()
+                        };
+                    });
+                }
+            };
+            const host = (0, appHost_1.createAppHost)([], testHostOptions);
+            expect(() => host.addShells([coldDependencyEntryPoint])).toThrow();
+        }));
+        it('should throw when accessing cold dependency during entry point extend', () => __awaiter(void 0, void 0, void 0, function* () {
+            const coldDependencyEntryPoint = {
+                name: 'COLD_DEPENDENCY_ENTRY_POINT',
+                getColdDependencyAPIs() {
+                    return [testKit_1.MockAPI];
+                },
+                extend(shell) {
+                    shell.getAPI(testKit_1.MockAPI).stubTrue();
+                }
+            };
+            const host = (0, appHost_1.createAppHost)([], testHostOptions);
+            expect(() => host.addShells([coldDependencyEntryPoint])).toThrow();
+        }));
+        it('should allow accessing cold dependency via getAPI after initialization completes', () => __awaiter(void 0, void 0, void 0, function* () {
+            const host = (0, appHost_1.createAppHost)([testKit_1.mockPackage], testHostOptions);
+            const shell = (0, testKit_1.addMockShell)(host, {
+                getColdDependencyAPIs: () => [testKit_1.MockAPI]
+            });
+            expect(() => shell.getAPI(testKit_1.MockAPI)).not.toThrow();
+            expect(shell.getAPI(testKit_1.MockAPI).stubTrue()).toBe(true);
+        }));
+        describe('getColdAPI', () => {
+            it('should allow using getColdAPI inside contributeAPI factory', () => __awaiter(void 0, void 0, void 0, function* () {
+                // Problem: You can't call getAPI(coldDep) inside contributeAPI factory because init hasn't completed
+                // Solution: getColdAPI returns a lazy wrapper that defers resolution until the method is actually called
+                const host = (0, appHost_1.createAppHost)([testKit_1.mockPackage], testHostOptions);
+                (0, testKit_1.addMockShell)(host, {
+                    getColdDependencyAPIs: () => [testKit_1.MockAPI],
+                    declareAPIs: () => [testKit_1.MockPublicAPI],
+                    attach(shell) {
+                        const mockAPI = shell.getColdAPI(testKit_1.MockAPI);
+                        shell.contributeAPI(testKit_1.MockPublicAPI, () => ({
+                            stubTrue: () => mockAPI.get().stubTrue()
+                        }));
+                    }
+                });
+                expect(host.getAPI(testKit_1.MockPublicAPI).stubTrue()).toBe(true);
+            }));
+            it('should resolve cold dependency when get() is called after initialization', () => __awaiter(void 0, void 0, void 0, function* () {
+                const host = (0, appHost_1.createAppHost)([testKit_1.mockPackage], testHostOptions);
+                const shell = (0, testKit_1.addMockShell)(host, {
+                    getColdDependencyAPIs: () => [testKit_1.MockAPI]
+                });
+                const lazyAPI = shell.getColdAPI(testKit_1.MockAPI);
+                expect(lazyAPI.get().stubTrue()).toBe(true);
+            }));
+            it('should throw when get() is called and cold dependency is not ready', () => __awaiter(void 0, void 0, void 0, function* () {
+                const host = (0, appHost_1.createAppHost)([], testHostOptions);
+                const shell = (0, testKit_1.addMockShell)(host, {
+                    getColdDependencyAPIs: () => [testKit_1.MockAPI]
+                });
+                const lazyAPI = shell.getColdAPI(testKit_1.MockAPI);
+                expect(() => lazyAPI.get()).toThrow();
+            }));
+            it('should cache the API after first get() call', () => __awaiter(void 0, void 0, void 0, function* () {
+                const host = (0, appHost_1.createAppHost)([testKit_1.mockPackage], testHostOptions);
+                const shell = (0, testKit_1.addMockShell)(host, {
+                    getColdDependencyAPIs: () => [testKit_1.MockAPI]
+                });
+                const lazyAPI = shell.getColdAPI(testKit_1.MockAPI);
+                const first = lazyAPI.get();
+                const second = lazyAPI.get();
+                expect(first).toBe(second);
+            }));
+        });
+        describe('Cyclic Cold Dependencies', () => {
+            it('should load entry point with cyclic cold dependencies', () => __awaiter(void 0, void 0, void 0, function* () {
+                /**
+                 *      (A)───cold───>(B)
+                 *       ^             │
+                 *       │             │
+                 *       └────cold─────┘
+                 *
+                 *   A declares APIA, has cold dep on APIB
+                 *   B declares APIB, has cold dep on APIA
+                 */
+                const APIA = { name: 'API_A' };
+                const APIB = { name: 'API_B' };
+                const declaringAWithColdDepOnB = {
+                    name: 'ENTRY_POINT_A',
+                    getColdDependencyAPIs() {
+                        return [APIB];
+                    },
+                    declareAPIs() {
+                        return [APIA];
+                    },
+                    attach(shell) {
+                        shell.contributeAPI(APIA, () => ({
+                            stubTrue: () => true
+                        }));
+                    }
+                };
+                const declaringBWithColdDepOnA = {
+                    name: 'ENTRY_POINT_B',
+                    getColdDependencyAPIs() {
+                        return [APIA];
+                    },
+                    declareAPIs() {
+                        return [APIB];
+                    },
+                    attach(shell) {
+                        shell.contributeAPI(APIB, () => ({
+                            stubTrue: () => true
+                        }));
+                    }
+                };
+                const host = (0, appHost_1.createAppHost)([declaringAWithColdDepOnB, declaringBWithColdDepOnA], testHostOptions);
+                expect(host.hasShell(declaringAWithColdDepOnB.name)).toBe(true);
+                expect(host.hasShell(declaringBWithColdDepOnA.name)).toBe(true);
+            }));
+            it('should load entry points with cyclic cold and regular dependencies', () => __awaiter(void 0, void 0, void 0, function* () {
+                /**
+                 *      (A)───cold───>(B)───cold───>(C)
+                 *       ^                            │
+                 *       │                            │
+                 *       └─────────regular────────────┘
+                 *
+                 *   A declares APIA, has cold dep on APIB
+                 *   B declares APIB, has cold dep on APIC
+                 *   C declares APIC, has regular dep on APIA
+                 */
+                const APIA = { name: 'API_A' };
+                const APIB = { name: 'API_B' };
+                const APIC = { name: 'API_C' };
+                const declaringA = {
+                    name: 'ENTRY_POINT_A',
+                    getColdDependencyAPIs() {
+                        return [APIB];
+                    },
+                    declareAPIs() {
+                        return [APIA];
+                    },
+                    attach(shell) {
+                        shell.contributeAPI(APIA, () => ({
+                            stubTrue: () => true
+                        }));
+                    }
+                };
+                const declaringB = {
+                    name: 'ENTRY_POINT_B',
+                    getColdDependencyAPIs() {
+                        return [APIC];
+                    },
+                    declareAPIs() {
+                        return [APIB];
+                    },
+                    attach(shell) {
+                        shell.contributeAPI(APIB, () => ({
+                            stubTrue: () => true
+                        }));
+                    }
+                };
+                const declaringC = {
+                    name: 'ENTRY_POINT_C',
+                    getDependencyAPIs() {
+                        return [APIA];
+                    },
+                    declareAPIs() {
+                        return [APIC];
+                    },
+                    attach(shell) {
+                        shell.contributeAPI(APIC, () => ({
+                            stubTrue: () => true
+                        }));
+                    }
+                };
+                const host = (0, appHost_1.createAppHost)([declaringA, declaringB, declaringC], testHostOptions);
+                expect(host.hasShell(declaringA.name)).toBe(true);
+                expect(host.hasShell(declaringB.name)).toBe(true);
+                expect(host.hasShell(declaringC.name)).toBe(true);
+            }));
+        });
+        describe('Cold dependency promotion', () => {
+            it('should promote transitive cold dependencies to regular dependencies when there is a real direct dependency', () => __awaiter(void 0, void 0, void 0, function* () {
+                const APIA = { name: 'API_A' };
+                const APIB = { name: 'API_B' };
+                const APIC = { name: 'API_C' };
+                const declaringA = {
+                    name: 'ENTRY_POINT_A',
+                    declareAPIs() {
+                        return [APIA];
+                    },
+                    attach(shell) {
+                        shell.contributeAPI(APIA, () => ({
+                            stubTrue: () => true
+                        }));
+                    }
+                };
+                const declaringBWithColdDepOnA = {
+                    name: 'ENTRY_POINT_B',
+                    getColdDependencyAPIs() {
+                        return [APIA];
+                    },
+                    declareAPIs() {
+                        return [APIB];
+                    },
+                    attach(shell) {
+                        shell.contributeAPI(APIB, () => ({
+                            stubTrue: () => true
+                        }));
+                    }
+                };
+                const declaringCWithRegularDepOnB = {
+                    name: 'ENTRY_POINT_C',
+                    getDependencyAPIs() {
+                        return [APIB];
+                    },
+                    declareAPIs() {
+                        return [APIC];
+                    },
+                    attach(shell) {
+                        shell.contributeAPI(APIC, () => ({
+                            stubTrue: () => true
+                        }));
+                    }
+                };
+                // no APIA in the host
+                const host = (0, appHost_1.createAppHost)([declaringBWithColdDepOnA, declaringCWithRegularDepOnB], testHostOptions);
+                expect(host.hasShell(declaringBWithColdDepOnA.name)).toBe(true);
+                expect(host.hasShell(declaringCWithRegularDepOnB.name)).toBe(false);
+                yield host.addShells([declaringA]);
+                expect(host.hasShell(declaringCWithRegularDepOnB.name)).toBe(true);
+            }));
+            it('should promote cold dependencies from unready entry points added in previous batches', () => __awaiter(void 0, void 0, void 0, function* () {
+                const APIA = { name: 'API_A' };
+                const APIB = { name: 'API_B' };
+                const APIC = { name: 'API_C' };
+                const APIX = { name: 'API_X' };
+                // B declares APIB, depends on APIX (keeps B unready), has cold dep on APIA
+                const declaringB = {
+                    name: 'ENTRY_POINT_B',
+                    getDependencyAPIs() {
+                        return [APIX];
+                    },
+                    getColdDependencyAPIs() {
+                        return [APIA];
+                    },
+                    declareAPIs() {
+                        return [APIB];
+                    },
+                    attach(shell) {
+                        shell.contributeAPI(APIB, () => ({ stubTrue: () => true }));
+                    }
+                };
+                // C depends on APIB (from unready B)
+                const declaringC = {
+                    name: 'ENTRY_POINT_C',
+                    getDependencyAPIs() {
+                        return [APIB];
+                    },
+                    declareAPIs() {
+                        return [APIC];
+                    },
+                    attach(shell) {
+                        shell.contributeAPI(APIC, () => ({ stubTrue: () => true }));
+                    }
+                };
+                const declaringA = {
+                    name: 'ENTRY_POINT_A',
+                    declareAPIs() {
+                        return [APIA];
+                    },
+                    attach(shell) {
+                        shell.contributeAPI(APIA, () => ({ stubTrue: () => true }));
+                    }
+                };
+                const declaringX = {
+                    name: 'ENTRY_POINT_X',
+                    declareAPIs() {
+                        return [APIX];
+                    },
+                    attach(shell) {
+                        shell.contributeAPI(APIX, () => ({ stubTrue: () => true }));
+                    }
+                };
+                const host = (0, appHost_1.createAppHost)([], testHostOptions);
+                // Batch 1: Add B (stays unready - needs APIX)
+                yield host.addShells([declaringB]);
+                expect(host.hasShell(declaringB.name)).toBe(false);
+                // Batch 2: Add C (depends on APIB from unready B)
+                // Even though B is unready, C's effective deps should include B's cold dep on APIA
+                yield host.addShells([declaringC]);
+                expect(host.hasShell(declaringC.name)).toBe(false);
+                // Add X only (provides APIX for B)
+                // B can now load and contribute APIB
+                // But C should still wait because B's cold dep (APIA) is promoted to C
+                yield host.addShells([declaringX]);
+                expect(host.hasShell(declaringB.name)).toBe(true);
+                expect(host.hasShell(declaringC.name)).toBe(false);
+                // Add A (provides APIA)
+                yield host.addShells([declaringA]);
+                expect(host.hasShell(declaringC.name)).toBe(true);
+            }));
+            it('should promote cold dependencies through deep regular dependency chains', () => __awaiter(void 0, void 0, void 0, function* () {
+                /**
+                 *      (A)───regular───>(B)───regular───>(C)───regular───>(D)
+                 *                                                          │
+                 *                                                          cold
+                 *                                                          │
+                 *                                                          v
+                 *                                                         (E)
+                 *
+                 * A depends on B, B depends on C, C depends on D, D has cold dep on E
+                 * A should wait for E (cold dep promoted through entire chain)
+                 */
+                const APIA = { name: 'API_A' };
+                const APIB = { name: 'API_B' };
+                const APIC = { name: 'API_C' };
+                const APID = { name: 'API_D' };
+                const APIE = { name: 'API_E' };
+                const declaringE = {
+                    name: 'ENTRY_POINT_E',
+                    declareAPIs() {
+                        return [APIE];
+                    },
+                    attach(shell) {
+                        shell.contributeAPI(APIE, () => ({ stubTrue: () => true }));
+                    }
+                };
+                const declaringD = {
+                    name: 'ENTRY_POINT_D',
+                    getColdDependencyAPIs() {
+                        return [APIE];
+                    },
+                    declareAPIs() {
+                        return [APID];
+                    },
+                    attach(shell) {
+                        shell.contributeAPI(APID, () => ({ stubTrue: () => true }));
+                    }
+                };
+                const declaringC = {
+                    name: 'ENTRY_POINT_C',
+                    getDependencyAPIs() {
+                        return [APID];
+                    },
+                    declareAPIs() {
+                        return [APIC];
+                    },
+                    attach(shell) {
+                        shell.contributeAPI(APIC, () => ({ stubTrue: () => true }));
+                    }
+                };
+                const declaringB = {
+                    name: 'ENTRY_POINT_B',
+                    getDependencyAPIs() {
+                        return [APIC];
+                    },
+                    declareAPIs() {
+                        return [APIB];
+                    },
+                    attach(shell) {
+                        shell.contributeAPI(APIB, () => ({ stubTrue: () => true }));
+                    }
+                };
+                const declaringA = {
+                    name: 'ENTRY_POINT_A',
+                    getDependencyAPIs() {
+                        return [APIB];
+                    },
+                    declareAPIs() {
+                        return [APIA];
+                    },
+                    attach(shell) {
+                        shell.contributeAPI(APIA, () => ({ stubTrue: () => true }));
+                    }
+                };
+                // Without E, D loads (cold dep doesn't block), but A, B, C should wait
+                const host = (0, appHost_1.createAppHost)([declaringA, declaringB, declaringC, declaringD], testHostOptions);
+                expect(host.hasShell(declaringD.name)).toBe(true);
+                expect(host.hasShell(declaringC.name)).toBe(false);
+                expect(host.hasShell(declaringB.name)).toBe(false);
+                expect(host.hasShell(declaringA.name)).toBe(false);
+                // Add E, now everyone can load
+                yield host.addShells([declaringE]);
+                expect(host.hasShell(declaringC.name)).toBe(true);
+                expect(host.hasShell(declaringB.name)).toBe(true);
+                expect(host.hasShell(declaringA.name)).toBe(true);
+            }));
+        });
+        it('should not promote transitive cold dependencies to regular dependencies when there is no real direct dependency', () => __awaiter(void 0, void 0, void 0, function* () {
+            const APIA = { name: 'API_A' };
+            const APIB = { name: 'API_B' };
+            const APIC = { name: 'API_C' };
+            const APID = { name: 'API_D' };
+            const declaringA = {
+                name: 'ENTRY_POINT_A',
+                declareAPIs() {
+                    return [APIA];
+                },
+                attach(shell) {
+                    shell.contributeAPI(APIA, () => ({
+                        stubTrue: () => true
+                    }));
+                }
+            };
+            const declaringBWithColdDepOnA = {
+                name: 'ENTRY_POINT_B',
+                getColdDependencyAPIs() {
+                    return [APIA];
+                },
+                declareAPIs() {
+                    return [APIB];
+                },
+                attach(shell) {
+                    shell.contributeAPI(APIB, () => ({
+                        stubTrue: () => true
+                    }));
+                }
+            };
+            const declaringCWithRegularDepOnB = {
+                name: 'ENTRY_POINT_C',
+                getDependencyAPIs() {
+                    return [APIB];
+                },
+                declareAPIs() {
+                    return [APIC];
+                },
+                attach(shell) {
+                    shell.contributeAPI(APIC, () => ({
+                        stubTrue: () => true
+                    }));
+                }
+            };
+            const declaringDWithColdDepOnC = {
+                name: 'ENTRY_POINT_D',
+                getColdDependencyAPIs() {
+                    return [APIC];
+                },
+                declareAPIs() {
+                    return [APID];
+                },
+                attach(shell) {
+                    shell.contributeAPI(APID, () => ({
+                        stubTrue: () => true
+                    }));
+                }
+            };
+            const host = (0, appHost_1.createAppHost)([declaringBWithColdDepOnA, declaringCWithRegularDepOnB, declaringDWithColdDepOnC], testHostOptions);
+            expect(host.hasShell(declaringDWithColdDepOnC.name)).toBe(true);
+            expect(host.hasShell(declaringCWithRegularDepOnB.name)).toBe(false);
+            yield host.addShells([declaringA]);
+            expect(host.hasShell(declaringCWithRegularDepOnB.name)).toBe(true);
+        }));
+    });
 });
 //# sourceMappingURL=appHost.spec.js.map