deps: update undici to v5.28.4

Signed-off-by: Matteo Collina <hello@matteocollina.com>

PR-URL: nodejs-private/node-private#577
Reviewed-By: Rafael Gonzaga <rafael.nunu@hotmail.com>

Author: mcollina

deps/undici/src/README.md

@@ -18,30 +18,34 @@ npm i undici
 ## Benchmarks
 
 The benchmark is a simple `hello world` [example](benchmarks/benchmark.js) using a
-number of unix sockets (connections) with a pipelining depth of 10 running on Node 16.
-The benchmarks below have the [simd](https://github.com/WebAssembly/simd) feature enabled.
+number of unix sockets (connections) with a pipelining depth of 10 running on Node 20.6.0.
 
 ### Connections 1
 
+
 | Tests               | Samples |        Result | Tolerance | Difference with slowest |
 |---------------------|---------|---------------|-----------|-------------------------|
-| http - no keepalive |      15 |  4.63 req/sec |  ± 2.77 % |                       - |
-| http - keepalive    |      10 |  4.81 req/sec |  ± 2.16 % |                + 3.94 % |
-| undici - stream     |      25 | 62.22 req/sec |  ± 2.67 % |             + 1244.58 % |
-| undici - dispatch   |      15 | 64.33 req/sec |  ± 2.47 % |             + 1290.24 % |
-| undici - request    |      15 | 66.08 req/sec |  ± 2.48 % |             + 1327.88 % |
-| undici - pipeline   |      10 | 66.13 req/sec |  ± 1.39 % |             + 1329.08 % |
+| http - no keepalive |      15 |  5.32 req/sec |  ± 2.61 % |                       - |
+| http - keepalive    |      10 |  5.35 req/sec |  ± 2.47 % |                + 0.44 % |
+| undici - fetch      |      15 | 41.85 req/sec |  ± 2.49 % |              + 686.04 % |
+| undici - pipeline   |      40 | 50.36 req/sec |  ± 2.77 % |              + 845.92 % |
+| undici - stream     |      15 | 60.58 req/sec |  ± 2.75 % |             + 1037.72 % |
+| undici - request    |      10 | 61.19 req/sec |  ± 2.60 % |             + 1049.24 % |
+| undici - dispatch   |      20 | 64.84 req/sec |  ± 2.81 % |             + 1117.81 % |
+
 
 ### Connections 50
 
 | Tests               | Samples |           Result | Tolerance | Difference with slowest |
 |---------------------|---------|------------------|-----------|-------------------------|
-| http - no keepalive |      50 |  3546.49 req/sec |  ± 2.90 % |                       - |
-| http - keepalive    |      15 |  5692.67 req/sec |  ± 2.48 % |               + 60.52 % |
-| undici - pipeline   |      25 |  8478.71 req/sec |  ± 2.62 % |              + 139.07 % |
-| undici - request    |      20 |  9766.66 req/sec |  ± 2.79 % |              + 175.39 % |
-| undici - stream     |      15 | 10109.74 req/sec |  ± 2.94 % |              + 185.06 % |
-| undici - dispatch   |      25 | 10949.73 req/sec |  ± 2.54 % |              + 208.75 % |
+| undici - fetch      |      30 |  2107.19 req/sec |  ± 2.69 % |                       - |
+| http - no keepalive |      10 |  2698.90 req/sec |  ± 2.68 % |               + 28.08 % |
+| http - keepalive    |      10 |  4639.49 req/sec |  ± 2.55 % |              + 120.17 % |
+| undici - pipeline   |      40 |  6123.33 req/sec |  ± 2.97 % |              + 190.59 % |
+| undici - stream     |      50 |  9426.51 req/sec |  ± 2.92 % |              + 347.35 % |
+| undici - request    |      10 | 10162.88 req/sec |  ± 2.13 % |              + 382.29 % |
+| undici - dispatch   |      50 | 11191.11 req/sec |  ± 2.98 % |              + 431.09 % |
+
 
 ## Quick Start
 
@@ -432,6 +436,7 @@ and `undici.Agent`) which will enable the family autoselection algorithm when es
 * [__Ethan Arrowood__](https://github.com/ethan-arrowood), <https://www.npmjs.com/~ethan_arrowood>
 * [__Matteo Collina__](https://github.com/mcollina), <https://www.npmjs.com/~matteo.collina>
 * [__Robert Nagy__](https://github.com/ronag), <https://www.npmjs.com/~ronag>
+* [__Matthew Aitken__](https://github.com/KhafraDev), <https://www.npmjs.com/~khaf>
 
 ## License
 

deps/undici/src/docs/api/Client.md

@@ -33,7 +33,7 @@ Returns: `Client`
 * **autoSelectFamily**: `boolean` (optional) - Default: depends on local Node version, on Node 18.13.0 and above is `false`. Enables a family autodetection algorithm that loosely implements section 5 of [RFC 8305](https://tools.ietf.org/html/rfc8305#section-5). See [here](https://nodejs.org/api/net.html#socketconnectoptions-connectlistener) for more details. This option is ignored if not supported by the current Node version.
 * **autoSelectFamilyAttemptTimeout**: `number` - Default: depends on local Node version, on Node 18.13.0 and above is `250`. The amount of time in milliseconds to wait for a connection attempt to finish before trying the next address when using the `autoSelectFamily` option. See [here](https://nodejs.org/api/net.html#socketconnectoptions-connectlistener) for more details.
 * **allowH2**: `boolean` - Default: `false`. Enables support for H2 if the server has assigned bigger priority to it through ALPN negotiation.
-* **maxConcurrentStreams**: `number` - Default: `100`. Dictates the maximum number of concurrent streams for a single H2 session. It can be overriden by a SETTINGS remote frame.
+* **maxConcurrentStreams**: `number` - Default: `100`. Dictates the maximum number of concurrent streams for a single H2 session. It can be overridden by a SETTINGS remote frame.
 
 #### Parameter: `ConnectOptions`
 

deps/undici/src/docs/api/Connector.md

@@ -13,8 +13,8 @@ Every Tls option, see [here](https://nodejs.org/api/tls.html#tls_tls_connect_opt
 Furthermore, the following options can be passed:
 
 * **socketPath** `string | null` (optional) - Default: `null` - An IPC endpoint, either Unix domain socket or Windows named pipe.
-* **maxCachedSessions** `number | null` (optional) - Default: `100` - Maximum number of TLS cached sessions. Use 0 to disable TLS session caching. Default: 100.
-* **timeout** `number | null` (optional) -  Default `10e3`
+* **maxCachedSessions** `number | null` (optional) - Default: `100` - Maximum number of TLS cached sessions. Use 0 to disable TLS session caching. Default: `100`.
+* **timeout** `number | null` (optional) -  In milliseconds. Default `10e3`.
 * **servername** `string | null` (optional)
 
 Once you call `buildConnector`, it will return a connector function, which takes the following parameters.

deps/undici/src/docs/api/Dispatcher.md

@@ -200,8 +200,9 @@ Returns: `Boolean` - `false` if dispatcher is busy and further dispatch calls wo
 * **blocking** `boolean` (optional) - Default: `false` - Whether the response is expected to take a long time and would end up blocking the pipeline. When this is set to `true` further pipelining will be avoided on the same connection until headers have been received.
 * **upgrade** `string | null` (optional) - Default: `null` - Upgrade the request. Should be used to specify the kind of upgrade i.e. `'Websocket'`.
 * **bodyTimeout** `number | null` (optional) - The timeout after which a request will time out, in milliseconds. Monitors time between receiving body data. Use `0` to disable it entirely. Defaults to 300 seconds.
-* **headersTimeout** `number | null` (optional) - The amount of time the parser will wait to receive the complete HTTP headers while not sending the request. Defaults to 300 seconds.
+* **headersTimeout** `number | null` (optional) - The amount of time, in milliseconds, the parser will wait to receive the complete HTTP headers while not sending the request. Defaults to 300 seconds.
 * **throwOnError** `boolean` (optional) - Default: `false` - Whether Undici should throw an error upon receiving a 4xx or 5xx response from the server.
+* **expectContinue** `boolean` (optional) - Default: `false` - For H2, it appends the expect: 100-continue header, and halts the request body until a 100-continue is received from the remote server
 
 #### Parameter: `DispatchHandler`
 

deps/undici/src/docs/api/MockPool.md

@@ -35,7 +35,7 @@ const mockPool = mockAgent.get('http://localhost:3000')
 
 ### `MockPool.intercept(options)`
 
-This method defines the interception rules for matching against requests for a MockPool or MockPool. We can intercept multiple times on a single instance.
+This method defines the interception rules for matching against requests for a MockPool or MockPool. We can intercept multiple times on a single instance, but each intercept is only used once. For example if you expect to make 2 requests inside a test, you need to call `intercept()` twice. Assuming you use `disableNetConnect()` you will get `MockNotMatchedError` on the second request when you only call `intercept()` once.
 
 When defining interception rules, all the rules must pass for a request to be intercepted. If a request is not intercepted, a real request will be attempted.
 
@@ -53,11 +53,11 @@ Returns: `MockInterceptor` corresponding to the input options.
 
 ### Parameter: `MockPoolInterceptOptions`
 
-* **path** `string | RegExp | (path: string) => boolean` - a matcher for the HTTP request path.
+* **path** `string | RegExp | (path: string) => boolean` - a matcher for the HTTP request path. When a `RegExp` or callback is used, it will match against the request path including all query parameters in alphabetical order. When a `string` is provided, the query parameters can be conveniently specified through the `MockPoolInterceptOptions.query` setting.
 * **method** `string | RegExp | (method: string) => boolean` - (optional) - a matcher for the HTTP request method. Defaults to `GET`.
 * **body** `string | RegExp | (body: string) => boolean` - (optional) - a matcher for the HTTP request body.
 * **headers** `Record<string, string | RegExp | (body: string) => boolean`> - (optional) - a matcher for the HTTP request headers. To be intercepted, a request must match all defined headers. Extra headers not defined here may (or may not) be included in the request and do not affect the interception in any way.
-* **query** `Record<string, any> | null` - (optional) - a matcher for the HTTP request query string params.
+* **query** `Record<string, any> | null` - (optional) - a matcher for the HTTP request query string params. Only applies when a `string` was provided for `MockPoolInterceptOptions.path`.
 
 ### Return: `MockInterceptor`
 
@@ -457,6 +457,41 @@ const result3 = await request('http://localhost:3000/foo')
 // Will not match and make attempt a real request
 ```
 
+#### Example - Mocked request with path callback
+
+```js
+import { MockAgent, setGlobalDispatcher, request } from 'undici'
+import querystring from 'querystring'
+
+const mockAgent = new MockAgent()
+setGlobalDispatcher(mockAgent)
+
+const mockPool = mockAgent.get('http://localhost:3000')
+
+const matchPath = requestPath => {
+  const [pathname, search] = requestPath.split('?')
+  const requestQuery = querystring.parse(search)
+
+  if (!pathname.startsWith('/foo')) {
+    return false
+  }
+
+  if (!Object.keys(requestQuery).includes('foo') || requestQuery.foo !== 'bar') {
+    return false
+  }
+
+  return true
+}
+
+mockPool.intercept({
+  path: matchPath,
+  method: 'GET'
+}).reply(200, 'foo')
+
+const result = await request('http://localhost:3000/foo?foo=bar')
+// Will match and return mocked data
+```
+
 ### `MockPool.close()`
 
 Closes the mock pool and de-registers from associated MockAgent.

deps/undici/src/docs/api/ProxyAgent.md

@@ -19,7 +19,9 @@ Extends: [`AgentOptions`](Agent.md#parameter-agentoptions)
 * **uri** `string` (required) - It can be passed either by a string or a object containing `uri` as string.
 * **token** `string` (optional) - It can be passed by a string of token for authentication.
 * **auth** `string` (**deprecated**) - Use token.
-* **clientFactory** `(origin: URL, opts: Object) => Dispatcher` - Default: `(origin, opts) => new Pool(origin, opts)`
+* **clientFactory** `(origin: URL, opts: Object) => Dispatcher` (optional) - Default: `(origin, opts) => new Pool(origin, opts)`
+* **requestTls** `BuildOptions` (optional) - Options object passed when creating the underlying socket via the connector builder for the request. See [TLS](https://nodejs.org/api/tls.html#tlsconnectoptions-callback).
+* **proxyTls** `BuildOptions` (optional) - Options object passed when creating the underlying socket via the connector builder for the proxy server. See [TLS](https://nodejs.org/api/tls.html#tlsconnectoptions-callback).
 
 Examples:
 

deps/undici/src/docs/api/RetryHandler.md

@@ -0,0 +1,108 @@
+# Class: RetryHandler
+
+Extends: `undici.DispatcherHandlers`
+
+A handler class that implements the retry logic for a request.
+
+## `new RetryHandler(dispatchOptions, retryHandlers, [retryOptions])`
+
+Arguments:
+
+- **options** `Dispatch.DispatchOptions & RetryOptions` (required) - It is an intersection of `Dispatcher.DispatchOptions` and `RetryOptions`.
+- **retryHandlers** `RetryHandlers` (required) - Object containing the `dispatch` to be used on every retry, and `handler` for handling the `dispatch` lifecycle.
+
+Returns: `retryHandler`
+
+### Parameter: `Dispatch.DispatchOptions & RetryOptions`
+
+Extends: [`Dispatch.DispatchOptions`](Dispatcher.md#parameter-dispatchoptions).
+
+#### `RetryOptions`
+
+- **retry** `(err: Error, context: RetryContext, callback: (err?: Error | null) => void) => void` (optional) - Function to be called after every retry. It should pass error if no more retries should be performed.
+- **maxRetries** `number` (optional) - Maximum number of retries. Default: `5`
+- **maxTimeout** `number` (optional) - Maximum number of milliseconds to wait before retrying. Default: `30000` (30 seconds)
+- **minTimeout** `number` (optional) - Minimum number of milliseconds to wait before retrying. Default: `500` (half a second)
+- **timeoutFactor** `number` (optional) - Factor to multiply the timeout by for each retry attempt. Default: `2`
+- **retryAfter** `boolean` (optional) - It enables automatic retry after the `Retry-After` header is received. Default: `true`
+-
+- **methods** `string[]` (optional) - Array of HTTP methods to retry. Default: `['GET', 'PUT', 'HEAD', 'OPTIONS', 'DELETE']`
+- **statusCodes** `number[]` (optional) - Array of HTTP status codes to retry. Default: `[429, 500, 502, 503, 504]`
+- **errorCodes** `string[]` (optional) - Array of Error codes to retry. Default: `['ECONNRESET', 'ECONNREFUSED', 'ENOTFOUND', 'ENETDOWN','ENETUNREACH', 'EHOSTDOWN',
+
+**`RetryContext`**
+
+- `state`: `RetryState` - Current retry state. It can be mutated.
+- `opts`: `Dispatch.DispatchOptions & RetryOptions` - Options passed to the retry handler.
+
+### Parameter `RetryHandlers`
+
+- **dispatch** `(options: Dispatch.DispatchOptions, handlers: Dispatch.DispatchHandlers) => Promise<Dispatch.DispatchResponse>` (required) - Dispatch function to be called after every retry.
+- **handler** Extends [`Dispatch.DispatchHandlers`](Dispatcher.md#dispatcherdispatchoptions-handler) (required) - Handler function to be called after the request is successful or the retries are exhausted.
+
+Examples:
+
+```js
+const client = new Client(`http://localhost:${server.address().port}`);
+const chunks = [];
+const handler = new RetryHandler(
+  {
+    ...dispatchOptions,
+    retryOptions: {
+      // custom retry function
+      retry: function (err, state, callback) {
+        counter++;
+
+        if (err.code && err.code === "UND_ERR_DESTROYED") {
+          callback(err);
+          return;
+        }
+
+        if (err.statusCode === 206) {
+          callback(err);
+          return;
+        }
+
+        setTimeout(() => callback(null), 1000);
+      },
+    },
+  },
+  {
+    dispatch: (...args) => {
+      return client.dispatch(...args);
+    },
+    handler: {
+      onConnect() {},
+      onBodySent() {},
+      onHeaders(status, _rawHeaders, resume, _statusMessage) {
+        // do something with headers
+      },
+      onData(chunk) {
+        chunks.push(chunk);
+        return true;
+      },
+      onComplete() {},
+      onError() {
+        // handle error properly
+      },
+    },
+  }
+);
+```
+
+#### Example - Basic RetryHandler with defaults
+
+```js
+const client = new Client(`http://localhost:${server.address().port}`);
+const handler = new RetryHandler(dispatchOptions, {
+  dispatch: client.dispatch.bind(client),
+  handler: {
+    onConnect() {},
+    onBodySent() {},
+    onHeaders(status, _rawHeaders, resume, _statusMessage) {},
+    onData(chunk) {},
+    onComplete() {},
+    onError(err) {},
+  },
+});
+```

deps/undici/src/index-fetch.js

@@ -2,15 +2,14 @@
 
 const fetchImpl = require('./lib/fetch').fetch
 
-module.exports.fetch = async function fetch (resource) {
-  try {
-    return await fetchImpl(...arguments)
-  } catch (err) {
+module.exports.fetch = function fetch (resource, init = undefined) {
+  return fetchImpl(resource, init).catch((err) => {
     Error.captureStackTrace(err, this)
     throw err
-  }
+  })
 }
 module.exports.FormData = require('./lib/fetch/formdata').FormData
 module.exports.Headers = require('./lib/fetch/headers').Headers
 module.exports.Response = require('./lib/fetch/response').Response
 module.exports.Request = require('./lib/fetch/request').Request
+module.exports.WebSocket = require('./lib/websocket/websocket').WebSocket

deps/undici/src/index.d.ts

@@ -1,57 +1,3 @@
-import Dispatcher from'./types/dispatcher'
-import { setGlobalDispatcher, getGlobalDispatcher } from './types/global-dispatcher'
-import { setGlobalOrigin, getGlobalOrigin } from './types/global-origin'
-import Pool from'./types/pool'
-import { RedirectHandler, DecoratorHandler } from './types/handlers'
-
-import BalancedPool from './types/balanced-pool'
-import Client from'./types/client'
-import buildConnector from'./types/connector'
-import errors from'./types/errors'
-import Agent from'./types/agent'
-import MockClient from'./types/mock-client'
-import MockPool from'./types/mock-pool'
-import MockAgent from'./types/mock-agent'
-import mockErrors from'./types/mock-errors'
-import ProxyAgent from'./types/proxy-agent'
-import { request, pipeline, stream, connect, upgrade } from './types/api'
-
-export * from './types/cookies'
-export * from './types/fetch'
-export * from './types/file'
-export * from './types/filereader'
-export * from './types/formdata'
-export * from './types/diagnostics-channel'
-export * from './types/websocket'
-export * from './types/content-type'
-export * from './types/cache'
-export { Interceptable } from './types/mock-interceptor'
-
-export { Dispatcher, BalancedPool, Pool, Client, buildConnector, errors, Agent, request, stream, pipeline, connect, upgrade, setGlobalDispatcher, getGlobalDispatcher, setGlobalOrigin, getGlobalOrigin, MockClient, MockPool, MockAgent, mockErrors, ProxyAgent, RedirectHandler, DecoratorHandler }
+export * from './types/index'
+import Undici from './types/index'
 export default Undici
-
-declare namespace Undici {
-  var Dispatcher: typeof import('./types/dispatcher').default
-  var Pool: typeof import('./types/pool').default;
-  var RedirectHandler: typeof import ('./types/handlers').RedirectHandler
-  var DecoratorHandler: typeof import ('./types/handlers').DecoratorHandler
-  var createRedirectInterceptor: typeof import ('./types/interceptors').createRedirectInterceptor
-  var BalancedPool: typeof import('./types/balanced-pool').default;
-  var Client: typeof import('./types/client').default;
-  var buildConnector: typeof import('./types/connector').default;
-  var errors: typeof import('./types/errors').default;
-  var Agent: typeof import('./types/agent').default;
-  var setGlobalDispatcher: typeof import('./types/global-dispatcher').setGlobalDispatcher;
-  var getGlobalDispatcher: typeof import('./types/global-dispatcher').getGlobalDispatcher;
-  var request: typeof import('./types/api').request;
-  var stream: typeof import('./types/api').stream;
-  var pipeline: typeof import('./types/api').pipeline;
-  var connect: typeof import('./types/api').connect;
-  var upgrade: typeof import('./types/api').upgrade;
-  var MockClient: typeof import('./types/mock-client').default;
-  var MockPool: typeof import('./types/mock-pool').default;
-  var MockAgent: typeof import('./types/mock-agent').default;
-  var mockErrors: typeof import('./types/mock-errors').default;
-  var fetch: typeof import('./types/fetch').fetch;
-  var caches: typeof import('./types/cache').caches;
-}