@nxtedition/nxt-undici 6.2.13 → 6.2.14

package/lib/interceptor/response-retry.js

@@ -10,14 +10,14 @@ class Handler extends DecoratorHandler {
   #opts
 
   #retryCount = 0
+  #retryError = null
   #headersSent = false
   #errorSent = false
 
   #statusCode = 0
   #headers
   #trailers
-  #body = ''
-  #decoder
+  #body
 
   #abort
   #aborted = false
@@ -27,7 +27,6 @@ class Handler extends DecoratorHandler {
   #pos
   #end
   #etag
-  #error
 
   constructor(opts, { handler, dispatch }) {
     super(handler)
@@ -48,15 +47,13 @@ class Handler extends DecoratorHandler {
   onConnect(abort) {
     this.#statusCode = 0
     this.#headers = null
+    this.#body = null
     this.#trailers = null
-    this.#body = ''
-    this.#decoder = null
 
     if (!this.#headersSent) {
       this.#pos = null
       this.#end = null
       this.#etag = null
-      this.#error = null
       this.#resume = null
 
       super.onConnect((reason) => {
@@ -82,25 +79,28 @@ class Handler extends DecoratorHandler {
     this.#statusCode = statusCode
     this.#headers = headers
 
-    if (this.#error == null) {
+    if (!this.#headersSent) {
       assert(this.#etag == null)
       assert(this.#pos == null)
       assert(this.#end == null)
       assert(this.#headersSent === false)
 
       if (headers.trailer) {
-        return this.#onHeaders(statusCode, headers, resume)
+        this.#headersSent = true
+        return super.onHeaders(statusCode, headers, resume)
       }
 
       const contentLength = headers['content-length'] ? Number(headers['content-length']) : null
       if (contentLength != null && !Number.isFinite(contentLength)) {
-        return this.#onHeaders(statusCode, headers, resume)
+        this.#headersSent = true
+        return super.onHeaders(statusCode, headers, resume)
       }
 
       if (statusCode === 206) {
         const range = parseRangeHeader(headers['content-range'])
         if (!range) {
-          return this.#onHeaders(statusCode, headers, resume)
+          this.#headersSent = true
+          return super.onHeaders(statusCode, headers, resume)
         }
 
         const { start, size, end = size } = range
@@ -120,16 +120,11 @@ class Handler extends DecoratorHandler {
         this.#end = contentLength
         this.#etag = headers.etag
       } else if (statusCode >= 400) {
-        if (
-          this.#headers['content-type']?.startsWith('application/json') ||
-          this.#headers['content-type']?.startsWith('text/plain')
-        ) {
-          this.#decoder = new TextDecoder('utf-8')
-          this.#body = ''
-        }
+        this.#body = []
         return true
       } else {
-        return this.#onHeaders(statusCode, headers, resume)
+        this.#headersSent = true
+        return super.onHeaders(statusCode, headers, resume)
       }
 
       // Weak etags are not useful for comparison nor cache
@@ -144,17 +139,20 @@ class Handler extends DecoratorHandler {
 
       this.#resume = resume
 
-      return this.#onHeaders(statusCode, headers, () => this.#resume?.())
+      this.#headersSent = true
+      return super.onHeaders(statusCode, headers, () => this.#resume?.())
     } else if (statusCode === 206 || (this.#pos === 0 && statusCode === 200)) {
       assert(this.#etag != null || !this.#pos)
 
       if (this.#pos > 0 && this.#etag !== headers.etag) {
-        throw this.#error
+        this.#maybeError(null)
+        return null
       }
 
       const contentRange = parseRangeHeader(headers['content-range'])
       if (!contentRange) {
-        throw this.#error
+        this.#maybeError(null)
+        return null
       }
 
       const { start, size, end = size } = contentRange
@@ -166,7 +164,7 @@ class Handler extends DecoratorHandler {
       // TODO (fix): What if we were paused before the error?
       return true
     } else {
-      throw this.#error
+      this.#maybeError(this.#retryError)
     }
   }
 
@@ -179,7 +177,7 @@ class Handler extends DecoratorHandler {
       return super.onData(chunk)
     }
 
-    this.#body += this.#decoder?.decode(chunk, { stream: true }) ?? ''
+    this.#body?.push(chunk)
   }
 
   onComplete(trailers) {
@@ -189,7 +187,6 @@ class Handler extends DecoratorHandler {
       return super.onComplete(trailers)
     }
 
-    this.#body += this.#decoder?.decode(undefined, { stream: false }) ?? ''
     this.#maybeRetry(null)
   }
 
@@ -197,20 +194,38 @@ class Handler extends DecoratorHandler {
     this.#maybeRetry(err)
   }
 
+  #maybeAbort(err) {
+    if (this.#abort && !this.#aborted) {
+      this.#aborted = true
+      this.#abort(err)
+    }
+  }
+
   #maybeError(err) {
     if (err) {
-      this.#onError(err)
-    } else {
-      assert(this.#aborted === false, 'unexpected aborted')
-      assert(this.#statusCode, 'unexpected statusCode')
-      assert(this.#headers, 'unexpected headers')
-
-      this.#onHeaders(this.#statusCode, this.#headers, noop)
+      if (!this.#errorSent) {
+        this.#errorSent = true
+        super.onError(err)
+      }
+    } else if (!this.#headersSent) {
+      super.onHeaders(this.#statusCode, this.#headers, noop)
+      if (this.#aborted) {
+        return
+      }
 
-      if (!this.#aborted) {
-        super.onComplete(this.#trailers)
+      if (this.#body) {
+        for (const chunk of this.#body) {
+          super.onData(chunk)
+          if (this.#aborted) {
+            return
+          }
+        }
       }
+
+      super.onComplete(this.#trailers)
     }
+
+    this.#maybeAbort(err)
   }
 
   #maybeRetry(err) {
@@ -219,23 +234,23 @@ class Handler extends DecoratorHandler {
       return
     }
 
-    this.#error =
-      err ??
-      decorateError(null, this.#opts, {
-        statusCode: this.#statusCode,
-        headers: this.#headers,
-        trailers: this.#trailers,
-        body: this.#body,
-      })
-
     let retryPromise
     try {
-      retryPromise =
-        typeof this.#opts?.retry === 'function'
-          ? this.#opts?.retry(this.#error, this.#retryCount, this.#opts, () =>
-              retryFn(this.#error, this.#retryCount, this.#opts),
-            )
-          : retryFn(this.#error, this.#retryCount, this.#opts)
+      if (typeof this.#opts.retry === 'function') {
+        retryPromise = this.#opts.retry(
+          decorateError(err, this.#opts, {
+            statusCode: this.#statusCode,
+            headers: this.#headers,
+            trailers: this.#trailers,
+            body: this.#body,
+          }),
+          this.#retryCount,
+          this.#opts,
+          () => this.#retryFn(err, this.#retryCount, this.#opts),
+        )
+      } else {
+        retryPromise = this.#retryFn(err, this.#retryCount, this.#opts)
+      }
     } catch (err) {
       retryPromise = Promise.reject(err)
     }
@@ -246,116 +261,96 @@ class Handler extends DecoratorHandler {
     }
 
     retryPromise
-      .then((opts) => {
+      .then((shouldRetry) => {
         if (this.#aborted) {
-          this.#onError(this.#reason)
-        } else if (isDisturbed(this.#opts.body)) {
-          this.#onError(this.#error)
+          this.#maybeError(this.#reason)
+        } else if (shouldRetry === false || isDisturbed(this.#opts.body)) {
+          this.#maybeError(err)
         } else if (!this.#headersSent) {
-          this.#retryCount++
           this.#opts.logger?.debug({ err, retryCount: this.#retryCount }, 'retry response headers')
+
+          this.#retryCount++
+          this.#retryError = err
+
           this.#dispatch(this.#opts, this)
         } else {
           assert(Number.isFinite(this.#pos))
           assert(this.#end == null || (Number.isFinite(this.#end) && this.#end > 0))
 
-          this.#opts = {
-            ...this.#opts,
-            ...opts,
-            headers: {
-              ...this.#opts.headers,
-              ...opts?.headers,
-              'if-match': this.#etag,
-              range: `bytes=${this.#pos}-${this.#end ? this.#end - 1 : ''}`,
-            },
-          }
+          this.#opts.headers['if-match'] = this.#etag
+          this.#opts.headers.range = `bytes=${this.#pos}-${this.#end ? this.#end - 1 : ''}`
+          this.#opts.logger?.debug({ err, retryCount: this.#retryCount }, 'retry response body')
 
           this.#retryCount++
-          this.#opts.logger?.debug({ err, retryCount: this.#retryCount }, 'retry response body')
+          this.#retryError = err
+
           this.#dispatch(this.#opts, this)
         }
       })
       .catch((err) => {
-        if (!this.#errorSent) {
-          this.#onError(err)
-        }
+        this.#maybeError(err)
       })
   }
 
-  #onError(err) {
-    assert(!this.#errorSent)
-    this.#errorSent = true
-    super.onError(err)
-  }
-
-  #onHeaders(statusCode, headers, resume) {
-    assert(!this.#headersSent)
-    this.#headersSent = true
-    return super.onHeaders(statusCode, headers, resume)
-  }
-}
-
-export default () => (dispatch) => (opts, handler) =>
-  opts.retry !== false &&
-  !opts.upgrade &&
-  (opts.method === 'HEAD' ||
-    opts.method === 'GET' ||
-    opts.method === 'PUT' ||
-    opts.method === 'PATCH' ||
-    opts.idempotent)
-    ? dispatch(opts, new Handler(opts, { handler, dispatch }))
-    : dispatch(opts, handler)
-
-async function retryFn(err, retryCount, opts) {
-  let retryOpts = opts?.retry
+  async #retryFn(err, retryCount, opts) {
+    let retryOpts = opts?.retry
 
-  if (!retryOpts) {
-    throw err
-  }
+    if (!retryOpts) {
+      return false
+    }
 
-  if (typeof retryOpts === 'number') {
-    retryOpts = { count: retryOpts }
-  }
+    if (typeof retryOpts === 'number') {
+      retryOpts = { count: retryOpts }
+    }
 
-  const retryMax = retryOpts?.count ?? 8
+    const retryMax = retryOpts?.count ?? 8
 
-  if (retryCount > retryMax) {
-    throw err
-  }
+    if (retryCount > retryMax) {
+      return false
+    }
 
-  const statusCode = err.statusCode ?? err.status ?? err.$metadata?.httpStatusCode ?? null
+    const statusCode =
+      err?.statusCode ?? err?.status ?? err?.$metadata?.httpStatusCode ?? this.#statusCode
+    const headers = err?.headers ?? this.#headers
+
+    if (statusCode && [420, 429, 502, 503, 504].includes(statusCode)) {
+      const retryAfter = headers?.['retry-after'] ? Number(headers['retry-after']) * 1e3 : null
+      const delay =
+        retryAfter != null && Number.isFinite(retryAfter)
+          ? retryAfter
+          : Math.min(10e3, retryCount * 1e3)
+      return tp.setTimeout(delay, true, { signal: opts.signal })
+    }
 
-  if (statusCode && [420, 429, 502, 503, 504].includes(statusCode)) {
-    let retryAfter = err.headers?.['retry-after'] ? err.headers['retry-after'] * 1e3 : null
-    retryAfter = Number.isFinite(retryAfter) ? retryAfter : Math.min(10e3, retryCount * 1e3)
-    if (retryAfter != null && Number.isFinite(retryAfter)) {
-      return tp.setTimeout(retryAfter, undefined, { signal: opts.signal })
-    } else {
-      return null
+    if (
+      err?.code &&
+      [
+        'ECONNRESET',
+        'ECONNREFUSED',
+        'ENOTFOUND',
+        'ENETDOWN',
+        'ENETUNREACH',
+        'EHOSTDOWN',
+        'EHOSTUNREACH',
+        'EPIPE',
+        'ENODATA',
+        'UND_ERR_CONNECT_TIMEOUT',
+      ].includes(err.code)
+    ) {
+      return tp.setTimeout(Math.min(10e3, retryCount * 1e3), true, { signal: opts.signal })
     }
-  }
 
-  if (
-    err.code &&
-    [
-      'ECONNRESET',
-      'ECONNREFUSED',
-      'ENOTFOUND',
-      'ENETDOWN',
-      'ENETUNREACH',
-      'EHOSTDOWN',
-      'EHOSTUNREACH',
-      'EPIPE',
-      'ENODATA',
-      'UND_ERR_CONNECT_TIMEOUT',
-    ].includes(err.code)
-  ) {
-    return tp.setTimeout(Math.min(10e3, retryCount * 1e3), undefined, { signal: opts.signal })
-  }
+    if (err?.message && ['other side closed'].includes(err.message)) {
+      return tp.setTimeout(Math.min(10e3, retryCount * 1e3), true, { signal: opts.signal })
+    }
 
-  if (err.message && ['other side closed'].includes(err.message)) {
-    return tp.setTimeout(Math.min(10e3, retryCount * 1e3), undefined, { signal: opts.signal })
+    return false
   }
-
-  throw err
 }
+
+export default () => (dispatch) => (opts, handler) =>
+  opts.retry !== false &&
+  !opts.upgrade &&
+  (/^(HEAD|GET|PUT|PATCH)$/.test(opts.method) || opts.idempotent)
+    ? dispatch(opts, new Handler(opts, { handler, dispatch }))
+    : dispatch(opts, handler)

package/lib/utils.js

@@ -385,7 +385,13 @@ export function decorateError(err, opts, { statusCode, headers, trailers, body }
         typeof opts?.body !== 'string' || opts.body.length > 1024 ? undefined : opts.body,
     }
 
-    if (headers?.['content-type']?.startsWith('application/json') && typeof body === 'string') {
+    if (Array.isArray(body) && body.every((x) => Buffer.isBuffer(x))) {
+      body = Buffer.concat(body).toString()
+    } else if (typeof body !== 'string') {
+      body = null
+    }
+
+    if (typeof body === 'string' && headers?.['content-type']?.startsWith('application/json')) {
       try {
         body = JSON.parse(body)
       } catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/nxt-undici",
-  "version": "6.2.13",
+  "version": "6.2.14",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "main": "lib/index.js",