fix(logger-plugin): support ipv6 host and handle undefined protocol/host

Author: chimurai

CHANGELOG.md

@@ -18,6 +18,7 @@
 - feat(hono): support for hono with createHonoProxyMiddleware
 - feat(ipv6): support literal IPv6 addresses in `target` and `forward` options (ie. "http://[::1]:8000")
 - chore(package.json): bump httpxy to ^0.5.1
+- fix(logger-plugin): support ipv6 host and handle undefined protocol/host
 
 ## [v3.0.5](https://github.com/chimurai/http-proxy-middleware/releases/tag/v3.0.5)
 

src/plugins/default/logger-plugin.ts

@@ -1,8 +1,9 @@
-import type { IncomingMessage } from 'node:http';
+import type { ClientRequest, IncomingMessage } from 'node:http';
 import { URL } from 'node:url';
 
 import { getLogger } from '../../logger.js';
 import type { Plugin } from '../../types.js';
+import { createUrl } from '../../utils/create-url.js';
 import { getPort } from '../../utils/logger-plugin.js';
 
 type ExpressRequest = {
@@ -49,21 +50,12 @@ export const loggerPlugin: Plugin = (proxyServer, options) => {
 
     try {
       const port = getPort(proxyRes.req?.agent?.sockets);
+      const { protocol, host, path } = proxyRes.req as ClientRequest;
 
-      const obj = {
-        protocol: proxyRes.req.protocol,
-        host: proxyRes.req.host,
-        pathname: proxyRes.req.path,
-      } as URL;
-
-      target = new URL(`${obj.protocol}//${obj.host}${obj.pathname}`);
-
-      if (port) {
-        target.port = port;
-      }
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      target = createUrl({ protocol, host, port, path });
     } catch (err) {
-      // nock issue (https://github.com/chimurai/http-proxy-middleware/issues/1035)
+      // should not error. keeping fallback just in case
+      console.error('[HPM] Unexpected error while creating target URL', err);
       // fallback to old implementation (less correct - without port)
       target = new URL(options.target as URL);
       target.pathname = proxyRes.req.path;

src/utils/create-url.ts

@@ -0,0 +1,28 @@
+import { URL } from 'url';
+
+type CreateUrlParams = {
+  protocol?: string;
+  host?: string;
+  port?: string;
+  path?: string;
+};
+
+export function createUrl({ protocol, host, port, path }: CreateUrlParams): URL {
+  // wrap IPv6 host in brackets
+  const ipv6Host = host?.includes(':') ? `[${host}]` : host;
+
+  // use fallback values to create a valid URL (protocol: 'undefined:', host: '[::]')
+  // nock v13 issue: protocol and host are undefined (https://github.com/chimurai/http-proxy-middleware/issues/1035)
+  // nock v14+ seems to return protocol and host correctly
+  const base = `${protocol || 'undefined:'}//${ipv6Host || '[::]'}`;
+  const url = new URL(base);
+
+  if (port) {
+    url.port = port;
+  }
+
+  if (path) {
+    url.pathname = path;
+  }
+  return url;
+}

test/unit/utils/create-url.spec.ts

@@ -0,0 +1,126 @@
+import { describe, expect, it } from 'vitest';
+
+import { createUrl } from '../../../src/utils/create-url.js';
+
+describe('createUrl()', () => {
+  describe('happy paths', () => {
+    it('should create a basic HTTP URL', () => {
+      const url = createUrl({ protocol: 'http:', host: 'example.com', path: '/api' });
+      expect(url.href).toBe('http://example.com/api');
+    });
+
+    it('should create an HTTPS URL', () => {
+      const url = createUrl({ protocol: 'https:', host: 'example.com', path: '/secure' });
+      expect(url.href).toBe('https://example.com/secure');
+    });
+
+    it('should include port when provided', () => {
+      const url = createUrl({ protocol: 'http:', host: 'example.com', port: '3000', path: '/api' });
+      expect(url.href).toBe('http://example.com:3000/api');
+    });
+
+    it('should default pathname to / when path is omitted', () => {
+      const url = createUrl({ protocol: 'http:', host: 'example.com' });
+      expect(url.href).toBe('http://example.com/');
+    });
+
+    it('should handle an IPv4 host', () => {
+      const url = createUrl({
+        protocol: 'http:',
+        host: '127.0.0.1',
+        port: '8080',
+        path: '/health',
+      });
+      expect(url.href).toBe('http://127.0.0.1:8080/health');
+    });
+
+    it('should wrap an IPv6 localhost address in brackets', () => {
+      const url = createUrl({ protocol: 'http:', host: '::1', port: '8080', path: '/' });
+      expect(url.href).toBe('http://[::1]:8080/');
+    });
+
+    it('should wrap the IPv6 unspecified address in brackets', () => {
+      const url = createUrl({ protocol: 'http:', host: '::', path: '/status' });
+      expect(url.href).toBe('http://[::]/status');
+    });
+
+    it('should double-bracket an already-bracketed IPv6 host (pass-through behavior)', () => {
+      // '[::1]' contains ':' so the function wraps it again → '[[::1]]', which is an invalid URL
+      expect(() => createUrl({ protocol: 'http:', host: '[::1]', port: '9000' })).toThrow();
+    });
+
+    it('should handle a root path explicitly', () => {
+      const url = createUrl({ protocol: 'http:', host: 'localhost', path: '/' });
+      expect(url.href).toBe('http://localhost/');
+    });
+
+    it('should handle a deep nested path', () => {
+      const url = createUrl({ protocol: 'http:', host: 'api.example.com', path: '/v1/users/42' });
+      expect(url.href).toBe('http://api.example.com/v1/users/42');
+    });
+  });
+
+  describe('edge cases — missing / undefined inputs', () => {
+    it('should fall back gracefully when protocol is undefined', () => {
+      const url = createUrl({ host: 'example.com', path: '/api' });
+      expect(url.href).toBe('undefined://example.com/api');
+    });
+
+    it('should fall back gracefully when host is undefined', () => {
+      const url = createUrl({ protocol: 'http:', path: '/api' });
+      expect(url.href).toBe('http://[::]/api');
+    });
+
+    it('should fall back gracefully when both protocol and host are undefined (nock v13 scenario)', () => {
+      const url = createUrl({ path: '/api' });
+      expect(url.href).toBe('undefined://[::]/api');
+    });
+
+    it('should not set port when port is omitted', () => {
+      const url = createUrl({ protocol: 'http:', host: 'example.com', path: '/no-port' });
+      expect(url.href).toBe('http://example.com/no-port');
+    });
+
+    it('should not set pathname when path is omitted', () => {
+      const url = createUrl({ protocol: 'http:', host: 'example.com' });
+      expect(url.href).toBe('http://example.com/');
+    });
+  });
+
+  describe('edge cases — empty string inputs', () => {
+    it('should use fallback protocol when protocol is an empty string', () => {
+      // empty string is falsy: fallback 'undefined:' is used
+      const url = createUrl({ protocol: '', host: 'example.com', path: '/api' });
+      expect(url.href).toBe('undefined://example.com/api');
+    });
+
+    it('should use fallback host when host is an empty string', () => {
+      // empty string host → ipv6Host is '' (falsy) → fallback '[::]' used
+      const url = createUrl({ protocol: 'http:', host: '', path: '/api' });
+      expect(url.href).toBe('http://[::]/api');
+    });
+
+    it('should not set pathname when path is an empty string', () => {
+      // empty string is falsy, so the `if (path)` branch is skipped
+      const url = createUrl({ protocol: 'http:', host: 'example.com', path: '' });
+      expect(url.href).toBe('http://example.com/');
+    });
+
+    it('should not set port when port is an empty string', () => {
+      const url = createUrl({ protocol: 'http:', host: 'example.com', port: '', path: '/api' });
+      expect(url.href).toBe('http://example.com/api');
+    });
+  });
+
+  describe('edge cases — numeric port (runtime flexibility)', () => {
+    it('should accept a numeric port value at runtime', () => {
+      // type is string but runtime numeric values can occur; `url.port` coerces via assignment
+      const url = createUrl({
+        protocol: 'http:',
+        host: 'example.com',
+        port: 8080 as unknown as string,
+      });
+      expect(url.href).toBe('http://example.com:8080/');
+    });
+  });
+});