undici 7.14.0 → 7.16.0

package/lib/core/util.js

@@ -102,13 +102,24 @@ function isBlobLike (object) {
   }
 }
 
+/**
+ * @param {string} url The path to check for query strings or fragments.
+ * @returns {boolean} Returns true if the path contains a query string or fragment.
+ */
+function pathHasQueryOrFragment (url) {
+  return (
+    url.includes('?') ||
+    url.includes('#')
+  )
+}
+
 /**
  * @param {string} url The URL to add the query params to
  * @param {import('node:querystring').ParsedUrlQueryInput} queryParams The object to serialize into a URL query string
  * @returns {string} The URL with the query params added
  */
 function serializePathWithQuery (url, queryParams) {
-  if (url.includes('?') || url.includes('#')) {
+  if (pathHasQueryOrFragment(url)) {
     throw new Error('Query params cannot be passed when url already contains "?" or "#".')
   }
 
@@ -598,12 +609,11 @@ function ReadableStreamFrom (iterable) {
   let iterator
   return new ReadableStream(
     {
-      async start () {
+      start () {
         iterator = iterable[Symbol.asyncIterator]()
       },
       pull (controller) {
-        async function pull () {
-          const { done, value } = await iterator.next()
+        return iterator.next().then(({ done, value }) => {
           if (done) {
             queueMicrotask(() => {
               controller.close()
@@ -614,15 +624,13 @@ function ReadableStreamFrom (iterable) {
             if (buf.byteLength) {
               controller.enqueue(new Uint8Array(buf))
             } else {
-              return await pull()
+              return this.pull(controller)
             }
           }
-        }
-
-        return pull()
+        })
       },
-      async cancel () {
-        await iterator.return()
+      cancel () {
+        return iterator.return()
       },
       type: 'bytes'
     }
@@ -868,6 +876,30 @@ function onConnectTimeout (socket, opts) {
   destroy(socket, new ConnectTimeoutError(message))
 }
 
+/**
+ * @param {string} urlString
+ * @returns {string}
+ */
+function getProtocolFromUrlString (urlString) {
+  if (
+    urlString[0] === 'h' &&
+    urlString[1] === 't' &&
+    urlString[2] === 't' &&
+    urlString[3] === 'p'
+  ) {
+    switch (urlString[4]) {
+      case ':':
+        return 'http:'
+      case 's':
+        if (urlString[5] === ':') {
+          return 'https:'
+        }
+    }
+  }
+  // fallback if none of the usual suspects
+  return urlString.slice(0, urlString.indexOf(':') + 1)
+}
+
 const kEnumerableProperty = Object.create(null)
 kEnumerableProperty.enumerable = true
 
@@ -924,6 +956,7 @@ module.exports = {
   assertRequestHandler,
   getSocketInfo,
   isFormDataLike,
+  pathHasQueryOrFragment,
   serializePathWithQuery,
   addAbortListener,
   isValidHTTPToken,
@@ -938,5 +971,6 @@ module.exports = {
   nodeMinor,
   safeHTTPMethods: Object.freeze(['GET', 'HEAD', 'OPTIONS', 'TRACE']),
   wrapRequestBody,
-  setupConnectTimeout
+  setupConnectTimeout,
+  getProtocolFromUrlString
 }

package/lib/dispatcher/agent.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { InvalidArgumentError } = require('../core/errors')
+const { InvalidArgumentError, MaxOriginsReachedError } = require('../core/errors')
 const { kClients, kRunning, kClose, kDestroy, kDispatch, kUrl } = require('../core/symbols')
 const DispatcherBase = require('./dispatcher-base')
 const Pool = require('./pool')
@@ -13,6 +13,7 @@ const kOnConnectionError = Symbol('onConnectionError')
 const kOnDrain = Symbol('onDrain')
 const kFactory = Symbol('factory')
 const kOptions = Symbol('options')
+const kOrigins = Symbol('origins')
 
 function defaultFactory (origin, opts) {
   return opts && opts.connections === 1
@@ -21,7 +22,7 @@ function defaultFactory (origin, opts) {
 }
 
 class Agent extends DispatcherBase {
-  constructor ({ factory = defaultFactory, connect, ...options } = {}) {
+  constructor ({ factory = defaultFactory, maxOrigins = Infinity, connect, ...options } = {}) {
     if (typeof factory !== 'function') {
       throw new InvalidArgumentError('factory must be a function.')
     }
@@ -30,42 +31,34 @@ class Agent extends DispatcherBase {
       throw new InvalidArgumentError('connect must be a function or an object')
     }
 
+    if (typeof maxOrigins !== 'number' || Number.isNaN(maxOrigins) || maxOrigins <= 0) {
+      throw new InvalidArgumentError('maxOrigins must be a number greater than 0')
+    }
+
     super()
 
     if (connect && typeof connect !== 'function') {
       connect = { ...connect }
     }
 
-    this[kOptions] = { ...util.deepClone(options), connect }
+    this[kOptions] = { ...util.deepClone(options), maxOrigins, connect }
     this[kFactory] = factory
     this[kClients] = new Map()
+    this[kOrigins] = new Set()
 
     this[kOnDrain] = (origin, targets) => {
       this.emit('drain', origin, [this, ...targets])
     }
 
     this[kOnConnect] = (origin, targets) => {
-      const result = this[kClients].get(origin)
-      if (result) {
-        result.count += 1
-      }
       this.emit('connect', origin, [this, ...targets])
     }
 
     this[kOnDisconnect] = (origin, targets, err) => {
-      const result = this[kClients].get(origin)
-      if (result) {
-        result.count -= 1
-        if (result.count <= 0) {
-          this[kClients].delete(origin)
-          result.dispatcher.destroy()
-        }
-      }
       this.emit('disconnect', origin, [this, ...targets], err)
     }
 
     this[kOnConnectionError] = (origin, targets, err) => {
-      // TODO: should this decrement result.count here?
       this.emit('connectionError', origin, [this, ...targets], err)
     }
   }
@@ -86,39 +79,67 @@ class Agent extends DispatcherBase {
       throw new InvalidArgumentError('opts.origin must be a non-empty string or URL.')
     }
 
+    if (this[kOrigins].size >= this[kOptions].maxOrigins && !this[kOrigins].has(key)) {
+      throw new MaxOriginsReachedError()
+    }
+
     const result = this[kClients].get(key)
     let dispatcher = result && result.dispatcher
     if (!dispatcher) {
+      const closeClientIfUnused = (connected) => {
+        const result = this[kClients].get(key)
+        if (result) {
+          if (connected) result.count -= 1
+          if (result.count <= 0) {
+            this[kClients].delete(key)
+            result.dispatcher.close()
+          }
+          this[kOrigins].delete(key)
+        }
+      }
       dispatcher = this[kFactory](opts.origin, this[kOptions])
         .on('drain', this[kOnDrain])
-        .on('connect', this[kOnConnect])
-        .on('disconnect', this[kOnDisconnect])
-        .on('connectionError', this[kOnConnectionError])
+        .on('connect', (origin, targets) => {
+          const result = this[kClients].get(key)
+          if (result) {
+            result.count += 1
+          }
+          this[kOnConnect](origin, targets)
+        })
+        .on('disconnect', (origin, targets, err) => {
+          closeClientIfUnused(true)
+          this[kOnDisconnect](origin, targets, err)
+        })
+        .on('connectionError', (origin, targets, err) => {
+          closeClientIfUnused(false)
+          this[kOnConnectionError](origin, targets, err)
+        })
 
       this[kClients].set(key, { count: 0, dispatcher })
+      this[kOrigins].add(key)
     }
 
     return dispatcher.dispatch(opts, handler)
   }
 
-  async [kClose] () {
+  [kClose] () {
     const closePromises = []
     for (const { dispatcher } of this[kClients].values()) {
       closePromises.push(dispatcher.close())
     }
     this[kClients].clear()
 
-    await Promise.all(closePromises)
+    return Promise.all(closePromises)
   }
 
-  async [kDestroy] (err) {
+  [kDestroy] (err) {
     const destroyPromises = []
     for (const { dispatcher } of this[kClients].values()) {
       destroyPromises.push(dispatcher.destroy(err))
     }
     this[kClients].clear()
 
-    await Promise.all(destroyPromises)
+    return Promise.all(destroyPromises)
   }
 
   get stats () {

package/lib/dispatcher/client-h1.js

@@ -64,11 +64,26 @@ function lazyllhttp () {
   const llhttpWasmData = process.env.JEST_WORKER_ID ? require('../llhttp/llhttp-wasm.js') : undefined
 
   let mod
-  try {
-    mod = new WebAssembly.Module(require('../llhttp/llhttp_simd-wasm.js'))
-  } catch (e) {
-    /* istanbul ignore next */
 
+  // We disable wasm SIMD on ppc64 as it seems to be broken on Power 9 architectures.
+  let useWasmSIMD = process.arch !== 'ppc64'
+  // The Env Variable UNDICI_NO_WASM_SIMD allows explicitly overriding the default behavior
+  if (process.env.UNDICI_NO_WASM_SIMD === '1') {
+    useWasmSIMD = true
+  } else if (process.env.UNDICI_NO_WASM_SIMD === '0') {
+    useWasmSIMD = false
+  }
+
+  if (useWasmSIMD) {
+    try {
+      mod = new WebAssembly.Module(require('../llhttp/llhttp_simd-wasm.js'))
+      /* istanbul ignore next */
+    } catch {
+    }
+  }
+
+  /* istanbul ignore next */
+  if (!mod) {
     // We could check if the error was caused by the simd option not
     // being enabled, but the occurring of this other error
     // * https://github.com/emscripten-core/emscripten/issues/11495
@@ -325,10 +340,6 @@ class Parser {
         currentBufferRef = chunk
         currentParser = this
         ret = llhttp.llhttp_execute(this.ptr, currentBufferPtr, chunk.length)
-        /* eslint-disable-next-line no-useless-catch */
-      } catch (err) {
-        /* istanbul ignore next: difficult to make a test case for */
-        throw err
       } finally {
         currentParser = null
         currentBufferRef = null
@@ -760,7 +771,7 @@ function onParserTimeout (parser) {
  * @param {import('net').Socket} socket
  * @returns
  */
-async function connectH1 (client, socket) {
+function connectH1 (client, socket) {
   client[kSocket] = socket
 
   if (!llhttpInstance) {

package/lib/dispatcher/client-h2.js

@@ -77,7 +77,7 @@ function parseH2Headers (headers) {
   return result
 }
 
-async function connectH2 (client, socket) {
+function connectH2 (client, socket) {
   client[kSocket] = socket
 
   const session = http2.connect(client[kUrl], {
@@ -279,7 +279,7 @@ function shouldSendContentLength (method) {
 function writeH2 (client, request) {
   const requestTimeout = request.bodyTimeout ?? client[kBodyTimeout]
   const session = client[kHTTP2Session]
-  const { method, path, host, upgrade, expectContinue, signal, headers: reqHeaders } = request
+  const { method, path, host, upgrade, expectContinue, signal, protocol, headers: reqHeaders } = request
   let { body } = request
 
   if (upgrade) {
@@ -292,6 +292,16 @@ function writeH2 (client, request) {
     const key = reqHeaders[n + 0]
     const val = reqHeaders[n + 1]
 
+    if (key === 'cookie') {
+      if (headers[key] != null) {
+        headers[key] = Array.isArray(headers[key]) ? (headers[key].push(val), headers[key]) : [headers[key], val]
+      } else {
+        headers[key] = val
+      }
+
+      continue
+    }
+
     if (Array.isArray(val)) {
       for (let i = 0; i < val.length; i++) {
         if (headers[key]) {
@@ -387,7 +397,7 @@ function writeH2 (client, request) {
   // :path and :scheme headers must be omitted when sending CONNECT
 
   headers[HTTP2_HEADER_PATH] = path
-  headers[HTTP2_HEADER_SCHEME] = 'https'
+  headers[HTTP2_HEADER_SCHEME] = protocol === 'http:' ? 'http' : 'https'
 
   // https://tools.ietf.org/html/rfc7231#section-4.3.1
   // https://tools.ietf.org/html/rfc7231#section-4.3.2

package/lib/dispatcher/client.js

@@ -296,8 +296,7 @@ class Client extends DispatcherBase {
   }
 
   [kDispatch] (opts, handler) {
-    const origin = opts.origin || this[kUrl].origin
-    const request = new Request(origin, opts, handler)
+    const request = new Request(this[kUrl].origin, opts, handler)
 
     this[kQueue].push(request)
     if (this[kResuming]) {
@@ -317,7 +316,7 @@ class Client extends DispatcherBase {
     return this[kNeedDrain] < 2
   }
 
-  async [kClose] () {
+  [kClose] () {
     // TODO: for H2 we need to gracefully flush the remaining enqueued
     // request and close each stream.
     return new Promise((resolve) => {
@@ -329,7 +328,7 @@ class Client extends DispatcherBase {
     })
   }
 
-  async [kDestroy] (err) {
+  [kDestroy] (err) {
     return new Promise((resolve) => {
       const requests = this[kQueue].splice(this[kPendingIdx])
       for (let i = 0; i < requests.length; i++) {
@@ -381,9 +380,9 @@ function onError (client, err) {
 
 /**
  * @param {Client} client
- * @returns
+ * @returns {void}
  */
-async function connect (client) {
+function connect (client) {
   assert(!client[kConnecting])
   assert(!client[kHTTPContext])
 
@@ -417,26 +416,23 @@ async function connect (client) {
     })
   }
 
-  try {
-    const socket = await new Promise((resolve, reject) => {
-      client[kConnector]({
-        host,
-        hostname,
-        protocol,
-        port,
-        servername: client[kServerName],
-        localAddress: client[kLocalAddress]
-      }, (err, socket) => {
-        if (err) {
-          reject(err)
-        } else {
-          resolve(socket)
-        }
-      })
-    })
+  client[kConnector]({
+    host,
+    hostname,
+    protocol,
+    port,
+    servername: client[kServerName],
+    localAddress: client[kLocalAddress]
+  }, (err, socket) => {
+    if (err) {
+      handleConnectError(client, err, { host, hostname, protocol, port })
+      client[kResume]()
+      return
+    }
 
     if (client.destroyed) {
       util.destroy(socket.on('error', noop), new ClientDestroyedError())
+      client[kResume]()
       return
     }
 
@@ -444,11 +440,13 @@ async function connect (client) {
 
     try {
       client[kHTTPContext] = socket.alpnProtocol === 'h2'
-        ? await connectH2(client, socket)
-        : await connectH1(client, socket)
+        ? connectH2(client, socket)
+        : connectH1(client, socket)
     } catch (err) {
       socket.destroy().on('error', noop)
-      throw err
+      handleConnectError(client, err, { host, hostname, protocol, port })
+      client[kResume]()
+      return
     }
 
     client[kConnecting] = false
@@ -473,44 +471,46 @@ async function connect (client) {
         socket
       })
     }
+
     client.emit('connect', client[kUrl], [client])
-  } catch (err) {
-    if (client.destroyed) {
-      return
-    }
+    client[kResume]()
+  })
+}
 
-    client[kConnecting] = false
+function handleConnectError (client, err, { host, hostname, protocol, port }) {
+  if (client.destroyed) {
+    return
+  }
 
-    if (channels.connectError.hasSubscribers) {
-      channels.connectError.publish({
-        connectParams: {
-          host,
-          hostname,
-          protocol,
-          port,
-          version: client[kHTTPContext]?.version,
-          servername: client[kServerName],
-          localAddress: client[kLocalAddress]
-        },
-        connector: client[kConnector],
-        error: err
-      })
-    }
+  client[kConnecting] = false
 
-    if (err.code === 'ERR_TLS_CERT_ALTNAME_INVALID') {
-      assert(client[kRunning] === 0)
-      while (client[kPending] > 0 && client[kQueue][client[kPendingIdx]].servername === client[kServerName]) {
-        const request = client[kQueue][client[kPendingIdx]++]
-        util.errorRequest(client, request, err)
-      }
-    } else {
-      onError(client, err)
-    }
+  if (channels.connectError.hasSubscribers) {
+    channels.connectError.publish({
+      connectParams: {
+        host,
+        hostname,
+        protocol,
+        port,
+        version: client[kHTTPContext]?.version,
+        servername: client[kServerName],
+        localAddress: client[kLocalAddress]
+      },
+      connector: client[kConnector],
+      error: err
+    })
+  }
 
-    client.emit('connectionError', client[kUrl], [client], err)
+  if (err.code === 'ERR_TLS_CERT_ALTNAME_INVALID') {
+    assert(client[kRunning] === 0)
+    while (client[kPending] > 0 && client[kQueue][client[kPendingIdx]].servername === client[kServerName]) {
+      const request = client[kQueue][client[kPendingIdx]++]
+      util.errorRequest(client, request, err)
+    }
+  } else {
+    onError(client, err)
   }
 
-  client[kResume]()
+  client.emit('connectionError', client[kUrl], [client], err)
 }
 
 function emitDrain (client) {

package/lib/dispatcher/dispatcher-base.js

@@ -13,19 +13,24 @@ const kOnDestroyed = Symbol('onDestroyed')
 const kOnClosed = Symbol('onClosed')
 
 class DispatcherBase extends Dispatcher {
-  constructor () {
-    super()
+  /** @type {boolean} */
+  [kDestroyed] = false;
 
-    this[kDestroyed] = false
-    this[kOnDestroyed] = null
-    this[kClosed] = false
-    this[kOnClosed] = []
-  }
+  /** @type {Array|null} */
+  [kOnDestroyed] = null;
+
+  /** @type {boolean} */
+  [kClosed] = false;
+
+  /** @type {Array} */
+  [kOnClosed] = []
 
+  /** @returns {boolean} */
   get destroyed () {
     return this[kDestroyed]
   }
 
+  /** @returns {boolean} */
   get closed () {
     return this[kClosed]
   }

package/lib/dispatcher/env-http-proxy-agent.js

@@ -46,24 +46,20 @@ class EnvHttpProxyAgent extends DispatcherBase {
     return agent.dispatch(opts, handler)
   }
 
-  async [kClose] () {
-    await this[kNoProxyAgent].close()
-    if (!this[kHttpProxyAgent][kClosed]) {
-      await this[kHttpProxyAgent].close()
-    }
-    if (!this[kHttpsProxyAgent][kClosed]) {
-      await this[kHttpsProxyAgent].close()
-    }
+  [kClose] () {
+    return Promise.all([
+      this[kNoProxyAgent].close(),
+      !this[kHttpProxyAgent][kClosed] && this[kHttpProxyAgent].close(),
+      !this[kHttpsProxyAgent][kClosed] && this[kHttpsProxyAgent].close()
+    ])
   }
 
-  async [kDestroy] (err) {
-    await this[kNoProxyAgent].destroy(err)
-    if (!this[kHttpProxyAgent][kDestroyed]) {
-      await this[kHttpProxyAgent].destroy(err)
-    }
-    if (!this[kHttpsProxyAgent][kDestroyed]) {
-      await this[kHttpsProxyAgent].destroy(err)
-    }
+  [kDestroy] (err) {
+    return Promise.all([
+      this[kNoProxyAgent].destroy(err),
+      !this[kHttpProxyAgent][kDestroyed] && this[kHttpProxyAgent].destroy(err),
+      !this[kHttpsProxyAgent][kDestroyed] && this[kHttpsProxyAgent].destroy(err)
+    ])
   }
 
   #getProxyAgentForUrl (url) {

package/lib/dispatcher/fixed-queue.js

@@ -59,35 +59,21 @@ const kMask = kSize - 1
  * @template T
  */
 class FixedCircularBuffer {
-  constructor () {
-    /**
-     * @type {number}
-     */
-    this.bottom = 0
-    /**
-     * @type {number}
-     */
-    this.top = 0
-    /**
-     * @type {Array<T|undefined>}
-     */
-    this.list = new Array(kSize).fill(undefined)
-    /**
-     * @type {T|null}
-     */
-    this.next = null
-  }
+  /** @type {number} */
+  bottom = 0
+  /** @type {number} */
+  top = 0
+  /** @type {Array<T|undefined>} */
+  list = new Array(kSize).fill(undefined)
+  /** @type {T|null} */
+  next = null
 
-  /**
-   * @returns {boolean}
-   */
+  /** @returns {boolean} */
   isEmpty () {
     return this.top === this.bottom
   }
 
-  /**
-   * @returns {boolean}
-   */
+  /** @returns {boolean} */
   isFull () {
     return ((this.top + 1) & kMask) === this.bottom
   }
@@ -101,9 +87,7 @@ class FixedCircularBuffer {
     this.top = (this.top + 1) & kMask
   }
 
-  /**
-   * @returns {T|null}
-   */
+  /** @returns {T|null} */
   shift () {
     const nextItem = this.list[this.bottom]
     if (nextItem === undefined) { return null }
@@ -118,22 +102,16 @@ class FixedCircularBuffer {
  */
 module.exports = class FixedQueue {
   constructor () {
-    /**
-     * @type {FixedCircularBuffer<T>}
-     */
+    /** @type {FixedCircularBuffer<T>} */
     this.head = this.tail = new FixedCircularBuffer()
   }
 
-  /**
-   * @returns {boolean}
-   */
+  /** @returns {boolean} */
   isEmpty () {
     return this.head.isEmpty()
   }
 
-  /**
-   * @param {T} data
-   */
+  /** @param {T} data */
   push (data) {
     if (this.head.isFull()) {
       // Head is full: Creates a new queue, sets the old queue's `.next` to it,
@@ -143,9 +121,7 @@ module.exports = class FixedQueue {
     this.head.push(data)
   }
 
-  /**
-   * @returns {T|null}
-   */
+  /** @returns {T|null} */
   shift () {
     const tail = this.tail
     const next = tail.shift()