undici 6.19.8 → 7.0.0-alpha.1

package/lib/api/api-stream.js

@@ -1,11 +1,10 @@
 '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')
 
 class StreamHandler extends AsyncResource {
@@ -14,7 +13,7 @@ class StreamHandler extends AsyncResource {
       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') {
@@ -55,7 +54,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 +77,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 +90,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 +192,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,6 +14,8 @@ 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 = () => {}
 
@@ -35,9 +37,11 @@ class BodyReadable extends Readable {
 
     this[kAbort] = abort
     this[kConsume] = null
+    this[kBytesRead] = 0
     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 +50,7 @@ class BodyReadable extends Readable {
     this[kReading] = false
   }
 
-  destroy (err) {
+  _destroy (err, callback) {
     if (!err && !this._readableState.endEmitted) {
       err = new RequestAbortedError()
     }
@@ -55,15 +59,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
     // never get a chance and will always encounter an unhandled exception.
-    if (!this[kReading]) {
+    if (!this[kUsed]) {
       setImmediate(() => {
         callback(err)
       })
@@ -75,6 +75,7 @@ class BodyReadable extends Readable {
   on (ev, ...args) {
     if (ev === 'data' || ev === 'readable') {
       this[kReading] = true
+      this[kUsed] = true
     }
     return super.on(ev, ...args)
   }
@@ -99,6 +100,8 @@ class BodyReadable extends Readable {
   }
 
   push (chunk) {
+    this[kBytesRead] += chunk ? chunk.length : 0
+
     if (this[kConsume] && chunk !== null) {
       consumePush(this[kConsume], chunk)
       return this[kReading] ? super.push(chunk) : true
@@ -121,6 +124,11 @@ class BodyReadable extends Readable {
     return consume(this, 'blob')
   }
 
+  // https://fetch.spec.whatwg.org/#dom-body-bytes
+  async bytes () {
+    return consume(this, 'bytes')
+  }
+
   // https://fetch.spec.whatwg.org/#dom-body-arraybuffer
   async arrayBuffer () {
     return consume(this, 'arrayBuffer')
@@ -151,13 +159,14 @@ class BodyReadable extends Readable {
   }
 
   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 = Number.isFinite(opts?.limit) ? opts.limit : 128 * 1024
+
     signal?.throwIfAborted()
 
     if (this._readableState.closeEmitted) {
@@ -165,7 +174,7 @@ class BodyReadable extends Readable {
     }
 
     return await new Promise((resolve, reject) => {
-      if (this[kContentLength] > limit) {
+      if (this[kContentLength] > limit || this[kBytesRead] > limit) {
         this.destroy(new AbortError())
       }
 
@@ -185,14 +194,24 @@ class BodyReadable extends Readable {
         })
         .on('error', noop)
         .on('data', function (chunk) {
-          limit -= chunk.length
-          if (limit <= 0) {
+          if (this[kBytesRead] > limit) {
             this.destroy()
           }
         })
         .resume()
     })
   }
+
+  /**
+   * @param {BufferEncoding} encoding
+   * @returns {BodyReadable}
+   */
+  setEncoding (encoding) {
+    if (Buffer.isEncoding(encoding)) {
+      this._readableState.encoding = encoding
+    }
+    return this
+  }
 }
 
 // https://streams.spec.whatwg.org/#readablestream-locked
@@ -270,10 +289,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 +306,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 +324,52 @@ 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) {
+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)

package/lib/core/connect.js

@@ -4,6 +4,7 @@ const net = require('node:net')
 const assert = require('node:assert')
 const util = require('./util')
 const { InvalidArgumentError, ConnectTimeoutError } = require('./errors')
+const timers = require('../util/timers')
 
 let tls // include tls conditionally since it is not always available
 
@@ -130,12 +131,12 @@ function buildConnector ({ allowH2, maxCachedSessions, socketPath, timeout, sess
       socket.setKeepAlive(true, keepAliveInitialDelay)
     }
 
-    const cancelTimeout = setupTimeout(() => onConnectTimeout(socket), timeout)
+    const cancelConnectTimeout = setupConnectTimeout(new WeakRef(socket), timeout)
 
     socket
       .setNoDelay(true)
       .once(protocol === 'https:' ? 'secureConnect' : 'connect', function () {
-        cancelTimeout()
+        cancelConnectTimeout()
 
         if (callback) {
           const cb = callback
@@ -144,7 +145,7 @@ function buildConnector ({ allowH2, maxCachedSessions, socketPath, timeout, sess
         }
       })
       .on('error', function (err) {
-        cancelTimeout()
+        cancelConnectTimeout()
 
         if (callback) {
           const cb = callback
@@ -157,30 +158,44 @@ function buildConnector ({ allowH2, maxCachedSessions, socketPath, timeout, sess
   }
 }
 
-function setupTimeout (onConnectTimeout, timeout) {
-  if (!timeout) {
-    return () => {}
-  }
+const setupConnectTimeout = process.platform === 'win32'
+  ? (socket, timeout) => {
+      if (!timeout) {
+        return () => { }
+      }
 
-  let s1 = null
-  let s2 = null
-  const timeoutId = setTimeout(() => {
-    // setImmediate is added to make sure that we prioritize socket error events over timeouts
-    s1 = setImmediate(() => {
-      if (process.platform === 'win32') {
+      let s1 = null
+      let s2 = null
+      const timer = timers.setTimeout(() => {
+      // setImmediate is added to make sure that we prioritize socket error events over timeouts
+        s1 = setImmediate(() => {
         // Windows needs an extra setImmediate probably due to implementation differences in the socket logic
-        s2 = setImmediate(() => onConnectTimeout())
-      } else {
-        onConnectTimeout()
+          s2 = setImmediate(() => onConnectTimeout(socket.deref()))
+        })
+      }, timeout)
+      return () => {
+        timers.clearTimeout(timer)
+        clearImmediate(s1)
+        clearImmediate(s2)
       }
-    })
-  }, timeout)
-  return () => {
-    clearTimeout(timeoutId)
-    clearImmediate(s1)
-    clearImmediate(s2)
-  }
-}
+    }
+  : (socket, timeout) => {
+      if (!timeout) {
+        return () => { }
+      }
+
+      let s1 = null
+      const timer = timers.setTimeout(() => {
+      // setImmediate is added to make sure that we prioritize socket error events over timeouts
+        s1 = setImmediate(() => {
+          onConnectTimeout(socket.deref())
+        })
+      }, timeout)
+      return () => {
+        timers.clearTimeout(timer)
+        clearImmediate(s1)
+      }
+    }
 
 function onConnectTimeout (socket) {
   let message = 'Connect Timeout Error'

package/lib/core/errors.js

@@ -1,8 +1,8 @@
 'use strict'
 
 class UndiciError extends Error {
-  constructor (message) {
-    super(message)
+  constructor (message, options) {
+    super(message, options)
     this.name = 'UndiciError'
     this.code = 'UND_ERR'
   }
@@ -195,9 +195,21 @@ class RequestRetryError extends UndiciError {
   }
 }
 
+class ResponseError extends UndiciError {
+  constructor (message, code, { headers, data }) {
+    super(message)
+    this.name = 'ResponseError'
+    this.message = message || 'Response error'
+    this.code = 'UND_ERR_RESPONSE'
+    this.statusCode = code
+    this.data = data
+    this.headers = headers
+  }
+}
+
 class SecureProxyConnectionError extends UndiciError {
-  constructor (cause, message, options) {
-    super(message, { cause, ...(options ?? {}) })
+  constructor (cause, message, options = {}) {
+    super(message, { cause, ...options })
     this.name = 'SecureProxyConnectionError'
     this.message = message || 'Secure Proxy Connection failed'
     this.code = 'UND_ERR_PRX_TLS'
@@ -227,5 +239,6 @@ module.exports = {
   BalancedPoolMissingUpstreamError,
   ResponseExceededMaxSizeError,
   RequestRetryError,
+  ResponseError,
   SecureProxyConnectionError
 }

package/lib/core/request.js

@@ -40,9 +40,9 @@ class Request {
     headersTimeout,
     bodyTimeout,
     reset,
-    throwOnError,
     expectContinue,
-    servername
+    servername,
+    throwOnError
   }, handler) {
     if (typeof path !== 'string') {
       throw new InvalidArgumentError('path must be a string')
@@ -82,12 +82,14 @@ class Request {
       throw new InvalidArgumentError('invalid expectContinue')
     }
 
+    if (throwOnError != null) {
+      throw new InvalidArgumentError('invalid throwOnError')
+    }
+
     this.headersTimeout = headersTimeout
 
     this.bodyTimeout = bodyTimeout
 
-    this.throwOnError = throwOnError === true
-
     this.method = method
 
     this.abort = null
@@ -183,7 +185,7 @@ class Request {
 
     validateHandler(handler, method, upgrade)
 
-    this.servername = servername || getServerName(this.host)
+    this.servername = servername || getServerName(this.host) || null
 
     this[kHandler] = handler
 

package/lib/core/symbols.js

@@ -52,7 +52,6 @@ module.exports = {
   kMaxRequests: Symbol('maxRequestsPerClient'),
   kProxy: Symbol('proxy agent options'),
   kCounter: Symbol('socket request counter'),
-  kInterceptors: Symbol('dispatch interceptors'),
   kMaxResponseSize: Symbol('max response size'),
   kHTTP2Session: Symbol('http2Session'),
   kHTTP2SessionState: Symbol('http2Session state'),

package/lib/core/tree.js

@@ -47,6 +47,9 @@ class TstNode {
       throw new TypeError('Unreachable')
     }
     let index = 0
+    /**
+     * @type {TstNode}
+     */
     let node = this
     while (true) {
       const code = key.charCodeAt(index)
@@ -87,6 +90,9 @@ class TstNode {
   search (key) {
     const keylength = key.length
     let index = 0
+    /**
+     * @type {TstNode}
+     */
     let node = this
     while (node !== null && index < keylength) {
       let code = key[index]

package/lib/core/util.js

@@ -443,14 +443,6 @@ function isDisturbed (body) {
   return !!(body && (stream.isDisturbed(body) || body[kBodyUsed]))
 }
 
-function isErrored (body) {
-  return !!(body && stream.isErrored(body))
-}
-
-function isReadable (body) {
-  return !!(body && stream.isReadable(body))
-}
-
 function getSocketInfo (socket) {
   return {
     localAddress: socket.localAddress,
@@ -518,7 +510,7 @@ function addAbortListener (signal, listener) {
     signal.addEventListener('abort', listener, { once: true })
     return () => signal.removeEventListener('abort', listener)
   }
-  signal.addListener('abort', listener)
+  signal.once('abort', listener)
   return () => signal.removeListener('abort', listener)
 }
 
@@ -674,8 +666,6 @@ module.exports = {
   kEnumerableProperty,
   nop,
   isDisturbed,
-  isErrored,
-  isReadable,
   toUSVString,
   isUSVString,
   isBlobLike,

package/lib/dispatcher/agent.js

@@ -1,17 +1,15 @@
 'use strict'
 
 const { InvalidArgumentError } = require('../core/errors')
-const { kClients, kRunning, kClose, kDestroy, kDispatch, kInterceptors } = require('../core/symbols')
+const { kClients, kRunning, kClose, kDestroy, kDispatch } = require('../core/symbols')
 const DispatcherBase = require('./dispatcher-base')
 const Pool = require('./pool')
 const Client = require('./client')
 const util = require('../core/util')
-const createRedirectInterceptor = require('../interceptor/redirect-interceptor')
 
 const kOnConnect = Symbol('onConnect')
 const kOnDisconnect = Symbol('onDisconnect')
 const kOnConnectionError = Symbol('onConnectionError')
-const kMaxRedirections = Symbol('maxRedirections')
 const kOnDrain = Symbol('onDrain')
 const kFactory = Symbol('factory')
 const kOptions = Symbol('options')
@@ -23,9 +21,7 @@ function defaultFactory (origin, opts) {
 }
 
 class Agent extends DispatcherBase {
-  constructor ({ factory = defaultFactory, maxRedirections = 0, connect, ...options } = {}) {
-    super()
-
+  constructor ({ factory = defaultFactory, connect, ...options } = {}) {
     if (typeof factory !== 'function') {
       throw new InvalidArgumentError('factory must be a function.')
     }
@@ -34,23 +30,13 @@ class Agent extends DispatcherBase {
       throw new InvalidArgumentError('connect must be a function or an object')
     }
 
-    if (!Number.isInteger(maxRedirections) || maxRedirections < 0) {
-      throw new InvalidArgumentError('maxRedirections must be a positive number')
-    }
+    super()
 
     if (connect && typeof connect !== 'function') {
       connect = { ...connect }
     }
 
-    this[kInterceptors] = options.interceptors?.Agent && Array.isArray(options.interceptors.Agent)
-      ? options.interceptors.Agent
-      : [createRedirectInterceptor({ maxRedirections })]
-
     this[kOptions] = { ...util.deepClone(options), connect }
-    this[kOptions].interceptors = options.interceptors
-      ? { ...options.interceptors }
-      : undefined
-    this[kMaxRedirections] = maxRedirections
     this[kFactory] = factory
     this[kClients] = new Map()