@fastify/reply-from 9.7.0 → 10.0.0-pre.fv5.1

package/.github/workflows/ci.yml

@@ -17,7 +17,7 @@ on:
 
 jobs:
   test:
-    uses: fastify/workflows/.github/workflows/plugins-ci.yml@v3
+    uses: fastify/workflows/.github/workflows/plugins-ci.yml@v4.1.0
     with:
       license-check: true
       lint: true

package/.taprc

@@ -1,11 +1,3 @@
-ts: false
-jsx: false
-flow: false
-
-functions: 97
-lines: 96
-statements: 96
-branches: 96
-
+disable-coverage: true
 files:
   - test/**/*.test.js

package/README.md

@@ -82,7 +82,7 @@ proxy.register(require('@fastify/reply-from'), {
 
 #### `undici`
 
-By default, [undici](https://github.com/mcollina/undici) will be used to perform the HTTP/1.1
+By default, [undici](https://github.com/nodejs/undici) will be used to perform the HTTP/1.1
 requests. Enabling this flag should guarantee
 20-50% more throughput.
 
@@ -102,6 +102,18 @@ proxy.register(require('@fastify/reply-from'), {
   }
 })
 ```
+
+You can also include a proxy for the undici client:
+
+```js
+proxy.register(require('@fastify/reply-from'), {
+  base: 'http://localhost:3001/',
+  undici: {
+    proxy: 'http://my.proxy.server:8080',
+  }
+})
+```
+
 See undici own options for more configurations.
 
 You can also pass the plugin a custom instance:
@@ -325,17 +337,18 @@ const customRetryLogic = ({req, res, err, getDefaultRetry}: RetryDetails) => {
 ### `reply.from(source, [opts])`
 
 The plugin decorates the
-[`Reply`](https://github.com/fastify/fastify/blob/master/docs/Reply.md)
+[`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 to override any part of
 the request or response being sent or received to/from the source.
 
 **Note: If `base` is specified in plugin options, the `source` here should not override the host/origin.**
 
-#### `onResponse(request, reply, res)`
+#### `onResponse(request, reply, response)`
+
+Called when a HTTP response is received from the source. Passed the original source `request`, the in-progress reply to the source as `reply`, and the ongoing `response` from the upstream server.
 
-Called when a HTTP response is received from the source.
-The default behavior is `reply.send(res)`, which will be disabled if the
+The default behavior is `reply.send(response.stream)`, which will be disabled if the
 option is specified.
 
 When replying with a body of a different length it is necessary to remove
@@ -350,6 +363,8 @@ the `content-length` header.
 }
 ```
 
+**Note**: `onResponse` is called after headers have already been sent. If you want to modify response headers, use the `rewriteHeaders` hook.
+
 #### `onError(reply, error)`
 
 Called when a HTTP response is received with error from the source.
@@ -428,7 +443,7 @@ server.register(fastifyHttpProxy, {
 });
 ```
 
-#### `queryString` or `queryString(search, reqUrl)`
+#### `queryString` or `queryString(search, reqUrl, request)`
 
 Replaces the original querystring of the request with what is specified.
 This will be passed to
@@ -473,8 +488,8 @@ This library has:
 
 - `timeout` for `http` set by default. The default value is 10 seconds (`10000`).
 - `requestTimeout` & `sessionTimeout` for `http2` set by default.
-  - The default value for `requestTimeout` is 10 seconds (`10000`).
-  - The default value for `sessionTimeout` is 60 seconds (`60000`).
+  - 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)
 will be returned to the client.

package/index.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const fp = require('fastify-plugin')
-const { lru } = require('tiny-lru')
+const { LruMap } = require('toad-cache')
 const querystring = require('fast-querystring')
 const fastContentTypeParse = require('fast-content-type-parse')
 const Stream = require('node:stream')
@@ -32,12 +32,13 @@ const fastifyReplyFrom = fp(function from (fastify, opts, next) {
   const retryMethods = new Set(opts.retryMethods || [
     'GET', 'HEAD', 'OPTIONS', 'TRACE'])
 
-  const cache = opts.disableCache ? undefined : lru(opts.cacheURLs || 100)
+  const cache = opts.disableCache ? undefined : new LruMap(opts.cacheURLs || 100)
   const base = opts.base
   const requestBuilt = buildRequest({
     http: opts.http,
     http2: opts.http2,
     base,
+    sessionTimeout: opts.sessionTimeout,
     undici: opts.undici,
     globalAgent: opts.globalAgent,
     destroyAgent: opts.destroyAgent
@@ -80,7 +81,7 @@ const fastifyReplyFrom = fp(function from (fastify, opts, next) {
     const sourceHttp2 = req.httpVersionMajor === 2
     const headers = sourceHttp2 ? filterPseudoHeaders(req.headers) : { ...req.headers }
     headers.host = url.host
-    const qs = getQueryString(url.search, req.url, opts)
+    const qs = getQueryString(url.search, req.url, opts, this.request)
     let body = ''
 
     if (opts.body !== undefined) {
@@ -200,7 +201,7 @@ const fastifyReplyFrom = fp(function from (fastify, opts, next) {
       }
       this.code(res.statusCode)
       if (onResponse) {
-        onResponse(this.request, this, res.stream)
+        onResponse(this.request, this, res)
       } else {
         this.send(res.stream)
       }
@@ -227,9 +228,9 @@ const fastifyReplyFrom = fp(function from (fastify, opts, next) {
   name: '@fastify/reply-from'
 })
 
-function getQueryString (search, reqUrl, opts) {
+function getQueryString (search, reqUrl, opts, request) {
   if (typeof opts.queryString === 'function') {
-    return '?' + opts.queryString(search, reqUrl)
+    return '?' + opts.queryString(search, reqUrl, request)
   }
 
   if (opts.queryString) {
@@ -266,9 +267,7 @@ function onErrorDefault (reply, { error }) {
 }
 
 function isFastifyMultipartRegistered (fastify) {
-  // TODO: remove fastify.hasContentTypeParser('multipart') in next major
-  // It is used to be compatible with @fastify/multipart@<=7.3.0
-  return (fastify.hasContentTypeParser('multipart') || fastify.hasContentTypeParser('multipart/form-data')) && fastify.hasRequestDecorator('multipart')
+  return fastify.hasContentTypeParser('multipart/form-data')
 }
 
 function createRequestRetry (requestImpl, reply, retryHandler) {

package/lib/request.js

@@ -3,7 +3,7 @@ const http = require('node:http')
 const https = require('node:https')
 const querystring = require('node:querystring')
 const eos = require('end-of-stream')
-const pump = require('pump')
+const { pipeline } = require('node:stream')
 const undici = require('undici')
 const { stripHttp1ConnectionHeaders } = require('./utils')
 const http2 = require('node:http2')
@@ -83,7 +83,11 @@ function buildRequest (opts) {
     } else if (isUndiciInstance(opts.undici)) {
       undiciInstance = opts.undici
     } else if (!globalAgent) {
-      undiciAgent = new undici.Agent(getUndiciOptions(opts.undici))
+      if (undiciOpts.proxy) {
+        undiciAgent = new undici.ProxyAgent(getUndiciProxyOptions(opts.undici))
+      } else {
+        undiciAgent = new undici.Agent(getUndiciOptions(opts.undici))
+      }
     } else {
       undiciAgent = undici.getGlobalDispatcher()
     }
@@ -204,7 +208,8 @@ function buildRequest (opts) {
       ...stripHttp1ConnectionHeaders(opts.headers)
     }, http2Opts.requestOptions)
     const isGet = opts.method === 'GET' || opts.method === 'get'
-    if (!isGet) {
+    const isDelete = opts.method === 'DELETE' || opts.method === 'delete'
+    if (!isGet && !isDelete) {
       end(req, opts.body, done)
     }
     req.setTimeout(http2Opts.requestTimeout, () => {
@@ -248,7 +253,7 @@ function end (req, body, cb) {
   if (!body || typeof body === 'string' || body instanceof Uint8Array) {
     req.end(body)
   } else if (body.pipe) {
-    pump(body, req, err => {
+    pipeline(body, req, err => {
       if (err) cb(err)
     })
   } else {
@@ -267,10 +272,10 @@ function getHttp2Opts (opts) {
   }
   http2Opts.sessionOptions = http2Opts.sessionOptions || {}
 
-  if (!http2Opts.sessionTimeout) {
+  if (http2Opts.sessionTimeout === undefined) {
     http2Opts.sessionTimeout = opts.sessionTimeout || 60000
   }
-  if (!http2Opts.requestTimeout) {
+  if (http2Opts.requestTimeout === undefined) {
     http2Opts.requestTimeout = 10000
   }
   http2Opts.sessionOptions.rejectUnauthorized = http2Opts.sessionOptions.rejectUnauthorized || false
@@ -303,6 +308,13 @@ function getAgentOptions (opts) {
   }
 }
 
+function getUndiciProxyOptions ({ proxy, ...opts }) {
+  if (typeof proxy === 'string' || proxy instanceof URL) {
+    return getUndiciOptions({ uri: proxy, ...opts })
+  }
+  return getUndiciOptions({ ...proxy, ...opts })
+}
+
 function getUndiciOptions (opts = {}) {
   const res = {
     pipelining: 1,

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@fastify/reply-from",
-  "version": "9.7.0",
+  "version": "10.0.0-pre.fv5.1",
   "description": "forward your HTTP request to another server, for fastify",
   "main": "index.js",
   "type": "commonjs",
   "types": "types/index.d.ts",
   "scripts": {
     "lint": "standard | snazzy",
-    "lint:fix": "standard --fix",
+    "lint:fix": "standard --fix | snazzy",
     "test": "npm run test:unit && npm run test:typescript",
     "test:unit": "tap",
     "test:typescript": "tsd"
@@ -30,35 +30,35 @@
   "homepage": "https://github.com/fastify/fastify-reply-from#readme",
   "devDependencies": {
     "@fastify/formbody": "^7.4.0",
-    "@fastify/multipart": "^7.4.0",
-    "@fastify/pre-commit": "^2.0.2",
-    "@sinonjs/fake-timers": "^11.0.0",
-    "@types/node": "^20.1.4",
-    "@types/tap": "^15.0.7",
-    "fastify": "^4.0.2",
+    "@fastify/multipart": "^8.2.0",
+    "@fastify/pre-commit": "^2.1.0",
+    "@sinonjs/fake-timers": "^11.2.2",
+    "@types/node": "^20.11.30",
+    "@types/tap": "^15.0.11",
+    "fastify": "^4.26.2",
     "form-data": "^4.0.0",
-    "got": "^11.8.2",
+    "got": "^11.8.6",
     "h2url": "^0.2.0",
-    "msgpack5": "^6.0.1",
-    "nock": "^13.2.6",
+    "msgpack5": "^6.0.2",
+    "nock": "^13.5.4",
+    "proxy": "^2.1.1",
     "proxyquire": "^2.1.3",
-    "semver": "^7.5.1",
+    "semver": "^7.6.0",
     "simple-get": "^4.0.1",
     "snazzy": "^9.0.0",
-    "split2": "^4.1.0",
-    "standard": "^17.0.0",
-    "tap": "^16.2.0",
-    "tsd": "^0.30.1"
+    "split2": "^4.2.0",
+    "standard": "^17.1.0",
+    "tap": "^18.7.2",
+    "tsd": "^0.31.0"
   },
   "dependencies": {
-    "@fastify/error": "^3.0.0",
+    "@fastify/error": "^3.4.1",
     "end-of-stream": "^1.4.4",
     "fast-content-type-parse": "^1.1.0",
-    "fast-querystring": "^1.0.0",
-    "fastify-plugin": "^4.0.0",
-    "pump": "^3.0.0",
-    "tiny-lru": "^11.0.0",
-    "undici": "^5.19.1"
+    "fast-querystring": "^1.1.2",
+    "fastify-plugin": "^4.5.1",
+    "toad-cache": "^3.7.0",
+    "undici": "^6.11.1"
   },
   "pre-commit": [
     "lint",

package/test/full-delete-http2.test.js

@@ -0,0 +1,52 @@
+'use strict'
+
+const { test } = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const got = require('got')
+
+test('http -> http2', async function (t) {
+  const instance = Fastify()
+
+  t.teardown(instance.close.bind(instance))
+
+  const target = Fastify({
+    http2: true
+  })
+
+  target.delete('/', (request, reply) => {
+    t.pass('request proxied')
+    reply.code(200).header('x-my-header', 'hello!').send({
+      hello: 'world'
+    })
+  })
+
+  instance.delete('/', (request, reply) => {
+    reply.from()
+  })
+
+  t.teardown(target.close.bind(target))
+
+  await target.listen({ port: 0 })
+
+  instance.register(From, {
+    base: `http://localhost:${target.server.address().port}`,
+    http2: true
+  })
+
+  await instance.listen({ port: 0 })
+
+  const { headers, body, statusCode } = await got(
+    `http://localhost:${instance.server.address().port}`,
+    {
+      method: 'DELETE',
+      responseType: 'json'
+    }
+  )
+  t.equal(statusCode, 200)
+  t.equal(headers['x-my-header'], 'hello!')
+  t.match(headers['content-type'], /application\/json/)
+  t.same(body, { hello: 'world' })
+  instance.close()
+  target.close()
+})

package/test/full-post-http2.test.js

@@ -46,4 +46,6 @@ test('http -> http2', async function (t) {
   t.equal(headers['x-my-header'], 'hello!')
   t.match(headers['content-type'], /application\/json/)
   t.same(body, { hello: 'world' })
+  instance.close()
+  target.close()
 })

package/test/full-querystring-rewrite-option-function-request.test.js

@@ -0,0 +1,58 @@
+'use strict'
+
+const t = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const http = require('node:http')
+const get = require('simple-get').concat
+const querystring = require('node:querystring')
+
+const instance = Fastify()
+
+instance.addHook('preHandler', (request, reply, done) => {
+  request.addedVal = 'test'
+  done()
+})
+
+t.plan(10)
+t.teardown(instance.close.bind(instance))
+
+const target = http.createServer((req, res) => {
+  t.pass('request proxied')
+  t.equal(req.method, 'GET')
+  t.equal(req.url, '/world?q=test')
+  res.statusCode = 205
+  res.setHeader('Content-Type', 'text/plain')
+  res.setHeader('x-my-header', 'hello!')
+  res.end('hello world')
+})
+
+instance.get('/hello', (request, reply) => {
+  reply.from(`http://localhost:${target.address().port}/world?a=b`, {
+    queryString (search, reqUrl, request) {
+      return querystring.stringify({ q: request.addedVal })
+    }
+  })
+})
+
+t.teardown(target.close.bind(target))
+
+target.listen({ port: 0 }, (err) => {
+  t.error(err)
+
+  instance.register(From)
+
+  instance.listen({ port: 0 }, (err) => {
+    t.error(err)
+
+    get(`http://localhost:${instance.server.address().port}/hello?a=b`, (err, res, data) => {
+      t.error(err)
+      t.equal(res.headers['content-type'], 'text/plain')
+      t.equal(res.headers['x-my-header'], 'hello!')
+      t.equal(res.statusCode, 205)
+      t.equal(data.toString(), 'hello world')
+      instance.close()
+      target.close()
+    })
+  })
+})

package/test/http-http2.test.js

@@ -43,6 +43,8 @@ test('http -> http2', async (t) => {
     t.equal(err.response.headers['x-my-header'], 'hello!')
     t.match(err.response.headers['content-type'], /application\/json/)
     t.same(JSON.parse(err.response.body), { hello: 'world' })
+    instance.close()
+    target.close()
     return
   }
 

package/test/http-timeout.test.js

@@ -9,8 +9,6 @@ const FakeTimers = require('@sinonjs/fake-timers')
 const clock = FakeTimers.createClock()
 
 test('http request timeout', async (t) => {
-  t.autoend(false)
-
   const target = Fastify()
   t.teardown(target.close.bind(target))
 

package/test/http2-http2.test.js

@@ -54,4 +54,6 @@ t.test('http2 -> http2', async (t) => {
   t.equal(headers['x-my-header'], 'hello!')
   t.match(headers['content-type'], /application\/json/)
   t.same(JSON.parse(body), { hello: 'world' })
+  instance.close()
+  target.close()
 })

package/test/http2-invalid-base.test.js

@@ -7,7 +7,7 @@ const From = require('../index')
 test('http2 invalid base', async (t) => {
   const instance = Fastify()
 
-  await t.rejects(instance.register(From, {
+  await t.rejects(async () => instance.register(From, {
     http2: { requestTimeout: 100 }
   }), new Error('Option base is required when http2 is true'))
 })

package/test/http2-timeout-disabled.test.js

@@ -0,0 +1,85 @@
+'use strict'
+
+const { test } = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const got = require('got')
+
+test('http2 request timeout disabled', async (t) => {
+  const target = Fastify({ http2: true })
+  t.teardown(target.close.bind(target))
+
+  target.get('/', () => {
+    t.pass('request arrives')
+  })
+
+  await target.listen({ port: 0 })
+
+  const instance = Fastify()
+  t.teardown(instance.close.bind(instance))
+
+  instance.register(From, {
+    base: `http://localhost:${target.server.address().port}`,
+    http2: { requestTimeout: 0, sessionTimeout: 16000 }
+  })
+
+  instance.get('/', (request, reply) => {
+    reply.from(`http://localhost:${target.server.address().port}/`)
+  })
+
+  await instance.listen({ port: 0 })
+
+  const result = await Promise.race([
+    got.get(`http://localhost:${instance.server.address().port}/`, {
+      retry: 0
+    }),
+    new Promise(resolve => setTimeout(resolve, 11000, 'passed'))
+  ])
+
+  // if we wait 11000 ms without a timeout error, we assume disabling the timeout worked
+  // 10000 ms is the default timeout
+  t.equal(result, 'passed')
+})
+
+test('http2 session timeout disabled', async (t) => {
+  const target = Fastify({ http2: true })
+
+  target.get('/', () => {
+    t.pass('request arrives')
+  })
+
+  await target.listen({ port: 0 })
+
+  const instance = Fastify()
+
+  instance.register(From, {
+    sessionTimeout: 3000,
+    destroyAgent: true,
+    base: `http://localhost:${target.server.address().port}`,
+    http2: { requestTimeout: 0, sessionTimeout: 0 }
+  })
+
+  instance.get('/', (request, reply) => {
+    reply.from(`http://localhost:${target.server.address().port}/`)
+  })
+
+  await instance.listen({ port: 0 })
+
+  const request = got.get(`http://localhost:${instance.server.address().port}/`, {
+    retry: 0
+  })
+
+  const result = await Promise.race([
+    request,
+    new Promise(resolve => setTimeout(resolve, 4000, 'passed'))
+  ])
+
+  // clean up right after the timeout, otherwise test will hang
+  request.cancel()
+  target.close()
+  instance.close()
+
+  // if we wait 4000 ms without a timeout error, we assume disabling the session timeout for reply-from worked
+  // because we pass 3000 ms as session timeout to the Fastify options itself
+  t.equal(result, 'passed')
+})

package/test/http2-timeout.test.js

@@ -122,4 +122,6 @@ test('http2 sse removes request and session timeout test', async (t) => {
 
   const { statusCode } = await got.get(`http://localhost:${instance.server.address().port}/`, { retry: 0 })
   t.equal(statusCode, 200)
+  instance.close()
+  target.close()
 })

package/test/http2-unix-socket.test.js

@@ -9,7 +9,7 @@ test('throw an error if http2 is used with a Unix socket destination', async t =
 
   const instance = Fastify()
 
-  await t.rejects(instance.register(From, {
+  await t.rejects(async () => instance.register(From, {
     base: 'unix+http://localhost:1337',
     http2: { requestTimeout: 100 }
   }), new Error('Unix socket destination is not supported when http2 is true'))

package/test/on-error.test.js

@@ -8,21 +8,19 @@ const FakeTimers = require('@sinonjs/fake-timers')
 
 const clock = FakeTimers.createClock()
 
-t.autoend(false)
+t.test('on-error', async (t) => {
+  const target = Fastify()
+  t.teardown(target.close.bind(target))
 
-const target = Fastify()
-t.teardown(target.close.bind(target))
+  target.get('/', (request, reply) => {
+    t.pass('request arrives')
 
-target.get('/', (request, reply) => {
-  t.pass('request arrives')
-
-  clock.setTimeout(() => {
-    reply.status(200).send('hello world')
-    t.end()
-  }, 1000)
-})
+    clock.setTimeout(() => {
+      reply.status(200).send('hello world')
+      t.end()
+    }, 1000)
+  })
 
-async function main () {
   await target.listen({ port: 0 })
 
   const instance = Fastify()
@@ -63,6 +61,4 @@ async function main () {
   }
 
   t.fail()
-}
-
-main()
+})

package/test/onResponse.test.js

@@ -9,7 +9,7 @@ const get = require('simple-get').concat
 const instance = Fastify()
 instance.register(From)
 
-t.plan(8)
+t.plan(9)
 t.teardown(instance.close.bind(instance))
 
 const target = http.createServer((req, res) => {
@@ -22,8 +22,9 @@ const target = http.createServer((req, res) => {
 instance.get('/', (request1, reply) => {
   reply.from(`http://localhost:${target.address().port}`, {
     onResponse: (request2, reply, res) => {
+      t.equal(res.statusCode, 200)
       t.equal(request1.raw, request2.raw)
-      reply.send(res)
+      reply.send(res.stream)
     }
   })
 })

package/test/transform-body.test.js

@@ -26,7 +26,7 @@ instance.get('/', (request, reply) => {
   reply.from(`http://localhost:${target.address().port}`, {
     onResponse: (request, reply, res) => {
       reply.send(
-        res.pipe(
+        res.stream.pipe(
           new Transform({
             transform: function (chunk, enc, cb) {
               this.push(chunk.toString().toUpperCase())

package/test/undici-agent.test.js

@@ -31,7 +31,7 @@ target.listen({ port: 0 }, err => {
   const From = proxyquire('..', {
     './lib/request.js': proxyquire('../lib/request.js', {
       undici: proxyquire('undici', {
-        './lib/agent': proxyquire('undici/lib/agent.js', {
+        './lib/dispatcher/agent': proxyquire('undici/lib/dispatcher/agent.js', {
           './pool': class Pool extends undici.Pool {
             constructor (url, options) {
               super(url, options)

package/test/undici-connect-timeout.test.js

@@ -7,18 +7,16 @@ const Fastify = require('fastify')
 const From = require('..')
 const got = require('got')
 
-t.autoend(false)
-
+t.test('undici connect timeout', async (t) => {
 // never connect
-net.connect = function (options) {
-  return new net.Socket(options)
-}
+  net.connect = function (options) {
+    return new net.Socket(options)
+  }
 
-const target = http.createServer((req, res) => {
-  t.fail('target never called')
-})
+  const target = http.createServer((req, res) => {
+    t.fail('target never called')
+  })
 
-async function main () {
   t.plan(2)
   await target.listen({ port: 0 })
 
@@ -53,6 +51,4 @@ async function main () {
   }
 
   t.fail()
-}
-
-main()
+})

package/test/undici-proxy-agent.test.js

@@ -0,0 +1,81 @@
+'use strict'
+
+const { test } = require('tap')
+const { createServer } = require('node:http')
+const Fastify = require('fastify')
+const get = require('simple-get').concat
+const { createProxy } = require('proxy')
+const From = require('..')
+
+const configFormat = {
+  string: (value) => value,
+  'url instance': (value) => new URL(value),
+  object: (value) => ({ uri: value })
+}
+
+for (const [description, format] of Object.entries(configFormat)) {
+  test(`use undici ProxyAgent to connect through proxy - configured via ${description}`, async (t) => {
+    t.plan(5)
+    const target = await buildServer()
+    const proxy = await buildProxy()
+    t.teardown(target.close.bind(target))
+    t.teardown(proxy.close.bind(proxy))
+
+    const targetUrl = `http://localhost:${target.address().port}`
+    const proxyUrl = `http://localhost:${proxy.address().port}`
+
+    proxy.on('connect', () => {
+      t.ok(true, 'should connect to proxy')
+    })
+
+    target.on('request', (req, res) => {
+      res.setHeader('content-type', 'application/json')
+      res.end(JSON.stringify({ hello: 'world' }))
+    })
+
+    const instance = Fastify()
+    t.teardown(instance.close.bind(instance))
+
+    instance.register(From, {
+      base: targetUrl,
+      undici: {
+        proxy: format(proxyUrl)
+      }
+    })
+
+    instance.get('/', (request, reply) => {
+      reply.from()
+    })
+
+    const executionFlow = () => new Promise((resolve) => {
+      instance.listen({ port: 0 }, err => {
+        t.error(err)
+
+        get(`http://localhost:${instance.server.address().port}`, (err, res, data) => {
+          t.error(err)
+          t.same(res.statusCode, 200)
+          t.match(JSON.parse(data.toString()), { hello: 'world' })
+          resolve()
+          instance.close()
+          target.close()
+        })
+      })
+    })
+
+    await executionFlow()
+  })
+}
+
+function buildServer () {
+  return new Promise((resolve) => {
+    const server = createServer()
+    server.listen(0, () => resolve(server))
+  })
+}
+
+function buildProxy () {
+  return new Promise((resolve) => {
+    const server = createProxy(createServer())
+    server.listen(0, () => resolve(server))
+  })
+}

package/test/undici-timeout-body-partial.test.js

@@ -9,23 +9,21 @@ const FakeTimers = require('@sinonjs/fake-timers')
 
 const clock = FakeTimers.createClock()
 
-t.autoend(false)
-
-const target = http.createServer((req, res) => {
-  t.pass('request proxied')
-  req.on('data', () => undefined)
-  req.on('end', () => {
-    res.writeHead(200)
-    res.flushHeaders()
-    res.write('test')
-    clock.setTimeout(() => {
-      res.end()
-      t.end()
-    }, 1000)
+t.test('undici body timeout', async (t) => {
+  const target = http.createServer((req, res) => {
+    t.pass('request proxied')
+    req.on('data', () => undefined)
+    req.on('end', () => {
+      res.writeHead(200)
+      res.flushHeaders()
+      res.write('test')
+      clock.setTimeout(() => {
+        res.end()
+        t.end()
+      }, 1000)
+    })
   })
-})
 
-async function main () {
   await target.listen({ port: 0 })
 
   const instance = Fastify()
@@ -55,6 +53,4 @@ async function main () {
   }
 
   t.fail()
-}
-
-main()
+})

package/test/undici-timeout-body.test.js

@@ -9,21 +9,19 @@ const FakeTimers = require('@sinonjs/fake-timers')
 
 const clock = FakeTimers.createClock()
 
-t.autoend(false)
-
-const target = http.createServer((req, res) => {
-  t.pass('request proxied')
-  req.on('data', () => undefined)
-  req.on('end', () => {
-    res.flushHeaders()
-    clock.setTimeout(() => {
-      res.end()
-      t.end()
-    }, 1000)
+t.test('undici body timeout', async (t) => {
+  const target = http.createServer((req, res) => {
+    t.pass('request proxied')
+    req.on('data', () => undefined)
+    req.on('end', () => {
+      res.flushHeaders()
+      clock.setTimeout(() => {
+        res.end()
+        t.end()
+      }, 1000)
+    })
   })
-})
 
-async function main () {
   await target.listen({ port: 0 })
 
   const instance = Fastify()
@@ -58,6 +56,4 @@ async function main () {
   }
 
   t.fail()
-}
-
-main()
+})

package/test/undici-timeout.test.js

@@ -8,21 +8,19 @@ const FakeTimers = require('@sinonjs/fake-timers')
 
 const clock = FakeTimers.createClock()
 
-t.autoend(false)
+t.test('undici request timeout', async (t) => {
+  const target = Fastify()
+  t.teardown(target.close.bind(target))
 
-const target = Fastify()
-t.teardown(target.close.bind(target))
+  target.get('/', (request, reply) => {
+    t.pass('request arrives')
 
-target.get('/', (request, reply) => {
-  t.pass('request arrives')
-
-  clock.setTimeout(() => {
-    reply.status(200).send('hello world')
-    t.end()
-  }, 1000)
-})
+    clock.setTimeout(() => {
+      reply.status(200).send('hello world')
+      t.end()
+    }, 1000)
+  })
 
-async function main () {
   await target.listen({ port: 0 })
 
   const instance = Fastify()
@@ -57,6 +55,4 @@ async function main () {
   }
 
   t.fail()
-}
-
-main()
+})

package/types/index.d.ts

@@ -28,6 +28,7 @@ import {
   RequestOptions as SecureRequestOptions
 } from "https";
 import { Pool } from 'undici';
+import { ProxyAgent } from 'undici';
 
 declare module "fastify" {
   interface FastifyReply {
@@ -40,13 +41,18 @@ declare module "fastify" {
 
 type FastifyReplyFrom = FastifyPluginCallback<fastifyReplyFrom.FastifyReplyFromOptions>
 declare namespace fastifyReplyFrom {
-  type QueryStringFunction = (search: string | undefined, reqUrl: string) => string;
+  type QueryStringFunction = (
+    search: string | undefined,
+    reqUrl: string,
+    request: FastifyRequest<RequestGenericInterface, RawServerBase>
+  ) => string;
 
   export type RetryDetails = {
     err: Error;
     req: FastifyRequest<RequestGenericInterface, RawServerBase>;
     res: FastifyReply<RawServerBase>;
     attempt: number;
+    retriesCount: number;
     getDefaultDelay: () => number | null;
   }
   export interface FastifyReplyFromHooks {
@@ -98,7 +104,7 @@ declare namespace fastifyReplyFrom {
     disableCache?: boolean;
     http?: HttpOptions;
     http2?: Http2Options | boolean;
-    undici?: Pool.Options;
+    undici?: Pool.Options & { proxy?: string  | URL | ProxyAgent.Options };
     contentTypesToEncode?: string[];
     retryMethods?: (HTTPMethods | 'TRACE')[];
     maxRetriesOn503?: number;

package/types/index.test-d.ts

@@ -1,4 +1,4 @@
-import fastify, { FastifyReply, FastifyRequest, RawServerBase, RequestGenericInterface } from "fastify";
+import fastify, { FastifyReply, FastifyRequest, RawReplyDefaultExpression, RawServerBase, RequestGenericInterface } from "fastify";
 import * as http from 'http';
 import { IncomingHttpHeaders } from "http2";
 import * as https from 'https';
@@ -38,7 +38,8 @@ const fullOptions: FastifyReplyFromOptions = {
   disableCache: false,
   undici: {
     connections: 100,
-    pipelining: 10
+    pipelining: 10,
+    proxy: 'http://example2.com:8080'
   },
   contentTypesToEncode: ['application/x-www-form-urlencoded'],
   retryMethods: ['GET', 'HEAD', 'OPTIONS', 'TRACE'],
@@ -47,7 +48,6 @@ const fullOptions: FastifyReplyFromOptions = {
   globalAgent: false,
   destroyAgent: true
 };
-tap.autoend(false);
 
 async function main() {
   const server = fastify();
@@ -60,6 +60,10 @@ async function main() {
 
   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());
   });
@@ -73,6 +77,12 @@ async function main() {
           getUpstream(req, base) {
               expectType<FastifyRequest<RequestGenericInterface, RawServerBase>>(req);
               return base;
+          },
+          onResponse(request, reply, res) {
+            expectType<FastifyRequest<RequestGenericInterface, RawServerBase>>(request);
+            expectType<FastifyReply<RawServerBase>>(reply);
+            expectType<RawReplyDefaultExpression<RawServerBase>>(res);
+            expectType<number>(res.statusCode);
           }
       });
   });
@@ -91,7 +101,7 @@ async function main() {
   instance.get("/http2", (request, reply) => {
       reply.from("/", {
           method: "POST",
-          retryDelay: ({err, req, res, attempt, getDefaultDelay}) => {
+          retryDelay: ({err, req, res, attempt, retriesCount, getDefaultDelay }) => {
               const defaultDelay = getDefaultDelay();
               if (defaultDelay) return defaultDelay;
 
@@ -111,7 +121,13 @@ async function main() {
           },
           onError(reply: FastifyReply<RawServerBase>, error) {
               return reply.send(error.error);
-          }
+          },
+          queryString(search, reqUrl, request) {
+              expectType<string | undefined>(search);
+              expectType<string>(reqUrl);
+              expectType<FastifyRequest<RequestGenericInterface, RawServerBase>>(request);
+              return '';
+          },
       });
   });