@chidchanun/bcp 0.1.0

package/packages/server/src/response-cache-proxy.ts

@@ -0,0 +1,828 @@
+import * as http from "node:http";
+
+import {
+    createRouteCacheKey,
+    getCacheEntry,
+    setCacheEntry,
+    type RevalidateValue,
+} from "../../cache/src/index.js";
+
+import {
+    matchApiRoute,
+    matchRoute,
+    type ApiRoute,
+    type Route,
+    type RouteSegment,
+} from "../../router/src/index.js";
+
+export interface ResponseCacheRoute {
+    pathname: string;
+    segments: RouteSegment[];
+    revalidate: RevalidateValue;
+}
+
+export interface ResponseCacheManifest {
+    version: 1;
+    pages: ResponseCacheRoute[];
+    apiRoutes: ResponseCacheRoute[];
+}
+
+export interface ResponseCacheProxyOptions {
+    port: number;
+    hostname: string;
+    upstreamPort: number;
+    upstreamHostname?: string;
+    manifest: ResponseCacheManifest;
+}
+
+interface CacheTarget {
+    kind: "page" | "api" | "navigation";
+    pathname: string;
+    urlKey: string;
+    revalidate: RevalidateValue;
+}
+
+interface CachedHttpResponse {
+    statusCode: number;
+    statusMessage?: string;
+    headers: http.IncomingHttpHeaders;
+    body: Buffer;
+}
+
+export function createResponseCacheProxy(
+    options: ResponseCacheProxyOptions
+) {
+    const upstreamHostname =
+        options.upstreamHostname ??
+        "127.0.0.1";
+
+    const pagePatterns:
+        Route[] =
+        options.manifest.pages.map(
+            (route) => ({
+                pathname:
+                    route.pathname,
+                segments:
+                    route.segments,
+                filePath:
+                    route.pathname,
+                layouts: [],
+            })
+        );
+
+    const apiPatterns:
+        ApiRoute[] =
+        options.manifest.apiRoutes.map(
+            (route) => ({
+                pathname:
+                    route.pathname,
+                segments:
+                    route.segments,
+                filePath:
+                    route.pathname,
+            })
+        );
+
+    const pageByPathname =
+        new Map(
+            options.manifest.pages.map(
+                (route) => [
+                    route.pathname,
+                    route,
+                ]
+            )
+        );
+
+    const apiByPathname =
+        new Map(
+            options.manifest.apiRoutes.map(
+                (route) => [
+                    route.pathname,
+                    route,
+                ]
+            )
+        );
+
+    let server:
+        http.Server | null =
+        null;
+
+    async function start(): Promise<void> {
+        if (server) {
+            return;
+        }
+
+        server =
+            http.createServer(
+                (
+                    req,
+                    res
+                ) => {
+                    const host =
+                        req.headers.host ??
+                        `${options.hostname}:${options.port}`;
+
+                    let requestUrl:
+                        URL;
+
+                    try {
+                        requestUrl =
+                            new URL(
+                                req.url ?? "/",
+                                `http://${host}`
+                            );
+                    } catch {
+                        proxyRequest(
+                            req,
+                            res,
+                            null
+                        );
+                        return;
+                    }
+
+                    const target =
+                        resolveCacheTarget(
+                            requestUrl,
+                            pagePatterns,
+                            apiPatterns,
+                            pageByPathname,
+                            apiByPathname
+                        );
+
+                    if (
+                        !target ||
+                        !isCacheEligibleRequest(
+                            req
+                        )
+                    ) {
+                        proxyRequest(
+                            req,
+                            res,
+                            target
+                                ? "BYPASS"
+                                : null
+                        );
+                        return;
+                    }
+
+                    const representationKey =
+                        normalizeAcceptEncoding(
+                            req.headers[
+                                "accept-encoding"
+                            ]
+                        );
+
+                    const cacheKey =
+                        createRouteCacheKey(
+                            target.kind,
+                            `${target.urlKey}|accept-encoding:${representationKey}`
+                        );
+
+                    const cached =
+                        getCacheEntry<CachedHttpResponse>(
+                            cacheKey
+                        );
+
+                    if (cached) {
+                        sendCachedResponse(
+                            req,
+                            res,
+                            cached
+                        );
+                        return;
+                    }
+
+                    proxyRequest(
+                        req,
+                        res,
+                        "MISS",
+                        target,
+                        cacheKey
+                    );
+                }
+            );
+
+        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
+        );
+    }
+
+    function proxyRequest(
+        req: http.IncomingMessage,
+        res: http.ServerResponse,
+        cacheStatus:
+            | "MISS"
+            | "BYPASS"
+            | null,
+        target?: CacheTarget,
+        cacheKey?: string
+    ): void {
+        const upstream =
+            http.request(
+                {
+                    hostname:
+                        upstreamHostname,
+                    port:
+                        options.upstreamPort,
+                    method:
+                        req.method ??
+                        "GET",
+                    path:
+                        req.url ??
+                        "/",
+                    headers:
+                        req.headers,
+                }
+            );
+
+        upstream.on(
+            "response",
+            (upstreamResponse) => {
+                const chunks:
+                    Buffer[] = [];
+
+                upstreamResponse.on(
+                    "data",
+                    (chunk) => {
+                        chunks.push(
+                            Buffer.isBuffer(
+                                chunk
+                            )
+                                ? chunk
+                                : Buffer.from(
+                                    chunk
+                                )
+                        );
+                    }
+                );
+
+                upstreamResponse.on(
+                    "end",
+                    () => {
+                        const body =
+                            Buffer.concat(
+                                chunks
+                            );
+
+                        const response:
+                            CachedHttpResponse = {
+                            statusCode:
+                                upstreamResponse.statusCode ??
+                                502,
+                            statusMessage:
+                                upstreamResponse.statusMessage,
+                            headers: {
+                                ...upstreamResponse.headers,
+                            },
+                            body,
+                        };
+
+                        const canStore =
+                            Boolean(
+                                target &&
+                                cacheKey &&
+                                (
+                                    req.method ??
+                                    "GET"
+                                ).toUpperCase() ===
+                                    "GET" &&
+                                isCacheableResponse(
+                                    response,
+                                    target.kind
+                                )
+                            );
+
+                        if (
+                            canStore &&
+                            target &&
+                            cacheKey
+                        ) {
+                            setCacheEntry(
+                                cacheKey,
+                                response,
+                                {
+                                    revalidate:
+                                        target.revalidate,
+                                    paths: [
+                                        target.pathname,
+                                    ],
+                                    tags: [
+                                        `route:${target.pathname}`,
+                                    ],
+                                }
+                            );
+                        }
+
+                        sendProxyResponse(
+                            req,
+                            res,
+                            response,
+                            cacheStatus
+                        );
+                    }
+                );
+            }
+        );
+
+        upstream.on(
+            "error",
+            (error) => {
+                console.error(
+                    "[BCP Cache] 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
+        );
+    }
+
+    return {
+        start,
+        stop,
+    };
+}
+
+function resolveCacheTarget(
+    requestUrl: URL,
+    pagePatterns: Route[],
+    apiPatterns: ApiRoute[],
+    pageByPathname: Map<string, ResponseCacheRoute>,
+    apiByPathname: Map<string, ResponseCacheRoute>
+): CacheTarget | null {
+    if (
+        requestUrl.pathname.startsWith(
+            "/_bcp/client/"
+        ) ||
+        requestUrl.pathname ===
+            "/_bcp/dev-events"
+    ) {
+        return null;
+    }
+
+    if (
+        requestUrl.pathname ===
+        "/_bcp/navigation"
+    ) {
+        const rawTarget =
+            requestUrl.searchParams.get(
+                "url"
+            );
+
+        if (!rawTarget) {
+            return null;
+        }
+
+        let targetUrl:
+            URL;
+
+        try {
+            targetUrl =
+                new URL(
+                    rawTarget,
+                    requestUrl.origin
+                );
+        } catch {
+            return null;
+        }
+
+        if (
+            targetUrl.origin !==
+            requestUrl.origin
+        ) {
+            return null;
+        }
+
+        const match =
+            matchRoute(
+                pagePatterns,
+                normalizePathname(
+                    targetUrl.pathname
+                )
+            );
+
+        if (!match) {
+            return null;
+        }
+
+        const definition =
+            pageByPathname.get(
+                match.route.pathname
+            );
+
+        if (!definition) {
+            return null;
+        }
+
+        return {
+            kind:
+                "navigation",
+            pathname:
+                normalizePathname(
+                    targetUrl.pathname
+                ),
+            urlKey:
+                `${targetUrl.pathname}${targetUrl.search}`,
+            revalidate:
+                definition.revalidate,
+        };
+    }
+
+    const normalizedPathname =
+        normalizePathname(
+            requestUrl.pathname
+        );
+
+    const apiMatch =
+        matchApiRoute(
+            apiPatterns,
+            normalizedPathname
+        );
+
+    if (apiMatch) {
+        const definition =
+            apiByPathname.get(
+                apiMatch.route.pathname
+            );
+
+        if (definition) {
+            return {
+                kind:
+                    "api",
+                pathname:
+                    normalizedPathname,
+                urlKey:
+                    `${normalizedPathname}${requestUrl.search}`,
+                revalidate:
+                    definition.revalidate,
+            };
+        }
+    }
+
+    const pageMatch =
+        matchRoute(
+            pagePatterns,
+            normalizedPathname
+        );
+
+    if (!pageMatch) {
+        return null;
+    }
+
+    const definition =
+        pageByPathname.get(
+            pageMatch.route.pathname
+        );
+
+    if (!definition) {
+        return null;
+    }
+
+    return {
+        kind:
+            "page",
+        pathname:
+            normalizedPathname,
+        urlKey:
+            `${normalizedPathname}${requestUrl.search}`,
+        revalidate:
+            definition.revalidate,
+    };
+}
+
+function isCacheEligibleRequest(
+    req: http.IncomingMessage
+): boolean {
+    const method =
+        (
+            req.method ??
+            "GET"
+        ).toUpperCase();
+
+    if (
+        method !== "GET" &&
+        method !== "HEAD"
+    ) {
+        return false;
+    }
+
+    if (
+        req.headers.authorization ||
+        req.headers.cookie
+    ) {
+        return false;
+    }
+
+    const cacheControl =
+        req.headers[
+            "cache-control"
+        ] ??
+        "";
+
+    if (
+        /(?:^|,)\s*(?:no-cache|no-store|max-age=0)\b/i.test(
+            String(
+                cacheControl
+            )
+        )
+    ) {
+        return false;
+    }
+
+    return !/no-cache/i.test(
+        String(
+            req.headers.pragma ??
+            ""
+        )
+    );
+}
+
+function isCacheableResponse(
+    response: CachedHttpResponse,
+    kind: CacheTarget["kind"]
+): boolean {
+    if (
+        response.statusCode !== 200
+    ) {
+        return false;
+    }
+
+    if (
+        response.headers[
+            "set-cookie"
+        ] !== undefined
+    ) {
+        return false;
+    }
+
+    const cacheControl =
+        String(
+            response.headers[
+                "cache-control"
+            ] ??
+            ""
+        );
+
+    if (
+        /(?:private|no-cache)/i.test(
+            cacheControl
+        )
+    ) {
+        return false;
+    }
+
+    /*
+     * BCP-generated SSR HTML and navigation JSON intentionally use
+     * Cache-Control: no-store so browsers and intermediary caches never
+     * reuse framework responses on their own. Route-level `revalidate`
+     * controls a separate, server-side BCP cache, so that framework header
+     * must not prevent page/navigation entries from being stored internally.
+     *
+     * API responses are application-controlled, however. A no-store header
+     * returned by an API handler is explicit user intent and remains a hard
+     * opt-out from the BCP response cache.
+     */
+    if (
+        kind === "api" &&
+        /no-store/i.test(
+            cacheControl
+        )
+    ) {
+        return false;
+    }
+
+    const vary =
+        String(
+            response.headers.vary ??
+            ""
+        )
+            .split(",")
+            .map(
+                (value) =>
+                    value.trim()
+                        .toLowerCase()
+            )
+            .filter(
+                Boolean
+            );
+
+    return vary.every(
+        (value) =>
+            value ===
+            "accept-encoding"
+    );
+}
+
+function normalizeAcceptEncoding(
+    value:
+        string |
+        string[] |
+        undefined
+): string {
+    if (
+        Array.isArray(value)
+    ) {
+        return value
+            .join(",")
+            .toLowerCase();
+    }
+
+    return String(
+        value ??
+        "identity"
+    )
+        .trim()
+        .toLowerCase();
+}
+
+function sendCachedResponse(
+    req: http.IncomingMessage,
+    res: http.ServerResponse,
+    cached: CachedHttpResponse
+): void {
+    sendProxyResponse(
+        req,
+        res,
+        cached,
+        "HIT"
+    );
+}
+
+function sendProxyResponse(
+    req: http.IncomingMessage,
+    res: http.ServerResponse,
+    response: CachedHttpResponse,
+    cacheStatus:
+        | "HIT"
+        | "MISS"
+        | "BYPASS"
+        | null
+): void {
+    const headers:
+        http.OutgoingHttpHeaders = {
+        ...response.headers,
+    };
+
+    if (cacheStatus) {
+        headers[
+            "x-bcp-cache"
+        ] =
+            cacheStatus;
+    }
+
+    res.writeHead(
+        response.statusCode,
+        response.statusMessage,
+        headers
+    );
+
+    if (
+        (
+            req.method ??
+            "GET"
+        ).toUpperCase() ===
+            "HEAD"
+    ) {
+        res.end();
+        return;
+    }
+
+    res.end(
+        response.body
+    );
+}
+
+function normalizePathname(
+    pathname: string
+): string {
+    if (
+        pathname.length > 1 &&
+        pathname.endsWith("/")
+    ) {
+        return pathname.slice(
+            0,
+            -1
+        );
+    }
+
+    return pathname || "/";
+}
+
+async function listen(
+    server: http.Server,
+    port: number,
+    hostname: string
+): Promise<void> {
+    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(
+                port,
+                hostname
+            );
+        }
+    );
+}
+
+async function closeServer(
+    server: http.Server
+): Promise<void> {
+    if (!server.listening) {
+        return;
+    }
+
+    await new Promise<void>(
+        (
+            resolve,
+            reject
+        ) => {
+            server.close(
+                (error) => {
+                    if (error) {
+                        reject(
+                            error
+                        );
+                        return;
+                    }
+                    resolve();
+                }
+            );
+        }
+    );
+}