@chidchanun/bcp 0.1.0

package/packages/server/src/middleware-loader.ts

@@ -0,0 +1,140 @@
+import fs from "node:fs";
+import path from "node:path";
+import {
+    pathToFileURL,
+} from "node:url";
+
+import type {
+    MiddlewareModule,
+} from "./middleware.js";
+
+const MIDDLEWARE_EXTENSIONS = [
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+] as const;
+
+export function findProjectMiddlewareFile(
+    rootDirectory: string
+): string | null {
+    const matches =
+        MIDDLEWARE_EXTENSIONS
+            .map(
+                (extension) =>
+                    path.join(
+                        rootDirectory,
+                        `middleware${extension}`
+                    )
+            )
+            .filter(
+                (filePath) =>
+                    fs.existsSync(
+                        filePath
+                    ) &&
+                    fs.statSync(
+                        filePath
+                    ).isFile()
+            );
+
+    if (
+        matches.length > 1
+    ) {
+        throw new Error(
+            `BCP Framework: multiple middleware files found: ${matches.map((value) => path.basename(value)).join(", ")}. Keep only one middleware.ts/.tsx/.js/.jsx file.`
+        );
+    }
+
+    return matches[0] ??
+        null;
+}
+
+export async function loadProjectMiddleware(
+    rootDirectory: string
+): Promise<MiddlewareModule | null> {
+    const filePath =
+        findProjectMiddlewareFile(
+            rootDirectory
+        );
+
+    if (!filePath) {
+        return null;
+    }
+
+    const stat =
+        fs.statSync(
+            filePath
+        );
+
+    const moduleUrl =
+        pathToFileURL(
+            filePath
+        );
+
+    moduleUrl.searchParams.set(
+        "bcp-middleware",
+        `${stat.mtimeMs}-${stat.size}`
+    );
+
+    const module =
+        await import(
+            moduleUrl.href
+        ) as MiddlewareModule;
+
+    assertMiddlewareModule(
+        module,
+        filePath
+    );
+
+    return module;
+}
+
+export function assertMiddlewareModule(
+    module: MiddlewareModule,
+    filePath = "middleware"
+): void {
+    const handler =
+        module.middleware ??
+        module.default;
+
+    if (
+        typeof handler !==
+        "function"
+    ) {
+        throw new Error(
+            `BCP Framework: ${filePath} must export a middleware(request) function or a default middleware function.`
+        );
+    }
+
+    const matcher =
+        module.config?.matcher;
+
+    if (
+        matcher === undefined
+    ) {
+        return;
+    }
+
+    const values =
+        Array.isArray(
+            matcher
+        )
+            ? matcher
+            : [
+                matcher,
+            ];
+
+    for (
+        const value
+        of values
+    ) {
+        if (
+            typeof value !== "string" &&
+            !(value instanceof RegExp)
+        ) {
+            throw new Error(
+                `BCP Framework: middleware matcher in ${filePath} must be a string, RegExp, or an array of them.`
+            );
+        }
+    }
+}

package/packages/server/src/middleware-proxy.ts

@@ -0,0 +1,516 @@
+import * as http from "node:http";
+
+import {
+    applyMiddlewareRequestHeaders,
+    applyMiddlewareResponseHeaders,
+    executeMiddleware,
+    sendMiddlewareRedirect,
+    sendMiddlewareResponse,
+    type MiddlewareModule,
+} from "./middleware.js";
+
+import {
+    applySecurityHeaders,
+} from "./security.js";
+
+export const NAVIGATION_REDIRECT_HEADER =
+    "X-BCP-Middleware-Redirect";
+
+export interface MiddlewareProxyOptions {
+    port: number;
+    hostname: string;
+    upstreamPort: number;
+    upstreamHostname?: string;
+    getMiddleware:
+        () =>
+            MiddlewareModule |
+            null |
+            Promise<
+                MiddlewareModule |
+                null
+            >;
+}
+
+export function createMiddlewareProxy(
+    options: MiddlewareProxyOptions
+) {
+    const upstreamHostname =
+        options.upstreamHostname ??
+        "127.0.0.1";
+
+    let server:
+        http.Server | null =
+        null;
+
+    async function start(): Promise<void> {
+        if (server) {
+            return;
+        }
+
+        server =
+            http.createServer(
+                async (
+                    req,
+                    res
+                ) => {
+                    applySecurityHeaders(
+                        res
+                    );
+
+                    try {
+                        const host =
+                            req.headers.host ??
+                            `${options.hostname}:${options.port}`;
+
+                        const incomingUrl =
+                            new URL(
+                                req.url ?? "/",
+                                `http://${host}`
+                            );
+
+                        const navigationTarget =
+                            resolveNavigationTarget(
+                                incomingUrl
+                            );
+
+                        const targetUrl =
+                            navigationTarget ??
+                            incomingUrl;
+
+                        const module =
+                            await options
+                                .getMiddleware();
+
+                        const result =
+                            await executeMiddleware(
+                                module,
+                                {
+                                    url:
+                                        targetUrl,
+                                    method:
+                                        req.method ??
+                                        "GET",
+                                    headers:
+                                        incomingHeadersToHeaders(
+                                            req.headers
+                                        ),
+                                }
+                            );
+
+                        if (
+                            result.type ===
+                            "redirect"
+                        ) {
+                            if (
+                                navigationTarget
+                            ) {
+                                applyMiddlewareResponseHeaders(
+                                    res,
+                                    result.headers
+                                );
+                                res.statusCode =
+                                    204;
+                                res.setHeader(
+                                    NAVIGATION_REDIRECT_HEADER,
+                                    result.url.href
+                                );
+                                res.setHeader(
+                                    "Cache-Control",
+                                    "no-store"
+                                );
+                                res.end();
+                                return;
+                            }
+
+                            sendMiddlewareRedirect(
+                                req,
+                                res,
+                                result
+                            );
+                            return;
+                        }
+
+                        if (
+                            result.type ===
+                            "response"
+                        ) {
+                            await sendMiddlewareResponse(
+                                req,
+                                res,
+                                result.response
+                            );
+                            return;
+                        }
+
+                        applyMiddlewareRequestHeaders(
+                            req,
+                            result.requestHeaders
+                        );
+                        applyMiddlewareResponseHeaders(
+                            res,
+                            result.responseHeaders
+                        );
+
+                        if (
+                            result.type ===
+                            "rewrite"
+                        ) {
+                            if (
+                                navigationTarget
+                            ) {
+                                incomingUrl
+                                    .searchParams
+                                    .set(
+                                        "url",
+                                        `${result.url.pathname}${result.url.search}${result.url.hash}`
+                                    );
+
+                                req.url =
+                                    `${incomingUrl.pathname}${incomingUrl.search}`;
+                            } else {
+                                req.url =
+                                    `${result.url.pathname}${result.url.search}`;
+                            }
+                        }
+
+                        proxyRequest(
+                            req,
+                            res,
+                            upstreamHostname,
+                            options.upstreamPort,
+                            host
+                        );
+                    } catch (error) {
+                        console.error(
+                            "[BCP Middleware] request failed:",
+                            error
+                        );
+
+                        if (
+                            res.headersSent
+                        ) {
+                            res.destroy();
+                            return;
+                        }
+
+                        res.writeHead(
+                            500,
+                            {
+                                "Content-Type":
+                                    "text/plain; charset=utf-8",
+                                "Cache-Control":
+                                    "no-store",
+                            }
+                        );
+                        res.end(
+                            "Internal Server Error"
+                        );
+                    }
+                }
+            );
+
+        server.keepAliveTimeout =
+            65_000;
+        server.headersTimeout =
+            66_000;
+
+        await listen(
+            server,
+            options.port,
+            options.hostname
+        );
+    }
+
+    async function stop(): Promise<void> {
+        if (!server) {
+            return;
+        }
+
+        const current =
+            server;
+        server =
+            null;
+
+        await closeServer(
+            current
+        );
+    }
+
+    return {
+        start,
+        stop,
+    };
+}
+
+function resolveNavigationTarget(
+    requestUrl: URL
+): URL | null {
+    if (
+        requestUrl.pathname !==
+        "/_bcp/navigation"
+    ) {
+        return null;
+    }
+
+    const rawTarget =
+        requestUrl.searchParams
+            .get(
+                "url"
+            );
+
+    if (!rawTarget) {
+        return null;
+    }
+
+    try {
+        const target =
+            new URL(
+                rawTarget,
+                requestUrl.origin
+            );
+
+        if (
+            target.origin !==
+            requestUrl.origin
+        ) {
+            return null;
+        }
+
+        return target;
+    } catch {
+        return null;
+    }
+}
+
+function proxyRequest(
+    req: http.IncomingMessage,
+    res: http.ServerResponse,
+    upstreamHostname: string,
+    upstreamPort: number,
+    originalHost: string
+): void {
+    const upstream =
+        http.request(
+            {
+                hostname:
+                    upstreamHostname,
+                port:
+                    upstreamPort,
+                method:
+                    req.method ??
+                    "GET",
+                path:
+                    req.url ??
+                    "/",
+                headers: {
+                    ...req.headers,
+                    host:
+                        originalHost,
+                    "x-forwarded-host":
+                        originalHost,
+                },
+            }
+        );
+
+    upstream.on(
+        "response",
+        (upstreamResponse) => {
+            const headers = {
+                ...upstreamResponse.headers,
+            };
+
+            for (
+                const [
+                    name,
+                    value,
+                ]
+                of Object.entries(
+                    headers
+                )
+            ) {
+                if (
+                    value !== undefined
+                ) {
+                    res.setHeader(
+                        name,
+                        value
+                    );
+                }
+            }
+
+            res.statusCode =
+                upstreamResponse.statusCode ??
+                502;
+
+            if (
+                upstreamResponse.statusMessage
+            ) {
+                res.statusMessage =
+                    upstreamResponse.statusMessage;
+            }
+
+            upstreamResponse.pipe(
+                res
+            );
+        }
+    );
+
+    upstream.on(
+        "error",
+        (error) => {
+            console.error(
+                "[BCP Middleware] upstream request failed:",
+                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 incomingHeadersToHeaders(
+    input: http.IncomingHttpHeaders
+): Headers {
+    const headers =
+        new Headers();
+
+    for (
+        const [
+            key,
+            value,
+        ]
+        of Object.entries(
+            input
+        )
+    ) {
+        if (
+            value === undefined
+        ) {
+            continue;
+        }
+
+        if (
+            Array.isArray(
+                value
+            )
+        ) {
+            for (
+                const item
+                of value
+            ) {
+                headers.append(
+                    key,
+                    item
+                );
+            }
+            continue;
+        }
+
+        headers.set(
+            key,
+            value
+        );
+    }
+
+    return headers;
+}
+
+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();
+                }
+            );
+        }
+    );
+}