undici 4.11.1 → 4.11.2

package/lib/fetch/body.js

@@ -3,7 +3,7 @@
 const util = require('../core/util')
 const { ReadableStreamFrom, toUSVString, isBlobLike } = require('./util')
 const { FormData } = require('./formdata')
-const { kState } = require('./symbols')
+const { kState, kError } = require('./symbols')
 const { Blob } = require('buffer')
 const { kBodyUsed } = require('../core/symbols')
 const assert = require('assert')
@@ -268,6 +268,10 @@ const methods = {
     if (this[kState].body) {
       const stream = this[kState].body.stream
 
+      if (stream[kError]) {
+        throw stream[kError]
+      }
+
       if (util.isDisturbed(stream)) {
         throw new TypeError('disturbed')
       }

package/lib/fetch/index.js

@@ -31,7 +31,7 @@ const {
   determineRequestsReferrer,
   coarsenedSharedCurrentTime
 } = require('./util')
-const { kState, kHeaders, kGuard, kRealm } = require('./symbols')
+const { kState, kHeaders, kGuard, kRealm, kError } = require('./symbols')
 const { AbortError } = require('../core/errors')
 const assert = require('assert')
 const { safelyExtractBody, cancelBody } = require('./body')
@@ -82,14 +82,13 @@ async function fetch (...args) {
       if (this.terminated) {
         return
       }
+      this.terminated = { aborted }
 
       if (this.connection) {
-        this.connection.destroy()
+        this.connection.destroy(reason)
         this.connection = null
       }
 
-      this.terminated = { aborted }
-
       this.emit('terminated', reason)
     }
   })
@@ -266,8 +265,6 @@ function markResourceTiming () {
 
 // https://fetch.spec.whatwg.org/#abort-fetch
 function abortFetch (p, request, responseObject) {
-  const context = this
-
   // 1. Let error be an "AbortError" DOMException.
   const error = new AbortError()
 
@@ -291,7 +288,7 @@ function abortFetch (p, request, responseObject) {
   // 6. If response’s body is not null and is readable, then error response’s
   // body with error.
   if (response.body != null) {
-    context.connection.destroy(error)
+    cancelBody(response.body, error)
   }
 }
 
@@ -649,7 +646,7 @@ async function mainFetch (fetchParams, recursive = false) {
       nullBodyStatus.includes(internalResponse.status))
   ) {
     internalResponse.body = null
-    context.connection.dump = true
+    context.dump = true
   }
 
   // 20. If request’s integrity metadata is not the empty string, then:
@@ -1335,32 +1332,28 @@ function httpNetworkFetch (
   return new Promise((resolve) => {
     assert(!context.connection || context.connection.destroyed)
 
-    const connection = (context.connection = {
+    context.connection = {
       abort: null,
       controller: null,
       destroyed: false,
-      errored: false,
-      dump: false,
       destroy (err) {
         if (this.destroyed) {
           return
         }
-
         this.destroyed = true
 
+        err = err ?? new AbortError()
+
         if (this.abort) {
-          this.abort()
+          this.abort(err)
           this.abort = null
         }
 
-        if (err) {
-          this.errored = err
-        }
-
-        if (this.controller) {
+        // TODO (fix): Do we need controller here?
+        if (context.controller) {
           try {
-            this.controller.error(err ?? new AbortError())
-            this.controller = null
+            context.controller.error(err)
+            context.controller = null
           } catch (err) {
             // Will throw TypeError if body is not readable.
             if (err.name !== 'TypeError') {
@@ -1369,7 +1362,7 @@ function httpNetworkFetch (
           }
         }
       }
-    })
+    }
 
     // 1. Let request be fetchParams’s request.
     const request = fetchParams.request
@@ -1505,10 +1498,10 @@ function httpNetworkFetch (
     // 9. If aborted, then:
     function onRequestAborted () {
       // 1. Let aborted be the termination’s aborted flag.
-      const aborted = context.terminated.aborted
+      const aborted = this.terminated.aborted
 
       // 2. If connection uses HTTP/2, then transmit an RST_STREAM frame.
-      connection.destroy()
+      this.connection?.destroy()
 
       // 3. If aborted is set, then return an aborted network error.
       const reason = aborted ? new AbortError() : new Error('terminated')
@@ -1529,7 +1522,7 @@ function httpNetworkFetch (
 
     // 12. Let highWaterMark be a non-negative, non-NaN number, chosen by
     // the user agent.
-    const highWaterMark = 65536
+    const highWaterMark = 64 * 1024 // Same as nodejs fs streams.
 
     // 13. Let sizeAlgorithm be an algorithm that accepts a chunk object
     // and returns a non-negative, non-NaN, non-infinite number, chosen by the user agent.
@@ -1543,20 +1536,24 @@ function httpNetworkFetch (
       ReadableStream = require('stream/web').ReadableStream
     }
 
+    let pullResolve
+
     const stream = new ReadableStream(
       {
         async start (controller) {
-          connection.controller = controller
+          context.controller = controller
         },
-        async pull () {
-          if (pullAlgorithm) {
-            pullAlgorithm()
-          } else {
-            pullAlgorithm = null
+        async pull (controller) {
+          if (!pullAlgorithm) {
+            await new Promise((resolve) => {
+              pullResolve = resolve
+            })
           }
+          await pullAlgorithm(controller)
         },
         async cancel (reason) {
-          cancelAlgorithm()
+          stream[kError] = reason
+          await cancelAlgorithm(reason)
         }
       },
       { highWaterMark }
@@ -1586,7 +1583,7 @@ function httpNetworkFetch (
       finalizeResponse(fetchParams, response)
 
       // 2. Let aborted be the termination’s aborted flag.
-      const aborted = context.terminated.aborted
+      const aborted = this.terminated.aborted
 
       // 3. If aborted is set, then:
       if (aborted) {
@@ -1594,15 +1591,29 @@ function httpNetworkFetch (
         response.aborted = true
 
         // 2. If stream is readable, error stream with an "AbortError" DOMException.
-        connection.destroy(new AbortError())
+        try {
+          this.controller.error(new AbortError())
+        } catch (err) {
+          // Will throw TypeError if body is not readable.
+          if (err.name !== 'TypeError') {
+            throw err
+          }
+        }
       } else {
         // 4. Otherwise, if stream is readable, error stream with a TypeError.
-        connection.destroy(new TypeError('terminated'))
+        try {
+          this.controller.error(new TypeError('terminated'))
+        } catch (err) {
+          // Will throw TypeError if body is not readable.
+          if (err.name !== 'TypeError') {
+            throw err
+          }
+        }
       }
 
       // 5. If connection uses HTTP/2, then transmit an RST_STREAM frame.
       // 6. Otherwise, the user agent should close connection unless it would be bad for performance to do so.
-      connection.destroy()
+      this.connection?.destroy()
     }
 
     // 19. Return response.
@@ -1621,8 +1632,12 @@ function httpNetworkFetch (
       },
       {
         decoder: null,
+        context,
 
         onConnect (abort) {
+          // TODO (fix): Do we need connection here?
+          const { connection } = this.context
+
           if (connection.destroyed) {
             abort(new AbortError())
           } else {
@@ -1643,19 +1658,16 @@ function httpNetworkFetch (
             )
           }
 
-          const hasPulled = pullAlgorithm !== undefined
-
-          const body = { stream }
-          registry.register(body, connection.abort)
+          registry.register(stream, this.abort, this)
 
           response = makeResponse({
             status,
             statusText,
             headersList: headers[kHeadersList],
-            body
+            body: { stream }
           })
 
-          context.on('terminated', onResponseAborted)
+          this.context.on('terminated', onResponseAborted)
 
           const codings =
             headers
@@ -1704,7 +1716,7 @@ function httpNetworkFetch (
             this.decoder.on('drain', resume)
           }
 
-          pullAlgorithm = async () => {
+          pullAlgorithm = async (controller) => {
             // 4. Set bytes to the result of handling content codings given
             // codings and bytes.
             let bytes
@@ -1720,10 +1732,6 @@ function httpNetworkFetch (
               }
             }
 
-            if (!connection.controller) {
-              return
-            }
-
             if (bytes === undefined) {
               // 2. Otherwise, if the bytes transmission for response’s message
               // body is done normally and stream is readable, then close
@@ -1731,13 +1739,7 @@ function httpNetworkFetch (
               // abort these in-parallel steps.
               finalizeResponse(fetchParams, response)
 
-              context.off('terminated', onResponseAborted)
-              context.off('terminated', onRequestAborted)
-
-              connection.controller.close()
-              connection.controller = null
-
-              connection.destroy()
+              controller.close()
 
               return
             }
@@ -1747,27 +1749,28 @@ function httpNetworkFetch (
 
             // 6. If bytes is failure, then terminate the ongoing fetch.
             if (bytes instanceof Error) {
-              context.terminate({ reason: bytes })
+              this.context.terminate({ reason: bytes })
               return
             }
 
             // 7. Enqueue a Uint8Array wrapping an ArrayBuffer containing bytes
-            //  into stream.
-            connection.controller.enqueue(new Uint8Array(bytes))
+            // into stream.
+            controller.enqueue(new Uint8Array(bytes))
 
             // 8. If stream is errored, then terminate the ongoing fetch.
-            if (connection.errored) {
-              context.terminate({ reason: connection.errored })
+            if (stream[kError]) {
+              this.context.terminate({ reason: stream[kError] })
               return
             }
 
             // 9. If stream doesn’t need more data ask the user agent to suspend
-            //  the ongoing fetch.
-            return connection.controller.desiredSize > 0
+            // the ongoing fetch.
+            return controller.desiredSize > 0
           }
 
-          if (hasPulled) {
-            pullAlgorithm()
+          if (pullResolve) {
+            pullResolve()
+            pullResolve = null
           }
 
           resolve(response)
@@ -1776,7 +1779,7 @@ function httpNetworkFetch (
         },
 
         onData (chunk) {
-          if (connection.dump) {
+          if (this.context.dump) {
             return
           }
 
@@ -1798,17 +1801,18 @@ function httpNetworkFetch (
           return this.decoder.write(bytes)
         },
 
-        async onComplete () {
+        onComplete () {
+          registry.unregister(this)
+
           this.decoder.end()
         },
 
         onError (error) {
-          context.off('terminated', onResponseAborted)
-          context.off('terminated', onRequestAborted)
+          registry.unregister(this)
 
-          connection.destroy(error)
+          this.decoder?.destroy(error)
 
-          context.terminate({ reason: error })
+          this.context.terminate({ reason: error })
 
           if (!response) {
             resolve(makeNetworkError(error))

package/lib/fetch/symbols.js

@@ -6,5 +6,6 @@ module.exports = {
   kSignal: Symbol('signal'),
   kState: Symbol('state'),
   kGuard: Symbol('guard'),
-  kRealm: Symbol('realm')
+  kRealm: Symbol('realm'),
+  kError: Symbol('error')
 }

package/package.json

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