fix: preserve double slashes in url

src/_utils.ts

@@ -1,3 +1,5 @@
+import { ProxyServerOptions } from "./types";
+
 const upgradeHeader = /(^|,)\s*upgrade\s*($|,)/i;
 
 /**
@@ -100,7 +102,7 @@ export function setupOutgoing(outgoing, options, req, forward?) {
   //
   outgoingPath = options.ignorePath ? "" : outgoingPath;
 
-  outgoing.path = urlJoin(targetPath, outgoingPath);
+  outgoing.path = urlJoin(options, targetPath, outgoingPath);
 
   if (options.changeOrigin) {
     outgoing.headers.host =
@@ -176,7 +178,7 @@ export function hasEncryptedConnection(req) {
  * @api private
  */
 
-export function urlJoin(...args: string[]) {
+export function urlJoin(options: ProxyServerOptions, ...args: string[]) {
   // We do not want to mess with the query string. All we want to touch is the path.
   const lastIndex = args.length - 1;
   const last = args[lastIndex];
@@ -188,13 +190,15 @@ export function urlJoin(...args: string[]) {
   // Join all strings, but remove empty strings so we don't get extra slashes from
   // joining e.g. ['', 'am']
   //
+  let retStr = args.filter(Boolean).join("/");
+
+  // Avoid normalize url if option is set
+  if (options.normalizeUrl) {
+    retStr = retStr.replace(/\/+/g, "/");
+  }
+
   const retSegs = [
-    args
-      .filter(Boolean)
-      .join("/")
-      .replace(/\/+/g, "/")
-      .replace("http:/", "http://")
-      .replace("https:/", "https://"),
+    retStr.replace("http:/", "http://").replace("https:/", "https://"),
   ];
 
   // Only join the query string if it exists so we don't have trailing a '?'

src/server.ts

@@ -39,6 +39,7 @@ export class ProxyServer extends EventEmitter {
 
     this.options = options || {};
     this.options.prependPath = options.prependPath !== false;
+    this.options.normalizeUrl = options.normalizeUrl !== false;
 
     this.web = _createProxyFn("web", this);
     this.ws = _createProxyFn("ws", this);

src/types.ts

@@ -68,4 +68,6 @@ export interface ProxyServerOptions {
   selfHandleResponse?: boolean;
   /** Buffer */
   buffer?: stream.Stream;
+  /** If set to true, the path will be normalized by removing double slashes. Default: true */
+  normalizeUrl?: boolean;
 }

test/index.test.ts

@@ -1,7 +1,7 @@
-import { expect, it, describe, beforeAll } from "vitest";
+import { expect, it, describe } from "vitest";
 import { listen, Listener } from "listhen";
 import { $fetch } from "ofetch";
-import { createProxyServer, ProxyServer } from "../src";
+import { createProxyServer, ProxyServer, ProxyServerOptions } from "../src";
 
 describe("httpxy", () => {
   let mainListener: Listener;
@@ -11,7 +11,12 @@ describe("httpxy", () => {
   let lastResolved: any;
   let lastRejected: any;
 
-  beforeAll(async () => {
+  const maskResponse = (obj: any) => ({
+    ...obj,
+    headers: { ...obj.headers, connection: "<>", host: "<>" },
+  });
+
+  const makeProxy = async (options: ProxyServerOptions) => {
     mainListener = await listen((req, res) => {
       res.end(
         JSON.stringify({
@@ -22,7 +27,7 @@ describe("httpxy", () => {
       );
     });
 
-    proxy = createProxyServer({});
+    proxy = createProxyServer(options);
 
     proxyListener = await listen(async (req, res) => {
       lastResolved = false;
@@ -36,17 +41,13 @@ describe("httpxy", () => {
         res.end("Proxy error: " + error.toString());
       }
     });
-  });
+  };
 
   it("works", async () => {
+    await makeProxy({});
     const mainResponse = await $fetch(mainListener.url + "base/test?foo");
     const proxyResponse = await $fetch(proxyListener.url + "test?foo");
 
-    const maskResponse = (obj: any) => ({
-      ...obj,
-      headers: { ...obj.headers, connection: "<>", host: "<>" },
-    });
-
     expect(maskResponse(await mainResponse)).toMatchObject(
       maskResponse(proxyResponse),
     );
@@ -56,4 +57,19 @@ describe("httpxy", () => {
     expect(lastResolved).toBe(true);
     expect(lastRejected).toBe(undefined);
   });
+
+  it("should avoid normalize url", async () => {
+    await makeProxy({ normalizeUrl: false });
+    const mainResponse = await $fetch(mainListener.url + "base//test?foo");
+    const proxyResponse = await $fetch(proxyListener.url + "test?foo");
+
+    expect(maskResponse(await mainResponse)).toMatchObject(
+      maskResponse(proxyResponse),
+    );
+
+    expect(proxyResponse.path).toBe("/base//test?foo");
+
+    expect(lastResolved).toBe(true);
+    expect(lastRejected).toBe(undefined);
+  });
 });