feat: Add callback functions, group options

vhess · vhess · commit 769957beba41 · 2025-10-23T09:07:10.000+02:00
diff --git a/lib/http-proxy/index.ts b/lib/http-proxy/index.ts
@@ -93,8 +93,19 @@ export interface ServerOptions {
 	 * This is passed to https.request.
 	 */
 	ca?: string;
+	/** Enable undici for HTTP/2 support. Set to true for defaults, or provide custom configuration. */
+	undici?: boolean | UndiciOptions;
+}
+
+export interface UndiciOptions {
+	/** Undici Agent configuration */
 	agentOptions?: Agent.Options;
+	/** Undici request options */
 	requestOptions?: Dispatcher.RequestOptions;
+	/** Called before making the undici request */
+	onBeforeRequest?: (requestOptions: Dispatcher.RequestOptions, req: http.IncomingMessage, res: http.ServerResponse, options: NormalizedServerOptions) => void | Promise<void>;
+	/** Called after receiving the undici response */
+	onAfterResponse?: (response: Dispatcher.ResponseData, req: http.IncomingMessage, res: http.ServerResponse, options: NormalizedServerOptions) => void | Promise<void>;
 }
 
 export interface NormalizedServerOptions extends ServerOptions {
@@ -232,7 +243,7 @@ export class ProxyServer<TIncomingMessage extends typeof http.IncomingMessage =
 	constructor(options: ServerOptions = {}) {
 		super();
 		log("creating a ProxyServer", options);
-		options.prependPath = options.prependPath === false ? false : true;
+		options.prependPath = options.prependPath !== false;
 		this.options = options;
 		this.web = this.createRightProxy("web")(options);
 		this.ws = this.createRightProxy("ws")(options);
diff --git a/lib/http-proxy/passes/web-incoming.ts b/lib/http-proxy/passes/web-incoming.ts
@@ -17,7 +17,7 @@ import type { Socket } from "node:net";
 import type Stream from "node:stream";
 import * as followRedirects from "follow-redirects";
 import { Agent, type Dispatcher, interceptors } from "undici";
-import type { ErrorCallback, NormalizedServerOptions, NormalizeProxyTarget, ProxyServer, ProxyTarget, ProxyTargetUrl, ServerOptions } from "..";
+import type { ErrorCallback, NormalizedServerOptions, NormalizeProxyTarget, ProxyServer, ProxyTarget, ProxyTargetUrl, ServerOptions, UndiciOptions } from "..";
 import * as common from "../common";
 import { type EditableResponse, OUTGOING_PASSES } from "./web-outgoing";
 
@@ -79,8 +79,7 @@ export function stream(req: Request, res: Response, options: NormalizedServerOpt
   // And we begin!
   server.emit("start", req, res, options.target || options.forward!);
 
-  if (options.agentOptions || options.requestOptions
-  ) {
+  if (options.undici) {
     return stream2(req, res, options, _, server, cb);
   }
 
@@ -213,12 +212,16 @@ async function stream2(
   }
   );
 
+  const undiciOptions = options.undici === true ? {} as UndiciOptions : options.undici;
+  if (!undiciOptions) {
+    throw new Error("stream2 called without undici options");
+  }
   const agentOptions: Agent.Options = {
-    ...options.agentOptions,
     allowH2: true,
     connect: {
       rejectUnauthorized: options.secure !== false,
     },
+    ...(undiciOptions.agentOptions || {}),
   };
 
   let agent: Agent | Dispatcher = new Agent(agentOptions)
@@ -249,8 +252,36 @@ async function stream2(
       requestOptions.body = req;
     }
 
+    // Call onBeforeRequest callback before making the forward request
+    if (undiciOptions.onBeforeRequest) {
+      try {
+        await undiciOptions.onBeforeRequest(requestOptions, req, res, options);
+      } catch (err) {
+        if (cb) {
+          cb(err as Error, req, res, options.forward);
+        } else {
+          server.emit("error", err as Error, req, res, options.forward);
+        }
+        return;
+      }
+    }
+
     try {
-      await agent.request(requestOptions)
+      const result = await agent.request(requestOptions);
+
+      // Call onAfterResponse callback for forward requests (though they typically don't expect responses)
+      if (undiciOptions.onAfterResponse) {
+        try {
+          await undiciOptions.onAfterResponse(result, req, res, options);
+        } catch (err) {
+          if (cb) {
+            cb(err as Error, req, res, options.forward);
+          } else {
+            server.emit("error", err as Error, req, res, options.forward);
+          }
+          return;
+        }
+      }
     } catch (err) {
       if (cb) {
         cb(err as Error, req, res, options.forward);
@@ -272,6 +303,7 @@ async function stream2(
     headers: outgoingOptions.headers || {},
     path: outgoingOptions.path || "/",
     headersTimeout: options.proxyTimeout,
+    ...undiciOptions.requestOptions
   };
 
   if (options.auth) {
@@ -284,29 +316,47 @@ async function stream2(
     requestOptions.body = req;
   }
 
-  
-  
-  
+  // Call onBeforeRequest callback before making the request
+  if (undiciOptions.onBeforeRequest) {
+    try {
+      await undiciOptions.onBeforeRequest(requestOptions, req, res, options);
+    } catch (err) {
+      if (cb) {
+        cb(err as Error, req, res, options.target);
+      } else {
+        server.emit("error", err as Error, req, res, options.target);
+      }
+      return;
+    }
+  }
+
   try {
-    const { statusCode, headers, body } = await agent.request(
-      requestOptions
-    );
+    const response = await agent.request(requestOptions);
+
+    // Call onAfterResponse callback after receiving the response
+    if (undiciOptions.onAfterResponse) {
+      try {
+        await undiciOptions.onAfterResponse(response, req, res, options);
+      } catch (err) {
+        if (cb) {
+          cb(err as Error, req, res, options.target);
+        } else {
+          server.emit("error", err as Error, req, res, options.target);
+        }
+        return;
+      }
+    }
+
 
     // ProxyRes is used in the outgoing passes
     // But since only certain properties are used, we can fake it here
     // to avoid having to refactor everything.
-    const fakeProxyRes = {} as ProxyResponse;
-
-    fakeProxyRes.statusCode = statusCode;
-    fakeProxyRes.headers = headers as { [key: string]: string | string[] };
-    fakeProxyRes.rawHeaders = Object.entries(headers).flatMap(([key, value]) => {
+    const fakeProxyRes = {...response, rawHeaders: Object.entries(response.headers).flatMap(([key, value]) => {
       if (Array.isArray(value)) {
         return value.flatMap(v => (v != null ? [key, v] : []));
       }
       return value != null ? [key, value] : [];
-    }) as string[];
-    fakeProxyRes.pipe = body.pipe.bind(body);
-
+    }) as string[]} as unknown as ProxyResponse;
 
     if (!res.headersSent && !options.selfHandleResponse) {
       for (const pass of web_o) {
@@ -317,12 +367,12 @@ async function stream2(
 
     if (!res.writableEnded) {
       // Allow us to listen for when the proxy has completed
-      body.on("end", () => {
+      response.body.on("end", () => {
         server?.emit("end", req, res, fakeProxyRes);
       });
       // We pipe to the response unless its expected to be handled by the user
       if (!options.selfHandleResponse) {
-        body.pipe(res);
+        response.body.pipe(res);
       }
     } else {
       server?.emit("end", req, res, fakeProxyRes);
diff --git a/lib/test/http/proxy-callbacks.test.ts b/lib/test/http/proxy-callbacks.test.ts
@@ -0,0 +1,93 @@
+/*
+Test the new onProxyReq and onProxyRes callbacks for undici code path
+
+pnpm test proxy-callbacks.test.ts
+*/
+
+import * as http from "node:http";
+import * as httpProxy from "../..";
+import getPort from "../get-port";
+import fetch from "node-fetch";
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { Agent, setGlobalDispatcher } from "undici";
+
+setGlobalDispatcher(new Agent({
+    allowH2: true
+}));
+
+describe("Undici callback functions (onBeforeRequest and onAfterResponse)", () => {
+    let ports: Record<'target' | 'proxy', number>;
+    const servers: Record<string, any> = {};
+
+    beforeAll(async () => {
+        ports = { target: await getPort(), proxy: await getPort() };
+    });
+
+    afterAll(async () => {
+        Object.values(servers).map((x) => x?.close());
+    });
+
+    it("Create the target HTTP server", async () => {
+        servers.target = http
+            .createServer((req, res) => {
+                res.writeHead(200, {
+                    "Content-Type": "text/plain",
+                    "X-Target-Header": "from-target"
+                });
+                res.write(`Request received: ${req.method} ${req.url}\n`);
+                res.write(`Headers: ${JSON.stringify(req.headers, null, 2)}\n`);
+                res.end();
+            })
+            .listen(ports.target);
+    });
+
+    it("Test onBeforeRequest and onAfterResponse callbacks", async () => {
+        let onBeforeRequestCalled = false;
+        let onAfterResponseCalled = false;
+        let capturedResponse: unknown = {};
+
+        const proxy = httpProxy.createServer({
+            target: `http://localhost:${ports.target}`,
+            undici: {
+                agentOptions: { allowH2: true }, // Enable undici code path
+                onBeforeRequest: async (requestOptions, _req, _res, _options) => {
+                    onBeforeRequestCalled = true;
+                    // Modify the outgoing request
+                    requestOptions.headers = {
+                        ...requestOptions.headers,
+                        'X-Proxy-Added': 'callback-added-header',
+                        'X-Original-Method': _req.method || 'unknown'
+                    };
+                },
+                onAfterResponse: async (response, _req, _res, _options) => {
+                    onAfterResponseCalled = true;
+                    capturedResponse = response;
+                    console.log(`Response received: ${response.statusCode}`);
+                }
+            }
+        }); servers.proxy = proxy.listen(ports.proxy);
+
+        // Make a request through the proxy
+        const response = await fetch(`http://localhost:${ports.proxy}/test`);
+        const text = await response.text();
+
+        // Check that the response is successful
+        expect(response.status).toBe(200);
+        expect(text).toContain("Request received: GET /test");
+
+        // Check that our added header made it to the target
+        expect(text).toContain("x-proxy-added");
+        expect(text).toContain("callback-added-header");
+
+        // Check that callbacks were called
+        expect(onBeforeRequestCalled).toBe(true);
+        expect(onAfterResponseCalled).toBe(true);
+
+        // Check that we received the full response object
+        expect(capturedResponse).toHaveProperty('statusCode');
+        expect((capturedResponse as { statusCode: number }).statusCode).toBe(200);
+        expect(capturedResponse).toHaveProperty('headers');
+        expect((capturedResponse as { headers: Record<string, string> }).headers).toHaveProperty('x-target-header');
+        expect((capturedResponse as { headers: Record<string, string> }).headers['x-target-header']).toBe('from-target');
+    });
+});
diff --git a/lib/test/http/proxy-http2-to-http2.test.ts b/lib/test/http/proxy-http2-to-http2.test.ts
@@ -46,7 +46,7 @@ describe("Basic example of proxying over HTTP2 to a target HTTP2 server", () =>
       .createServer({
         target: `https://localhost:${ports.http2}`,
         ssl,
-        agentOptions: { allowH2: true },
+        undici: { agentOptions: { allowH2: true } },
         // without secure false, clients will fail and this is broken:
         secure: false,
       })
