@chidchanun/bcp 0.1.8 → 0.1.10

package/packages/cli/src/update.ts

@@ -0,0 +1,860 @@
+import fs from "node:fs";
+import path from "node:path";
+import {
+    spawn,
+} from "node:child_process";
+
+const FRAMEWORK_PACKAGE =
+    "@chidchanun/bcp";
+
+const LOCKFILES = [
+    ["package-lock.json", "npm"],
+    ["pnpm-lock.yaml", "pnpm"],
+    ["yarn.lock", "yarn"],
+    ["bun.lock", "bun"],
+    ["bun.lockb", "bun"],
+] as const;
+
+type DependencySectionName =
+    | "dependencies"
+    | "devDependencies"
+    | "optionalDependencies";
+
+export type PackageManager =
+    | "npm"
+    | "pnpm"
+    | "yarn"
+    | "bun";
+
+interface ProjectPackageJson {
+    name?: unknown;
+    scripts?: Record<string, string>;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
+    [key: string]: unknown;
+}
+
+export interface FrameworkDependency {
+    section: DependencySectionName;
+    key: "bcp" | "@chidchanun/bcp";
+    specifier: string;
+}
+
+export interface UpdatePlan {
+    currentSpecifier: string;
+    currentVersion: string | null;
+    targetVersion: string;
+    nextSpecifier: string;
+    dependency: FrameworkDependency;
+    addUpdateScript: boolean;
+    changed: boolean;
+}
+
+export interface UpdateCommandOptions {
+    rootDirectory: string;
+    target?: string;
+    check?: boolean;
+    dryRun?: boolean;
+}
+
+export async function runBcpUpdate(
+    options: UpdateCommandOptions
+): Promise<UpdatePlan> {
+    const rootDirectory =
+        path.resolve(
+            options.rootDirectory
+        );
+    const packageFile =
+        path.join(
+            rootDirectory,
+            "package.json"
+        );
+
+    if (!fs.existsSync(packageFile)) {
+        throw new Error(
+            `BCP Update: package.json was not found in ${rootDirectory}.`
+        );
+    }
+
+    const originalPackageText =
+        fs.readFileSync(
+            packageFile,
+            "utf8"
+        );
+    const packageJson =
+        parsePackageJson(
+            originalPackageText,
+            packageFile
+        );
+    const target =
+        normalizeUpdateTarget(
+            options.target
+        );
+    const targetVersion =
+        await resolvePublishedVersion(
+            target,
+            rootDirectory
+        );
+    const plan =
+        createUpdatePlan(
+            packageJson,
+            targetVersion
+        );
+    const installedVersion =
+        readInstalledFrameworkVersion(
+            rootDirectory
+        );
+
+    console.log("");
+    console.log(
+        `[BCP Update] Project: ${rootDirectory}`
+    );
+    console.log(
+        `[BCP Update] Installed: ${installedVersion ?? plan.currentVersion ?? plan.currentSpecifier}`
+    );
+    console.log(
+        `[BCP Update] Target: ${targetVersion} (${target})`
+    );
+    console.log(
+        `[BCP Update] Dependency: ${plan.dependency.key} ${plan.currentSpecifier} -> ${plan.nextSpecifier}`
+    );
+
+    if (plan.addUpdateScript) {
+        console.log(
+            "[BCP Update] Project script: add `update: bcp update`."
+        );
+    }
+
+    if (
+        installedVersion === targetVersion &&
+        !plan.changed
+    ) {
+        console.log(
+            "[BCP Update] Already up to date."
+        );
+        console.log("");
+        return plan;
+    }
+
+    if (
+        options.check ||
+        options.dryRun
+    ) {
+        console.log(
+            options.check
+                ? "[BCP Update] Update available; no files were changed (--check)."
+                : "[BCP Update] Dry run complete; no files were changed."
+        );
+        console.log("");
+        return plan;
+    }
+
+    const packageManager =
+        detectPackageManager(
+            rootDirectory
+        );
+    const lockfile =
+        getPackageManagerLockfile(
+            rootDirectory,
+            packageManager
+        );
+    const originalLockfile =
+        lockfile &&
+        fs.existsSync(lockfile)
+            ? fs.readFileSync(
+                lockfile
+            )
+            : null;
+
+    const nextPackageJson =
+        applyUpdatePlan(
+            packageJson,
+            plan
+        );
+
+    writeJsonAtomic(
+        packageFile,
+        nextPackageJson
+    );
+
+    try {
+        console.log(
+            `[BCP Update] Installing with ${packageManager}...`
+        );
+
+        await runPackageInstall(
+            packageManager,
+            rootDirectory
+        );
+    } catch (error) {
+        fs.writeFileSync(
+            packageFile,
+            originalPackageText,
+            "utf8"
+        );
+
+        if (lockfile) {
+            if (originalLockfile) {
+                fs.writeFileSync(
+                    lockfile,
+                    originalLockfile
+                );
+            } else if (
+                fs.existsSync(lockfile)
+            ) {
+                fs.rmSync(
+                    lockfile,
+                    {
+                        force: true,
+                    }
+                );
+            }
+        }
+
+        throw new Error(
+            `BCP Update: install failed; package.json${lockfile ? " and the detected lockfile" : ""} were restored. ${error instanceof Error ? error.message : String(error)}`
+        );
+    }
+
+    const finalVersion =
+        readInstalledFrameworkVersion(
+            rootDirectory
+        );
+
+    if (
+        finalVersion &&
+        finalVersion !== targetVersion
+    ) {
+        throw new Error(
+            `BCP Update: install completed but resolved framework version is ${finalVersion}; expected ${targetVersion}.`
+        );
+    }
+
+    console.log(
+        `[BCP Update] Updated to ${targetVersion}.`
+    );
+    console.log(
+        "[BCP Update] Next time you can run `npm run update` from this project."
+    );
+    console.log(
+        "[BCP Update] Recommended: run your typecheck and test suite before committing package.json and the lockfile."
+    );
+    console.log("");
+
+    return plan;
+}
+
+export function createUpdatePlan(
+    packageJson: ProjectPackageJson,
+    targetVersion: string
+): UpdatePlan {
+    assertVersion(
+        targetVersion,
+        "resolved target version"
+    );
+
+    const dependency =
+        findFrameworkDependency(
+            packageJson
+        );
+
+    assertRegistryDependency(
+        dependency.specifier
+    );
+
+    /*
+     * Updating is an explicit operation, so pin the resolved registry
+     * version. This prevents a later plain package-manager install from
+     * silently jumping to a different BCP release than the one the updater
+     * verified.
+     */
+    const nextSpecifier =
+        dependency.key === "bcp"
+            ? `npm:${FRAMEWORK_PACKAGE}@${targetVersion}`
+            : targetVersion;
+    const addUpdateScript =
+        packageJson.scripts?.update ===
+        undefined;
+
+    return {
+        currentSpecifier:
+            dependency.specifier,
+        currentVersion:
+            extractVersion(
+                dependency.specifier
+            ),
+        targetVersion,
+        nextSpecifier,
+        dependency,
+        addUpdateScript,
+        changed:
+            dependency.specifier !==
+                nextSpecifier ||
+            addUpdateScript,
+    };
+}
+
+export function applyUpdatePlan(
+    packageJson: ProjectPackageJson,
+    plan: UpdatePlan
+): ProjectPackageJson {
+    const copy =
+        structuredClone(
+            packageJson
+        );
+    const section =
+        copy[
+            plan.dependency.section
+        ];
+
+    if (
+        !section ||
+        typeof section !== "object"
+    ) {
+        throw new Error(
+            `BCP Update: dependency section ${plan.dependency.section} disappeared while applying the update.`
+        );
+    }
+
+    (
+        section as
+        Record<string, string>
+    )[
+        plan.dependency.key
+    ] =
+        plan.nextSpecifier;
+
+    if (plan.addUpdateScript) {
+        copy.scripts = {
+            ...copy.scripts,
+            update:
+                "bcp update",
+        };
+    }
+
+    return copy;
+}
+
+export function findFrameworkDependency(
+    packageJson: ProjectPackageJson
+): FrameworkDependency {
+    const matches:
+        FrameworkDependency[] = [];
+
+    for (
+        const sectionName
+        of [
+            "dependencies",
+            "devDependencies",
+            "optionalDependencies",
+        ] as const
+    ) {
+        const section =
+            packageJson[
+                sectionName
+            ];
+
+        if (!section) {
+            continue;
+        }
+
+        for (
+            const key
+            of [
+                "bcp",
+                FRAMEWORK_PACKAGE,
+            ] as const
+        ) {
+            const specifier =
+                section[key];
+
+            if (
+                typeof specifier === "string" &&
+                specifier.trim() !== ""
+            ) {
+                matches.push({
+                    section:
+                        sectionName,
+                    key,
+                    specifier:
+                        specifier.trim(),
+                });
+            }
+        }
+    }
+
+    if (matches.length === 0) {
+        throw new Error(
+            "BCP Update: this project does not declare `bcp` or `@chidchanun/bcp` in dependencies."
+        );
+    }
+
+    if (matches.length > 1) {
+        throw new Error(
+            "BCP Update: multiple BCP framework dependencies were found. Keep only one of `bcp` or `@chidchanun/bcp` before updating."
+        );
+    }
+
+    return matches[0];
+}
+
+export function detectPackageManager(
+    rootDirectory: string
+): PackageManager {
+    const detected =
+        LOCKFILES
+            .filter(
+                ([fileName]) =>
+                    fs.existsSync(
+                        path.join(
+                            rootDirectory,
+                            fileName
+                        )
+                    )
+            )
+            .map(
+                ([, manager]) =>
+                    manager
+            );
+    const unique =
+        Array.from(
+            new Set(
+                detected
+            )
+        );
+
+    if (unique.length > 1) {
+        throw new Error(
+            `BCP Update: multiple package-manager lockfiles were found (${unique.join(", ")}). Keep only the lockfile for the package manager you use.`
+        );
+    }
+
+    if (unique.length === 1) {
+        return unique[0];
+    }
+
+    const userAgent =
+        process.env.npm_config_user_agent ??
+        "";
+
+    if (/^pnpm\//i.test(userAgent)) {
+        return "pnpm";
+    }
+
+    if (/^yarn\//i.test(userAgent)) {
+        return "yarn";
+    }
+
+    if (/^bun\//i.test(userAgent)) {
+        return "bun";
+    }
+
+    return "npm";
+}
+
+export function normalizeUpdateTarget(
+    value: string | undefined
+): string {
+    const target =
+        value?.trim() ||
+        "latest";
+
+    if (
+        /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(
+            target
+        ) ||
+        /^[A-Za-z][A-Za-z0-9._-]*$/.test(
+            target
+        )
+    ) {
+        return target;
+    }
+
+    throw new Error(
+        `BCP Update: invalid target ${target}. Use a version such as 0.1.10 or an npm dist-tag such as latest.`
+    );
+}
+
+async function resolvePublishedVersion(
+    target: string,
+    rootDirectory: string
+): Promise<string> {
+    const output =
+        await runCommandCapture(
+            "npm",
+            [
+                "view",
+                `${FRAMEWORK_PACKAGE}@${target}`,
+                "version",
+                "--json",
+                "--prefer-online",
+            ],
+            rootDirectory
+        );
+
+    let parsed:
+        unknown;
+
+    try {
+        parsed =
+            JSON.parse(
+                output
+            );
+    } catch {
+        parsed =
+            output
+                .trim()
+                .replace(
+                    /^"|"$/g,
+                    ""
+                );
+    }
+
+    if (
+        Array.isArray(parsed)
+    ) {
+        parsed =
+            parsed.at(-1);
+    }
+
+    const version =
+        String(
+            parsed ?? ""
+        ).trim();
+
+    assertVersion(
+        version,
+        `${FRAMEWORK_PACKAGE}@${target}`
+    );
+
+    return version;
+}
+
+function assertRegistryDependency(
+    specifier: string
+): void {
+    if (
+        /^(?:file:|link:|workspace:|git\+|https?:)/i.test(
+            specifier
+        )
+    ) {
+        throw new Error(
+            `BCP Update: dependency specifier ${specifier} is not a published npm dependency. Use a registry dependency before running update.`
+        );
+    }
+}
+
+function extractVersion(
+    specifier: string
+): string | null {
+    const match =
+        /(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)/.exec(
+            specifier
+        );
+
+    return match?.[1] ??
+        null;
+}
+
+function readInstalledFrameworkVersion(
+    rootDirectory: string
+): string | null {
+    for (
+        const packageFile
+        of [
+            path.join(
+                rootDirectory,
+                "node_modules",
+                "bcp",
+                "package.json"
+            ),
+            path.join(
+                rootDirectory,
+                "node_modules",
+                "@chidchanun",
+                "bcp",
+                "package.json"
+            ),
+        ]
+    ) {
+        if (!fs.existsSync(packageFile)) {
+            continue;
+        }
+
+        try {
+            const metadata =
+                JSON.parse(
+                    fs.readFileSync(
+                        packageFile,
+                        "utf8"
+                    )
+                ) as {
+                    version?: unknown;
+                };
+
+            if (
+                typeof metadata.version === "string" &&
+                /^\d+\.\d+\.\d+/.test(
+                    metadata.version
+                )
+            ) {
+                return metadata.version;
+            }
+        } catch {
+            // Fall back to the declared dependency version.
+        }
+    }
+
+    return null;
+}
+
+function getPackageManagerLockfile(
+    rootDirectory: string,
+    manager: PackageManager
+): string | null {
+    const entry =
+        LOCKFILES.find(
+            ([fileName, candidate]) =>
+                candidate === manager &&
+                fs.existsSync(
+                    path.join(
+                        rootDirectory,
+                        fileName
+                    )
+                )
+        );
+
+    return entry
+        ? path.join(
+            rootDirectory,
+            entry[0]
+        )
+        : null;
+}
+
+function runPackageInstall(
+    packageManager: PackageManager,
+    rootDirectory: string
+): Promise<void> {
+    return runCommandInherited(
+        packageManager,
+        [
+            "install",
+        ],
+        rootDirectory
+    );
+}
+
+function runCommandCapture(
+    command: string,
+    args: string[],
+    cwd: string
+): Promise<string> {
+    const invocation =
+        resolveCommandInvocation(
+            command,
+            args
+        );
+
+    return new Promise<string>(
+        (
+            resolve,
+            reject
+        ) => {
+            const chunks:
+                string[] = [];
+            const errors:
+                string[] = [];
+            const child =
+                spawn(
+                    invocation.command,
+                    invocation.args,
+                    {
+                        cwd,
+                        env:
+                            process.env,
+                        stdio: [
+                            "ignore",
+                            "pipe",
+                            "pipe",
+                        ],
+                    }
+                );
+
+            child.stdout?.on(
+                "data",
+                (chunk) => {
+                    chunks.push(
+                        chunk.toString()
+                    );
+                }
+            );
+            child.stderr?.on(
+                "data",
+                (chunk) => {
+                    errors.push(
+                        chunk.toString()
+                    );
+                }
+            );
+            child.once(
+                "error",
+                reject
+            );
+            child.once(
+                "exit",
+                (code) => {
+                    if (code === 0) {
+                        resolve(
+                            chunks.join("")
+                        );
+                        return;
+                    }
+
+                    reject(
+                        new Error(
+                            `${command} ${args.join(" ")} failed with exit code ${code}. ${errors.join("").trim()}`
+                        )
+                    );
+                }
+            );
+        }
+    );
+}
+
+function runCommandInherited(
+    command: string,
+    args: string[],
+    cwd: string
+): Promise<void> {
+    const invocation =
+        resolveCommandInvocation(
+            command,
+            args
+        );
+
+    return new Promise<void>(
+        (
+            resolve,
+            reject
+        ) => {
+            const child =
+                spawn(
+                    invocation.command,
+                    invocation.args,
+                    {
+                        cwd,
+                        env:
+                            process.env,
+                        stdio:
+                            "inherit",
+                    }
+                );
+
+            child.once(
+                "error",
+                reject
+            );
+            child.once(
+                "exit",
+                (code) => {
+                    if (code === 0) {
+                        resolve();
+                        return;
+                    }
+
+                    reject(
+                        new Error(
+                            `${command} install failed with exit code ${code}.`
+                        )
+                    );
+                }
+            );
+        }
+    );
+}
+
+function resolveCommandInvocation(
+    command: string,
+    args: string[]
+): {
+    command: string;
+    args: string[];
+} {
+    if (
+        process.platform === "win32"
+    ) {
+        return {
+            command:
+                process.env.ComSpec ??
+                "cmd.exe",
+            args: [
+                "/d",
+                "/s",
+                "/c",
+                command,
+                ...args,
+            ],
+        };
+    }
+
+    return {
+        command,
+        args,
+    };
+}
+
+function writeJsonAtomic(
+    filePath: string,
+    value: unknown
+): void {
+    const temporary =
+        `${filePath}.bcp-update-${process.pid}`;
+    const content =
+        `${JSON.stringify(
+            value,
+            null,
+            2
+        )}\n`;
+
+    fs.writeFileSync(
+        temporary,
+        content,
+        "utf8"
+    );
+    fs.renameSync(
+        temporary,
+        filePath
+    );
+}
+
+function parsePackageJson(
+    content: string,
+    filePath: string
+): ProjectPackageJson {
+    try {
+        return JSON.parse(
+            content
+        ) as ProjectPackageJson;
+    } catch (error) {
+        throw new Error(
+            `BCP Update: invalid package.json at ${filePath}. ${error instanceof Error ? error.message : String(error)}`
+        );
+    }
+}
+
+function assertVersion(
+    value: string,
+    label: string
+): void {
+    if (
+        !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(
+            value
+        )
+    ) {
+        throw new Error(
+            `BCP Update: ${label} resolved to invalid version ${value || "(empty)"}.`
+        );
+    }
+}