@chidchanun/bcp 0.1.0

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

@@ -0,0 +1,1193 @@
+import fs from "node:fs";
+import path from "node:path";
+import {
+    fileURLToPath,
+} from "node:url";
+
+import {
+    build,
+} from "esbuild";
+
+import {
+    readResolvedBcpConfig,
+    type ResolvedBcpConfig,
+} from "../../config/src/index.js";
+
+import {
+    createServerEnvironmentDefines,
+} from "../../env/src/index.js";
+
+import type {
+    ApiRoute,
+    Route,
+} from "../../router/src/index.js";
+
+import type {
+    PartialHydrationBuildManifest,
+} from "./partial-hydration.js";
+
+import {
+    findNearestSpecialFile,
+    findSpecialFileInDirectory,
+} from "./special-files.js";
+
+export interface ProductionServerBuildResult {
+    serverFile: string;
+    size: number;
+    pageRoutes: number;
+    apiRoutes: number;
+}
+
+export async function buildProductionServer(
+    pageRoutes: Route[],
+    apiRoutes: ApiRoute[],
+    rootDirectory: string,
+    clientManifest: PartialHydrationBuildManifest
+): Promise<ProductionServerBuildResult> {
+    const frameworkConfig =
+        readResolvedBcpConfig();
+
+    const buildRoot =
+        path.join(
+            rootDirectory,
+            ".bcp-framework",
+            "build"
+        );
+
+    const serverDirectory =
+        path.join(
+            buildRoot,
+            "server"
+        );
+
+    const entryDirectory =
+        path.join(
+            buildRoot,
+            ".server-entry"
+        );
+
+    const publicSource =
+        path.join(
+            rootDirectory,
+            "public"
+        );
+
+    const publicOutput =
+        path.join(
+            buildRoot,
+            "public"
+        );
+
+    fs.rmSync(
+        serverDirectory,
+        {
+            recursive: true,
+            force: true,
+        }
+    );
+    fs.rmSync(
+        entryDirectory,
+        {
+            recursive: true,
+            force: true,
+        }
+    );
+    fs.rmSync(
+        publicOutput,
+        {
+            recursive: true,
+            force: true,
+        }
+    );
+
+    fs.mkdirSync(
+        serverDirectory,
+        {
+            recursive: true,
+        }
+    );
+    fs.mkdirSync(
+        entryDirectory,
+        {
+            recursive: true,
+        }
+    );
+
+    writeResolvedConfigManifest(
+        serverDirectory,
+        frameworkConfig
+    );
+
+    if (fs.existsSync(publicSource)) {
+        fs.cpSync(
+            publicSource,
+            publicOutput,
+            {
+                recursive: true,
+            }
+        );
+    }
+
+    const entryFile =
+        path.join(
+            entryDirectory,
+            "server-entry.mjs"
+        );
+
+    fs.writeFileSync(
+        entryFile,
+        createServerEntry(
+            pageRoutes,
+            apiRoutes,
+            rootDirectory,
+            entryDirectory,
+            clientManifest,
+            frameworkConfig
+        ),
+        "utf8"
+    );
+
+    const serverFile =
+        path.join(
+            serverDirectory,
+            "server.mjs"
+        );
+
+    const frameworkDirectory =
+        path.dirname(
+            fileURLToPath(
+                import.meta.url
+            )
+        );
+
+    const frameworkClientEntry =
+        path.resolve(
+            frameworkDirectory,
+            "../../client/src/index.tsx"
+        );
+
+    const frameworkIslandEntry =
+        path.resolve(
+            frameworkDirectory,
+            "../../client/src/islands.tsx"
+        );
+
+    await build({
+        absWorkingDir:
+            rootDirectory,
+        entryPoints: [
+            entryFile,
+        ],
+        outfile:
+            serverFile,
+        bundle: true,
+        platform: "node",
+        format: "esm",
+        target: [
+            "node24",
+        ],
+        minify:
+            frameworkConfig.build.minify,
+        sourcemap:
+            frameworkConfig.build.sourceMaps,
+        treeShaking: true,
+        packages: "external",
+        external: [
+            "react",
+            "react-dom",
+            "react-dom/*",
+        ],
+        plugins: [
+            {
+                name:
+                    "bcp-standalone-client-runtime",
+                setup(buildApi) {
+                    buildApi.onResolve(
+                        {
+                            filter:
+                                /^bcp$/,
+                        },
+                        () => ({
+                            path:
+                                frameworkClientEntry,
+                        })
+                    );
+
+                    buildApi.onResolve(
+                        {
+                            filter:
+                                /^bcp\/island$/,
+                        },
+                        () => ({
+                            path:
+                                frameworkIslandEntry,
+                        })
+                    );
+                },
+            },
+        ],
+        define:
+            createServerEnvironmentDefines(
+                "production"
+            ),
+        legalComments: "none",
+        logLevel: "silent",
+    });
+
+    fs.rmSync(
+        entryDirectory,
+        {
+            recursive: true,
+            force: true,
+        }
+    );
+
+    const stat =
+        fs.statSync(
+            serverFile
+        );
+
+    return {
+        serverFile,
+        size:
+            stat.size,
+        pageRoutes:
+            pageRoutes.length,
+        apiRoutes:
+            apiRoutes.length,
+    };
+}
+
+function writeResolvedConfigManifest(
+    serverDirectory: string,
+    frameworkConfig: ResolvedBcpConfig
+): void {
+    fs.writeFileSync(
+        path.join(
+            serverDirectory,
+            "config.json"
+        ),
+        JSON.stringify(
+            {
+                version: 1,
+                ...frameworkConfig,
+            },
+            null,
+            2
+        ),
+        "utf8"
+    );
+}
+
+function createServerEntry(
+    pageRoutes: Route[],
+    apiRoutes: ApiRoute[],
+    rootDirectory: string,
+    entryDirectory: string,
+    clientManifest: PartialHydrationBuildManifest,
+    frameworkConfig: ResolvedBcpConfig
+): string {
+    const frameworkDirectory =
+        path.dirname(
+            fileURLToPath(
+                import.meta.url
+            )
+        );
+
+    const standaloneServerFile =
+        path.resolve(
+            frameworkDirectory,
+            "../../server/src/standalone-production-server.ts"
+        );
+
+    const appDirectory =
+        path.join(
+            rootDirectory,
+            "app"
+        );
+
+    const imports: string[] = [
+        `import path from "node:path";`,
+        `import { fileURLToPath } from "node:url";`,
+        `import { createElement, Fragment } from "react";`,
+        `import { createStandaloneProductionServer } from ${JSON.stringify(
+            toImportSpecifier(
+                entryDirectory,
+                standaloneServerFile
+            )
+        )};`,
+    ];
+
+    const componentDefinitions:
+        string[] = [];
+    const routeDefinitions:
+        string[] = [];
+    const apiDefinitions:
+        string[] = [];
+
+    const serverOnlyRoutes =
+        new Set(
+            clientManifest
+                .hydration
+                .serverOnlyRoutes
+        );
+
+    const rootNotFoundFile =
+        findSpecialFileInDirectory(
+            appDirectory,
+            "not-found"
+        );
+
+    let globalNotFoundName =
+        "null";
+
+    if (rootNotFoundFile) {
+        globalNotFoundName =
+            "GlobalNotFound";
+
+        imports.push(
+            `import GlobalNotFound from ${JSON.stringify(
+                toImportSpecifier(
+                    entryDirectory,
+                    rootNotFoundFile
+                )
+            )};`
+        );
+    }
+
+    const rootLayoutFile =
+        findRootLayoutFile(
+            appDirectory
+        );
+
+    let rootLayoutName =
+        "null";
+
+    if (rootLayoutFile) {
+        rootLayoutName =
+            "GlobalNotFoundLayout";
+
+        imports.push(
+            `import GlobalNotFoundLayout from ${JSON.stringify(
+                toImportSpecifier(
+                    entryDirectory,
+                    rootLayoutFile
+                )
+            )};`
+        );
+    }
+
+    pageRoutes.forEach(
+        (
+            route,
+            routeIndex
+        ) => {
+            const pageModuleName =
+                `PageModule${routeIndex}`;
+            const pageName =
+                `Page${routeIndex}`;
+
+            imports.push(
+                `import * as ${pageModuleName} from ${JSON.stringify(
+                    toImportSpecifier(
+                        entryDirectory,
+                        route.filePath
+                    )
+                )};`
+            );
+            componentDefinitions.push(
+                `const ${pageName} = ${pageModuleName}.default;`
+            );
+
+            const layoutModules:
+                Array<{
+                    name: string;
+                    moduleName: string;
+                    filePath: string;
+                }> = [];
+
+            route.layouts.forEach(
+                (
+                    layoutFile,
+                    layoutIndex
+                ) => {
+                    const layoutName =
+                        `Layout${routeIndex}_${layoutIndex}`;
+                    const moduleName =
+                        `LayoutModule${routeIndex}_${layoutIndex}`;
+
+                    imports.push(
+                        `import * as ${moduleName} from ${JSON.stringify(
+                            toImportSpecifier(
+                                entryDirectory,
+                                layoutFile
+                            )
+                        )};`
+                    );
+                    componentDefinitions.push(
+                        `const ${layoutName} = ${moduleName}.default;`
+                    );
+
+                    layoutModules.push({
+                        name:
+                            layoutName,
+                        moduleName,
+                        filePath:
+                            layoutFile,
+                    });
+                }
+            );
+
+            const layoutNames =
+                layoutModules.map(
+                    (layout) =>
+                        layout.name
+                );
+
+            const loadingFile =
+                findNearestLoadingFile(
+                    appDirectory,
+                    route.filePath
+                );
+
+            let loadingName =
+                "null";
+
+            if (loadingFile) {
+                loadingName =
+                    `Loading${routeIndex}`;
+                imports.push(
+                    `import ${loadingName} from ${JSON.stringify(
+                        toImportSpecifier(
+                            entryDirectory,
+                            loadingFile
+                        )
+                    )};`
+                );
+            }
+
+            const errorFile =
+                findNearestSpecialFile(
+                    appDirectory,
+                    route.filePath,
+                    "error"
+                );
+
+            let errorName =
+                "null";
+
+            if (errorFile) {
+                errorName =
+                    `Error${routeIndex}`;
+                imports.push(
+                    `import ${errorName} from ${JSON.stringify(
+                        toImportSpecifier(
+                            entryDirectory,
+                            errorFile
+                        )
+                    )};`
+                );
+            }
+
+            const notFoundFile =
+                findNearestSpecialFile(
+                    appDirectory,
+                    route.filePath,
+                    "not-found"
+                );
+
+            let notFoundName =
+                "null";
+
+            if (notFoundFile) {
+                notFoundName =
+                    `NotFound${routeIndex}`;
+                imports.push(
+                    `import ${notFoundName} from ${JSON.stringify(
+                        toImportSpecifier(
+                            entryDirectory,
+                            notFoundFile
+                        )
+                    )};`
+                );
+            }
+
+            const client =
+                clientManifest.routes[
+                    route.pathname
+                ];
+
+            if (!client) {
+                throw new Error(
+                    `BCP Framework: client manifest entry missing for route "${route.pathname}".`
+                );
+            }
+
+            const hydration =
+                serverOnlyRoutes.has(
+                    route.pathname
+                )
+                    ? "none"
+                    : "full";
+
+            let renderedPageName =
+                pageName;
+
+            if (
+                hydration === "none" &&
+                frameworkConfig.experimental.islands
+            ) {
+                const islandIds =
+                    collectRouteIslandIds(
+                        route,
+                        rootDirectory,
+                        [
+                            errorFile,
+                            notFoundFile,
+                        ].filter(
+                            (
+                                value
+                            ): value is string =>
+                                Boolean(value)
+                        )
+                    );
+
+                const islandAssets =
+                    islandIds.map(
+                        (islandId) => {
+                            const asset =
+                                clientManifest
+                                    .islands[
+                                        islandId
+                                    ];
+
+                            if (!asset) {
+                                throw new Error(
+                                    `BCP Framework: island "${islandId}" used by route "${route.pathname}" was not found in the client island manifest.`
+                                );
+                            }
+
+                            return {
+                                id:
+                                    islandId,
+                                asset,
+                            };
+                        }
+                    );
+
+                if (islandAssets.length > 0) {
+                    renderedPageName =
+                        `Page${routeIndex}WithIslands`;
+                    componentDefinitions.push(
+                        createIslandPageWrapper(
+                            renderedPageName,
+                            pageName,
+                            islandAssets
+                        )
+                    );
+                }
+            }
+
+            const metadataSources = [
+                ...layoutModules.map(
+                    (layout) =>
+                        createMetadataSourceDefinition(
+                            layout.moduleName,
+                            layout.filePath,
+                            rootDirectory
+                        )
+                ),
+                createMetadataSourceDefinition(
+                    pageModuleName,
+                    route.filePath,
+                    rootDirectory
+                ),
+            ];
+
+            routeDefinitions.push(`{
+  pathname: ${JSON.stringify(route.pathname)},
+  segments: ${JSON.stringify(route.segments)},
+  page: ${renderedPageName},
+  layouts: [${layoutNames.join(", ")}],
+  loading: ${loadingName},
+  error: ${errorName},
+  notFound: ${notFoundName},
+  metadataSources: [${metadataSources.join(", ")}],
+  hydration: ${JSON.stringify(hydration)},
+  client: ${JSON.stringify(client)}
+}`);
+        }
+    );
+
+    apiRoutes.forEach(
+        (
+            route,
+            routeIndex
+        ) => {
+            const moduleName =
+                `Api${routeIndex}`;
+
+            imports.push(
+                `import * as ${moduleName} from ${JSON.stringify(
+                    toImportSpecifier(
+                        entryDirectory,
+                        route.filePath
+                    )
+                )};`
+            );
+
+            apiDefinitions.push(`{
+  pathname: ${JSON.stringify(route.pathname)},
+  segments: ${JSON.stringify(route.segments)},
+  handlers: ${moduleName}
+}`);
+        }
+    );
+
+    const standaloneDefaults = {
+        server:
+            frameworkConfig.server,
+        compression:
+            frameworkConfig.compression,
+        responseCache:
+            frameworkConfig.cache.response,
+        partialHydration:
+            frameworkConfig.experimental.partialHydration,
+        islands:
+            frameworkConfig.experimental.islands,
+    };
+
+    return `${imports.join("\n")}
+
+${componentDefinitions.join("\n\n")}
+
+process.env.NODE_ENV = "production";
+
+const bcpDefaults =
+  ${JSON.stringify(standaloneDefaults)};
+
+process.env.BCP_COMPRESSION ??=
+  bcpDefaults.compression
+    ? "1"
+    : "0";
+process.env.BCP_RESPONSE_CACHE ??=
+  bcpDefaults.responseCache
+    ? "1"
+    : "0";
+process.env.BCP_EXPERIMENTAL_PARTIAL_HYDRATION ??=
+  bcpDefaults.partialHydration
+    ? "1"
+    : "0";
+process.env.BCP_EXPERIMENTAL_ISLANDS ??=
+  bcpDefaults.islands
+    ? "1"
+    : "0";
+
+const serverDirectory =
+  path.dirname(
+    fileURLToPath(
+      import.meta.url
+    )
+  );
+
+const buildDirectory =
+  path.resolve(
+    serverDirectory,
+    ".."
+  );
+
+const server =
+  createStandaloneProductionServer({
+    port:
+      Number(
+        process.env.BCP_PORT ||
+        process.env.PORT ||
+        bcpDefaults.server.port
+      ),
+    hostname:
+      process.env.BCP_HOSTNAME ||
+      process.env.HOST ||
+      bcpDefaults.server.hostname,
+    buildDirectory,
+    buildId:
+      ${JSON.stringify(clientManifest.buildId)},
+    version:
+      ${JSON.stringify(clientManifest.version)},
+    routes: [
+      ${routeDefinitions.join(",\n      ")}
+    ],
+    apiRoutes: [
+      ${apiDefinitions.join(",\n      ")}
+    ],
+    globalNotFound:
+      ${globalNotFoundName},
+    globalNotFoundLayouts:
+      ${rootLayoutName === "null"
+        ? "[]"
+        : `[${rootLayoutName}]`}
+  });
+
+process.once(
+  "SIGINT",
+  async () => {
+    await server.stop();
+    process.exit(0);
+  }
+);
+
+process.once(
+  "SIGTERM",
+  async () => {
+    await server.stop();
+    process.exit(0);
+  }
+);
+
+await server.start();
+`;
+}
+
+function createMetadataSourceDefinition(
+    moduleName: string,
+    filePath: string,
+    rootDirectory: string
+): string {
+    const label =
+        path.relative(
+            rootDirectory,
+            filePath
+        )
+            .replace(
+                /\\/g,
+                "/"
+            );
+
+    return `{
+    label: ${JSON.stringify(label)},
+    metadata: ${moduleName}.metadata,
+    generateMetadata: ${moduleName}.generateMetadata
+  }`;
+}
+
+function createIslandPageWrapper(
+    wrapperName: string,
+    pageName: string,
+    islands: Array<{
+        id: string;
+        asset: {
+            entry: string;
+            imports: string[];
+        };
+    }>
+): string {
+    const preloadPaths =
+        Array.from(
+            new Set(
+                islands.flatMap(
+                    (island) =>
+                        island.asset.imports
+                )
+            )
+        );
+
+    const preloadElements =
+        preloadPaths.map(
+            (
+                importPath,
+                index
+            ) =>
+                `createElement("link", { key: "bcp-island-preload-${index}", rel: "modulepreload", href: ${JSON.stringify(importPath)}, "data-bcp-island-preload": "true" })`
+        );
+
+    const islandScripts =
+        islands.map(
+            (
+                island,
+                index
+            ) =>
+                `createElement("script", { key: "bcp-island-${index}", type: "module", src: ${JSON.stringify(island.asset.entry)}, "data-bcp-island-entry": ${JSON.stringify(island.id)} })`
+        );
+
+    return `const ${wrapperName} = (props) =>
+  createElement(
+    Fragment,
+    null,
+    createElement(
+      ${pageName},
+      props
+    ),
+    ${[
+        ...preloadElements,
+        ...islandScripts,
+    ].join(",\n    ")}
+  );`;
+}
+
+function collectRouteIslandIds(
+    route: Route,
+    rootDirectory: string,
+    extraFiles: string[] = []
+): string[] {
+    const appDirectory =
+        path.resolve(
+            rootDirectory,
+            "app"
+        );
+
+    const visited =
+        new Set<string>();
+    const islandIds =
+        new Set<string>();
+
+    for (
+        const entryFile
+        of [
+            route.filePath,
+            ...route.layouts,
+            ...extraFiles,
+        ]
+    ) {
+        visitSourceFile(
+            entryFile,
+            appDirectory,
+            visited,
+            islandIds
+        );
+    }
+
+    return Array.from(
+        islandIds
+    ).sort();
+}
+
+function visitSourceFile(
+    filePath: string,
+    appDirectory: string,
+    visited: Set<string>,
+    islandIds: Set<string>
+): void {
+    const resolved =
+        path.resolve(
+            filePath
+        );
+
+    if (visited.has(resolved)) {
+        return;
+    }
+
+    visited.add(
+        resolved
+    );
+
+    const source =
+        fs.readFileSync(
+            resolved,
+            "utf8"
+        );
+
+    if (
+        /\.island\.(?:ts|tsx)$/.test(
+            resolved
+        )
+    ) {
+        const match =
+            /\bcreateIsland\s*\(\s*["']([A-Za-z][A-Za-z0-9._-]*)["']\s*,/.exec(
+                source
+            );
+
+        if (!match) {
+            throw new Error(
+                `BCP Framework: island file "${resolved}" must export createIsland("literal-id", Component).`
+            );
+        }
+
+        islandIds.add(
+            match[1]
+        );
+        return;
+    }
+
+    for (
+        const specifier
+        of collectRelativeImports(
+            source
+        )
+    ) {
+        const importedFile =
+            resolveSourceImport(
+                resolved,
+                specifier
+            );
+
+        if (!importedFile) {
+            continue;
+        }
+
+        const relative =
+            path.relative(
+                appDirectory,
+                importedFile
+            );
+
+        if (
+            relative.startsWith("..") ||
+            path.isAbsolute(
+                relative
+            )
+        ) {
+            continue;
+        }
+
+        visitSourceFile(
+            importedFile,
+            appDirectory,
+            visited,
+            islandIds
+        );
+    }
+}
+
+function collectRelativeImports(
+    source: string
+): string[] {
+    const imports =
+        new Set<string>();
+
+    const pattern =
+        /(?:\bimport\s+(?:[^"']*?\s+from\s+)?|\bexport\s+[^"']*?\s+from\s+)["']([^"']+)["']/g;
+
+    let match:
+        RegExpExecArray | null;
+
+    while (
+        (
+            match =
+                pattern.exec(
+                    source
+                )
+        ) !== null
+    ) {
+        if (
+            match[1].startsWith(".")
+        ) {
+            imports.add(
+                match[1]
+            );
+        }
+    }
+
+    return Array.from(
+        imports
+    );
+}
+
+function resolveSourceImport(
+    fromFile: string,
+    specifier: string
+): string | null {
+    const basePath =
+        path.resolve(
+            path.dirname(
+                fromFile
+            ),
+            specifier
+        );
+
+    const candidates = [
+        basePath,
+        `${basePath}.ts`,
+        `${basePath}.tsx`,
+        `${basePath}.js`,
+        `${basePath}.jsx`,
+        path.join(
+            basePath,
+            "index.ts"
+        ),
+        path.join(
+            basePath,
+            "index.tsx"
+        ),
+        path.join(
+            basePath,
+            "index.js"
+        ),
+        path.join(
+            basePath,
+            "index.jsx"
+        ),
+    ];
+
+    for (const candidate of candidates) {
+        if (!fs.existsSync(candidate)) {
+            continue;
+        }
+
+        const stat =
+            fs.statSync(
+                candidate
+            );
+
+        if (stat.isFile()) {
+            return candidate;
+        }
+    }
+
+    return null;
+}
+
+function findNearestLoadingFile(
+    appDirectory: string,
+    pageFilePath: string
+): string | null {
+    const appRoot =
+        path.resolve(
+            appDirectory
+        );
+
+    let currentDirectory =
+        path.dirname(
+            path.resolve(
+                pageFilePath
+            )
+        );
+
+    while (true) {
+        const tsxFile =
+            path.join(
+                currentDirectory,
+                "loading.tsx"
+            );
+        const tsFile =
+            path.join(
+                currentDirectory,
+                "loading.ts"
+            );
+
+        const hasTsx =
+            fs.existsSync(
+                tsxFile
+            );
+        const hasTs =
+            fs.existsSync(
+                tsFile
+            );
+
+        if (hasTsx && hasTs) {
+            throw new Error(
+                `BCP Framework: both loading.ts and loading.tsx exist in "${currentDirectory}".`
+            );
+        }
+
+        if (hasTsx) {
+            return tsxFile;
+        }
+        if (hasTs) {
+            return tsFile;
+        }
+
+        if (currentDirectory === appRoot) {
+            break;
+        }
+
+        const parent =
+            path.dirname(
+                currentDirectory
+            );
+
+        if (
+            parent === currentDirectory ||
+            !isInsideDirectory(
+                appRoot,
+                parent
+            )
+        ) {
+            break;
+        }
+
+        currentDirectory =
+            parent;
+    }
+
+    return null;
+}
+
+function findRootLayoutFile(
+    appDirectory: string
+): string | null {
+    const tsxFile =
+        path.join(
+            appDirectory,
+            "layout.tsx"
+        );
+    const tsFile =
+        path.join(
+            appDirectory,
+            "layout.ts"
+        );
+
+    const hasTsx =
+        fs.existsSync(
+            tsxFile
+        );
+    const hasTs =
+        fs.existsSync(
+            tsFile
+        );
+
+    if (hasTsx && hasTs) {
+        throw new Error(
+            `BCP Framework: both layout.ts and layout.tsx exist in "${appDirectory}".`
+        );
+    }
+
+    if (hasTsx) {
+        return tsxFile;
+    }
+    if (hasTs) {
+        return tsFile;
+    }
+
+    return null;
+}
+
+function isInsideDirectory(
+    rootDirectory: string,
+    candidate: string
+): boolean {
+    const relative =
+        path.relative(
+            rootDirectory,
+            candidate
+        );
+
+    return (
+        relative === "" ||
+        (
+            !relative.startsWith(
+                ".."
+            ) &&
+            !path.isAbsolute(
+                relative
+            )
+        )
+    );
+}
+
+function toImportSpecifier(
+    fromDirectory: string,
+    filePath: string
+): string {
+    const relative =
+        path.relative(
+            fromDirectory,
+            filePath
+        )
+            .replace(
+                /\\/g,
+                "/"
+            );
+
+    return relative.startsWith(".")
+        ? relative
+        : `./${relative}`;
+}