@chidchanun/bcp 0.1.16 → 0.1.18

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

@@ -1,11 +1,10 @@
 import * as http from "node:http";
 
 import {
-    applyMiddlewareRequestHeaders,
-    applyMiddlewareResponseHeaders,
-    executeMiddleware,
-    sendMiddlewareRedirect,
+    executeMiddlewarePipeline,
+    getMiddlewareRedirectTarget,
     sendMiddlewareResponse,
+    type MiddlewareExecutionInput,
     type MiddlewareModule,
 } from "./middleware.js";
 
@@ -81,8 +80,8 @@ export function createMiddlewareProxy(
                             await options
                                 .getMiddleware();
 
-                        const result =
-                            await executeMiddleware(
+                        const response =
+                            await executeMiddlewarePipeline(
                                 module,
                                 {
                                     url:
@@ -94,91 +93,53 @@ export function createMiddlewareProxy(
                                         incomingHeadersToHeaders(
                                             req.headers
                                         ),
-                                }
+                                },
+                                (
+                                    pipelineInput
+                                ) =>
+                                    requestUpstreamAsResponse(
+                                        req,
+                                        pipelineInput,
+                                        upstreamHostname,
+                                        options.upstreamPort,
+                                        host,
+                                        incomingUrl,
+                                        navigationTarget,
+                                        targetUrl
+                                    )
                             );
 
-                        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
+                        const middlewareRedirect =
+                            getMiddlewareRedirectTarget(
+                                response
                             );
-                            return;
-                        }
 
                         if (
-                            result.type ===
-                            "response"
+                            navigationTarget &&
+                            middlewareRedirect
                         ) {
-                            await sendMiddlewareResponse(
-                                req,
+                            applyNavigationRedirectHeaders(
                                 res,
-                                result.response
+                                response.headers
                             );
+                            res.statusCode =
+                                204;
+                            res.setHeader(
+                                NAVIGATION_REDIRECT_HEADER,
+                                middlewareRedirect.href
+                            );
+                            res.setHeader(
+                                "Cache-Control",
+                                "no-store"
+                            );
+                            res.end();
                             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(
+                        await sendMiddlewareResponse(
                             req,
                             res,
-                            upstreamHostname,
-                            options.upstreamPort,
-                            host
+                            response
                         );
                     } catch (error) {
                         console.error(
@@ -282,114 +243,319 @@ function resolveNavigationTarget(
     }
 }
 
-function proxyRequest(
+function requestUpstreamAsResponse(
     req: http.IncomingMessage,
-    res: http.ServerResponse,
+    input: MiddlewareExecutionInput,
     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,
-                },
-            }
+    originalHost: string,
+    incomingUrl: URL,
+    navigationTarget: URL | null,
+    originalTargetUrl: URL
+): Promise<Response> {
+    const target =
+        input.url instanceof URL
+            ? new URL(
+                input.url.href
+            )
+            : new URL(
+                input.url
+            );
+    const requestHeaders =
+        headersToNodeHeaders(
+            new Headers(
+                input.headers
+            )
         );
 
-    upstream.on(
-        "response",
-        (upstreamResponse) => {
-            const headers = {
-                ...upstreamResponse.headers,
-            };
+    requestHeaders.host =
+        originalHost;
+    requestHeaders[
+        "x-forwarded-host"
+    ] = originalHost;
+
+    const path =
+        resolveUpstreamPath(
+            target,
+            incomingUrl,
+            navigationTarget,
+            originalTargetUrl
+        );
 
-            for (
-                const [
-                    name,
-                    value,
-                ]
-                of Object.entries(
-                    headers
-                )
-            ) {
-                if (
-                    value !== undefined
-                ) {
-                    res.setHeader(
-                        name,
-                        value
+    return new Promise<Response>(
+        (
+            resolve,
+            reject
+        ) => {
+            const upstream =
+                http.request(
+                    {
+                        hostname:
+                            upstreamHostname,
+                        port:
+                            upstreamPort,
+                        method:
+                            input.method ??
+                            req.method ??
+                            "GET",
+                        path,
+                        headers:
+                            requestHeaders,
+                    }
+                );
+
+            upstream.once(
+                "response",
+                (
+                    upstreamResponse
+                ) => {
+                    const chunks:
+                        Buffer[] = [];
+
+                    upstreamResponse.on(
+                        "data",
+                        (
+                            chunk:
+                                Buffer |
+                                string
+                        ) => {
+                            chunks.push(
+                                Buffer.isBuffer(
+                                    chunk
+                                )
+                                    ? chunk
+                                    : Buffer.from(
+                                        chunk
+                                    )
+                            );
+                        }
+                    );
+                    upstreamResponse.once(
+                        "error",
+                        reject
+                    );
+                    upstreamResponse.once(
+                        "end",
+                        () => {
+                            const headers =
+                                responseHeadersFromNode(
+                                    upstreamResponse.headers
+                                );
+                            const status =
+                                upstreamResponse.statusCode ??
+                                502;
+                            const body =
+                                req.method ===
+                                    "HEAD" ||
+                                status === 204 ||
+                                status === 304
+                                    ? null
+                                    : Buffer.concat(
+                                        chunks
+                                    );
+
+                            resolve(
+                                new Response(
+                                    body,
+                                    {
+                                        status,
+                                        statusText:
+                                            upstreamResponse.statusMessage ??
+                                            "",
+                                        headers,
+                                    }
+                                )
+                            );
+                        }
                     );
                 }
+            );
+
+            upstream.once(
+                "error",
+                reject
+            );
+
+            req.pipe(
+                upstream
+            );
+        }
+    );
+}
+
+function resolveUpstreamPath(
+    target: URL,
+    incomingUrl: URL,
+    navigationTarget: URL | null,
+    originalTargetUrl: URL
+): string {
+    if (!navigationTarget) {
+        return `${target.pathname}${target.search}`;
+    }
+
+    const envelope =
+        new URL(
+            incomingUrl.href
+        );
+
+    if (
+        target.href !==
+        originalTargetUrl.href
+    ) {
+        envelope.searchParams.set(
+            "url",
+            `${target.pathname}${target.search}${target.hash}`
+        );
+    }
+
+    return `${envelope.pathname}${envelope.search}`;
+}
+
+function responseHeadersFromNode(
+    input: http.IncomingHttpHeaders
+): Headers {
+    const headers =
+        new Headers();
+
+    for (
+        const [
+            key,
+            value,
+        ]
+        of Object.entries(
+            input
+        )
+    ) {
+        if (
+            value === undefined ||
+            isHopByHopHeader(
+                key
+            )
+        ) {
+            continue;
+        }
+
+        if (
+            Array.isArray(
+                value
+            )
+        ) {
+            for (
+                const item
+                of value
+            ) {
+                headers.append(
+                    key,
+                    item
+                );
             }
+            continue;
+        }
 
-            res.statusCode =
-                upstreamResponse.statusCode ??
-                502;
+        headers.set(
+            key,
+            value
+        );
+    }
+
+    return headers;
+}
 
+function headersToNodeHeaders(
+    input: Headers
+): http.OutgoingHttpHeaders {
+    const headers:
+        http.OutgoingHttpHeaders = {};
+
+    input.forEach(
+        (value, key) => {
             if (
-                upstreamResponse.statusMessage
+                !isHopByHopHeader(
+                    key
+                )
             ) {
-                res.statusMessage =
-                    upstreamResponse.statusMessage;
+                headers[key] =
+                    value;
             }
-
-            upstreamResponse.pipe(
-                res
-            );
         }
     );
 
-    upstream.on(
-        "error",
-        (error) => {
-            console.error(
-                "[BCP Middleware] upstream request failed:",
-                error
-            );
+    return headers;
+}
+
+function applyNavigationRedirectHeaders(
+    res: http.ServerResponse,
+    headers: Headers
+): void {
+    headers.forEach(
+        (value, key) => {
+            const normalized =
+                key.toLowerCase();
 
             if (
-                res.headersSent
+                normalized ===
+                    "location" ||
+                normalized ===
+                    "content-length" ||
+                isHopByHopHeader(
+                    normalized
+                )
             ) {
-                res.destroy(
-                    error
-                );
                 return;
             }
 
-            res.writeHead(
-                502,
-                {
-                    "Content-Type":
-                        "text/plain; charset=utf-8",
-                    "Cache-Control":
-                        "no-store",
-                }
-            );
-            res.end(
-                "Bad Gateway"
+            res.setHeader(
+                key,
+                value
             );
         }
     );
 
-    req.pipe(
-        upstream
-    );
+    const getSetCookie =
+        (
+            headers as Headers & {
+                getSetCookie?: () => string[];
+            }
+        ).getSetCookie;
+
+    if (
+        typeof getSetCookie ===
+        "function"
+    ) {
+        const cookies =
+            getSetCookie.call(
+                headers
+            );
+
+        if (
+            cookies.length > 0
+        ) {
+            res.setHeader(
+                "Set-Cookie",
+                cookies
+            );
+        }
+    }
+}
+
+function isHopByHopHeader(
+    name: string
+): boolean {
+    switch (
+        name.toLowerCase()
+    ) {
+        case "connection":
+        case "keep-alive":
+        case "proxy-authenticate":
+        case "proxy-authorization":
+        case "te":
+        case "trailer":
+        case "transfer-encoding":
+        case "upgrade":
+            return true;
+        default:
+            return false;
+    }
 }
 
 function incomingHeadersToHeaders(