(#59) Additional Diagnostics on Fastify Request

dajinchu · web-flow · commit 09ae474ad3ca · 2026-01-16T13:08:22.000-05:00
diff --git a/bifrost-fastify/index.ts b/bifrost-fastify/index.ts
@@ -10,12 +10,10 @@ import proxy, { type FastifyHttpProxyOptions } from "@fastify/http-proxy";
 import accepts from "@fastify/accepts";
 import forwarded from "@fastify/forwarded";
 import type { GetLayout, WrappedServerOnly } from "@alignable/bifrost/config";
-import { PassThrough, Writable } from "stream";
 import { renderPage } from "vike/server";
 import { PageContextServer } from "vike/types";
 import { extractDomElements } from "./lib/extractDomElements";
 import { Http2ServerRequest } from "http2";
-import { IncomingMessage } from "http";
 import { text } from "node:stream/consumers";
 import { parse as parseContentType } from "fast-content-type-parse";
 
@@ -32,7 +30,12 @@ type RenderedPageContext = Awaited<
 
 declare module "fastify" {
   interface FastifyRequest {
-    bifrostPageId?: string | null;
+    /// Actual ProxyMode after processing  backend server results, which can tell us to fallback to passthru or redirect
+    bifrostProxyMode?: Vike.Config["proxyMode"];
+    /// whether we sent proxy headers to legacy backend
+    bifrostSentProxyHeaders?: boolean;
+    bifrostProxyLayout?: Vike.ProxyLayoutInfo | null;
+    /// Only set when proxy mode is false or wrapped
     vikePageContext?: Partial<PageContextServer> | null;
     getLayout: GetLayout | null;
     customPageContextInit: Partial<Omit<PageContextServer, "headers">> | null;
@@ -96,7 +99,9 @@ export const viteProxyPlugin: FastifyPluginAsync<
     );
   }
   await fastify.register(accepts);
-  fastify.decorateRequest("bifrostPageId", null);
+  fastify.decorateRequest("bifrostProxyMode", false);
+  fastify.decorateRequest("bifrostProxyLayout", null);
+  fastify.decorateRequest("bifrostSentProxyHeaders", false);
   fastify.decorateRequest("vikePageContext", null);
   fastify.decorateRequest("getLayout", null);
   fastify.decorateRequest("customPageContextInit", null);
@@ -121,16 +126,14 @@ export const viteProxyPlugin: FastifyPluginAsync<
 
         const pageContext = await renderPage(pageContextInit);
 
-        // this does not handle getting the original pageId when errors are thrown: https://github.com/vikejs/vike/issues/1112
-        req.bifrostPageId = pageContext.pageId;
-        req.vikePageContext = pageContext;
-
-        const proxyMode = pageContext.config?.proxyMode;
+        let proxyMode = pageContext.config?.proxyMode;
         if (!proxyMode) {
+          req.vikePageContext = pageContext;
           req.log.info(`bifrost: rendering page ${pageContext.pageId}`);
           return replyWithPage(reply, pageContext);
         }
 
+        req.bifrostProxyMode = "passthru";
         switch (proxyMode) {
           case "passthru": {
             req.log.info(`bifrost: passthru proxy to backend`);
@@ -163,6 +166,7 @@ export const viteProxyPlugin: FastifyPluginAsync<
                 // setting _bfproxy tells onResponse we're in wrapped mode
                 (req.raw as RawRequestExtendedWithProxy)._bfproxy = true;
                 req.getLayout = pageContext.config.getLayout;
+                req.bifrostSentProxyHeaders = true;
               }
             } else {
               req.log.error(
@@ -216,6 +220,7 @@ export const viteProxyPlugin: FastifyPluginAsync<
         }
 
         const proxyLayoutInfo = req.getLayout?.(reply.getHeaders());
+        req.bifrostProxyLayout = proxyLayoutInfo;
         if (!proxyLayoutInfo) {
           return reply.send("stream" in res ? res.stream : res);
         }
@@ -254,6 +259,8 @@ export const viteProxyPlugin: FastifyPluginAsync<
           ...req.customPageContextInit,
         };
         const pageContext = await renderPage(pageContextInit);
+        req.vikePageContext = pageContext;
+        req.bifrostProxyMode = "wrapped";
         return replyWithPage(reply, pageContext);
       },
     },
diff --git a/tests/e2e/specs/http.spec.ts b/tests/e2e/specs/http.spec.ts
@@ -1,4 +1,5 @@
-import { test, expect } from "@playwright/test";
+import { test, expect, APIResponse } from "@playwright/test";
+import { toPath } from "../../fake-backend/page-builder";
 
 test.describe("requests", () => {
   test("it proxies non-html requests", async ({ request }) => {
@@ -9,55 +10,111 @@ test.describe("requests", () => {
     );
   });
 
-  test.describe("HEAD request", () => {
-    test("returns headers for vite page", async ({ request }) => {
-      const req = await request.head("./vite-page");
-      expect(req.headers()).toMatchObject({
-        "x-test-pageid": "/pages/vite-page",
-      });
-      expect(req.headers()).not.toMatchObject({
-        "x-test-fake-backend": "1",
-      });
-    });
-
-    test("returns headers for proxied page", async ({ request }) => {
-      const req = await request.head("./custom-incorrect");
-      expect(req.headers()).toMatchObject({
-        "x-test-pageid": "/pages/proxy/passthru",
-        // hits old backend
-        "x-test-fake-backend": "1",
-      });
-    });
-  });
-
   test.describe("onError", () => {
     test("returns header that we set in onError", async ({ request }) => {
       const req = await request.get("./broken-page");
       expect(req.headers()["x-test-onerror"]).toBe("true");
     });
   });
 
-  test.describe("req.bifrostPageId", () => {
-    test("returns page id", async ({ request }) => {
+  test.describe("diagnostics attached to req", () => {
+    function diagnostics(req: APIResponse) {
+      return {
+        status: req.status(),
+        pageId: req.headers()["x-test-pageid"],
+        layout:
+          req.headers()["x-test-layout"]?.split(",").filter(Boolean) || [],
+        proxyMode:
+          req.headers()["x-test-proxymode"] &&
+          JSON.parse(req.headers()["x-test-proxymode"]),
+        sentProxyHeaders: req.headers()["x-test-sent-proxy-headers"] === "1",
+      };
+    }
+
+    test("vite page sets pageId", async ({ request }) => {
       const req = await request.get("./vite-page");
-      expect(req.headers()["x-test-pageid"]).toBe("/pages/vite-page");
+      expect(diagnostics(req)).toEqual({
+        status: 200,
+        pageId: "/pages/vite-page",
+        layout: [],
+        proxyMode: false,
+        sentProxyHeaders: false,
+      });
     });
 
-    test("returns undefined when no route matches at all", async ({
-      request,
-    }) => {
+    test("when no route matches at all", async ({ request }) => {
       const req = await request.get("./jsaidofjasidofjasoidf");
-      expect(req.headers()["x-test-pageid"]).toBe(undefined);
+      expect(diagnostics(req)).toEqual({
+        status: 404,
+        pageId: undefined,
+        layout: [],
+        proxyMode: undefined,
+        sentProxyHeaders: false,
+      });
     });
 
-    test("returns wrapped proxy route when hit", async ({ request }) => {
-      const req = await request.get("./json-route");
-      expect(req.headers()["x-test-pageid"]).toBe("/pages/proxy/wrapped");
+    test("on passthru, undefined pageId and layout", async ({ request }) => {
+      const req = await request.get(
+        toPath({ endpoint: "custom-incorrect", title: "a" })
+      );
+      expect(diagnostics(req)).toEqual({
+        status: 200,
+        pageId: undefined,
+        layout: [],
+        proxyMode: "passthru",
+        sentProxyHeaders: false,
+      });
     });
 
-    test("returns passthru proxy route when hit", async ({ request }) => {
-      const req = await request.get("./custom-incorrect");
-      expect(req.headers()["x-test-pageid"]).toBe("/pages/proxy/passthru");
+    test("wrapped with layout", async ({ request }) => {
+      const req = await request.get(toPath({ title: "a" }));
+      expect(diagnostics(req)).toEqual({
+        status: 200,
+        pageId: "/pages/proxy/wrapped",
+        layout: ["main_nav"],
+        proxyMode: "wrapped",
+        sentProxyHeaders: true,
+      });
+    });
+
+    test("wrapped with no layout", async ({ request }) => {
+      const req = await request.get(toPath({ title: "a", layout: "" }));
+      expect(diagnostics(req)).toEqual({
+        status: 200,
+        pageId: undefined,
+        layout: [],
+        proxyMode: "passthru",
+        sentProxyHeaders: true,
+      });
+    });
+
+    test("HEAD request on vite-page", async ({ request }) => {
+      const req = await request.head("./vite-page");
+      expect(diagnostics(req)).toEqual({
+        status: 200,
+        pageId: "/pages/vite-page",
+        layout: [],
+        proxyMode: false,
+        sentProxyHeaders: false,
+      });
+      expect(req.headers()).not.toMatchObject({
+        "x-test-fake-backend": "1",
+      });
+    });
+
+    test("HEAD request on proxied page", async ({ request }) => {
+      const req = await request.head(
+        toPath({ endpoint: "custom-incorrect", title: "a" })
+      );
+      expect(diagnostics(req)).toEqual({
+        status: 200,
+        pageId: undefined,
+        layout: [],
+        proxyMode: "passthru",
+        sentProxyHeaders: false,
+      });
+      // hits old backend
+      expect(req.headers()["x-test-fake-backend"]).toBe("1");
     });
 
     test.skip("returns original page id on error pages", async ({
@@ -69,9 +126,7 @@ test.describe("requests", () => {
   });
 
   test.describe("wrapped xhr", () => {
-    test("passes through script response", async ({
-      request,
-    }) => {
+    test("passes through script response", async ({ request }) => {
       const req = await request.get("/script-wrapped", {
         headers: { Accept: "text/html" },
       });
@@ -81,15 +136,13 @@ test.describe("requests", () => {
       );
     });
 
-    test("passes through JSON response", async ({
-      request,
-    }) => {
+    test("passes through JSON response", async ({ request }) => {
       // important to set accept */* to allow the wrapped proxy
       const req = await request.get("/json-wrapped", {
         headers: { Accept: "application/json */*" },
       });
       expect(req.status()).toBe(200);
       expect(await req.json()).toEqual({ data: true });
     });
-  })
+  });
 });
diff --git a/tests/vite/server/index.ts b/tests/vite/server/index.ts
@@ -38,10 +38,21 @@ async function startServer() {
   }
 
   app.addHook("onSend", async (req, reply) => {
-    if (req.bifrostPageId) {
-      // set header for testing
-      reply.header("X-TEST-PAGEID", req.bifrostPageId);
+    // set header for testing
+    if (req.vikePageContext?.pageId) {
+      reply.header("X-TEST-PAGEID", req.vikePageContext.pageId);
     }
+
+    const layoutInfo = Object.keys(req.bifrostProxyLayout || {}).join(",");
+    if (layoutInfo) reply.header("X-TEST-LAYOUT", layoutInfo);
+
+    if (req.bifrostProxyMode !== undefined)
+      reply.header("X-TEST-PROXYMODE", JSON.stringify(req.bifrostProxyMode));
+
+    reply.header(
+      "X-TEST-SENT-PROXY-HEADERS",
+      req.bifrostSentProxyHeaders ? "1" : "0"
+    );
   });
 
   app.register(viteProxyPlugin, {
