@fastify/reply-from 10.0.0 → 11.0.0

package/.gitattributes

@@ -0,0 +1,2 @@
+# Set default behavior to automatically convert line endings
+* text=auto eol=lf

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@v5.0.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

@@ -14,7 +14,7 @@ npm i @fastify/reply-from
 ```
 
 ## Compatibility with @fastify/multipart
-`@fastify/reply-from` and [`@fastify/multipart`](https://github.com/fastify/fastify-multipart) should not be registered as sibling plugins nor should they be registered in plugins which have a parent-child relationship.<br> The two plugins are incompatible, in the sense that the behavior of `@fastify/reply-from` might not be the expected one when the above-mentioned conditions are not respected.<br> This is due to the fact that `@fastify/multipart` consumes the multipart content by parsing it, hence this content is not forwarded to the target service by `@fastify/reply-from`.<br>
+`@fastify/reply-from` and [`@fastify/multipart`](https://github.com/fastify/fastify-multipart) should not be registered as sibling plugins nor should they be registered in plugins which have a parent-child relationship.`<br>` The two plugins are incompatible, in the sense that the behavior of `@fastify/reply-from` might not be the expected one when the above-mentioned conditions are not respected.`<br>` This is due to the fact that `@fastify/multipart` consumes the multipart content by parsing it, hence this content is not forwarded to the target service by `@fastify/reply-from`.`<br>`
 However, the two plugins may be used within the same fastify instance, at the condition that they belong to disjoint branches of the fastify plugins hierarchy tree.
 
 ## Usage
@@ -74,7 +74,7 @@ socket server by using `querystring.escape(socketPath)` as the hostname.  This i
 for http2 nor undici.  To illustrate:
 
 ```js
-const socketPath = require('querystring').escape('/run/http-daemon.socket')
+const socketPath = require('node:querystring').escape('/run/http-daemon.socket')
 proxy.register(require('@fastify/reply-from'), {
   base: 'unix+http://${socketPath}/'
 });
@@ -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:
@@ -115,7 +127,7 @@ proxy.register(require('@fastify/reply-from'), {
 
 #### `http`
 
-Set the `http` option to an Object to use 
+Set the `http` option to an Object to use
 Node's [`http.request`](https://nodejs.org/api/http.html#http_http_request_options_callback)
 will be used if you do not enable [`http2`](#http2). To customize the `request`,
 you can pass in [`agentOptions`](https://nodejs.org/api/http.html#http_new_agent_options) and
@@ -136,6 +148,7 @@ proxy.register(require('@fastify/reply-from'), {
 ```
 
 You can also pass custom HTTP agents. If you pass the agents, then the http.agentOptions will be ignored. To illustrate:
+
 ```js
 proxy.register(require('@fastify/reply-from'), {
   base: 'http://localhost:3001/',
@@ -192,27 +205,27 @@ The number of parsed URLs that will be cached. Default: `100`.
 
 #### `disableCache`
 
-This option will disable the URL caching. 
+This option will disable the URL caching.
 This cache is dedicated to reduce the amount of URL object generation.
 Generating URLs is a main bottleneck of this module, please disable this cache with caution.
 
 #### `contentTypesToEncode`
 
-An array of content types whose response body will be passed through `JSON.stringify()`. 
+An array of content types whose response body will be passed through `JSON.stringify()`.
 This only applies when a custom [`body`](#body) is not passed in. Defaults to:
 
 ```js
-[ 
+[
   'application/json'
 ]
 ```
 
 #### `retryMethods`
 
-On which methods should the connection be retried in case of socket hang up.  
+On which methods should the connection be retried in case of socket hang up.
 **Be aware** that setting here not idempotent method may lead to unexpected results on target.
 
-By default: `['GET', 'HEAD', 'OPTIONS', 'TRACE' ]`
+By default: `['GET', 'HEAD', 'OPTIONS', 'TRACE']`
 
 This plugin will always retry on 503 errors, _unless_ `retryMethods` does not contain `GET`.
 
@@ -221,6 +234,7 @@ This plugin will always retry on 503 errors, _unless_ `retryMethods` does not co
 Enables the possibility to explictly opt-in for global agents.
 
 Usage for undici global agent:
+
 ```js
 import { setGlobalDispatcher, ProxyAgent } from 'undici'
 
@@ -234,11 +248,12 @@ fastify.register(FastifyReplyFrom, {
 ```
 
 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, 
+  globalAgent: true,
   http: {
   }
 })
@@ -246,6 +261,15 @@ fastify.register(FastifyReplyFrom, {
 
 ---
 
+#### `destroyAgent`
+
+If set to `true`, it will destroy all agents when the Fastify is closed.
+If set to `false`, it will not destroy the agents.
+
+By Default: `false`
+
+---
+
 #### `maxRetriesOn503`
 
 This plugin will always retry on `GET` requests that returns 503 errors, _unless_ `retryMethods` does not contain `GET`.
@@ -254,23 +278,77 @@ This option set the limit on how many times the plugin should retry the request,
 
 By Default: 10
 
+---
+
+### `retryDelay`
+
+- `handler`. Required
+
+This plugin gives the client an option to pass their own retry callback to allow the client to define what retryDelay they would like on any retries
+outside the scope of what is handled by default in fastify-reply-from. To see the default please refer to index.js `getDefaultDelay()`
+If a `handler` is passed to the `retryDelay` object the onus is on the client to invoke the default retry logic in their callback otherwise default cases such as 500 will not be handled
+
+- `err` is the error thrown by making a request using whichever agent is configured
+- `req` is the raw request details sent to the underlying agent. __Note__: this object is not a Fastify request object, but instead the low-level request for the agent.
+- `res` is the raw response returned by the underlying agent (if available) __Note__: this object is not a Fastify response, but instead the low-level response from the agent. This property may be null if no response was obtained at all, like from a connection reset or timeout.
+- `attempt` in the object callback refers to the current retriesAttempt number. You are given the freedom to use this in concert with the retryCount property set to handle retries
+- `getDefaultRetry` refers to the default retry handler. If this callback returns not null and you wish to handle those case of errors simply invoke it as done below.
+- `retriesCount` refers to the retriesCount property a client passes to reply-from. Note if the client does not explicitly set this value it will default to 0. The objective value here is to avoid hard-coding and seeing the retriesCount set. It is your perogative to ensure that you ensure the value here is as you wish (and not `0` if not intended to be as a result of a lack of not setting it).
+
+Given example
+
+```js
+   const customRetryLogic = ({err, req, res, attempt, getDefaultRetry}) => {
+    //If this block is not included all non 500 errors will not be retried
+    const defaultDelay = getDefaultDelay();
+    if (defaultDelay) return defaultDelay();
+
+    //Custom retry logic
+    if (res && res.statusCode === 500 && req.method === 'GET') {
+      return 300
+    }
+
+    if (err && err.code == "UND_ERR_SOCKET"){
+      return 600
+    }
+
+    return null
+  }
+
+.......
+
+fastify.register(FastifyReplyFrom, {
+  base: 'http://localhost:3001/',
+  retryDelay: customRetryLogic
+})
+
+```
+
+Note the Typescript Equivalent
+```
+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
@@ -285,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.
@@ -319,6 +399,7 @@ ContraintStrategies.
 e.g.:
 
 Route grpc-web/http1 and grpc/http2 to different routes with a ContentType-ConstraintStrategy:
+
 ```
 const contentTypeMatchContraintStrategy = {
     // strategy name for referencing in the route handler `constraints` options
@@ -332,17 +413,18 @@ const contentTypeMatchContraintStrategy = {
       }
     },
     // function to get the value of the constraint from each incoming request
-    deriveConstraint: (req: any, ctx: any) => { 
+    deriveConstraint: (req: any, ctx: any) => {
       return req.headers['content-type']
     },
     // optional flag marking if handlers without constraints can match requests that have a value for this constraint
     mustMatchWhenDerived: true
   }
- 
+
   server.addConstraintStrategy(contentTypeMatchContraintStrategy);
 ```
 
 and then 2 different upstreams with different register's:
+
 ```
 // grpc-web / http1
 server.register(fastifyHttpProxy, {
@@ -350,19 +432,18 @@ server.register(fastifyHttpProxy, {
     // therefore we have to transport to the grpc-web-proxy via http1
     http2: false,
     upstream: 'http://grpc-web-proxy',
-    constraints: { "contentType": "application/grpc-web+proto" }   
+    constraints: { "contentType": "application/grpc-web+proto" }
 });
 
 // grpc / http2
 server.register(fastifyHttpProxy, {
     http2: true,
     upstream: 'http://grpc.server',
-    constraints: { "contentType": "application/grpc+proto" }   
+    constraints: { "contentType": "application/grpc+proto" }
 });
 ```
 
-
-#### `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
@@ -379,10 +460,14 @@ through `JSON.stringify()`.
 Setting this option for GET, HEAD requests will throw an error "Rewriting the body when doing a {GET|HEAD} is not allowed".
 Setting this option to `null` will strip the body (and `content-type` header) entirely from the proxied request.
 
+#### `method`
+
+Replaces the original request method with what is specified.
+
 #### `retriesCount`
 
-How many times it will try to pick another connection on socket hangup (`ECONNRESET` error).  
-Useful when keeping the connection open (KeepAlive).  
+How many times it will try to pick another connection on socket hangup (`ECONNRESET` error).
+Useful when keeping the connection open (KeepAlive).
 This number should be a function of the number of connections and the number of instances of a target.
 
 By default: 0 (disabled)
@@ -394,17 +479,17 @@ already overriding the [`body`](#body).
 
 ### Combining with [@fastify/formbody](https://github.com/fastify/fastify-formbody)
 
-`formbody` expects the body to be returned as a string and not an object. 
+`formbody` expects the body to be returned as a string and not an object.
 Use the [`contentTypesToEncode`](#contentTypesToEncode) option to pass in `['application/x-www-form-urlencoded']`
 
-
 ### HTTP & HTTP2 timeouts
 
 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.
@@ -413,10 +498,10 @@ will be returned to the client.
 
 * [ ] support overriding the body with a stream
 * [ ] forward the request id to the other peer might require some
-      refactoring because we have to make the `req.id` unique
-      (see [hyperid](https://npm.im/hyperid)).
+  refactoring because we have to make the `req.id` unique
+  (see [hyperid](https://npm.im/hyperid)).
 * [ ] Support origin HTTP2 push
-* [x] benchmarks
+* [X] benchmarks
 
 ## License
 

package/index.js

@@ -1,9 +1,10 @@
 'use strict'
 
 const fp = require('fastify-plugin')
-const { lru } = require('tiny-lru')
+const { LruMap } = require('toad-cache')
 const querystring = require('fast-querystring')
-const Stream = require('stream')
+const fastContentTypeParse = require('fast-content-type-parse')
+const Stream = require('node:stream')
 const buildRequest = require('./lib/request')
 const {
   filterPseudoHeaders,
@@ -29,17 +30,18 @@ const fastifyReplyFrom = fp(function from (fastify, opts, next) {
   ])
 
   const retryMethods = new Set(opts.retryMethods || [
-    'GET', 'HEAD', 'OPTIONS', 'TRACE'
-  ])
+    '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
+    globalAgent: opts.globalAgent,
+    destroyAgent: opts.destroyAgent
   })
   if (requestBuilt instanceof Error) {
     next(requestBuilt)
@@ -51,6 +53,7 @@ const fastifyReplyFrom = fp(function from (fastify, opts, next) {
   fastify.decorateReply('from', function (source, opts) {
     opts = opts || {}
     const req = this.request.raw
+    const method = opts.method || req.method
     const onResponse = opts.onResponse
     const rewriteHeaders = opts.rewriteHeaders || headersNoOp
     const rewriteRequestHeaders = opts.rewriteRequestHeaders || requestHeadersNoOp
@@ -58,6 +61,7 @@ const fastifyReplyFrom = fp(function from (fastify, opts, next) {
     const onError = opts.onError || onErrorDefault
     const retriesCount = opts.retriesCount || 0
     const maxRetriesOn503 = opts.maxRetriesOn503 || 10
+    const retryDelay = opts.retryDelay || undefined
 
     if (!source) {
       source = req.url
@@ -77,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) {
@@ -105,15 +109,13 @@ const fastifyReplyFrom = fp(function from (fastify, opts, next) {
         body = this.request.body
       } else {
         // Per RFC 7231 §3.1.1.5 if this header is not present we MAY assume application/octet-stream
-        const contentType = req.headers['content-type'] || 'application/octet-stream'
-        // detect if body should be encoded as JSON
-        // supporting extended content-type header formats:
-        // - https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Type
-        const lowerCaseContentType = contentType.toLowerCase()
-        const plainContentType = lowerCaseContentType.indexOf(';') > -1
-          ? lowerCaseContentType.slice(0, lowerCaseContentType.indexOf(';'))
-          : lowerCaseContentType
-        const shouldEncodeJSON = contentTypesToEncode.has(plainContentType)
+        let contentType = 'application/octet-stream'
+        if (req.headers['content-type']) {
+          const plainContentType = fastContentTypeParse.parse(req.headers['content-type'])
+          contentType = plainContentType.type
+        }
+
+        const shouldEncodeJSON = contentTypesToEncode.has(contentType)
         // transparently support JSON encoding
         body = shouldEncodeJSON ? JSON.stringify(this.request.body) : this.request.body
         // update origin request headers after encoding
@@ -126,12 +128,12 @@ const fastifyReplyFrom = fp(function from (fastify, opts, next) {
     // 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
-    if (req.method === 'GET' || req.method === 'HEAD') {
+    if (method === 'GET' || method === 'HEAD') {
       // body will be populated here only if opts.body is passed.
       // if we are doing that with a GET or HEAD request is a programmer error
       // and as such we can throw immediately.
       if (body) {
-        throw new Error(`Rewriting the body when doing a ${req.method} is not allowed`)
+        throw new Error(`Rewriting the body when doing a ${method} is not allowed`)
       }
     }
 
@@ -140,13 +142,35 @@ const fastifyReplyFrom = fp(function from (fastify, opts, next) {
     const requestHeaders = rewriteRequestHeaders(this.request, headers)
     const contentLength = requestHeaders['content-length']
     let requestImpl
-    if (retryMethods.has(req.method) && !contentLength) {
-      requestImpl = createRequestRetry(request, this, retriesCount, retryOnError, maxRetriesOn503)
+
+    const getDefaultDelay = (req, res, err, retries) => {
+      if (retryMethods.has(method) && !contentLength) {
+        // Magic number, so why not 42? We might want to make this configurable.
+        let retryAfter = 42 * Math.random() * (retries + 1)
+
+        if (res && res.headers['retry-after']) {
+          retryAfter = res.headers['retry-after']
+        }
+        if (res && res.statusCode === 503 && req.method === 'GET') {
+          if (retriesCount === 0 && retries < maxRetriesOn503) {
+            return retryAfter
+          }
+        } else if (retriesCount > retries && err && err.code === retryOnError) {
+          return retryAfter
+        }
+      }
+      return null
+    }
+
+    if (retryDelay) {
+      requestImpl = createRequestRetry(request, this, (req, res, err, retries) => {
+        return retryDelay({ err, req, res, attempt: retries, getDefaultDelay, retriesCount })
+      })
     } else {
-      requestImpl = request
+      requestImpl = createRequestRetry(request, this, getDefaultDelay)
     }
 
-    requestImpl({ method: req.method, url, qs, headers: requestHeaders, body }, (err, res) => {
+    requestImpl({ method, url, qs, headers: requestHeaders, body }, (err, res) => {
       if (err) {
         this.request.log.warn(err, 'response errored')
         if (!this.sent) {
@@ -177,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)
       }
@@ -198,16 +222,15 @@ const fastifyReplyFrom = fp(function from (fastify, opts, next) {
     // actually destroy those sockets
     setImmediate(next)
   })
-
   next()
 }, {
-  fastify: '4.x',
+  fastify: '5.x',
   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) {
@@ -244,33 +267,18 @@ 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, retriesCount, retryOnError, maxRetriesOn503) {
+function createRequestRetry (requestImpl, reply, retryHandler) {
   function requestRetry (req, cb) {
     let retries = 0
 
     function run () {
       requestImpl(req, function (err, res) {
-        // Magic number, so why not 42? We might want to make this configurable.
-        let retryAfter = 42 * Math.random() * (retries + 1)
-
-        if (res && res.headers['retry-after']) {
-          retryAfter = res.headers['retry-after']
-        }
-        if (!reply.sent) {
-          // always retry on 503 errors
-          if (res && res.statusCode === 503 && req.method === 'GET') {
-            if (retriesCount === 0 && retries < maxRetriesOn503) {
-              // we should stop at some point
-              return retry(retryAfter)
-            }
-          } else if (retriesCount > retries && err && err.code === retryOnError) {
-            return retry(retryAfter)
-          }
+        const retryDelay = retryHandler(req, res, err, retries)
+        if (!reply.sent && retryDelay) {
+          return retry(retryDelay)
         }
         cb(err, res)
       })

package/lib/request.js

@@ -1,12 +1,12 @@
 'use strict'
-const http = require('http')
-const https = require('https')
-const querystring = require('querystring')
+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('http2')
+const http2 = require('node:http2')
 
 const {
   TimeoutError,
@@ -22,10 +22,17 @@ function shouldUseUndici (opts) {
   return true
 }
 
+function isRequestable (obj) {
+  return obj !== null &&
+    typeof obj === 'object' &&
+    typeof obj.request === 'function'
+}
+
 function isUndiciInstance (obj) {
   return obj instanceof undici.Pool ||
     obj instanceof undici.Client ||
-    obj instanceof undici.Dispatcher
+    obj instanceof undici.Dispatcher ||
+    isRequestable(obj)
 }
 
 function buildRequest (opts) {
@@ -42,6 +49,7 @@ function buildRequest (opts) {
   const baseUrl = opts.base && new URL(opts.base).origin
   const undiciOpts = opts.undici || {}
   const globalAgent = opts.globalAgent
+  const destroyAgent = opts.destroyAgent
   let http2Client
   let undiciAgent
   let undiciInstance
@@ -75,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()
     }
@@ -85,7 +97,7 @@ function buildRequest (opts) {
   }
 
   function close () {
-    if (globalAgent) {
+    if (globalAgent || destroyAgent === false) {
       return
     }
 
@@ -196,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, () => {
@@ -240,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 {
@@ -259,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
@@ -295,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,