undici 6.3.0 → 6.5.0

package/README.md

@@ -18,34 +18,23 @@ 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 20.6.0.
-
-### Connections 1
-
-
-| Tests               | Samples |        Result | Tolerance | Difference with slowest |
-|---------------------|---------|---------------|-----------|-------------------------|
-| 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 |
-|---------------------|---------|------------------|-----------|-------------------------|
-| 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 % |
+50 TCP connections with a pipelining depth of 10 running on Node 20.10.0.
 
+```
+│ Tests               │ Samples │          Result │ Tolerance │ Difference with slowest │
+|─────────────────────|─────────|─────────────────|───────────|─────────────────────────|
+│ got                 │      45 │ 1661.71 req/sec │  ± 2.93 % │                       - │
+│ node-fetch          │      20 │ 2164.81 req/sec │  ± 2.63 % │               + 30.28 % │
+│ undici - fetch      │      35 │ 2274.27 req/sec │  ± 2.70 % │               + 36.86 % │
+│ http - no keepalive │      15 │ 2376.04 req/sec │  ± 2.99 % │               + 42.99 % │
+│ axios               │      25 │ 2612.93 req/sec │  ± 2.89 % │               + 57.24 % │
+│ request             │      40 │ 2712.19 req/sec │  ± 2.92 % │               + 63.22 % │
+│ http - keepalive    │      45 │ 4393.25 req/sec │  ± 2.86 % │              + 164.38 % │
+│ undici - pipeline   │      45 │ 5484.69 req/sec │  ± 2.87 % │              + 230.06 % │
+│ undici - request    │      55 │ 7773.98 req/sec │  ± 2.93 % │              + 367.83 % │
+│ undici - stream     │      70 │ 8425.96 req/sec │  ± 2.91 % │              + 407.07 % │
+│ undici - dispatch   │      50 │ 9488.99 req/sec │  ± 2.85 % │              + 471.04 % │
+```
 
 ## Quick Start
 
@@ -62,9 +51,7 @@ const {
 console.log('response received', statusCode)
 console.log('headers', headers)
 
-for await (const data of body) {
-  console.log('data', data)
-}
+for await (const data of body) { console.log('data', data) }
 
 console.log('trailers', trailers)
 ```

package/docs/api/Debug.md

@@ -53,10 +53,10 @@ This flag enables debug statements for the `Websocket` API.
 > **Note**: statements can overlap with `UNDICI` ones if `undici` or `fetch` flag has been enabled as well.
 
 ```sh
-NODE_DEBUG=fetch node script.js
+NODE_DEBUG=websocket node script.js
 
 WEBSOCKET 18309: connecting to echo.websocket.org using https:h1
 WEBSOCKET 18309: connected to echo.websocket.org using https:h1
 WEBSOCKET 18309: sending request to GET https://echo.websocket.org//
 WEBSOCKET 18309: connection opened <ip_address>
-```
+```

package/docs/api/EventSource.md

@@ -0,0 +1,21 @@
+# EventSource
+
+Undici exposes a WHATWG spec-compliant implementation of [EventSource](https://developer.mozilla.org/en-US/docs/Web/API/EventSource)
+for [Server-Sent Events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events).
+
+## Instantiating EventSource
+
+Undici exports a EventSource class. You can instantiate the EventSource as
+follows:
+
+```mjs
+import { EventSource } from 'undici'
+
+const evenSource = new EventSource('http://localhost:3000')
+evenSource.onmessage = (event) => {
+  console.log(event.data)
+}
+```
+
+More information about the EventSource API can be found on
+[MDN](https://developer.mozilla.org/en-US/docs/Web/API/EventSource).

package/docs/api/RedirectHandler.md

@@ -0,0 +1,96 @@
+# Class: RedirectHandler
+
+A class that handles redirection logic for HTTP requests.
+
+## `new RedirectHandler(dispatch, maxRedirections, opts, handler, redirectionLimitReached)`
+
+Arguments:
+
+- **dispatch** `function` - The dispatch function to be called after every retry.
+- **maxRedirections** `number` - Maximum number of redirections allowed.
+- **opts** `object` - Options for handling redirection.
+- **handler** `object` - An object containing handlers for different stages of the request lifecycle.
+- **redirectionLimitReached** `boolean` (default: `false`) - A flag that the implementer can provide to enable or disable the feature. If set to `false`, it indicates that the caller doesn't want to use the feature and prefers the old behavior.
+
+Returns: `RedirectHandler`
+
+### Parameters
+
+- **dispatch** `(options: Dispatch.DispatchOptions, handlers: Dispatch.DispatchHandlers) => Promise<Dispatch.DispatchResponse>` (required) - Dispatch function to be called after every redirection.
+- **maxRedirections** `number` (required) - Maximum number of redirections allowed.
+- **opts** `object` (required) - Options for handling redirection.
+- **handler** `object` (required) - Handlers for different stages of the request lifecycle.
+- **redirectionLimitReached** `boolean` (default: `false`) - A flag that the implementer can provide to enable or disable the feature. If set to `false`, it indicates that the caller doesn't want to use the feature and prefers the old behavior.
+
+### Properties
+
+- **location** `string` - The current redirection location.
+- **abort** `function` - The abort function.
+- **opts** `object` - The options for handling redirection.
+- **maxRedirections** `number` - Maximum number of redirections allowed.
+- **handler** `object` - Handlers for different stages of the request lifecycle.
+- **history** `Array` - An array representing the history of URLs during redirection.
+- **redirectionLimitReached** `boolean` - Indicates whether the redirection limit has been reached.
+
+### Methods
+
+#### `onConnect(abort)`
+
+Called when the connection is established.
+
+Parameters:
+
+- **abort** `function` - The abort function.
+
+#### `onUpgrade(statusCode, headers, socket)`
+
+Called when an upgrade is requested.
+
+Parameters:
+
+- **statusCode** `number` - The HTTP status code.
+- **headers** `object` - The headers received in the response.
+- **socket** `object` - The socket object.
+
+#### `onError(error)`
+
+Called when an error occurs.
+
+Parameters:
+
+- **error** `Error` - The error that occurred.
+
+#### `onHeaders(statusCode, headers, resume, statusText)`
+
+Called when headers are received.
+
+Parameters:
+
+- **statusCode** `number` - The HTTP status code.
+- **headers** `object` - The headers received in the response.
+- **resume** `function` - The resume function.
+- **statusText** `string` - The status text.
+
+#### `onData(chunk)`
+
+Called when data is received.
+
+Parameters:
+
+- **chunk** `Buffer` - The data chunk received.
+
+#### `onComplete(trailers)`
+
+Called when the request is complete.
+
+Parameters:
+
+- **trailers** `object` - The trailers received.
+
+#### `onBodySent(chunk)`
+
+Called when the request body is sent.
+
+Parameters:
+
+- **chunk** `Buffer` - The chunk of the request body sent.

package/index.js

@@ -21,14 +21,6 @@ const DecoratorHandler = require('./lib/handler/DecoratorHandler')
 const RedirectHandler = require('./lib/handler/RedirectHandler')
 const createRedirectInterceptor = require('./lib/interceptor/redirectInterceptor')
 
-let hasCrypto
-try {
-  require('crypto')
-  hasCrypto = true
-} catch {
-  hasCrypto = false
-}
-
 Object.assign(Dispatcher.prototype, api)
 
 module.exports.Dispatcher = Dispatcher
@@ -102,14 +94,10 @@ function makeDispatcher (fn) {
 module.exports.setGlobalDispatcher = setGlobalDispatcher
 module.exports.getGlobalDispatcher = getGlobalDispatcher
 
-let fetchImpl = null
-module.exports.fetch = async function fetch (resource) {
-  if (!fetchImpl) {
-    fetchImpl = require('./lib/fetch').fetch
-  }
-
+const fetchImpl = require('./lib/fetch').fetch
+module.exports.fetch = async function fetch (init, options = undefined) {
   try {
-    return await fetchImpl(...arguments)
+    return await fetchImpl(init, options)
   } catch (err) {
     if (typeof err === 'object') {
       Error.captureStackTrace(err, this)
@@ -149,11 +137,7 @@ const { parseMIMEType, serializeAMimeType } = require('./lib/fetch/dataURL')
 module.exports.parseMIMEType = parseMIMEType
 module.exports.serializeAMimeType = serializeAMimeType
 
-if (hasCrypto) {
-  const { WebSocket } = require('./lib/websocket/websocket')
-
-  module.exports.WebSocket = WebSocket
-}
+module.exports.WebSocket = require('./lib/websocket/websocket').WebSocket
 
 module.exports.request = makeDispatcher(api.request)
 module.exports.stream = makeDispatcher(api.stream)
@@ -165,3 +149,7 @@ module.exports.MockClient = MockClient
 module.exports.MockPool = MockPool
 module.exports.MockAgent = MockAgent
 module.exports.mockErrors = mockErrors
+
+const { EventSource } = require('./lib/eventsource/eventsource')
+
+module.exports.EventSource = EventSource

package/lib/api/readable.js

@@ -94,7 +94,7 @@ module.exports = class BodyReadable extends Readable {
   }
 
   push (chunk) {
-    if (this[kConsume] && chunk !== null && this.readableLength === 0) {
+    if (this[kConsume] && chunk !== null) {
       consumePush(this[kConsume], chunk)
       return this[kReading] ? super.push(chunk) : true
     }
@@ -215,26 +215,28 @@ async function consume (stream, type) {
         reject(rState.errored ?? new TypeError('unusable'))
       }
     } else {
-      stream[kConsume] = {
-        type,
-        stream,
-        resolve,
-        reject,
-        length: 0,
-        body: []
-      }
+      queueMicrotask(() => {
+        stream[kConsume] = {
+          type,
+          stream,
+          resolve,
+          reject,
+          length: 0,
+          body: []
+        }
 
-      stream
-        .on('error', function (err) {
-          consumeFinish(this[kConsume], err)
-        })
-        .on('close', function () {
-          if (this[kConsume].body !== null) {
-            consumeFinish(this[kConsume], new RequestAbortedError())
-          }
-        })
+        stream
+          .on('error', function (err) {
+            consumeFinish(this[kConsume], err)
+          })
+          .on('close', function () {
+            if (this[kConsume].body !== null) {
+              consumeFinish(this[kConsume], new RequestAbortedError())
+            }
+          })
 
-      queueMicrotask(() => consumeStart(stream[kConsume]))
+        consumeStart(stream[kConsume])
+      })
     }
   })
 }
@@ -246,8 +248,16 @@ function consumeStart (consume) {
 
   const { _readableState: state } = consume.stream
 
-  for (const chunk of state.buffer) {
-    consumePush(consume, chunk)
+  if (state.bufferIndex) {
+    const start = state.bufferIndex
+    const end = state.buffer.length
+    for (let n = start; n < end; n++) {
+      consumePush(consume, state.buffer[n])
+    }
+  } else {
+    for (const chunk of state.buffer) {
+      consumePush(consume, chunk)
+    }
   }
 
   if (state.endEmitted) {

package/lib/cache/cache.js

@@ -6,8 +6,9 @@ const { kEnumerableProperty, isDisturbed } = require('../core/util')
 const { kHeadersList } = require('../core/symbols')
 const { webidl } = require('../fetch/webidl')
 const { Response, cloneResponse } = require('../fetch/response')
-const { Request } = require('../fetch/request')
-const { kState, kHeaders, kGuard, kRealm } = require('../fetch/symbols')
+const { Request, fromInnerRequest } = require('../fetch/request')
+const { Headers } = require('../fetch/headers')
+const { kState, kHeaders, kGuard } = require('../fetch/symbols')
 const { fetching } = require('../fetch/index')
 const { urlIsHttpHttpsScheme, createDeferredPromise, readAllBytes } = require('../fetch/util')
 const assert = require('assert')
@@ -49,7 +50,7 @@ class Cache {
     request = webidl.converters.RequestInfo(request)
     options = webidl.converters.CacheQueryOptions(options)
 
-    const p = await this.matchAll(request, options)
+    const p = this.#internalMatchAll(request, options, 1)
 
     if (p.length === 0) {
       return
@@ -64,64 +65,7 @@ class Cache {
     if (request !== undefined) request = webidl.converters.RequestInfo(request)
     options = webidl.converters.CacheQueryOptions(options)
 
-    // 1.
-    let r = null
-
-    // 2.
-    if (request !== undefined) {
-      if (request instanceof Request) {
-        // 2.1.1
-        r = request[kState]
-
-        // 2.1.2
-        if (r.method !== 'GET' && !options.ignoreMethod) {
-          return []
-        }
-      } else if (typeof request === 'string') {
-        // 2.2.1
-        r = new Request(request)[kState]
-      }
-    }
-
-    // 5.
-    // 5.1
-    const responses = []
-
-    // 5.2
-    if (request === undefined) {
-      // 5.2.1
-      for (const requestResponse of this.#relevantRequestResponseList) {
-        responses.push(requestResponse[1])
-      }
-    } else { // 5.3
-      // 5.3.1
-      const requestResponses = this.#queryCache(r, options)
-
-      // 5.3.2
-      for (const requestResponse of requestResponses) {
-        responses.push(requestResponse[1])
-      }
-    }
-
-    // 5.4
-    // We don't implement CORs so we don't need to loop over the responses, yay!
-
-    // 5.5.1
-    const responseList = []
-
-    // 5.5.2
-    for (const response of responses) {
-      // 5.5.2.1
-      const responseObject = new Response(null)
-      responseObject[kState] = response
-      responseObject[kHeaders][kHeadersList] = response.headersList
-      responseObject[kHeaders][kGuard] = 'immutable'
-
-      responseList.push(responseObject.clone())
-    }
-
-    // 6.
-    return Object.freeze(responseList)
+    return this.#internalMatchAll(request, options)
   }
 
   async add (request) {
@@ -500,7 +444,7 @@ class Cache {
    * @see https://w3c.github.io/ServiceWorker/#dom-cache-keys
    * @param {any} request
    * @param {import('../../types/cache').CacheQueryOptions} options
-   * @returns {readonly Request[]}
+   * @returns {Promise<readonly Request[]>}
    */
   async keys (request = undefined, options = {}) {
     webidl.brandCheck(this, Cache)
@@ -559,12 +503,12 @@ class Cache {
 
       // 5.4.2
       for (const request of requests) {
-        const requestObject = new Request('https://a')
-        requestObject[kState] = request
-        requestObject[kHeaders][kHeadersList] = request.headersList
-        requestObject[kHeaders][kGuard] = 'immutable'
-        requestObject[kRealm] = request.client
-
+        const requestObject = fromInnerRequest(
+          request,
+          new AbortController().signal,
+          'immutable',
+          { settingsObject: request.client }
+        )
         // 5.4.2.1
         requestList.push(requestObject)
       }
@@ -789,6 +733,72 @@ class Cache {
 
     return true
   }
+
+  #internalMatchAll (request, options, maxResponses = Infinity) {
+    // 1.
+    let r = null
+
+    // 2.
+    if (request !== undefined) {
+      if (request instanceof Request) {
+        // 2.1.1
+        r = request[kState]
+
+        // 2.1.2
+        if (r.method !== 'GET' && !options.ignoreMethod) {
+          return []
+        }
+      } else if (typeof request === 'string') {
+        // 2.2.1
+        r = new Request(request)[kState]
+      }
+    }
+
+    // 5.
+    // 5.1
+    const responses = []
+
+    // 5.2
+    if (request === undefined) {
+      // 5.2.1
+      for (const requestResponse of this.#relevantRequestResponseList) {
+        responses.push(requestResponse[1])
+      }
+    } else { // 5.3
+      // 5.3.1
+      const requestResponses = this.#queryCache(r, options)
+
+      // 5.3.2
+      for (const requestResponse of requestResponses) {
+        responses.push(requestResponse[1])
+      }
+    }
+
+    // 5.4
+    // We don't implement CORs so we don't need to loop over the responses, yay!
+
+    // 5.5.1
+    const responseList = []
+
+    // 5.5.2
+    for (const response of responses) {
+      // 5.5.2.1
+      const responseObject = new Response(kConstruct)
+      responseObject[kState] = response
+      responseObject[kHeaders] = new Headers(kConstruct)
+      responseObject[kHeaders][kHeadersList] = response.headersList
+      responseObject[kHeaders][kGuard] = 'immutable'
+
+      responseList.push(responseObject.clone())
+
+      if (responseList.length >= maxResponses) {
+        break
+      }
+    }
+
+    // 6.
+    return Object.freeze(responseList)
+  }
 }
 
 Object.defineProperties(Cache.prototype, {

package/lib/cache/cachestorage.js

@@ -114,7 +114,7 @@ class CacheStorage {
 
   /**
    * @see https://w3c.github.io/ServiceWorker/#cache-storage-keys
-   * @returns {string[]}
+   * @returns {Promise<string[]>}
    */
   async keys () {
     webidl.brandCheck(this, CacheStorage)

package/lib/client.js

@@ -1769,7 +1769,7 @@ function writeH2 (client, session, request) {
 
   session.ref()
 
-  const shouldEndStream = method === 'GET' || method === 'HEAD'
+  const shouldEndStream = method === 'GET' || method === 'HEAD' || body === null
   if (expectContinue) {
     headers[HTTP2_HEADER_EXPECT] = '100-continue'
     stream = session.request(headers, { endStream: shouldEndStream, signal })

package/lib/core/util.js

@@ -349,14 +349,8 @@ function validateHandler (handler, method, upgrade) {
 // A body is disturbed if it has been read from and it cannot
 // be re-used without losing state or data.
 function isDisturbed (body) {
-  return !!(body && (
-    stream.isDisturbed
-      ? stream.isDisturbed(body) || body[kBodyUsed] // TODO (fix): Why is body[kBodyUsed] needed?
-      : body[kBodyUsed] ||
-        body.readableDidRead ||
-        (body._readableState && body._readableState.dataEmitted) ||
-        isReadableAborted(body)
-  ))
+  // TODO (fix): Why is body[kBodyUsed] needed?
+  return !!(body && (stream.isDisturbed(body) || body[kBodyUsed]))
 }
 
 function isErrored (body) {