@fastify/reply-from 12.6.1 → 12.6.3

package/.github/dependabot.yml

@@ -2,12 +2,52 @@ version: 2
 updates:
   - package-ecosystem: "github-actions"
     directory: "/"
+    commit-message:
+      # Prefix all commit messages with "chore: "
+      prefix: "chore"
     schedule:
-      interval: "monthly"
+      interval: "weekly"
+    cooldown:
+      default-days: 7
+    allow:
+      - dependency-name: "*"
+        update-types:
+          - "version-update:semver-major"
     open-pull-requests-limit: 10
 
   - package-ecosystem: "npm"
     directory: "/"
+    commit-message:
+      # Prefix all commit messages with "chore: "
+      prefix: "chore"
     schedule:
-      interval: "monthly"
+      interval: "weekly"
+    cooldown:
+      default-days: 7
+    versioning-strategy: "increase-if-necessary"
+    allow:
+      - dependency-name: "*"
+        update-types:
+          - "version-update:semver-major"
+    ignore:
+      # TODO: remove ignore until neostandard support ESLint 10
+      - dependency-name: "eslint"
+      - dependency-name: "neostandard"
+      - dependency-name: "@stylistic/*"
     open-pull-requests-limit: 10
+    groups:
+      # Production dependencies with breaking changes
+      dependencies:
+        dependency-type: "production"
+      # ESLint related dependencies
+      dev-dependencies-eslint:
+        patterns:
+          - "eslint"
+          - "neostandard"
+          - "@stylistic/*"
+      # TypeScript related dependencies
+      dev-dependencies-typescript:
+        patterns:
+          - "@types/*"
+          - "tstyche"
+          - "typescript"

package/.github/workflows/ci.yml

@@ -27,7 +27,7 @@ jobs:
     permissions:
       contents: write
       pull-requests: write
-    uses: fastify/workflows/.github/workflows/plugins-ci.yml@v5
+    uses: fastify/workflows/.github/workflows/plugins-ci.yml@v6
     with:
       license-check: true
       lint: true

package/.github/workflows/lock-threads.yml

@@ -0,0 +1,19 @@
+name: Lock Threads
+
+on:
+  schedule:
+    - cron: '0 0 1 * *'
+  workflow_dispatch:
+
+concurrency:
+  group: lock
+
+permissions:
+  contents: read
+
+jobs:
+  lock-threads:
+    permissions:
+      issues: write
+      pull-requests: write
+    uses: fastify/workflows/.github/workflows/lock-threads.yml@v6

package/README.md

@@ -70,7 +70,7 @@ Set the base URL for all the forwarded requests.
 *String or String[]*:
 
 * **Single string** → a normal `undici.Pool` / `http.request` client is used.
-* **Array with ≥ 2 elements** → **[`undici.BalancedPool`](https://undici.nodejs.org/#/docs/api/BalancedPool)** is automatically selected and requests are load-balanced round-robin across the given origins.
+* **Array with ≥ 2 elements** → **[`undici.BalancedPool`](https://undici.nodejs.org/api/BalancedPool)** is automatically selected and requests are load-balanced round-robin across the given origins.
 
 When you provide an array, only the *origin* (`protocol://host:port`) part of each URL is considered; any path component is ignored.
 
@@ -354,7 +354,7 @@ const customRetryLogic = ({req, res, err, getDefaultRetry}: RetryDetails) => {
 ### `reply.from(source, [opts])`
 
 The plugin decorates the
-[`Reply`](https://fastify.dev/docs/latest/Reference/Reply)
+[`Reply`](https://fastify.dev/docs/latest/Reference/Reply/)
 instance with a `from` method, which will reply to the original request
 __from the desired source__. The options allows overrides of any part of
 the request or response being sent or received to/from the source.
@@ -512,7 +512,7 @@ This library has:
   - The default value for `requestTimeout` is 10 seconds (`10000`), a value of 0 disables the timeout.
   - The default value for `sessionTimeout` is 60 seconds (`60000`), a value of 0 disables the timeout.
 
-When a timeout happens, [`504 Gateway Timeout`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/504)
+When a timeout happens, [`504 Gateway Timeout`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status/504)
 will be returned to the client.
 
 ## Compatibility with @fastify/multipart

package/index.js

@@ -11,6 +11,7 @@ const {
   filterPseudoHeaders,
   copyHeaders,
   stripHttp1ConnectionHeaders,
+  getConnectionHeaders,
   buildURL
 } = require('./lib/utils')
 
@@ -89,6 +90,18 @@ const fastifyReplyFrom = fp(function from (fastify, opts, next) {
 
     const sourceHttp2 = req.httpVersionMajor === 2
     const headers = sourceHttp2 ? filterPseudoHeaders(req.headers) : { ...req.headers }
+
+    // Strip client-supplied Connection header and all header names listed in it
+    // before rewriteRequestHeaders runs. This prevents clients from stripping
+    // headers added by the proxy itself.
+    const connectionHeaderNames = getConnectionHeaders(headers)
+    if (headers.connection || connectionHeaderNames.length > 0) {
+      delete headers.connection
+      for (let i = 0; i < connectionHeaderNames.length; i++) {
+        delete headers[connectionHeaderNames[i]]
+      }
+    }
+
     headers.host = url.host
     const qs = getQueryString(url.search, req.url, opts, this.request)
     let body = ''
@@ -133,7 +146,7 @@ const fastifyReplyFrom = fp(function from (fastify, opts, next) {
       }
     }
 
-    // according to https://tools.ietf.org/html/rfc2616#section-4.3
+    // according to https://datatracker.ietf.org/doc/html/rfc2616#section-4.3
     // fastify ignore message body when it's a GET or HEAD request
     // when proxy this request, we should reset the content-length to make it a valid http request
     // discussion: https://github.com/fastify/fastify/issues/953
@@ -205,6 +218,11 @@ const fastifyReplyFrom = fp(function from (fastify, opts, next) {
         )
       } else {
         copyHeaders(rewriteHeaders(res.headers, this.request), this)
+        // An HTTP/1 connection cannot be reused until its request body has
+        // been consumed. Close it if the upstream responds before that point.
+        if (!req.complete) {
+          this.header('connection', 'close')
+        }
       }
       try {
         this.code(res.statusCode)

package/lib/utils.js

@@ -92,7 +92,12 @@ function stripHttp1ConnectionHeaders (headers) {
 
 // issue ref: https://github.com/fastify/fast-proxy/issues/42
 function buildURL (source, reqBase) {
-  if (decodeURIComponent(source).includes('..')) {
+  // Check for path traversal: '..' must be a complete path segment to be an
+  // attack. A bare substring match incorrectly rejects legitimate URLs that
+  // contain '...' (e.g. Next.js catch-all routes like '[...slug]').
+  // See: https://github.com/fastify/fastify-reply-from/issues/460
+  const decoded = decodeURIComponent(source)
+  if (decoded === '..' || decoded.includes('/..') || decoded.includes('../')) {
     const err = new Error('source/request contain invalid characters')
     err.statusCode = 400
     throw err

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastify/reply-from",
-  "version": "12.6.1",
+  "version": "12.6.3",
   "description": "forward your HTTP request to another server, for fastify",
   "main": "index.js",
   "type": "commonjs",
@@ -10,7 +10,7 @@
     "lint:fix": "eslint --fix",
     "test": "npm run test:unit && npm run test:typescript",
     "test:unit": "c8 node --test --test-timeout=30000",
-    "test:typescript": "tsd"
+    "test:typescript": "tstyche"
   },
   "repository": {
     "type": "git",
@@ -59,28 +59,27 @@
   ],
   "devDependencies": {
     "@fastify/formbody": "^8.0.0",
-    "@fastify/multipart": "^9.0.0",
+    "@fastify/multipart": "^10.0.0",
     "@sinonjs/fake-timers": "^15.0.0",
-    "@types/node": "^25.0.3",
-    "@types/tap": "^18.0.0",
+    "@types/node": "^26.0.0",
     "c8": "^11.0.0",
     "eslint": "^9.17.0",
     "fastify": "^5.0.0",
     "form-data": "^4.0.0",
     "h2url": "^0.2.0",
-    "neostandard": "^0.12.0",
+    "neostandard": "^0.13.0",
     "nock": "^14.0.0",
-    "proxy": "^2.1.1",
+    "proxy": "^4.0.0",
     "proxyquire": "^2.1.3",
     "split2": "^4.2.0",
-    "tsd": "^0.33.0"
+    "tstyche": "^7.0.0"
   },
   "dependencies": {
     "@fastify/error": "^4.0.0",
     "end-of-stream": "^1.4.4",
     "fast-content-type-parse": "^3.0.0",
     "fast-querystring": "^1.1.2",
-    "fastify-plugin": "^5.0.1",
+    "fastify-plugin": "^6.0.0",
     "toad-cache": "^3.7.0",
     "undici": "^7.0.0"
   },

package/test/build-url.test.js

@@ -77,6 +77,15 @@ test('should throw when trying to override base', async (t) => {
   await Promise.all(promises)
 })
 
+test('should not throw on URLs containing "..." (e.g. Next.js catch-all routes)', (t) => {
+  t.plan(2)
+  // Next.js catch-all routes like [...slug] appear percent-encoded in static chunk URLs.
+  // These contain '...' as a substring but are not path traversal.
+  // See: https://github.com/fastify/fastify-reply-from/issues/460
+  t.assert.doesNotThrow(() => buildURL('/_next/static/chunks/pages/%5B...slug%5D.js', 'http://localhost'))
+  t.assert.doesNotThrow(() => buildURL('/_next/static/chunks/pages/%5B%5B...slug%5D%5D.js', 'http://localhost'))
+})
+
 test('should throw on path traversal attempts', (t) => {
   t.assert.throws(
     () => buildURL('/foo/bar/../', 'http://localhost'),

package/test/incomplete-request.test.js

@@ -0,0 +1,142 @@
+'use strict'
+
+const { once } = require('node:events')
+const http = require('node:http')
+const net = require('node:net')
+const t = require('node:test')
+const Fastify = require('fastify')
+const From = require('..')
+
+for (const [name, options] of [
+  ['undici', {}],
+  ['node:http', { undici: false }]
+]) {
+  t.test(`closes the downstream connection when ${name} responds before the request is complete`, async (t) => {
+    const target = http.createServer((_req, res) => {
+      res.end('early')
+    })
+    const instance = Fastify()
+
+    t.after(async () => {
+      instance.server.closeAllConnections()
+      target.closeAllConnections()
+      await instance.close()
+      if (target.listening) await new Promise(resolve => target.close(resolve))
+    })
+
+    await new Promise(resolve => target.listen({ port: 0 }, resolve))
+
+    instance.register(From, options)
+    instance.addContentTypeParser('application/octet-stream', function (_request, payload, done) {
+      done(null, payload)
+    })
+    instance.post('/', (_request, reply) => {
+      reply.from(`http://localhost:${target.address().port}`)
+    })
+    await instance.listen({ port: 0 })
+
+    const socket = net.connect(instance.server.address().port, '127.0.0.1')
+    t.after(() => socket.destroy())
+    await once(socket, 'connect')
+
+    const responsePromise = new Promise((resolve, reject) => {
+      let response = ''
+      const timeout = setTimeout(() => {
+        reject(new Error('downstream connection was not closed'))
+      }, 5000)
+
+      socket.on('data', chunk => {
+        response += chunk.toString('latin1')
+      })
+      socket.once('error', err => {
+        clearTimeout(timeout)
+        reject(err)
+      })
+      socket.once('close', () => {
+        clearTimeout(timeout)
+        resolve(response)
+      })
+    })
+
+    socket.write([
+      'POST / HTTP/1.1',
+      'Host: localhost',
+      'Content-Type: application/octet-stream',
+      'Content-Length: 1048576',
+      'Connection: keep-alive',
+      '',
+      'a'
+    ].join('\r\n'))
+
+    const response = await responsePromise
+    t.assert.match(response, /^HTTP\/1\.1 200 OK\r\n/)
+    t.assert.match(response, /\r\nconnection: close\r\n/i)
+    t.assert.match(response, /\r\n\r\nearly$/)
+  })
+
+  t.test(`keeps the downstream connection reusable after ${name} consumes the request`, async (t) => {
+    const target = http.createServer((req, res) => {
+      req.resume()
+      req.on('end', () => res.end('complete'))
+    })
+    const agent = new http.Agent({ keepAlive: true, maxSockets: 1 })
+    const instance = Fastify()
+
+    t.after(async () => {
+      agent.destroy()
+      instance.server.closeAllConnections()
+      target.closeAllConnections()
+      await instance.close()
+      if (target.listening) await new Promise(resolve => target.close(resolve))
+    })
+
+    await new Promise(resolve => target.listen({ port: 0 }, resolve))
+
+    instance.register(From, options)
+    instance.addContentTypeParser('application/octet-stream', function (_request, payload, done) {
+      done(null, payload)
+    })
+    instance.post('/', (_request, reply) => {
+      reply.from(`http://localhost:${target.address().port}`)
+    })
+    await instance.listen({ port: 0 })
+
+    const first = await makeRequest(instance.server.address().port, agent, 'first')
+    t.assert.notStrictEqual(first.headers.connection, 'close')
+
+    const second = await makeRequest(instance.server.address().port, agent, 'second')
+    t.assert.strictEqual(second.reusedSocket, true)
+    t.assert.strictEqual(second.body, 'complete')
+  })
+}
+
+function makeRequest (port, agent, body) {
+  return new Promise((resolve, reject) => {
+    const req = http.request({
+      agent,
+      method: 'POST',
+      hostname: '127.0.0.1',
+      port,
+      path: '/',
+      headers: {
+        'content-length': Buffer.byteLength(body),
+        'content-type': 'application/octet-stream'
+      }
+    }, res => {
+      let responseBody = ''
+      res.setEncoding('utf8')
+      res.on('data', chunk => {
+        responseBody += chunk
+      })
+      res.on('end', () => {
+        resolve({
+          body: responseBody,
+          headers: res.headers,
+          reusedSocket: req.reusedSocket
+        })
+      })
+    })
+    req.on('error', reject)
+    req.end(body)
+  })
+}

package/test/strip-connection-headers.test.js

@@ -230,3 +230,79 @@ t.test('handles Connection header with keep-alive and custom headers (undici)',
   t.assert.strictEqual(result.statusCode, 200)
   t.assert.strictEqual(result.body, 'ok')
 })
+
+t.test('does not strip headers added by rewriteRequestHeaders (undici)', async (t) => {
+  t.plan(4)
+  const instance = Fastify()
+  instance.register(From)
+
+  t.after(() => instance.close())
+
+  let seenForwardedBy
+  const target = http.createServer((req, res) => {
+    seenForwardedBy = req.headers['x-forwarded-by']
+    t.assert.ok('request proxied')
+    res.statusCode = 200
+    res.setHeader('Content-Type', 'text/plain')
+    res.end('ok')
+  })
+
+  instance.get('/', (_request, reply) => {
+    reply.from(`http://localhost:${target.address().port}`, {
+      rewriteRequestHeaders: (_request, headers) => {
+        return { ...headers, 'x-forwarded-by': 'fastify-proxy' }
+      }
+    })
+  })
+
+  t.after(() => target.close())
+
+  await new Promise((resolve) => instance.listen({ port: 0 }, resolve))
+  await new Promise((resolve) => target.listen({ port: 0 }, resolve))
+
+  const result = await makeRequest(instance.server.address().port, {
+    Connection: 'X-Forwarded-By'
+  })
+
+  t.assert.strictEqual(result.statusCode, 200)
+  t.assert.strictEqual(result.body, 'ok')
+  t.assert.strictEqual(seenForwardedBy, 'fastify-proxy', 'X-Forwarded-By should not be stripped')
+})
+
+t.test('does not strip headers added by rewriteRequestHeaders (http)', async (t) => {
+  t.plan(4)
+  const instance = Fastify()
+  instance.register(From, { undici: false })
+
+  t.after(() => instance.close())
+
+  let seenForwardedBy
+  const target = http.createServer((req, res) => {
+    seenForwardedBy = req.headers['x-forwarded-by']
+    t.assert.ok('request proxied')
+    res.statusCode = 200
+    res.setHeader('Content-Type', 'text/plain')
+    res.end('ok')
+  })
+
+  instance.get('/', (_request, reply) => {
+    reply.from(`http://localhost:${target.address().port}`, {
+      rewriteRequestHeaders: (_request, headers) => {
+        return { ...headers, 'x-forwarded-by': 'fastify-proxy' }
+      }
+    })
+  })
+
+  t.after(() => target.close())
+
+  await new Promise((resolve) => instance.listen({ port: 0 }, resolve))
+  await new Promise((resolve) => target.listen({ port: 0 }, resolve))
+
+  const result = await makeRequest(instance.server.address().port, {
+    Connection: 'X-Forwarded-By'
+  })
+
+  t.assert.strictEqual(result.statusCode, 200)
+  t.assert.strictEqual(result.body, 'ok')
+  t.assert.strictEqual(seenForwardedBy, 'fastify-proxy', 'X-Forwarded-By should not be stripped')
+})

package/types/index.tst.ts

@@ -0,0 +1,123 @@
+import { expect } from 'tstyche'
+import fastify, {
+  type FastifyReply,
+  type FastifyRequest,
+  type RawServerBase,
+  type RequestGenericInterface,
+  type RouteGenericInterface
+} from 'fastify'
+import * as http from 'node:http'
+import { type IncomingHttpHeaders } from 'node:http2'
+import * as https from 'node:https'
+import { Agent, Client, Dispatcher, Pool } from 'undici'
+import replyFrom, {
+  type FastifyReplyFromOptions,
+  type RawServerResponse
+} from '.'
+
+const fullOptions: FastifyReplyFromOptions = {
+  base: 'http://example2.com',
+  http: {
+    agentOptions: {
+      keepAliveMsecs: 60 * 1000,
+      maxFreeSockets: 2048,
+      maxSockets: 2048
+    },
+    requestOptions: { timeout: 1000 },
+    agents: {
+      'http:': new http.Agent({}),
+      'https:': new https.Agent({})
+    }
+  },
+  http2: {
+    sessionTimeout: 1000,
+    requestTimeout: 1000,
+    sessionOptions: { rejectUnauthorized: true },
+    requestOptions: { endStream: true }
+  },
+  cacheURLs: 100,
+  disableCache: false,
+  undici: {
+    connections: 100,
+    pipelining: 10,
+    proxy: 'http://example2.com:8080'
+  },
+  contentTypesToEncode: ['application/x-www-form-urlencoded'],
+  retryMethods: ['GET', 'HEAD', 'OPTIONS', 'TRACE'],
+  maxRetriesOn503: 10,
+  disableRequestLogging: false,
+  globalAgent: false,
+  destroyAgent: true
+}
+
+const app = fastify()
+
+app.register(replyFrom)
+app.register(replyFrom, {})
+app.register(replyFrom, { http2: true })
+app.register(replyFrom, fullOptions)
+app.register(replyFrom, { undici: { proxy: new URL('http://example2.com:8080') } })
+app.register(replyFrom, { undici: { proxy: { uri: 'http://example2.com:8080' } } })
+
+app.register(replyFrom, { base: 'http://example.com', undici: new Agent() })
+app.register(replyFrom, { base: 'http://example.com', undici: new Pool('http://example.com') })
+app.register(replyFrom, { base: 'http://example.com', undici: new Client('http://example.com') })
+app.register(replyFrom, { base: 'http://example.com', undici: new Dispatcher() })
+
+app.get('/v1', (_request, reply) => {
+  expect(reply.from()).type.toBe<FastifyReply>()
+})
+
+app.get('/v3', (_request, reply) => {
+  reply.from('/v3', {
+    timeout: 1000,
+    body: { hello: 'world' },
+    rewriteRequestHeaders (req, headers) {
+      expect(req).type.toBe<FastifyRequest<RequestGenericInterface, RawServerBase>>()
+      return headers
+    },
+    getUpstream (req, base) {
+      expect(req).type.toBe<FastifyRequest<RequestGenericInterface, RawServerBase>>()
+      return base
+    },
+    onResponse (request, reply, res) {
+      expect(request).type.toBe<FastifyRequest<RequestGenericInterface, RawServerBase>>()
+      expect(reply).type.toBe<FastifyReply<RouteGenericInterface, RawServerBase>>()
+      expect(res).type.toBe<RawServerResponse<RawServerBase>>()
+      expect(res.statusCode).type.toBe<number>()
+    }
+  })
+})
+
+app.get('/http2', (_request, reply) => {
+  reply.from('/', {
+    method: 'POST',
+    retryDelay: ({ req, res, err, attempt, getDefaultDelay }) => {
+      const defaultDelay = getDefaultDelay(req, res, err, attempt)
+      expect(defaultDelay).type.toBe<number | null>()
+
+      if (res && res.statusCode === 500 && req.method === 'GET') {
+        return 300
+      }
+      return null
+    },
+    rewriteHeaders (headers) {
+      return headers
+    },
+    rewriteRequestHeaders (_req, headers: IncomingHttpHeaders) {
+      return headers
+    },
+    onError (reply: FastifyReply<RouteGenericInterface, RawServerBase>, error) {
+      return reply.send(error.error)
+    },
+    queryString (search, reqUrl, request) {
+      expect(search).type.toBe<string | undefined>()
+      expect(reqUrl).type.toBe<string>()
+      expect(request).type.toBe<FastifyRequest<RequestGenericInterface, RawServerBase>>()
+      return ''
+    },
+  })
+})
+
+expect<FastifyReplyFromOptions>().type.toBeAssignableFrom(fullOptions)
+expect<FastifyReplyFromOptions>().type.toBeAssignableFrom({ http2: true })

package/types/index.test-d.ts

@@ -1,194 +0,0 @@
-import fastify, { FastifyReply, FastifyRequest, RawServerBase, RequestGenericInterface, RouteGenericInterface } from 'fastify'
-import * as http from 'node:http'
-import { IncomingHttpHeaders } from 'node:http2'
-import * as https from 'node:https'
-import { AddressInfo } from 'node:net'
-import { expectType } from 'tsd'
-import { Agent, Client, Dispatcher, Pool } from 'undici'
-import replyFrom, { FastifyReplyFromOptions, RawServerResponse } from '..'
-// @ts-ignore
-import tap from 'tap'
-
-const fullOptions: FastifyReplyFromOptions = {
-  base: 'http://example2.com',
-  http: {
-    agentOptions: {
-      keepAliveMsecs: 60 * 1000,
-      maxFreeSockets: 2048,
-      maxSockets: 2048
-    },
-    requestOptions: {
-      timeout: 1000
-    },
-    agents: {
-      'http:': new http.Agent({}),
-      'https:': new https.Agent({})
-    }
-  },
-  http2: {
-    sessionTimeout: 1000,
-    requestTimeout: 1000,
-    sessionOptions: {
-      rejectUnauthorized: true
-    },
-    requestOptions: {
-      endStream: true
-    }
-  },
-  cacheURLs: 100,
-  disableCache: false,
-  undici: {
-    connections: 100,
-    pipelining: 10,
-    proxy: 'http://example2.com:8080'
-  },
-  contentTypesToEncode: ['application/x-www-form-urlencoded'],
-  retryMethods: ['GET', 'HEAD', 'OPTIONS', 'TRACE'],
-  maxRetriesOn503: 10,
-  disableRequestLogging: false,
-  globalAgent: false,
-  destroyAgent: true
-}
-
-async function main () {
-  const server = fastify()
-
-  server.register(replyFrom)
-
-  server.register(replyFrom, {})
-
-  server.register(replyFrom, { http2: true })
-
-  server.register(replyFrom, fullOptions)
-
-  server.register(replyFrom, { undici: { proxy: new URL('http://example2.com:8080') } })
-
-  server.register(replyFrom, { undici: { proxy: { uri: 'http://example2.com:8080' } } })
-
-  server.get('/v1', (_request, reply) => {
-    expectType<FastifyReply>(reply.from())
-  })
-  server.get('/v3', (_request, reply) => {
-    reply.from('/v3', {
-      timeout: 1000,
-      body: { hello: 'world' },
-      rewriteRequestHeaders (req, headers) {
-        expectType<FastifyRequest<RequestGenericInterface, RawServerBase>>(req)
-        return headers
-      },
-      getUpstream (req, base) {
-        expectType<FastifyRequest<RequestGenericInterface, RawServerBase>>(req)
-        return base
-      },
-      onResponse (request, reply, res) {
-        expectType<FastifyRequest<RequestGenericInterface, RawServerBase>>(request)
-        expectType<FastifyReply<RouteGenericInterface, RawServerBase>>(reply)
-        expectType<RawServerResponse<RawServerBase>>(res)
-        expectType<number>(res.statusCode)
-      }
-    })
-  })
-
-  // http2
-  const instance = fastify({ http2: true })
-  // @ts-ignore
-  tap.tearDown(instance.close.bind(instance))
-  const target = fastify({ http2: true })
-  // @ts-ignore
-  tap.tearDown(target.close.bind(target))
-  instance.get('/', (_request, reply) => {
-    reply.from()
-  })
-
-  instance.get('/http2', (_request, reply) => {
-    reply.from('/', {
-      method: 'POST',
-      retryDelay: ({ req, res, err, attempt, getDefaultDelay }) => {
-        const defaultDelay = getDefaultDelay(req, res, err, attempt)
-        if (defaultDelay) return defaultDelay
-
-        if (res && res.statusCode === 500 && req.method === 'GET') {
-          return 300
-        }
-        return null
-      },
-      rewriteHeaders (headers) {
-        return headers
-      },
-      rewriteRequestHeaders (_req, headers: IncomingHttpHeaders) {
-        return headers
-      },
-      getUpstream (_req, base) {
-        return base
-      },
-      onError (reply: FastifyReply<RouteGenericInterface, RawServerBase>, error) {
-        return reply.send(error.error)
-      },
-      queryString (search, reqUrl, request) {
-        expectType<string | undefined>(search)
-        expectType<string>(reqUrl)
-        expectType<FastifyRequest<RequestGenericInterface, RawServerBase>>(request)
-        return ''
-      },
-    })
-  })
-
-  await target.listen({ port: 0 })
-  const port = (target.server.address() as AddressInfo).port
-  instance.register(replyFrom, {
-    base: `http://localhost:${port}`,
-    http2: {
-      sessionOptions: {
-        rejectUnauthorized: false,
-      },
-    },
-  })
-  instance.register(replyFrom, {
-    base: `http://localhost:${port}`,
-    http2: true,
-  })
-  await instance.listen({ port: 0 })
-
-  const undiciInstance = fastify()
-  undiciInstance.register(replyFrom, {
-    base: 'http://example2.com',
-    undici: {
-      pipelining: 10,
-      connections: 10
-    }
-  })
-  await undiciInstance.ready()
-
-  const undiciInstanceAgent = fastify()
-  undiciInstance.register(replyFrom, {
-    base: 'http://example2.com',
-    undici: new Agent()
-  })
-  await undiciInstanceAgent.ready()
-
-  const undiciInstancePool = fastify()
-  undiciInstance.register(replyFrom, {
-    base: 'http://example2.com',
-    undici: new Pool('http://example2.com')
-  })
-  await undiciInstancePool.ready()
-
-  const undiciInstanceClient = fastify()
-  undiciInstance.register(replyFrom, {
-    base: 'http://example2.com',
-    undici: new Client('http://example2.com')
-  })
-  await undiciInstanceClient.ready()
-
-  const undiciInstanceDispatcher = fastify()
-  undiciInstance.register(replyFrom, {
-    base: 'http://example2.com',
-    undici: new Dispatcher()
-  })
-  await undiciInstanceDispatcher.ready()
-
-  tap.pass('done')
-  tap.end()
-}
-
-main()