@yanglaofish/fishtools 0.5.2 → 0.5.3

package/node_modules/undici/lib/api/api-connect.js

@@ -32,48 +32,45 @@ class ConnectHandler extends AsyncResource {
     addSignal(this, signal)
   }
 
-  onRequestStart (controller, context) {
+  onConnect (abort, context) {
     if (this.reason) {
-      controller.abort(this.reason)
+      abort(this.reason)
       return
     }
 
     assert(this.callback)
 
-    this.abort = (reason) => controller.abort(reason)
+    this.abort = abort
     this.context = context
   }
 
-  onResponseStart () {
+  onHeaders () {
     throw new SocketError('bad connect', null)
   }
 
-  onRequestUpgrade (controller, statusCode, headers, socket) {
+  onUpgrade (statusCode, rawHeaders, socket) {
     const { callback, opaque, context } = this
 
     removeSignal(this)
 
     this.callback = null
 
-    let responseHeaders = headers
-    const rawHeaders = controller?.rawHeaders
+    let headers = rawHeaders
     // Indicates is an HTTP2Session
-    if (responseHeaders != null) {
-      responseHeaders = this.responseHeaders === 'raw'
-        ? util.parseRawHeaders(rawHeaders)
-        : headers
+    if (headers != null) {
+      headers = this.responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders)
     }
 
     this.runInAsyncScope(callback, null, null, {
       statusCode,
-      headers: responseHeaders,
+      headers,
       socket,
       opaque,
       context
     })
   }
 
-  onResponseError (_controller, err) {
+  onError (err) {
     const { callback, opaque } = this
 
     removeSignal(this)
@@ -98,8 +95,7 @@ function connect (opts, callback) {
 
   try {
     const connectHandler = new ConnectHandler(opts, callback)
-    const connectOptions = { ...opts, method: 'CONNECT' }
-    this.dispatch(connectOptions, connectHandler)
+    this.dispatch({ ...opts, method: 'CONNECT' }, connectHandler)
   } catch (err) {
     if (typeof callback !== 'function') {
       throw err

package/node_modules/undici/lib/api/api-pipeline.js

@@ -5,18 +5,15 @@ const {
   Duplex,
   PassThrough
 } = require('node:stream')
-const assert = require('node:assert')
-const { AsyncResource } = require('node:async_hooks')
 const {
   InvalidArgumentError,
   InvalidReturnValueError,
   RequestAbortedError
 } = require('../core/errors')
 const util = require('../core/util')
-const { kBodyUsed } = require('../core/symbols')
+const { AsyncResource } = require('node:async_hooks')
 const { addSignal, removeSignal } = require('./abort-signal')
-
-function noop () {}
+const assert = require('node:assert')
 
 const kResume = Symbol('resume')
 
@@ -25,9 +22,6 @@ class PipelineRequest extends Readable {
     super({ autoDestroy: true })
 
     this[kResume] = null
-    // Pipeline request bodies come from a live writable side and cannot be
-    // replayed across redirects or retries, even before any bytes are read.
-    this[kBodyUsed] = true
   }
 
   _read () {
@@ -98,7 +92,7 @@ class PipelineHandler extends AsyncResource {
     this.context = null
     this.onInfo = onInfo || null
 
-    this.req = new PipelineRequest().on('error', noop)
+    this.req = new PipelineRequest().on('error', util.nop)
 
     this.ret = new Duplex({
       readableObjectMode: opts.objectMode,
@@ -150,52 +144,47 @@ class PipelineHandler extends AsyncResource {
     addSignal(this, signal)
   }
 
-  onRequestStart (controller, context) {
-    const { res } = this
+  onConnect (abort, context) {
+    const { ret, res } = this
 
     if (this.reason) {
-      controller.abort(this.reason)
+      abort(this.reason)
       return
     }
 
     assert(!res, 'pipeline cannot be retried')
+    assert(!ret.destroyed)
 
-    this.abort = (reason) => controller.abort(reason)
+    this.abort = abort
     this.context = context
   }
 
-  onResponseStart (controller, statusCode, headers, _statusMessage) {
+  onHeaders (statusCode, rawHeaders, resume) {
     const { opaque, handler, context } = this
 
     if (statusCode < 200) {
       if (this.onInfo) {
-        const rawHeaders = controller?.rawHeaders
-        const responseHeaders = this.responseHeaders === 'raw'
-          ? util.parseRawHeaders(rawHeaders)
-          : headers
-        this.onInfo({ statusCode, headers: responseHeaders })
+        const headers = this.responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders)
+        this.onInfo({ statusCode, headers })
       }
       return
     }
 
-    this.res = new PipelineResponse(() => controller.resume())
+    this.res = new PipelineResponse(resume)
 
     let body
     try {
       this.handler = null
-      const rawHeaders = controller?.rawHeaders
-      const responseHeaders = this.responseHeaders === 'raw'
-        ? util.parseRawHeaders(rawHeaders)
-        : headers
+      const headers = this.responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders)
       body = this.runInAsyncScope(handler, null, {
         statusCode,
-        headers: responseHeaders,
+        headers,
         opaque,
         body: this.res,
         context
       })
     } catch (err) {
-      this.res.on('error', noop)
+      this.res.on('error', util.nop)
       throw err
     }
 
@@ -232,20 +221,17 @@ class PipelineHandler extends AsyncResource {
     this.body = body
   }
 
-  onResponseData (controller, chunk) {
+  onData (chunk) {
     const { res } = this
-
-    if (res.push(chunk) === false) {
-      controller.pause()
-    }
+    return res.push(chunk)
   }
 
-  onResponseEnd (_controller, _trailers) {
+  onComplete (trailers) {
     const { res } = this
     res.push(null)
   }
 
-  onResponseError (_controller, err) {
+  onError (err) {
     const { ret } = this
     this.handler = null
     util.destroy(ret, err)

package/node_modules/undici/lib/api/api-request.js

@@ -1,12 +1,11 @@
 'use strict'
 
 const assert = require('node:assert')
-const { AsyncResource } = require('node:async_hooks')
 const { Readable } = require('./readable')
 const { InvalidArgumentError, RequestAbortedError } = require('../core/errors')
 const util = require('../core/util')
-
-function noop () {}
+const { getResolveErrorBodyCallback } = require('./util')
+const { AsyncResource } = require('node:async_hooks')
 
 class RequestHandler extends AsyncResource {
   constructor (opts, callback) {
@@ -14,14 +13,14 @@ class RequestHandler extends AsyncResource {
       throw new InvalidArgumentError('invalid opts')
     }
 
-    const { signal, method, opaque, body, onInfo, responseHeaders, highWaterMark } = opts
+    const { signal, method, opaque, body, onInfo, responseHeaders, throwOnError, highWaterMark } = opts
 
     try {
       if (typeof callback !== 'function') {
         throw new InvalidArgumentError('invalid callback')
       }
 
-      if (highWaterMark != null && (!Number.isFinite(highWaterMark) || highWaterMark < 0)) {
+      if (highWaterMark && (typeof highWaterMark !== 'number' || highWaterMark < 0)) {
         throw new InvalidArgumentError('invalid highWaterMark')
       }
 
@@ -40,7 +39,7 @@ class RequestHandler extends AsyncResource {
       super('UNDICI_REQUEST')
     } catch (err) {
       if (util.isStream(body)) {
-        util.destroy(body.on('error', noop), err)
+        util.destroy(body.on('error', util.nop), err)
       }
       throw err
     }
@@ -54,66 +53,71 @@ class RequestHandler extends AsyncResource {
     this.body = body
     this.trailers = {}
     this.context = null
-    this.controller = null
     this.onInfo = onInfo || null
+    this.throwOnError = throwOnError
     this.highWaterMark = highWaterMark
+    this.signal = signal
     this.reason = null
     this.removeAbortListener = null
 
-    if (signal?.aborted) {
-      this.reason = signal.reason ?? new RequestAbortedError()
-    } else if (signal) {
-      this.removeAbortListener = util.addAbortListener(signal, () => {
-        this.reason = signal.reason ?? new RequestAbortedError()
-        if (this.res) {
-          // Null the reference before destroying, mirroring onResponseError, so
-          // that chunks flushed after the abort (e.g. an async decompressor
-          // flush) are dropped by the `!this.res` guard in onResponseData
-          // instead of being pushed into the torn-down stream.
-          const res = this.res
-          this.res = null
-          util.destroy(res.on('error', noop), this.reason)
-        } else if (this.abort) {
-          this.abort(this.reason)
-        }
+    if (util.isStream(body)) {
+      body.on('error', (err) => {
+        this.onError(err)
       })
     }
+
+    if (this.signal) {
+      if (this.signal.aborted) {
+        this.reason = this.signal.reason ?? new RequestAbortedError()
+      } else {
+        this.removeAbortListener = util.addAbortListener(this.signal, () => {
+          this.reason = this.signal.reason ?? new RequestAbortedError()
+          if (this.res) {
+            util.destroy(this.res.on('error', util.nop), this.reason)
+          } else if (this.abort) {
+            this.abort(this.reason)
+          }
+
+          if (this.removeAbortListener) {
+            this.res?.off('close', this.removeAbortListener)
+            this.removeAbortListener()
+            this.removeAbortListener = null
+          }
+        })
+      }
+    }
   }
 
-  onRequestStart (controller, context) {
+  onConnect (abort, context) {
     if (this.reason) {
-      controller.abort(this.reason)
+      abort(this.reason)
       return
     }
 
     assert(this.callback)
 
-    this.controller = controller
-    this.abort = (reason) => controller.abort(reason)
+    this.abort = abort
     this.context = context
   }
 
-  onResponseStart (controller, statusCode, headers, statusText) {
-    const { callback, opaque, context, responseHeaders, highWaterMark } = this
+  onHeaders (statusCode, rawHeaders, resume, statusMessage) {
+    const { callback, opaque, abort, context, responseHeaders, highWaterMark } = this
 
-    const rawHeaders = controller?.rawHeaders
-    const responseHeaderData = responseHeaders === 'raw'
-      ? util.parseRawHeaders(rawHeaders)
-      : headers
+    const headers = responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders)
 
     if (statusCode < 200) {
       if (this.onInfo) {
-        this.onInfo({ statusCode, headers: responseHeaderData })
+        this.onInfo({ statusCode, headers })
       }
       return
     }
 
-    const parsedHeaders = headers
-    const contentType = parsedHeaders?.['content-type']
-    const contentLength = parsedHeaders?.['content-length']
+    const parsedHeaders = responseHeaders === 'raw' ? util.parseHeaders(rawHeaders) : headers
+    const contentType = parsedHeaders['content-type']
+    const contentLength = parsedHeaders['content-length']
     const res = new Readable({
-      resume: () => controller.resume(),
-      abort: (reason) => controller.abort(reason),
+      resume,
+      abort,
       contentType,
       contentLength: this.method !== 'HEAD' && contentLength
         ? Number(contentLength)
@@ -123,67 +127,38 @@ class RequestHandler extends AsyncResource {
 
     if (this.removeAbortListener) {
       res.on('close', this.removeAbortListener)
-      this.removeAbortListener = null
     }
 
     this.callback = null
     this.res = res
     if (callback !== null) {
-      try {
+      if (this.throwOnError && statusCode >= 400) {
+        this.runInAsyncScope(getResolveErrorBodyCallback, null,
+          { callback, body: res, contentType, statusCode, statusMessage, headers }
+        )
+      } else {
         this.runInAsyncScope(callback, null, null, {
           statusCode,
-          statusText,
-          headers: responseHeaderData,
+          headers,
           trailers: this.trailers,
           opaque,
           body: res,
           context
         })
-      } catch (err) {
-        // If the callback throws synchronously, we need to handle it
-        // Remove reference to res to allow res being garbage collected
-        this.res = null
-
-        // Destroy the response stream
-        util.destroy(res.on('error', noop), err)
-
-        // Use queueMicrotask to re-throw the error so it reaches uncaughtException
-        queueMicrotask(() => {
-          throw err
-        })
       }
     }
   }
 
-  onResponseData (controller, chunk) {
-    if (!this.res) {
-      return
-    }
-
-    if (this.res.push(chunk) === false) {
-      controller.pause()
-    }
+  onData (chunk) {
+    return this.res.push(chunk)
   }
 
-  onResponseEnd (_controller, trailers) {
-    if (trailers && typeof trailers === 'object') {
-      for (const key of Object.keys(trailers)) {
-        if (key === '__proto__') {
-          Object.defineProperty(this.trailers, key, {
-            value: trailers[key],
-            enumerable: true,
-            configurable: true,
-            writable: true
-          })
-        } else {
-          this.trailers[key] = trailers[key]
-        }
-      }
-    }
-    this.res?.push(null)
+  onComplete (trailers) {
+    util.parseHeaders(trailers, this.trailers)
+    this.res.push(null)
   }
 
-  onResponseError (_controller, err) {
+  onError (err) {
     const { res, callback, body, opaque } = this
 
     if (callback) {
@@ -198,20 +173,17 @@ class RequestHandler extends AsyncResource {
       this.res = null
       // Ensure all queued handlers are invoked before destroying res.
       queueMicrotask(() => {
-        util.destroy(res.on('error', noop), err)
+        util.destroy(res, err)
       })
     }
 
     if (body) {
       this.body = null
-
-      if (util.isStream(body)) {
-        body.on('error', noop)
-        util.destroy(body, err)
-      }
+      util.destroy(body, err)
     }
 
     if (this.removeAbortListener) {
+      res?.off('close', this.removeAbortListener)
       this.removeAbortListener()
       this.removeAbortListener = null
     }
@@ -228,9 +200,7 @@ function request (opts, callback) {
   }
 
   try {
-    const handler = new RequestHandler(opts, callback)
-
-    this.dispatch(opts, handler)
+    this.dispatch(opts, new RequestHandler(opts, callback))
   } catch (err) {
     if (typeof callback !== 'function') {
       throw err