@chidchanun/bcp 0.1.0

package/packages/bundler/src/server-production-middleware.ts

@@ -0,0 +1,447 @@
+import fs from "node:fs";
+import path from "node:path";
+import {
+    fileURLToPath,
+} from "node:url";
+
+import {
+    build,
+} from "esbuild";
+
+import {
+    createServerEnvironmentDefines,
+} from "../../env/src/index.js";
+
+import {
+    findProjectMiddlewareFile,
+} from "../../server/src/middleware-loader.js";
+
+import type {
+    ApiRoute,
+    Route,
+} from "../../router/src/index.js";
+
+import type {
+    RevalidateValue,
+} from "../../cache/src/index.js";
+
+import type {
+    PartialHydrationBuildManifest,
+} from "./partial-hydration.js";
+
+import {
+    buildProductionServer as buildBaseProductionServer,
+    type ProductionServerBuildResult,
+} from "./server-production.js";
+
+interface CacheManifestRoute {
+    pathname: string;
+    segments: Route["segments"];
+    revalidate: RevalidateValue;
+}
+
+interface CacheManifest {
+    version: 1;
+    pages: CacheManifestRoute[];
+    apiRoutes: CacheManifestRoute[];
+}
+
+export async function buildProductionServer(
+    pageRoutes: Route[],
+    apiRoutes: ApiRoute[],
+    rootDirectory: string,
+    clientManifest: PartialHydrationBuildManifest
+): Promise<ProductionServerBuildResult> {
+    const baseResult =
+        await buildBaseProductionServer(
+            pageRoutes,
+            apiRoutes,
+            rootDirectory,
+            clientManifest
+        );
+
+    await bundleServerCacheRuntime(
+        baseResult.serverFile,
+        rootDirectory
+    );
+
+    const serverDirectory =
+        path.dirname(
+            baseResult.serverFile
+        );
+
+    writeCacheManifest(
+        pageRoutes,
+        apiRoutes,
+        serverDirectory
+    );
+
+    await buildProductionMiddleware(
+        rootDirectory,
+        serverDirectory
+    );
+
+    return {
+        ...baseResult,
+        size:
+            fs.statSync(
+                baseResult.serverFile
+            ).size,
+    };
+}
+
+async function bundleServerCacheRuntime(
+    serverFile: string,
+    rootDirectory: string
+): Promise<void> {
+    const temporaryFile =
+        `${serverFile}.cache-runtime.mjs`;
+
+    const sourceMaps =
+        process.env
+            .BCP_BUILD_SOURCE_MAPS ===
+        "1";
+
+    const frameworkDirectory =
+        path.dirname(
+            fileURLToPath(
+                import.meta.url
+            )
+        );
+
+    const frameworkCacheEntry =
+        path.resolve(
+            frameworkDirectory,
+            "../../cache/src/index.ts"
+        );
+
+    try {
+        await build({
+            absWorkingDir:
+                rootDirectory,
+            entryPoints: [
+                serverFile,
+            ],
+            outfile:
+                temporaryFile,
+            bundle:
+                true,
+            platform:
+                "node",
+            format:
+                "esm",
+            target: [
+                "node24",
+            ],
+            minify:
+                process.env
+                    .BCP_BUILD_MINIFY !==
+                "0",
+            sourcemap:
+                sourceMaps
+                    ? "inline"
+                    : false,
+            treeShaking:
+                true,
+            packages:
+                "external",
+            plugins: [
+                {
+                    name:
+                        "bcp-cache-runtime",
+                    setup(buildApi) {
+                        buildApi.onResolve(
+                            {
+                                filter:
+                                    /^bcp\/cache$/,
+                            },
+                            () => ({
+                                path:
+                                    frameworkCacheEntry,
+                            })
+                        );
+                    },
+                },
+            ],
+            legalComments:
+                "none",
+            logLevel:
+                "silent",
+        });
+
+        fs.copyFileSync(
+            temporaryFile,
+            serverFile
+        );
+
+        /*
+         * The base server build may have emitted an external map. The final
+         * cache-runtime rebundle uses an inline map so a stale server.mjs.map
+         * must not be shipped next to the rewritten bundle.
+         */
+        fs.rmSync(
+            `${serverFile}.map`,
+            {
+                force: true,
+            }
+        );
+    } finally {
+        fs.rmSync(
+            temporaryFile,
+            {
+                force: true,
+            }
+        );
+        fs.rmSync(
+            `${temporaryFile}.map`,
+            {
+                force: true,
+            }
+        );
+    }
+}
+
+function writeCacheManifest(
+    pageRoutes: Route[],
+    apiRoutes: ApiRoute[],
+    serverDirectory: string
+): void {
+    const manifest:
+        CacheManifest = {
+        version: 1,
+        pages:
+            collectCacheRoutes(
+                pageRoutes
+            ),
+        apiRoutes:
+            collectCacheRoutes(
+                apiRoutes
+            ),
+    };
+
+    const outputFile =
+        path.join(
+            serverDirectory,
+            "cache-manifest.json"
+        );
+
+    fs.writeFileSync(
+        outputFile,
+        JSON.stringify(
+            manifest,
+            null,
+            2
+        ),
+        "utf8"
+    );
+
+    console.log(
+        `[BCP Build] Cache routes: ${manifest.pages.length} page(s), ${manifest.apiRoutes.length} API route(s)`
+    );
+}
+
+function collectCacheRoutes<
+    T extends Route | ApiRoute
+>(
+    routes: T[]
+): CacheManifestRoute[] {
+    const result:
+        CacheManifestRoute[] = [];
+
+    for (const route of routes) {
+        const revalidate =
+            readRouteRevalidate(
+                route.filePath
+            );
+
+        if (
+            revalidate === undefined ||
+            revalidate === 0
+        ) {
+            continue;
+        }
+
+        result.push({
+            pathname:
+                route.pathname,
+            segments:
+                route.segments,
+            revalidate,
+        });
+    }
+
+    return result;
+}
+
+function readRouteRevalidate(
+    filePath: string
+): RevalidateValue | undefined {
+    const source =
+        fs.readFileSync(
+            filePath,
+            "utf8"
+        );
+
+    const declaration =
+        /\bexport\s+const\s+revalidate\b/.test(
+            source
+        );
+
+    if (!declaration) {
+        return undefined;
+    }
+
+    const match =
+        /\bexport\s+const\s+revalidate\s*(?::[^=;]+)?=\s*(false|(?:\d+(?:\.\d+)?))\s*;?/.exec(
+            source
+        );
+
+    if (!match) {
+        throw new Error(
+            `BCP Framework: revalidate in "${filePath}" must be a literal false or non-negative number.`
+        );
+    }
+
+    if (
+        match[1] === "false"
+    ) {
+        return false;
+    }
+
+    const value =
+        Number(
+            match[1]
+        );
+
+    if (
+        !Number.isFinite(value) ||
+        value < 0
+    ) {
+        throw new Error(
+            `BCP Framework: invalid revalidate value in "${filePath}".`
+        );
+    }
+
+    return value;
+}
+
+async function buildProductionMiddleware(
+    rootDirectory: string,
+    serverDirectory: string
+): Promise<void> {
+    const outputFile =
+        path.join(
+            serverDirectory,
+            "middleware.mjs"
+        );
+
+    fs.rmSync(
+        outputFile,
+        {
+            force: true,
+        }
+    );
+
+    const middlewareFile =
+        findProjectMiddlewareFile(
+            rootDirectory
+        );
+
+    if (!middlewareFile) {
+        console.log(
+            "[BCP Build] Middleware: none"
+        );
+        return;
+    }
+
+    const frameworkDirectory =
+        path.dirname(
+            fileURLToPath(
+                import.meta.url
+            )
+        );
+
+    const frameworkMiddlewareEntry =
+        path.resolve(
+            frameworkDirectory,
+            "../../server/src/middleware.ts"
+        );
+
+    const frameworkCacheEntry =
+        path.resolve(
+            frameworkDirectory,
+            "../../cache/src/index.ts"
+        );
+
+    await build({
+        absWorkingDir:
+            rootDirectory,
+        entryPoints: [
+            middlewareFile,
+        ],
+        outfile:
+            outputFile,
+        bundle:
+            true,
+        platform:
+            "node",
+        format:
+            "esm",
+        target: [
+            "node24",
+        ],
+        minify:
+            process.env
+                .BCP_BUILD_MINIFY !==
+            "0",
+        sourcemap:
+            process.env
+                .BCP_BUILD_SOURCE_MAPS ===
+            "1",
+        treeShaking:
+            true,
+        packages:
+            "external",
+        plugins: [
+            {
+                name:
+                    "bcp-middleware-runtime",
+                setup(buildApi) {
+                    buildApi.onResolve(
+                        {
+                            filter:
+                                /^bcp\/middleware$/,
+                        },
+                        () => ({
+                            path:
+                                frameworkMiddlewareEntry,
+                        })
+                    );
+
+                    buildApi.onResolve(
+                        {
+                            filter:
+                                /^bcp\/cache$/,
+                        },
+                        () => ({
+                            path:
+                                frameworkCacheEntry,
+                        })
+                    );
+                },
+            },
+        ],
+        define:
+            createServerEnvironmentDefines(
+                "production"
+            ),
+        legalComments:
+            "none",
+        logLevel:
+            "silent",
+    });
+
+    console.log(
+        `[BCP Build] Middleware: ${path.relative(rootDirectory, middlewareFile).replace(/\\/g, "/")} -> ${path.relative(rootDirectory, outputFile).replace(/\\/g, "/")}`
+    );
+}