@akira-tl/forgerelay 1.1.2 → 1.2.0

package/dist/runtime/config/resolution/language-servers.js

@@ -0,0 +1,237 @@
+import { join } from "node:path";
+import { BUILTIN_LANGUAGE_SERVER_DEFINITIONS, languageServersConfigDefinition, } from "../definition/language-servers.js";
+import { refreshLegacyUserConfigField } from "./project-sources.js";
+import { resolveConfigDomain } from "./resolver.js";
+import { ConfigSourceRuntime } from "../runtime/source-refresh.js";
+const CANONICAL_PRIORITY = 100;
+const LEGACY_PRIORITY = 0;
+const LEGACY_DEPRECATION = {
+    since: "1.2.0",
+    removeIn: "1.4.0",
+    replacement: "language-servers.json",
+};
+export async function resolveLanguageServersConfig(input) {
+    const sources = [];
+    const refreshDiagnostics = [];
+    const sourceRuntime = input.sourceRuntime ?? new ConfigSourceRuntime();
+    if (input.configDir) {
+        const legacy = readLegacyInlineLanguageServers(sourceRuntime, input.configDir);
+        if (legacy.source)
+            sources.push(legacy.source);
+        if (legacy.diagnostic)
+            refreshDiagnostics.push(legacy.diagnostic);
+        const user = readLanguageServerSource(sourceRuntime, "canonical:user:language-servers", "user", join(input.configDir, "language-servers.json"), input.environment);
+        if (user.source)
+            sources.push(user.source);
+        if (user.diagnostic)
+            refreshDiagnostics.push(user.diagnostic);
+    }
+    const sharedConfigDir = input.project?.sharedConfigDir ?? input.projectSharedConfigDir;
+    if (sharedConfigDir) {
+        const shared = readLanguageServerSource(sourceRuntime, "canonical:project:language-servers", "project", join(sharedConfigDir, "language-servers.json"), input.environment);
+        if (shared.source)
+            sources.push(shared.source);
+        if (shared.diagnostic)
+            refreshDiagnostics.push(shared.diagnostic);
+    }
+    if (input.project) {
+        const local = readLanguageServerSource(sourceRuntime, "canonical:project-local:language-servers", "project-local", join(input.project.localConfigDir, "language-servers.json"), input.environment);
+        if (local.source)
+            sources.push(local.source);
+        if (local.diagnostic)
+            refreshDiagnostics.push(local.diagnostic);
+    }
+    const resolution = resolveConfigDomain({
+        definition: languageServersConfigDefinition,
+        sources,
+        environment: input.environment,
+    });
+    resolution.diagnostics = mergeDiagnostics(resolution.diagnostics, refreshDiagnostics);
+    return resolution;
+}
+export function effectiveLanguageServerEntries(resolution) {
+    const servers = isRecord(resolution.values.servers) ? resolution.values.servers : {};
+    return Object.entries(servers).map(([id, value]) => {
+        const entry = resolution.entries[`servers.${id}`];
+        if (!entry || !isRecord(value)) {
+            throw new Error(`Language Server resolver produced an invalid entry for ${id}.`);
+        }
+        return {
+            id,
+            value: value,
+            scope: entry.effective.source.scope,
+        };
+    });
+}
+function readLegacyInlineLanguageServers(sourceRuntime, configDir) {
+    const location = join(configDir, "config.json");
+    const refreshed = refreshLegacyUserConfigField({
+        sourceRuntime,
+        configDir,
+        field: "languageServers",
+        parse: (value) => {
+            if (value === undefined)
+                return undefined;
+            if (!isRecord(value))
+                throw new Error("languageServers must be an object.");
+            return normalizeLanguageServerDefinitions(value);
+        },
+        invalidMessage: "Legacy inline Language Server configuration is invalid.",
+    });
+    if (refreshed.status.state === "missing")
+        return {};
+    const source = refreshed.value === undefined ? undefined : {
+        id: "legacy:user:languageServers",
+        scope: "user",
+        kind: "file",
+        location,
+        priority: LEGACY_PRIORITY,
+        value: refreshed.value,
+        deprecation: LEGACY_DEPRECATION,
+    };
+    if (refreshed.status.state !== "invalid" || !refreshed.issue)
+        return source ? { source } : {};
+    if (refreshed.issueScope === "container")
+        return source ? { source } : {};
+    if (source) {
+        return {
+            source,
+            diagnostic: {
+                severity: "error",
+                code: refreshed.issue.code,
+                source: sourceReference(source),
+                message: refreshed.issue.message,
+                usingLastKnownGood: refreshed.status.usingLastKnownGood,
+                diagnosticChanged: refreshed.status.diagnosticChanged,
+            },
+        };
+    }
+    return {
+        source: invalidSource("legacy:user:languageServers", "user", location, refreshed.issue.message, refreshed.issue.code, LEGACY_PRIORITY, LEGACY_DEPRECATION),
+    };
+}
+function readLanguageServerSource(sourceRuntime, id, scope, location, environment) {
+    const refreshed = sourceRuntime.refreshFile({
+        key: `language-servers:${id}:${location}`,
+        path: location,
+        parse: (raw) => {
+            const value = JSON.parse(raw);
+            return isRecord(value) ? normalizeFileDefinitions(value) : value;
+        },
+        parseIssue: {
+            code: "invalid_source",
+            message: "Configuration source is not valid JSON.",
+        },
+        readIssue: {
+            code: "invalid_source",
+            message: "Configuration source could not be read.",
+        },
+        validate: (value) => {
+            const validation = resolveConfigDomain({
+                definition: languageServersConfigDefinition,
+                sources: [canonicalLanguageServerSource(id, scope, location, value)],
+                environment,
+            });
+            const error = validation.diagnostics.find((diagnostic) => diagnostic.severity === "error");
+            if (!error)
+                return undefined;
+            return {
+                code: error.code === "missing_environment" ? "missing_environment" : "invalid_source",
+                message: error.message,
+            };
+        },
+    });
+    if (refreshed.status.state === "missing")
+        return {};
+    if (refreshed.value !== undefined) {
+        const source = canonicalLanguageServerSource(id, scope, location, refreshed.value);
+        if (refreshed.status.state !== "invalid" || !refreshed.issue)
+            return { source };
+        return {
+            source,
+            diagnostic: {
+                severity: "error",
+                code: refreshed.issue.code,
+                source: sourceReference(source),
+                message: refreshed.issue.message,
+                usingLastKnownGood: true,
+                diagnosticChanged: refreshed.status.diagnosticChanged,
+            },
+        };
+    }
+    const source = invalidSource(id, scope, location, refreshed.issue?.message ?? "Language Server configuration is invalid.", refreshed.issue?.code);
+    return { source };
+}
+function canonicalLanguageServerSource(id, scope, location, value) {
+    return {
+        id,
+        scope,
+        kind: "file",
+        location,
+        priority: CANONICAL_PRIORITY,
+        shadowsLowerPriority: true,
+        value,
+    };
+}
+function invalidSource(id, scope, location, message, code = "invalid_source", priority = CANONICAL_PRIORITY, deprecation) {
+    return {
+        id,
+        scope,
+        kind: "file",
+        location,
+        priority,
+        ...(priority === CANONICAL_PRIORITY ? { shadowsLowerPriority: true } : {}),
+        ...(deprecation ? { deprecation } : {}),
+        error: { code, message },
+    };
+}
+function sourceReference(source) {
+    return {
+        id: source.id,
+        scope: source.scope,
+        kind: source.kind,
+        ...(source.location ? { location: source.location } : {}),
+        priority: source.priority,
+    };
+}
+function mergeDiagnostics(left, right) {
+    const seen = new Set();
+    return [...left, ...right].filter((diagnostic) => {
+        const key = `${diagnostic.source.id}\0${diagnostic.code}\0${diagnostic.message}\0${diagnostic.usingLastKnownGood === true}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function normalizeFileDefinitions(value) {
+    const { $schema, ...definitions } = value;
+    return {
+        ...($schema === undefined ? {} : { $schema }),
+        ...normalizeLanguageServerDefinitions(definitions),
+    };
+}
+export function normalizeLanguageServerDefinitions(value) {
+    return Object.fromEntries(Object.entries(value).map(([id, raw]) => {
+        if (!isRecord(raw))
+            return [id, raw];
+        if (raw.disabled === true || raw.enabled === false)
+            return [id, { disabled: true }];
+        const { enabled: _enabled, disabled: _disabled, ...rest } = raw;
+        const builtin = BUILTIN_LANGUAGE_SERVER_DEFINITIONS[id];
+        if (!builtin)
+            return [id, rest];
+        return [id, {
+                ...builtin,
+                ...rest,
+                env: { ...(builtin.env ?? {}), ...(isRecord(rest.env) ? rest.env : {}) },
+                languageIdByExtension: {
+                    ...(builtin.languageIdByExtension ?? {}),
+                    ...(isRecord(rest.languageIdByExtension) ? rest.languageIdByExtension : {}),
+                },
+            }];
+    }));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/runtime/config/resolution/project-sources.js

@@ -0,0 +1,159 @@
+import { readFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { resolveGeneralConfig } from "./general.js";
+export function refreshLegacyUserConfigField(input) {
+    const location = join(input.configDir, "config.json");
+    const refreshed = input.sourceRuntime.refreshFile({
+        key: `legacy-user-config:${input.field}:${location}`,
+        path: location,
+        parse: (raw) => {
+            let value;
+            try {
+                value = JSON.parse(raw);
+            }
+            catch {
+                throw new LegacyUserConfigFieldError("container");
+            }
+            if (!isRecord(value))
+                throw new LegacyUserConfigFieldError("container");
+            const validation = resolveGeneralConfig({
+                env: {},
+                user: value,
+                userSourcePath: location,
+            });
+            const error = validation.diagnostics.find((diagnostic) => diagnostic.severity === "error");
+            if (error)
+                throw new LegacyUserConfigFieldError("container");
+            try {
+                return input.parse(value[input.field]);
+            }
+            catch {
+                throw new LegacyUserConfigFieldError("field");
+            }
+        },
+        parseIssue: (error) => ({
+            code: "invalid_source",
+            message: error instanceof LegacyUserConfigFieldError && error.scope === "field"
+                ? input.invalidMessage
+                : "General configuration is invalid.",
+        }),
+        readIssue: {
+            code: "invalid_source",
+            message: "General configuration could not be read.",
+        },
+    });
+    return {
+        ...refreshed,
+        ...(refreshed.issue
+            ? { issueScope: refreshed.issue.message === input.invalidMessage ? "field" : "container" }
+            : {}),
+    };
+}
+class LegacyUserConfigFieldError extends Error {
+    scope;
+    constructor(scope) {
+        super(scope);
+        this.scope = scope;
+    }
+}
+export async function resolveProjectGeneralConfig(project, input = {}) {
+    const userSource = await readJsonConfigSource({
+        id: "user:config",
+        scope: "user",
+        location: join(project.configDir, "config.json"),
+    });
+    const projectSources = await loadProjectConfigSources(project, {
+        domain: "config",
+        fileName: "config.json",
+    });
+    const resolutionInput = {
+        ...(input.env === undefined ? {} : { env: input.env }),
+        ...(input.cli === undefined ? {} : { cli: input.cli }),
+        ...(userSource === undefined ? {} : { userSource }),
+    };
+    const projectSource = projectSources.find((source) => source.scope === "project");
+    const projectLocalSource = projectSources.find((source) => source.scope === "project-local");
+    if (projectSource)
+        resolutionInput.projectSource = projectSource;
+    if (projectLocalSource)
+        resolutionInput.projectLocalSource = projectLocalSource;
+    return resolveGeneralConfig(resolutionInput);
+}
+export async function loadProjectConfigSources(project, options) {
+    const fileName = normalizeConfigFileName(options.fileName);
+    const domain = normalizeDomain(options.domain);
+    const sources = [];
+    const projectSource = await readJsonConfigSource({
+        id: `project:${domain}`,
+        scope: "project",
+        location: join(project.sharedConfigDir, fileName),
+    });
+    if (projectSource)
+        sources.push(projectSource);
+    const localSource = await readJsonConfigSource({
+        id: `project-local:${domain}`,
+        scope: "project-local",
+        location: join(project.localConfigDir, fileName),
+    });
+    if (localSource)
+        sources.push(localSource);
+    return sources;
+}
+export async function readJsonConfigSource(input) {
+    let raw;
+    try {
+        raw = await readFile(input.location, "utf8");
+    }
+    catch (error) {
+        if (isErrno(error, "ENOENT"))
+            return undefined;
+        return {
+            ...input,
+            kind: "file",
+            priority: 0,
+            error: {
+                code: "invalid_source",
+                message: "Configuration source could not be read.",
+            },
+        };
+    }
+    try {
+        return {
+            ...input,
+            kind: "file",
+            priority: 0,
+            value: JSON.parse(raw),
+        };
+    }
+    catch {
+        return {
+            ...input,
+            kind: "file",
+            priority: 0,
+            error: {
+                code: "invalid_source",
+                message: "Configuration source is not valid JSON.",
+            },
+        };
+    }
+}
+function normalizeConfigFileName(value) {
+    const normalized = value.trim();
+    if (!normalized || normalized === "." || normalized === ".." || basename(normalized) !== normalized) {
+        throw new Error("Project configuration fileName must be one file name without path separators.");
+    }
+    return normalized;
+}
+function normalizeDomain(value) {
+    const normalized = value.trim();
+    if (!/^[a-z][a-z0-9-]*$/.test(normalized)) {
+        throw new Error("Project configuration domain must use lowercase letters, digits, and hyphens.");
+    }
+    return normalized;
+}
+function isErrno(error, code) {
+    return error instanceof Error && "code" in error && error.code === code;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}