undici 6.20.0 → 7.0.0-alpha.2

package/lib/api/api-stream.js

@@ -1,20 +1,21 @@
 'use strict'
 
 const assert = require('node:assert')
-const { finished, PassThrough } = require('node:stream')
+const { finished } = require('node:stream')
+const { AsyncResource } = require('node:async_hooks')
 const { InvalidArgumentError, InvalidReturnValueError } = require('../core/errors')
 const util = require('../core/util')
-const { getResolveErrorBodyCallback } = require('./util')
-const { AsyncResource } = require('node:async_hooks')
 const { addSignal, removeSignal } = require('./abort-signal')
 
+function noop () {}
+
 class StreamHandler extends AsyncResource {
   constructor (opts, factory, callback) {
     if (!opts || typeof opts !== 'object') {
       throw new InvalidArgumentError('invalid opts')
     }
 
-    const { signal, method, opaque, body, onInfo, responseHeaders, throwOnError } = opts
+    const { signal, method, opaque, body, onInfo, responseHeaders } = opts
 
     try {
       if (typeof callback !== 'function') {
@@ -40,7 +41,7 @@ class StreamHandler extends AsyncResource {
       super('UNDICI_STREAM')
     } catch (err) {
       if (util.isStream(body)) {
-        util.destroy(body.on('error', util.nop), err)
+        util.destroy(body.on('error', noop), err)
       }
       throw err
     }
@@ -55,7 +56,6 @@ class StreamHandler extends AsyncResource {
     this.trailers = null
     this.body = body
     this.onInfo = onInfo || null
-    this.throwOnError = throwOnError || false
 
     if (util.isStream(body)) {
       body.on('error', (err) => {
@@ -79,7 +79,7 @@ class StreamHandler extends AsyncResource {
   }
 
   onHeaders (statusCode, rawHeaders, resume, statusMessage) {
-    const { factory, opaque, context, callback, responseHeaders } = this
+    const { factory, opaque, context, responseHeaders } = this
 
     const headers = responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders)
 
@@ -92,55 +92,42 @@ class StreamHandler extends AsyncResource {
 
     this.factory = null
 
-    let res
+    if (factory === null) {
+      return
+    }
 
-    if (this.throwOnError && statusCode >= 400) {
-      const parsedHeaders = responseHeaders === 'raw' ? util.parseHeaders(rawHeaders) : headers
-      const contentType = parsedHeaders['content-type']
-      res = new PassThrough()
+    const res = this.runInAsyncScope(factory, null, {
+      statusCode,
+      headers,
+      opaque,
+      context
+    })
 
-      this.callback = null
-      this.runInAsyncScope(getResolveErrorBodyCallback, null,
-        { callback, body: res, contentType, statusCode, statusMessage, headers }
-      )
-    } else {
-      if (factory === null) {
-        return
-      }
+    if (
+      !res ||
+      typeof res.write !== 'function' ||
+      typeof res.end !== 'function' ||
+      typeof res.on !== 'function'
+    ) {
+      throw new InvalidReturnValueError('expected Writable')
+    }
 
-      res = this.runInAsyncScope(factory, null, {
-        statusCode,
-        headers,
-        opaque,
-        context
-      })
+    // TODO: Avoid finished. It registers an unnecessary amount of listeners.
+    finished(res, { readable: false }, (err) => {
+      const { callback, res, opaque, trailers, abort } = this
 
-      if (
-        !res ||
-        typeof res.write !== 'function' ||
-        typeof res.end !== 'function' ||
-        typeof res.on !== 'function'
-      ) {
-        throw new InvalidReturnValueError('expected Writable')
+      this.res = null
+      if (err || !res.readable) {
+        util.destroy(res, err)
       }
 
-      // TODO: Avoid finished. It registers an unnecessary amount of listeners.
-      finished(res, { readable: false }, (err) => {
-        const { callback, res, opaque, trailers, abort } = this
-
-        this.res = null
-        if (err || !res.readable) {
-          util.destroy(res, err)
-        }
-
-        this.callback = null
-        this.runInAsyncScope(callback, null, err || null, { opaque, trailers })
+      this.callback = null
+      this.runInAsyncScope(callback, null, err || null, { opaque, trailers })
 
-        if (err) {
-          abort()
-        }
-      })
-    }
+      if (err) {
+        abort()
+      }
+    })
 
     res.on('drain', resume)
 
@@ -207,7 +194,9 @@ function stream (opts, factory, callback) {
   }
 
   try {
-    this.dispatch(opts, new StreamHandler(opts, factory, callback))
+    const handler = new StreamHandler(opts, factory, callback)
+
+    this.dispatch(opts, handler)
   } catch (err) {
     if (typeof callback !== 'function') {
       throw err

package/lib/api/api-upgrade.js

@@ -2,9 +2,9 @@
 
 const { InvalidArgumentError, SocketError } = require('../core/errors')
 const { AsyncResource } = require('node:async_hooks')
+const assert = require('node:assert')
 const util = require('../core/util')
 const { addSignal, removeSignal } = require('./abort-signal')
-const assert = require('node:assert')
 
 class UpgradeHandler extends AsyncResource {
   constructor (opts, callback) {
@@ -91,11 +91,13 @@ function upgrade (opts, callback) {
 
   try {
     const upgradeHandler = new UpgradeHandler(opts, callback)
-    this.dispatch({
+    const upgradeOpts = {
       ...opts,
       method: opts.method || 'GET',
       upgrade: opts.protocol || 'Websocket'
-    }, upgradeHandler)
+    }
+
+    this.dispatch(upgradeOpts, upgradeHandler)
   } catch (err) {
     if (typeof callback !== 'function') {
       throw err

package/lib/api/readable.js

@@ -14,10 +14,25 @@ const kBody = Symbol('kBody')
 const kAbort = Symbol('kAbort')
 const kContentType = Symbol('kContentType')
 const kContentLength = Symbol('kContentLength')
+const kUsed = Symbol('kUsed')
+const kBytesRead = Symbol('kBytesRead')
 
 const noop = () => {}
 
+/**
+ * @class
+ * @extends {Readable}
+ * @see https://fetch.spec.whatwg.org/#body
+ */
 class BodyReadable extends Readable {
+  /**
+   * @param {object} opts
+   * @param {(this: Readable, size: number) => void} opts.resume
+   * @param {() => (void | null)} opts.abort
+   * @param {string} [opts.contentType = '']
+   * @param {number} [opts.contentLength]
+   * @param {number} [opts.highWaterMark = 64 * 1024]
+   */
   constructor ({
     resume,
     abort,
@@ -34,10 +49,19 @@ class BodyReadable extends Readable {
     this._readableState.dataEmitted = false
 
     this[kAbort] = abort
+
+    /**
+     * @type {Consume | null}
+     */
     this[kConsume] = null
+    this[kBytesRead] = 0
+    /**
+     * @type {ReadableStream|null}
+     */
     this[kBody] = null
+    this[kUsed] = false
     this[kContentType] = contentType
-    this[kContentLength] = contentLength
+    this[kContentLength] = Number.isFinite(contentLength) ? contentLength : null
 
     // Is stream being consumed through Readable API?
     // This is an optimization so that we avoid checking
@@ -46,7 +70,12 @@ class BodyReadable extends Readable {
     this[kReading] = false
   }
 
-  destroy (err) {
+  /**
+   * @param {Error|null} err
+   * @param {(error:(Error|null)) => void} callback
+   * @returns {void}
+   */
+  _destroy (err, callback) {
     if (!err && !this._readableState.endEmitted) {
       err = new RequestAbortedError()
     }
@@ -55,15 +84,11 @@ class BodyReadable extends Readable {
       this[kAbort]()
     }
 
-    return super.destroy(err)
-  }
-
-  _destroy (err, callback) {
     // Workaround for Node "bug". If the stream is destroyed in same
     // tick as it is created, then a user who is waiting for a
-    // promise (i.e micro tick) for installing a 'error' listener will
+    // promise (i.e micro tick) for installing an 'error' listener will
     // never get a chance and will always encounter an unhandled exception.
-    if (!this[kReading]) {
+    if (!this[kUsed]) {
       setImmediate(() => {
         callback(err)
       })
@@ -72,20 +97,36 @@ class BodyReadable extends Readable {
     }
   }
 
-  on (ev, ...args) {
-    if (ev === 'data' || ev === 'readable') {
+  /**
+   * @param {string} event
+   * @param {(...args: any[]) => void} listener
+   * @returns {this}
+   */
+  on (event, listener) {
+    if (event === 'data' || event === 'readable') {
       this[kReading] = true
+      this[kUsed] = true
     }
-    return super.on(ev, ...args)
+    return super.on(event, listener)
   }
 
-  addListener (ev, ...args) {
-    return this.on(ev, ...args)
+  /**
+   * @param {string} event
+   * @param {(...args: any[]) => void} listener
+   * @returns {this}
+   */
+  addListener (event, listener) {
+    return this.on(event, listener)
   }
 
-  off (ev, ...args) {
-    const ret = super.off(ev, ...args)
-    if (ev === 'data' || ev === 'readable') {
+  /**
+   * @param {string|symbol} event
+   * @param {(...args: any[]) => void} listener
+   * @returns {this}
+   */
+  off (event, listener) {
+    const ret = super.off(event, listener)
+    if (event === 'data' || event === 'readable') {
       this[kReading] = (
         this.listenerCount('data') > 0 ||
         this.listenerCount('readable') > 0
@@ -94,11 +135,22 @@ class BodyReadable extends Readable {
     return ret
   }
 
-  removeListener (ev, ...args) {
-    return this.off(ev, ...args)
+  /**
+   * @param {string|symbol} event
+   * @param {(...args: any[]) => void} listener
+   * @returns {this}
+   */
+  removeListener (event, listener) {
+    return this.off(event, listener)
   }
 
+  /**
+   * @param {Buffer|null} chunk
+   * @returns {boolean}
+   */
   push (chunk) {
+    this[kBytesRead] += chunk ? chunk.length : 0
+
     if (this[kConsume] && chunk !== null) {
       consumePush(this[kConsume], chunk)
       return this[kReading] ? super.push(chunk) : true
@@ -106,38 +158,84 @@ class BodyReadable extends Readable {
     return super.push(chunk)
   }
 
-  // https://fetch.spec.whatwg.org/#dom-body-text
+  /**
+   * Consumes and returns the body as a string.
+   *
+   * @see https://fetch.spec.whatwg.org/#dom-body-text
+   * @returns {Promise<string>}
+   */
   async text () {
     return consume(this, 'text')
   }
 
-  // https://fetch.spec.whatwg.org/#dom-body-json
+  /**
+   * Consumes and returns the body as a JavaScript Object.
+   *
+   * @see https://fetch.spec.whatwg.org/#dom-body-json
+   * @returns {Promise<unknown>}
+   */
   async json () {
     return consume(this, 'json')
   }
 
-  // https://fetch.spec.whatwg.org/#dom-body-blob
+  /**
+   * Consumes and returns the body as a Blob
+   *
+   * @see https://fetch.spec.whatwg.org/#dom-body-blob
+   * @returns {Promise<Blob>}
+   */
   async blob () {
     return consume(this, 'blob')
   }
 
-  // https://fetch.spec.whatwg.org/#dom-body-arraybuffer
+  /**
+   * Consumes and returns the body as an Uint8Array.
+   *
+   * @see https://fetch.spec.whatwg.org/#dom-body-bytes
+   * @returns {Promise<Uint8Array>}
+   */
+  async bytes () {
+    return consume(this, 'bytes')
+  }
+
+  /**
+   * Consumes and returns the body as an ArrayBuffer.
+   *
+   * @see https://fetch.spec.whatwg.org/#dom-body-arraybuffer
+   * @returns {Promise<ArrayBuffer>}
+   */
   async arrayBuffer () {
     return consume(this, 'arrayBuffer')
   }
 
-  // https://fetch.spec.whatwg.org/#dom-body-formdata
+  /**
+   * Not implemented
+   *
+   * @see https://fetch.spec.whatwg.org/#dom-body-formdata
+   * @throws {NotSupportedError}
+   */
   async formData () {
     // TODO: Implement.
     throw new NotSupportedError()
   }
 
-  // https://fetch.spec.whatwg.org/#dom-body-bodyused
+  /**
+   * Returns true if the body is not null and the body has been consumed.
+   * Otherwise, returns false.
+   *
+   * @see https://fetch.spec.whatwg.org/#dom-body-bodyused
+   * @readonly
+   * @returns {boolean}
+   */
   get bodyUsed () {
     return util.isDisturbed(this)
   }
 
-  // https://fetch.spec.whatwg.org/#dom-body-body
+  /**
+   * @see https://fetch.spec.whatwg.org/#dom-body-body
+   * @readonly
+   * @returns {ReadableStream}
+   */
   get body () {
     if (!this[kBody]) {
       this[kBody] = ReadableStreamFrom(this)
@@ -150,14 +248,24 @@ class BodyReadable extends Readable {
     return this[kBody]
   }
 
+  /**
+   * Dumps the response body by reading `limit` number of bytes.
+   * @param {object} opts
+   * @param {number} [opts.limit = 131072] Number of bytes to read.
+   * @param {AbortSignal} [opts.signal] An AbortSignal to cancel the dump.
+   * @returns {Promise<null>}
+   */
   async dump (opts) {
-    let limit = Number.isFinite(opts?.limit) ? opts.limit : 128 * 1024
     const signal = opts?.signal
 
     if (signal != null && (typeof signal !== 'object' || !('aborted' in signal))) {
       throw new InvalidArgumentError('signal must be an AbortSignal')
     }
 
+    const limit = opts?.limit && Number.isFinite(opts.limit)
+      ? opts.limit
+      : 128 * 1024
+
     signal?.throwIfAborted()
 
     if (this._readableState.closeEmitted) {
@@ -165,47 +273,88 @@ class BodyReadable extends Readable {
     }
 
     return await new Promise((resolve, reject) => {
-      if (this[kContentLength] > limit) {
+      if (
+        (this[kContentLength] && (this[kContentLength] > limit)) ||
+        this[kBytesRead] > limit
+      ) {
         this.destroy(new AbortError())
       }
 
-      const onAbort = () => {
-        this.destroy(signal.reason ?? new AbortError())
+      if (signal) {
+        const onAbort = () => {
+          this.destroy(signal.reason ?? new AbortError())
+        }
+        signal.addEventListener('abort', onAbort)
+        this
+          .on('close', function () {
+            signal.removeEventListener('abort', onAbort)
+            if (signal.aborted) {
+              reject(signal.reason ?? new AbortError())
+            } else {
+              resolve(null)
+            }
+          })
+      } else {
+        this.on('close', resolve)
       }
-      signal?.addEventListener('abort', onAbort)
 
       this
-        .on('close', function () {
-          signal?.removeEventListener('abort', onAbort)
-          if (signal?.aborted) {
-            reject(signal.reason ?? new AbortError())
-          } else {
-            resolve(null)
-          }
-        })
         .on('error', noop)
-        .on('data', function (chunk) {
-          limit -= chunk.length
-          if (limit <= 0) {
+        .on('data', () => {
+          if (this[kBytesRead] > limit) {
             this.destroy()
           }
         })
         .resume()
     })
   }
+
+  /**
+   * @param {BufferEncoding} encoding
+   * @returns {this}
+   */
+  setEncoding (encoding) {
+    if (Buffer.isEncoding(encoding)) {
+      this._readableState.encoding = encoding
+    }
+    return this
+  }
 }
 
-// https://streams.spec.whatwg.org/#readablestream-locked
-function isLocked (self) {
+/**
+ * @see https://streams.spec.whatwg.org/#readablestream-locked
+ * @param {BodyReadable} bodyReadable
+ * @returns {boolean}
+ */
+function isLocked (bodyReadable) {
   // Consume is an implicit lock.
-  return (self[kBody] && self[kBody].locked === true) || self[kConsume]
+  return bodyReadable[kBody]?.locked === true || bodyReadable[kConsume] !== null
 }
 
-// https://fetch.spec.whatwg.org/#body-unusable
-function isUnusable (self) {
-  return util.isDisturbed(self) || isLocked(self)
+/**
+ * @see https://fetch.spec.whatwg.org/#body-unusable
+ * @param {BodyReadable} bodyReadable
+ * @returns {boolean}
+ */
+function isUnusable (bodyReadable) {
+  return util.isDisturbed(bodyReadable) || isLocked(bodyReadable)
 }
 
+/**
+ * @typedef {object} Consume
+ * @property {string} type
+ * @property {BodyReadable} stream
+ * @property {((value?: any) => void)} resolve
+ * @property {((err: Error) => void)} reject
+ * @property {number} length
+ * @property {Buffer[]} body
+ */
+
+/**
+ * @param {BodyReadable} stream
+ * @param {string} type
+ * @returns {Promise<any>}
+ */
 async function consume (stream, type) {
   assert(!stream[kConsume])
 
@@ -250,6 +399,10 @@ async function consume (stream, type) {
   })
 }
 
+/**
+ * @param {Consume} consume
+ * @returns {void}
+ */
 function consumeStart (consume) {
   if (consume.body === null) {
     return
@@ -270,10 +423,10 @@ function consumeStart (consume) {
   }
 
   if (state.endEmitted) {
-    consumeEnd(this[kConsume])
+    consumeEnd(this[kConsume], this._readableState.encoding)
   } else {
     consume.stream.on('end', function () {
-      consumeEnd(this[kConsume])
+      consumeEnd(this[kConsume], this._readableState.encoding)
     })
   }
 
@@ -287,8 +440,10 @@ function consumeStart (consume) {
 /**
  * @param {Buffer[]} chunks
  * @param {number} length
+ * @param {BufferEncoding} encoding
+ * @returns {string}
  */
-function chunksDecode (chunks, length) {
+function chunksDecode (chunks, length, encoding) {
   if (chunks.length === 0 || length === 0) {
     return ''
   }
@@ -303,29 +458,57 @@ function chunksDecode (chunks, length) {
     buffer[2] === 0xbf
       ? 3
       : 0
-  return buffer.utf8Slice(start, bufferLength)
+  if (!encoding || encoding === 'utf8' || encoding === 'utf-8') {
+    return buffer.utf8Slice(start, bufferLength)
+  } else {
+    return buffer.subarray(start, bufferLength).toString(encoding)
+  }
+}
+
+/**
+ * @param {Buffer[]} chunks
+ * @param {number} length
+ * @returns {Uint8Array}
+ */
+function chunksConcat (chunks, length) {
+  if (chunks.length === 0 || length === 0) {
+    return new Uint8Array(0)
+  }
+  if (chunks.length === 1) {
+    // fast-path
+    return new Uint8Array(chunks[0])
+  }
+  const buffer = new Uint8Array(Buffer.allocUnsafeSlow(length).buffer)
+
+  let offset = 0
+  for (let i = 0; i < chunks.length; ++i) {
+    const chunk = chunks[i]
+    buffer.set(chunk, offset)
+    offset += chunk.length
+  }
+
+  return buffer
 }
 
-function consumeEnd (consume) {
+/**
+ * @param {Consume} consume
+ * @param {BufferEncoding} encoding
+ * @returns {void}
+ */
+function consumeEnd (consume, encoding) {
   const { type, body, resolve, stream, length } = consume
 
   try {
     if (type === 'text') {
-      resolve(chunksDecode(body, length))
+      resolve(chunksDecode(body, length, encoding))
     } else if (type === 'json') {
-      resolve(JSON.parse(chunksDecode(body, length)))
+      resolve(JSON.parse(chunksDecode(body, length, encoding)))
     } else if (type === 'arrayBuffer') {
-      const dst = new Uint8Array(length)
-
-      let pos = 0
-      for (const buf of body) {
-        dst.set(buf, pos)
-        pos += buf.byteLength
-      }
-
-      resolve(dst.buffer)
+      resolve(chunksConcat(body, length).buffer)
     } else if (type === 'blob') {
       resolve(new Blob(body, { type: stream[kContentType] }))
+    } else if (type === 'bytes') {
+      resolve(chunksConcat(body, length))
     }
 
     consumeFinish(consume)
@@ -334,11 +517,21 @@ function consumeEnd (consume) {
   }
 }
 
+/**
+ * @param {Consume} consume
+ * @param {Buffer} chunk
+ * @returns {void}
+ */
 function consumePush (consume, chunk) {
   consume.length += chunk.length
   consume.body.push(chunk)
 }
 
+/**
+ * @param {Consume} consume
+ * @param {Error} [err]
+ * @returns {void}
+ */
 function consumeFinish (consume, err) {
   if (consume.body === null) {
     return
@@ -350,6 +543,7 @@ function consumeFinish (consume, err) {
     consume.resolve()
   }
 
+  // Reset the consume object to allow for garbage collection.
   consume.type = null
   consume.stream = null
   consume.resolve = null
@@ -358,4 +552,7 @@ function consumeFinish (consume, err) {
   consume.body = null
 }
 
-module.exports = { Readable: BodyReadable, chunksDecode }
+module.exports = {
+  Readable: BodyReadable,
+  chunksDecode
+}

package/lib/api/util.js

@@ -1,3 +1,5 @@
+'use strict'
+
 const assert = require('node:assert')
 const {
   ResponseStatusCodeError