@antelopejs/core 1.4.7 → 1.4.8

package/dist/core/module-manager.js

@@ -36,10 +36,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModuleManager = void 0;
 const path = __importStar(require("node:path"));
 const logging_1 = require("@antelopejs/interface-core/logging");
+const semver_1 = require("semver");
+const types_1 = require("../types");
 const interface_registry_1 = require("./interface-registry");
 const module_1 = require("./module");
+const module_context_1 = require("./module-context");
 const module_registry_1 = require("./module-registry");
 const module_tracker_1 = require("./module-tracker");
+const package_resolution_1 = require("./resolution/package-resolution");
 const path_mapper_1 = require("./resolution/path-mapper");
 const resolver_1 = require("./resolution/resolver");
 const resolver_detour_1 = require("./resolution/resolver-detour");
@@ -52,9 +56,13 @@ class ModuleManager {
     moduleTracker;
     resolverDetour;
     resolvedAssociations = new Map();
+    resolvedConnections = new Map();
+    selectedProviders = new Map();
     staticModules = [];
     loaded = new Map();
-    stubbedInterfacePaths = new Map();
+    stubbedInterfacePackages = new Map();
+    interfacePackagePlans = new Map();
+    pendingCleanup = [];
     startupOrder = [];
     constructor(deps = {}) {
         this.registry = deps.registry ?? new module_registry_1.ModuleRegistry();
@@ -160,41 +168,37 @@ class ModuleManager {
         return this.resolvedAssociations.get(moduleId)?.has(interfaceName) ?? false;
     }
     registerStubbedInterfaces(stubbed) {
-        for (const { moduleId, interfacePackage, standalone } of stubbed) {
-            if (this.stubbedInterfacePaths.has(interfacePackage)) {
-                continue;
-            }
-            const consumerFolder = this.loaded.get(moduleId)?.module.manifest.folder;
-            if (!consumerFolder) {
-                continue;
-            }
-            const pkgRoot = this.resolveInterfacePackageRoot(interfacePackage, consumerFolder);
-            if (!pkgRoot) {
-                continue;
-            }
-            this.stubbedInterfacePaths.set(interfacePackage, pkgRoot);
-            this.resolver.interfacePackages.set(interfacePackage, pkgRoot);
-            (0, stub_interface_runtime_1.logStubInterfaceWarningOnce)(interfacePackage, standalone);
+        const packageNames = new Set(stubbed.map((entry) => entry.interfacePackage));
+        for (const packageName of packageNames) {
+            const entries = stubbed.filter((entry) => entry.interfacePackage === packageName);
+            this.registerStubbedInterfacePackage(packageName, entries);
         }
     }
-    resolveInterfacePackageRoot(ifacePkg, fromFolder) {
-        try {
-            const mainPath = require.resolve(ifacePkg, { paths: [fromFolder] });
-            return extractPackageRoot(mainPath, ifacePkg);
-        }
-        catch {
-            return undefined;
+    registerStubbedInterfacePackage(packageName, entries) {
+        const consumers = this.collectInterfacePackageConsumers(packageName);
+        const canonicalPackage = consumers.find((consumer) => consumer.resolvedPackage)?.resolvedPackage;
+        if (!canonicalPackage) {
+            return;
         }
+        this.stubbedInterfacePackages.set(packageName, canonicalPackage);
+        this.interfacePackagePlans.set(packageName, {
+            canonicalPackage,
+            consumers,
+        });
+        this.registerInterfacePackage(packageName, canonicalPackage);
+        (0, stub_interface_runtime_1.logStubInterfaceWarningOnce)(packageName, entries.some((entry) => entry.standalone));
     }
     applyInterfaceStubs() {
         const implemented = this.collectImplementedInterfaces();
-        for (const [interfaceName, pkgRoot] of [...this.stubbedInterfacePaths]) {
+        for (const [interfaceName, resolvedPackage] of [
+            ...this.stubbedInterfacePackages,
+        ]) {
             if (implemented.has(interfaceName)) {
-                this.stubbedInterfacePaths.delete(interfaceName);
+                this.stubbedInterfacePackages.delete(interfaceName);
                 continue;
             }
             if (!this.resolver.interfacePackages.has(interfaceName)) {
-                this.resolver.interfacePackages.set(interfaceName, pkgRoot);
+                this.registerInterfacePackage(interfaceName, resolvedPackage);
             }
             try {
                 require(interfaceName);
@@ -203,7 +207,7 @@ class ModuleManager {
                 Logger.Error(`Failed to load interface '${interfaceName}':`, err);
                 continue;
             }
-            (0, stub_interface_runtime_1.neutralizeInterfacePackage)(pkgRoot, interfaceName);
+            (0, stub_interface_runtime_1.neutralizeInterfacePackage)(resolvedPackage.root, interfaceName);
         }
     }
     collectImplementedInterfaces() {
@@ -218,83 +222,143 @@ class ModuleManager {
         return implemented;
     }
     async constructAll() {
-        this.resolverDetour.attach();
-        this.applyInterfaceStubs();
+        const leaseAcquired = this.resolverDetour.attach();
+        const modules = [...this.loaded.values()];
         try {
-            await Promise.all([...this.loaded.values()].map(({ module, config }) => module.construct(config.config).catch((err) => {
-                Logger.Error(`Failed to construct module:`);
-                Logger.Error(`  - ID: ${module.id}`);
-                Logger.Error(`  - Version: ${module.version}`);
-                Logger.Error("  - Error:", err);
-                throw err;
-            })));
-        }
-        catch (err) {
-            this.resolverDetour.detach();
-            throw err;
+            this.validateInterfacePackages();
+            this.applyInterfaceStubs();
+        }
+        catch (error) {
+            if (leaseAcquired) {
+                throw aggregateErrors([error, ...this.releaseRuntimeState()], "Failed to construct modules");
+            }
+            throw error;
+        }
+        const results = await Promise.allSettled(modules.map(({ module, config }) => this.constructModule(module, config.config)));
+        const errors = collectRejectedErrors(results);
+        if (errors.length === 0) {
+            return;
         }
+        const cleanupCandidates = modules.filter(({ module }) => module.state !== types_1.ModuleState.Loaded);
+        const cleanupErrors = await runModuleOperations(cleanupCandidates.reverse(), (module) => module.destroy());
+        if (leaseAcquired) {
+            cleanupErrors.push(...this.releaseRuntimeState());
+        }
+        throw new AggregateError([...errors, ...cleanupErrors], "Failed to construct modules");
     }
     async constructModules(modules) {
-        this.resolverDetour.attach();
-        this.applyInterfaceStubs();
-        await Promise.all(modules.map(({ module, config }) => module.construct(config.config).catch((err) => {
-            Logger.Error(`Failed to construct module:`);
-            Logger.Error(`  - ID: ${module.id}`);
-            Logger.Error(`  - Version: ${module.version}`);
-            Logger.Error("  - Error:", err);
-            throw err;
-        })));
+        const leaseAcquired = this.resolverDetour.attach();
+        try {
+            this.validateInterfacePackages();
+            this.applyInterfaceStubs();
+            await Promise.all(modules.map(({ module, config }) => this.constructModule(module, config.config)));
+        }
+        catch (error) {
+            if (leaseAcquired) {
+                throw aggregateErrors([error, ...this.releaseRuntimeState()], "Failed to construct modules");
+            }
+            throw error;
+        }
     }
     async startAll() {
-        await this.startModules([...this.loaded.values()]);
+        try {
+            await this.startModules([...this.loaded.values()]);
+        }
+        catch (error) {
+            let cleanupErrors = [];
+            try {
+                await this.destroyAll();
+            }
+            catch (cleanupError) {
+                cleanupErrors = unpackErrors(cleanupError);
+            }
+            throw new AggregateError([...unpackErrors(error), ...cleanupErrors], "Failed to start modules");
+        }
     }
     async startModules(modules) {
-        const starting = [];
-        for (const { module } of modules) {
-            starting.push(module.start());
+        modules.forEach(({ module }) => {
             this.trackModuleStart(module.id);
+        });
+        const results = await Promise.allSettled(modules.map(({ module }) => module.start()));
+        const errors = collectRejectedErrors(results);
+        if (errors.length > 0) {
+            throw new AggregateError(errors, "Failed to start modules");
         }
-        await Promise.all(starting);
     }
     async stopAll() {
-        const reverseOrder = [...this.startupOrder].reverse();
-        const idsToStop = reverseOrder.length > 0
-            ? reverseOrder
-            : [...this.loaded.keys()].reverse();
-        for (const id of idsToStop) {
-            const entry = this.loaded.get(id);
-            if (!entry) {
-                continue;
-            }
-            try {
-                await entry.module.stop();
-            }
-            catch (error) {
-                Logger.Error(`Failed to stop module ${id}:`, error);
-            }
-        }
+        const modules = this.getReverseLifecycleModules();
+        const errors = await runModuleOperations(modules, (module) => module.stop());
         this.startupOrder = [];
+        if (errors.length > 0) {
+            throw new AggregateError(errors, "Failed to stop modules");
+        }
     }
     async destroyAll() {
-        const reverseOrder = [...this.startupOrder].reverse();
-        const idsToDestroy = reverseOrder.length > 0
-            ? reverseOrder
-            : [...this.loaded.keys()].reverse();
+        const modules = this.getReverseLifecycleModules();
+        const results = await runTrackedModuleOperations(modules, (module) => module.destroy());
+        this.pendingCleanup = results.failed.filter(({ module }) => module.state !== types_1.ModuleState.Loaded);
+        const errors = [...results.errors, ...this.clearManagedState()];
+        if (errors.length > 0) {
+            throw new AggregateError(errors, "Failed to destroy modules");
+        }
+    }
+    async constructModule(module, config) {
         try {
-            for (const id of idsToDestroy) {
-                const entry = this.loaded.get(id);
-                if (!entry) {
-                    continue;
-                }
-                await entry.module.destroy();
+            await module.construct(config);
+        }
+        catch (error) {
+            Logger.Error(`Failed to construct module:`);
+            Logger.Error(`  - ID: ${module.id}`);
+            Logger.Error(`  - Version: ${module.version}`);
+            Logger.Error("  - Error:", error);
+            throw error;
+        }
+    }
+    getReverseLifecycleModules() {
+        const orderedIds = [...this.startupOrder].reverse();
+        const seen = new Set(orderedIds);
+        for (const id of [...this.loaded.keys()].reverse()) {
+            if (!seen.has(id)) {
+                orderedIds.push(id);
             }
         }
-        finally {
-            this.startupOrder = [];
-            this.stubbedInterfacePaths.clear();
-            (0, stub_interface_runtime_1.clearStubInterfaceWarnings)();
+        const loadedModules = orderedIds.flatMap((id) => {
+            const entry = this.loaded.get(id);
+            return entry ? [entry] : [];
+        });
+        const loadedInstances = new Set(loadedModules.map(({ module }) => module));
+        return [
+            ...loadedModules,
+            ...this.pendingCleanup.filter(({ module }) => !loadedInstances.has(module)),
+        ];
+    }
+    clearManagedState() {
+        this.loaded.clear();
+        this.staticModules.length = 0;
+        this.registry.clear();
+        this.resolvedAssociations.clear();
+        this.resolver.moduleByFolder.clear();
+        this.resolver.modulesById.clear();
+        this.resolver.interfacePackages.clear();
+        this.resolver.interfacePackageEntries.clear();
+        this.resolver.interfacePackageResolveFrom.clear();
+        this.interfacePackagePlans.clear();
+        this.startupOrder = [];
+        return this.releaseRuntimeState();
+    }
+    releaseRuntimeState() {
+        const errors = [];
+        this.stubbedInterfacePackages.clear();
+        (0, stub_interface_runtime_1.clearStubInterfaceWarnings)();
+        this.moduleTracker.clear();
+        this.interfaceRegistry.clear();
+        try {
             this.resolverDetour.detach();
         }
+        catch (error) {
+            errors.push(error);
+        }
+        return errors;
     }
     trackModuleStart(moduleId) {
         this.startupOrder = this.startupOrder.filter((id) => id !== moduleId);
@@ -303,13 +367,20 @@ class ModuleManager {
     rebuildAssociations() {
         const interfaceSources = this.collectInterfaceSources();
         this.buildModuleAssociations(interfaceSources);
+        this.configureModuleContexts();
     }
     collectInterfaceSources() {
         this.resolver.moduleByFolder.clear();
         this.resolver.modulesById.clear();
         this.resolver.interfacePackages.clear();
+        this.resolver.interfacePackageEntries.clear();
+        this.resolver.interfacePackageResolveFrom.clear();
+        this.interfacePackagePlans.clear();
         this.resolvedAssociations.clear();
+        this.resolvedConnections.clear();
+        this.selectedProviders.clear();
         this.moduleTracker.clear();
+        this.interfaceRegistry.clear();
         const interfaceSources = new Map();
         for (const { module, config } of this.loaded.values()) {
             this.resolver.moduleByFolder.set(module.manifest.folder, module);
@@ -321,7 +392,7 @@ class ModuleManager {
             });
             for (const interfacePackage of module.manifest.implements ?? []) {
                 if (!config.disabledExports?.has(interfacePackage)) {
-                    interfaceSources.set(interfacePackage, module);
+                    this.addInterfaceSource(interfaceSources, interfacePackage, module);
                 }
             }
         }
@@ -329,7 +400,7 @@ class ModuleManager {
             this.resolver.modulesById.set(module.id, module);
             for (const interfacePackage of module.manifest.implements ?? []) {
                 if (!config.disabledExports?.has(interfacePackage)) {
-                    interfaceSources.set(interfacePackage, module);
+                    this.addInterfaceSource(interfaceSources, interfacePackage, module);
                 }
             }
         }
@@ -337,75 +408,209 @@ class ModuleManager {
         return interfaceSources;
     }
     resolveInterfacePackagePaths(interfaceSources) {
-        for (const [ifacePkg, module] of interfaceSources) {
-            if (module.manifest.manifest.name === ifacePkg) {
-                this.resolver.interfacePackages.set(ifacePkg, module.manifest.folder);
+        for (const [ifacePkg, modules] of interfaceSources) {
+            const module = [...modules].sort((left, right) => left.id.localeCompare(right.id))[0];
+            if (!module) {
                 continue;
             }
-            try {
-                const mainPath = require.resolve(ifacePkg, {
-                    paths: [module.manifest.folder],
-                });
-                const pkgRoot = extractPackageRoot(mainPath, ifacePkg);
-                if (pkgRoot) {
-                    this.resolver.interfacePackages.set(ifacePkg, pkgRoot);
-                }
+            const canonicalPackage = this.resolveImplementedPackage(ifacePkg, module);
+            if (!canonicalPackage) {
+                continue;
             }
-            catch {
+            this.interfacePackagePlans.set(ifacePkg, {
+                canonicalPackage,
+                consumers: this.collectInterfacePackageConsumers(ifacePkg),
+            });
+            this.registerInterfacePackage(ifacePkg, canonicalPackage);
+        }
+        for (const [packageName, canonicalPackage] of this
+            .stubbedInterfacePackages) {
+            if (interfaceSources.has(packageName)) {
+                continue;
+            }
+            this.interfacePackagePlans.set(packageName, {
+                canonicalPackage,
+                consumers: this.collectInterfacePackageConsumers(packageName),
+            });
+            this.registerInterfacePackage(packageName, canonicalPackage);
+        }
+    }
+    resolveImplementedPackage(packageName, module) {
+        const resolvedPackage = (0, package_resolution_1.resolvePackage)(packageName, module.manifest.folder);
+        if (resolvedPackage) {
+            return resolvedPackage;
+        }
+        if (module.manifest.manifest.name !== packageName) {
+            return undefined;
+        }
+        return (0, package_resolution_1.resolvePackageAtRoot)(packageName, module.manifest.folder, module.manifest.version);
+    }
+    collectInterfacePackageConsumers(packageName) {
+        const consumers = [];
+        for (const { module } of this.loaded.values()) {
+            const manifest = module.manifest.manifest;
+            const range = manifest.dependencies?.[packageName] ??
+                manifest.optionalDependencies?.[packageName];
+            if (!range) {
+                continue;
             }
+            consumers.push({
+                moduleId: module.id,
+                range,
+                resolvedPackage: (0, package_resolution_1.resolvePackage)(packageName, module.manifest.folder),
+            });
         }
+        return consumers;
+    }
+    registerInterfacePackage(packageName, resolvedPackage) {
+        this.resolver.interfacePackages.set(packageName, resolvedPackage.root);
+        this.resolver.interfacePackageEntries.set(packageName, resolvedPackage.entry);
+        this.resolver.interfacePackageResolveFrom.set(packageName, resolvedPackage.resolveFrom);
+    }
+    validateInterfacePackages() {
+        const errors = [...this.interfacePackagePlans].flatMap(([name, plan]) => [
+            ...this.findVersionErrors(name, plan),
+            ...this.findPreloadedCopyErrors(name, plan),
+        ]);
+        if (errors.length === 0) {
+            return;
+        }
+        throw new Error(`Incompatible interface package resolution:\n${errors.join("\n")}`);
+    }
+    findVersionErrors(packageName, plan) {
+        return plan.consumers.flatMap((consumer) => {
+            const range = (0, semver_1.validRange)(consumer.range);
+            if (!range || (0, semver_1.satisfies)(plan.canonicalPackage.version, range)) {
+                return [];
+            }
+            const installed = consumer.resolvedPackage
+                ? `${consumer.resolvedPackage.version} at ${consumer.resolvedPackage.root}`
+                : "not installed from the consumer";
+            return [
+                `  - ${consumer.moduleId} requires ${packageName}@${consumer.range}, but the canonical package is ${plan.canonicalPackage.version} at ${plan.canonicalPackage.root} (consumer copy: ${installed})`,
+            ];
+        });
+    }
+    findPreloadedCopyErrors(packageName, plan) {
+        const canonicalRoot = plan.canonicalPackage.realRoot;
+        const copies = plan.consumers
+            .map((consumer) => consumer.resolvedPackage)
+            .filter((resolvedPackage) => Boolean(resolvedPackage && resolvedPackage.realRoot !== canonicalRoot));
+        return copies.flatMap((copy) => {
+            const loadedFile = Object.keys(require.cache).find((filePath) => (0, package_resolution_1.isPathWithin)(filePath, copy.root));
+            return loadedFile
+                ? [
+                    `  - ${packageName}@${copy.version} was loaded from ${copy.root} before the canonical copy at ${plan.canonicalPackage.root}; preloaded interface copies cannot be redirected (${loadedFile})`,
+                ]
+                : [];
+        });
     }
     buildModuleAssociations(interfaceSources) {
         for (const { module, config } of this.loaded.values()) {
-            const associations = new Map();
             const connections = new Map();
-            this.addDefaultAssociations(module, associations, connections, interfaceSources);
-            this.applyImportOverrides(config.importOverrides, associations, connections);
-            this.resolvedAssociations.set(module.id, new Set(associations.keys()));
-            this.interfaceRegistry.setConnections(module.id, connections);
+            const selected = new Map();
+            this.addDefaultAssociations(module, connections, selected, interfaceSources);
+            this.applyImportOverrides(module.id, config.importOverrides, connections, selected);
+            this.resolvedAssociations.set(module.id, new Set(connections.keys()));
+            this.resolvedConnections.set(module.id, connections);
+            this.selectedProviders.set(module.id, selected);
+            this.interfaceRegistry.setConnections(module.id, connections, selected);
         }
     }
-    addDefaultAssociations(module, associations, connections, interfaceSources) {
+    addDefaultAssociations(module, connections, selected, interfaceSources) {
         const dependencies = module.manifest.manifest.dependencies ?? {};
         const optionalDependencies = module.manifest.manifest.optionalDependencies ?? {};
-        for (const [iface, provider] of interfaceSources) {
+        for (const [iface, providers] of interfaceSources) {
             if (iface in dependencies || iface in optionalDependencies) {
-                associations.set(iface, provider);
-                connections.set(iface, [{ module: provider.id }]);
+                const providerIds = providers.map(({ id }) => id).sort();
+                const defaultProvider = providerIds[0];
+                if (!defaultProvider) {
+                    continue;
+                }
+                connections.set(iface, providerIds.map((provider) => ({ module: provider })));
+                selected.set(iface, defaultProvider);
             }
         }
     }
-    applyImportOverrides(importOverrides, associations, connections) {
+    applyImportOverrides(moduleId, importOverrides, connections, selected) {
         if (!importOverrides) {
             return;
         }
         for (const [iface, overrides] of importOverrides.entries()) {
-            const usable = overrides.filter((override) => this.loaded.has(override.module));
-            connections.set(iface, usable);
-            if (usable.length > 0) {
-                const target = this.loaded.get(usable[0].module)?.module;
-                if (target) {
-                    associations.set(iface, target);
-                }
+            this.validateImportOverrides(moduleId, iface, overrides);
+            connections.set(iface, overrides);
+            selected.set(iface, overrides[0].module);
+        }
+    }
+    addInterfaceSource(sources, interfaceName, module) {
+        const providers = sources.get(interfaceName) ?? [];
+        providers.push(module);
+        sources.set(interfaceName, providers);
+    }
+    validateImportOverrides(consumerId, interfaceName, overrides) {
+        if (overrides.length === 0) {
+            throw new Error(`Module '${consumerId}' has no providers in its '${interfaceName}' import override.`);
+        }
+        const connectionIds = new Set();
+        for (const override of overrides) {
+            const target = this.getModuleEntry(override.module);
+            const implementsInterface = target?.module.manifest.implements.includes(interfaceName) &&
+                !target.config.disabledExports?.has(interfaceName);
+            if (!implementsInterface) {
+                throw new Error(`Module '${consumerId}' routes '${interfaceName}' to '${override.module}', but that loaded module does not provide the interface.`);
+            }
+            if (override.id && connectionIds.has(override.id)) {
+                throw new Error(`Module '${consumerId}' has duplicate connection ID '${override.id}' for '${interfaceName}'.`);
+            }
+            if (override.id) {
+                connectionIds.add(override.id);
             }
         }
     }
-    isPathWithin(filePath, dirPath) {
-        const normalizedDir = path.resolve(dirPath);
-        const normalizedFile = path.resolve(filePath);
-        if (normalizedFile === normalizedDir) {
-            return true;
+    configureModuleContexts() {
+        for (const { module, config } of this.getAllManagedModules()) {
+            const selected = this.selectedProviders.get(module.id) ?? new Map();
+            const connections = this.resolvedConnections.get(module.id) ??
+                new Map();
+            const routes = [...selected].map(([interfaceName, provider]) => ({
+                interfaceName,
+                packageEntry: this.resolver.interfacePackageEntries.get(interfaceName),
+                provider,
+                providerCount: new Set(connections.get(interfaceName)?.map(({ module }) => module)).size,
+            }));
+            const isProvider = (module.manifest.implements ?? []).some((interfaceName) => !config.disabledExports?.has(interfaceName));
+            module.setProviderRoutes((0, module_context_1.buildProviderRoutes)(module.id, routes), isProvider);
         }
-        return normalizedFile.startsWith(normalizedDir + path.sep);
+    }
+    isPathWithin(filePath, dirPath) {
+        return (0, package_resolution_1.isPathWithin)(filePath, dirPath);
     }
 }
 exports.ModuleManager = ModuleManager;
-function extractPackageRoot(mainPath, ifacePkg) {
-    const marker = `${path.sep}${ifacePkg.replace("/", path.sep)}${path.sep}`;
-    const scopeIndex = mainPath.indexOf(marker);
-    if (scopeIndex === -1) {
-        return undefined;
+function collectRejectedErrors(results) {
+    return results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+}
+function unpackErrors(error) {
+    return error instanceof AggregateError ? error.errors : [error];
+}
+function aggregateErrors(errors, message) {
+    return errors.length === 1 ? errors[0] : new AggregateError(errors, message);
+}
+async function runModuleOperations(modules, operation) {
+    return (await runTrackedModuleOperations(modules, operation)).errors;
+}
+async function runTrackedModuleOperations(modules, operation) {
+    const errors = [];
+    const failed = [];
+    for (const entry of modules) {
+        try {
+            await operation(entry.module);
+        }
+        catch (error) {
+            errors.push(...unpackErrors(error));
+            failed.push(entry);
+        }
     }
-    return mainPath.substring(0, scopeIndex + marker.length - 1);
+    return { errors, failed };
 }
 //# sourceMappingURL=module-manager.js.map