undici 7.9.0 → 7.11.0

package/lib/web/{fetch/webidl.js → webidl/index.js}

@@ -2,7 +2,6 @@
 
 const { types, inspect } = require('node:util')
 const { markAsUncloneable } = require('node:worker_threads')
-const { toUSVString } = require('../../core/util')
 
 const UNDEFINED = 1
 const BOOLEAN = 2
@@ -23,22 +22,48 @@ const webidl = {
   is: {}
 }
 
+/**
+ * @description Instantiate an error.
+ *
+ * @param {Object} opts
+ * @param {string} opts.header
+ * @param {string} opts.message
+ * @returns {TypeError}
+ */
 webidl.errors.exception = function (message) {
   return new TypeError(`${message.header}: ${message.message}`)
 }
 
-webidl.errors.conversionFailed = function (context) {
-  const plural = context.types.length === 1 ? '' : ' one of'
+/**
+ * @description Instantiate an error when conversion from one type to another has failed.
+ *
+ * @param {Object} opts
+ * @param {string} opts.prefix
+ * @param {string} opts.argument
+ * @param {string[]} opts.types
+ * @returns {TypeError}
+ */
+webidl.errors.conversionFailed = function (opts) {
+  const plural = opts.types.length === 1 ? '' : ' one of'
   const message =
-    `${context.argument} could not be converted to` +
-    `${plural}: ${context.types.join(', ')}.`
+    `${opts.argument} could not be converted to` +
+    `${plural}: ${opts.types.join(', ')}.`
 
   return webidl.errors.exception({
-    header: context.prefix,
+    header: opts.prefix,
     message
   })
 }
 
+/**
+ * @description Instantiate an error when an invalid argument is provided
+ *
+ * @param {Object} context
+ * @param {string} context.prefix
+ * @param {string} context.value
+ * @param {string} context.type
+ * @returns {TypeError}
+ */
 webidl.errors.invalidArgument = function (context) {
   return webidl.errors.exception({
     header: context.prefix,
@@ -278,6 +303,8 @@ webidl.util.Stringify = function (V) {
       return inspect(V)
     case STRING:
       return `"${V}"`
+    case BIGINT:
+      return `${V}n`
     default:
       return `${V}`
   }
@@ -468,6 +495,17 @@ webidl.nullableConverter = function (converter) {
   }
 }
 
+/**
+ * @param {*} value
+ * @returns {boolean}
+ */
+webidl.is.USVString = function (value) {
+  return (
+    typeof value === 'string' &&
+    value.isWellFormed()
+  )
+}
+
 webidl.is.ReadableStream = webidl.util.MakeTypeAssertion(ReadableStream)
 webidl.is.Blob = webidl.util.MakeTypeAssertion(Blob)
 webidl.is.URLSearchParams = webidl.util.MakeTypeAssertion(URLSearchParams)
@@ -529,13 +567,23 @@ webidl.converters.ByteString = function (V, prefix, argument) {
   return x
 }
 
-// https://webidl.spec.whatwg.org/#es-USVString
-// TODO: rewrite this so we can control the errors thrown
-webidl.converters.USVString = toUSVString
+/**
+ * @param {unknown} value
+ * @returns {string}
+ * @see https://webidl.spec.whatwg.org/#es-USVString
+ */
+webidl.converters.USVString = function (value) {
+  // TODO: rewrite this so we can control the errors thrown
+  if (typeof value === 'string') {
+    return value.toWellFormed()
+  }
+  return `${value}`.toWellFormed()
+}
 
 // https://webidl.spec.whatwg.org/#es-boolean
 webidl.converters.boolean = function (V) {
   // 1. Let x be the result of computing ToBoolean(V).
+  // https://262.ecma-international.org/10.0/index.html#table-10
   const x = Boolean(V)
 
   // 2. Return the IDL boolean value that is the one that represents

package/lib/web/websocket/connection.js

@@ -105,7 +105,7 @@ function establishWebSocketConnection (url, protocols, client, handler, options)
       // 1. If response is a network error or its status is not 101,
       //    fail the WebSocket connection.
       if (response.type === 'error' || response.status !== 101) {
-        failWebsocketConnection(handler, 1002, 'Received network error or non-101 status code.')
+        failWebsocketConnection(handler, 1002, 'Received network error or non-101 status code.', response.error)
         return
       }
 
@@ -298,9 +298,10 @@ function closeWebSocketConnection (object, code, reason, validate = false) {
  * @param {import('./websocket').Handler} handler
  * @param {number} code
  * @param {string|undefined} reason
+ * @param {unknown} cause
  * @returns {void}
  */
-function failWebsocketConnection (handler, code, reason) {
+function failWebsocketConnection (handler, code, reason, cause) {
   // If _The WebSocket Connection is Established_ prior to the point where
   // the endpoint is required to _Fail the WebSocket Connection_, the
   // endpoint SHOULD send a Close frame with an appropriate status code
@@ -315,7 +316,7 @@ function failWebsocketConnection (handler, code, reason) {
     handler.socket.destroy()
   }
 
-  handler.onFail(code, reason)
+  handler.onFail(code, reason, cause)
 }
 
 module.exports = {

package/lib/web/websocket/events.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { webidl } = require('../fetch/webidl')
+const { webidl } = require('../webidl')
 const { kEnumerableProperty } = require('../../core/util')
 const { kConstruct } = require('../../core/symbols')
 

package/lib/web/websocket/frame.js

@@ -134,5 +134,6 @@ class WebsocketFrameSend {
 }
 
 module.exports = {
-  WebsocketFrameSend
+  WebsocketFrameSend,
+  generateMask // for benchmark
 }

package/lib/web/websocket/stream/websocketerror.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { webidl } = require('../../fetch/webidl')
+const { webidl } = require('../../webidl')
 const { validateCloseCodeAndReason } = require('../util')
 const { kConstruct } = require('../../../core/symbols')
 const { kEnumerableProperty } = require('../../../core/util')

package/lib/web/websocket/stream/websocketstream.js

@@ -2,7 +2,7 @@
 
 const { createDeferredPromise, environmentSettingsObject } = require('../../fetch/util')
 const { states, opcodes, sentCloseFrameState } = require('../constants')
-const { webidl } = require('../../fetch/webidl')
+const { webidl } = require('../../webidl')
 const { getURLRecord, isValidSubprotocol, isEstablished, utf8Decode } = require('../util')
 const { establishWebSocketConnection, failWebsocketConnection, closeWebSocketConnection } = require('../connection')
 const { types } = require('node:util')

package/lib/web/websocket/websocket.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { webidl } = require('../fetch/webidl')
+const { webidl } = require('../webidl')
 const { URLSerializer } = require('../fetch/data-url')
 const { environmentSettingsObject } = require('../fetch/util')
 const { staticPropertyDescriptors, states, sentCloseFrameState, sendHints, opcodes } = require('./constants')
@@ -60,7 +60,7 @@ class WebSocket extends EventTarget {
   /** @type {Handler} */
   #handler = {
     onConnectionEstablished: (response, extensions) => this.#onConnectionEstablished(response, extensions),
-    onFail: (code, reason) => this.#onFail(code, reason),
+    onFail: (code, reason, cause) => this.#onFail(code, reason, cause),
     onMessage: (opcode, data) => this.#onMessage(opcode, data),
     onParserError: (err) => failWebsocketConnection(this.#handler, null, err.message),
     onParserDrain: () => this.#onParserDrain(),
@@ -462,11 +462,11 @@ class WebSocket extends EventTarget {
     fireEvent('open', this)
   }
 
-  #onFail (code, reason) {
+  #onFail (code, reason, cause) {
     if (reason) {
       // TODO: process.nextTick
       fireEvent('error', this, (type, init) => new ErrorEvent(type, init), {
-        error: new Error(reason),
+        error: new Error(reason, cause ? { cause } : undefined),
         message: reason
       })
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "undici",
-  "version": "7.9.0",
+  "version": "7.11.0",
   "description": "An HTTP/1.1 client, written from scratch for Node.js",
   "homepage": "https://undici.nodejs.org",
   "bugs": {
@@ -112,20 +112,20 @@
     "@sinonjs/fake-timers": "^12.0.0",
     "@types/node": "^18.19.50",
     "abort-controller": "^3.0.0",
-    "borp": "^0.19.0",
+    "borp": "^0.20.0",
     "c8": "^10.0.0",
     "cross-env": "^7.0.3",
     "dns-packet": "^5.4.0",
     "esbuild": "^0.25.2",
     "eslint": "^9.9.0",
-    "fast-check": "^3.17.1",
+    "fast-check": "^4.1.1",
     "https-pem": "^3.0.0",
     "husky": "^9.0.7",
     "jest": "^29.0.2",
     "neostandard": "^0.12.0",
     "node-forge": "^1.3.1",
     "proxy": "^2.1.1",
-    "tsd": "^0.31.2",
+    "tsd": "^0.32.0",
     "typescript": "^5.6.2",
     "ws": "^8.11.0"
   },

package/types/diagnostics-channel.d.ts

@@ -31,6 +31,15 @@ declare namespace DiagnosticsChannel {
   export interface RequestBodySentMessage {
     request: Request;
   }
+
+  export interface RequestBodyChunkSentMessage {
+    request: Request;
+    chunk: Uint8Array | string;
+  }
+  export interface RequestBodyChunkReceivedMessage {
+    request: Request;
+    chunk: Buffer;
+  }
   export interface RequestHeadersMessage {
     request: Request;
     response: Response;

package/types/dispatcher.d.ts

@@ -97,7 +97,8 @@ declare class Dispatcher extends EventEmitter {
 
 declare namespace Dispatcher {
   export interface ComposedDispatcher extends Dispatcher {}
-  export type DispatcherComposeInterceptor = (dispatch: Dispatcher['dispatch']) => Dispatcher['dispatch']
+  export type Dispatch = Dispatcher['dispatch']
+  export type DispatcherComposeInterceptor = (dispatch: Dispatch) => Dispatch
   export interface DispatchOptions {
     origin?: string | URL;
     path: string;
@@ -276,6 +277,6 @@ declare namespace Dispatcher {
   }
 
   export interface DispatchInterceptor {
-    (dispatch: Dispatcher['dispatch']): Dispatcher['dispatch']
+    (dispatch: Dispatch): Dispatch
   }
 }

package/types/env-http-proxy-agent.d.ts

@@ -1,4 +1,5 @@
 import Agent from './agent'
+import ProxyAgent from './proxy-agent'
 import Dispatcher from './dispatcher'
 
 export default EnvHttpProxyAgent
@@ -10,7 +11,7 @@ declare class EnvHttpProxyAgent extends Dispatcher {
 }
 
 declare namespace EnvHttpProxyAgent {
-  export interface Options extends Agent.Options {
+  export interface Options extends Omit<ProxyAgent.Options, 'uri'> {
     /** Overrides the value of the HTTP_PROXY environment variable  */
     httpProxy?: string;
     /** Overrides the value of the HTTPS_PROXY environment variable  */

package/types/eventsource.d.ts

@@ -18,9 +18,9 @@ interface EventSource extends EventTarget {
   readonly CLOSED: 2
   readonly CONNECTING: 0
   readonly OPEN: 1
-  onerror: (this: EventSource, ev: ErrorEvent) => any
-  onmessage: (this: EventSource, ev: MessageEvent) => any
-  onopen: (this: EventSource, ev: Event) => any
+  onerror: ((this: EventSource, ev: ErrorEvent) => any) | null
+  onmessage: ((this: EventSource, ev: MessageEvent) => any) | null
+  onopen: ((this: EventSource, ev: Event) => any) | null
   readonly readyState: 0 | 1 | 2
   readonly url: string
   readonly withCredentials: boolean

package/types/fetch.d.ts

@@ -33,6 +33,7 @@ export class BodyMixin {
 
   readonly arrayBuffer: () => Promise<ArrayBuffer>
   readonly blob: () => Promise<Blob>
+  readonly bytes: () => Promise<Uint8Array>
   /**
    * @deprecated This method is not recommended for parsing multipart/form-data bodies in server environments.
    * It is recommended to use a library such as [@fastify/busboy](https://www.npmjs.com/package/@fastify/busboy) as follows:

package/types/handlers.d.ts

@@ -2,7 +2,7 @@ import Dispatcher from './dispatcher'
 
 export declare class RedirectHandler implements Dispatcher.DispatchHandler {
   constructor (
-    dispatch: Dispatcher,
+    dispatch: Dispatcher.Dispatch,
     maxRedirections: number,
     opts: Dispatcher.DispatchOptions,
     handler: Dispatcher.DispatchHandler,

package/types/mock-client.d.ts

@@ -14,6 +14,8 @@ declare class MockClient extends Client implements Interceptable {
   dispatch (options: Dispatcher.DispatchOptions, handlers: Dispatcher.DispatchHandler): boolean
   /** Closes the mock client and gracefully waits for enqueued requests to complete. */
   close (): Promise<void>
+  /** Clean up all the prepared mocks. */
+  cleanMocks (): void
 }
 
 declare namespace MockClient {

package/types/mock-interceptor.d.ts

@@ -84,6 +84,8 @@ declare namespace MockInterceptor {
 interface Interceptable extends Dispatcher {
   /** Intercepts any matching requests that use the same origin as this mock client. */
   intercept(options: MockInterceptor.Options): MockInterceptor;
+  /** Clean up all the prepared mocks. */
+  cleanMocks (): void
 }
 
 export {

package/types/mock-pool.d.ts

@@ -14,6 +14,8 @@ declare class MockPool extends Pool implements Interceptable {
   dispatch (options: Dispatcher.DispatchOptions, handlers: Dispatcher.DispatchHandler): boolean
   /** Closes the mock pool and gracefully waits for enqueued requests to complete. */
   close (): Promise<void>
+  /** Clean up all the prepared mocks. */
+  cleanMocks (): void
 }
 
 declare namespace MockPool {

package/types/pool.d.ts

@@ -33,6 +33,8 @@ declare namespace Pool {
     factory?(origin: URL, opts: object): Dispatcher;
     /** The max number of clients to create. `null` if no limit. Default `null`. */
     connections?: number | null;
+    /** The amount of time before a client is removed from the pool and closed. `null` if no time limit. Default `null` */
+    clientTtl?: number | null;
 
     interceptors?: { Pool?: readonly Dispatcher.DispatchInterceptor[] } & Client.Options['interceptors']
   }

package/types/proxy-agent.d.ts

@@ -24,5 +24,6 @@ declare namespace ProxyAgent {
     requestTls?: buildConnector.BuildOptions;
     proxyTls?: buildConnector.BuildOptions;
     clientFactory?(origin: URL, opts: object): Dispatcher;
+    proxyTunnel?: boolean;
   }
 }

package/types/retry-handler.d.ts

@@ -35,6 +35,15 @@ declare namespace RetryHandler {
   ) => void
 
   export interface RetryOptions {
+    /**
+     * If true, the retry handler will throw an error if the request fails,
+     * this will prevent the folling handlers from being called, and will destroy the socket.
+     *
+     * @type {boolean}
+     * @memberof RetryOptions
+     * @default true
+     */
+    throwOnError?: boolean;
     /**
      * Callback to be invoked on every retry iteration.
      * It receives the error, current state of the retry object and the options object

package/types/webidl.d.ts

@@ -16,9 +16,12 @@ interface ConvertToIntOpts {
 }
 
 interface WebidlErrors {
+  /**
+   * @description Instantiate an error
+   */
   exception (opts: { header: string, message: string }): TypeError
   /**
-   * @description Throw an error when conversion from one type to another has failed
+   * @description Instantiate an error when conversion from one type to another has failed
    */
   conversionFailed (opts: {
     prefix: string
@@ -75,7 +78,7 @@ interface WebidlUtil {
   ): number
 
   /**
-   * @see https://webidl.spec.whatwg.org/#abstract-opdef-converttoint
+   * @see https://webidl.spec.whatwg.org/#abstract-opdef-integerpart
    */
   IntegerPart (N: number): number
 
@@ -182,20 +185,21 @@ interface WebidlConverters {
   [Key: string]: (...args: any[]) => unknown
 }
 
-type IsAssertion<T> = (arg: any) => arg is T
+type WebidlIsFunction<T> = (arg: any) => arg is T
 
 interface WebidlIs {
-  Request: IsAssertion<undici.Request>
-  Response: IsAssertion<undici.Response>
-  ReadableStream: IsAssertion<ReadableStream>
-  Blob: IsAssertion<Blob>
-  URLSearchParams: IsAssertion<URLSearchParams>
-  File: IsAssertion<File>
-  FormData: IsAssertion<undici.FormData>
-  URL: IsAssertion<URL>
-  WebSocketError: IsAssertion<undici.WebSocketError>
-  AbortSignal: IsAssertion<AbortSignal>
-  MessagePort: IsAssertion<MessagePort>
+  Request: WebidlIsFunction<undici.Request>
+  Response: WebidlIsFunction<undici.Response>
+  ReadableStream: WebidlIsFunction<ReadableStream>
+  Blob: WebidlIsFunction<Blob>
+  URLSearchParams: WebidlIsFunction<URLSearchParams>
+  File: WebidlIsFunction<File>
+  FormData: WebidlIsFunction<undici.FormData>
+  URL: WebidlIsFunction<URL>
+  WebSocketError: WebidlIsFunction<undici.WebSocketError>
+  AbortSignal: WebidlIsFunction<AbortSignal>
+  MessagePort: WebidlIsFunction<MessagePort>
+  USVString: WebidlIsFunction<string>
 }
 
 export interface Webidl {
@@ -233,7 +237,7 @@ export interface Webidl {
    * Similar to {@link Webidl.brandCheck} but allows skipping the check if third party
    * interfaces are allowed.
    */
-  interfaceConverter <Interface>(typeCheck: IsAssertion<Interface>, name: string): (
+  interfaceConverter <Interface>(typeCheck: WebidlIsFunction<Interface>, name: string): (
     V: unknown,
     prefix: string,
     argument: string

package/types/websocket.d.ts

@@ -136,7 +136,7 @@ interface ErrorEvent extends Event {
   readonly filename: string
   readonly lineno: number
   readonly colno: number
-  readonly error: any
+  readonly error: Error
 }
 
 export declare const ErrorEvent: {