undici 5.5.1 → 5.7.0

package/README.md

@@ -176,7 +176,7 @@ Implements [fetch](https://fetch.spec.whatwg.org/#fetch-method).
 * https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch
 * https://fetch.spec.whatwg.org/#fetch-method
 
-Only supported on Node 16.5+.
+Only supported on Node 16.8+.
 
 This is [experimental](https://nodejs.org/api/documentation.html#documentation_stability_index) and is not yet fully compliant with the Fetch Standard.
 We plan to ship breaking changes to this feature until it is out of experimental.
@@ -283,6 +283,13 @@ const headers = await fetch(url)
   .then(res => res.headers)
 ```
 
+However, if you want to get only headers, it might be better to use `HEAD` request method. Usage of this method will obviate the need for consumption or cancelling of the response body. See [MDN - HTTP - HTTP request methods - HEAD](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/HEAD) for more details.
+
+```js
+const headers = await fetch(url, { method: 'HEAD' })
+  .then(res => res.headers)
+```
+
 ##### Forbidden and Safelisted Header Names
 
 * https://fetch.spec.whatwg.org/#cors-safelisted-response-header-name

package/docs/api/Dispatcher.md

@@ -461,14 +461,14 @@ Arguments:
 * **options** `RequestOptions`
 * **callback** `(error: Error | null, data: ResponseData) => void` (optional)
 
-Returns: `void | Promise<ResponseData>` - Only returns a `Promise` if no `callback` argument was passed
+Returns: `void | Promise<ResponseData>` - Only returns a `Promise` if no `callback` argument was passed.
 
 #### Parameter: `RequestOptions`
 
 Extends: [`DispatchOptions`](#parameter-dispatchoptions)
 
-* **opaque** `unknown` (optional) - Default: `null` - Used for passing through context to `ResponseData`
-* **signal** `AbortSignal | events.EventEmitter | null` (optional) - Default: `null`
+* **opaque** `unknown` (optional) - Default: `null` - Used for passing through context to `ResponseData`.
+* **signal** `AbortSignal | events.EventEmitter | null` (optional) - Default: `null`.
 * **onInfo** `({statusCode: number, headers: Record<string, string | string[]>}) => void | null` (optional) - Default: `null` - Callback collecting all the info headers (HTTP 100-199) received.
 
 The `RequestOptions.method` property should not be value `'CONNECT'`.
@@ -476,7 +476,7 @@ The `RequestOptions.method` property should not be value `'CONNECT'`.
 #### Parameter: `ResponseData`
 
 * **statusCode** `number`
-* **headers** `http.IncomingHttpHeaders`
+* **headers** `http.IncomingHttpHeaders` - Note that all header keys are lower-cased, e. g. `content-type`.
 * **body** `stream.Readable` which also implements [the body mixin from the Fetch Standard](https://fetch.spec.whatwg.org/#body-mixin).
 * **trailers** `Record<string, string>` - This object starts out
   as empty and will be mutated to contain trailers after `body` has emitted `'end'`.
@@ -497,6 +497,8 @@ The `RequestOptions.method` property should not be value `'CONNECT'`.
 
 - `dump({ limit: Integer })`, dump the response by reading up to `limit` bytes without killing the socket (optional) - Default: 262144.
 
+Note that body will still be a `Readable` even if it is empty, but attempting to deserialize it with `json()` will result in an exception. Recommended way to ensure there is a body to deserialize is to check if status code is not 204, and `content-type` header starts with `application/json`.
+
 #### Example 1 - Basic GET Request
 
 ```js

package/docs/api/MockAgent.md

@@ -465,7 +465,7 @@ agent.disableNetConnect()
 agent
   .get('https://example.com')
   .intercept({ method: 'GET', path: '/' })
-  .reply(200, '')
+  .reply(200)
 
 const pendingInterceptors = agent.pendingInterceptors()
 // Returns [
@@ -508,7 +508,7 @@ agent.disableNetConnect()
 agent
   .get('https://example.com')
   .intercept({ method: 'GET', path: '/' })
-  .reply(200, '')
+  .reply(200)
 
 agent.assertNoPendingInterceptors()
 // Throws an UndiciError with the following message:

package/index.js

@@ -80,7 +80,7 @@ function makeDispatcher (fn) {
 module.exports.setGlobalDispatcher = setGlobalDispatcher
 module.exports.getGlobalDispatcher = getGlobalDispatcher
 
-if (nodeMajor > 16 || (nodeMajor === 16 && nodeMinor >= 5)) {
+if (nodeMajor > 16 || (nodeMajor === 16 && nodeMinor >= 8)) {
   let fetchImpl = null
   module.exports.fetch = async function fetch (resource) {
     if (!fetchImpl) {

package/lib/api/api-connect.js

@@ -15,7 +15,7 @@ class ConnectHandler extends AsyncResource {
       throw new InvalidArgumentError('invalid callback')
     }
 
-    const { signal, opaque, responseHeaders, httpTunnel } = opts
+    const { signal, opaque, responseHeaders } = opts
 
     if (signal && typeof signal.on !== 'function' && typeof signal.addEventListener !== 'function') {
       throw new InvalidArgumentError('signal must be an EventEmitter or EventTarget')
@@ -27,7 +27,6 @@ class ConnectHandler extends AsyncResource {
     this.responseHeaders = responseHeaders || null
     this.callback = callback
     this.abort = null
-    this.httpTunnel = httpTunnel
 
     addSignal(this, signal)
   }
@@ -41,23 +40,8 @@ class ConnectHandler extends AsyncResource {
     this.context = context
   }
 
-  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)
-    }
+  onHeaders () {
+    throw new SocketError('bad connect', null)
   }
 
   onUpgrade (statusCode, rawHeaders, socket) {

package/lib/api/api-request.js

@@ -84,7 +84,8 @@ class RequestHandler extends AsyncResource {
     }
 
     const parsedHeaders = util.parseHeaders(rawHeaders)
-    const body = new Readable(resume, abort, parsedHeaders['content-type'])
+    const contentType = parsedHeaders['content-type']
+    const body = new Readable(resume, abort, contentType)
 
     this.callback = null
     this.res = body
@@ -92,8 +93,8 @@ class RequestHandler extends AsyncResource {
 
     if (callback !== null) {
       if (this.throwOnError && statusCode >= 400) {
-        this.runInAsyncScope(callback, null,
-          new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ''}`, statusCode, headers)
+        this.runInAsyncScope(getResolveErrorBodyCallback, null,
+          { callback, body, contentType, statusCode, statusMessage, headers }
         )
         return
       }
@@ -152,6 +153,33 @@ class RequestHandler extends AsyncResource {
   }
 }
 
+async function getResolveErrorBodyCallback ({ callback, body, contentType, statusCode, statusMessage, headers }) {
+  if (statusCode === 204 || !contentType) {
+    body.dump()
+    process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ''}`, statusCode, headers))
+    return
+  }
+
+  try {
+    if (contentType.startsWith('application/json')) {
+      const payload = await body.json()
+      process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ''}`, statusCode, headers, payload))
+      return
+    }
+
+    if (contentType.startsWith('text/')) {
+      const payload = await body.text()
+      process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ''}`, statusCode, headers, payload))
+      return
+    }
+  } catch (err) {
+    // Process in a fallback if error
+  }
+
+  body.dump()
+  process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ''}`, statusCode, headers))
+}
+
 function request (opts, callback) {
   if (callback === undefined) {
     return new Promise((resolve, reject) => {

package/lib/client.js

@@ -720,7 +720,7 @@ class Parser {
       }
     }
 
-    if (request.method === 'CONNECT' && statusCode >= 200 && statusCode < 300) {
+    if (request.method === 'CONNECT') {
       assert(client[kRunning] === 1)
       this.upgrade = true
       return 2
@@ -889,10 +889,8 @@ function onParserTimeout (parser) {
 
   /* istanbul ignore else */
   if (timeoutType === TIMEOUT_HEADERS) {
-    if (!socket[kWriting]) {
-      assert(!parser.paused, 'cannot be paused while waiting for headers')
-      util.destroy(socket, new HeadersTimeoutError())
-    }
+    assert(!parser.paused, 'cannot be paused while waiting for headers')
+    util.destroy(socket, new HeadersTimeoutError())
   } else if (timeoutType === TIMEOUT_BODY) {
     if (!parser.paused) {
       util.destroy(socket, new BodyTimeoutError())

package/lib/core/errors.js

@@ -1,13 +1,5 @@
 'use strict'
 
-class AbortError extends Error {
-  constructor () {
-    super('The operation was aborted')
-    this.code = 'ABORT_ERR'
-    this.name = 'AbortError'
-  }
-}
-
 class UndiciError extends Error {
   constructor (message) {
     super(message)
@@ -57,12 +49,13 @@ class BodyTimeoutError extends UndiciError {
 }
 
 class ResponseStatusCodeError extends UndiciError {
-  constructor (message, statusCode, headers) {
+  constructor (message, statusCode, headers, body) {
     super(message)
     Error.captureStackTrace(this, ResponseStatusCodeError)
     this.name = 'ResponseStatusCodeError'
     this.message = message || 'Response Status Code Error'
     this.code = 'UND_ERR_RESPONSE_STATUS_CODE'
+    this.body = body
     this.status = statusCode
     this.statusCode = statusCode
     this.headers = headers
@@ -191,7 +184,6 @@ class HTTPParserError extends Error {
 }
 
 module.exports = {
-  AbortError,
   HTTPParserError,
   UndiciError,
   HeadersTimeoutError,

package/lib/core/request.js

@@ -140,8 +140,8 @@ class Request {
     }
 
     if (util.isFormDataLike(this.body)) {
-      if (nodeMajor < 16 || (nodeMajor === 16 && nodeMinor < 5)) {
-        throw new InvalidArgumentError('Form-Data bodies are only supported in node v16.5 and newer.')
+      if (nodeMajor < 16 || (nodeMajor === 16 && nodeMinor < 8)) {
+        throw new InvalidArgumentError('Form-Data bodies are only supported in node v16.8 and newer.')
       }
 
       if (!extractBody) {

package/lib/fetch/body.js

@@ -4,6 +4,7 @@ const util = require('../core/util')
 const { ReadableStreamFrom, toUSVString, isBlobLike } = require('./util')
 const { FormData } = require('./formdata')
 const { kState } = require('./symbols')
+const { webidl } = require('./webidl')
 const { Blob } = require('buffer')
 const { kBodyUsed } = require('../core/symbols')
 const assert = require('assert')
@@ -14,12 +15,7 @@ const { isUint8Array, isArrayBuffer } = require('util/types')
 let ReadableStream
 
 async function * blobGen (blob) {
-  if (blob.stream) {
-    yield * blob.stream()
-  } else {
-    // istanbul ignore next: node < 16.7
-    yield await blob.arrayBuffer()
-  }
+  yield * blob.stream()
 }
 
 // https://fetch.spec.whatwg.org/#concept-bodyinit-extract
@@ -262,100 +258,188 @@ function cloneBody (body) {
   }
 }
 
-const methods = {
-  async blob () {
-    const chunks = []
+async function * consumeBody (body) {
+  if (body) {
+    if (isUint8Array(body)) {
+      yield body
+    } else {
+      const stream = body.stream
 
-    if (this[kState].body) {
-      if (isUint8Array(this[kState].body)) {
-        chunks.push(this[kState].body)
-      } else {
-        const stream = this[kState].body.stream
+      if (util.isDisturbed(stream)) {
+        throw new TypeError('disturbed')
+      }
 
-        if (util.isDisturbed(stream)) {
-          throw new TypeError('disturbed')
-        }
+      if (stream.locked) {
+        throw new TypeError('locked')
+      }
 
-        if (stream.locked) {
-          throw new TypeError('locked')
-        }
+      // Compat.
+      stream[kBodyUsed] = true
+
+      yield * stream
+    }
+  }
+}
+
+function bodyMixinMethods (instance) {
+  const methods = {
+    async blob () {
+      if (!(this instanceof instance)) {
+        throw new TypeError('Illegal invocation')
+      }
 
-        // Compat.
-        stream[kBodyUsed] = true
+      const chunks = []
 
-        for await (const chunk of stream) {
-          chunks.push(chunk)
+      for await (const chunk of consumeBody(this[kState].body)) {
+        // Assemble one final large blob with Uint8Array's can exhaust memory.
+        // That's why we create create multiple blob's and using references
+        chunks.push(new Blob([chunk]))
+      }
+
+      return new Blob(chunks, { type: this.headers.get('Content-Type') || '' })
+    },
+
+    async arrayBuffer () {
+      if (!(this instanceof instance)) {
+        throw new TypeError('Illegal invocation')
+      }
+
+      const contentLength = this.headers.get('content-length')
+      const encoded = this.headers.has('content-encoding')
+
+      // if we have content length and no encoding, then we can
+      // pre allocate the buffer and just read the data into it
+      if (!encoded && contentLength) {
+        const buffer = new Uint8Array(contentLength)
+        let offset = 0
+
+        for await (const chunk of consumeBody(this[kState].body)) {
+          buffer.set(chunk, offset)
+          offset += chunk.length
         }
+
+        return buffer.buffer
       }
-    }
 
-    return new Blob(chunks, { type: this.headers.get('Content-Type') || '' })
-  },
+      // if we don't have content length, then we have to allocate 2x the
+      // size of the body, once for consumed data, and once for the final buffer
 
-  async arrayBuffer () {
-    const blob = await this.blob()
-    return await blob.arrayBuffer()
-  },
+      // This could be optimized by using growable ArrayBuffer, but it's not
+      // implemented yet. https://github.com/tc39/proposal-resizablearraybuffer
 
-  async text () {
-    const blob = await this.blob()
-    return toUSVString(await blob.text())
-  },
+      const chunks = []
+      let size = 0
 
-  async json () {
-    return JSON.parse(await this.text())
-  },
+      for await (const chunk of consumeBody(this[kState].body)) {
+        chunks.push(chunk)
+        size += chunk.byteLength
+      }
+
+      const buffer = new Uint8Array(size)
+      let offset = 0
 
-  async formData () {
-    const contentType = this.headers.get('Content-Type')
-
-    // If mimeType’s essence is "multipart/form-data", then:
-    if (/multipart\/form-data/.test(contentType)) {
-      throw new NotSupportedError('multipart/form-data not supported')
-    } else if (/application\/x-www-form-urlencoded/.test(contentType)) {
-      // Otherwise, if mimeType’s essence is "application/x-www-form-urlencoded", then:
-
-      // 1. Let entries be the result of parsing bytes.
-      let entries
-      try {
-        entries = new URLSearchParams(await this.text())
-      } catch (err) {
-        // istanbul ignore next: Unclear when new URLSearchParams can fail on a string.
-        // 2. If entries is failure, then throw a TypeError.
-        throw Object.assign(new TypeError(), { cause: err })
+      for (const chunk of chunks) {
+        buffer.set(chunk, offset)
+        offset += chunk.byteLength
       }
 
-      // 3. Return a new FormData object whose entries are entries.
-      const formData = new FormData()
-      for (const [name, value] of entries) {
-        formData.append(name, value)
+      return buffer.buffer
+    },
+
+    async text () {
+      if (!(this instanceof instance)) {
+        throw new TypeError('Illegal invocation')
+      }
+
+      let result = ''
+      const textDecoder = new TextDecoder()
+
+      for await (const chunk of consumeBody(this[kState].body)) {
+        result += textDecoder.decode(chunk, { stream: true })
+      }
+
+      // flush
+      result += textDecoder.decode()
+
+      return result
+    },
+
+    async json () {
+      if (!(this instanceof instance)) {
+        throw new TypeError('Illegal invocation')
+      }
+
+      return JSON.parse(await this.text())
+    },
+
+    async formData () {
+      if (!(this instanceof instance)) {
+        throw new TypeError('Illegal invocation')
+      }
+
+      const contentType = this.headers.get('Content-Type')
+
+      // If mimeType’s essence is "multipart/form-data", then:
+      if (/multipart\/form-data/.test(contentType)) {
+        throw new NotSupportedError('multipart/form-data not supported')
+      } else if (/application\/x-www-form-urlencoded/.test(contentType)) {
+        // Otherwise, if mimeType’s essence is "application/x-www-form-urlencoded", then:
+
+        // 1. Let entries be the result of parsing bytes.
+        let entries
+        try {
+          entries = new URLSearchParams(await this.text())
+        } catch (err) {
+          // istanbul ignore next: Unclear when new URLSearchParams can fail on a string.
+          // 2. If entries is failure, then throw a TypeError.
+          throw Object.assign(new TypeError(), { cause: err })
+        }
+
+        // 3. Return a new FormData object whose entries are entries.
+        const formData = new FormData()
+        for (const [name, value] of entries) {
+          formData.append(name, value)
+        }
+        return formData
+      } else {
+        // Otherwise, throw a TypeError.
+        webidl.errors.exception({
+          header: `${instance.name}.formData`,
+          value: 'Could not parse content as FormData.'
+        })
       }
-      return formData
-    } else {
-      // Otherwise, throw a TypeError.
-      throw new TypeError()
     }
   }
+
+  return methods
 }
 
 const properties = {
   body: {
     enumerable: true,
     get () {
+      if (!this || !this[kState]) {
+        throw new TypeError('Illegal invocation')
+      }
+
       return this[kState].body ? this[kState].body.stream : null
     }
   },
   bodyUsed: {
     enumerable: true,
     get () {
+      if (!this || !this[kState]) {
+        throw new TypeError('Illegal invocation')
+      }
+
       return !!this[kState].body && util.isDisturbed(this[kState].body.stream)
     }
   }
 }
 
 function mixinBody (prototype) {
-  Object.assign(prototype, methods)
-  Object.defineProperties(prototype, properties)
+  Object.assign(prototype.prototype, bodyMixinMethods(prototype))
+  Object.defineProperties(prototype.prototype, properties)
 }
 
 module.exports = {

package/lib/fetch/constants.js

@@ -60,7 +60,19 @@ const subresource = [
   ''
 ]
 
+/** @type {globalThis['DOMException']} */
+const DOMException = globalThis.DOMException ?? (() => {
+  // DOMException was only made a global in Node v17.0.0,
+  // but fetch supports >= v16.8.
+  try {
+    atob('~')
+  } catch (err) {
+    return Object.getPrototypeOf(err).constructor
+  }
+})()
+
 module.exports = {
+  DOMException,
   subresource,
   forbiddenMethods,
   requestBodyHeader,