undici 7.14.0 → 7.16.0

package/README.md

@@ -1,6 +1,6 @@
 # undici
 
-[![Node CI](https://github.com/nodejs/undici/actions/workflows/nodejs.yml/badge.svg)](https://github.com/nodejs/undici/actions/workflows/nodejs.yml) [![neostandard javascript style](https://img.shields.io/badge/neo-standard-7fffff?style=flat\&labelColor=ff80ff)](https://github.com/neostandard/neostandard) [![npm version](https://badge.fury.io/js/undici.svg)](https://badge.fury.io/js/undici) [![codecov](https://codecov.io/gh/nodejs/undici/branch/main/graph/badge.svg?token=yZL6LtXkOA)](https://codecov.io/gh/nodejs/undici)
+[![Node CI](https://github.com/nodejs/undici/actions/workflows/ci.yml/badge.svg)](https://github.com/nodejs/undici/actions/workflows/nodejs.yml) [![neostandard javascript style](https://img.shields.io/badge/neo-standard-7fffff?style=flat\&labelColor=ff80ff)](https://github.com/neostandard/neostandard) [![npm version](https://badge.fury.io/js/undici.svg)](https://badge.fury.io/js/undici) [![codecov](https://codecov.io/gh/nodejs/undici/branch/main/graph/badge.svg?token=yZL6LtXkOA)](https://codecov.io/gh/nodejs/undici)
 
 An HTTP/1.1 client, written from scratch for Node.js.
 

package/docs/docs/api/Agent.md

@@ -19,6 +19,7 @@ Returns: `Agent`
 Extends: [`PoolOptions`](/docs/docs/api/Pool.md#parameter-pooloptions)
 
 * **factory** `(origin: URL, opts: Object) => Dispatcher` - Default: `(origin, opts) => new Pool(origin, opts)`
+* **maxOrigins** `number` (optional) - Default: `Infinity` - Limits the total number of origins that can receive requests at a time, throwing an `MaxOriginsReachedError` error when attempting to dispatch when the max is reached. If `Infinity`, no limit is enforced.
 
 ## Instance Properties
 

package/docs/docs/api/Dispatcher.md

@@ -1094,6 +1094,65 @@ await client.request({
 });
 ```
 
+##### `decompress`
+
+⚠️ The decompress interceptor is experimental and subject to change.
+
+The `decompress` interceptor automatically decompresses response bodies that are compressed with gzip, deflate, brotli, or zstd compression. It removes the `content-encoding` and `content-length` headers from decompressed responses and supports RFC-9110 compliant multiple encodings.
+
+**Options**
+
+- `skipErrorResponses` - Whether to skip decompression for error responses (status codes >= 400). Default: `true`.
+- `skipStatusCodes` - Array of status codes to skip decompression for. Default: `[204, 304]`.
+
+**Example - Basic Decompress Interceptor**
+
+```js
+const { Client, interceptors } = require("undici");
+const { decompress } = interceptors;
+
+const client = new Client("http://example.com").compose(
+  decompress()
+);
+
+// Automatically decompresses gzip/deflate/brotli/zstd responses
+const response = await client.request({
+  method: "GET",
+  path: "/"
+});
+```
+
+**Example - Custom Options**
+
+```js
+const { Client, interceptors } = require("undici");
+const { decompress } = interceptors;
+
+const client = new Client("http://example.com").compose(
+  decompress({
+    skipErrorResponses: false, // Decompress 5xx responses
+    skipStatusCodes: [204, 304, 201] // Skip these status codes
+  })
+);
+```
+
+**Supported Encodings**
+
+- `gzip` / `x-gzip` - GZIP compression
+- `deflate` / `x-compress` - DEFLATE compression  
+- `br` - Brotli compression
+- `zstd` - Zstandard compression
+- Multiple encodings (e.g., `gzip, deflate`) are supported per RFC-9110
+
+**Behavior**
+
+- Skips decompression for status codes < 200 or >= 400 (configurable)
+- Skips decompression for 204 No Content and 304 Not Modified by default
+- Removes `content-encoding` and `content-length` headers when decompressing
+- Passes through unsupported encodings unchanged
+- Handles case-insensitive encoding names
+- Supports streaming decompression without buffering
+
 ##### `Cache Interceptor`
 
 The `cache` interceptor implements client-side response caching as described in

package/docs/docs/api/Errors.md

@@ -14,7 +14,6 @@ import { errors } from 'undici'
 | `HeadersTimeoutError`                | `UND_ERR_HEADERS_TIMEOUT`             | socket is destroyed due to headers timeout.                               |
 | `HeadersOverflowError`               | `UND_ERR_HEADERS_OVERFLOW`            | socket is destroyed due to headers' max size being exceeded.              |
 | `BodyTimeoutError`                   | `UND_ERR_BODY_TIMEOUT`                | socket is destroyed due to body timeout.                                  |
-| `ResponseStatusCodeError`            | `UND_ERR_RESPONSE_STATUS_CODE`        | an error is thrown when `throwOnError` is `true` for status codes >= 400. |
 | `InvalidArgumentError`               | `UND_ERR_INVALID_ARG`                 | passed an invalid argument.                                               |
 | `InvalidReturnValueError`            | `UND_ERR_INVALID_RETURN_VALUE`        | returned an invalid value.                                                |
 | `RequestAbortedError`                | `UND_ERR_ABORTED`                     | the request has been aborted by the user                                  |

package/index-fetch.js

@@ -4,8 +4,8 @@ const { getGlobalDispatcher, setGlobalDispatcher } = require('./lib/global')
 const EnvHttpProxyAgent = require('./lib/dispatcher/env-http-proxy-agent')
 const fetchImpl = require('./lib/web/fetch').fetch
 
-module.exports.fetch = function fetch (resource, init = undefined) {
-  return fetchImpl(resource, init).catch((err) => {
+module.exports.fetch = function fetch (init, options = undefined) {
+  return fetchImpl(init, options).catch(err => {
     if (err && typeof err === 'object') {
       Error.captureStackTrace(err)
     }

package/index.js

@@ -46,7 +46,8 @@ module.exports.interceptors = {
   retry: require('./lib/interceptor/retry'),
   dump: require('./lib/interceptor/dump'),
   dns: require('./lib/interceptor/dns'),
-  cache: require('./lib/interceptor/cache')
+  cache: require('./lib/interceptor/cache'),
+  decompress: require('./lib/interceptor/decompress')
 }
 
 module.exports.cacheStores = {
@@ -116,16 +117,14 @@ module.exports.setGlobalDispatcher = setGlobalDispatcher
 module.exports.getGlobalDispatcher = getGlobalDispatcher
 
 const fetchImpl = require('./lib/web/fetch').fetch
-module.exports.fetch = async function fetch (init, options = undefined) {
-  try {
-    return await fetchImpl(init, options)
-  } catch (err) {
+
+module.exports.fetch = function fetch (init, options = undefined) {
+  return fetchImpl(init, options).catch(err => {
     if (err && typeof err === 'object') {
       Error.captureStackTrace(err)
     }
-
     throw err
-  }
+  })
 }
 module.exports.Headers = require('./lib/web/fetch/headers').Headers
 module.exports.Response = require('./lib/web/fetch/response').Response
@@ -140,8 +139,6 @@ module.exports.getGlobalOrigin = getGlobalOrigin
 const { CacheStorage } = require('./lib/web/cache/cachestorage')
 const { kConstruct } = require('./lib/core/symbols')
 
-// Cache & CacheStorage are tightly coupled with fetch. Even if it may run
-// in an older version of Node, it doesn't have any use without fetch.
 module.exports.caches = new CacheStorage(kConstruct)
 
 const { deleteCookie, getCookies, getSetCookies, setCookie, parseCookie } = require('./lib/web/cookies')

package/lib/api/api-request.js

@@ -118,14 +118,28 @@ class RequestHandler extends AsyncResource {
     this.callback = null
     this.res = res
     if (callback !== null) {
-      this.runInAsyncScope(callback, null, null, {
-        statusCode,
-        headers,
-        trailers: this.trailers,
-        opaque,
-        body: res,
-        context
-      })
+      try {
+        this.runInAsyncScope(callback, null, null, {
+          statusCode,
+          headers,
+          trailers: this.trailers,
+          opaque,
+          body: res,
+          context
+        })
+      } catch (err) {
+        // If the callback throws synchronously, we need to handle it
+        // Remove reference to res to allow res being garbage collected
+        this.res = null
+
+        // Destroy the response stream
+        util.destroy(res.on('error', noop), err)
+
+        // Use queueMicrotask to re-throw the error so it reaches uncaughtException
+        queueMicrotask(() => {
+          throw err
+        })
+      }
     }
   }
 

package/lib/api/readable.js

@@ -262,24 +262,26 @@ class BodyReadable extends Readable {
    * @param {AbortSignal} [opts.signal] An AbortSignal to cancel the dump.
    * @returns {Promise<null>}
    */
-  async dump (opts) {
+  dump (opts) {
     const signal = opts?.signal
 
     if (signal != null && (typeof signal !== 'object' || !('aborted' in signal))) {
-      throw new InvalidArgumentError('signal must be an AbortSignal')
+      return Promise.reject(new InvalidArgumentError('signal must be an AbortSignal'))
     }
 
     const limit = opts?.limit && Number.isFinite(opts.limit)
       ? opts.limit
       : 128 * 1024
 
-    signal?.throwIfAborted()
+    if (signal?.aborted) {
+      return Promise.reject(signal.reason ?? new AbortError())
+    }
 
     if (this._readableState.closeEmitted) {
-      return null
+      return Promise.resolve(null)
     }
 
-    return await new Promise((resolve, reject) => {
+    return new Promise((resolve, reject) => {
       if (
         (this[kContentLength] && (this[kContentLength] > limit)) ||
         this[kBytesRead] > limit

package/lib/core/errors.js

@@ -1,13 +1,23 @@
 'use strict'
 
+const kUndiciError = Symbol.for('undici.error.UND_ERR')
 class UndiciError extends Error {
   constructor (message, options) {
     super(message, options)
     this.name = 'UndiciError'
     this.code = 'UND_ERR'
   }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kUndiciError] === true
+  }
+
+  get [kUndiciError] () {
+    return true
+  }
 }
 
+const kConnectTimeoutError = Symbol.for('undici.error.UND_ERR_CONNECT_TIMEOUT')
 class ConnectTimeoutError extends UndiciError {
   constructor (message) {
     super(message)
@@ -15,8 +25,17 @@ class ConnectTimeoutError extends UndiciError {
     this.message = message || 'Connect Timeout Error'
     this.code = 'UND_ERR_CONNECT_TIMEOUT'
   }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kConnectTimeoutError] === true
+  }
+
+  get [kConnectTimeoutError] () {
+    return true
+  }
 }
 
+const kHeadersTimeoutError = Symbol.for('undici.error.UND_ERR_HEADERS_TIMEOUT')
 class HeadersTimeoutError extends UndiciError {
   constructor (message) {
     super(message)
@@ -24,8 +43,17 @@ class HeadersTimeoutError extends UndiciError {
     this.message = message || 'Headers Timeout Error'
     this.code = 'UND_ERR_HEADERS_TIMEOUT'
   }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kHeadersTimeoutError] === true
+  }
+
+  get [kHeadersTimeoutError] () {
+    return true
+  }
 }
 
+const kHeadersOverflowError = Symbol.for('undici.error.UND_ERR_HEADERS_OVERFLOW')
 class HeadersOverflowError extends UndiciError {
   constructor (message) {
     super(message)
@@ -33,8 +61,17 @@ class HeadersOverflowError extends UndiciError {
     this.message = message || 'Headers Overflow Error'
     this.code = 'UND_ERR_HEADERS_OVERFLOW'
   }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kHeadersOverflowError] === true
+  }
+
+  get [kHeadersOverflowError] () {
+    return true
+  }
 }
 
+const kBodyTimeoutError = Symbol.for('undici.error.UND_ERR_BODY_TIMEOUT')
 class BodyTimeoutError extends UndiciError {
   constructor (message) {
     super(message)
@@ -42,21 +79,17 @@ class BodyTimeoutError extends UndiciError {
     this.message = message || 'Body Timeout Error'
     this.code = 'UND_ERR_BODY_TIMEOUT'
   }
-}
 
-class ResponseStatusCodeError extends UndiciError {
-  constructor (message, statusCode, headers, body) {
-    super(message)
-    this.name = 'ResponseStatusCodeError'
-    this.message = message || 'Response Status Code Error'
-    this.code = 'UND_ERR_RESPONSE_STATUS_CODE'
-    this.body = body
-    this.status = statusCode
-    this.statusCode = statusCode
-    this.headers = headers
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kBodyTimeoutError] === true
+  }
+
+  get [kBodyTimeoutError] () {
+    return true
   }
 }
 
+const kInvalidArgumentError = Symbol.for('undici.error.UND_ERR_INVALID_ARG')
 class InvalidArgumentError extends UndiciError {
   constructor (message) {
     super(message)
@@ -64,8 +97,17 @@ class InvalidArgumentError extends UndiciError {
     this.message = message || 'Invalid Argument Error'
     this.code = 'UND_ERR_INVALID_ARG'
   }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kInvalidArgumentError] === true
+  }
+
+  get [kInvalidArgumentError] () {
+    return true
+  }
 }
 
+const kInvalidReturnValueError = Symbol.for('undici.error.UND_ERR_INVALID_RETURN_VALUE')
 class InvalidReturnValueError extends UndiciError {
   constructor (message) {
     super(message)
@@ -73,16 +115,35 @@ class InvalidReturnValueError extends UndiciError {
     this.message = message || 'Invalid Return Value Error'
     this.code = 'UND_ERR_INVALID_RETURN_VALUE'
   }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kInvalidReturnValueError] === true
+  }
+
+  get [kInvalidReturnValueError] () {
+    return true
+  }
 }
 
+const kAbortError = Symbol.for('undici.error.UND_ERR_ABORT')
 class AbortError extends UndiciError {
   constructor (message) {
     super(message)
     this.name = 'AbortError'
     this.message = message || 'The operation was aborted'
+    this.code = 'UND_ERR_ABORT'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kAbortError] === true
+  }
+
+  get [kAbortError] () {
+    return true
   }
 }
 
+const kRequestAbortedError = Symbol.for('undici.error.UND_ERR_ABORTED')
 class RequestAbortedError extends AbortError {
   constructor (message) {
     super(message)
@@ -90,8 +151,17 @@ class RequestAbortedError extends AbortError {
     this.message = message || 'Request aborted'
     this.code = 'UND_ERR_ABORTED'
   }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kRequestAbortedError] === true
+  }
+
+  get [kRequestAbortedError] () {
+    return true
+  }
 }
 
+const kInformationalError = Symbol.for('undici.error.UND_ERR_INFO')
 class InformationalError extends UndiciError {
   constructor (message) {
     super(message)
@@ -99,8 +169,17 @@ class InformationalError extends UndiciError {
     this.message = message || 'Request information'
     this.code = 'UND_ERR_INFO'
   }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kInformationalError] === true
+  }
+
+  get [kInformationalError] () {
+    return true
+  }
 }
 
+const kRequestContentLengthMismatchError = Symbol.for('undici.error.UND_ERR_REQ_CONTENT_LENGTH_MISMATCH')
 class RequestContentLengthMismatchError extends UndiciError {
   constructor (message) {
     super(message)
@@ -108,8 +187,17 @@ class RequestContentLengthMismatchError extends UndiciError {
     this.message = message || 'Request body length does not match content-length header'
     this.code = 'UND_ERR_REQ_CONTENT_LENGTH_MISMATCH'
   }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kRequestContentLengthMismatchError] === true
+  }
+
+  get [kRequestContentLengthMismatchError] () {
+    return true
+  }
 }
 
+const kResponseContentLengthMismatchError = Symbol.for('undici.error.UND_ERR_RES_CONTENT_LENGTH_MISMATCH')
 class ResponseContentLengthMismatchError extends UndiciError {
   constructor (message) {
     super(message)
@@ -117,8 +205,17 @@ class ResponseContentLengthMismatchError extends UndiciError {
     this.message = message || 'Response body length does not match content-length header'
     this.code = 'UND_ERR_RES_CONTENT_LENGTH_MISMATCH'
   }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kResponseContentLengthMismatchError] === true
+  }
+
+  get [kResponseContentLengthMismatchError] () {
+    return true
+  }
 }
 
+const kClientDestroyedError = Symbol.for('undici.error.UND_ERR_DESTROYED')
 class ClientDestroyedError extends UndiciError {
   constructor (message) {
     super(message)
@@ -126,8 +223,17 @@ class ClientDestroyedError extends UndiciError {
     this.message = message || 'The client is destroyed'
     this.code = 'UND_ERR_DESTROYED'
   }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kClientDestroyedError] === true
+  }
+
+  get [kClientDestroyedError] () {
+    return true
+  }
 }
 
+const kClientClosedError = Symbol.for('undici.error.UND_ERR_CLOSED')
 class ClientClosedError extends UndiciError {
   constructor (message) {
     super(message)
@@ -135,8 +241,17 @@ class ClientClosedError extends UndiciError {
     this.message = message || 'The client is closed'
     this.code = 'UND_ERR_CLOSED'
   }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kClientClosedError] === true
+  }
+
+  get [kClientClosedError] () {
+    return true
+  }
 }
 
+const kSocketError = Symbol.for('undici.error.UND_ERR_SOCKET')
 class SocketError extends UndiciError {
   constructor (message, socket) {
     super(message)
@@ -145,8 +260,17 @@ class SocketError extends UndiciError {
     this.code = 'UND_ERR_SOCKET'
     this.socket = socket
   }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kSocketError] === true
+  }
+
+  get [kSocketError] () {
+    return true
+  }
 }
 
+const kNotSupportedError = Symbol.for('undici.error.UND_ERR_NOT_SUPPORTED')
 class NotSupportedError extends UndiciError {
   constructor (message) {
     super(message)
@@ -154,8 +278,17 @@ class NotSupportedError extends UndiciError {
     this.message = message || 'Not supported error'
     this.code = 'UND_ERR_NOT_SUPPORTED'
   }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kNotSupportedError] === true
+  }
+
+  get [kNotSupportedError] () {
+    return true
+  }
 }
 
+const kBalancedPoolMissingUpstreamError = Symbol.for('undici.error.UND_ERR_BPL_MISSING_UPSTREAM')
 class BalancedPoolMissingUpstreamError extends UndiciError {
   constructor (message) {
     super(message)
@@ -163,8 +296,17 @@ class BalancedPoolMissingUpstreamError extends UndiciError {
     this.message = message || 'No upstream has been added to the BalancedPool'
     this.code = 'UND_ERR_BPL_MISSING_UPSTREAM'
   }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kBalancedPoolMissingUpstreamError] === true
+  }
+
+  get [kBalancedPoolMissingUpstreamError] () {
+    return true
+  }
 }
 
+const kHTTPParserError = Symbol.for('undici.error.UND_ERR_HTTP_PARSER')
 class HTTPParserError extends Error {
   constructor (message, code, data) {
     super(message)
@@ -172,8 +314,17 @@ class HTTPParserError extends Error {
     this.code = code ? `HPE_${code}` : undefined
     this.data = data ? data.toString() : undefined
   }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kHTTPParserError] === true
+  }
+
+  get [kHTTPParserError] () {
+    return true
+  }
 }
 
+const kResponseExceededMaxSizeError = Symbol.for('undici.error.UND_ERR_RES_EXCEEDED_MAX_SIZE')
 class ResponseExceededMaxSizeError extends UndiciError {
   constructor (message) {
     super(message)
@@ -181,8 +332,17 @@ class ResponseExceededMaxSizeError extends UndiciError {
     this.message = message || 'Response content exceeded max size'
     this.code = 'UND_ERR_RES_EXCEEDED_MAX_SIZE'
   }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kResponseExceededMaxSizeError] === true
+  }
+
+  get [kResponseExceededMaxSizeError] () {
+    return true
+  }
 }
 
+const kRequestRetryError = Symbol.for('undici.error.UND_ERR_REQ_RETRY')
 class RequestRetryError extends UndiciError {
   constructor (message, code, { headers, data }) {
     super(message)
@@ -193,8 +353,17 @@ class RequestRetryError extends UndiciError {
     this.data = data
     this.headers = headers
   }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kRequestRetryError] === true
+  }
+
+  get [kRequestRetryError] () {
+    return true
+  }
 }
 
+const kResponseError = Symbol.for('undici.error.UND_ERR_RESPONSE')
 class ResponseError extends UndiciError {
   constructor (message, code, { headers, body }) {
     super(message)
@@ -205,8 +374,17 @@ class ResponseError extends UndiciError {
     this.body = body
     this.headers = headers
   }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kResponseError] === true
+  }
+
+  get [kResponseError] () {
+    return true
+  }
 }
 
+const kSecureProxyConnectionError = Symbol.for('undici.error.UND_ERR_PRX_TLS')
 class SecureProxyConnectionError extends UndiciError {
   constructor (cause, message, options = {}) {
     super(message, { cause, ...options })
@@ -215,6 +393,32 @@ class SecureProxyConnectionError extends UndiciError {
     this.code = 'UND_ERR_PRX_TLS'
     this.cause = cause
   }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kSecureProxyConnectionError] === true
+  }
+
+  get [kSecureProxyConnectionError] () {
+    return true
+  }
+}
+
+const kMaxOriginsReachedError = Symbol.for('undici.error.UND_ERR_MAX_ORIGINS_REACHED')
+class MaxOriginsReachedError extends UndiciError {
+  constructor (message) {
+    super(message)
+    this.name = 'MaxOriginsReachedError'
+    this.message = message || 'Maximum allowed origins reached'
+    this.code = 'UND_ERR_MAX_ORIGINS_REACHED'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kMaxOriginsReachedError] === true
+  }
+
+  get [kMaxOriginsReachedError] () {
+    return true
+  }
 }
 
 module.exports = {
@@ -226,7 +430,6 @@ module.exports = {
   BodyTimeoutError,
   RequestContentLengthMismatchError,
   ConnectTimeoutError,
-  ResponseStatusCodeError,
   InvalidArgumentError,
   InvalidReturnValueError,
   RequestAbortedError,
@@ -240,5 +443,6 @@ module.exports = {
   ResponseExceededMaxSizeError,
   RequestRetryError,
   ResponseError,
-  SecureProxyConnectionError
+  SecureProxyConnectionError,
+  MaxOriginsReachedError
 }

package/lib/core/request.js

@@ -17,7 +17,8 @@ const {
   serializePathWithQuery,
   assertRequestHandler,
   getServerName,
-  normalizedMethodRecords
+  normalizedMethodRecords,
+  getProtocolFromUrlString
 } = require('./util')
 const { channels } = require('./diagnostics.js')
 const { headerNameLowerCasedRecord } = require('./constants')
@@ -141,8 +142,11 @@ class Request {
 
     this.path = query ? serializePathWithQuery(path, query) : path
 
+    // TODO: shall we maybe standardize it to an URL object?
     this.origin = origin
 
+    this.protocol = getProtocolFromUrlString(origin)
+
     this.idempotent = idempotent == null
       ? method === 'HEAD' || method === 'GET'
       : idempotent