@fastify/reply-from 8.3.0 → 8.4.0

package/.taprc

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

package/README.md

@@ -1,6 +1,6 @@
 # @fastify/reply-from
 
-[![CI](https://github.com/fastify/reply-fro/workflows/CI/badge.svg)](https://github.com/fastify/reply-fro/actions/workflows/ci.yml)
+[![CI](https://github.com/fastify/fastify-reply-from/workflows/CI/badge.svg)](https://github.com/fastify/fastify-reply-from/actions/workflows/ci.yml)
 [![NPM version](https://img.shields.io/npm/v/@fastify/reply-from.svg?style=flat)](https://www.npmjs.com/package/@fastify/reply-from)
 [![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat)](https://standardjs.com/)
 
@@ -166,7 +166,7 @@ proxy.register(require('@fastify/reply-from'), {
     sessionOptions: { // HTTP/2 session connect options, pass in any options from https://nodejs.org/api/http2.html#http2_http2_connect_authority_options_listener
       rejectUnauthorized: true
     },
-    requestTimeout: { // HTTP/2 request options, pass in any options from https://nodejs.org/api/http2.html#http2_clienthttp2session_request_headers_options
+    requestOptions: { // HTTP/2 request options, pass in any options from https://nodejs.org/api/http2.html#clienthttp2sessionrequestheaders-options
       endStream: true
     }
   }
@@ -203,8 +203,7 @@ This only applies when a custom [`body`](#body) is not passed in. Defaults to:
 
 ```js
 [ 
-  'application/json',
-  'application/x-www-form-urlencoded'
+  'application/json'
 ]
 ```
 
@@ -217,6 +216,34 @@ By default: `['GET', 'HEAD', 'OPTIONS', 'TRACE' ]`
 
 This plugin will always retry on 503 errors, _unless_ `retryMethods` does not contain `GET`.
 
+#### `globalAgent`
+
+Enables the possibility to explictly opt-in for global agents.
+
+Usage for undici global agent:
+```js
+import { setGlobalDispatcher, ProxyAgent } from 'undici'
+
+const proxyAgent = new ProxyAgent('my.proxy.server')
+setGlobalDispatcher(proxyAgent)
+
+fastify.register(FastifyReplyFrom, {
+  base: 'http://localhost:3001/',
+  globalAgent: true
+})
+```
+
+Usage for http/https global agent:
+```js
+fastify.register(FastifyReplyFrom, {
+  base: 'http://localhost:3001/',
+  // http and https is allowed to use http.globalAgent or https.globalAgent
+  globalAgent: true, 
+  http: {
+  }
+})
+```
+
 ---
 
 #### `maxRetriesOn503`

package/index.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const fp = require('fastify-plugin')
-const lru = require('tiny-lru')
+const { lru } = require('tiny-lru')
 const querystring = require('fast-querystring')
 const Stream = require('stream')
 const buildRequest = require('./lib/request')
@@ -21,7 +21,7 @@ const {
   InternalServerError
 } = require('./lib/errors')
 
-module.exports = fp(function from (fastify, opts, next) {
+const fastifyReplyFrom = fp(function from (fastify, opts, next) {
   const contentTypesToEncode = new Set([
     'application/json',
     ...(opts.contentTypesToEncode || [])
@@ -33,12 +33,18 @@ module.exports = fp(function from (fastify, opts, next) {
 
   const cache = opts.disableCache ? undefined : lru(opts.cacheURLs || 100)
   const base = opts.base
-  const { request, close, retryOnError } = buildRequest({
+  const requestBuilt = buildRequest({
     http: opts.http,
     http2: opts.http2,
     base,
-    undici: opts.undici
+    undici: opts.undici,
+    globalAgent: opts.globalAgent
   })
+  if (requestBuilt instanceof Error) {
+    next(requestBuilt)
+    return
+  }
+  const { request, close, retryOnError } = requestBuilt
   const disableRequestLogging = opts.disableRequestLogging || false
 
   fastify.decorateReply('from', function (source, opts) {
@@ -60,8 +66,9 @@ module.exports = fp(function from (fastify, opts, next) {
     const dest = getUpstream(req, base)
     let url
     if (cache) {
-      url = cache.get(source) || buildURL(source, dest)
-      cache.set(source, url)
+      const cacheKey = dest + source
+      url = cache.get(cacheKey) || buildURL(source, dest)
+      cache.set(cacheKey, url)
     } else {
       url = buildURL(source, dest)
     }
@@ -234,7 +241,9 @@ function onErrorDefault (reply, { error }) {
 }
 
 function isFastifyMultipartRegistered (fastify) {
-  return fastify.hasContentTypeParser('multipart') && fastify.hasRequestDecorator('multipart')
+  // 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')
 }
 
 function createRequestRetry (requestImpl, reply, retriesCount, retryOnError, maxRetriesOn503) {
@@ -274,3 +283,7 @@ function createRequestRetry (requestImpl, reply, retriesCount, retryOnError, max
 
   return requestRetry
 }
+
+module.exports = fastifyReplyFrom
+module.exports.default = fastifyReplyFrom
+module.exports.fastifyReplyFrom = fastifyReplyFrom

package/lib/request.js

@@ -41,21 +41,27 @@ function buildRequest (opts) {
   const httpOpts = getHttpOpts(opts)
   const baseUrl = opts.base && new URL(opts.base).origin
   const undiciOpts = opts.undici || {}
+  const globalAgent = opts.globalAgent
   let http2Client
   let undiciAgent
   let undiciInstance
   let agents
 
   if (isHttp2) {
-    if (!opts.base) throw new Error('Option base is required when http2 is true')
+    if (!opts.base) return new Error('Option base is required when http2 is true')
     if (opts.base.startsWith('unix+')) {
-      throw new Error('Unix socket destination is not supported when http2 is true')
+      return new Error('Unix socket destination is not supported when http2 is true')
     }
-  } else {
+  } else if (!globalAgent) {
     agents = httpOpts.agents || {
       'http:': new http.Agent(httpOpts.agentOptions),
       'https:': new https.Agent(httpOpts.agentOptions)
     }
+  } else {
+    agents = {
+      'http:': http.globalAgent,
+      'https:': https.globalAgent
+    }
   }
 
   if (isHttp2) {
@@ -68,8 +74,10 @@ function buildRequest (opts) {
       undiciInstance = new undici.Pool(protocol + '://localhost', undiciOpts)
     } else if (isUndiciInstance(opts.undici)) {
       undiciInstance = opts.undici
-    } else {
+    } else if (!globalAgent) {
       undiciAgent = new undici.Agent(getUndiciOptions(opts.undici))
+    } else {
+      undiciAgent = undici.getGlobalDispatcher()
     }
     return { request: handleUndici, close, retryOnError: 'UND_ERR_SOCKET' }
   } else {
@@ -77,6 +85,10 @@ function buildRequest (opts) {
   }
 
   function close () {
+    if (globalAgent) {
+      return
+    }
+
     if (hasUndiciOptions) {
       undiciAgent && undiciAgent.destroy()
       undiciInstance && undiciInstance.destroy()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastify/reply-from",
-  "version": "8.3.0",
+  "version": "8.4.0",
   "description": "forward your HTTP request to another server, for fastify",
   "main": "index.js",
   "types": "types/index.d.ts",
@@ -28,10 +28,10 @@
   },
   "homepage": "https://github.com/fastify/fastify-reply-from#readme",
   "devDependencies": {
-    "@fastify/formbody": "^7.0.1",
-    "@fastify/multipart": "^7.1.0",
+    "@fastify/formbody": "^7.4.0",
+    "@fastify/multipart": "^7.4.0",
     "@fastify/pre-commit": "^2.0.2",
-    "@sinonjs/fake-timers": "^9.1.2",
+    "@sinonjs/fake-timers": "^10.0.0",
     "@types/node": "^18.0.0",
     "@types/tap": "^15.0.7",
     "fastify": "^4.0.2",
@@ -46,7 +46,7 @@
     "split2": "^4.1.0",
     "standard": "^17.0.0",
     "tap": "^16.2.0",
-    "tsd": "^0.23.0"
+    "tsd": "^0.25.0"
   },
   "dependencies": {
     "@fastify/error": "^3.0.0",
@@ -54,7 +54,7 @@
     "fast-querystring": "^1.0.0",
     "fastify-plugin": "^4.0.0",
     "pump": "^3.0.0",
-    "tiny-lru": "^8.0.2",
+    "tiny-lru": "^10.0.0",
     "undici": "^5.5.1"
   },
   "pre-commit": [

package/test/get-upstream-cache.js

@@ -0,0 +1,72 @@
+'use strict'
+
+const t = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+
+async function createTarget (i) {
+  const target = Fastify({
+    keepAliveTimeout: 1
+  })
+
+  target.get('/test', async () => {
+    return `Hello from target ${i}`
+  })
+
+  t.teardown(() => target.close())
+  await target.listen({ port: 3000 + i })
+}
+
+t.plan(4)
+
+async function run () {
+  await Promise.all([
+    createTarget(1),
+    createTarget(2)
+  ])
+
+  const instance = Fastify({
+    keepAliveTimeout: 1
+  })
+
+  instance.register(From, {
+    base: 'http://localhost',
+    http: true
+  })
+
+  instance.get('/', (req, reply) => {
+    const hostNumber = parseInt(req.headers['x-host-number'])
+    const port = 3000 + hostNumber
+
+    reply.from('/test', {
+      getUpstream () {
+        return `http://localhost:${port}`
+      }
+    })
+  })
+
+  t.teardown(() => instance.close())
+  await instance.listen({ port: 3000 })
+
+  const res1 = await instance.inject({
+    method: 'GET',
+    url: '/',
+    headers: {
+      'x-host-number': 1
+    }
+  })
+  t.equal(res1.statusCode, 200)
+  t.equal(res1.body, 'Hello from target 1')
+
+  const res2 = await instance.inject({
+    method: 'GET',
+    url: '/',
+    headers: {
+      'x-host-number': 2
+    }
+  })
+  t.equal(res2.statusCode, 200)
+  t.equal(res2.body, 'Hello from target 2')
+}
+
+run()

package/test/http-global-agent.js

@@ -0,0 +1,57 @@
+'use strict'
+
+const { test } = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const http = require('http')
+const get = require('simple-get').concat
+
+test('http global agent is used, but not destroyed', async (t) => {
+  http.globalAgent.destroy = () => {
+    t.fail()
+  }
+  const instance = Fastify()
+  t.teardown(instance.close.bind(instance))
+  instance.get('/', (request, reply) => {
+    reply.from()
+  })
+
+  const target = http.createServer((req, res) => {
+    t.pass('request proxied')
+    t.equal(req.method, 'GET')
+    t.equal(req.url, '/')
+    res.statusCode = 200
+    res.end()
+  })
+  t.teardown(target.close.bind(target))
+
+  const executionFlow = () => new Promise((resolve) => {
+    target.listen({ port: 0 }, (err) => {
+      t.error(err)
+
+      instance.register(From, {
+        base: `http://localhost:${target.address().port}`,
+        globalAgent: true,
+        http: {
+        }
+      })
+
+      instance.listen({ port: 0 }, (err) => {
+        t.error(err)
+
+        get(
+          `http://localhost:${instance.server.address().port}`,
+          (err, res) => {
+            t.error(err)
+            t.equal(res.statusCode, 200)
+            resolve()
+          }
+        )
+      })
+    })
+  })
+
+  await executionFlow()
+
+  target.close()
+})

package/test/http2-invalid-base.js

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

package/test/http2-unix-socket.js

@@ -0,0 +1,16 @@
+'use strict'
+
+const { test } = require('tap')
+const Fastify = require('fastify')
+const From = require('../index')
+
+test('throw an error if http2 is used with a Unix socket destination', async t => {
+  t.plan(1)
+
+  const instance = Fastify()
+
+  await t.rejects(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/https-global-agent.js

@@ -0,0 +1,69 @@
+'use strict'
+
+const { test } = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const https = require('https')
+const get = require('simple-get').concat
+
+const fs = require('fs')
+const path = require('path')
+const certs = {
+  key: fs.readFileSync(path.join(__dirname, 'fixtures', 'fastify.key')),
+  cert: fs.readFileSync(path.join(__dirname, 'fixtures', 'fastify.cert'))
+}
+
+test('https global agent is used, but not destroyed', async (t) => {
+  https.globalAgent.destroy = () => {
+    t.fail()
+  }
+  const instance = Fastify({
+    https: certs
+  })
+  t.teardown(instance.close.bind(instance))
+  instance.get('/', (request, reply) => {
+    reply.from()
+  })
+
+  const target = https.createServer(certs, (req, res) => {
+    t.pass('request proxied')
+    t.equal(req.method, 'GET')
+    t.equal(req.url, '/')
+    res.statusCode = 200
+    res.end()
+  })
+  t.teardown(target.close.bind(target))
+
+  const executionFlow = () => new Promise((resolve) => {
+    target.listen({ port: 0 }, (err) => {
+      t.error(err)
+
+      instance.register(From, {
+        base: `https://localhost:${target.address().port}`,
+        globalAgent: true,
+        http: {
+        }
+      })
+
+      instance.listen({ port: 0 }, (err) => {
+        t.error(err)
+
+        get(
+          {
+            url: `https://localhost:${instance.server.address().port}`,
+            rejectUnauthorized: false
+          },
+          (err, res) => {
+            t.error(err)
+            t.equal(res.statusCode, 200)
+            resolve()
+          }
+        )
+      })
+    })
+  })
+
+  await executionFlow()
+
+  target.close()
+})

package/test/post-with-octet-stream.js

@@ -0,0 +1,131 @@
+'use strict'
+
+const test = require('tap').test
+const Fastify = require('fastify')
+const From = require('../index')
+const http = require('http')
+const get = require('simple-get').concat
+const { parse } = require('querystring')
+
+test('with explicitly set content-type application/octet-stream', t => {
+  const instance = Fastify()
+  instance.register(From, {
+    contentTypesToEncode: ['application/octet-stream']
+  })
+
+  instance.addContentTypeParser(
+    'application/octet-stream',
+    { parseAs: 'buffer', bodyLimit: 1000 },
+    (req, body, done) => done(null, parse(body.toString()))
+  )
+
+  t.plan(9)
+  t.teardown(instance.close.bind(instance))
+
+  const target = http.createServer((req, res) => {
+    t.pass('request proxied')
+    t.equal(req.method, 'POST')
+    t.equal(req.headers['content-type'], 'application/octet-stream')
+    let data = ''
+    req.setEncoding('utf8')
+    req.on('data', (d) => {
+      data += d
+    })
+    req.on('end', () => {
+      const str = data.toString()
+      t.same(JSON.parse(data), { some: 'info', another: 'detail' })
+      res.statusCode = 200
+      res.setHeader('content-type', 'application/octet-stream')
+      res.end(str)
+    })
+  })
+
+  instance.post('/', (request, reply) => {
+    reply.from(`http://localhost:${target.address().port}`)
+  })
+
+  t.teardown(target.close.bind(target))
+
+  instance.listen({ port: 0 }, (err) => {
+    t.error(err)
+
+    target.listen({ port: 0 }, (err) => {
+      t.error(err)
+
+      get({
+        url: `http://localhost:${instance.server.address().port}`,
+        method: 'POST',
+        headers: { 'content-type': 'application/octet-stream' },
+        body: 'some=info&another=detail'
+      }, (err, res, data) => {
+        t.error(err)
+        t.equal(res.headers['content-type'], 'application/octet-stream')
+        t.same(JSON.parse(data), { some: 'info', another: 'detail' })
+      })
+    })
+  })
+})
+
+test('with implicit content-type application/octet-stream', t => {
+  const instance = Fastify()
+  instance.register(From, {
+    contentTypesToEncode: ['application/octet-stream']
+  })
+
+  instance.addContentTypeParser(
+    'application/octet-stream',
+    { parseAs: 'buffer', bodyLimit: 1000 },
+    (req, body, done) => done(null, parse(body.toString()))
+  )
+
+  instance.addContentTypeParser(
+    '*',
+    { parseAs: 'buffer', bodyLimit: 1000 },
+    (req, body, done) => done(null, parse(body.toString()))
+  )
+
+  t.plan(9)
+  t.teardown(instance.close.bind(instance))
+
+  const target = http.createServer((req, res) => {
+    t.pass('request proxied')
+    t.equal(req.method, 'POST')
+    t.equal(req.headers['content-type'], 'application/octet-stream')
+    let data = ''
+    req.setEncoding('utf8')
+    req.on('data', (d) => {
+      data += d
+    })
+    req.on('end', () => {
+      const str = data.toString()
+      t.same(JSON.parse(data), { some: 'info', another: 'detail' })
+      res.statusCode = 200
+      res.setHeader('content-type', 'application/octet-stream')
+      res.end(str)
+    })
+  })
+
+  instance.post('/', (request, reply) => {
+    reply.from(`http://localhost:${target.address().port}`)
+  })
+
+  t.teardown(target.close.bind(target))
+
+  instance.listen({ port: 0 }, (err) => {
+    t.error(err)
+
+    target.listen({ port: 0 }, (err) => {
+      t.error(err)
+
+      get({
+        url: `http://localhost:${instance.server.address().port}`,
+        method: 'POST',
+        body: 'some=info&another=detail'
+      }, (err, res, data) => {
+        t.error(err)
+        t.equal(res.headers['content-type'], 'application/octet-stream')
+        t.same(JSON.parse(data), { some: 'info', another: 'detail' })
+      })
+    })
+  })
+})

package/test/undici-global-agent.js

@@ -0,0 +1,66 @@
+'use strict'
+
+const { test } = require('tap')
+const Fastify = require('fastify')
+const http = require('http')
+const get = require('simple-get').concat
+const undici = require('undici')
+const From = require('..')
+
+test('undici global agent is used, but not destroyed', async (t) => {
+  const mockAgent = new undici.Agent()
+  mockAgent.destroy = () => {
+    t.fail()
+  }
+  undici.setGlobalDispatcher(mockAgent)
+  const instance = Fastify()
+
+  t.teardown(instance.close.bind(instance))
+
+  const target = http.createServer((req, res) => {
+    res.statusCode = 200
+    res.end()
+  })
+
+  instance.get('/', (request, reply) => {
+    reply.from()
+  })
+
+  t.teardown(target.close.bind(target))
+
+  const executionFlow = () => new Promise((resolve) => {
+    target.listen({ port: 0 }, (err) => {
+      t.error(err)
+
+      instance.register(From, {
+        base: `http://localhost:${target.address().port}`,
+        globalAgent: true
+      })
+
+      instance.listen({ port: 0 }, (err) => {
+        t.error(err)
+
+        get(
+          `http://localhost:${instance.server.address().port}`,
+          (err, res) => {
+            t.error(err)
+            t.equal(res.statusCode, 200)
+
+            get(
+              `http://localhost:${instance.server.address().port}`,
+              (err, res) => {
+                t.error(err)
+                t.equal(res.statusCode, 200)
+                resolve()
+              }
+            )
+          }
+        )
+      })
+    })
+  })
+
+  await executionFlow()
+
+  target.close()
+})

package/test/utils-filter-pseudo-headers.js

@@ -0,0 +1,18 @@
+'use strict'
+
+const test = require('tap').test
+const filterPseudoHeaders = require('../lib/utils').filterPseudoHeaders
+
+test('filterPseudoHeaders', t => {
+  t.plan(1)
+  const headers = {
+    accept: '*/*',
+    'Content-Type': 'text/html; charset=UTF-8',
+    ':method': 'GET'
+  }
+
+  t.strictSame(filterPseudoHeaders(headers), {
+    accept: '*/*',
+    'content-type': 'text/html; charset=UTF-8'
+  })
+})

package/types/index.d.ts

@@ -30,68 +30,77 @@ import {
   SecureClientSessionOptions,
 } from "http2";
 import { Pool } from 'undici'
-type QueryStringFunction = (search: string | undefined, reqUrl: string) => string;
-export interface FastifyReplyFromHooks {
-  queryString?: { [key: string]: unknown } | QueryStringFunction;
-  contentType?: string;
-  onResponse?: (
-    request: FastifyRequest<RequestGenericInterface, RawServerBase>,
-    reply: FastifyReply<RawServerBase>,
-    res: RawReplyDefaultExpression<RawServerBase>
-  ) => void;
-  onError?: (
-      reply: FastifyReply<RawServerBase>,
-      error: { error: Error }
-  ) => void;
-  body?: unknown;
-  rewriteHeaders?: (
-    headers: Http2IncomingHttpHeaders | IncomingHttpHeaders,
-    req?: Http2ServerRequest | IncomingMessage
-  ) => Http2IncomingHttpHeaders | IncomingHttpHeaders;
-  rewriteRequestHeaders?: (
-    req: Http2ServerRequest | IncomingMessage,
-    headers: Http2IncomingHttpHeaders | IncomingHttpHeaders
-  ) => Http2IncomingHttpHeaders | IncomingHttpHeaders;
-  getUpstream?: (
-      req: Http2ServerRequest | IncomingMessage,
-      base: string
-  ) => string;
-}
 
 declare module "fastify" {
   interface FastifyReply {
     from(
       source?: string,
-      opts?: FastifyReplyFromHooks
-    ): void;
+      opts?: fastifyReplyFrom.FastifyReplyFromHooks
+    ): this;
   }
 }
 
-interface Http2Options {
-  sessionTimeout?: number;
-  requestTimeout?: number;
-  sessionOptions?: ClientSessionOptions | SecureClientSessionOptions;
-  requestOptions?: ClientSessionRequestOptions;
-}
+type FastifyReplyFrom = FastifyPluginCallback<fastifyReplyFrom.FastifyReplyFromOptions>
 
-interface HttpOptions {
-  agentOptions?: AgentOptions | SecureAgentOptions;
-  requestOptions?: RequestOptions | SecureRequestOptions;
-  agents?: { 'http:': Agent, 'https:': SecureAgent }
-}
+declare namespace fastifyReplyFrom {
+  type QueryStringFunction = (search: string | undefined, reqUrl: string) => string;
+  export interface FastifyReplyFromHooks {
+    queryString?: { [key: string]: unknown } | QueryStringFunction;
+    contentType?: string;
+    onResponse?: (
+      request: FastifyRequest<RequestGenericInterface, RawServerBase>,
+      reply: FastifyReply<RawServerBase>,
+      res: RawReplyDefaultExpression<RawServerBase>
+    ) => void;
+    onError?: (
+      reply: FastifyReply<RawServerBase>,
+      error: { error: Error }
+    ) => void;
+    body?: unknown;
+    rewriteHeaders?: (
+      headers: Http2IncomingHttpHeaders | IncomingHttpHeaders,
+      req?: Http2ServerRequest | IncomingMessage
+    ) => Http2IncomingHttpHeaders | IncomingHttpHeaders;
+    rewriteRequestHeaders?: (
+      req: Http2ServerRequest | IncomingMessage,
+      headers: Http2IncomingHttpHeaders | IncomingHttpHeaders
+    ) => Http2IncomingHttpHeaders | IncomingHttpHeaders;
+    getUpstream?: (
+      req: Http2ServerRequest | IncomingMessage,
+      base: string
+    ) => string;
+  }
+
+  interface Http2Options {
+    sessionTimeout?: number;
+    requestTimeout?: number;
+    sessionOptions?: ClientSessionOptions | SecureClientSessionOptions;
+    requestOptions?: ClientSessionRequestOptions;
+  }
+
+  interface HttpOptions {
+    agentOptions?: AgentOptions | SecureAgentOptions;
+    requestOptions?: RequestOptions | SecureRequestOptions;
+    agents?: { 'http:': Agent, 'https:': SecureAgent }
+  }
+
+  export interface FastifyReplyFromOptions {
+    base?: string;
+    cacheURLs?: number;
+    disableCache?: boolean;
+    http?: HttpOptions;
+    http2?: Http2Options | boolean;
+    undici?: Pool.Options;
+    contentTypesToEncode?: string[];
+    retryMethods?: (HTTPMethods | 'TRACE')[];
+    maxRetriesOn503?: number;
+    disableRequestLogging?: boolean;
+    globalAgent?: boolean;
+  }
 
-export interface FastifyReplyFromOptions {
-  base?: string;
-  cacheURLs?: number;
-  disableCache?: boolean;
-  http?: HttpOptions;
-  http2?: Http2Options | boolean;
-  undici?: Pool.Options;
-  contentTypesToEncode?: string[];
-  retryMethods?: (HTTPMethods | 'TRACE')[];
-  maxRetriesOn503?: number;
-  disableRequestLogging?: boolean;
+  export const fastifyReplyFrom: FastifyReplyFrom
+  export { fastifyReplyFrom as default }
 }
 
-declare const fastifyReplyFrom: FastifyPluginCallback<FastifyReplyFromOptions>;
-export default fastifyReplyFrom;
+declare function fastifyReplyFrom(...params: Parameters<FastifyReplyFrom>): ReturnType<FastifyReplyFrom>
+export = fastifyReplyFrom

package/types/index.test-d.ts

@@ -45,6 +45,7 @@ const fullOptions: FastifyReplyFromOptions = {
   retryMethods: ['GET', 'HEAD', 'OPTIONS', 'TRACE'],
   maxRetriesOn503: 10,
   disableRequestLogging: false,
+  globalAgent: false,
 };
 tap.autoend(false);
 
@@ -60,7 +61,7 @@ async function main() {
   server.register(replyFrom, fullOptions);
 
   server.get("/v1", (request, reply) => {
-      reply.from();
+      expectType<FastifyReply>(reply.from());
   });
   server.get("/v3", (request, reply) => {
       reply.from("/v3", {