@chidchanun/bcp 0.1.8 → 0.1.9

package/packages/server/src/standalone-production-runtime-v2-navigation.ts

@@ -0,0 +1,785 @@
+import * as http from "node:http";
+import * as net from "node:net";
+
+import {
+    createElement,
+} from "react";
+
+import {
+    renderToStaticMarkup,
+} from "react-dom/server";
+
+import {
+    isNotFoundError,
+} from "../../client/src/not-found.js";
+
+import {
+    matchRoute,
+    type Route,
+} from "../../router/src/index.js";
+
+import {
+    resolveRouteMetadata,
+} from "./metadata.js";
+
+import {
+    attachLoaderDataToParams,
+    executePageLoaderFunction,
+    type PageLoaderExecution,
+} from "./page-loader.js";
+
+import {
+    createNavigationJsonResponse,
+    createNavigationRedirectResponse,
+    sendNavigationWebResponse,
+} from "./navigation-response.js";
+
+import {
+    applyResponseCookies,
+    runWithRequestContext,
+} from "./request-context.js";
+
+import {
+    createStandaloneProductionServer as createBaseStandaloneProductionServer,
+    type StandaloneApiRoute,
+    type StandalonePageRoute,
+    type StandaloneProductionServerOptions as BaseStandaloneProductionServerOptions,
+} from "./standalone-production-runtime-v2.js";
+
+export type {
+    StandaloneApiRoute,
+    StandalonePageRoute,
+};
+
+export interface StandaloneProductionServerOptions
+    extends BaseStandaloneProductionServerOptions {}
+
+export function createStandaloneProductionServer(
+    options: StandaloneProductionServerOptions
+) {
+    const hasLoaderRoutes =
+        options.routes.some(
+            (route) =>
+                route.loader !==
+                null
+        );
+
+    if (!hasLoaderRoutes) {
+        return createBaseStandaloneProductionServer(
+            options
+        );
+    }
+
+    const routeByPathname =
+        new Map(
+            options.routes.map(
+                (route) => [
+                    route.pathname,
+                    route,
+                ]
+            )
+        );
+
+    const routePatterns:
+        Route[] =
+        options.routes.map(
+            (route) => ({
+                pathname:
+                    route.pathname,
+                segments:
+                    route.segments,
+                filePath:
+                    route.pathname,
+                layouts: [],
+            })
+        );
+
+    let baseServer:
+        ReturnType<
+            typeof createBaseStandaloneProductionServer
+        > | null =
+        null;
+
+    let gateway:
+        http.Server | null =
+        null;
+
+    let started =
+        false;
+
+    async function start(): Promise<void> {
+        if (started) {
+            return;
+        }
+
+        const internalPort =
+            await findFreePort();
+
+        baseServer =
+            createBaseStandaloneProductionServer({
+                ...options,
+                port:
+                    internalPort,
+                hostname:
+                    "127.0.0.1",
+            });
+
+        await baseServer.start();
+
+        gateway =
+            http.createServer(
+                async (
+                    req,
+                    res
+                ) => {
+                    try {
+                        const requestUrl =
+                            new URL(
+                                req.url ??
+                                "/",
+                                `http://${
+                                    req.headers.host ??
+                                    `${options.hostname}:${options.port}`
+                                }`
+                            );
+
+                        if (
+                            requestUrl.pathname !==
+                            "/_bcp/navigation"
+                        ) {
+                            proxyRequest(
+                                req,
+                                res,
+                                internalPort
+                            );
+                            return;
+                        }
+
+                        await handleNavigation(
+                            req,
+                            res,
+                            requestUrl,
+                            routePatterns,
+                            routeByPathname,
+                            options.version
+                        );
+                    } catch (error) {
+                        console.error(
+                            "[BCP Loader Navigation Error]",
+                            error
+                        );
+
+                        if (
+                            res.headersSent
+                        ) {
+                            res.end();
+                            return;
+                        }
+
+                        await sendNavigationWebResponse(
+                            req,
+                            res,
+                            createNavigationJsonResponse(
+                                {
+                                    error:
+                                        "Internal Server Error",
+                                },
+                                {
+                                    status:
+                                        500,
+                                }
+                            )
+                        );
+                    }
+                }
+            );
+
+        gateway.keepAliveTimeout =
+            65_000;
+        gateway.headersTimeout =
+            66_000;
+
+        try {
+            await listen(
+                gateway,
+                options.port,
+                options.hostname
+            );
+        } catch (error) {
+            await baseServer.stop();
+            baseServer =
+                null;
+            gateway =
+                null;
+            throw error;
+        }
+
+        started =
+            true;
+
+        console.log(
+            `[BCP Loader] SPA navigation gateway: http://${options.hostname}:${options.port}`
+        );
+        console.log("");
+    }
+
+    async function stop(): Promise<void> {
+        if (gateway) {
+            await closeServer(
+                gateway
+            );
+            gateway =
+                null;
+        }
+
+        if (baseServer) {
+            await baseServer.stop();
+            baseServer =
+                null;
+        }
+
+        started =
+            false;
+    }
+
+    return {
+        start,
+        stop,
+    };
+}
+
+async function handleNavigation(
+    req: http.IncomingMessage,
+    res: http.ServerResponse,
+    requestUrl: URL,
+    routes: Route[],
+    routeByPathname: Map<
+        string,
+        StandalonePageRoute
+    >,
+    version: number
+): Promise<void> {
+    if (
+        (
+            req.method ??
+            "GET"
+        ).toUpperCase() !==
+        "GET"
+    ) {
+        await sendNavigationWebResponse(
+            req,
+            res,
+            createNavigationJsonResponse(
+                {
+                    error:
+                        "Method Not Allowed",
+                },
+                {
+                    status:
+                        405,
+                }
+            )
+        );
+        return;
+    }
+
+    const targetPath =
+        requestUrl.searchParams.get(
+            "url"
+        );
+
+    if (!targetPath) {
+        await sendNavigationWebResponse(
+            req,
+            res,
+            createNavigationJsonResponse(
+                {
+                    error:
+                        "Missing navigation target.",
+                },
+                {
+                    status:
+                        400,
+                }
+            )
+        );
+        return;
+    }
+
+    let target: URL;
+
+    try {
+        target =
+            new URL(
+                targetPath,
+                requestUrl.origin
+            );
+    } catch {
+        await sendNavigationWebResponse(
+            req,
+            res,
+            createNavigationJsonResponse(
+                {
+                    error:
+                        "Invalid navigation target.",
+                },
+                {
+                    status:
+                        400,
+                }
+            )
+        );
+        return;
+    }
+
+    if (
+        target.origin !==
+        requestUrl.origin
+    ) {
+        await sendNavigationWebResponse(
+            req,
+            res,
+            createNavigationJsonResponse(
+                {
+                    error:
+                        "Cross-origin navigation is not allowed.",
+                },
+                {
+                    status:
+                        400,
+                }
+            )
+        );
+        return;
+    }
+
+    const match =
+        matchRoute(
+            routes,
+            normalizePathname(
+                target.pathname
+            )
+        );
+
+    if (!match) {
+        await sendNavigationWebResponse(
+            req,
+            res,
+            createNavigationJsonResponse(
+                {
+                    error:
+                        "Route not found.",
+                },
+                {
+                    status:
+                        404,
+                }
+            )
+        );
+        return;
+    }
+
+    const definition =
+        routeByPathname.get(
+            match.route.pathname
+        );
+
+    if (!definition) {
+        await sendNavigationWebResponse(
+            req,
+            res,
+            createNavigationJsonResponse(
+                {
+                    error:
+                        "Route not found.",
+                },
+                {
+                    status:
+                        404,
+                }
+            )
+        );
+        return;
+    }
+
+    const request =
+        createNavigationRequest(
+            req,
+            target
+        );
+
+    let response: Response;
+
+    try {
+        response =
+            await runWithRequestContext(
+                request,
+                async () => {
+                    const loaderExecution:
+                        PageLoaderExecution =
+                        definition.loader
+                            ? await executePageLoaderFunction(
+                                definition.loader,
+                                match.params,
+                                target,
+                                definition.pathname
+                            )
+                            : {
+                                hasLoader:
+                                    false,
+                                data:
+                                    undefined,
+                                response:
+                                    null,
+                            };
+
+                    if (
+                        loaderExecution.response
+                    ) {
+                        const loaderResponse =
+                            applyResponseCookies(
+                                loaderExecution.response
+                            );
+
+                        return (
+                            createNavigationRedirectResponse(
+                                loaderResponse
+                            ) ??
+                            loaderResponse
+                        );
+                    }
+
+                    const metadata =
+                        await resolveRouteMetadata(
+                            definition.metadataSources,
+                            match.params
+                        );
+
+                    const loadingHtml =
+                        definition.loading
+                            ? renderToStaticMarkup(
+                                createElement(
+                                    definition.loading,
+                                    {
+                                        params:
+                                            match.params,
+                                    }
+                                )
+                            )
+                            : null;
+
+                    const params =
+                        attachLoaderDataToParams(
+                            match.params,
+                            loaderExecution
+                        );
+
+                    return applyResponseCookies(
+                        createNavigationJsonResponse(
+                            {
+                                route:
+                                    definition.pathname,
+                                params,
+                                clientScript:
+                                    definition.client.entry,
+                                clientImports:
+                                    definition.client.imports,
+                                title:
+                                    metadata.title,
+                                metadata,
+                                version,
+                                loadingHtml,
+                            }
+                        )
+                    );
+                },
+                {
+                    remoteAddress:
+                        req.socket
+                            .remoteAddress ??
+                        null,
+                }
+            );
+    } catch (error) {
+        if (
+            isNotFoundError(
+                error
+            )
+        ) {
+            response =
+                createNavigationJsonResponse(
+                    {
+                        error:
+                            "Route not found.",
+                    },
+                    {
+                        status:
+                            404,
+                    }
+                );
+        } else {
+            console.error(
+                `[BCP Loader Navigation Error] ${definition.pathname}:`,
+                error
+            );
+
+            response =
+                createNavigationJsonResponse(
+                    {
+                        error:
+                            "Internal Server Error",
+                    },
+                    {
+                        status:
+                            500,
+                    }
+                );
+        }
+    }
+
+    await sendNavigationWebResponse(
+        req,
+        res,
+        response
+    );
+}
+
+function createNavigationRequest(
+    req: http.IncomingMessage,
+    target: URL
+): Request {
+    const headers =
+        new Headers();
+
+    for (
+        const [key, value]
+        of Object.entries(
+            req.headers
+        )
+    ) {
+        if (value === undefined) {
+            continue;
+        }
+
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                headers.append(
+                    key,
+                    item
+                );
+            }
+        } else {
+            headers.set(
+                key,
+                value
+            );
+        }
+    }
+
+    return new Request(
+        target,
+        {
+            method:
+                "GET",
+            headers,
+        }
+    );
+}
+
+function proxyRequest(
+    req: http.IncomingMessage,
+    res: http.ServerResponse,
+    port: number
+): void {
+    const upstream =
+        http.request({
+            hostname:
+                "127.0.0.1",
+            port,
+            method:
+                req.method ??
+                "GET",
+            path:
+                req.url ??
+                "/",
+            headers: {
+                ...req.headers,
+                host:
+                    req.headers.host,
+            },
+        });
+
+    upstream.on(
+        "response",
+        (upstreamResponse) => {
+            res.writeHead(
+                upstreamResponse
+                    .statusCode ??
+                    502,
+                upstreamResponse
+                    .statusMessage ??
+                    "",
+                upstreamResponse.headers
+            );
+
+            upstreamResponse.pipe(
+                res
+            );
+        }
+    );
+
+    upstream.on(
+        "error",
+        (error) => {
+            if (
+                res.headersSent
+            ) {
+                res.destroy(
+                    error
+                );
+                return;
+            }
+
+            res.writeHead(
+                502,
+                {
+                    "Content-Type":
+                        "text/plain; charset=utf-8",
+                    "Cache-Control":
+                        "no-store",
+                }
+            );
+            res.end(
+                "Bad Gateway"
+            );
+        }
+    );
+
+    req.pipe(
+        upstream
+    );
+}
+
+function normalizePathname(
+    pathname: string
+): string {
+    if (
+        pathname.length > 1 &&
+        pathname.endsWith(
+            "/"
+        )
+    ) {
+        return pathname.slice(
+            0,
+            -1
+        );
+    }
+
+    return pathname || "/";
+}
+
+async function findFreePort(): Promise<number> {
+    const server =
+        net.createServer();
+
+    try {
+        await listen(
+            server,
+            0,
+            "127.0.0.1"
+        );
+
+        const address =
+            server.address();
+
+        if (
+            !address ||
+            typeof address ===
+                "string"
+        ) {
+            throw new Error(
+                "BCP Framework: could not allocate loader navigation production port."
+            );
+        }
+
+        return address.port;
+    } finally {
+        await closeServer(
+            server
+        );
+    }
+}
+
+function listen(
+    server: net.Server | http.Server,
+    port: number,
+    hostname: string
+): Promise<void> {
+    return new Promise(
+        (
+            resolve,
+            reject
+        ) => {
+            const onError =
+                (error: Error) => {
+                    server.off(
+                        "listening",
+                        onListening
+                    );
+                    reject(
+                        error
+                    );
+                };
+
+            const onListening =
+                () => {
+                    server.off(
+                        "error",
+                        onError
+                    );
+                    resolve();
+                };
+
+            server.once(
+                "error",
+                onError
+            );
+            server.once(
+                "listening",
+                onListening
+            );
+            server.listen(
+                port,
+                hostname
+            );
+        }
+    );
+}
+
+function closeServer(
+    server: net.Server | http.Server
+): Promise<void> {
+    if (!server.listening) {
+        return Promise.resolve();
+    }
+
+    return new Promise(
+        (
+            resolve,
+            reject
+        ) => {
+            server.close(
+                (error) => {
+                    if (error) {
+                        reject(
+                            error
+                        );
+                        return;
+                    }
+
+                    resolve();
+                }
+            );
+        }
+    );
+}