@chidchanun/bcp 0.1.0

package/packages/cli/src/bootstrap.ts

@@ -0,0 +1,514 @@
+import {
+    spawn,
+    type ChildProcess,
+} from "node:child_process";
+import path from "node:path";
+import {
+    fileURLToPath,
+} from "node:url";
+
+import chokidar from "chokidar";
+
+import {
+    applyResolvedBcpConfig,
+    getConfigFileNames,
+    resolveBcpConfig,
+} from "../../config/src/index.js";
+
+import {
+    getEnvironmentFileNames,
+    loadEnvironment,
+    type EnvironmentMode,
+} from "../../env/src/index.js";
+
+import {
+    parseCliArgs,
+    resolveProjectRoot,
+    type CliOptions,
+} from "./args.js";
+
+const options =
+    parseCliArgs(
+        process.argv.slice(2)
+    );
+
+if (
+    options.command === "dev" &&
+    process.env.BCP_DEV_CHILD !== "1"
+) {
+    await runDevSupervisor(
+        options
+    );
+} else {
+    await runCli(
+        options
+    );
+}
+
+async function runCli(
+    cliOptions: CliOptions
+): Promise<void> {
+    const mode =
+        resolveEnvironmentMode(
+            cliOptions.command
+        );
+
+    if (mode) {
+        process.env.NODE_ENV =
+            mode;
+
+        const rootDirectory =
+            resolveProjectRoot(
+                cliOptions.rootDirectory
+            );
+
+        const result =
+            loadEnvironment(
+                rootDirectory,
+                mode
+            );
+
+        if (
+            result.files.length > 0
+        ) {
+            console.log(
+                `[BCP Env] ${mode}: ${result.files.join(", ")}`
+            );
+        }
+
+        if (
+            Object.keys(
+                result.publicValues
+            ).length > 0
+        ) {
+            console.log(
+                `[BCP Env] Public variables: ${Object.keys(result.publicValues).sort().join(", ")}`
+            );
+        }
+
+        /*
+         * A standalone start uses the configuration frozen at build time.
+         * Runtime BCP_* environment variables and CLI server overrides stay
+         * available to server.mjs, but source bcp.config.* must not replace
+         * build-dependent settings after the artifact has been created.
+         */
+        if (
+            cliOptions.command !==
+            "start"
+        ) {
+            const resolved =
+                await resolveBcpConfig(
+                    rootDirectory,
+                    {
+                        port:
+                            cliOptions.port,
+                        hostname:
+                            cliOptions.hostname,
+                    }
+                );
+
+            applyResolvedBcpConfig(
+                resolved.config
+            );
+
+            if (
+                resolved.file
+            ) {
+                console.log(
+                    `[BCP Config] Loaded: ${path.basename(resolved.file)}`
+                );
+            }
+
+            console.log(
+                `[BCP Config] Server: ${resolved.config.server.hostname}:${resolved.config.server.port}`
+            );
+        }
+    }
+
+    await import(
+        "./index.js"
+    );
+}
+
+async function runDevSupervisor(
+    cliOptions: CliOptions
+): Promise<void> {
+    const rootDirectory =
+        resolveProjectRoot(
+            cliOptions.rootDirectory
+        );
+
+    const envFiles =
+        getEnvironmentFileNames(
+            "development"
+        ).map(
+            (fileName) =>
+                path.join(
+                    rootDirectory,
+                    fileName
+                )
+        );
+
+    const configFiles =
+        getConfigFileNames()
+            .map(
+                (fileName) =>
+                    path.join(
+                        rootDirectory,
+                        fileName
+                    )
+            );
+
+    const watchedFiles = [
+        ...envFiles,
+        ...configFiles,
+    ];
+
+    const bootstrapFile =
+        fileURLToPath(
+            import.meta.url
+        );
+
+    const tsxImport =
+        import.meta.resolve(
+            "tsx"
+        );
+
+    let child:
+        ChildProcess | null =
+        null;
+
+    let stopping =
+        false;
+
+    let restarting =
+        false;
+
+    let restartQueued =
+        false;
+
+    let restartTimer:
+        NodeJS.Timeout | null =
+        null;
+
+    let restartGeneration =
+        0;
+
+    let resolveSupervisor:
+        (() => void) | null =
+        null;
+
+    const supervisorDone =
+        new Promise<void>(
+            (resolve) => {
+                resolveSupervisor =
+                    resolve;
+            }
+        );
+
+    const watcher =
+        chokidar.watch(
+            watchedFiles,
+            {
+                persistent: true,
+                ignoreInitial: true,
+                atomic: true,
+            }
+        );
+
+    function startChild(
+        configRestart: boolean
+    ): void {
+        const restartToken =
+            configRestart
+                ? `${Date.now()}-${++restartGeneration}`
+                : "0";
+
+        child =
+            spawn(
+                process.execPath,
+                [
+                    "--import",
+                    tsxImport,
+                    bootstrapFile,
+                    ...process.argv.slice(2),
+                ],
+                {
+                    cwd:
+                        process.cwd(),
+                    stdio:
+                        "inherit",
+                    env: {
+                        ...process.env,
+                        BCP_DEV_CHILD:
+                            "1",
+                        BCP_DEV_ENV_RESTART:
+                            restartToken,
+                    },
+                }
+            );
+
+        child.once(
+            "exit",
+            (
+                code,
+                signal
+            ) => {
+                child =
+                    null;
+
+                if (
+                    stopping ||
+                    restarting
+                ) {
+                    return;
+                }
+
+                if (signal) {
+                    console.error(
+                        `[BCP Dev] Worker stopped by ${signal}.`
+                    );
+                }
+
+                void shutdown(
+                    code ?? 1
+                );
+            }
+        );
+    }
+
+    async function stopChild(): Promise<void> {
+        const current =
+            child;
+
+        if (
+            !current ||
+            current.exitCode !== null ||
+            current.signalCode !== null
+        ) {
+            return;
+        }
+
+        await new Promise<void>(
+            (resolve) => {
+                let finished =
+                    false;
+
+                const finish =
+                    () => {
+                        if (finished) {
+                            return;
+                        }
+
+                        finished =
+                            true;
+                        resolve();
+                    };
+
+                current.once(
+                    "exit",
+                    finish
+                );
+
+                current.kill(
+                    "SIGTERM"
+                );
+
+                const forceTimer =
+                    setTimeout(
+                        () => {
+                            if (
+                                current.exitCode === null &&
+                                current.signalCode === null
+                            ) {
+                                current.kill(
+                                    "SIGKILL"
+                                );
+                            }
+                        },
+                        3000
+                    );
+
+                forceTimer.unref();
+            }
+        );
+    }
+
+    async function restartChild(
+        changedPath: string
+    ): Promise<void> {
+        if (stopping) {
+            return;
+        }
+
+        if (restarting) {
+            restartQueued =
+                true;
+            return;
+        }
+
+        restarting =
+            true;
+
+        try {
+            const fileName =
+                path.basename(
+                    changedPath
+                );
+            const source =
+                fileName.startsWith(
+                    "bcp.config."
+                )
+                    ? "Config"
+                    : "Env";
+
+            console.log("");
+            console.log(
+                `[BCP ${source}] ${fileName} changed; restarting dev worker...`
+            );
+
+            await stopChild();
+
+            if (!stopping) {
+                startChild(
+                    true
+                );
+            }
+        } finally {
+            restarting =
+                false;
+
+            if (
+                restartQueued &&
+                !stopping
+            ) {
+                restartQueued =
+                    false;
+
+                await restartChild(
+                    changedPath
+                );
+            }
+        }
+    }
+
+    function scheduleRestart(
+        changedPath: string
+    ): void {
+        if (restartTimer) {
+            clearTimeout(
+                restartTimer
+            );
+        }
+
+        restartTimer =
+            setTimeout(
+                () => {
+                    restartTimer =
+                        null;
+
+                    void restartChild(
+                        changedPath
+                    );
+                },
+                120
+            );
+    }
+
+    watcher.on(
+        "add",
+        scheduleRestart
+    );
+    watcher.on(
+        "change",
+        scheduleRestart
+    );
+    watcher.on(
+        "unlink",
+        scheduleRestart
+    );
+    watcher.on(
+        "error",
+        (error) => {
+            console.error(
+                "[BCP Dev] Configuration watcher error:",
+                error
+            );
+        }
+    );
+
+    async function shutdown(
+        exitCode = 0
+    ): Promise<void> {
+        if (stopping) {
+            return;
+        }
+
+        stopping =
+            true;
+
+        if (restartTimer) {
+            clearTimeout(
+                restartTimer
+            );
+            restartTimer =
+                null;
+        }
+
+        await watcher.close();
+        await stopChild();
+
+        process.exitCode =
+            exitCode;
+
+        resolveSupervisor?.();
+        resolveSupervisor =
+            null;
+    }
+
+    process.once(
+        "SIGINT",
+        () => {
+            void shutdown(0);
+        }
+    );
+
+    process.once(
+        "SIGTERM",
+        () => {
+            void shutdown(0);
+        }
+    );
+
+    console.log(
+        `[BCP Env] Watching: ${getEnvironmentFileNames("development").join(", ")}`
+    );
+    console.log(
+        `[BCP Config] Watching: ${getConfigFileNames().join(", ")}`
+    );
+
+    startChild(
+        false
+    );
+
+    await supervisorDone;
+}
+
+function resolveEnvironmentMode(
+    command: string
+): EnvironmentMode | null {
+    if (
+        command === "dev"
+    ) {
+        return "development";
+    }
+
+    if (
+        command === "build" ||
+        command === "start"
+    ) {
+        return "production";
+    }
+
+    return null;
+}