@fastify/reply-from 12.6.2 → 12.6.4

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/CLAUDE.md

@@ -0,0 +1,66 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Development Commands
+
+### Testing
+- `npm test` - Run all tests (unit + TypeScript)
+- `npm run test:unit` - Run unit tests with coverage using c8 and Node.js test runner
+- `npm run test:typescript` - Run TypeScript definition tests using tsd
+
+### Linting
+- `npm run lint` - Run ESLint to check code style
+- `npm run lint:fix` - Run ESLint with automatic fixes
+- ESLint configuration uses neostandard with TypeScript support
+
+### Building
+- No build step required - this is a CommonJS library
+
+## Architecture Overview
+
+This is a Fastify plugin for proxying HTTP requests to upstream servers. The plugin decorates the Fastify reply with a `from()` method.
+
+### Key Components
+
+**Main Plugin (`index.js`)**
+- Entry point that registers the plugin using fastify-plugin
+- Decorates `reply.from(source, opts)` method
+- Handles request proxying, retries, caching, and error handling
+- Supports HTTP/1.1, HTTP/2, and Undici client strategies
+
+**Request Builder (`lib/request.js`)**
+- Factory for creating request handlers based on transport (HTTP/1.1, HTTP/2, Undici)
+- Handles different agent configurations (HTTP, HTTPS, Unix sockets)
+- Manages timeouts, connection pooling, and retry logic
+- Returns unified interface: `{ request, close, retryOnError }`
+
+**Utilities (`lib/utils.js`)**
+- `filterPseudoHeaders()` - Removes HTTP/2 pseudo-headers (starting with :)
+- `copyHeaders()` - Copies headers to Fastify reply
+- `stripHttp1ConnectionHeaders()` - Removes HTTP/1 connection-specific headers for HTTP/2
+- `buildURL()` - Constructs destination URLs with base path validation
+
+**Error Definitions (`lib/errors.js`)**
+- Standardized error types using @fastify/error
+- Maps different error conditions to appropriate HTTP status codes
+- Includes timeout, connection reset, and gateway errors
+
+### Transport Strategies
+
+1. **Undici (default)** - High-performance HTTP/1.1 client with connection pooling
+2. **HTTP/2** - Native Node.js HTTP/2 client for modern protocols  
+3. **HTTP/1.1** - Node.js built-in http/https modules with custom agents
+
+### Key Features
+
+- **Caching**: URL parsing cache using toad-cache LruMap (default 100 entries)
+- **Retries**: Configurable retry logic for socket hangups and 503 errors
+- **Headers**: Smart header rewriting for HTTP/1.1 ↔ HTTP/2 compatibility
+- **Body handling**: Supports streams, JSON encoding, and custom content types
+- **Unix sockets**: Special handling for unix+http: and unix+https: protocols
+- **Timeouts**: Per-request and session-level timeout configuration
+
+### Configuration
+
+The plugin accepts extensive configuration for different transport methods, retry behavior, caching, and request/response transformation hooks. See README.md for full option documentation.

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

@@ -81,7 +81,7 @@ const fastifyReplyFrom = fp(function from (fastify, opts, next) {
     const dest = getUpstream(this.request, base)
     let url
     if (cache) {
-      const cacheKey = dest + source
+      const cacheKey = JSON.stringify([dest, source])
       url = cache.get(cacheKey) || buildURL(source, dest)
       cache.set(cacheKey, url)
     } else {
@@ -146,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
@@ -218,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)
@@ -226,10 +231,14 @@ const fastifyReplyFrom = fp(function from (fastify, opts, next) {
         onError(this, { error: new BadGatewayError() })
         this.request.log.warn(err, 'response has invalid status code')
       }
-      if (this.request.raw.aborted && isHttp2) {
+      if (this.request.raw.aborted) {
         // the request could have been canceled before we got a response from the target
-        // forward this to the upstream server and close the stream to prevent leaks
-        res.stream.close(NGHTTP2_CANCEL)
+        // clean up the upstream stream to prevent leaks and skip sending a reply
+        if (isHttp2) {
+          res.stream.close(NGHTTP2_CANCEL)
+        } else {
+          res.stream.destroy()
+        }
         // no need to send a reply for aborted requests or call the onResponse callback
         return
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastify/reply-from",
-  "version": "12.6.2",
+  "version": "12.6.4",
   "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,10 +59,9 @@
   ],
   "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",
@@ -73,14 +72,14 @@
     "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/fix-GHSA-v574-6498-x57v.test.js

@@ -0,0 +1,219 @@
+'use strict'
+
+const t = require('node:test')
+const Fastify = require('fastify')
+const From = require('..')
+
+// GHSA-v574-6498-x57v: Cache key collision via ambiguous concatenation.
+// dest + source was used as the cache key.  Different (dest, source) pairs
+// could produce identical concatenations while resolving to different URLs,
+// causing a request to be forwarded to the wrong upstream.
+//
+//   dest   = http://127.0.0.1:31001  , source = /private
+//   dest   = http://127.0.0.1:3100   , source = 1/private
+//
+// Both concatenate to "http://127.0.0.1:31001/private" but resolve to
+// different URLs.
+
+async function run (t) {
+  // victim upstream on port 31001 with a private route and a writable route
+  const victim = Fastify({ keepAliveTimeout: 1 })
+  victim.get('/private', async () => ({ marker: 'VICTIM_PRIVATE_DATA' }))
+  victim.get('/state', async () => ({ written: victim.written }))
+  victim.post('/private', async (req, reply) => {
+    victim.written = req.body
+    return { marker: 'VICTIM_PRIVATE_DATA', written: victim.written }
+  })
+  t.after(() => victim.close())
+  await victim.listen({ port: 31001 })
+
+  // attacker upstream on port 3100
+  const attacker = Fastify({ keepAliveTimeout: 1 })
+  attacker.get('/1/private', async () => ({ marker: 'ATTACKER_UPSTREAM' }))
+  attacker.post('/1/private', async (req, reply) => {
+    return { marker: 'ATTACKER_UPSTREAM', written: req.body }
+  })
+  t.after(() => attacker.close())
+  await attacker.listen({ port: 3100 })
+
+  // proxy using getUpstream() and default cache
+  const proxy = Fastify({ keepAliveTimeout: 1 })
+  proxy.register(From, {
+    base: 'http://localhost',
+    http: true
+  })
+
+  proxy.get('/proxy/victim/private', (req, reply) => {
+    reply.from('/private', {
+      getUpstream () {
+        return 'http://127.0.0.1:31001'
+      }
+    })
+  })
+
+  proxy.post('/proxy/victim/write', (req, reply) => {
+    reply.from('/private', {
+      method: 'POST',
+      body: JSON.stringify(req.body),
+      contentType: 'application/json',
+      getUpstream () {
+        return 'http://127.0.0.1:31001'
+      }
+    })
+  })
+
+  proxy.get('/proxy/attacker/private', (req, reply) => {
+    reply.from('1/private', {
+      getUpstream () {
+        return 'http://127.0.0.1:3100'
+      }
+    })
+  })
+
+  proxy.post('/proxy/attacker/write', (req, reply) => {
+    reply.from('1/private', {
+      method: 'POST',
+      body: JSON.stringify(req.body),
+      contentType: 'application/json',
+      getUpstream () {
+        return 'http://127.0.0.1:3100'
+      }
+    })
+  })
+
+  proxy.get('/proxy/victim/state', (req, reply) => {
+    reply.from('/state', {
+      getUpstream () {
+        return 'http://127.0.0.1:31001'
+      }
+    })
+  })
+
+  t.after(() => proxy.close())
+  await proxy.listen({ port: 31000 })
+
+  // prime the cache with the victim entry (dest = "http://127.0.0.1:31001", source = "/private")
+  const primeRes = await fetch('http://127.0.0.1:31000/proxy/victim/private')
+  t.assert.strictEqual(primeRes.status, 200)
+
+  // now the attacker pair (dest = "http://127.0.0.1:3100", source = "1/private")
+  // should NOT reuse the cached URL — it must resolve to the attacker upstream.
+
+  // 1. attacker read — should return ATTACKER_UPSTREAM, not VICTIM_PRIVATE_DATA
+  const attackerReadRes = await fetch('http://127.0.0.1:31000/proxy/attacker/private')
+  t.assert.strictEqual(attackerReadRes.status, 200)
+  const attackerReadBody = await attackerReadRes.json()
+  t.assert.strictEqual(
+    attackerReadBody.marker,
+    'ATTACKER_UPSTREAM',
+    'attacker request must reach attacker upstream, not victim'
+  )
+
+  // 2. attacker write — should write to attacker, not victim
+  const attackerWriteRes = await fetch('http://127.0.0.1:31000/proxy/attacker/write', {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ changedBy: 'attacker' })
+  })
+  t.assert.strictEqual(attackerWriteRes.status, 200)
+
+  // 3. verify victim state is unchanged (victim.written should be undefined/null)
+  const victimStateRes = await fetch('http://127.0.0.1:31000/proxy/victim/state')
+  t.assert.strictEqual(victimStateRes.status, 200)
+  const victimStateBody = await victimStateRes.json()
+  t.assert.strictEqual(
+    victimStateBody.written,
+    undefined,
+    'victim state must not be affected by attacker write'
+  )
+}
+
+t.test('GHSA-v574-6498-x57v: cache key collision via ambiguous concatenation', async (t) => {
+  t.plan(6)
+  await run(t)
+})
+
+t.test('GHSA-v574-6498-x57v: cache key delimiter cannot be injected', async (t) => {
+  const victim = Fastify()
+  victim.get('/*', async (req) => ({ marker: 'VICTIM', path: req.url }))
+  t.after(() => victim.close())
+  const victimOrigin = await victim.listen({ host: '127.0.0.1', port: 0 })
+
+  const attacker = Fastify()
+  attacker.get('/*', async (req) => ({ marker: 'ATTACKER', path: req.url }))
+  t.after(() => attacker.close())
+  const attackerOrigin = await attacker.listen({ host: '127.0.0.1', port: 0 })
+
+  const victimPair = {
+    source: 'private',
+    dest: `${victimOrigin}/|${attackerOrigin}/`
+  }
+  const attackerPair = {
+    source: `private|${victimOrigin}/`,
+    dest: `${attackerOrigin}/`
+  }
+
+  // These pairs collide when the key is source + '|' + dest.
+  t.assert.strictEqual(
+    victimPair.source + '|' + victimPair.dest,
+    attackerPair.source + '|' + attackerPair.dest
+  )
+
+  const proxy = Fastify()
+  proxy.register(From, {
+    base: 'http://localhost',
+    http: true
+  })
+  proxy.get('/prime', (req, reply) => {
+    reply.from(victimPair.source, {
+      getUpstream: () => victimPair.dest
+    })
+  })
+  proxy.get('/collide', (req, reply) => {
+    reply.from(attackerPair.source, {
+      getUpstream: () => attackerPair.dest
+    })
+  })
+  t.after(() => proxy.close())
+
+  const primeResponse = await proxy.inject('/prime')
+  t.assert.strictEqual(primeResponse.statusCode, 200)
+  t.assert.strictEqual(primeResponse.json().marker, 'VICTIM')
+
+  const attackerResponse = await proxy.inject('/collide')
+  t.assert.strictEqual(attackerResponse.statusCode, 200)
+  t.assert.strictEqual(
+    attackerResponse.json().marker,
+    'ATTACKER',
+    'attacker request must not reuse the victim cache entry'
+  )
+})
+
+t.test('GHSA-v574-6498-x57v: cache key distinguishes an absent base', async (t) => {
+  const target = Fastify()
+  target.get('/private', async () => ({ marker: 'TARGET' }))
+  t.after(() => target.close())
+  const targetOrigin = await target.listen({ host: '127.0.0.1', port: 0 })
+  const source = `${targetOrigin}/private`
+
+  const proxy = Fastify()
+  proxy.register(From, { http: true })
+  proxy.get('/prime', (req, reply) => reply.from(source))
+  proxy.get('/invalid', (req, reply) => {
+    reply.from(source, {
+      getUpstream: () => 'undefined'
+    })
+  })
+  t.after(() => proxy.close())
+
+  const primeResponse = await proxy.inject('/prime')
+  t.assert.strictEqual(primeResponse.statusCode, 200)
+  t.assert.strictEqual(primeResponse.json().marker, 'TARGET')
+
+  const invalidResponse = await proxy.inject('/invalid')
+  t.assert.strictEqual(
+    invalidResponse.statusCode,
+    500,
+    'invalid upstream must not reuse the entry cached without a base'
+  )
+})

package/test/http1-aborted-request.test.js

@@ -0,0 +1,61 @@
+'use strict'
+
+const t = require('node:test')
+const Fastify = require('fastify')
+const From = require('..')
+const http = require('node:http')
+const { once } = require('node:events')
+
+// See https://github.com/fastify/fastify-reply-from/issues/419
+// When a client aborts an HTTP/1 request before the upstream target responds,
+// reply-from must not attempt to forward the (late) upstream response: it should
+// neither invoke the onResponse callback nor pipe the upstream body to the
+// already-closed reply. The equivalent HTTP/2 path was already handled; this
+// covers the HTTP/1 path.
+t.test('does not forward the upstream response when the HTTP/1 request was aborted', async (t) => {
+  t.plan(1)
+
+  // Target that delays its response long enough for the client to abort first.
+  const target = http.createServer((_req, res) => {
+    setTimeout(() => {
+      res.statusCode = 200
+      res.end('hello world')
+    }, 500)
+  })
+  t.after(() => target.close())
+  target.listen({ port: 0 })
+  await once(target, 'listening')
+
+  const instance = Fastify()
+  t.after(() => instance.close())
+
+  let onResponseCalled = false
+  instance.register(From)
+  instance.get('/', (_request, reply) => {
+    reply.from(`http://localhost:${target.address().port}`, {
+      onResponse (_req, replyInner, res) {
+        onResponseCalled = true
+        replyInner.send(res.stream)
+      }
+    })
+  })
+
+  instance.listen({ port: 0 })
+  await once(instance.server, 'listening')
+
+  await new Promise((resolve) => {
+    const req = http.request({
+      host: 'localhost',
+      port: instance.server.address().port,
+      path: '/'
+    }, (res) => { res.resume() })
+    req.on('error', () => {})
+    req.end()
+    // Abort well before the target responds.
+    setTimeout(() => req.destroy(), 50)
+    // Wait past the target's response so any (buggy) forwarding would have happened.
+    setTimeout(resolve, 800)
+  })
+
+  t.assert.strictEqual(onResponseCalled, false, 'onResponse must not run for an aborted request')
+})

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/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()