@fastify/reply-from 8.3.1 → 8.4.1

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
     }
   }
@@ -216,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

@@ -37,7 +37,8 @@ const fastifyReplyFrom = fp(function from (fastify, opts, next) {
     http: opts.http,
     http2: opts.http2,
     base,
-    undici: opts.undici
+    undici: opts.undici,
+    globalAgent: opts.globalAgent
   })
   if (requestBuilt instanceof Error) {
     next(requestBuilt)
@@ -240,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) {

package/lib/request.js

@@ -5,7 +5,7 @@ const querystring = require('querystring')
 const eos = require('end-of-stream')
 const pump = require('pump')
 const undici = require('undici')
-const { stripHttp1ConnectionHeaders } = require('./utils')
+const { patchUndiciHeaders, stripHttp1ConnectionHeaders } = require('./utils')
 const http2 = require('http2')
 
 const {
@@ -41,6 +41,7 @@ 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
@@ -51,11 +52,16 @@ function buildRequest (opts) {
     if (opts.base.startsWith('unix+')) {
       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()
@@ -146,7 +158,7 @@ function buildRequest (opts) {
       // using delete, otherwise it will render as an empty string
       delete res.headers['transfer-encoding']
 
-      done(null, { statusCode: res.statusCode, headers: res.headers, stream: res.body })
+      done(null, { statusCode: res.statusCode, headers: patchUndiciHeaders(res.headers), stream: res.body })
     })
   }
 

package/lib/utils.js

@@ -12,6 +12,31 @@ function filterPseudoHeaders (headers) {
   return dest
 }
 
+// http requires the header to be encoded with latin1
+// undici will convert the latin1 buffer to utf8
+// https://github.com/nodejs/undici/blob/2b260c997ad4efe4ed2064b264b4b546a59e7a67/lib/core/util.js#L216-L229
+// after chaining, the header will be serialised using wrong encoding
+// Buffer.from('', 'latin1').toString('utf8') applied
+//
+// in order to persist the encoding, always encode it
+// back to latin1
+function patchUndiciHeaders (headers) {
+  const headersKeys = Object.keys(headers)
+  const dist = {}
+
+  let header
+  let i
+
+  for (i = 0; i < headersKeys.length; i++) {
+    header = headersKeys[i]
+    if (header.charCodeAt(0) !== 58) { // fast path for indexOf(':') === 0
+      dist[header] = Buffer.from(headers[header]).toString('latin1')
+    }
+  }
+
+  return dist
+}
+
 function copyHeaders (headers, reply) {
   const headersKeys = Object.keys(headers)
 
@@ -74,6 +99,7 @@ function buildURL (source, reqBase) {
 }
 
 module.exports = {
+  patchUndiciHeaders,
   copyHeaders,
   stripHttp1ConnectionHeaders,
   filterPseudoHeaders,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastify/reply-from",
-  "version": "8.3.1",
+  "version": "8.4.1",
   "description": "forward your HTTP request to another server, for fastify",
   "main": "index.js",
   "types": "types/index.d.ts",
@@ -28,8 +28,8 @@
   },
   "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": "^10.0.0",
     "@types/node": "^18.0.0",
@@ -46,7 +46,7 @@
     "split2": "^4.1.0",
     "standard": "^17.0.0",
     "tap": "^16.2.0",
-    "tsd": "^0.24.1"
+    "tsd": "^0.25.0"
   },
   "dependencies": {
     "@fastify/error": "^3.0.0",

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/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/undici-chaining.js

@@ -0,0 +1,57 @@
+'use strict'
+
+const t = require('tap')
+const Fastify = require('fastify')
+const get = require('simple-get').concat
+const From = require('..')
+
+const header = 'attachment; filename="år.pdf"'
+
+t.plan(6)
+
+const instance = Fastify()
+t.teardown(instance.close.bind(instance))
+const proxy1 = Fastify()
+t.teardown(proxy1.close.bind(proxy1))
+const proxy2 = Fastify()
+t.teardown(proxy2.close.bind(proxy2))
+
+instance.get('/', (request, reply) => {
+  reply.header('content-disposition', header).send('OK')
+})
+
+proxy1.register(From, {
+  undici: {
+    keepAliveMaxTimeout: 10
+  }
+})
+proxy1.get('/', (request, reply) => {
+  return reply.from(`http://localhost:${instance.server.address().port}`)
+})
+
+proxy2.register(From, {
+  undici: {
+    keepAliveMaxTimeout: 10
+  }
+})
+proxy2.get('/', (request, reply) => {
+  return reply.from(`http://localhost:${proxy1.server.address().port}`)
+})
+
+instance.listen({ port: 0 }, err => {
+  t.error(err)
+
+  proxy1.listen({ port: 0 }, err => {
+    t.error(err)
+
+    proxy2.listen({ port: 0 }, err => {
+      t.error(err)
+
+      get(`http://localhost:${proxy2.server.address().port}`, (err, res, data) => {
+        t.error(err)
+        t.equal(res.statusCode, 200)
+        t.equal(data.toString(), 'OK')
+      })
+    })
+  })
+})

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/types/index.d.ts

@@ -95,6 +95,7 @@ declare namespace fastifyReplyFrom {
     retryMethods?: (HTTPMethods | 'TRACE')[];
     maxRetriesOn503?: number;
     disableRequestLogging?: boolean;
+    globalAgent?: boolean;
   }
 
   export const fastifyReplyFrom: 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);