697 lines
22 KiB
TypeScript
697 lines
22 KiB
TypeScript
import type { Dirent } from "node:fs";
|
|
import { readdir, readFile, realpath, stat } from "node:fs/promises";
|
|
import path from "node:path";
|
|
import {
|
|
isVersionCompatible,
|
|
type ModuleManifest,
|
|
safeParseModuleManifest,
|
|
semanticVersionSchema,
|
|
} from "@ekklesia/contracts";
|
|
|
|
export const MODULE_MANIFEST_FILENAME = "ekklesia.module.json";
|
|
|
|
export type ModuleDiscoveryIssueCode =
|
|
| "DISCOVERY_CONFIGURATION_INVALID"
|
|
| "MODULE_CAPABILITY_MISSING"
|
|
| "MODULE_DEPENDENCY_CYCLE"
|
|
| "MODULE_DEPENDENCY_INCOMPATIBLE"
|
|
| "MODULE_DEPENDENCY_MISSING"
|
|
| "MODULE_DIRECTORY_INVALID"
|
|
| "MODULE_ENTRYPOINT_INVALID"
|
|
| "MODULE_ENTRYPOINT_MISSING"
|
|
| "MODULE_ID_DUPLICATE"
|
|
| "MODULE_MANIFEST_INVALID"
|
|
| "MODULE_MANIFEST_MISSING"
|
|
| "MODULE_PACKAGE_INVALID"
|
|
| "MODULE_PACKAGE_MISSING"
|
|
| "MODULE_PACKAGE_NAME_DUPLICATE"
|
|
| "MODULE_PLATFORM_INCOMPATIBLE"
|
|
| "MODULE_SDK_INCOMPATIBLE"
|
|
| "MODULE_VERSION_MISMATCH"
|
|
| "MODULES_DIRECTORY_UNREADABLE";
|
|
|
|
export interface ModuleDiscoveryIssue {
|
|
readonly code: ModuleDiscoveryIssueCode;
|
|
readonly message: string;
|
|
readonly moduleDirectory: string;
|
|
readonly moduleId?: string;
|
|
readonly path?: string;
|
|
}
|
|
|
|
export interface ResolvedModuleEntrypoints {
|
|
readonly server: string;
|
|
readonly schema?: string;
|
|
readonly migrations?: string;
|
|
readonly jobs?: string;
|
|
}
|
|
|
|
type DeepReadonly<T> = T extends (...arguments_: never[]) => unknown
|
|
? T
|
|
: T extends readonly (infer Item)[]
|
|
? readonly DeepReadonly<Item>[]
|
|
: T extends object
|
|
? { readonly [Key in keyof T]: DeepReadonly<T[Key]> }
|
|
: T;
|
|
|
|
export type ReadonlyModuleManifest = DeepReadonly<ModuleManifest>;
|
|
|
|
export interface DiscoveredModule {
|
|
readonly directory: string;
|
|
readonly entrypoints: ResolvedModuleEntrypoints;
|
|
readonly manifest: ReadonlyModuleManifest;
|
|
readonly manifestPath: string;
|
|
readonly packageName: string;
|
|
}
|
|
|
|
export interface ModuleDiscoveryOptions {
|
|
readonly moduleSdkVersion: string;
|
|
readonly modulesDirectory: string;
|
|
readonly platformVersion: string;
|
|
}
|
|
|
|
interface ModulePackageData {
|
|
name: string;
|
|
version: string;
|
|
}
|
|
|
|
interface ModuleCandidate {
|
|
directory: string;
|
|
directoryName: string;
|
|
entrypoints: ResolvedModuleEntrypoints;
|
|
manifest: ModuleManifest;
|
|
manifestPath: string;
|
|
packageName: string;
|
|
}
|
|
|
|
export class ModuleDiscoveryError extends Error {
|
|
readonly issues: readonly ModuleDiscoveryIssue[];
|
|
|
|
constructor(issues: readonly ModuleDiscoveryIssue[]) {
|
|
const sortedIssues = [...issues].sort(compareIssues);
|
|
super(`Module discovery failed with ${sortedIssues.length} issue(s).`);
|
|
this.name = "ModuleDiscoveryError";
|
|
this.issues = freezeRecursively(sortedIssues);
|
|
}
|
|
}
|
|
|
|
function compareText(left: string, right: string): number {
|
|
if (left < right) {
|
|
return -1;
|
|
}
|
|
if (left > right) {
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
function compareIssues(left: ModuleDiscoveryIssue, right: ModuleDiscoveryIssue): number {
|
|
return (
|
|
compareText(left.moduleDirectory, right.moduleDirectory) ||
|
|
compareText(left.code, right.code) ||
|
|
compareText(left.path ?? "", right.path ?? "") ||
|
|
compareText(left.message, right.message)
|
|
);
|
|
}
|
|
|
|
function isRecord(value: unknown): value is Record<string, unknown> {
|
|
return typeof value === "object" && value !== null && !Array.isArray(value);
|
|
}
|
|
|
|
function freezeRecursively<T>(value: T): T {
|
|
if (typeof value !== "object" || value === null || Object.isFrozen(value)) {
|
|
return value;
|
|
}
|
|
for (const nestedValue of Object.values(value)) {
|
|
freezeRecursively(nestedValue);
|
|
}
|
|
Object.freeze(value);
|
|
return value;
|
|
}
|
|
|
|
function errorCode(error: unknown): string | undefined {
|
|
if (isRecord(error) && typeof error.code === "string") {
|
|
return error.code;
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
function issuePath(pathParts: readonly PropertyKey[]): string {
|
|
return pathParts.map(String).join(".");
|
|
}
|
|
|
|
function pathIsInside(parent: string, candidate: string): boolean {
|
|
const relativePath = path.relative(parent, candidate);
|
|
return (
|
|
relativePath === "" ||
|
|
(relativePath !== ".." &&
|
|
!relativePath.startsWith(`..${path.sep}`) &&
|
|
!path.isAbsolute(relativePath))
|
|
);
|
|
}
|
|
|
|
async function readJson(pathname: string): Promise<unknown> {
|
|
return JSON.parse(await readFile(pathname, "utf8")) as unknown;
|
|
}
|
|
|
|
function validatePackageData(
|
|
input: unknown,
|
|
directoryName: string,
|
|
issues: ModuleDiscoveryIssue[],
|
|
): ModulePackageData | undefined {
|
|
if (!isRecord(input)) {
|
|
issues.push({
|
|
code: "MODULE_PACKAGE_INVALID",
|
|
message: "package.json must contain a JSON object.",
|
|
moduleDirectory: directoryName,
|
|
});
|
|
return undefined;
|
|
}
|
|
|
|
const name = input.name;
|
|
const version = input.version;
|
|
const packageType = input.type;
|
|
const layer = isRecord(input.ekklesia) ? input.ekklesia.layer : undefined;
|
|
let validPackage = true;
|
|
|
|
if (typeof name !== "string" || name.length === 0) {
|
|
validPackage = false;
|
|
issues.push({
|
|
code: "MODULE_PACKAGE_INVALID",
|
|
message: "package.json must declare a non-empty package name.",
|
|
moduleDirectory: directoryName,
|
|
path: "name",
|
|
});
|
|
}
|
|
if (semanticVersionSchema.safeParse(version).success === false) {
|
|
validPackage = false;
|
|
issues.push({
|
|
code: "MODULE_PACKAGE_INVALID",
|
|
message: "package.json must declare a strict semantic version.",
|
|
moduleDirectory: directoryName,
|
|
path: "version",
|
|
});
|
|
}
|
|
if (packageType !== "module") {
|
|
validPackage = false;
|
|
issues.push({
|
|
code: "MODULE_PACKAGE_INVALID",
|
|
message: 'package.json must declare "type": "module".',
|
|
moduleDirectory: directoryName,
|
|
path: "type",
|
|
});
|
|
}
|
|
if (layer !== "module") {
|
|
validPackage = false;
|
|
issues.push({
|
|
code: "MODULE_PACKAGE_INVALID",
|
|
message: 'package.json must declare "ekklesia.layer": "module".',
|
|
moduleDirectory: directoryName,
|
|
path: "ekklesia.layer",
|
|
});
|
|
}
|
|
|
|
if (!validPackage || typeof name !== "string" || typeof version !== "string") {
|
|
return undefined;
|
|
}
|
|
return { name, version };
|
|
}
|
|
|
|
async function resolveEntrypoints(
|
|
moduleDirectory: string,
|
|
directoryName: string,
|
|
manifest: ModuleManifest,
|
|
issues: ModuleDiscoveryIssue[],
|
|
): Promise<ResolvedModuleEntrypoints | undefined> {
|
|
const resolved: Partial<Record<keyof ModuleManifest["entrypoints"], string>> = {};
|
|
const canonicalModuleDirectory = await realpath(moduleDirectory);
|
|
|
|
for (const [entrypointName, relativeEntrypoint] of Object.entries(manifest.entrypoints)) {
|
|
if (relativeEntrypoint === undefined) {
|
|
continue;
|
|
}
|
|
const configuredPath = path.resolve(moduleDirectory, relativeEntrypoint);
|
|
if (!pathIsInside(moduleDirectory, configuredPath)) {
|
|
issues.push({
|
|
code: "MODULE_ENTRYPOINT_INVALID",
|
|
message: `${entrypointName} resolves outside its module directory.`,
|
|
moduleDirectory: directoryName,
|
|
moduleId: manifest.id,
|
|
path: `entrypoints.${entrypointName}`,
|
|
});
|
|
continue;
|
|
}
|
|
|
|
try {
|
|
const canonicalEntrypoint = await realpath(configuredPath);
|
|
if (!pathIsInside(canonicalModuleDirectory, canonicalEntrypoint)) {
|
|
issues.push({
|
|
code: "MODULE_ENTRYPOINT_INVALID",
|
|
message: `${entrypointName} resolves through a link outside its module directory.`,
|
|
moduleDirectory: directoryName,
|
|
moduleId: manifest.id,
|
|
path: `entrypoints.${entrypointName}`,
|
|
});
|
|
continue;
|
|
}
|
|
const entrypointStats = await stat(canonicalEntrypoint);
|
|
const hasExpectedKind =
|
|
entrypointName === "migrations" ? entrypointStats.isDirectory() : entrypointStats.isFile();
|
|
if (!hasExpectedKind) {
|
|
issues.push({
|
|
code: "MODULE_ENTRYPOINT_INVALID",
|
|
message:
|
|
entrypointName === "migrations"
|
|
? "migrations must resolve to a directory."
|
|
: `${entrypointName} must resolve to a file.`,
|
|
moduleDirectory: directoryName,
|
|
moduleId: manifest.id,
|
|
path: `entrypoints.${entrypointName}`,
|
|
});
|
|
continue;
|
|
}
|
|
resolved[entrypointName as keyof ModuleManifest["entrypoints"]] = canonicalEntrypoint;
|
|
} catch (error) {
|
|
const code = errorCode(error);
|
|
issues.push({
|
|
code: code === "ENOENT" ? "MODULE_ENTRYPOINT_MISSING" : "MODULE_ENTRYPOINT_INVALID",
|
|
message:
|
|
code === "ENOENT"
|
|
? `${entrypointName} does not exist at ${relativeEntrypoint}.`
|
|
: `${entrypointName} could not be resolved at ${relativeEntrypoint}${
|
|
code ? ` (${code})` : ""
|
|
}.`,
|
|
moduleDirectory: directoryName,
|
|
moduleId: manifest.id,
|
|
path: `entrypoints.${entrypointName}`,
|
|
});
|
|
}
|
|
}
|
|
|
|
if (!resolved.server) {
|
|
return undefined;
|
|
}
|
|
|
|
return {
|
|
server: resolved.server,
|
|
...(resolved.schema ? { schema: resolved.schema } : {}),
|
|
...(resolved.migrations ? { migrations: resolved.migrations } : {}),
|
|
...(resolved.jobs ? { jobs: resolved.jobs } : {}),
|
|
};
|
|
}
|
|
|
|
async function scanModuleDirectory(
|
|
modulesDirectory: string,
|
|
directoryName: string,
|
|
issues: ModuleDiscoveryIssue[],
|
|
): Promise<ModuleCandidate | undefined> {
|
|
const moduleDirectory = path.join(modulesDirectory, directoryName);
|
|
const packagePath = path.join(moduleDirectory, "package.json");
|
|
const manifestPath = path.join(moduleDirectory, MODULE_MANIFEST_FILENAME);
|
|
const canonicalModuleDirectory = await realpath(moduleDirectory);
|
|
let canonicalManifestPath: string | undefined;
|
|
let packageInput: unknown;
|
|
let manifestInput: unknown;
|
|
let packageLoaded = false;
|
|
let manifestLoaded = false;
|
|
|
|
try {
|
|
const canonicalPackagePath = await realpath(packagePath);
|
|
if (!pathIsInside(canonicalModuleDirectory, canonicalPackagePath)) {
|
|
issues.push({
|
|
code: "MODULE_PACKAGE_INVALID",
|
|
message: "package.json must not resolve outside its module directory.",
|
|
moduleDirectory: directoryName,
|
|
});
|
|
} else {
|
|
packageInput = await readJson(canonicalPackagePath);
|
|
packageLoaded = true;
|
|
}
|
|
} catch (error) {
|
|
const code = errorCode(error);
|
|
issues.push({
|
|
code: code === "ENOENT" ? "MODULE_PACKAGE_MISSING" : "MODULE_PACKAGE_INVALID",
|
|
message:
|
|
code === "ENOENT"
|
|
? "package.json is missing."
|
|
: `package.json could not be read or parsed${code ? ` (${code})` : ""}.`,
|
|
moduleDirectory: directoryName,
|
|
});
|
|
}
|
|
|
|
try {
|
|
canonicalManifestPath = await realpath(manifestPath);
|
|
if (!pathIsInside(canonicalModuleDirectory, canonicalManifestPath)) {
|
|
issues.push({
|
|
code: "MODULE_MANIFEST_INVALID",
|
|
message: `${MODULE_MANIFEST_FILENAME} must not resolve outside its module directory.`,
|
|
moduleDirectory: directoryName,
|
|
});
|
|
} else {
|
|
manifestInput = await readJson(canonicalManifestPath);
|
|
manifestLoaded = true;
|
|
}
|
|
} catch (error) {
|
|
const code = errorCode(error);
|
|
issues.push({
|
|
code: code === "ENOENT" ? "MODULE_MANIFEST_MISSING" : "MODULE_MANIFEST_INVALID",
|
|
message:
|
|
code === "ENOENT"
|
|
? `${MODULE_MANIFEST_FILENAME} is missing.`
|
|
: `${MODULE_MANIFEST_FILENAME} could not be read or parsed${code ? ` (${code})` : ""}.`,
|
|
moduleDirectory: directoryName,
|
|
});
|
|
}
|
|
|
|
if (!packageLoaded || !manifestLoaded || !canonicalManifestPath) {
|
|
return undefined;
|
|
}
|
|
|
|
const packageData = validatePackageData(packageInput, directoryName, issues);
|
|
const parsedManifest = safeParseModuleManifest(manifestInput);
|
|
if (!parsedManifest.success) {
|
|
for (const validationIssue of parsedManifest.error.issues) {
|
|
issues.push({
|
|
code: "MODULE_MANIFEST_INVALID",
|
|
message: validationIssue.message,
|
|
moduleDirectory: directoryName,
|
|
path: issuePath(validationIssue.path),
|
|
});
|
|
}
|
|
}
|
|
|
|
if (!packageData || !parsedManifest.success) {
|
|
return undefined;
|
|
}
|
|
|
|
const manifest = parsedManifest.data;
|
|
if (packageData.version !== manifest.version) {
|
|
issues.push({
|
|
code: "MODULE_VERSION_MISMATCH",
|
|
message: `package.json version ${packageData.version} does not match manifest version ${manifest.version}.`,
|
|
moduleDirectory: directoryName,
|
|
moduleId: manifest.id,
|
|
path: "version",
|
|
});
|
|
}
|
|
|
|
const entrypoints = await resolveEntrypoints(moduleDirectory, directoryName, manifest, issues);
|
|
if (!entrypoints) {
|
|
return undefined;
|
|
}
|
|
|
|
return {
|
|
directory: canonicalModuleDirectory,
|
|
directoryName,
|
|
entrypoints,
|
|
manifest,
|
|
manifestPath: canonicalManifestPath,
|
|
packageName: packageData.name,
|
|
};
|
|
}
|
|
|
|
function addGraphEdge(
|
|
dependencyId: string,
|
|
dependentId: string,
|
|
dependents: Map<string, Set<string>>,
|
|
indegrees: Map<string, number>,
|
|
): void {
|
|
const targets = dependents.get(dependencyId);
|
|
if (!targets || targets.has(dependentId)) {
|
|
return;
|
|
}
|
|
targets.add(dependentId);
|
|
indegrees.set(dependentId, (indegrees.get(dependentId) ?? 0) + 1);
|
|
}
|
|
|
|
function nodeParticipatesInCycle(node: string, graph: ReadonlyMap<string, Set<string>>): boolean {
|
|
const visited = new Set<string>();
|
|
const pending = [...(graph.get(node) ?? [])];
|
|
while (pending.length > 0) {
|
|
const candidate = pending.pop();
|
|
if (!candidate) {
|
|
continue;
|
|
}
|
|
if (candidate === node) {
|
|
return true;
|
|
}
|
|
if (visited.has(candidate)) {
|
|
continue;
|
|
}
|
|
visited.add(candidate);
|
|
pending.push(...(graph.get(candidate) ?? []));
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function topologicalModuleIds(
|
|
modulesById: ReadonlyMap<string, ModuleCandidate>,
|
|
dependents: Map<string, Set<string>>,
|
|
indegrees: Map<string, number>,
|
|
issues: ModuleDiscoveryIssue[],
|
|
): string[] {
|
|
const ready = [...modulesById.keys()]
|
|
.filter((moduleId) => indegrees.get(moduleId) === 0)
|
|
.sort(compareText);
|
|
const ordered: string[] = [];
|
|
|
|
while (ready.length > 0) {
|
|
const moduleId = ready.shift();
|
|
if (!moduleId) {
|
|
break;
|
|
}
|
|
ordered.push(moduleId);
|
|
for (const dependentId of [...(dependents.get(moduleId) ?? [])].sort(compareText)) {
|
|
const nextIndegree = (indegrees.get(dependentId) ?? 0) - 1;
|
|
indegrees.set(dependentId, nextIndegree);
|
|
if (nextIndegree === 0) {
|
|
ready.push(dependentId);
|
|
ready.sort(compareText);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ordered.length !== modulesById.size) {
|
|
const cycleMembers = [...modulesById.keys()]
|
|
.filter((moduleId) => nodeParticipatesInCycle(moduleId, dependents))
|
|
.sort(compareText);
|
|
issues.push({
|
|
code: "MODULE_DEPENDENCY_CYCLE",
|
|
message: `Module dependency cycle contains: ${cycleMembers.join(", ")}.`,
|
|
moduleDirectory: cycleMembers.join(","),
|
|
});
|
|
}
|
|
|
|
return ordered;
|
|
}
|
|
|
|
export async function discoverModules(
|
|
options: ModuleDiscoveryOptions,
|
|
): Promise<readonly DiscoveredModule[]> {
|
|
const issues: ModuleDiscoveryIssue[] = [];
|
|
for (const [versionName, version] of [
|
|
["platformVersion", options.platformVersion],
|
|
["moduleSdkVersion", options.moduleSdkVersion],
|
|
] as const) {
|
|
if (!semanticVersionSchema.safeParse(version).success) {
|
|
issues.push({
|
|
code: "DISCOVERY_CONFIGURATION_INVALID",
|
|
message: `${versionName} must be a strict semantic version, received ${version}.`,
|
|
moduleDirectory: ".",
|
|
path: versionName,
|
|
});
|
|
}
|
|
}
|
|
if (issues.length > 0) {
|
|
throw new ModuleDiscoveryError(issues);
|
|
}
|
|
|
|
let directoryEntries: Dirent[];
|
|
try {
|
|
directoryEntries = await readdir(options.modulesDirectory, { withFileTypes: true });
|
|
} catch (error) {
|
|
if (errorCode(error) === "ENOENT") {
|
|
return Object.freeze([]);
|
|
}
|
|
throw new ModuleDiscoveryError([
|
|
{
|
|
code: "MODULES_DIRECTORY_UNREADABLE",
|
|
message: `The configured modules directory could not be read${
|
|
errorCode(error) ? ` (${errorCode(error)})` : ""
|
|
}.`,
|
|
moduleDirectory: ".",
|
|
},
|
|
]);
|
|
}
|
|
|
|
const visibleEntries = directoryEntries
|
|
.filter((entry) => !entry.name.startsWith("."))
|
|
.sort((left, right) => compareText(left.name, right.name));
|
|
const directoryNames: string[] = [];
|
|
for (const entry of visibleEntries) {
|
|
if (entry.isSymbolicLink()) {
|
|
issues.push({
|
|
code: "MODULE_DIRECTORY_INVALID",
|
|
message: "Module directories must not be symbolic links.",
|
|
moduleDirectory: entry.name,
|
|
});
|
|
} else if (entry.isDirectory()) {
|
|
directoryNames.push(entry.name);
|
|
}
|
|
}
|
|
const candidates: ModuleCandidate[] = [];
|
|
for (const directoryName of directoryNames) {
|
|
const candidate = await scanModuleDirectory(options.modulesDirectory, directoryName, issues);
|
|
if (candidate) {
|
|
candidates.push(candidate);
|
|
}
|
|
}
|
|
|
|
const duplicateIds = new Set<string>();
|
|
const duplicatePackageNames = new Set<string>();
|
|
const firstById = new Map<string, ModuleCandidate>();
|
|
const firstByPackageName = new Map<string, ModuleCandidate>();
|
|
for (const candidate of candidates) {
|
|
const existingId = firstById.get(candidate.manifest.id);
|
|
if (existingId) {
|
|
duplicateIds.add(candidate.manifest.id);
|
|
issues.push({
|
|
code: "MODULE_ID_DUPLICATE",
|
|
message: `Module ID ${candidate.manifest.id} is also declared by ${existingId.directoryName}.`,
|
|
moduleDirectory: candidate.directoryName,
|
|
moduleId: candidate.manifest.id,
|
|
path: "id",
|
|
});
|
|
} else {
|
|
firstById.set(candidate.manifest.id, candidate);
|
|
}
|
|
|
|
const existingPackage = firstByPackageName.get(candidate.packageName);
|
|
if (existingPackage) {
|
|
duplicatePackageNames.add(candidate.packageName);
|
|
issues.push({
|
|
code: "MODULE_PACKAGE_NAME_DUPLICATE",
|
|
message: `Package name ${candidate.packageName} is also used by ${existingPackage.directoryName}.`,
|
|
moduleDirectory: candidate.directoryName,
|
|
moduleId: candidate.manifest.id,
|
|
path: "name",
|
|
});
|
|
} else {
|
|
firstByPackageName.set(candidate.packageName, candidate);
|
|
}
|
|
}
|
|
|
|
const modulesById = new Map(
|
|
candidates
|
|
.filter(
|
|
(candidate) =>
|
|
!duplicateIds.has(candidate.manifest.id) &&
|
|
!duplicatePackageNames.has(candidate.packageName),
|
|
)
|
|
.map((candidate) => [candidate.manifest.id, candidate] as const),
|
|
);
|
|
|
|
const capabilityProviders = new Map<string, ModuleCandidate>();
|
|
for (const candidate of modulesById.values()) {
|
|
if (!isVersionCompatible(options.platformVersion, candidate.manifest.compatibility.platform)) {
|
|
issues.push({
|
|
code: "MODULE_PLATFORM_INCOMPATIBLE",
|
|
message: `Platform ${options.platformVersion} does not satisfy ${candidate.manifest.compatibility.platform}.`,
|
|
moduleDirectory: candidate.directoryName,
|
|
moduleId: candidate.manifest.id,
|
|
path: "compatibility.platform",
|
|
});
|
|
}
|
|
if (
|
|
!isVersionCompatible(options.moduleSdkVersion, candidate.manifest.compatibility.moduleSdk)
|
|
) {
|
|
issues.push({
|
|
code: "MODULE_SDK_INCOMPATIBLE",
|
|
message: `Module SDK ${options.moduleSdkVersion} does not satisfy ${candidate.manifest.compatibility.moduleSdk}.`,
|
|
moduleDirectory: candidate.directoryName,
|
|
moduleId: candidate.manifest.id,
|
|
path: "compatibility.moduleSdk",
|
|
});
|
|
}
|
|
|
|
for (const capability of candidate.manifest.capabilities) {
|
|
capabilityProviders.set(capability, candidate);
|
|
}
|
|
}
|
|
|
|
const dependents = new Map<string, Set<string>>();
|
|
const indegrees = new Map<string, number>();
|
|
for (const moduleId of modulesById.keys()) {
|
|
dependents.set(moduleId, new Set());
|
|
indegrees.set(moduleId, 0);
|
|
}
|
|
|
|
for (const candidate of modulesById.values()) {
|
|
for (const dependencyKind of ["required", "optional"] as const) {
|
|
for (const [dependencyId, versionRange] of Object.entries(
|
|
candidate.manifest.dependencies.modules[dependencyKind],
|
|
)) {
|
|
const dependency = modulesById.get(dependencyId);
|
|
if (!dependency) {
|
|
if (dependencyKind === "required") {
|
|
issues.push({
|
|
code: "MODULE_DEPENDENCY_MISSING",
|
|
message: `Required module ${dependencyId} is not installed.`,
|
|
moduleDirectory: candidate.directoryName,
|
|
moduleId: candidate.manifest.id,
|
|
path: `dependencies.modules.${dependencyKind}.${dependencyId}`,
|
|
});
|
|
}
|
|
continue;
|
|
}
|
|
if (!isVersionCompatible(dependency.manifest.version, versionRange)) {
|
|
issues.push({
|
|
code: "MODULE_DEPENDENCY_INCOMPATIBLE",
|
|
message: `${dependencyId} ${dependency.manifest.version} does not satisfy ${versionRange}.`,
|
|
moduleDirectory: candidate.directoryName,
|
|
moduleId: candidate.manifest.id,
|
|
path: `dependencies.modules.${dependencyKind}.${dependencyId}`,
|
|
});
|
|
}
|
|
addGraphEdge(dependencyId, candidate.manifest.id, dependents, indegrees);
|
|
}
|
|
}
|
|
|
|
for (const dependencyKind of ["required", "optional"] as const) {
|
|
for (const [index, capability] of candidate.manifest.dependencies.capabilities[
|
|
dependencyKind
|
|
].entries()) {
|
|
const provider = capabilityProviders.get(capability);
|
|
if (!provider) {
|
|
if (dependencyKind === "required") {
|
|
issues.push({
|
|
code: "MODULE_CAPABILITY_MISSING",
|
|
message: `Required capability ${capability} is not installed.`,
|
|
moduleDirectory: candidate.directoryName,
|
|
moduleId: candidate.manifest.id,
|
|
path: `dependencies.capabilities.${dependencyKind}.${index}`,
|
|
});
|
|
}
|
|
continue;
|
|
}
|
|
addGraphEdge(provider.manifest.id, candidate.manifest.id, dependents, indegrees);
|
|
}
|
|
}
|
|
}
|
|
|
|
const orderedIds = topologicalModuleIds(modulesById, dependents, indegrees, issues);
|
|
if (issues.length > 0) {
|
|
throw new ModuleDiscoveryError(issues);
|
|
}
|
|
|
|
return Object.freeze(
|
|
orderedIds.map((moduleId) => {
|
|
const candidate = modulesById.get(moduleId);
|
|
if (!candidate) {
|
|
throw new Error(`Internal discovery error: ${moduleId} was not indexed.`);
|
|
}
|
|
const { directoryName: _directoryName, ...discoveredModule } = candidate;
|
|
return freezeRecursively(discoveredModule);
|
|
}),
|
|
);
|
|
}
|