@nxtedition/nxt-undici 6.2.12 → 6.2.14

package/lib/interceptor/dns.js

@@ -42,8 +42,11 @@ export default () => (dispatch) => {
 
           if (err) {
             logger?.error({ err, dns: { hostname } }, 'lookup failed')
+
             resolve([err, null])
           } else {
+            logger?.debug({ dns: { hostname, records } }, 'lookup completed')
+
             const now = getFastNow()
             const val = records.map(({ address, ttl }) => ({
               address,
@@ -53,8 +56,6 @@ export default () => (dispatch) => {
               counter: 0,
             }))
 
-            logger?.debug({ err, dns: { hostname, records } }, 'lookup completed')
-
             cache.set(hostname, val)
 
             resolve([null, val])

package/lib/interceptor/response-error.js

@@ -1,11 +1,10 @@
-import createHttpError from 'http-errors'
-import { DecoratorHandler } from '../utils.js'
+import { DecoratorHandler, decorateError } from '../utils.js'
 
 class Handler extends DecoratorHandler {
   #statusCode = 0
-  #contentType
   #decoder
   #headers
+  #trailers
   #body = ''
   #opts
 
@@ -15,13 +14,8 @@ class Handler extends DecoratorHandler {
     this.#opts = opts
   }
 
-  #checkContentType(contentType) {
-    return (this.#contentType ?? '').indexOf(contentType) === 0
-  }
-
   onConnect(abort) {
     this.#statusCode = 0
-    this.#contentType = null
     this.#decoder = null
     this.#headers = null
     this.#body = ''
@@ -32,14 +26,17 @@ class Handler extends DecoratorHandler {
   onHeaders(statusCode, headers, resume) {
     this.#statusCode = statusCode
     this.#headers = headers
-    this.#contentType = headers['content-type']
 
     if (this.#statusCode < 400) {
       return super.onHeaders(statusCode, headers, resume)
     }
 
-    if (this.#checkContentType('application/json') || this.#checkContentType('text/plain')) {
+    if (
+      this.#headers['content-type']?.startsWith('application/json') ||
+      this.#headers['content-type']?.startsWith('text/plain')
+    ) {
       this.#decoder = new TextDecoder('utf-8')
+      this.#body = ''
     }
   }
 
@@ -52,72 +49,33 @@ class Handler extends DecoratorHandler {
   }
 
   onComplete(trailers) {
-    if (this.#statusCode >= 400) {
-      this.#body += this.#decoder?.decode(undefined, { stream: false }) ?? ''
-
-      if (this.#checkContentType('application/json')) {
-        try {
-          this.#body = JSON.parse(this.#body)
-        } catch {
-          // Do nothing...
-        }
-      }
-
-      let err
-      const stackTraceLimit = Error.stackTraceLimit
-      Error.stackTraceLimit = 0
-      try {
-        err = createHttpError(this.#statusCode)
-      } finally {
-        Error.stackTraceLimit = stackTraceLimit
-      }
-
-      super.onError(this.#decorateError(err))
-    } else {
-      super.onComplete(trailers)
+    this.#trailers = trailers
+
+    if (this.#statusCode < 400) {
+      return super.onComplete(trailers)
     }
-  }
 
-  onError(err) {
-    super.onError(this.#decorateError(err))
+    this.#body += this.#decoder?.decode(undefined, { stream: false }) ?? ''
+
+    super.onError(
+      decorateError(null, this.#opts, {
+        statusCode: this.#statusCode,
+        headers: this.#headers,
+        trailers: this.#trailers,
+        body: this.#body,
+      }),
+    )
   }
 
-  #decorateError(err) {
-    try {
-      err.url ??= this.#opts.origin ? new URL(this.#opts.path, this.#opts.origin).href : null
-
-      err.req = {
-        method: this.#opts?.method,
-        headers: this.#opts?.headers,
-        body:
-          // TODO (fix): JSON.stringify POJO
-          typeof this.#opts?.body !== 'string' || this.#opts.body.length > 1024
-            ? undefined
-            : this.#opts.body,
-      }
-
-      err.res = {
+  onError(err) {
+    super.onError(
+      decorateError(err, this.#opts, {
+        statusCode: this.#statusCode,
         headers: this.#headers,
-        // TODO (fix): JSON.stringify POJO
-        body: typeof this.#body !== 'string' || this.#body.length < 1024 ? undefined : this.#body,
-      }
-
-      if (this.#body) {
-        if (this.#body.reason != null) {
-          err.reason ??= this.#body.reason
-        }
-        if (this.#body.code != null) {
-          err.code ??= this.#body.code
-        }
-        if (this.#body.error != null) {
-          err.error ??= this.#body.error
-        }
-      }
-
-      return err
-    } catch (er) {
-      return new AggregateError([er, err])
-    }
+        trailers: this.#trailers,
+        body: null,
+      }),
+    )
   }
 }
 

package/lib/interceptor/response-retry.js

@@ -1,7 +1,6 @@
 import assert from 'node:assert'
 import tp from 'node:timers/promises'
-import { DecoratorHandler, isDisturbed, parseRangeHeader } from '../utils.js'
-import createHttpError from 'http-errors'
+import { DecoratorHandler, isDisturbed, decorateError, parseRangeHeader } from '../utils.js'
 
 function noop() {}
 
@@ -11,12 +10,14 @@ class Handler extends DecoratorHandler {
   #opts
 
   #retryCount = 0
+  #retryError = null
   #headersSent = false
   #errorSent = false
 
   #statusCode = 0
-  #headers = null
-  #trailers = null
+  #headers
+  #trailers
+  #body
 
   #abort
   #aborted = false
@@ -26,7 +27,6 @@ class Handler extends DecoratorHandler {
   #pos
   #end
   #etag
-  #error
 
   constructor(opts, { handler, dispatch }) {
     super(handler)
@@ -47,13 +47,13 @@ class Handler extends DecoratorHandler {
   onConnect(abort) {
     this.#statusCode = 0
     this.#headers = null
+    this.#body = null
     this.#trailers = null
 
     if (!this.#headersSent) {
       this.#pos = null
       this.#end = null
       this.#etag = null
-      this.#error = null
       this.#resume = null
 
       super.onConnect((reason) => {
@@ -79,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
@@ -117,9 +120,11 @@ class Handler extends DecoratorHandler {
         this.#end = contentLength
         this.#etag = headers.etag
       } else if (statusCode >= 400) {
+        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
@@ -134,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
@@ -156,72 +164,93 @@ class Handler extends DecoratorHandler {
       // TODO (fix): What if we were paused before the error?
       return true
     } else {
-      throw this.#error
+      this.#maybeError(this.#retryError)
     }
   }
 
   onData(chunk) {
-    if (this.#statusCode >= 400) {
-      // TODO (fix): Limit the amount of data we read?
-      return true
-    }
-
     if (this.#pos != null) {
       this.#pos += chunk.byteLength
     }
-    return super.onData(chunk)
-  }
 
-  onError(err) {
-    this.#maybeRetry(err)
+    if (this.#statusCode < 400) {
+      return super.onData(chunk)
+    }
+
+    this.#body?.push(chunk)
   }
 
   onComplete(trailers) {
     this.#trailers = trailers
 
-    if (this.#statusCode >= 400) {
-      this.#maybeRetry(null, this.#statusCode)
-    } else {
-      super.onComplete(trailers)
+    if (this.#statusCode < 400) {
+      return super.onComplete(trailers)
+    }
+
+    this.#maybeRetry(null)
+  }
+
+  onError(err) {
+    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, statusCode) {
+  #maybeRetry(err) {
     if (this.#aborted || isDisturbed(this.#opts.body) || (this.#pos && !this.#etag)) {
       this.#maybeError(err)
       return
     }
 
-    if (!err) {
-      // TOOD (fix): Avoid creating an Error and do onHeaders + onComplete.
-      const stackTraceLimit = Error.stackTraceLimit
-      Error.stackTraceLimit = 0
-      try {
-        err = createHttpError(statusCode ?? 500)
-      } finally {
-        Error.stackTraceLimit = stackTraceLimit
-      }
-    }
-
     let retryPromise
     try {
-      retryPromise = retryFn(err, 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)
     }
@@ -231,123 +260,97 @@ class Handler extends DecoratorHandler {
       return
     }
 
-    this.#error = err
-
     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
-
-  if (!retryOpts) {
-    throw err
-  }
+  async #retryFn(err, retryCount, opts) {
+    let retryOpts = opts?.retry
 
-  if (typeof retryOpts === 'function') {
-    return retryOpts(err, retryCount, opts, () => retryFn(err, retryCount, opts))
-  }
+    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

@@ -2,6 +2,7 @@ import cacheControlParser from 'cache-control-parser'
 import stream from 'node:stream'
 import assert from 'node:assert'
 import { util } from '@nxtedition/undici'
+import createHttpError from 'http-errors'
 
 let fastNow = Date.now()
 
@@ -351,9 +352,75 @@ export function parseHeaders(headers, obj) {
   }
 
   // See https://github.com/nodejs/node/pull/46528
-  if ('content-length' in obj && 'content-disposition' in obj) {
+  if (obj != null && 'content-length' in obj && 'content-disposition' in obj) {
     obj['content-disposition'] = Buffer.from(obj['content-disposition']).toString('latin1')
   }
 
   return obj
 }
+
+export function decorateError(err, opts, { statusCode, headers, trailers, body }) {
+  try {
+    if (err == null) {
+      const stackTraceLimit = Error.stackTraceLimit
+      Error.stackTraceLimit = 0
+      try {
+        err = createHttpError(statusCode)
+      } finally {
+        Error.stackTraceLimit = stackTraceLimit
+      }
+    }
+
+    if (statusCode != null) {
+      err.statusCode = statusCode
+    }
+
+    err.url ??= opts.origin ? new URL(opts.path, opts.origin).href : null
+
+    err.req = {
+      method: opts?.method,
+      headers: opts?.headers,
+      body:
+        // TODO (fix): JSON.stringify POJO
+        typeof opts?.body !== 'string' || opts.body.length > 1024 ? undefined : opts.body,
+    }
+
+    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 {
+        // Do nothing...
+      }
+    }
+
+    err.res = {
+      headers,
+      trailers,
+      // TODO (fix): JSON.stringify POJO
+      body: typeof body !== 'string' || body.length < 1024 ? undefined : body,
+      statusCode,
+    }
+
+    if (body) {
+      if (body.reason != null) {
+        err.reason ??= body.reason
+      }
+      if (body.code != null) {
+        err.code ??= body.code
+      }
+      if (body.error != null) {
+        err.error ??= body.error
+      }
+    }
+
+    return err
+  } catch (er) {
+    return new AggregateError([er, err])
+  }
+}

package/package.json

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