undici 5.3.0 → 5.5.1

package/README.md

@@ -185,13 +185,12 @@ Help us improve the test coverage by following instructions at [nodejs/undici/#9
 Basic usage example:
 
 ```js
-    import {fetch} from 'undici';
+import { fetch } from 'undici';
 
-    async function fetchJson() {
-        const res = await fetch('https://example.com')
-        const json = await res.json()
-        console.log(json);
-    }
+
+const res = await fetch('https://example.com')
+const json = await res.json()
+console.log(json);
 ```
 
 You can pass an optional dispatcher to `fetch` as:
@@ -235,9 +234,7 @@ const data = {
   },
 };
 
-(async () => {
-  await fetch("https://example.com", { body: data, method: 'POST' });
-})();
+await fetch("https://example.com", { body: data, method: 'POST' });
 ```
 
 #### `response.body`
@@ -245,14 +242,12 @@ const data = {
 Nodejs has two kinds of streams: [web streams](https://nodejs.org/dist/latest-v16.x/docs/api/webstreams.html), which follow the API of the WHATWG web standard found in browsers, and an older Node-specific [streams API](https://nodejs.org/api/stream.html). `response.body` returns a readable web stream. If you would prefer to work with a Node stream you can convert a web stream using `.fromWeb()`.
 
 ```js
-    import {fetch} from 'undici';
-    import {Readable} from 'node:stream';
+import { fetch } from 'undici';
+import { Readable } from 'node:stream';
 
-    async function fetchStream() {
-        const response = await fetch('https://example.com')
-        const readableWebStream = response.body;
-        const readableNodeStream = Readable.fromWeb(readableWebStream);
-    }
+const response = await fetch('https://example.com')
+const readableWebStream = response.body;
+const readableNodeStream = Readable.fromWeb(readableWebStream);
 ```
 
 #### Specification Compliance
@@ -288,6 +283,15 @@ const headers = await fetch(url)
   .then(res => res.headers)
 ```
 
+##### Forbidden and Safelisted Header Names
+
+* https://fetch.spec.whatwg.org/#cors-safelisted-response-header-name
+* https://fetch.spec.whatwg.org/#forbidden-header-name
+* https://fetch.spec.whatwg.org/#forbidden-response-header-name
+* https://github.com/wintercg/fetch/issues/6
+
+The [Fetch Standard](https://fetch.spec.whatwg.org) requires implementations to exclude certain headers from requests and responses. In browser environments, some headers are forbidden so the user agent remains in full control over them. In Undici, these constraints are removed to give more control to the user.
+
 ### `undici.upgrade([url, options]): Promise`
 
 Upgrade to a different protocol. See [MDN - HTTP - Protocol upgrade mechanism](https://developer.mozilla.org/en-US/docs/Web/HTTP/Protocol_upgrade_mechanism) for more details.

package/docs/api/MockPool.md

@@ -57,6 +57,7 @@ Returns: `MockInterceptor` corresponding to the input options.
 * **method** `string | RegExp | (method: string) => boolean` - a matcher for the HTTP request method.
 * **body** `string | RegExp | (body: string) => boolean` - (optional) - a matcher for the HTTP request body.
 * **headers** `Record<string, string | RegExp | (body: string) => boolean`> - (optional) - a matcher for the HTTP request headers. To be intercepted, a request must match all defined headers. Extra headers not defined here may (or may not) be included in the request and do not affect the interception in any way.
+* **query** `Record<string, any> | null` - (optional) - a matcher for the HTTP request query string params.
 
 ### Return: `MockInterceptor`
 

package/lib/api/api-connect.js

@@ -15,7 +15,7 @@ class ConnectHandler extends AsyncResource {
       throw new InvalidArgumentError('invalid callback')
     }
 
-    const { signal, opaque, responseHeaders } = opts
+    const { signal, opaque, responseHeaders, httpTunnel } = opts
 
     if (signal && typeof signal.on !== 'function' && typeof signal.addEventListener !== 'function') {
       throw new InvalidArgumentError('signal must be an EventEmitter or EventTarget')
@@ -27,6 +27,7 @@ class ConnectHandler extends AsyncResource {
     this.responseHeaders = responseHeaders || null
     this.callback = callback
     this.abort = null
+    this.httpTunnel = httpTunnel
 
     addSignal(this, signal)
   }
@@ -40,8 +41,23 @@ class ConnectHandler extends AsyncResource {
     this.context = context
   }
 
-  onHeaders () {
-    throw new SocketError('bad connect', null)
+  onHeaders (statusCode) {
+    // when httpTunnel headers are allowed
+    if (this.httpTunnel) {
+      const { callback, opaque } = this
+      if (statusCode !== 200) {
+        if (callback) {
+          this.callback = null
+          const err = new RequestAbortedError('Proxy response !== 200 when HTTP Tunneling')
+          queueMicrotask(() => {
+            this.runInAsyncScope(callback, null, err, { opaque })
+          })
+        }
+        return 1
+      }
+    } else {
+      throw new SocketError('bad connect', null)
+    }
   }
 
   onUpgrade (statusCode, rawHeaders, socket) {

package/lib/client.js

@@ -873,6 +873,11 @@ class Parser {
       // have been queued since then.
       util.destroy(socket, new InformationalError('reset'))
       return constants.ERROR.PAUSED
+    } else if (client[kPipelining] === 1) {
+      // We must wait a full event loop cycle to reuse this socket to make sure
+      // that non-spec compliant servers are not closing the connection even if they
+      // said they won't.
+      setImmediate(resume, client)
     } else {
       resume(client)
     }

package/lib/core/connect.js

@@ -21,7 +21,7 @@ function buildConnector ({ maxCachedSessions, socketPath, timeout, ...opts }) {
   timeout = timeout == null ? 10e3 : timeout
   maxCachedSessions = maxCachedSessions == null ? 100 : maxCachedSessions
 
-  return function connect ({ hostname, host, protocol, port, servername }, callback) {
+  return function connect ({ hostname, host, protocol, port, servername, httpSocket }, callback) {
     let socket
     if (protocol === 'https:') {
       if (!tls) {
@@ -39,6 +39,7 @@ function buildConnector ({ maxCachedSessions, socketPath, timeout, ...opts }) {
         ...options,
         servername,
         session,
+        socket: httpSocket, // upgrade socket connection
         port: port || 443,
         host: hostname
       })
@@ -65,6 +66,7 @@ function buildConnector ({ maxCachedSessions, socketPath, timeout, ...opts }) {
           }
         })
     } else {
+      assert(!httpSocket, 'httpSocket can only be sent on TLS update')
       socket = net.connect({
         highWaterMark: 64 * 1024, // Same as nodejs fs streams.
         ...options,

package/lib/core/request.js

@@ -48,7 +48,11 @@ class Request {
   }, handler) {
     if (typeof path !== 'string') {
       throw new InvalidArgumentError('path must be a string')
-    } else if (path[0] !== '/' && !(path.startsWith('http://') || path.startsWith('https://'))) {
+    } else if (
+      path[0] !== '/' &&
+      !(path.startsWith('http://') || path.startsWith('https://')) &&
+      method !== 'CONNECT'
+    ) {
       throw new InvalidArgumentError('path must be an absolute URL or start with a slash')
     }
 
@@ -80,13 +84,12 @@ class Request {
       this.body = null
     } else if (util.isStream(body)) {
       this.body = body
-    } else if (body instanceof DataView) {
-      // TODO: Why is DataView special?
-      this.body = body.buffer.byteLength ? Buffer.from(body.buffer) : null
-    } else if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) {
-      this.body = body.byteLength ? Buffer.from(body) : null
     } else if (util.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
+    } else if (body instanceof ArrayBuffer) {
+      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)) {

package/lib/fetch/body.js

@@ -9,7 +9,7 @@ const { kBodyUsed } = require('../core/symbols')
 const assert = require('assert')
 const { NotSupportedError } = require('../core/errors')
 const { isErrored } = require('../core/util')
-const { isUint8Array } = require('util/types')
+const { isUint8Array, isArrayBuffer } = require('util/types')
 
 let ReadableStream
 
@@ -61,7 +61,7 @@ function extractBody (object, keepalive = false) {
 
     // Set Content-Type to `application/x-www-form-urlencoded;charset=UTF-8`.
     contentType = 'application/x-www-form-urlencoded;charset=UTF-8'
-  } else if (object instanceof ArrayBuffer || ArrayBuffer.isView(object)) {
+  } else if (isArrayBuffer(object) || ArrayBuffer.isView(object)) {
     // BufferSource
 
     if (object instanceof DataView) {

package/lib/fetch/constants.js

@@ -1,28 +1,5 @@
 'use strict'
 
-const forbiddenHeaderNames = [
-  'accept-charset',
-  'accept-encoding',
-  'access-control-request-headers',
-  'access-control-request-method',
-  'connection',
-  'content-length',
-  'cookie',
-  'cookie2',
-  'date',
-  'dnt',
-  'expect',
-  'host',
-  'keep-alive',
-  'origin',
-  'referer',
-  'te',
-  'trailer',
-  'transfer-encoding',
-  'upgrade',
-  'via'
-]
-
 const corsSafeListedMethods = ['GET', 'HEAD', 'POST']
 
 const nullBodyStatus = [101, 204, 205, 304]
@@ -58,9 +35,6 @@ const requestCache = [
   'only-if-cached'
 ]
 
-// https://fetch.spec.whatwg.org/#forbidden-response-header-name
-const forbiddenResponseHeaderNames = ['set-cookie', 'set-cookie2']
-
 const requestBodyHeader = [
   'content-encoding',
   'content-language',
@@ -86,12 +60,8 @@ const subresource = [
   ''
 ]
 
-const corsSafeListedResponseHeaderNames = [] // TODO
-
 module.exports = {
   subresource,
-  forbiddenResponseHeaderNames,
-  corsSafeListedResponseHeaderNames,
   forbiddenMethods,
   requestBodyHeader,
   referrerPolicy,
@@ -99,7 +69,6 @@ module.exports = {
   requestMode,
   requestCredentials,
   requestCache,
-  forbiddenHeaderNames,
   redirectStatus,
   corsSafeListedMethods,
   nullBodyStatus,

package/lib/fetch/formdata.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { isBlobLike, isFileLike, toUSVString } = require('./util')
+const { isBlobLike, isFileLike, toUSVString, makeIterator } = require('./util')
 const { kState } = require('./symbols')
 const { File, FileLike } = require('./file')
 const { Blob } = require('buffer')
@@ -187,45 +187,68 @@ class FormData {
     return this.constructor.name
   }
 
-  * entries () {
+  entries () {
     if (!(this instanceof FormData)) {
       throw new TypeError('Illegal invocation')
     }
 
-    for (const pair of this) {
-      yield pair
-    }
+    return makeIterator(
+      makeIterable(this[kState], 'entries'),
+      'FormData'
+    )
   }
 
-  * keys () {
+  keys () {
     if (!(this instanceof FormData)) {
       throw new TypeError('Illegal invocation')
     }
 
-    for (const [key] of this) {
-      yield key
+    return makeIterator(
+      makeIterable(this[kState], 'keys'),
+      'FormData'
+    )
+  }
+
+  values () {
+    if (!(this instanceof FormData)) {
+      throw new TypeError('Illegal invocation')
     }
+
+    return makeIterator(
+      makeIterable(this[kState], 'values'),
+      'FormData'
+    )
   }
 
-  * values () {
+  /**
+   * @param {(value: string, key: string, self: FormData) => void} callbackFn
+   * @param {unknown} thisArg
+   */
+  forEach (callbackFn, thisArg = globalThis) {
     if (!(this instanceof FormData)) {
       throw new TypeError('Illegal invocation')
     }
 
-    for (const [, value] of this) {
-      yield value
+    if (arguments.length < 1) {
+      throw new TypeError(
+        `Failed to execute 'forEach' on 'FormData': 1 argument required, but only ${arguments.length} present.`
+      )
     }
-  }
 
-  * [Symbol.iterator] () {
-    // The value pairs to iterate over are this’s entry list’s entries with
-    // the key being the name and the value being the value.
-    for (const { name, value } of this[kState]) {
-      yield [name, value]
+    if (typeof callbackFn !== 'function') {
+      throw new TypeError(
+        "Failed to execute 'forEach' on 'FormData': parameter 1 is not of type 'Function'."
+      )
+    }
+
+    for (const [key, value] of this) {
+      callbackFn.apply(thisArg, [value, key, this])
     }
   }
 }
 
+FormData.prototype[Symbol.iterator] = FormData.prototype.entries
+
 function makeEntry (name, value, filename) {
   // To create an entry for name, value, and optionally a filename, run these
   // steps:
@@ -243,8 +266,8 @@ function makeEntry (name, value, filename) {
   // object, representing the same bytes, whose name attribute value is "blob".
   if (isBlobLike(value) && !isFileLike(value)) {
     value = value instanceof Blob
-      ? new File([value], 'blob')
-      : new FileLike(value, 'blob')
+      ? new File([value], 'blob', value)
+      : new FileLike(value, 'blob', value)
   }
 
   // 4. If value is (now) a File object and filename is given, then set value to a
@@ -256,8 +279,8 @@ function makeEntry (name, value, filename) {
   // creating one more File instance doesn't make much sense....
   if (isFileLike(value) && filename != null) {
     value = value instanceof File
-      ? new File([value], filename)
-      : new FileLike(value, filename)
+      ? new File([value], filename, value)
+      : new FileLike(value, filename, value)
   }
 
   // 5. Set entry’s value to value.
@@ -267,4 +290,18 @@ function makeEntry (name, value, filename) {
   return entry
 }
 
+function * makeIterable (entries, type) {
+  // The value pairs to iterate over are this’s entry list’s entries
+  // with the key being the name and the value being the value.
+  for (const { name, value } of entries) {
+    if (type === 'entries') {
+      yield [name, value]
+    } else if (type === 'values') {
+      yield value
+    } else {
+      yield name
+    }
+  }
+}
+
 module.exports = { FormData }

package/lib/fetch/headers.js

@@ -6,10 +6,7 @@ const { validateHeaderName, validateHeaderValue } = require('http')
 const { kHeadersList } = require('../core/symbols')
 const { kGuard } = require('./symbols')
 const { kEnumerableProperty } = require('../core/util')
-const {
-  forbiddenHeaderNames,
-  forbiddenResponseHeaderNames
-} = require('./constants')
+const { makeIterator } = require('./util')
 
 const kHeadersMap = Symbol('headers map')
 const kHeadersSortedMap = Symbol('headers map sorted')
@@ -77,33 +74,6 @@ function fill (headers, object) {
   }
 }
 
-// https://tc39.es/ecma262/#sec-%25iteratorprototype%25-object
-const esIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()))
-
-// https://webidl.spec.whatwg.org/#dfn-iterator-prototype-object
-function makeHeadersIterator (iterator) {
-  const i = {
-    next () {
-      if (Object.getPrototypeOf(this) !== i) {
-        throw new TypeError(
-          '\'next\' called on an object that does not implement interface Headers Iterator.'
-        )
-      }
-
-      return iterator.next()
-    },
-    // The class string of an iterator prototype object for a given interface is the
-    // result of concatenating the identifier of the interface and the string " Iterator".
-    [Symbol.toStringTag]: 'Headers Iterator'
-  }
-
-  // The [[Prototype]] internal slot of an iterator prototype object must be %IteratorPrototype%.
-  Object.setPrototypeOf(i, esIteratorPrototype)
-  // esIteratorPrototype needs to be the prototype of i
-  // which is the prototype of an empty object. Yes, it's confusing.
-  return Object.setPrototypeOf({}, i)
-}
-
 class HeadersList {
   constructor (init) {
     if (init instanceof HeadersList) {
@@ -115,6 +85,11 @@ class HeadersList {
     }
   }
 
+  clear () {
+    this[kHeadersMap].clear()
+    this[kHeadersSortedMap] = null
+  }
+
   append (name, value) {
     this[kHeadersSortedMap] = null
 
@@ -211,22 +186,11 @@ class Headers {
       )
     }
 
-    const normalizedName = normalizeAndValidateHeaderName(String(name))
-
+    // Note: undici does not implement forbidden header names
     if (this[kGuard] === 'immutable') {
       throw new TypeError('immutable')
-    } else if (
-      this[kGuard] === 'request' &&
-      forbiddenHeaderNames.includes(normalizedName)
-    ) {
-      return
     } else if (this[kGuard] === 'request-no-cors') {
       // TODO
-    } else if (
-      this[kGuard] === 'response' &&
-      forbiddenResponseHeaderNames.includes(normalizedName)
-    ) {
-      return
     }
 
     return this[kHeadersList].append(String(name), String(value))
@@ -244,22 +208,11 @@ class Headers {
       )
     }
 
-    const normalizedName = normalizeAndValidateHeaderName(String(name))
-
+    // Note: undici does not implement forbidden header names
     if (this[kGuard] === 'immutable') {
       throw new TypeError('immutable')
-    } else if (
-      this[kGuard] === 'request' &&
-      forbiddenHeaderNames.includes(normalizedName)
-    ) {
-      return
     } else if (this[kGuard] === 'request-no-cors') {
       // TODO
-    } else if (
-      this[kGuard] === 'response' &&
-      forbiddenResponseHeaderNames.includes(normalizedName)
-    ) {
-      return
     }
 
     return this[kHeadersList].delete(String(name))
@@ -307,20 +260,11 @@ class Headers {
       )
     }
 
+    // Note: undici does not implement forbidden header names
     if (this[kGuard] === 'immutable') {
       throw new TypeError('immutable')
-    } else if (
-      this[kGuard] === 'request' &&
-      forbiddenHeaderNames.includes(String(name).toLocaleLowerCase())
-    ) {
-      return
     } else if (this[kGuard] === 'request-no-cors') {
       // TODO
-    } else if (
-      this[kGuard] === 'response' &&
-      forbiddenResponseHeaderNames.includes(String(name).toLocaleLowerCase())
-    ) {
-      return
     }
 
     return this[kHeadersList].set(String(name), String(value))
@@ -336,7 +280,7 @@ class Headers {
       throw new TypeError('Illegal invocation')
     }
 
-    return makeHeadersIterator(this[kHeadersSortedMap].keys())
+    return makeIterator(this[kHeadersSortedMap].keys(), 'Headers')
   }
 
   values () {
@@ -344,7 +288,7 @@ class Headers {
       throw new TypeError('Illegal invocation')
     }
 
-    return makeHeadersIterator(this[kHeadersSortedMap].values())
+    return makeIterator(this[kHeadersSortedMap].values(), 'Headers')
   }
 
   entries () {
@@ -352,7 +296,7 @@ class Headers {
       throw new TypeError('Illegal invocation')
     }
 
-    return makeHeadersIterator(this[kHeadersSortedMap].entries())
+    return makeIterator(this[kHeadersSortedMap].entries(), 'Headers')
   }
 
   /**

package/lib/fetch/index.js

@@ -1164,7 +1164,7 @@ async function httpRedirectFetch (fetchParams, response) {
   if (
     ([301, 302].includes(actualResponse.status) && request.method === 'POST') ||
     (actualResponse.status === 303 &&
-      !['GET', 'HEADER'].includes(request.method))
+      !['GET', 'HEAD'].includes(request.method))
   ) {
     // then:
     // 1. Set request’s method to `GET` and request’s body to null.

package/lib/fetch/request.js

@@ -384,8 +384,8 @@ class Request {
     // Realm, whose header list is request’s header list and guard is
     // "request".
     this[kHeaders] = new Headers()
-    this[kHeaders][kGuard] = 'request'
     this[kHeaders][kHeadersList] = request.headersList
+    this[kHeaders][kGuard] = 'request'
     this[kHeaders][kRealm] = this[kRealm]
 
     // 31. If this’s request’s mode is "no-cors", then:
@@ -406,7 +406,7 @@ class Request {
     if (Object.keys(init).length !== 0) {
       // 1. Let headers be a copy of this’s headers and its associated header
       // list.
-      let headers = new Headers(this.headers)
+      let headers = new Headers(this[kHeaders])
 
       // 2. If init["headers"] exists, then set headers to init["headers"].
       if (init.headers !== undefined) {
@@ -414,18 +414,17 @@ class Request {
       }
 
       // 3. Empty this’s headers’s header list.
-      this[kState].headersList = new HeadersList()
-      this[kHeaders][kHeadersList] = this[kState].headersList
+      this[kHeaders][kHeadersList].clear()
 
       // 4. If headers is a Headers object, then for each header in its header
       // list, append header’s name/header’s value to this’s headers.
       if (headers.constructor.name === 'Headers') {
-        for (const [key, val] of headers[kHeadersList] || headers) {
+        for (const [key, val] of headers) {
           this[kHeaders].append(key, val)
         }
       } else {
         // 5. Otherwise, fill this’s headers with headers.
-        fillHeaders(this[kState].headersList, headers)
+        fillHeaders(this[kHeaders], headers)
       }
     }
 

package/lib/fetch/response.js

@@ -8,9 +8,7 @@ const { kEnumerableProperty } = util
 const { responseURL, isValidReasonPhrase, toUSVString, isCancelled, isAborted, serializeJavascriptValueToJSONString } = require('./util')
 const {
   redirectStatus,
-  nullBodyStatus,
-  forbiddenResponseHeaderNames,
-  corsSafeListedResponseHeaderNames
+  nullBodyStatus
 } = require('./constants')
 const { kState, kHeaders, kGuard, kRealm } = require('./symbols')
 const { kHeadersList } = require('../core/symbols')
@@ -380,28 +378,6 @@ function makeFilteredResponse (response, state) {
   })
 }
 
-function makeFilteredHeadersList (headersList, filter) {
-  return new Proxy(headersList, {
-    get (target, prop) {
-      // Override methods used by Headers class.
-      if (prop === 'get' || prop === 'has') {
-        const defaultReturn = prop === 'has' ? false : null
-        return (name) => filter(name) ? target[prop](name) : defaultReturn
-      } else if (prop === Symbol.iterator) {
-        return function * () {
-          for (const entry of target) {
-            if (filter(entry[0])) {
-              yield entry
-            }
-          }
-        }
-      } else {
-        return target[prop]
-      }
-    }
-  })
-}
-
 // https://fetch.spec.whatwg.org/#concept-filtered-response
 function filterResponse (response, type) {
   // Set response to the following filtered response with response as its
@@ -411,12 +387,10 @@ function filterResponse (response, type) {
     // and header list excludes any headers in internal response’s header list
     // whose name is a forbidden response-header name.
 
+    // Note: undici does not implement forbidden response-header names
     return makeFilteredResponse(response, {
       type: 'basic',
-      headersList: makeFilteredHeadersList(
-        response.headersList,
-        (name) => !forbiddenResponseHeaderNames.includes(name.toLowerCase())
-      )
+      headersList: response.headersList
     })
   } else if (type === 'cors') {
     // A CORS filtered response is a filtered response whose type is "cors"
@@ -424,9 +398,10 @@ function filterResponse (response, type) {
     // list whose name is not a CORS-safelisted response-header name, given
     // internal response’s CORS-exposed header-name list.
 
+    // Note: undici does not implement CORS-safelisted response-header names
     return makeFilteredResponse(response, {
       type: 'cors',
-      headersList: makeFilteredHeadersList(response.headersList, (name) => !corsSafeListedResponseHeaderNames.includes(name))
+      headersList: response.headersList
     })
   } else if (type === 'opaque') {
     // An opaque filtered response is a filtered response whose type is
@@ -449,7 +424,7 @@ function filterResponse (response, type) {
       type: 'opaqueredirect',
       status: 0,
       statusText: '',
-      headersList: makeFilteredHeadersList(response.headersList, () => false),
+      headersList: [],
       body: null
     })
   } else {

package/lib/fetch/util.js

@@ -361,6 +361,33 @@ function serializeJavascriptValueToJSONString (value) {
   return result
 }
 
+// https://tc39.es/ecma262/#sec-%25iteratorprototype%25-object
+const esIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()))
+
+// https://webidl.spec.whatwg.org/#dfn-iterator-prototype-object
+function makeIterator (iterator, name) {
+  const i = {
+    next () {
+      if (Object.getPrototypeOf(this) !== i) {
+        throw new TypeError(
+          `'next' called on an object that does not implement interface ${name} Iterator.`
+        )
+      }
+
+      return iterator.next()
+    },
+    // The class string of an iterator prototype object for a given interface is the
+    // result of concatenating the identifier of the interface and the string " Iterator".
+    [Symbol.toStringTag]: `${name} Iterator`
+  }
+
+  // The [[Prototype]] internal slot of an iterator prototype object must be %IteratorPrototype%.
+  Object.setPrototypeOf(i, esIteratorPrototype)
+  // esIteratorPrototype needs to be the prototype of i
+  // which is the prototype of an empty object. Yes, it's confusing.
+  return Object.setPrototypeOf({}, i)
+}
+
 module.exports = {
   isAborted,
   isCancelled,
@@ -390,5 +417,6 @@ module.exports = {
   isValidReasonPhrase,
   sameOrigin,
   normalizeMethod,
-  serializeJavascriptValueToJSONString
+  serializeJavascriptValueToJSONString,
+  makeIterator
 }

package/lib/mock/mock-interceptor.js

@@ -10,6 +10,7 @@ const {
   kMockDispatch
 } = require('./mock-symbols')
 const { InvalidArgumentError } = require('../core/errors')
+const { buildURL } = require('../core/util')
 
 /**
  * Defines the scope API for an interceptor reply
@@ -70,9 +71,13 @@ class MockInterceptor {
     // As per RFC 3986, clients are not supposed to send URI
     // fragments to servers when they retrieve a document,
     if (typeof opts.path === 'string') {
-      // Matches https://github.com/nodejs/undici/blob/main/lib/fetch/index.js#L1811
-      const parsedURL = new URL(opts.path, 'data://')
-      opts.path = parsedURL.pathname + parsedURL.search
+      if (opts.query) {
+        opts.path = buildURL(opts.path, opts.query)
+      } else {
+        // Matches https://github.com/nodejs/undici/blob/main/lib/fetch/index.js#L1811
+        const parsedURL = new URL(opts.path, 'data://')
+        opts.path = parsedURL.pathname + parsedURL.search
+      }
     }
     if (typeof opts.method === 'string') {
       opts.method = opts.method.toUpperCase()

package/lib/mock/mock-utils.js

@@ -8,6 +8,7 @@ const {
   kOrigin,
   kGetNetConnect
 } = require('./mock-symbols')
+const { buildURL } = require('../core/util')
 
 function matchValue (match, value) {
   if (typeof match === 'string') {
@@ -98,10 +99,12 @@ function getResponseData (data) {
 }
 
 function getMockDispatch (mockDispatches, key) {
+  const resolvedPath = key.query ? buildURL(key.path, key.query) : key.path
+
   // Match path
-  let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path }) => matchValue(path, key.path))
+  let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path }) => matchValue(path, resolvedPath))
   if (matchedMockDispatches.length === 0) {
-    throw new MockNotMatchedError(`Mock dispatch not matched for path '${key.path}'`)
+    throw new MockNotMatchedError(`Mock dispatch not matched for path '${resolvedPath}'`)
   }
 
   // Match method
@@ -146,12 +149,13 @@ function deleteMockDispatch (mockDispatches, key) {
 }
 
 function buildKey (opts) {
-  const { path, method, body, headers } = opts
+  const { path, method, body, headers, query } = opts
   return {
     path,
     method,
     body,
-    headers
+    headers,
+    query
   }
 }
 

package/lib/proxy-agent.js

@@ -1,28 +1,46 @@
 'use strict'
 
 const { kProxy, kClose, kDestroy } = require('./core/symbols')
+const Client = require('./agent')
 const Agent = require('./agent')
 const DispatcherBase = require('./dispatcher-base')
 const { InvalidArgumentError } = require('./core/errors')
+const buildConnector = require('./core/connect')
 
 const kAgent = Symbol('proxy agent')
+const kClient = Symbol('proxy client')
+const kProxyHeaders = Symbol('proxy headers')
+const kRequestTls = Symbol('request tls settings')
+const kProxyTls = Symbol('proxy tls settings')
+const kConnectEndpoint = Symbol('connect endpoint function')
 
 class ProxyAgent extends DispatcherBase {
   constructor (opts) {
     super(opts)
     this[kProxy] = buildProxyOptions(opts)
-    this[kAgent] = new Agent(opts)
+    this[kRequestTls] = opts.requestTls
+    this[kProxyTls] = opts.proxyTls
+    this[kProxyHeaders] = {}
+
+    if (opts.auth) {
+      this[kProxyHeaders]['proxy-authorization'] = `Basic ${opts.auth}`
+    }
+
+    const connect = buildConnector({ ...opts.proxyTls })
+    this[kConnectEndpoint] = buildConnector({ ...opts.requestTls })
+    this[kClient] = new Client({ origin: opts.origin, connect })
+    this[kAgent] = new Agent({ ...opts, connect: this.connectTunnel.bind(this) })
   }
 
   dispatch (opts, handler) {
     const { host } = new URL(opts.origin)
+    const headers = buildHeaders(opts.headers)
+    throwIfProxyAuthIsSent(headers)
     return this[kAgent].dispatch(
       {
         ...opts,
-        origin: this[kProxy].uri,
-        path: opts.origin + opts.path,
         headers: {
-          ...buildHeaders(opts.headers),
+          ...headers,
           host
         }
       },
@@ -30,12 +48,43 @@ class ProxyAgent extends DispatcherBase {
     )
   }
 
+  async connectTunnel (opts, callback) {
+    try {
+      const { socket } = await this[kClient].connect({
+        origin: this[kProxy].origin,
+        port: this[kProxy].port,
+        path: opts.host,
+        signal: opts.signal,
+        headers: {
+          ...this[kProxyHeaders],
+          host: opts.host
+        },
+        httpTunnel: true
+      })
+      if (opts.protocol !== 'https:') {
+        callback(null, socket)
+        return
+      }
+      let servername
+      if (this[kRequestTls]) {
+        servername = this[kRequestTls].servername
+      } else {
+        servername = opts.servername
+      }
+      this[kConnectEndpoint]({ ...opts, servername, httpSocket: socket }, callback)
+    } catch (err) {
+      callback(err)
+    }
+  }
+
   async [kClose] () {
     await this[kAgent].close()
+    await this[kClient].close()
   }
 
   async [kDestroy] () {
     await this[kAgent].destroy()
+    await this[kClient].destroy()
   }
 }
 
@@ -48,10 +97,7 @@ function buildProxyOptions (opts) {
     throw new InvalidArgumentError('Proxy opts.uri is mandatory')
   }
 
-  return {
-    uri: opts.uri,
-    protocol: opts.protocol || 'https'
-  }
+  return new URL(opts.uri)
 }
 
 /**
@@ -75,4 +121,20 @@ function buildHeaders (headers) {
   return headers
 }
 
+/**
+ * @param {Record<string, string>} headers
+ *
+ * Previous versions of ProxyAgent suggests the Proxy-Authorization in request headers
+ * Nevertheless, it was changed and to avoid a security vulnerability by end users
+ * this check was created.
+ * It should be removed in the next major version for performance reasons
+ */
+function throwIfProxyAuthIsSent (headers) {
+  const existProxyAuth = headers && Object.keys(headers)
+    .find((key) => key.toLowerCase() === 'proxy-authorization')
+  if (existProxyAuth) {
+    throw new InvalidArgumentError('Proxy-Authorization should be sent in ProxyAgent constructor')
+  }
+}
+
 module.exports = ProxyAgent

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "undici",
-  "version": "5.3.0",
+  "version": "5.5.1",
   "description": "An HTTP/1.1 client, written from scratch for Node.js",
   "homepage": "https://undici.nodejs.org",
   "bugs": {
@@ -67,7 +67,7 @@
     "@sinonjs/fake-timers": "^9.1.2",
     "@types/node": "^17.0.29",
     "abort-controller": "^3.0.0",
-    "busboy": "^0.3.1",
+    "busboy": "^1.6.0",
     "chai": "^4.3.4",
     "chai-as-promised": "^7.1.1",
     "chai-iterator": "^3.0.2",
@@ -77,8 +77,8 @@
     "delay": "^5.0.0",
     "docsify-cli": "^4.4.3",
     "formdata-node": "^4.3.1",
-    "https-pem": "^2.0.0",
-    "husky": "^7.0.2",
+    "https-pem": "^3.0.0",
+    "husky": "^8.0.1",
     "import-fresh": "^3.3.0",
     "jest": "^28.0.1",
     "jsfuzz": "^1.0.15",

package/types/connector.d.ts

@@ -1,16 +1,15 @@
-import { URL } from 'url'
-import { TLSSocket, TlsOptions } from 'tls'
-import { Socket } from 'net'
+import {TLSSocket, ConnectionOptions} from 'tls'
+import {IpcNetConnectOpts, Socket, TcpNetConnectOpts} from 'net'
 
 export = buildConnector
 declare function buildConnector (options?: buildConnector.BuildOptions): typeof buildConnector.connector
 
 declare namespace buildConnector {
-  export interface BuildOptions extends TlsOptions {
+  export type BuildOptions = (ConnectionOptions | TcpNetConnectOpts | IpcNetConnectOpts) & {
     maxCachedSessions?: number | null;
     socketPath?: string | null;
     timeout?: number | null;
-    servername?: string | null;
+    port?: number;
   }
 
   export interface Options {

package/types/dispatcher.d.ts

@@ -3,7 +3,7 @@ import { Duplex, Readable, Writable } from 'stream'
 import { EventEmitter } from 'events'
 import { IncomingHttpHeaders } from 'http'
 import { Blob } from 'buffer'
-import BodyReadable from './readable'
+import BodyReadable = require('./readable')
 import { FormData } from './formdata'
 
 type AbortSignal = unknown;

package/types/fetch.d.ts

@@ -38,21 +38,21 @@ export interface BodyMixin {
   readonly text: () => Promise<string>
 }
 
-export interface HeadersIterator<T, TReturn = any, TNext = undefined> {
+export interface SpecIterator<T, TReturn = any, TNext = undefined> {
   next(...args: [] | [TNext]): IteratorResult<T, TReturn>;
 }
 
-export interface HeadersIterableIterator<T> extends HeadersIterator<T> {
-  [Symbol.iterator](): HeadersIterableIterator<T>;
+export interface SpecIterableIterator<T> extends SpecIterator<T> {
+  [Symbol.iterator](): SpecIterableIterator<T>;
 }
 
-export interface HeadersIterable<T> {
-  [Symbol.iterator](): HeadersIterator<T>;
+export interface SpecIterable<T> {
+  [Symbol.iterator](): SpecIterator<T>;
 }
 
 export type HeadersInit = string[][] | Record<string, string | ReadonlyArray<string>> | Headers
 
-export declare class Headers implements HeadersIterable<[string, string]> {
+export declare class Headers implements SpecIterable<[string, string]> {
   constructor (init?: HeadersInit)
   readonly append: (name: string, value: string) => void
   readonly delete: (name: string) => void
@@ -64,10 +64,10 @@ export declare class Headers implements HeadersIterable<[string, string]> {
     thisArg?: unknown
   ) => void
 
-  readonly keys: () => HeadersIterableIterator<string>
-  readonly values: () => HeadersIterableIterator<string>
-  readonly entries: () => HeadersIterableIterator<[string, string]>
-  readonly [Symbol.iterator]: () => HeadersIterator<[string, string]>
+  readonly keys: () => SpecIterableIterator<string>
+  readonly values: () => SpecIterableIterator<string>
+  readonly entries: () => SpecIterableIterator<[string, string]>
+  readonly [Symbol.iterator]: () => SpecIterator<[string, string]>
 }
 
 export type RequestCache =

package/types/formdata.d.ts

@@ -2,6 +2,7 @@
 /// <reference types="node" />
 
 import { File } from './file'
+import { SpecIterator, SpecIterableIterator } from './fetch'
 
 /**
  * A `string` or `File` that represents a single value from a set of `FormData` key-value pairs.
@@ -73,32 +74,35 @@ export declare class FormData {
   delete(name: string): void
 
   /**
-   * Returns an [`iterator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) allowing to go through all keys contained in this `FormData` object.
-   * Each key is a `string`.
+   * Executes given callback function for each field of the FormData instance
    */
-  keys(): Generator<string>
+  forEach: (
+    callbackfn: (value: FormDataEntryValue, key: string, iterable: FormData) => void,
+    thisArg?: unknown
+  ) => void
 
   /**
-   * Returns an [`iterator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) allowing to go through the `FormData` key/value pairs.
-   * The key of each pair is a string; the value is a [`FormDataValue`](https://developer.mozilla.org/en-US/docs/Web/API/FormDataEntryValue).
+   * Returns an [`iterator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) allowing to go through all keys contained in this `FormData` object.
+   * Each key is a `string`.
    */
-  entries(): Generator<[string, FormDataEntryValue]>
+  keys: () => SpecIterableIterator<string>
 
   /**
    * Returns an [`iterator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) allowing to go through all values contained in this object `FormData` object.
    * Each value is a [`FormDataValue`](https://developer.mozilla.org/en-US/docs/Web/API/FormDataEntryValue).
    */
-  values(): Generator<FormDataEntryValue>
+  values: () => SpecIterableIterator<FormDataEntryValue>
 
   /**
-   * An alias for FormData#entries()
+   * Returns an [`iterator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) allowing to go through the `FormData` key/value pairs.
+   * The key of each pair is a string; the value is a [`FormDataValue`](https://developer.mozilla.org/en-US/docs/Web/API/FormDataEntryValue).
    */
-  [Symbol.iterator](): Generator<[string, FormDataEntryValue], void>
+  entries: () => SpecIterableIterator<[string, FormDataEntryValue]>
 
   /**
-   * Executes given callback function for each field of the FormData instance
+   * An alias for FormData#entries()
    */
-  forEach(callback: (value: FormDataEntryValue, key: string, formData: FormData) => void, thisArg?: unknown): void
+  [Symbol.iterator]: () => SpecIterableIterator<[string, FormDataEntryValue]>
 
   readonly [Symbol.toStringTag]: string
 }

package/types/mock-interceptor.d.ts

@@ -1,5 +1,5 @@
 import { IncomingHttpHeaders } from 'http'
-import Dispatcher from './dispatcher';
+import Dispatcher = require('./dispatcher');
 import { BodyInit, Headers } from './fetch'
 
 export {
@@ -50,6 +50,8 @@ declare namespace MockInterceptor {
     body?: string | RegExp | ((body: string) => boolean);
     /** Headers to intercept on. */
     headers?: Record<string, string | RegExp | ((body: string) => boolean)> | ((headers: Record<string, string>) => boolean);
+    /** Query params to intercept on */
+    query?: Record<string, any>;
   }
   export interface MockDispatch<TData extends object = object, TError extends Error = Error> extends Options {
     times: number | null;

package/types/proxy-agent.d.ts

@@ -1,3 +1,4 @@
+import { TlsOptions } from 'tls'
 import Agent = require('./agent')
 import Dispatcher = require('./dispatcher')
 
@@ -13,5 +14,8 @@ declare class ProxyAgent extends Dispatcher {
 declare namespace ProxyAgent {
   export interface Options extends Agent.Options {
     uri: string;
+    auth?: string;
+    requestTls?: TlsOptions & { servername?: string };
+    proxyTls?: TlsOptions & { servername?: string };
   }
 }