Run tests with all Node frameworks

.changeset/warm-plums-grin.md

@@ -0,0 +1,17 @@
+---
+'@whatwg-node/node-fetch': patch
+---
+
+Normalize the URL if it has a port and query string without a pathname;
+
+```diff
++ http://example.com:80?query
+- http://example.com:80/?query
+```
+
+Previously, it was normalized like below which was incorrect;
+
+```diff
+- http://example.com:80?query
++ http://example.com/:80?query
+```

packages/node-fetch/src/URL.ts

@@ -26,6 +26,11 @@ export class PonyfillURL extends FastUrl implements URL {
     ) {
       this.hostname = `[${this.hostname}]`;
     }
+    if (url.includes(`${this.hostname}:`) && !this.port && this.pathname.startsWith('/:')) {
+      this.port = this.pathname.slice(2);
+      this.pathname = '/';
+      this.host = `${this.hostname}:${this.port}`;
+    }
     if (base) {
       const baseParsed = typeof base === 'string' ? new PonyfillURL(base) : base;
       this.protocol ||= baseParsed.protocol;
@@ -36,7 +41,7 @@ export class PonyfillURL extends FastUrl implements URL {
   }
 
   get origin(): string {
-    return `${this.protocol}//${this.host}${this.port ? `:${this.port}` : ''}`;
+    return `${this.protocol}//${this.hostname}${this.port ? `:${this.port}` : ''}`;
   }
 
   private _searchParams?: PonyfillURLSearchParams;

packages/node-fetch/tests/URL.spec.ts

@@ -1,6 +1,36 @@
 import { PonyfillURL } from '../src/URL.js';
 
 describe('URL', () => {
+  const urlExamples = [
+    'https://example.com/?foo=bar&bar=qux',
+    'http://[::1]:8080',
+    'http://localhost:8080?foo=bar',
+  ];
+  for (const urlExample of urlExamples) {
+    describe(urlExample, () => {
+      it('should parse and stringify URLs', () => {
+        const url = new PonyfillURL(urlExample);
+        expect(url.toString()).toBe(urlExample.replace('8080', '8080/'));
+      });
+      it('should parse the URLs as expected', () => {
+        const ponyfillUrl = new PonyfillURL(urlExample);
+        const nativeUrl = new URL(urlExample);
+        expect(ponyfillUrl.toString() || null).toBe(nativeUrl.toString() || null);
+        expect(ponyfillUrl.protocol || null).toBe(nativeUrl.protocol || null);
+        expect(ponyfillUrl.host || null).toBe(nativeUrl.host || null);
+        expect(ponyfillUrl.hostname || null).toBe(nativeUrl.hostname || null);
+        expect(ponyfillUrl.port || null).toBe(nativeUrl.port || null);
+        expect(ponyfillUrl.pathname || null).toBe(nativeUrl.pathname || null);
+        expect(ponyfillUrl.search || null).toBe(nativeUrl.search || null);
+        ponyfillUrl.searchParams.forEach((value, key) => {
+          expect(nativeUrl.searchParams.get(key) || null).toBe(value || null);
+        });
+        expect(ponyfillUrl.username || null).toBe(nativeUrl.username || null);
+        expect(ponyfillUrl.password || null).toBe(nativeUrl.password || null);
+        expect(ponyfillUrl.origin || null).toBe(nativeUrl.origin || null);
+      });
+    });
+  }
   it('should parse search params', () => {
     const url = new PonyfillURL('https://example.com/?foo=bar&foo=baz&bar=qux');
     expect(url.searchParams.get('foo')).toBe('bar');
@@ -22,4 +52,12 @@ describe('URL', () => {
     expect(url.hostname).toBe('[::1]');
     expect(url.port).toBe('8000');
   });
+  it('parses query strings with ports without pathname', () => {
+    const url = new PonyfillURL('http://localhost:8080?foo=bar');
+    expect(url.host).toBe('localhost:8080');
+    expect(url.hostname).toBe('localhost');
+    expect(url.pathname).toBe('/');
+    expect(url.port).toBe('8080');
+    expect(url.search).toBe('?foo=bar');
+  });
 });

packages/server/README.md

@@ -167,10 +167,15 @@ app.route({
   url: '/mypath',
   method: ['GET', 'POST', 'OPTIONS'],
   handler: async (req, reply) => {
-    const response = await myServerAdapter.handleNodeRequestAndResponse(req, reply, {
+    const response: Response = await myServerAdapter.handleNodeRequestAndResponse(req, reply, {
       req,
       reply
     })
+
+    if (!response) {
+      return reply.status(404).send('Not Found')
+    }
+
     response.headers.forEach((value, key) => {
       reply.header(key, value)
     })
@@ -200,7 +205,7 @@ import myServerAdapter from './myServerAdapter'
 const app = new Koa()
 
 app.use(async ctx => {
-  const response = await myServerAdapter.handleNodeRequest(ctx.req)
+  const response = await myServerAdapter.handleNodeRequestAndResponse(ctx.request, ctx.res, ctx)
 
   // Set status code
   ctx.status = response.status

packages/server/package.json

@@ -39,10 +39,13 @@
     "tslib": "^2.6.3"
   },
   "devDependencies": {
+    "@hapi/hapi": "^21.3.12",
     "@types/express": "5.0.0",
+    "@types/koa": "^2.15.0",
     "@types/node": "22.10.2",
     "express": "4.21.2",
     "fastify": "5.2.0",
+    "koa": "^2.15.3",
     "react": "19.0.0",
     "react-dom": "19.0.0"
   },