undici 7.11.0 → 7.13.0

package/lib/web/fetch/util.js

@@ -924,17 +924,6 @@ function sameOrigin (A, B) {
   return false
 }
 
-function createDeferredPromise () {
-  let res
-  let rej
-  const promise = new Promise((resolve, reject) => {
-    res = resolve
-    rej = reject
-  })
-
-  return { promise, resolve: res, reject: rej }
-}
-
 function isAborted (fetchParams) {
   return fetchParams.controller.state === 'aborted'
 }
@@ -1177,6 +1166,11 @@ function iteratorMixin (name, object, kInternalIterator, keyIndex = 0, valueInde
 }
 
 /**
+ * @param {import('./body').ExtractBodyResult} body
+ * @param {(bytes: Uint8Array) => void} processBody
+ * @param {(error: Error) => void} processBodyError
+ * @returns {void}
+ *
  * @see https://fetch.spec.whatwg.org/#body-fully-read
  */
 function fullyReadBody (body, processBody, processBodyError) {
@@ -1191,20 +1185,17 @@ function fullyReadBody (body, processBody, processBodyError) {
   //    with taskDestination.
   const errorSteps = processBodyError
 
+  try {
   // 4. Let reader be the result of getting a reader for body’s stream.
   //    If that threw an exception, then run errorSteps with that
   //    exception and return.
-  let reader
+    const reader = body.stream.getReader()
 
-  try {
-    reader = body.stream.getReader()
+    // 5. Read all bytes from reader, given successSteps and errorSteps.
+    readAllBytes(reader, successSteps, errorSteps)
   } catch (e) {
     errorSteps(e)
-    return
   }
-
-  // 5. Read all bytes from reader, given successSteps and errorSteps.
-  readAllBytes(reader, successSteps, errorSteps)
 }
 
 /**
@@ -1241,15 +1232,16 @@ function isomorphicEncode (input) {
 /**
  * @see https://streams.spec.whatwg.org/#readablestreamdefaultreader-read-all-bytes
  * @see https://streams.spec.whatwg.org/#read-loop
- * @param {ReadableStreamDefaultReader} reader
+ * @param {ReadableStream<Uint8Array<ArrayBuffer>>} reader
  * @param {(bytes: Uint8Array) => void} successSteps
  * @param {(error: Error) => void} failureSteps
+ * @returns {Promise<void>}
  */
 async function readAllBytes (reader, successSteps, failureSteps) {
-  const bytes = []
-  let byteLength = 0
-
   try {
+    const bytes = []
+    let byteLength = 0
+
     do {
       const { done, value: chunk } = await reader.read()
 
@@ -1324,10 +1316,17 @@ function urlIsHttpHttpsScheme (url) {
   return protocol === 'http:' || protocol === 'https:'
 }
 
+/**
+ * @typedef {Object} RangeHeaderValue
+ * @property {number|null} rangeStartValue
+ * @property {number|null} rangeEndValue
+ */
+
 /**
  * @see https://fetch.spec.whatwg.org/#simple-range-header-value
  * @param {string} value
  * @param {boolean} allowWhitespace
+ * @return {RangeHeaderValue|'failure'}
  */
 function simpleRangeHeaderValue (value, allowWhitespace) {
   // 1. Let data be the isomorphic decoding of value.
@@ -1732,7 +1731,6 @@ module.exports = {
   isAborted,
   isCancelled,
   isValidEncodedURL,
-  createDeferredPromise,
   ReadableStreamFrom,
   tryUpgradeRequestToAPotentiallyTrustworthyURL,
   clampAndCoarsenConnectionTimingInfo,

package/lib/web/webidl/index.js

@@ -509,7 +509,7 @@ webidl.is.USVString = function (value) {
 webidl.is.ReadableStream = webidl.util.MakeTypeAssertion(ReadableStream)
 webidl.is.Blob = webidl.util.MakeTypeAssertion(Blob)
 webidl.is.URLSearchParams = webidl.util.MakeTypeAssertion(URLSearchParams)
-webidl.is.File = webidl.util.MakeTypeAssertion(globalThis.File ?? require('node:buffer').File)
+webidl.is.File = webidl.util.MakeTypeAssertion(File)
 webidl.is.URL = webidl.util.MakeTypeAssertion(URL)
 webidl.is.AbortSignal = webidl.util.MakeTypeAssertion(AbortSignal)
 webidl.is.MessagePort = webidl.util.MakeTypeAssertion(MessagePort)

package/lib/web/websocket/connection.js

@@ -2,7 +2,6 @@
 
 const { uid, states, sentCloseFrameState, emptyBuffer, opcodes } = require('./constants')
 const { parseExtensions, isClosed, isClosing, isEstablished, validateCloseCodeAndReason } = require('./util')
-const { channels } = require('../../core/diagnostics')
 const { makeRequest } = require('../fetch/request')
 const { fetching } = require('../fetch/index')
 const { Headers, getHeadersList } = require('../fetch/headers')
@@ -200,14 +199,6 @@ function establishWebSocketConnection (url, protocols, client, handler, options)
       response.socket.on('close', handler.onSocketClose)
       response.socket.on('error', handler.onSocketError)
 
-      if (channels.open.hasSubscribers) {
-        channels.open.publish({
-          address: response.socket.address(),
-          protocol: secProtocol,
-          extensions: secExtension
-        })
-      }
-
       handler.wasEverConnected = true
       handler.onConnectionEstablished(response, extensions)
     }

package/lib/web/websocket/receiver.js

@@ -3,7 +3,6 @@
 const { Writable } = require('node:stream')
 const assert = require('node:assert')
 const { parserStates, opcodes, states, emptyBuffer, sentCloseFrameState } = require('./constants')
-const { channels } = require('../../core/diagnostics')
 const {
   isValidStatusCode,
   isValidOpcode,
@@ -423,22 +422,13 @@ class ByteParser extends Writable {
 
         this.#handler.socket.write(frame.createFrame(opcodes.PONG))
 
-        if (channels.ping.hasSubscribers) {
-          channels.ping.publish({
-            payload: body
-          })
-        }
+        this.#handler.onPing(body)
       }
     } else if (opcode === opcodes.PONG) {
       // A Pong frame MAY be sent unsolicited.  This serves as a
       // unidirectional heartbeat.  A response to an unsolicited Pong frame is
       // not expected.
-
-      if (channels.pong.hasSubscribers) {
-        channels.pong.publish({
-          payload: body
-        })
-      }
+      this.#handler.onPong(body)
     }
 
     return true

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

@@ -1,6 +1,7 @@
 'use strict'
 
-const { createDeferredPromise, environmentSettingsObject } = require('../../fetch/util')
+const { createDeferredPromise } = require('../../../util/promise')
+const { environmentSettingsObject } = require('../../fetch/util')
 const { states, opcodes, sentCloseFrameState } = require('../constants')
 const { webidl } = require('../../webidl')
 const { getURLRecord, isValidSubprotocol, isEstablished, utf8Decode } = require('../util')
@@ -21,11 +22,11 @@ class WebSocketStream {
   #url
 
   // Each WebSocketStream object has an associated opened promise , which is a promise.
-  /** @type {ReturnType<typeof createDeferredPromise>} */
+  /** @type {import('../../../util/promise').DeferredPromise} */
   #openedPromise
 
   // Each WebSocketStream object has an associated closed promise , which is a promise.
-  /** @type {ReturnType<typeof createDeferredPromise>} */
+  /** @type {import('../../../util/promise').DeferredPromise} */
   #closedPromise
 
   // Each WebSocketStream object has an associated readable stream , which is a ReadableStream .
@@ -64,6 +65,8 @@ class WebSocketStream {
       this.#handler.socket.destroy()
     },
     onSocketClose: () => this.#onSocketClose(),
+    onPing: () => {},
+    onPong: () => {},
 
     readyState: states.CONNECTING,
     socket: null,
@@ -388,7 +391,7 @@ class WebSocketStream {
     // 6. If the connection was closed cleanly ,
     if (wasClean) {
       // 6.1. Close stream ’s readable stream .
-      this.#readableStream.cancel().catch(() => {})
+      this.#readableStreamController.close()
 
       // 6.2. Error stream ’s writable stream with an " InvalidStateError " DOMException indicating that a closed WebSocketStream cannot be written to.
       if (!this.#writableStream.locked) {

package/lib/web/websocket/websocket.js

@@ -8,6 +8,7 @@ const {
   isConnecting,
   isEstablished,
   isClosing,
+  isClosed,
   isValidSubprotocol,
   fireEvent,
   utf8Decode,
@@ -21,6 +22,7 @@ const { getGlobalDispatcher } = require('../../global')
 const { types } = require('node:util')
 const { ErrorEvent, CloseEvent, createFastMessageEvent } = require('./events')
 const { SendQueue } = require('./sender')
+const { WebsocketFrameSend } = require('./frame')
 const { channels } = require('../../core/diagnostics')
 
 /**
@@ -33,6 +35,8 @@ const { channels } = require('../../core/diagnostics')
  * @property {(chunk: Buffer) => void} onSocketData
  * @property {(err: Error) => void} onSocketError
  * @property {() => void} onSocketClose
+ * @property {(body: Buffer) => void} onPing
+ * @property {(body: Buffer) => void} onPong
  *
  * @property {number} readyState
  * @property {import('stream').Duplex} socket
@@ -79,6 +83,22 @@ class WebSocket extends EventTarget {
       this.#handler.socket.destroy()
     },
     onSocketClose: () => this.#onSocketClose(),
+    onPing: (body) => {
+      if (channels.ping.hasSubscribers) {
+        channels.ping.publish({
+          payload: body,
+          websocket: this
+        })
+      }
+    },
+    onPong: (body) => {
+      if (channels.pong.hasSubscribers) {
+        channels.pong.publish({
+          payload: body,
+          websocket: this
+        })
+      }
+    },
 
     readyState: states.CONNECTING,
     socket: null,
@@ -460,6 +480,15 @@ class WebSocket extends EventTarget {
 
     // 4. Fire an event named open at the WebSocket object.
     fireEvent('open', this)
+
+    if (channels.open.hasSubscribers) {
+      channels.open.publish({
+        address: response.socket.address(),
+        protocol: this.#protocol,
+        extensions: this.#extensions,
+        websocket: this
+      })
+    }
   }
 
   #onFail (code, reason, cause) {
@@ -586,8 +615,34 @@ class WebSocket extends EventTarget {
       })
     }
   }
+
+  /**
+   * @param {WebSocket} ws
+   * @param {Buffer|undefined} buffer
+   */
+  static ping (ws, buffer) {
+    if (Buffer.isBuffer(buffer)) {
+      if (buffer.length > 125) {
+        throw new TypeError('A PING frame cannot have a body larger than 125 bytes.')
+      }
+    } else if (buffer !== undefined) {
+      throw new TypeError('Expected buffer payload')
+    }
+
+    // An endpoint MAY send a Ping frame any time after the connection is
+    // established and before the connection is closed.
+    const readyState = ws.#handler.readyState
+
+    if (isEstablished(readyState) && !isClosing(readyState) && !isClosed(readyState)) {
+      const frame = new WebsocketFrameSend(buffer)
+      ws.#handler.socket.write(frame.createFrame(opcodes.PING))
+    }
+  }
 }
 
+const { ping } = WebSocket
+Reflect.deleteProperty(WebSocket, 'ping')
+
 // https://websockets.spec.whatwg.org/#dom-websocket-connecting
 WebSocket.CONNECTING = WebSocket.prototype.CONNECTING = states.CONNECTING
 // https://websockets.spec.whatwg.org/#dom-websocket-open
@@ -682,5 +737,6 @@ webidl.converters.WebSocketSendData = function (V) {
 }
 
 module.exports = {
-  WebSocket
+  WebSocket,
+  ping
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "undici",
-  "version": "7.11.0",
+  "version": "7.13.0",
   "description": "An HTTP/1.1 client, written from scratch for Node.js",
   "homepage": "https://undici.nodejs.org",
   "bugs": {
@@ -91,7 +91,7 @@
     "test:tdd:node-test": "borp -p \"test/node-test/**/*.js\" -w",
     "test:typescript": "tsd && tsc test/imports/undici-import.ts --typeRoots ./types --noEmit && tsc ./types/*.d.ts --noEmit --typeRoots ./types",
     "test:webidl": "borp -p \"test/webidl/*.js\"",
-    "test:websocket": "borp -p \"test/websocket/*.js\"",
+    "test:websocket": "borp -p \"test/websocket/**/*.js\"",
     "test:websocket:autobahn": "node test/autobahn/client.js",
     "test:websocket:autobahn:report": "node test/autobahn/report.js",
     "test:wpt": "node test/wpt/start-fetch.mjs && node test/wpt/start-mimesniff.mjs && node test/wpt/start-xhr.mjs && node test/wpt/start-websockets.mjs && node test/wpt/start-cacheStorage.mjs && node test/wpt/start-eventsource.mjs",

package/types/agent.d.ts

@@ -22,14 +22,10 @@ declare namespace Agent {
   export interface Options extends Pool.Options {
     /** Default: `(origin, opts) => new Pool(origin, opts)`. */
     factory?(origin: string | URL, opts: Object): Dispatcher;
-    /** Integer. Default: `0` */
-    maxRedirections?: number;
 
     interceptors?: { Agent?: readonly Dispatcher.DispatchInterceptor[] } & Pool.Options['interceptors']
   }
 
   export interface DispatchOptions extends Dispatcher.DispatchOptions {
-    /** Integer. */
-    maxRedirections?: number;
   }
 }

package/types/client.d.ts

@@ -71,8 +71,6 @@ export declare namespace Client {
     /** TODO */
     maxCachedSessions?: number;
     /** TODO */
-    maxRedirections?: number;
-    /** TODO */
     connect?: Partial<buildConnector.BuildOptions> | buildConnector.connector;
     /** TODO */
     maxRequestsPerClient?: number;

package/types/dispatcher.d.ts

@@ -135,8 +135,6 @@ declare namespace Dispatcher {
     signal?: AbortSignal | EventEmitter | null;
     /** This argument parameter is passed through to `ConnectData` */
     opaque?: TOpaque;
-    /** Default: 0 */
-    maxRedirections?: number;
     /** Default: false */
     redirectionLimitReached?: boolean;
     /** Default: `null` */
@@ -147,8 +145,6 @@ declare namespace Dispatcher {
     opaque?: TOpaque;
     /** Default: `null` */
     signal?: AbortSignal | EventEmitter | null;
-    /** Default: 0 */
-    maxRedirections?: number;
     /** Default: false */
     redirectionLimitReached?: boolean;
     /** Default: `null` */
@@ -172,8 +168,6 @@ declare namespace Dispatcher {
     protocol?: string;
     /** Default: `null` */
     signal?: AbortSignal | EventEmitter | null;
-    /** Default: 0 */
-    maxRedirections?: number;
     /** Default: false */
     redirectionLimitReached?: boolean;
     /** Default: `null` */

package/types/h2c-client.d.ts

@@ -51,8 +51,6 @@ export declare namespace H2CClient {
     /** TODO */
     maxCachedSessions?: number;
     /** TODO */
-    maxRedirections?: number;
-    /** TODO */
     connect?: Omit<Partial<buildConnector.BuildOptions>, 'allowH2'> | buildConnector.connector;
     /** TODO */
     maxRequestsPerClient?: number;

package/types/index.d.ts

@@ -13,6 +13,7 @@ import Agent from './agent'
 import MockClient from './mock-client'
 import MockPool from './mock-pool'
 import MockAgent from './mock-agent'
+import { SnapshotAgent } from './snapshot-agent'
 import { MockCallHistory, MockCallHistoryLog } from './mock-call-history'
 import mockErrors from './mock-errors'
 import ProxyAgent from './proxy-agent'
@@ -33,7 +34,7 @@ export * from './content-type'
 export * from './cache'
 export { Interceptable } from './mock-interceptor'
 
-export { Dispatcher, BalancedPool, Pool, Client, buildConnector, errors, Agent, request, stream, pipeline, connect, upgrade, setGlobalDispatcher, getGlobalDispatcher, setGlobalOrigin, getGlobalOrigin, interceptors, MockClient, MockPool, MockAgent, MockCallHistory, MockCallHistoryLog, mockErrors, ProxyAgent, EnvHttpProxyAgent, RedirectHandler, DecoratorHandler, RetryHandler, RetryAgent, H2CClient }
+export { Dispatcher, BalancedPool, Pool, Client, buildConnector, errors, Agent, request, stream, pipeline, connect, upgrade, setGlobalDispatcher, getGlobalDispatcher, setGlobalOrigin, getGlobalOrigin, interceptors, MockClient, MockPool, MockAgent, SnapshotAgent, MockCallHistory, MockCallHistoryLog, mockErrors, ProxyAgent, EnvHttpProxyAgent, RedirectHandler, DecoratorHandler, RetryHandler, RetryAgent, H2CClient }
 export default Undici
 
 declare namespace Undici {
@@ -58,6 +59,7 @@ declare namespace Undici {
   const MockClient: typeof import('./mock-client').default
   const MockPool: typeof import('./mock-pool').default
   const MockAgent: typeof import('./mock-agent').default
+  const SnapshotAgent: typeof import('./snapshot-agent').SnapshotAgent
   const MockCallHistory: typeof import('./mock-call-history').MockCallHistory
   const MockCallHistoryLog: typeof import('./mock-call-history').MockCallHistoryLog
   const mockErrors: typeof import('./mock-errors').default

package/types/mock-interceptor.d.ts

@@ -69,7 +69,6 @@ declare namespace MockInterceptor {
     headers?: Headers | Record<string, string>;
     origin?: string;
     body?: BodyInit | Dispatcher.DispatchOptions['body'] | null;
-    maxRedirections?: number;
   }
 
   export type MockResponseDataHandler<TData extends object = object> = (

package/types/snapshot-agent.d.ts

@@ -0,0 +1,107 @@
+import MockAgent from './mock-agent'
+
+declare class SnapshotRecorder {
+  constructor (options?: SnapshotRecorder.Options)
+
+  record (requestOpts: any, response: any): Promise<void>
+  findSnapshot (requestOpts: any): SnapshotRecorder.Snapshot | undefined
+  loadSnapshots (filePath?: string): Promise<void>
+  saveSnapshots (filePath?: string): Promise<void>
+  clear (): void
+  getSnapshots (): SnapshotRecorder.Snapshot[]
+  size (): number
+  resetCallCounts (): void
+  deleteSnapshot (requestOpts: any): boolean
+  getSnapshotInfo (requestOpts: any): SnapshotRecorder.SnapshotInfo | null
+  replaceSnapshots (snapshotData: SnapshotRecorder.SnapshotData[]): void
+  destroy (): void
+}
+
+declare namespace SnapshotRecorder {
+  export interface Options {
+    snapshotPath?: string
+    mode?: 'record' | 'playback' | 'update'
+    maxSnapshots?: number
+    autoFlush?: boolean
+    flushInterval?: number
+    matchHeaders?: string[]
+    ignoreHeaders?: string[]
+    excludeHeaders?: string[]
+    matchBody?: boolean
+    matchQuery?: boolean
+    caseSensitive?: boolean
+    shouldRecord?: (requestOpts: any) => boolean
+    shouldPlayback?: (requestOpts: any) => boolean
+    excludeUrls?: (string | RegExp)[]
+  }
+
+  export interface Snapshot {
+    request: {
+      method: string
+      url: string
+      headers: Record<string, string>
+      body?: string
+    }
+    responses: {
+      statusCode: number
+      headers: Record<string, string>
+      body: string
+      trailers: Record<string, string>
+    }[]
+    callCount: number
+    timestamp: string
+  }
+
+  export interface SnapshotInfo {
+    hash: string
+    request: {
+      method: string
+      url: string
+      headers: Record<string, string>
+      body?: string
+    }
+    responseCount: number
+    callCount: number
+    timestamp: string
+  }
+
+  export interface SnapshotData {
+    hash: string
+    snapshot: Snapshot
+  }
+}
+
+declare class SnapshotAgent extends MockAgent {
+  constructor (options?: SnapshotAgent.Options)
+
+  saveSnapshots (filePath?: string): Promise<void>
+  loadSnapshots (filePath?: string): Promise<void>
+  getRecorder (): SnapshotRecorder
+  getMode (): 'record' | 'playback' | 'update'
+  clearSnapshots (): void
+  resetCallCounts (): void
+  deleteSnapshot (requestOpts: any): boolean
+  getSnapshotInfo (requestOpts: any): SnapshotRecorder.SnapshotInfo | null
+  replaceSnapshots (snapshotData: SnapshotRecorder.SnapshotData[]): void
+}
+
+declare namespace SnapshotAgent {
+  export interface Options extends MockAgent.Options {
+    mode?: 'record' | 'playback' | 'update'
+    snapshotPath?: string
+    maxSnapshots?: number
+    autoFlush?: boolean
+    flushInterval?: number
+    matchHeaders?: string[]
+    ignoreHeaders?: string[]
+    excludeHeaders?: string[]
+    matchBody?: boolean
+    matchQuery?: boolean
+    caseSensitive?: boolean
+    shouldRecord?: (requestOpts: any) => boolean
+    shouldPlayback?: (requestOpts: any) => boolean
+    excludeUrls?: (string | RegExp)[]
+  }
+}
+
+export { SnapshotAgent, SnapshotRecorder }

package/types/webidl.d.ts

@@ -182,6 +182,16 @@ interface WebidlConverters {
 
   ['record<ByteString, ByteString>']: RecordConverter<string, string>
 
+  /**
+  * @see https://fetch.spec.whatwg.org/#requestinfo
+  */
+  RequestInfo (V: unknown): undici.Request | string
+
+  /**
+   * @see https://fetch.spec.whatwg.org/#requestinit
+   */
+  RequestInit (V: unknown): undici.RequestInit
+
   [Key: string]: (...args: any[]) => unknown
 }
 

package/types/websocket.d.ts

@@ -182,3 +182,5 @@ export declare const WebSocketError: {
   prototype: WebSocketError
   new (type: string, init?: WebSocketCloseInfo): WebSocketError
 }
+
+export declare const ping: (ws: WebSocket, body?: Buffer) => void

package/lib/web/fetch/dispatcher-weakref.js

@@ -1,5 +0,0 @@
-'use strict'
-
-module.exports = function () {
-  return { WeakRef, FinalizationRegistry }
-}