wip: fix typescript errors

Author: vhess

lib/http-proxy/index.ts

@@ -7,8 +7,6 @@ import { EventEmitter } from "node:events";
 import type { Stream } from "node:stream";
 import debug from "debug";
 import { toURL } from "./common";
-import type { Agent, Dispatcher } from "undici";
-import { Agent as UndiciAgent, interceptors } from "undici";
 
 const log = debug("http-proxy-3");
 
@@ -95,28 +93,30 @@ export interface ServerOptions {
 	 */
 	ca?: string;
 	/** Enable undici for HTTP/2 support. Set to true for defaults, or provide custom configuration. */
-  fetch?: boolean | FetchOptions;
+	fetch?: boolean | FetchOptions;
 }
 
+export type Dispatcher = RequestInit["dispatcher"];
+
 export interface FetchOptions {
-  /** Undici Agent configuration */
-  dispatcher?: Dispatcher;
-  /** Undici request options */
-  requestOptions?: RequestInit;
-  /** Called before making the undici request */
-  onBeforeRequest?: (
-    requestOptions: RequestInit,
-    req: http.IncomingMessage,
-    res: http.ServerResponse,
-    options: NormalizedServerOptions,
-  ) => void | Promise<void>;
-  /** Called after receiving the undici response */
-  onAfterResponse?: (
-    response: Response,
-    req: http.IncomingMessage,
-    res: http.ServerResponse,
-    options: NormalizedServerOptions,
-  ) => void | Promise<void>;
+	/** Undici Agent configuration */
+	dispatcher?: Dispatcher;
+	/** Undici request options */
+	requestOptions?: RequestInit;
+	/** Called before making the undici request */
+	onBeforeRequest?: (
+		requestOptions: RequestInit,
+		req: http.IncomingMessage,
+		res: http.ServerResponse,
+		options: NormalizedServerOptions,
+	) => void | Promise<void>;
+	/** Called after receiving the undici response */
+	onAfterResponse?: (
+		response: Response,
+		req: http.IncomingMessage,
+		res: http.ServerResponse,
+		options: NormalizedServerOptions,
+	) => void | Promise<void>;
 }
 
 
@@ -265,7 +265,7 @@ export class ProxyServer<TIncomingMessage extends typeof http.IncomingMessage =
 		this.webPasses = Object.values(WEB_PASSES) as Array<PassFunctions<TIncomingMessage, TServerResponse, TError>['web']>;
 		this.wsPasses = Object.values(WS_PASSES) as Array<PassFunctions<TIncomingMessage, TServerResponse, TError>['ws']>;
 		this.on("error", this.onError);
-  }
+	}
 
 	/**
 	 * Creates the proxy server with specified options.

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 type { Dispatcher } from "undici";
-import type { ErrorCallback, FetchOptions, NormalizedServerOptions, NormalizeProxyTarget, ProxyServer, ProxyTarget, ProxyTargetUrl, ServerOptions, UndiciOptions } from "..";
+import type { ErrorCallback, FetchOptions, NormalizedServerOptions, NormalizeProxyTarget, ProxyServer, ProxyTarget, ProxyTargetUrl, ServerOptions } from "..";
 import * as common from "../common";
 import { type EditableResponse, OUTGOING_PASSES } from "./web-outgoing";
 import { Readable } from "node:stream";
@@ -236,11 +236,12 @@ async function stream2(
     );
 
     const requestOptions: RequestInit = {
-      origin: new URL(outgoingOptions.url).origin,
-      method: outgoingOptions.method as Dispatcher.HttpMethod,
-      headers: outgoingOptions.headers || {},
-      path: outgoingOptions.path || "/",
-    };
+      method: outgoingOptions.method,
+    }
+
+    if (fetchOptions.dispatcher) {
+      requestOptions.dispatcher = fetchOptions.dispatcher;
+    }
 
     // Handle request body
     if (options.buffer) {
@@ -283,14 +284,15 @@ async function stream2(
   const outgoingOptions = common.setupOutgoing(options.ssl || {}, options, req);
 
   const requestOptions: RequestInit = {
-    origin: new URL(outgoingOptions.url).origin,
     method: outgoingOptions.method as Dispatcher.HttpMethod,
-    headers: outgoingOptions.headers || {},
-    path: outgoingOptions.path || "/",
-    headersTimeout: options.proxyTimeout,
+    headers: outgoingOptions.headers as Record<string, string>,
     ...fetchOptions.requestOptions
   };
 
+  if (fetchOptions.dispatcher) {
+    requestOptions.dispatcher = fetchOptions.dispatcher;
+  }
+
   if (options.auth) {
     requestOptions.headers = { ...requestOptions.headers, authorization: `Basic ${Buffer.from(options.auth).toString("base64")}` };
   }

lib/index.ts

@@ -1,3 +1,4 @@
+import { Agent } from 'undici';
 import {
   type ErrorCallback,
   ProxyServer,
@@ -33,8 +34,8 @@ import type * as http from 'node:http';
 
 function createProxyServer<TIncomingMessage extends typeof http.IncomingMessage = typeof http.IncomingMessage, TServerResponse extends typeof http.ServerResponse = typeof http.ServerResponse, TError = Error>(options: ServerOptions = {}): ProxyServer<TIncomingMessage, TServerResponse, TError> {
   // Check if we're in forced undici mode
-  if (process.env.FORCE_UNDICI_PATH === 'true' && options.undici === undefined) {
-    options = { ...options, undici: { agentOptions: { allowH2: true } } };
+  if (process.env.FORCE_FETCH_PATH === 'true' && options.fetch === undefined) {
+    options = { ...options, fetch: { dispatcher: new Agent({ allowH2: true, connect: { rejectUnauthorized: true } }) as any } };
   }
 
   return new ProxyServer<TIncomingMessage, TServerResponse, TError>(options);

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

@@ -9,11 +9,8 @@ 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";
+import { Agent } from "undici";
 
-setGlobalDispatcher(new Agent({
-    allowH2: true
-}));
 
 describe("Undici callback functions (onBeforeRequest and onAfterResponse)", () => {
     let ports: Record<'target' | 'proxy', number>;
@@ -48,8 +45,10 @@ describe("Undici callback functions (onBeforeRequest and onAfterResponse)", () =
 
         const proxy = httpProxy.createServer({
             target: `http://localhost:${ports.target}`,
-            undici: {
-                agentOptions: { allowH2: true }, // Enable undici code path
+            fetch: {
+                dispatcher: new Agent({
+                    allowH2: true
+                }) as any, // Enable undici code path
                 onBeforeRequest: async (requestOptions, _req, _res, _options) => {
                     onBeforeRequestCalled = true;
                     // Modify the outgoing request
@@ -62,7 +61,7 @@ describe("Undici callback functions (onBeforeRequest and onAfterResponse)", () =
                 onAfterResponse: async (response, _req, _res, _options) => {
                     onAfterResponseCalled = true;
                     capturedResponse = response;
-                    console.log(`Response received: ${response.statusCode}`);
+                    console.log(`Response received: ${response.status}`);
                 }
             }
         }); servers.proxy = proxy.listen(ports.proxy);

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,
-        undici: { agentOptions: { allowH2: true } },
+        fetch: { dispatcher: new Agent({ allowH2: true }) as any },
         // without secure false, clients will fail and this is broken:
         secure: false,
       })

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

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