@chidchanun/bcp 0.1.10 → 0.1.12

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

@@ -0,0 +1,765 @@
+import fs from "node:fs";
+import * as http from "node:http";
+import * as net from "node:net";
+import path from "node:path";
+import {
+    pathToFileURL,
+} from "node:url";
+
+import {
+    createFormActionErrorResponse,
+    createFormActionTransportResponse,
+    isEnhancedFormActionRequest,
+    type CompletedPageAction,
+} from "./form-action-transport.js";
+
+import {
+    sendNavigationWebResponse,
+} from "./navigation-response.js";
+
+import {
+    createStandaloneProductionServer as createBaseStandaloneProductionServer,
+    type StandaloneApiRoute,
+    type StandalonePageRoute,
+    type StandaloneProductionServerOptions as BaseStandaloneProductionServerOptions,
+} from "./standalone-production-runtime-v2-guard.js";
+
+export type {
+    StandaloneApiRoute,
+    StandalonePageRoute,
+};
+
+export interface StandaloneProductionServerOptions
+    extends BaseStandaloneProductionServerOptions {}
+
+interface ProductionActionModule {
+    actionPathnames: string[];
+    evaluateRouteAction(
+        input: {
+            url: string;
+            name: string;
+            method: string;
+            formData: FormData;
+            headers: Array<[
+                string,
+                string
+            ]>;
+            remoteAddress: string | null;
+        }
+    ): Promise<CompletedPageAction | null>;
+}
+
+export function createStandaloneProductionServer(
+    options: StandaloneProductionServerOptions
+) {
+    const actionFile =
+        path.join(
+            options.buildDirectory,
+            "server",
+            "actions.mjs"
+        );
+
+    if (!fs.existsSync(actionFile)) {
+        return createBaseStandaloneProductionServer(
+            options
+        );
+    }
+
+    let baseServer:
+        ReturnType<
+            typeof createBaseStandaloneProductionServer
+        > | null =
+        null;
+    let gateway:
+        http.Server | null =
+        null;
+    let actionModule:
+        ProductionActionModule | null =
+        null;
+    let started =
+        false;
+
+    async function start(): Promise<void> {
+        if (started) {
+            return;
+        }
+
+        actionModule =
+            await import(
+                pathToFileURL(
+                    actionFile
+                ).href
+            ) as ProductionActionModule;
+
+        assertActionModule(
+            actionModule,
+            actionFile
+        );
+
+        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/action"
+                        ) {
+                            proxyRequest(
+                                req,
+                                res,
+                                internalPort
+                            );
+                            return;
+                        }
+
+                        await handleActionRequest(
+                            req,
+                            res,
+                            requestUrl,
+                            actionModule
+                        );
+                    } catch (error) {
+                        console.error(
+                            "[BCP Action Error]",
+                            error
+                        );
+
+                        if (
+                            res.headersSent
+                        ) {
+                            res.destroy();
+                            return;
+                        }
+
+                        await sendNavigationWebResponse(
+                            req,
+                            res,
+                            createFormActionErrorResponse(
+                                "Internal Server Error",
+                                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;
+            actionModule =
+                null;
+            throw error;
+        }
+
+        started =
+            true;
+
+        console.log(
+            `[BCP Actions] Production routes: ${actionModule.actionPathnames.length}`
+        );
+        console.log(
+            `[BCP Actions] 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;
+        }
+
+        actionModule =
+            null;
+        started =
+            false;
+    }
+
+    return {
+        start,
+        stop,
+    };
+}
+
+async function handleActionRequest(
+    req: http.IncomingMessage,
+    res: http.ServerResponse,
+    requestUrl: URL,
+    actionModule: ProductionActionModule | null
+): Promise<void> {
+    if (
+        !actionModule
+    ) {
+        throw new Error(
+            "BCP Framework: production action module was not loaded."
+        );
+    }
+
+    if (
+        (req.method ?? "GET")
+            .toUpperCase() !==
+        "POST"
+    ) {
+        await sendNavigationWebResponse(
+            req,
+            res,
+            createFormActionErrorResponse(
+                "Method Not Allowed",
+                405
+            )
+        );
+        return;
+    }
+
+    const actionName =
+        requestUrl.searchParams.get(
+            "name"
+        );
+
+    if (!actionName) {
+        await sendNavigationWebResponse(
+            req,
+            res,
+            createFormActionErrorResponse(
+                "Missing form action name.",
+                400
+            )
+        );
+        return;
+    }
+
+    const target =
+        resolveActionTarget(
+            req,
+            requestUrl
+        );
+
+    if (!target) {
+        await sendNavigationWebResponse(
+            req,
+            res,
+            createFormActionErrorResponse(
+                "Missing or invalid form action target.",
+                400
+            )
+        );
+        return;
+    }
+
+    const formData =
+        await readFormData(
+            req,
+            requestUrl
+        );
+    const result =
+        await actionModule
+            .evaluateRouteAction({
+                url:
+                    target.href,
+                name:
+                    actionName,
+                method:
+                    requestUrl.searchParams.get(
+                        "method"
+                    ) ??
+                    "POST",
+                formData,
+                headers:
+                    collectRequestHeaders(
+                        req
+                    ),
+                remoteAddress:
+                    req.socket
+                        .remoteAddress ??
+                    null,
+            });
+
+    if (!result) {
+        await sendNavigationWebResponse(
+            req,
+            res,
+            createFormActionErrorResponse(
+                "Form action not found.",
+                404
+            )
+        );
+        return;
+    }
+
+    const response =
+        createFormActionTransportResponse(
+            result,
+            target,
+            isEnhancedFormActionRequest(
+                collectHeaders(
+                    req
+                )
+            )
+        );
+
+    await sendNavigationWebResponse(
+        req,
+        res,
+        response
+    );
+}
+
+function assertActionModule(
+    value: ProductionActionModule,
+    filePath: string
+): void {
+    if (
+        !Array.isArray(
+            value.actionPathnames
+        ) ||
+        typeof value.evaluateRouteAction !==
+            "function"
+    ) {
+        throw new Error(
+            `BCP Framework: invalid standalone action module at "${filePath}".`
+        );
+    }
+}
+
+function resolveActionTarget(
+    req: http.IncomingMessage,
+    requestUrl: URL
+): URL | null {
+    const candidates = [
+        requestUrl.searchParams.get(
+            "url"
+        ),
+        headerValue(
+            req.headers[
+                "x-bcp-action-target"
+            ]
+        ),
+        headerValue(
+            req.headers.referer
+        ),
+    ];
+
+    for (
+        const candidate
+        of candidates
+    ) {
+        if (!candidate) {
+            continue;
+        }
+
+        try {
+            const target =
+                new URL(
+                    candidate,
+                    requestUrl.origin
+                );
+
+            if (
+                target.origin ===
+                requestUrl.origin &&
+                target.pathname !==
+                "/_bcp/action"
+            ) {
+                return target;
+            }
+        } catch {
+            // Try the next target source.
+        }
+    }
+
+    return null;
+}
+
+async function readFormData(
+    req: http.IncomingMessage,
+    requestUrl: URL
+): Promise<FormData> {
+    const chunks:
+        Buffer[] = [];
+
+    for await (
+        const chunk
+        of req
+    ) {
+        chunks.push(
+            Buffer.isBuffer(
+                chunk
+            )
+                ? chunk
+                : Buffer.from(
+                    chunk
+                )
+        );
+    }
+
+    const body =
+        Buffer.concat(
+            chunks
+        );
+    const request =
+        new Request(
+            requestUrl,
+            {
+                method: "POST",
+                headers:
+                    collectHeaders(
+                        req
+                    ),
+                body:
+                    body.length > 0
+                        ? body
+                        : undefined,
+            }
+        );
+
+    return request.formData();
+}
+
+function collectRequestHeaders(
+    req: http.IncomingMessage
+): Array<[
+    string,
+    string
+]> {
+    const result:
+        Array<[
+            string,
+            string
+        ]> = [];
+
+    for (
+        const [
+            name,
+            value,
+        ]
+        of Object.entries(
+            req.headers
+        )
+    ) {
+        if (
+            value === undefined
+        ) {
+            continue;
+        }
+
+        if (
+            Array.isArray(
+                value
+            )
+        ) {
+            for (
+                const item
+                of value
+            ) {
+                result.push([
+                    name,
+                    item,
+                ]);
+            }
+        } else {
+            result.push([
+                name,
+                value,
+            ]);
+        }
+    }
+
+    return result;
+}
+
+function collectHeaders(
+    req: http.IncomingMessage
+): Headers {
+    return new Headers(
+        collectRequestHeaders(
+            req
+        )
+    );
+}
+
+function headerValue(
+    value: string | string[] | undefined
+): string | null {
+    if (
+        Array.isArray(
+            value
+        )
+    ) {
+        return value[0] ??
+            null;
+    }
+
+    return value ??
+        null;
+}
+
+function proxyRequest(
+    req: http.IncomingMessage,
+    res: http.ServerResponse,
+    upstreamPort: number
+): void {
+    const upstream =
+        http.request({
+            hostname:
+                "127.0.0.1",
+            port:
+                upstreamPort,
+            method:
+                req.method ??
+                "GET",
+            path:
+                req.url ??
+                "/",
+            headers:
+                req.headers,
+        });
+
+    upstream.on(
+        "response",
+        (upstreamResponse) => {
+            res.writeHead(
+                upstreamResponse.statusCode ??
+                502,
+                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 listen(
+    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: http.Server
+): Promise<void> {
+    if (
+        !server.listening
+    ) {
+        return Promise.resolve();
+    }
+
+    return new Promise(
+        (
+            resolve,
+            reject
+        ) => {
+            server.close(
+                (error) => {
+                    if (error) {
+                        reject(
+                            error
+                        );
+                        return;
+                    }
+                    resolve();
+                }
+            );
+        }
+    );
+}
+
+async function findFreePort(): Promise<number> {
+    const server =
+        net.createServer();
+
+    try {
+        await new Promise<void>(
+            (
+                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(
+                    0,
+                    "127.0.0.1"
+                );
+            }
+        );
+
+        const address =
+            server.address();
+
+        if (
+            !address ||
+            typeof address ===
+                "string"
+        ) {
+            throw new Error(
+                "BCP Framework: could not allocate production action port."
+            );
+        }
+
+        return address.port;
+    } finally {
+        if (
+            server.listening
+        ) {
+            await new Promise<void>(
+                (
+                    resolve,
+                    reject
+                ) => {
+                    server.close(
+                        (error) => {
+                            if (error) {
+                                reject(
+                                    error
+                                );
+                                return;
+                            }
+                            resolve();
+                        }
+                    );
+                }
+            );
+        }
+    }
+}