@no-k/hermes 0.1.0 → 0.3.0

package/dist/lib/versions.js

@@ -0,0 +1,251 @@
+import { createHash } from "node:crypto";
+import { existsSync, realpathSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { Range, minVersion, satisfies, valid, validRange } from "semver";
+import { readDestination } from "./files.js";
+import { isRecord, readJsonObject } from "./json.js";
+export function sourceHash(content) {
+    return createHash("sha256").update(content).digest("hex");
+}
+// OR 범위를 각각 전개한 뒤 AND 교집합의 실제 최소 버전이 모든 범위를 만족하는지 확인한다.
+export function commonVersionRange(ranges) {
+    let combinations = [""];
+    for (const range of new Set(ranges)) {
+        const alternatives = new Range(range).set.map((set) => set.map((entry) => entry.value).join(" "));
+        combinations = combinations
+            .flatMap((previous) => alternatives.map((alternative) => (previous + " " + alternative).trim()))
+            .filter((combined) => minVersion(combined) !== null);
+        if (!combinations.length)
+            return null;
+    }
+    const compatible = combinations.flatMap((combined) => {
+        const minimum = minVersion(combined);
+        if (!minimum)
+            return [];
+        if (ranges.every((range) => satisfies(minimum, range)))
+            return [combined || "*"];
+        const stable = [minimum.major, minimum.minor, minimum.patch].join(".");
+        return satisfies(stable, combined) && ranges.every((range) => satisfies(stable, range))
+            ? [(combined + " >=" + stable).trim()]
+            : [];
+    });
+    return compatible.length ? [...new Set(compatible)].join(" || ") : null;
+}
+export function haveCommonVersion(ranges) {
+    return commonVersionRange(ranges) !== null;
+}
+function installedPackage(cwd, packageName) {
+    const require = createRequire(path.join(cwd, "package.json"));
+    // import 전용 exports를 쓰는 패키지도 실제 node_modules manifest에서 확인한다.
+    for (const directory of require.resolve.paths(packageName) ?? []) {
+        const file = path.join(directory, packageName, "package.json");
+        if (existsSync(file))
+            return realpathSync(file);
+    }
+    try {
+        return realpathSync(require.resolve(packageName + "/package.json"));
+    }
+    catch {
+        // exports로 package.json을 숨긴 패키지도 실제 entry에서 manifest를 찾는다.
+        try {
+            let directory = path.dirname(realpathSync(require.resolve(packageName)));
+            while (directory !== path.dirname(directory)) {
+                const file = path.join(directory, "package.json");
+                if (existsSync(file) && readJsonObject(file).name === packageName)
+                    return file;
+                directory = path.dirname(directory);
+            }
+        }
+        catch {
+            /* 아직 설치하지 않은 외부 패키지는 설치 안내에 남긴다. */
+        }
+        return undefined;
+    }
+}
+export function planInstalledVersions(current, targets, files, catalog, cwd) {
+    const planned = new Map(files.map((file) => [file.destination, file]));
+    const guards = new Map();
+    const errors = new Set();
+    function resultingContent(destination) {
+        const file = planned.get(destination);
+        if (file)
+            return file.action === "keep" ? file.existingContent : file.content;
+        const cached = guards.get(destination);
+        if (cached)
+            return cached.existingContent;
+        const content = readDestination(destination);
+        guards.set(destination, {
+            file: path.basename(destination),
+            destination,
+            existingContent: content,
+            content: content ?? "",
+            action: content === null ? "create" : "keep",
+        });
+        return content;
+    }
+    function matches(module, directory) {
+        return Object.entries(module.files).every(([file, hash]) => {
+            const content = resultingContent(path.join(directory, file));
+            return content !== null && sourceHash(content) === hash;
+        });
+    }
+    const groups = new Map();
+    function group(directory) {
+        const absolute = path.resolve(cwd, directory);
+        let value = groups.get(absolute);
+        if (!value) {
+            value = { candidates: new Map(), records: [] };
+            groups.set(absolute, value);
+        }
+        return value;
+    }
+    function add(directory, module) {
+        const candidates = group(directory).candidates;
+        const versions = candidates.get(module.packageName) ?? [];
+        if (!versions.some((entry) => JSON.stringify(entry) === JSON.stringify(module)))
+            versions.push(module);
+        candidates.set(module.packageName, versions);
+    }
+    // 새 카탈로그와 이전 설치의 해시 중 실제 설치 결과와 일치하는 버전을 사용한다.
+    for (const target of targets)
+        for (const item of target.items)
+            for (const module of item.modules)
+                add(target.directory, module);
+    for (const record of current.installed) {
+        group(record.directory).records.push(record);
+        for (const module of record.source?.modules ?? [])
+            add(record.directory, module);
+    }
+    const sources = new Map();
+    const externals = [];
+    for (const [directory, { candidates, records }] of groups) {
+        // 내부 소스는 목적지별로 검사하고, npm peer는 프로젝트 전체 설치 기록과 비교한다.
+        const affected = targets.some((target) => target.directory === directory) ||
+            [...candidates.values()]
+                .flat()
+                .some((module) => Object.keys(module.files).some((file) => planned.has(path.join(directory, file))));
+        const providers = new Map();
+        for (const [packageName, versions] of candidates) {
+            const matched = versions.find((module) => matches(module, directory));
+            const module = matched ?? versions[0];
+            if (!module)
+                throw new Error("Missing module candidate: " + packageName);
+            providers.set(packageName, {
+                module,
+                verified: !!matched,
+                present: Object.keys(module.files).some((file) => resultingContent(path.join(directory, file)) !== null),
+            });
+        }
+        for (const { module } of [...providers.values()].filter((provider) => provider.present)) {
+            externals.push(...module.requires.filter((requirement) => !requirement.internal));
+            for (const requirement of module.requires.filter((entry) => affected && entry.internal)) {
+                const provider = providers.get(requirement.packageName);
+                const mustMatch = !requirement.optional || provider?.present === true;
+                if (mustMatch &&
+                    (!provider?.present || !provider.verified || !satisfies(provider.module.version, requirement.range))) {
+                    errors.add(module.packageName +
+                        "@" +
+                        module.version +
+                        " requires " +
+                        requirement.packageName +
+                        "@" +
+                        requirement.range +
+                        "; installed result: " +
+                        (!provider?.present
+                            ? "missing"
+                            : provider.verified
+                                ? provider.module.version
+                                : "modified / unknown version") +
+                        ". Review the shared files and update dependent utilities together.");
+                }
+            }
+        }
+        for (const record of affected ? records : []) {
+            const item = targets
+                .filter((target) => target.directory === directory)
+                .flatMap((target) => target.items)
+                .find((candidate) => candidate.name === record.name && candidate.scope === record.scope);
+            if (item) {
+                sources.set(record, {
+                    catalogVersion: catalog.version,
+                    requestedVersion: item.version,
+                    status: item.modules.every((module) => matches(module, directory)) ? "verified" : "modified",
+                    modules: item.modules.map((module) => {
+                        const provider = providers.get(module.packageName);
+                        return provider?.verified ? provider.module : module;
+                    }),
+                });
+            }
+            else if (record.source) {
+                sources.set(record, {
+                    ...record.source,
+                    status: record.source.modules.every((module) => matches(module, directory))
+                        ? record.source.status
+                        : "modified",
+                });
+            }
+        }
+    }
+    const projectManifestPath = path.join(cwd, "package.json");
+    const projectContent = resultingContent(projectManifestPath);
+    const projectManifest = projectContent === null ? {} : JSON.parse(projectContent);
+    if (!isRecord(projectManifest))
+        throw new Error("Invalid project package.json.");
+    const packages = new Map();
+    const dependencies = [];
+    const requestedPackages = new Set(targets.flatMap((target) => target.items.flatMap((item) => item.modules.flatMap((module) => module.requires
+        .filter((requirement) => !requirement.internal && !requirement.optional)
+        .map((requirement) => requirement.packageName)))));
+    for (const requirement of externals) {
+        const requirements = packages.get(requirement.packageName) ?? [];
+        requirements.push(requirement);
+        packages.set(requirement.packageName, requirements);
+    }
+    for (const [packageName, requirements] of packages) {
+        const packageFile = installedPackage(cwd, packageName);
+        const declared = [
+            projectManifest.dependencies,
+            projectManifest.devDependencies,
+            projectManifest.peerDependencies,
+        ].flatMap((value) => isRecord(value) && typeof value[packageName] === "string" ? [value[packageName]] : []);
+        if (packageFile || declared.length || requirements.some((requirement) => !requirement.optional)) {
+            const ranges = [
+                ...requirements.map((requirement) => requirement.range),
+                ...declared.filter((range) => validRange(range)),
+            ];
+            const compatibleRange = commonVersionRange(ranges);
+            if (!compatibleRange) {
+                errors.add("Incompatible package requirements for " + packageName + ": " + ranges.join(" AND "));
+            }
+            if (compatibleRange && requestedPackages.has(packageName))
+                dependencies.push(packageName + "@" + compatibleRange);
+            if (packageFile) {
+                const content = resultingContent(packageFile);
+                const manifest = content === null ? {} : JSON.parse(content);
+                const version = isRecord(manifest) && typeof manifest.version === "string" ? manifest.version : "";
+                if (!valid(version) || requirements.some((requirement) => !satisfies(version, requirement.range))) {
+                    errors.add("Installed " +
+                        packageName +
+                        "@" +
+                        (version || "unknown") +
+                        " does not satisfy " +
+                        requirements.map((requirement) => requirement.range).join(" AND ") +
+                        ".");
+                }
+            }
+        }
+    }
+    return {
+        config: {
+            ...current,
+            installed: current.installed.map((item) => {
+                const source = sources.get(item);
+                return source ? { ...item, source } : item;
+            }),
+        },
+        compatibilityErrors: [...errors],
+        compatibilityGuards: [...guards.values()],
+        dependencies: dependencies.sort(),
+    };
+}