undici 6.12.0 → 6.13.0

package/README.md

@@ -248,6 +248,18 @@ const data = {
 await fetch('https://example.com', { body: data, method: 'POST', duplex: 'half' })
 ```
 
+[FormData](https://developer.mozilla.org/en-US/docs/Web/API/FormData) besides text data and buffers can also utilize streams via [Blob](https://developer.mozilla.org/en-US/docs/Web/API/Blob) objects:
+
+```js
+import { openAsBlob } from 'node:fs'
+
+const file = await openAsBlob('./big.csv')
+const body = new FormData()
+body.set('file', file, 'big.csv')
+
+await fetch('http://example.com', { method: 'POST', body })
+```
+
 #### `request.duplex`
 
 - half

package/lib/api/readable.js

@@ -63,9 +63,7 @@ class BodyReadable extends Readable {
     // tick as it is created, then a user who is waiting for a
     // promise (i.e micro tick) for installing a 'error' listener will
     // never get a chance and will always encounter an unhandled exception.
-    // - tick => process.nextTick(fn)
-    // - micro tick => queueMicrotask(fn)
-    queueMicrotask(() => {
+    setImmediate(() => {
       callback(err)
     })
   }

package/lib/dispatcher/client-h2.js

@@ -98,28 +98,22 @@ async function connectH2 (client, socket) {
   util.addListener(session, 'goaway', onHTTP2GoAway)
   util.addListener(session, 'close', function () {
     const { [kClient]: client } = this
+    const { [kSocket]: socket } = client
 
-    const err = this[kSocket][kError] || new SocketError('closed', util.getSocketInfo(this))
+    const err = this[kSocket][kError] || this[kError] || new SocketError('closed', util.getSocketInfo(socket))
 
-    client[kSocket] = null
     client[kHTTP2Session] = null
 
-    assert(client[kPending] === 0)
+    if (client.destroyed) {
+      assert(client[kPending] === 0)
 
-    // Fail entire queue.
-    const requests = client[kQueue].splice(client[kRunningIdx])
-    for (let i = 0; i < requests.length; i++) {
-      const request = requests[i]
-      util.errorRequest(client, request, err)
+      // Fail entire queue.
+      const requests = client[kQueue].splice(client[kRunningIdx])
+      for (let i = 0; i < requests.length; i++) {
+        const request = requests[i]
+        util.errorRequest(client, request, err)
+      }
     }
-
-    client[kPendingIdx] = client[kRunningIdx]
-
-    assert(client[kRunning] === 0)
-
-    client.emit('disconnect', client[kUrl], [client], err)
-
-    client[kResume]()
   })
 
   session.unref()
@@ -139,6 +133,24 @@ async function connectH2 (client, socket) {
     util.destroy(this, new SocketError('other side closed', util.getSocketInfo(this)))
   })
 
+  util.addListener(socket, 'close', function () {
+    const err = this[kError] || new SocketError('closed', util.getSocketInfo(this))
+
+    client[kSocket] = null
+
+    if (this[kHTTP2Session] != null) {
+      this[kHTTP2Session].destroy(err)
+    }
+
+    client[kPendingIdx] = client[kRunningIdx]
+
+    assert(client[kRunning] === 0)
+
+    client.emit('disconnect', client[kUrl], [client], err)
+
+    client[kResume]()
+  })
+
   let closed = false
   socket.on('close', () => {
     closed = true
@@ -155,10 +167,10 @@ async function connectH2 (client, socket) {
 
     },
     destroy (err, callback) {
-      session.destroy(err)
       if (closed) {
         queueMicrotask(callback)
       } else {
+        // Destroying the socket will trigger the session close
         socket.destroy(err).on('close', callback)
       }
     },
@@ -257,27 +269,28 @@ function writeH2 (client, request) {
   headers[HTTP2_HEADER_AUTHORITY] = host || `${hostname}${port ? `:${port}` : ''}`
   headers[HTTP2_HEADER_METHOD] = method
 
-  try {
-    // We are already connected, streams are pending.
-    // We can call on connect, and wait for abort
-    request.onConnect((err) => {
-      if (request.aborted || request.completed) {
-        return
-      }
+  const abort = (err) => {
+    if (request.aborted || request.completed) {
+      return
+    }
 
-      err = err || new RequestAbortedError()
+    err = err || new RequestAbortedError()
 
-      if (stream != null) {
-        util.destroy(stream, err)
+    util.errorRequest(client, request, err)
 
-        session[kOpenStreams] -= 1
-        if (session[kOpenStreams] === 0) {
-          session.unref()
-        }
-      }
+    if (stream != null) {
+      util.destroy(stream, err)
+    }
 
-      util.errorRequest(client, request, err)
-    })
+    // We do not destroy the socket as we can continue using the session
+    // the stream get's destroyed and the session remains to create new streams
+    util.destroy(body, err)
+  }
+
+  try {
+    // We are already connected, streams are pending.
+    // We can call on connect, and wait for abort
+    request.onConnect(abort)
   } catch (err) {
     util.errorRequest(client, request, err)
   }
@@ -302,7 +315,6 @@ function writeH2 (client, request) {
 
     stream.once('close', () => {
       session[kOpenStreams] -= 1
-      // TODO(HTTP/2): unref only if current streams count is 0
       if (session[kOpenStreams] === 0) session.unref()
     })
 
@@ -382,7 +394,7 @@ function writeH2 (client, request) {
     writeBodyH2()
   }
 
-  // Increment counter as we have new several streams open
+  // Increment counter as we have new streams open
   ++session[kOpenStreams]
 
   stream.once('response', headers => {
@@ -394,7 +406,7 @@ function writeH2 (client, request) {
     // the request remains in-flight and headers hasn't been received yet
     // for those scenarios, best effort is to destroy the stream immediately
     // as there's no value to keep it open.
-    if (request.aborted || request.completed) {
+    if (request.aborted) {
       const err = new RequestAbortedError()
       util.errorRequest(client, request, err)
       util.destroy(stream, err)
@@ -424,14 +436,11 @@ function writeH2 (client, request) {
     // Stream is closed or half-closed-remote (6), decrement counter and cleanup
     // It does not have sense to continue working with the stream as we do not
     // have yet RST_STREAM support on client-side
-    session[kOpenStreams] -= 1
     if (session[kOpenStreams] === 0) {
       session.unref()
     }
 
-    const err = new InformationalError('HTTP/2: stream half-closed (remote)')
-    util.errorRequest(client, request, err)
-    util.destroy(stream, err)
+    abort(new InformationalError('HTTP/2: stream half-closed (remote)'))
   })
 
   stream.once('close', () => {
@@ -442,21 +451,11 @@ function writeH2 (client, request) {
   })
 
   stream.once('error', function (err) {
-    if (client[kHTTP2Session] && !client[kHTTP2Session].destroyed && !this.closed && !this.destroyed) {
-      session[kOpenStreams] -= 1
-      util.errorRequest(client, request, err)
-      util.destroy(stream, err)
-    }
+    abort(err)
   })
 
   stream.once('frameError', (type, code) => {
-    const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`)
-    util.errorRequest(client, request, err)
-
-    if (client[kHTTP2Session] && !client[kHTTP2Session].destroyed && !this.closed && !this.destroyed) {
-      session[kOpenStreams] -= 1
-      util.destroy(stream, err)
-    }
+    abort(new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`))
   })
 
   // stream.on('aborted', () => {
@@ -479,37 +478,49 @@ function writeH2 (client, request) {
 
   function writeBodyH2 () {
     /* istanbul ignore else: assertion */
-    if (!body) {
-      request.onRequestSent()
+    if (!body || contentLength === 0) {
+      writeBuffer({
+        abort,
+        client,
+        request,
+        contentLength,
+        expectsPayload,
+        h2stream: stream,
+        body: null,
+        socket: client[kSocket]
+      })
     } else if (util.isBuffer(body)) {
-      assert(contentLength === body.byteLength, 'buffer body must have content length')
-      stream.cork()
-      stream.write(body)
-      stream.uncork()
-      stream.end()
-      request.onBodySent(body)
-      request.onRequestSent()
+      writeBuffer({
+        abort,
+        client,
+        request,
+        contentLength,
+        body,
+        expectsPayload,
+        h2stream: stream,
+        socket: client[kSocket]
+      })
     } else if (util.isBlobLike(body)) {
       if (typeof body.stream === 'function') {
         writeIterable({
+          abort,
           client,
           request,
           contentLength,
-          h2stream: stream,
           expectsPayload,
+          h2stream: stream,
           body: body.stream(),
-          socket: client[kSocket],
-          header: ''
+          socket: client[kSocket]
         })
       } else {
         writeBlob({
+          abort,
           body,
           client,
           request,
           contentLength,
           expectsPayload,
           h2stream: stream,
-          header: '',
           socket: client[kSocket]
         })
       }
@@ -541,7 +552,30 @@ function writeH2 (client, request) {
   }
 }
 
-function writeStream ({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) {
+function writeBuffer ({ abort, h2stream, body, client, request, socket, contentLength, expectsPayload }) {
+  try {
+    if (body != null && util.isBuffer(body)) {
+      assert(contentLength === body.byteLength, 'buffer body must have content length')
+      h2stream.cork()
+      h2stream.write(body)
+      h2stream.uncork()
+      h2stream.end()
+
+      request.onBodySent(body)
+    }
+
+    if (!expectsPayload) {
+      socket[kReset] = true
+    }
+
+    request.onRequestSent()
+    client[kResume]()
+  } catch (error) {
+    abort(error)
+  }
+}
+
+function writeStream ({ abort, socket, expectsPayload, h2stream, body, client, request, contentLength }) {
   assert(contentLength !== 0 || client[kRunning] === 0, 'stream body cannot be pipelined')
 
   // For HTTP/2, is enough to pipe the stream
@@ -550,26 +584,29 @@ function writeStream ({ h2stream, body, client, request, socket, contentLength,
     h2stream,
     (err) => {
       if (err) {
-        util.destroy(body, err)
-        util.destroy(h2stream, err)
+        util.destroy(pipe, err)
+        abort(err)
       } else {
+        util.removeAllListeners(pipe)
         request.onRequestSent()
+
+        if (!expectsPayload) {
+          socket[kReset] = true
+        }
+
+        client[kResume]()
       }
     }
   )
 
-  pipe.on('data', onPipeData)
-  pipe.once('end', () => {
-    pipe.removeListener('data', onPipeData)
-    util.destroy(pipe)
-  })
+  util.addListener(pipe, 'data', onPipeData)
 
   function onPipeData (chunk) {
     request.onBodySent(chunk)
   }
 }
 
-async function writeBlob ({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) {
+async function writeBlob ({ abort, h2stream, body, client, request, socket, contentLength, expectsPayload }) {
   assert(contentLength === body.size, 'blob body must have content length')
 
   try {
@@ -582,6 +619,7 @@ async function writeBlob ({ h2stream, body, client, request, socket, contentLeng
     h2stream.cork()
     h2stream.write(buffer)
     h2stream.uncork()
+    h2stream.end()
 
     request.onBodySent(buffer)
     request.onRequestSent()
@@ -592,11 +630,11 @@ async function writeBlob ({ h2stream, body, client, request, socket, contentLeng
 
     client[kResume]()
   } catch (err) {
-    util.destroy(h2stream)
+    abort(err)
   }
 }
 
-async function writeIterable ({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) {
+async function writeIterable ({ abort, h2stream, body, client, request, socket, contentLength, expectsPayload }) {
   assert(contentLength !== 0 || client[kRunning] === 0, 'iterator body cannot be pipelined')
 
   let callback = null
@@ -635,11 +673,19 @@ async function writeIterable ({ h2stream, body, client, request, socket, content
         await waitForDrain()
       }
     }
+
+    h2stream.end()
+
+    request.onRequestSent()
+
+    if (!expectsPayload) {
+      socket[kReset] = true
+    }
+
+    client[kResume]()
   } catch (err) {
-    h2stream.destroy(err)
+    abort(err)
   } finally {
-    request.onRequestSent()
-    h2stream.end()
     h2stream
       .off('close', onDrain)
       .off('drain', onDrain)

package/lib/handler/decorator-handler.js

@@ -1,35 +1,44 @@
 'use strict'
 
 module.exports = class DecoratorHandler {
+  #handler
+
   constructor (handler) {
-    this.handler = handler
+    if (typeof handler !== 'object' || handler === null) {
+      throw new TypeError('handler must be an object')
+    }
+    this.#handler = handler
   }
 
   onConnect (...args) {
-    return this.handler.onConnect(...args)
+    return this.#handler.onConnect?.(...args)
   }
 
   onError (...args) {
-    return this.handler.onError(...args)
+    return this.#handler.onError?.(...args)
   }
 
   onUpgrade (...args) {
-    return this.handler.onUpgrade(...args)
+    return this.#handler.onUpgrade?.(...args)
+  }
+
+  onResponseStarted (...args) {
+    return this.#handler.onResponseStarted?.(...args)
   }
 
   onHeaders (...args) {
-    return this.handler.onHeaders(...args)
+    return this.#handler.onHeaders?.(...args)
   }
 
   onData (...args) {
-    return this.handler.onData(...args)
+    return this.#handler.onData?.(...args)
   }
 
   onComplete (...args) {
-    return this.handler.onComplete(...args)
+    return this.#handler.onComplete?.(...args)
   }
 
   onBodySent (...args) {
-    return this.handler.onBodySent(...args)
+    return this.#handler.onBodySent?.(...args)
   }
 }

package/lib/web/fetch/body.js

@@ -403,14 +403,14 @@ function mixinBody (prototype) {
 async function consumeBody (object, convertBytesToJSValue, instance) {
   webidl.brandCheck(object, instance)
 
-  throwIfAborted(object[kState])
-
   // 1. If object is unusable, then return a promise rejected
   //    with a TypeError.
   if (bodyUnusable(object[kState].body)) {
     throw new TypeError('Body is unusable')
   }
 
+  throwIfAborted(object[kState])
+
   // 2. Let promise be a new promise.
   const promise = createDeferredPromise()
 

package/lib/web/fetch/formdata-parser.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { toUSVString, isUSVString, bufferToLowerCasedHeaderName } = require('../../core/util')
+const { isUSVString, bufferToLowerCasedHeaderName } = require('../../core/util')
 const { utf8DecodeBytes } = require('./util')
 const { HTTP_TOKEN_CODEPOINTS, isomorphicDecode } = require('./data-url')
 const { isFileLike, File: UndiciFile } = require('./file')
@@ -60,43 +60,6 @@ function validateBoundary (boundary) {
   return true
 }
 
-/**
- * @see https://andreubotella.github.io/multipart-form-data/#escape-a-multipart-form-data-name
- * @param {string} name
- * @param {string} [encoding='utf-8']
- * @param {boolean} [isFilename=false]
- */
-function escapeFormDataName (name, encoding = 'utf-8', isFilename = false) {
-  // 1. If isFilename is true:
-  if (isFilename) {
-    // 1.1. Set name to the result of converting name into a scalar value string.
-    name = toUSVString(name)
-  } else {
-    // 2. Otherwise:
-
-    // 2.1. Assert: name is a scalar value string.
-    assert(isUSVString(name))
-
-    // 2.2. Replace every occurrence of U+000D (CR) not followed by U+000A (LF),
-    //      and every occurrence of U+000A (LF) not preceded by U+000D (CR), in
-    //      name, by a string consisting of U+000D (CR) and U+000A (LF).
-    name = name.replace(/\r\n?|\r?\n/g, '\r\n')
-  }
-
-  // 3. Let encoded be the result of encoding name with encoding.
-  assert(Buffer.isEncoding(encoding))
-
-  // 4. Replace every 0x0A (LF) bytes in encoded with the byte sequence `%0A`,
-  //    0x0D (CR) with `%0D` and 0x22 (") with `%22`.
-  name = name
-    .replace(/\n/g, '%0A')
-    .replace(/\r/g, '%0D')
-    .replace(/"/g, '%22')
-
-  // 5. Return encoded.
-  return Buffer.from(name, encoding) // encoded
-}
-
 /**
  * @see https://andreubotella.github.io/multipart-form-data/#multipart-form-data-parser
  * @param {Buffer} input
@@ -497,6 +460,5 @@ function bufferStartsWith (buffer, start, position) {
 
 module.exports = {
   multipartFormDataParser,
-  validateBoundary,
-  escapeFormDataName
+  validateBoundary
 }

package/lib/web/fetch/index.js

@@ -58,7 +58,7 @@ const {
   subresourceSet
 } = require('./constants')
 const EE = require('node:events')
-const { Readable, pipeline } = require('node:stream')
+const { Readable, pipeline, finished } = require('node:stream')
 const { addAbortListener, isErrored, isReadable, nodeMajor, nodeMinor, bufferToLowerCasedHeaderName } = require('../../core/util')
 const { dataURLProcessor, serializeAMimeType, minimizeSupportedMimeType } = require('./data-url')
 const { getGlobalDispatcher } = require('../../global')
@@ -1080,42 +1080,19 @@ function fetchFinale (fetchParams, response) {
   if (internalResponse.body == null) {
     processResponseEndOfBody()
   } else {
+    // mcollina: all the following steps of the specs are skipped.
+    // The internal transform stream is not needed.
+    // See https://github.com/nodejs/undici/pull/3093#issuecomment-2050198541
+
     // 1. Let transformStream be a new TransformStream.
     // 2. Let identityTransformAlgorithm be an algorithm which, given chunk, enqueues chunk in transformStream.
     // 3. Set up transformStream with transformAlgorithm set to identityTransformAlgorithm and flushAlgorithm
     //    set to processResponseEndOfBody.
-    const transformStream = new TransformStream({
-      start () { },
-      transform (chunk, controller) {
-        controller.enqueue(chunk)
-      },
-      flush: processResponseEndOfBody
-    })
-
     // 4. Set internalResponse’s body’s stream to the result of internalResponse’s body’s stream piped through transformStream.
-    internalResponse.body.stream.pipeThrough(transformStream)
-
-    const byteStream = new ReadableStream({
-      readableStream: transformStream.readable,
-      async start () {
-        this._bodyReader = this.readableStream.getReader()
-      },
-      async pull (controller) {
-        while (controller.desiredSize >= 0) {
-          const { done, value } = await this._bodyReader.read()
 
-          if (done) {
-            queueMicrotask(() => readableStreamClose(controller))
-            break
-          }
-
-          controller.enqueue(value)
-        }
-      },
-      type: 'bytes'
+    finished(internalResponse.body.stream, () => {
+      processResponseEndOfBody()
     })
-
-    internalResponse.body.stream = byteStream
   }
 }
 

package/lib/web/fetch/util.js

@@ -73,14 +73,13 @@ function responseLocationURL (response, requestFragment) {
  * @returns {boolean}
  */
 function isValidEncodedURL (url) {
-  for (const c of url) {
-    const code = c.charCodeAt(0)
-    // Not used in US-ASCII
-    if (code >= 0x80) {
-      return false
-    }
-    // Control characters
-    if ((code >= 0x00 && code <= 0x1F) || code === 0x7F) {
+  for (let i = 0; i < url.length; ++i) {
+    const code = url.charCodeAt(i)
+
+    if (
+      code > 0x7E || // Non-US-ASCII + DEL
+      code < 0x20 // Control characters NUL - US
+    ) {
       return false
     }
   }
@@ -160,24 +159,15 @@ const isValidHeaderName = isValidHTTPToken
 function isValidHeaderValue (potentialValue) {
   // - Has no leading or trailing HTTP tab or space bytes.
   // - Contains no 0x00 (NUL) or HTTP newline bytes.
-  if (
-    potentialValue.startsWith('\t') ||
-    potentialValue.startsWith(' ') ||
-    potentialValue.endsWith('\t') ||
-    potentialValue.endsWith(' ')
-  ) {
-    return false
-  }
-
-  if (
-    potentialValue.includes('\0') ||
+  return (
+    potentialValue[0] === '\t' ||
+    potentialValue[0] === ' ' ||
+    potentialValue[potentialValue.length - 1] === '\t' ||
+    potentialValue[potentialValue.length - 1] === ' ' ||
+    potentialValue.includes('\n') ||
     potentialValue.includes('\r') ||
-    potentialValue.includes('\n')
-  ) {
-    return false
-  }
-
-  return true
+    potentialValue.includes('\0')
+  ) === false
 }
 
 // https://w3c.github.io/webappsec-referrer-policy/#set-requests-referrer-policy-on-redirect
@@ -1169,13 +1159,21 @@ function urlIsLocal (url) {
 
 /**
  * @param {string|URL} url
+ * @returns {boolean}
  */
 function urlHasHttpsScheme (url) {
-  if (typeof url === 'string') {
-    return url.startsWith('https:')
-  }
-
-  return url.protocol === 'https:'
+  return (
+    (
+      typeof url === 'string' &&
+      url[5] === ':' &&
+      url[0] === 'h' &&
+      url[1] === 't' &&
+      url[2] === 't' &&
+      url[3] === 'p' &&
+      url[4] === 's'
+    ) ||
+    url.protocol === 'https:'
+  )
 }
 
 /**
@@ -1567,6 +1565,7 @@ function utf8DecodeBytes (buffer) {
 module.exports = {
   isAborted,
   isCancelled,
+  isValidEncodedURL,
   createDeferredPromise,
   ReadableStreamFrom,
   tryUpgradeRequestToAPotentiallyTrustworthyURL,

package/lib/web/websocket/util.js

@@ -209,24 +209,21 @@ const fatalDecoder = hasIntl ? new TextDecoder('utf-8', { fatal: true }) : undef
  * Converts a Buffer to utf-8, even on platforms without icu.
  * @param {Buffer} buffer
  */
-function utf8Decode (buffer) {
-  if (hasIntl) {
-    return fatalDecoder.decode(buffer)
-  } else {
-    if (!isUtf8?.(buffer)) {
-      // TODO: remove once node 18 or < node v18.14.0 is dropped
-      if (!isUtf8) {
+const utf8Decode = hasIntl
+  ? fatalDecoder.decode.bind(fatalDecoder)
+  : !isUtf8
+      ? function () { // TODO: remove once node 18 or < node v18.14.0 is dropped
         process.emitWarning('ICU is not supported and no fallback exists. Please upgrade to at least Node v18.14.0.', {
           code: 'UNDICI-WS-NO-ICU'
         })
+        throw new TypeError('Invalid utf-8 received.')
+      }
+      : function (buffer) {
+        if (isUtf8(buffer)) {
+          return buffer.toString('utf-8')
+        }
+        throw new TypeError('Invalid utf-8 received.')
       }
-
-      throw new TypeError('Invalid utf-8 received.')
-    }
-
-    return buffer.toString('utf-8')
-  }
-}
 
 module.exports = {
   isConnecting,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "undici",
-  "version": "6.12.0",
+  "version": "6.13.0",
   "description": "An HTTP/1.1 client, written from scratch for Node.js",
   "homepage": "https://undici.nodejs.org",
   "bugs": {