undici 6.6.1 → 6.7.0

package/lib/core/request.js

@@ -5,29 +5,27 @@ const {
   NotSupportedError
 } = require('./errors')
 const assert = require('node:assert')
-const { kHTTP2BuildRequest, kHTTP2CopyHeaders, kHTTP1BuildRequest } = require('./symbols')
-const util = require('./util')
+const {
+  isValidHTTPToken,
+  isValidHeaderChar,
+  isStream,
+  destroy,
+  isBuffer,
+  isFormDataLike,
+  isIterable,
+  isBlobLike,
+  buildURL,
+  validateHandler,
+  getServerName
+} = require('./util')
 const { channels } = require('./diagnostics.js')
 const { headerNameLowerCasedRecord } = require('./constants')
 
-// headerCharRegex have been lifted from
-// https://github.com/nodejs/node/blob/main/lib/_http_common.js
-
-/**
- * Matches if val contains an invalid field-vchar
- *  field-value    = *( field-content / obs-fold )
- *  field-content  = field-vchar [ 1*( SP / HTAB ) field-vchar ]
- *  field-vchar    = VCHAR / obs-text
- */
-const headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/
-
 // Verifies that a given path is valid does not contain control chars \x00 to \x20
 const invalidPathRegex = /[^\u0021-\u00ff]/
 
 const kHandler = Symbol('handler')
 
-let extractBody
-
 class Request {
   constructor (origin, {
     path,
@@ -58,7 +56,7 @@ class Request {
 
     if (typeof method !== 'string') {
       throw new InvalidArgumentError('method must be a string')
-    } else if (!util.isValidHTTPToken(method)) {
+    } else if (!isValidHTTPToken(method)) {
       throw new InvalidArgumentError('invalid request method')
     }
 
@@ -94,13 +92,13 @@ class Request {
 
     if (body == null) {
       this.body = null
-    } else if (util.isStream(body)) {
+    } else if (isStream(body)) {
       this.body = body
 
       const rState = this.body._readableState
       if (!rState || !rState.autoDestroy) {
         this.endHandler = function autoDestroy () {
-          util.destroy(this)
+          destroy(this)
         }
         this.body.on('end', this.endHandler)
       }
@@ -113,7 +111,7 @@ class Request {
         }
       }
       this.body.on('error', this.errorHandler)
-    } else if (util.isBuffer(body)) {
+    } else if (isBuffer(body)) {
       this.body = body.byteLength ? body : null
     } else if (ArrayBuffer.isView(body)) {
       this.body = body.buffer.byteLength ? Buffer.from(body.buffer, body.byteOffset, body.byteLength) : null
@@ -121,7 +119,7 @@ class Request {
       this.body = body.byteLength ? Buffer.from(body) : null
     } else if (typeof body === 'string') {
       this.body = body.length ? Buffer.from(body) : null
-    } else if (util.isFormDataLike(body) || util.isIterable(body) || util.isBlobLike(body)) {
+    } else if (isFormDataLike(body) || isIterable(body) || isBlobLike(body)) {
       this.body = body
     } else {
       throw new InvalidArgumentError('body must be a string, a Buffer, a Readable stream, an iterable, or an async iterable')
@@ -133,7 +131,7 @@ class Request {
 
     this.upgrade = upgrade || null
 
-    this.path = query ? util.buildURL(path, query) : path
+    this.path = query ? buildURL(path, query) : path
 
     this.origin = origin
 
@@ -151,7 +149,7 @@ class Request {
 
     this.contentType = null
 
-    this.headers = ''
+    this.headers = []
 
     // Only for H2
     this.expectContinue = expectContinue != null ? expectContinue : false
@@ -164,35 +162,26 @@ class Request {
         processHeader(this, headers[i], headers[i + 1])
       }
     } else if (headers && typeof headers === 'object') {
-      const keys = Object.keys(headers)
-      for (let i = 0; i < keys.length; i++) {
-        const key = keys[i]
-        processHeader(this, key, headers[key])
+      if (headers[Symbol.iterator]) {
+        for (const header of headers) {
+          if (!Array.isArray(header) || header.length !== 2) {
+            throw new InvalidArgumentError('headers must be in key-value pair format')
+          }
+          processHeader(this, header[0], header[1])
+        }
+      } else {
+        const keys = Object.keys(headers)
+        for (let i = 0; i < keys.length; ++i) {
+          processHeader(this, keys[i], headers[keys[i]])
+        }
       }
     } else if (headers != null) {
       throw new InvalidArgumentError('headers must be an object or an array')
     }
 
-    if (util.isFormDataLike(this.body)) {
-      if (!extractBody) {
-        extractBody = require('../fetch/body.js').extractBody
-      }
-
-      const [bodyStream, contentType] = extractBody(body)
-      if (this.contentType == null) {
-        this.contentType = contentType
-        this.headers += `content-type: ${contentType}\r\n`
-      }
-      this.body = bodyStream.stream
-      this.contentLength = bodyStream.length
-    } else if (util.isBlobLike(body) && this.contentType == null && body.type) {
-      this.contentType = body.type
-      this.headers += `content-type: ${body.type}\r\n`
-    }
-
-    util.validateHandler(handler, method, upgrade)
+    validateHandler(handler, method, upgrade)
 
-    this.servername = util.getServerName(this.host)
+    this.servername = getServerName(this.host)
 
     this[kHandler] = handler
 
@@ -320,81 +309,13 @@ class Request {
     }
   }
 
-  // TODO: adjust to support H2
   addHeader (key, value) {
     processHeader(this, key, value)
     return this
   }
-
-  static [kHTTP1BuildRequest] (origin, opts, handler) {
-    // TODO: Migrate header parsing here, to make Requests
-    // HTTP agnostic
-    return new Request(origin, opts, handler)
-  }
-
-  static [kHTTP2BuildRequest] (origin, opts, handler) {
-    const headers = opts.headers
-    opts = { ...opts, headers: null }
-
-    const request = new Request(origin, opts, handler)
-
-    request.headers = {}
-
-    if (Array.isArray(headers)) {
-      if (headers.length % 2 !== 0) {
-        throw new InvalidArgumentError('headers array must be even')
-      }
-      for (let i = 0; i < headers.length; i += 2) {
-        processHeader(request, headers[i], headers[i + 1], true)
-      }
-    } else if (headers && typeof headers === 'object') {
-      const keys = Object.keys(headers)
-      for (let i = 0; i < keys.length; i++) {
-        const key = keys[i]
-        processHeader(request, key, headers[key], true)
-      }
-    } else if (headers != null) {
-      throw new InvalidArgumentError('headers must be an object or an array')
-    }
-
-    return request
-  }
-
-  static [kHTTP2CopyHeaders] (raw) {
-    const rawHeaders = raw.split('\r\n')
-    const headers = {}
-
-    for (const header of rawHeaders) {
-      const [key, value] = header.split(': ')
-
-      if (value == null || value.length === 0) continue
-
-      if (headers[key]) {
-        headers[key] += `,${value}`
-      } else {
-        headers[key] = value
-      }
-    }
-
-    return headers
-  }
 }
 
-function processHeaderValue (key, val, skipAppend) {
-  if (val && typeof val === 'object') {
-    throw new InvalidArgumentError(`invalid ${key} header`)
-  }
-
-  val = val != null ? `${val}` : ''
-
-  if (headerCharRegex.exec(val) !== null) {
-    throw new InvalidArgumentError(`invalid ${key} header`)
-  }
-
-  return skipAppend ? val : `${key}: ${val}\r\n`
-}
-
-function processHeader (request, key, val, skipAppend = false) {
+function processHeader (request, key, val) {
   if (val && (typeof val === 'object' && !Array.isArray(val))) {
     throw new InvalidArgumentError(`invalid ${key} header`)
   } else if (val === undefined) {
@@ -405,15 +326,44 @@ function processHeader (request, key, val, skipAppend = false) {
 
   if (headerName === undefined) {
     headerName = key.toLowerCase()
-    if (headerNameLowerCasedRecord[headerName] === undefined && !util.isValidHTTPToken(headerName)) {
+    if (headerNameLowerCasedRecord[headerName] === undefined && !isValidHTTPToken(headerName)) {
       throw new InvalidArgumentError('invalid header key')
     }
   }
 
-  if (request.host === null && headerName === 'host') {
-    if (headerCharRegex.exec(val) !== null) {
+  if (Array.isArray(val)) {
+    const arr = []
+    for (let i = 0; i < val.length; i++) {
+      if (typeof val[i] === 'string') {
+        if (!isValidHeaderChar(val[i])) {
+          throw new InvalidArgumentError(`invalid ${key} header`)
+        }
+        arr.push(val[i])
+      } else if (val[i] === null) {
+        arr.push('')
+      } else if (typeof val[i] === 'object') {
+        throw new InvalidArgumentError(`invalid ${key} header`)
+      } else {
+        arr.push(`${val[i]}`)
+      }
+    }
+    val = arr
+  } else if (typeof val === 'string') {
+    if (!isValidHeaderChar(val)) {
       throw new InvalidArgumentError(`invalid ${key} header`)
     }
+  } else if (val === null) {
+    val = ''
+  } else if (typeof val === 'object') {
+    throw new InvalidArgumentError(`invalid ${key} header`)
+  } else {
+    val = `${val}`
+  }
+
+  if (request.host === null && headerName === 'host') {
+    if (typeof val !== 'string') {
+      throw new InvalidArgumentError('invalid host header')
+    }
     // Consumed by Client
     request.host = val
   } else if (request.contentLength === null && headerName === 'content-length') {
@@ -423,35 +373,22 @@ function processHeader (request, key, val, skipAppend = false) {
     }
   } else if (request.contentType === null && headerName === 'content-type') {
     request.contentType = val
-    if (skipAppend) request.headers[key] = processHeaderValue(key, val, skipAppend)
-    else request.headers += processHeaderValue(key, val)
+    request.headers.push(key, val)
   } else if (headerName === 'transfer-encoding' || headerName === 'keep-alive' || headerName === 'upgrade') {
     throw new InvalidArgumentError(`invalid ${headerName} header`)
   } else if (headerName === 'connection') {
     const value = typeof val === 'string' ? val.toLowerCase() : null
     if (value !== 'close' && value !== 'keep-alive') {
       throw new InvalidArgumentError('invalid connection header')
-    } else if (value === 'close') {
+    }
+
+    if (value === 'close') {
       request.reset = true
     }
   } else if (headerName === 'expect') {
     throw new NotSupportedError('expect header not supported')
-  } else if (Array.isArray(val)) {
-    for (let i = 0; i < val.length; i++) {
-      if (skipAppend) {
-        if (request.headers[key]) {
-          request.headers[key] += `,${processHeaderValue(key, val[i], skipAppend)}`
-        } else {
-          request.headers[key] = processHeaderValue(key, val[i], skipAppend)
-        }
-      } else {
-        request.headers += processHeaderValue(key, val[i])
-      }
-    }
-  } else if (skipAppend) {
-    request.headers[key] = processHeaderValue(key, val, skipAppend)
   } else {
-    request.headers += processHeaderValue(key, val)
+    request.headers.push(key, val)
   }
 }
 

package/lib/core/symbols.js

@@ -33,6 +33,8 @@ module.exports = {
   kNeedDrain: Symbol('need drain'),
   kReset: Symbol('reset'),
   kDestroyed: Symbol.for('nodejs.stream.destroyed'),
+  kResume: Symbol('resume'),
+  kOnError: Symbol('on error'),
   kMaxHeadersSize: Symbol('max headers size'),
   kRunningIdx: Symbol('running index'),
   kPendingIdx: Symbol('pending index'),
@@ -54,10 +56,9 @@ module.exports = {
   kMaxResponseSize: Symbol('max response size'),
   kHTTP2Session: Symbol('http2Session'),
   kHTTP2SessionState: Symbol('http2Session state'),
-  kHTTP2BuildRequest: Symbol('http2 build request'),
-  kHTTP1BuildRequest: Symbol('http1 build request'),
-  kHTTP2CopyHeaders: Symbol('http2 copy headers'),
-  kHTTPConnVersion: Symbol('http connection version'),
   kRetryHandlerDefaultRetry: Symbol('retry agent default retry'),
-  kConstruct: Symbol('constructable')
+  kConstruct: Symbol('constructable'),
+  kListeners: Symbol('listeners'),
+  kHTTPContext: Symbol('http context'),
+  kMaxConcurrentStreams: Symbol('max concurrent streams')
 }

package/lib/core/tree.js

@@ -17,7 +17,7 @@ class TstNode {
   /** @type {number} */
   code
   /**
-   * @param {Uint8Array} key
+   * @param {string} key
    * @param {any} value
    * @param {number} index
    */
@@ -25,7 +25,11 @@ class TstNode {
     if (index === undefined || index >= key.length) {
       throw new TypeError('Unreachable')
     }
-    this.code = key[index]
+    const code = this.code = key.charCodeAt(index)
+    // check code is ascii string
+    if (code > 0x7F) {
+      throw new TypeError('key must be ascii string')
+    }
     if (key.length !== ++index) {
       this.middle = new TstNode(key, value, index)
     } else {
@@ -34,33 +38,45 @@ class TstNode {
   }
 
   /**
-   * @param {Uint8Array} key
+   * @param {string} key
    * @param {any} value
-   * @param {number} index
    */
-  add (key, value, index) {
-    if (index === undefined || index >= key.length) {
+  add (key, value) {
+    const length = key.length
+    if (length === 0) {
       throw new TypeError('Unreachable')
     }
-    const code = key[index]
-    if (this.code === code) {
-      if (key.length === ++index) {
-        this.value = value
-      } else if (this.middle !== null) {
-        this.middle.add(key, value, index)
-      } else {
-        this.middle = new TstNode(key, value, index)
+    let index = 0
+    let node = this
+    while (true) {
+      const code = key.charCodeAt(index)
+      // check code is ascii string
+      if (code > 0x7F) {
+        throw new TypeError('key must be ascii string')
       }
-    } else if (this.code < code) {
-      if (this.left !== null) {
-        this.left.add(key, value, index)
+      if (node.code === code) {
+        if (length === ++index) {
+          node.value = value
+          break
+        } else if (node.middle !== null) {
+          node = node.middle
+        } else {
+          node.middle = new TstNode(key, value, index)
+          break
+        }
+      } else if (node.code < code) {
+        if (node.left !== null) {
+          node = node.left
+        } else {
+          node.left = new TstNode(key, value, index)
+          break
+        }
+      } else if (node.right !== null) {
+        node = node.right
       } else {
-        this.left = new TstNode(key, value, index)
+        node.right = new TstNode(key, value, index)
+        break
       }
-    } else if (this.right !== null) {
-      this.right.add(key, value, index)
-    } else {
-      this.right = new TstNode(key, value, index)
     }
   }
 
@@ -75,7 +91,10 @@ class TstNode {
     while (node !== null && index < keylength) {
       let code = key[index]
       // A-Z
-      if (code >= 0x41 && code <= 0x5a) {
+      // First check if it is bigger than 0x5a.
+      // Lowercase letters have higher char codes than uppercase ones.
+      // Also we assume that headers will mostly contain lowercase characters.
+      if (code <= 0x5a && code >= 0x41) {
         // Lowercase for uppercase.
         code |= 32
       }
@@ -100,19 +119,20 @@ class TernarySearchTree {
   node = null
 
   /**
-   * @param {Uint8Array} key
+   * @param {string} key
    * @param {any} value
    * */
   insert (key, value) {
     if (this.node === null) {
       this.node = new TstNode(key, value, 0)
     } else {
-      this.node.add(key, value, 0)
+      this.node.add(key, value)
     }
   }
 
   /**
    * @param {Uint8Array} key
+   * @return {any}
    */
   lookup (key) {
     return this.node?.search(key)?.value ?? null
@@ -123,7 +143,7 @@ const tree = new TernarySearchTree()
 
 for (let i = 0; i < wellknownHeaderNames.length; ++i) {
   const key = headerNameLowerCasedRecord[wellknownHeaderNames[i]]
-  tree.insert(Buffer.from(key), key)
+  tree.insert(key, key)
 }
 
 module.exports = {

package/lib/core/util.js

@@ -182,8 +182,8 @@ function bodyLength (body) {
   return null
 }
 
-function isDestroyed (stream) {
-  return !stream || !!(stream.destroyed || stream[kDestroyed])
+function isDestroyed (body) {
+  return body && !!(body.destroyed || body[kDestroyed] || (stream.isDestroyed?.(body)))
 }
 
 function isReadableAborted (stream) {
@@ -204,9 +204,9 @@ function destroy (stream, err) {
 
     stream.destroy(err)
   } else if (err) {
-    process.nextTick((stream, err) => {
+    queueMicrotask(() => {
       stream.emit('error', err)
-    }, stream, err)
+    })
   }
 
   if (stream.destroyed !== true) {
@@ -279,22 +279,30 @@ function parseHeaders (headers, obj) {
 }
 
 function parseRawHeaders (headers) {
-  const ret = []
+  const len = headers.length
+  const ret = new Array(len)
+
   let hasContentLength = false
   let contentDispositionIdx = -1
+  let key
+  let val
+  let kLen = 0
 
   for (let n = 0; n < headers.length; n += 2) {
-    const key = headers[n + 0].toString()
-    const val = headers[n + 1].toString('utf8')
+    key = headers[n]
+    val = headers[n + 1]
+
+    typeof key !== 'string' && (key = key.toString())
+    typeof val !== 'string' && (val = val.toString('utf8'))
 
-    if (key.length === 14 && (key === 'content-length' || key.toLowerCase() === 'content-length')) {
-      ret.push(key, val)
+    kLen = key.length
+    if (kLen === 14 && key[7] === '-' && (key === 'content-length' || key.toLowerCase() === 'content-length')) {
       hasContentLength = true
-    } else if (key.length === 19 && (key === 'content-disposition' || key.toLowerCase() === 'content-disposition')) {
-      contentDispositionIdx = ret.push(key, val) - 1
-    } else {
-      ret.push(key, val)
+    } else if (kLen === 19 && key[7] === '-' && (key === 'content-disposition' || key.toLowerCase() === 'content-disposition')) {
+      contentDispositionIdx = n + 1
     }
+    ret[n] = key
+    ret[n + 1] = val
   }
 
   // See https://github.com/nodejs/node/pull/46528
@@ -438,13 +446,7 @@ const hasToWellFormed = !!String.prototype.toWellFormed
  * @param {string} val
  */
 function toUSVString (val) {
-  if (hasToWellFormed) {
-    return `${val}`.toWellFormed()
-  } else if (nodeUtil.toUSVString) {
-    return nodeUtil.toUSVString(val)
-  }
-
-  return `${val}`
+  return hasToWellFormed ? `${val}`.toWellFormed() : nodeUtil.toUSVString(val)
 }
 
 /**
@@ -493,6 +495,24 @@ function isValidHTTPToken (characters) {
   return true
 }
 
+// headerCharRegex have been lifted from
+// https://github.com/nodejs/node/blob/main/lib/_http_common.js
+
+/**
+ * Matches if val contains an invalid field-vchar
+ *  field-value    = *( field-content / obs-fold )
+ *  field-content  = field-vchar [ 1*( SP / HTAB ) field-vchar ]
+ *  field-vchar    = VCHAR / obs-text
+ */
+const headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/
+
+/**
+ * @param {string} characters
+ */
+function isValidHeaderChar (characters) {
+  return !headerCharRegex.test(characters)
+}
+
 // Parsed accordingly to RFC 9110
 // https://www.rfc-editor.org/rfc/rfc9110#field.content-range
 function parseRangeHeader (range) {
@@ -543,6 +563,7 @@ module.exports = {
   buildURL,
   addAbortListener,
   isValidHTTPToken,
+  isValidHeaderChar,
   isTokenCharCode,
   parseRangeHeader,
   nodeMajor,

package/lib/{agent.js → dispatcher/agent.js}

@@ -1,12 +1,12 @@
 'use strict'
 
-const { InvalidArgumentError } = require('./core/errors')
-const { kClients, kRunning, kClose, kDestroy, kDispatch, kInterceptors } = require('./core/symbols')
+const { InvalidArgumentError } = require('../core/errors')
+const { kClients, kRunning, kClose, kDestroy, kDispatch, kInterceptors } = 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/redirectInterceptor')
+const util = require('../core/util')
+const createRedirectInterceptor = require('../interceptor/redirect-interceptor')
 
 const kOnConnect = Symbol('onConnect')
 const kOnDisconnect = Symbol('onDisconnect')

package/lib/{balanced-pool.js → dispatcher/balanced-pool.js}

@@ -3,7 +3,7 @@
 const {
   BalancedPoolMissingUpstreamError,
   InvalidArgumentError
-} = require('./core/errors')
+} = require('../core/errors')
 const {
   PoolBase,
   kClients,
@@ -13,8 +13,8 @@ const {
   kGetDispatcher
 } = require('./pool-base')
 const Pool = require('./pool')
-const { kUrl, kInterceptors } = require('./core/symbols')
-const { parseOrigin } = require('./core/util')
+const { kUrl, kInterceptors } = require('../core/symbols')
+const { parseOrigin } = require('../core/util')
 const kFactory = Symbol('factory')
 
 const kOptions = Symbol('options')