fix body streaming and some tests

Author: vhess

lib/http-proxy/passes/web-incoming.ts

@@ -283,9 +283,14 @@ async function stream2(
 
   const outgoingOptions = common.setupOutgoing(options.ssl || {}, options, req);
 
+  // Remove symbols from headers as undici fetch does not like them
   const requestOptions: RequestInit = {
     method: outgoingOptions.method as Dispatcher.HttpMethod,
-    headers: outgoingOptions.headers as Record<string, string>,
+    headers: Object.fromEntries(
+      Object.entries(outgoingOptions.headers || {}).filter(([key, _value]) => {
+        return typeof key === "string";
+      })
+    ) as RequestInit["headers"],
     ...fetchOptions.requestOptions
   };
 
@@ -314,7 +319,7 @@ async function stream2(
   }
 
   try {
-    const response = await fetch(outgoingOptions.url, requestOptions);
+    const response = await fetch(new URL(outgoingOptions.path ?? "/", outgoingOptions.url), requestOptions);
 
     // Call onAfterResponse callback after receiving the response
     if (fetchOptions.onAfterResponse) {
@@ -331,14 +336,19 @@ async function stream2(
     // But since only certain properties are used, we can fake it here
     // to avoid having to refactor everything.
     const fakeProxyRes = {
-      ...response, rawHeaders: Object.entries(response.headers).flatMap(([key, value]) => {
+      statusCode: response.status,
+      statusMessage: response.statusText,
+      headers: Object.fromEntries(response.headers.entries()),
+      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[]
     } as unknown as ProxyResponse;
 
+    server?.emit("proxyRes", fakeProxyRes, req, res);
+
     if (!res.headersSent && !options.selfHandleResponse) {
       for (const pass of web_o) {
         // note: none of these return anything
@@ -353,12 +363,19 @@ async function stream2(
         : null;
 
       if (nodeStream) {
+        nodeStream.on("error", (err) => {
+          handleError(err, options.target);
+        });
+
         nodeStream.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) {
-          nodeStream.pipe(res);
+          nodeStream.pipe(res, { end: true });
+        } else {
+          nodeStream.resume();
         }
       } else {
         server?.emit("end", req, res, fakeProxyRes);

lib/test/http/proxy-callbacks.test.ts

@@ -41,7 +41,7 @@ describe("Undici callback functions (onBeforeRequest and onAfterResponse)", () =
     it("Test onBeforeRequest and onAfterResponse callbacks", async () => {
         let onBeforeRequestCalled = false;
         let onAfterResponseCalled = false;
-        let capturedResponse: unknown = {};
+        let capturedResponse: Response = {} as Response;
 
         const proxy = httpProxy.createServer({
             target: `http://localhost:${ports.target}`,
@@ -83,10 +83,9 @@ describe("Undici callback functions (onBeforeRequest and onAfterResponse)", () =
         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('status');
+        expect((capturedResponse).status).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');
+        expect((capturedResponse).headers.get('x-target-header')).toBe('from-target');
     });
 });

lib/test/lib/http-proxy-passes-web-incoming.test.ts

@@ -306,7 +306,6 @@ describe("#createProxyServer.web() using own http server", () => {
       target: address(8083),
       proxyTimeout: 100,
       timeout: 150, // so client exits and isn't left handing the test.
-      fetch: true
     });
 
     const server = require("net").createServer().listen(ports["8083"]);