@nxtedition/nxt-undici 2.0.15 → 2.0.17

package/lib/index.js

@@ -2,7 +2,7 @@ import assert from 'node:assert'
 import stream from 'node:stream'
 import createError from 'http-errors'
 import undici from 'undici'
-import { parseHeaders, AbortError } from './utils.js'
+import { findHeader, parseHeaders, AbortError } from './utils.js'
 import CacheableLookup from 'cacheable-lookup'
 
 const dispatcherCache = new WeakMap()
@@ -25,13 +25,15 @@ const kStatusCode = Symbol('statusCode')
 const kStatusMessage = Symbol('statusMessage')
 const kHeaders = Symbol('headers')
 const kSize = Symbol('size')
+const kHandler = Symbol('handler')
 
 let ABORT_ERROR
 
 class Readable extends stream.Readable {
-  constructor({ statusCode, statusMessage, headers, size, abort, highWaterMark, resume }) {
-    super(highWaterMark ? { highWaterMark } : undefined)
+  constructor(handler, { statusCode, statusMessage, headers, size, abort, highWaterMark, resume }) {
+    super({ highWaterMark })
 
+    this[kHandler] = handler
     this[kStatusCode] = statusCode
     this[kStatusMessage] = statusMessage
     this[kHeaders] = headers
@@ -71,12 +73,18 @@ class Readable extends stream.Readable {
       this[kAbort](err)
     }
 
+    if (this[kHandler].signal) {
+      this[kHandler].signal.removeEventListener('abort', this[kHandler].onAbort)
+      this[kHandler].signal = null
+    }
+
     callback(err)
   }
 
   async text() {
     const dec = new TextDecoder()
     let str = ''
+
     for await (const chunk of this) {
       if (typeof chunk === 'string') {
         str += chunk
@@ -84,6 +92,7 @@ class Readable extends stream.Readable {
         str += dec.decode(chunk, { stream: true })
       }
     }
+
     // Flush the streaming TextDecoder so that any pending
     // incomplete multibyte characters are handled.
     str += dec.decode(undefined, { stream: false })
@@ -127,16 +136,15 @@ class Readable extends stream.Readable {
 }
 
 const dispatchers = {
+  responseError: (await import('./interceptor/response-error.js')).default,
   requestBody: (await import('./interceptor/request-body.js')).default,
   requestBodyFactory: (await import('./interceptor/request-body-factory.js')).default,
   responseContent: (await import('./interceptor/response-content.js')).default,
   requestContent: (await import('./interceptor/request-content.js')).default,
   log: (await import('./interceptor/log.js')).default,
   redirect: (await import('./interceptor/redirect.js')).default,
-  responseBodyRetry: (await import('./interceptor/response-body-retry.js')).default,
-  responseStatusRetry: (await import('./interceptor/response-status-retry.js')).default,
   responseRetry: (await import('./interceptor/response-retry.js')).default,
-  signal: (await import('./interceptor/signal.js')).default,
+  responseRetryBody: (await import('./interceptor/response-retry-body.js')).default,
   proxy: (await import('./interceptor/proxy.js')).default,
   cache: (await import('./interceptor/cache.js')).default,
   requestId: (await import('./interceptor/request-id.js')).default,
@@ -222,26 +230,25 @@ export async function request(url, opts) {
   let dispatch = dispatcherCache.get(dispatcher)
   if (dispatch == null) {
     dispatch = (opts, handler) => dispatcher.dispatch(opts, handler)
+    dispatch = dispatchers.responseError(dispatch)
     dispatch = dispatchers.requestBodyFactory(dispatch)
     dispatch = dispatchers.log(dispatch)
     dispatch = dispatchers.requestId(dispatch)
     dispatch = dispatchers.responseRetry(dispatch)
-    dispatch = dispatchers.responseStatusRetry(dispatch)
-    dispatch = dispatchers.responseBodyRetry(dispatch)
+    dispatch = dispatchers.responseRetryBody(dispatch)
     dispatch = dispatchers.responseContent(dispatch)
     dispatch = dispatchers.requestContent(dispatch)
-    dispatch = dispatchers.redirect(dispatch)
-    dispatch = dispatchers.signal(dispatch)
     dispatch = dispatchers.cache(dispatch)
+    dispatch = dispatchers.redirect(dispatch)
     dispatch = dispatchers.proxy(dispatch)
     dispatch = dispatchers.requestBody(dispatch)
     dispatcherCache.set(dispatcher, dispatch)
   }
 
-  const res = await new Promise((resolve, reject) =>
+  return await new Promise((resolve, reject) =>
     dispatch(
       {
-        id: opts.id ?? headers?.['request-id'] ?? headers?.['Request-Id'] ?? genReqId(),
+        id: opts.id ?? findHeader(headers, 'request-id') ?? genReqId(),
         url,
         method,
         body: opts.body,
@@ -253,7 +260,6 @@ export async function request(url, opts) {
         headersTimeout: opts.headersTimeout,
         bodyTimeout: opts.bodyTimeout,
         idempotent,
-        signal: opts.signal,
         retry: opts.retry ?? 8,
         proxy: opts.proxy,
         cache: opts.cache,
@@ -266,14 +272,28 @@ export async function request(url, opts) {
         resolve,
         reject,
         logger: opts.logger,
+        signal: opts.signal,
         /** @type {Function | null} */ abort: null,
         /** @type {stream.Readable | null} */ body: null,
         onConnect(abort) {
-          this.abort = abort
+          if (this.signal?.aborted) {
+            abort(this.signal.reason)
+          } else {
+            this.abort = abort
+
+            if (this.signal) {
+              this.onAbort = () => {
+                if (this.body) {
+                  this.body.destroy(this.signal.reason ?? new AbortError())
+                } else {
+                  this.abort(this.signal.reason)
+                }
+              }
+              this.signal.addEventListener('abort', this.onAbort)
+            }
+          }
         },
-        onUpgrade(statusCode, rawHeaders, socket) {
-          const headers = parseHeaders(rawHeaders)
-
+        onUpgrade(statusCode, rawHeaders, socket, headers = parseHeaders(rawHeaders)) {
           if (statusCode !== 101) {
             this.abort(createError(statusCode, { headers }))
           } else {
@@ -283,14 +303,18 @@ export async function request(url, opts) {
         },
         onBodySent(chunk) {},
         onRequestSent() {},
-        onHeaders(statusCode, rawHeaders, resume, statusMessage) {
-          const headers = parseHeaders(rawHeaders)
-
+        onHeaders(
+          statusCode,
+          rawHeaders,
+          resume,
+          statusMessage,
+          headers = parseHeaders(rawHeaders),
+        ) {
           assert(statusCode >= 200)
 
-          const contentLength = Number(headers['content-length'] ?? headers['Content-Length'])
+          const contentLength = findHeader(rawHeaders, 'content-length')
 
-          this.body = new Readable({
+          this.body = new Readable(this, {
             resume,
             abort: this.abort,
             highWaterMark: this.highWaterMark,
@@ -304,7 +328,7 @@ export async function request(url, opts) {
           this.resolve = null
           this.reject = null
 
-          return false
+          return true
         },
         onData(chunk) {
           return this.body.push(chunk)
@@ -313,6 +337,9 @@ export async function request(url, opts) {
           this.body.push(null)
         },
         onError(err) {
+          this.signal?.removeEventListener('abort', this.onAbort)
+          this.signal = null
+
           if (this.body) {
             this.body.destroy(err)
           } else {
@@ -324,18 +351,4 @@ export async function request(url, opts) {
       },
     ),
   )
-
-  if (method === 'HEAD') {
-    await res.dump()
-  } else if (res.statusCode >= 400) {
-    // TODO (fix): Limit the size of the body?
-    const data = /^application\/json$/i.test(res.headers['content-type'])
-      ? await res.json()
-      : /^text-.+/i.test(res.headers['content-type'])
-        ? await res.text()
-        : await res.dump()
-    throw createError(res.statusCode, { headers, data })
-  }
-
-  return res
 }

package/lib/interceptor/cache.js

@@ -1,6 +1,6 @@
 import assert from 'node:assert'
 import { LRUCache } from 'lru-cache'
-import cacheControlParser from 'cache-control-parser'
+import { findHeader, parseCacheControl } from '../utils.js'
 
 class CacheHandler {
   constructor({ key, handler, store }) {
@@ -14,8 +14,8 @@ class CacheHandler {
     return this.handler.onConnect(abort)
   }
 
-  onUpgrade(statusCode, rawHeaders, socket) {
-    return this.handler.onUpgrade(statusCode, rawHeaders, socket)
+  onUpgrade(statusCode, rawHeaders, socket, headers) {
+    return this.handler.onUpgrade(statusCode, rawHeaders, socket, headers)
   }
 
   onBodySent(chunk) {
@@ -26,22 +26,13 @@ class CacheHandler {
     return this.handler.onRequestSent()
   }
 
-  onHeaders(statusCode, rawHeaders, resume, statusMessage) {
+  onHeaders(statusCode, rawHeaders, resume, statusMessage, headers) {
     // NOTE: Only cache 307 respones for now...
     if (statusCode !== 307) {
-      return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage)
+      return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage, headers)
     }
 
-    let cacheControl
-    for (let n = 0; n < rawHeaders.length; n += 2) {
-      if (
-        rawHeaders[n].length === 'cache-control'.length &&
-        rawHeaders[n].toString().toLowerCase() === 'cache-control'
-      ) {
-        cacheControl = cacheControlParser.parse(rawHeaders[n + 1].toString())
-        break
-      }
-    }
+    const cacheControl = parseCacheControl(findHeader(rawHeaders, 'cache-control'))
 
     if (
       cacheControl &&
@@ -73,7 +64,7 @@ class CacheHandler {
       }
     }
 
-    return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage)
+    return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage, headers)
   }
 
   onData(chunk) {

package/lib/interceptor/log.js

@@ -31,13 +31,13 @@ class Handler {
     })
   }
 
-  onUpgrade(statusCode, rawHeaders, socket) {
+  onUpgrade(statusCode, rawHeaders, socket, headers) {
     this.logger.debug('upstream request upgraded')
     socket.on('close', () => {
       this.logger.debug('upstream request socket closed')
     })
 
-    return this.handler.onUpgrade(statusCode, rawHeaders, socket)
+    return this.handler.onUpgrade(statusCode, rawHeaders, socket, headers)
   }
 
   onBodySent(chunk) {
@@ -54,18 +54,18 @@ class Handler {
     return this.handler.onRequestSent()
   }
 
-  onHeaders(statusCode, rawHeaders, resume, statusMessage) {
+  onHeaders(statusCode, rawHeaders, resume, statusMessage, headers = parseHeaders(rawHeaders)) {
     this.stats.headers = performance.now() - this.stats.start
 
     this.logger.debug(
       {
-        ures: { statusCode, headers: parseHeaders(rawHeaders) },
+        ures: { statusCode, headers },
         elapsedTime: this.stats.headers,
       },
       'upstream request response',
     )
 
-    return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage)
+    return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage, headers)
   }
 
   onData(chunk) {

package/lib/interceptor/redirect.js

@@ -34,8 +34,8 @@ class Handler {
     }
   }
 
-  onUpgrade(statusCode, headers, socket) {
-    return this.handler.onUpgrade(statusCode, headers, socket)
+  onUpgrade(statusCode, rawHeaders, socket, headers) {
+    return this.handler.onUpgrade(statusCode, rawHeaders, socket, headers)
   }
 
   onBodySent(chunk) {
@@ -46,16 +46,16 @@ class Handler {
     return this.handler.onRequestSent()
   }
 
-  onHeaders(statusCode, headers, resume, statusText) {
+  onHeaders(statusCode, rawHeaders, resume, statusText, headers) {
     if (redirectableStatusCodes.indexOf(statusCode) === -1) {
-      return this.handler.onHeaders(statusCode, headers, resume, statusText)
+      return this.handler.onHeaders(statusCode, rawHeaders, resume, statusText, headers)
     }
 
     if (isDisturbed(this.opts.body)) {
       throw new Error(`Disturbed request cannot be redirected.`)
     }
 
-    this.location = findHeader(headers, 'location')
+    this.location = findHeader(rawHeaders, 'location')
 
     if (!this.location) {
       throw new Error(`Missing redirection location .`)
@@ -65,7 +65,7 @@ class Handler {
 
     if (typeof this.opts.follow === 'function') {
       if (!this.opts.follow(this.location, this.count)) {
-        return this.handler.onHeaders(statusCode, headers, resume, statusText)
+        return this.handler.onHeaders(statusCode, rawHeaders, resume, statusText, headers)
       }
     } else {
       if (this.count >= this.maxCount) {

package/lib/interceptor/request-body-factory.js

@@ -8,7 +8,7 @@ export default (dispatch) => (opts, handler) => {
 
   const body = opts.body({ signal: opts.signal })
 
-  if (typeof body.then === 'function') {
+  if (typeof body?.then === 'function') {
     body.then(
       (body) => dispatch({ ...opts, body }, handler),
       (err) => handler.onError(err),

package/lib/interceptor/request-body.js

@@ -27,8 +27,8 @@ class Handler {
     }
   }
 
-  onUpgrade(statusCode, rawHeaders, socket) {
-    return this.handler.onUpgrade(statusCode, rawHeaders, socket)
+  onUpgrade(statusCode, rawHeaders, socket, headers) {
+    return this.handler.onUpgrade(statusCode, rawHeaders, socket, headers)
   }
 
   onBodySent(chunk) {
@@ -39,8 +39,8 @@ class Handler {
     return this.handler.onRequestSent()
   }
 
-  onHeaders(statusCode, rawHeaders, resume, statusMessage) {
-    return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage)
+  onHeaders(statusCode, rawHeaders, resume, statusMessage, headers) {
+    return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage, headers)
   }
 
   onData(chunk) {

package/lib/interceptor/request-content.js

@@ -1,4 +1,5 @@
 import crypto from 'node:crypto'
+import { findHeader } from '../utils.js'
 
 class Handler {
   constructor(opts, { handler, md5, length }) {
@@ -16,8 +17,8 @@ class Handler {
     return this.handler.onConnect(abort)
   }
 
-  onUpgrade(statusCode, rawHeaders, socket) {
-    return this.handler.onUpgrade(statusCode, rawHeaders, socket)
+  onUpgrade(statusCode, rawHeaders, socket, headers) {
+    return this.handler.onUpgrade(statusCode, rawHeaders, socket, headers)
   }
 
   onBodySent(chunk) {
@@ -51,8 +52,8 @@ class Handler {
     return this.handler.onRequestSent()
   }
 
-  onHeaders(statusCode, rawHeaders, resume, statusMessage) {
-    return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage)
+  onHeaders(statusCode, rawHeaders, resume, statusMessage, headers) {
+    return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage, headers)
   }
 
   onData(chunk) {
@@ -74,8 +75,8 @@ export default (dispatch) => (opts, handler) => {
   }
 
   // TODO (fix): case-insensitive check?
-  const md5 = opts.headers?.['content-md5'] ?? opts.headers?.['Content-MD5']
-  const length = opts.headers?.['content-lenght'] ?? opts.headers?.['Content-Length']
+  const md5 = findHeader(opts.headers, 'content-md5')
+  const length = findHeader(opts.headers, 'content-length')
 
   return md5 != null || length != null
     ? dispatch(opts, new Handler(opts, { handler, md5, length }))

package/lib/interceptor/response-content.js

@@ -14,8 +14,8 @@ class Handler {
     return this.handler.onConnect(abort)
   }
 
-  onUpgrade(statusCode, rawHeaders, socket) {
-    return this.handler.onUpgrade(statusCode, rawHeaders, socket)
+  onUpgrade(statusCode, rawHeaders, socket, headers) {
+    return this.handler.onUpgrade(statusCode, rawHeaders, socket, headers)
   }
 
   onBodySent(chunk) {
@@ -26,12 +26,12 @@ class Handler {
     return this.handler.onRequestSent()
   }
 
-  onHeaders(statusCode, rawHeaders, resume, statusMessage) {
+  onHeaders(statusCode, rawHeaders, resume, statusMessage, headers) {
     this.md5 = findHeader(rawHeaders, 'content-md5')
     this.length = findHeader(rawHeaders, 'content-length')
     this.hasher = this.md5 != null ? crypto.createHash('md5') : null
 
-    return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage)
+    return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage, headers)
   }
 
   onData(chunk) {

package/lib/interceptor/response-error.js

@@ -0,0 +1,96 @@
+import { findHeader, parseHeaders } from '../utils.js'
+import createHttpError from 'http-errors'
+
+class Handler {
+  constructor(opts, { handler }) {
+    this.handler = handler
+    this.statusCode = 0
+    this.contentType = null
+    this.decoder = null
+    this.headers = null
+    this.body = null
+  }
+
+  onConnect(abort) {
+    return this.handler.onConnect(abort)
+  }
+
+  onUpgrade(statusCode, rawHeaders, socket, headers) {
+    return this.handler.onUpgrade(statusCode, rawHeaders, socket, headers)
+  }
+
+  onBodySent(chunk) {
+    return this.handler.onBodySent(chunk)
+  }
+
+  onRequestSent() {
+    return this.handler.onRequestSent()
+  }
+
+  onHeaders(statusCode, rawHeaders, resume, statusMessage, headers = parseHeaders(rawHeaders)) {
+    if (statusCode >= 400) {
+      this.statusCode = statusCode
+      this.headers = headers
+      this.contentType = findHeader(rawHeaders, 'content-type')
+      if (this.contentType === 'application/json' || this.contentType === 'text/plain') {
+        this.decoder = new TextDecoder('utf-8')
+        this.body = ''
+      }
+    } else {
+      return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage, headers)
+    }
+  }
+
+  onData(chunk) {
+    if (this.statusCode) {
+      if (this.decoder) {
+        // TODO (fix): Limit body size?
+        this.body += this.decoder.decode(chunk, { stream: true })
+      }
+      return true
+    } else {
+      return this.handler.onData(chunk)
+    }
+  }
+
+  onComplete(rawTrailers) {
+    this.onFinally(null, rawTrailers)
+  }
+
+  onError(err) {
+    this.onFinally(err, null)
+  }
+
+  onFinally(err, rawTrailers) {
+    if (this.statusCode) {
+      if (this.decoder != null) {
+        this.body += this.decoder.decode(undefined, { stream: false })
+        if (this.contentType === 'application/json') {
+          this.body = JSON.parse(this.body)
+        }
+      }
+
+      const stackTraceLimit = Error.stackTraceLimit
+      Error.stackTraceLimit = 0
+      try {
+        this.handler.onError(
+          createHttpError(this.statusCode, { headers: this.headers, body: this.body }),
+        )
+      } finally {
+        Error.stackTraceLimit = stackTraceLimit
+      }
+
+      this.decoder = null
+      this.contentType = null
+      this.body = null
+    } else if (err) {
+      this.handler.onError(err)
+    } else {
+      this.handler.onComplete(rawTrailers)
+    }
+
+    this.handler = null
+  }
+}
+
+export default (dispatch) => (opts, handler) => dispatch(opts, new Handler(opts, { handler }))

package/lib/interceptor/{response-body-retry.js → response-retry-body.js}

@@ -6,18 +6,16 @@ class Handler {
     this.dispatch = dispatch
     this.handler = handler
     this.opts = opts
-    this.abort = null
-    this.aborted = false
-    this.reason = null
-
-    this.retryCount = 0
-    this.retryPromise = null
 
+    this.count = 0
     this.pos = 0
     this.end = null
     this.error = null
     this.etag = null
 
+    this.reason = null
+    this.aborted = false
+
     this.handler.onConnect((reason) => {
       this.aborted = true
       if (this.abort) {
@@ -36,8 +34,8 @@ class Handler {
     }
   }
 
-  onUpgrade(statusCode, rawHeaders, socket) {
-    return this.handler.onUpgrade(statusCode, rawHeaders, socket)
+  onUpgrade(statusCode, rawHeaders, socket, headers) {
+    return this.handler.onUpgrade(statusCode, rawHeaders, socket, headers)
   }
 
   onBodySent(chunk) {
@@ -48,7 +46,7 @@ class Handler {
     return this.handler.onRequestSent()
   }
 
-  onHeaders(statusCode, rawHeaders, resume, statusMessage) {
+  onHeaders(statusCode, rawHeaders, resume, statusMessage, headers) {
     const etag = findHeader(rawHeaders, 'etag')
 
     if (this.resume) {
@@ -82,7 +80,13 @@ class Handler {
       if (statusCode === 206) {
         const contentRange = parseContentRange(findHeader(rawHeaders, 'content-range'))
         if (!contentRange) {
-          return this.handler.onHeaders(statusCode, rawHeaders, () => this.resume(), statusMessage)
+          return this.handler.onHeaders(
+            statusCode,
+            rawHeaders,
+            () => this.resume(),
+            statusMessage,
+            headers,
+          )
         }
 
         const { start, size, end = size } = contentRange
@@ -102,7 +106,14 @@ class Handler {
 
     this.etag = etag
     this.resume = resume
-    return this.handler.onHeaders(statusCode, rawHeaders, () => this.resume(), statusMessage)
+
+    return this.handler.onHeaders(
+      statusCode,
+      rawHeaders,
+      () => this.resume(),
+      statusMessage,
+      headers,
+    )
   }
 
   onData(chunk) {
@@ -116,31 +127,15 @@ class Handler {
   }
 
   onError(err) {
-    if (!this.resume || this.aborted || !this.etag || isDisturbed(this.opts.body)) {
+    if (this.aborted || !this.etag || isDisturbed(this.opts.body)) {
       return this.handler.onError(err)
     }
 
-    const retryPromise = retryFn(err, this.retryCount++, this.opts)
+    const retryPromise = retryFn(err, this.count++, this.opts)
     if (retryPromise == null) {
       return this.handler.onError(err)
     }
 
-    retryPromise
-      .then(() => {
-        if (!this.aborted) {
-          try {
-            this.dispatch(this.opts, this)
-          } catch (err2) {
-            this.handler.onError(new AggregateError([err, err2]))
-          }
-        }
-      })
-      .catch((err) => {
-        if (!this.aborted) {
-          this.handler.onError(err)
-        }
-      })
-
     this.error = err
     this.opts = {
       ...this.opts,
@@ -152,6 +147,18 @@ class Handler {
     }
 
     this.opts.logger?.debug('retrying response body')
+
+    retryPromise
+      .then(() => {
+        if (!this.aborted) {
+          this.dispatch(this.opts, this)
+        }
+      })
+      .catch((err) => {
+        if (!this.aborted) {
+          this.handler.onError(err)
+        }
+      })
   }
 }
 

package/lib/interceptor/response-retry.js

@@ -5,13 +5,12 @@ class Handler {
     this.dispatch = dispatch
     this.handler = handler
     this.opts = opts
-    this.abort = null
-    this.aborted = false
-    this.reason = null
-    this.statusCode = 0
 
-    this.retryCount = 0
-    this.retryPromise = null
+    this.hasBody = false
+    this.count = 0
+
+    this.reason = null
+    this.aborted = false
 
     this.handler.onConnect((reason) => {
       this.aborted = true
@@ -31,8 +30,8 @@ class Handler {
     }
   }
 
-  onUpgrade(statusCode, rawHeaders, socket) {
-    return this.handler.onUpgrade(statusCode, rawHeaders, socket)
+  onUpgrade(statusCode, rawHeaders, socket, headers) {
+    return this.handler.onUpgrade(statusCode, rawHeaders, socket, headers)
   }
 
   onBodySent(chunk) {
@@ -43,12 +42,12 @@ class Handler {
     return this.handler.onRequestSent()
   }
 
-  onHeaders(statusCode, rawHeaders, resume, statusMessage) {
-    this.statusCode = statusCode
-    return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage)
+  onHeaders(statusCode, rawHeaders, resume, statusMessage, headers) {
+    return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage, headers)
   }
 
   onData(chunk) {
+    this.hasBody = true
     return this.handler.onData(chunk)
   }
 
@@ -57,23 +56,21 @@ class Handler {
   }
 
   onError(err) {
-    if (this.aborted || this.statusCode || isDisturbed(this.opts.body)) {
+    if (this.aborted || this.hasBody || isDisturbed(this.opts.body)) {
       return this.handler.onError(err)
     }
 
-    const retryPromise = retryFn(err, this.retryCount++, this.opts)
+    const retryPromise = retryFn(err, this.count++, this.opts)
     if (retryPromise == null) {
       return this.handler.onError(err)
     }
 
+    this.opts.logger?.debug('retrying response')
+
     retryPromise
       .then(() => {
         if (!this.aborted) {
-          try {
-            this.dispatch(this.opts, this)
-          } catch (err2) {
-            this.handler.onError(new AggregateError([err, err2]))
-          }
+          this.dispatch(this.opts, this)
         }
       })
       .catch((err) => {
@@ -81,12 +78,11 @@ class Handler {
           this.handler.onError(err)
         }
       })
-
-    this.opts.logger?.debug('retrying response')
   }
 }
 
-export default (dispatch) => (opts, handler) =>
-  opts.idempotent && opts.retry && !opts.upgrade
+export default (dispatch) => (opts, handler) => {
+  return opts.retry
     ? dispatch(opts, new Handler(opts, { handler, dispatch }))
     : dispatch(opts, handler)
+}

package/lib/utils.js

@@ -1,4 +1,19 @@
 import tp from 'node:timers/promises'
+import cacheControlParser from 'cache-control-parser'
+
+export function parseCacheControl(str) {
+  return str ? cacheControlParser.parse(str) : null
+}
+
+const lowerCaseCache = new Map()
+export function toLowerCase(val) {
+  let ret = lowerCaseCache.get(val)
+  if (ret === undefined) {
+    ret = val.toLowerCase()
+    lowerCaseCache.set(val, ret)
+  }
+  return ret
+}
 
 export function isDisturbed(body) {
   if (
@@ -45,15 +60,31 @@ export function parseContentRange(range) {
   return { start, end: end ? end + 1 : size, size }
 }
 
-export function findHeader(rawHeaders, name) {
+export function findHeader(headers, name) {
   const len = name.length
 
-  for (let i = 0; i < rawHeaders.length; i += 2) {
-    const key = rawHeaders[i + 0]
-    if (key.length === len && key.toString().toLowerCase() === name) {
-      return rawHeaders[i + 1].toString()
+  if (Array.isArray(headers)) {
+    for (let i = 0; i < headers.length; i += 2) {
+      const key = headers[i + 0]
+      if (key.length === len && toLowerCase(key.toString()) === name) {
+        return headers[i + 1].toString()
+      }
+    }
+  } else if (headers != null) {
+    {
+      const val = headers[name]
+      if (val !== undefined) {
+        return val
+      }
+    }
+
+    for (const key of Object.keys(headers)) {
+      if (key.length === len && toLowerCase(key) === name) {
+        return headers[key].toString()
+      }
     }
   }
+
   return null
 }
 
@@ -178,18 +209,24 @@ export function parseOrigin(url) {
   return url
 }
 
-export function parseHeaders(rawHeaders, obj = {}) {
-  for (let i = 0; i < rawHeaders.length; i += 2) {
-    const key = rawHeaders[i].toString().toLowerCase()
+export function parseHeaders(headers, obj = {}) {
+  for (let i = 0; i < headers.length; i += 2) {
+    const key = toLowerCase(headers[i].toString())
+
     let val = obj[key]
     if (!val) {
-      obj[key] = rawHeaders[i + 1].toString()
+      val = headers[i + 1]
+      if (typeof val === 'string') {
+        obj[key] = val
+      } else {
+        obj[key] = Array.isArray(val) ? val.map((x) => x.toString()) : val.toString()
+      }
     } else {
       if (!Array.isArray(val)) {
         val = [val]
         obj[key] = val
       }
-      val.push(rawHeaders[i + 1].toString())
+      val.push(headers[i + 1].toString())
     }
   }
   return obj

package/package.json

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

package/lib/interceptor/response-status-retry.js

@@ -1,104 +0,0 @@
-import { parseHeaders, isDisturbed, retry as retryFn } from '../utils.js'
-import createError from 'http-errors'
-
-class Handler {
-  constructor(opts, { dispatch, handler }) {
-    this.dispatch = dispatch
-    this.handler = handler
-    this.opts = opts
-    this.abort = null
-    this.aborted = false
-    this.reason = null
-
-    this.retryCount = 0
-    this.retryPromise = null
-
-    this.handler.onConnect((reason) => {
-      this.aborted = true
-      if (this.abort) {
-        this.abort(reason)
-      } else {
-        this.reason = reason
-      }
-    })
-  }
-
-  onConnect(abort) {
-    if (this.aborted) {
-      abort(this.reason)
-    } else {
-      this.abort = abort
-    }
-  }
-
-  onUpgrade(statusCode, rawHeaders, socket) {
-    return this.handler.onUpgrade(statusCode, rawHeaders, socket)
-  }
-
-  onBodySent(chunk) {
-    return this.handler.onBodySent(chunk)
-  }
-
-  onRequestSent() {
-    return this.handler.onRequestSent()
-  }
-
-  onHeaders(statusCode, rawHeaders, resume, statusMessage) {
-    if (statusCode < 400) {
-      return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage)
-    }
-
-    const err = createError(statusCode, { headers: parseHeaders(rawHeaders) })
-
-    const retryPromise = retryFn(err, this.retryCount++, this.opts)
-    if (retryPromise == null) {
-      return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage)
-    }
-
-    retryPromise.catch(() => {})
-
-    this.retryPromise = retryPromise
-
-    this.abort(err)
-
-    return false
-  }
-
-  onData(chunk) {
-    return this.handler.onData(chunk)
-  }
-
-  onComplete(rawTrailers) {
-    return this.handler.onComplete(rawTrailers)
-  }
-
-  onError(err) {
-    if (this.retryPromise == null || this.aborted || isDisturbed(this.opts.body)) {
-      return this.handler.onError(err)
-    }
-
-    this.retryPromise
-      .then(() => {
-        if (!this.aborted) {
-          try {
-            this.dispatch(this.opts, this)
-          } catch (err2) {
-            this.handler.onError(new AggregateError([err, err2]))
-          }
-        }
-      })
-      .catch((err) => {
-        if (!this.aborted) {
-          this.handler.onError(err)
-        }
-      })
-    this.retryPromise = null
-
-    this.opts.logger?.debug('retrying response status')
-  }
-}
-
-export default (dispatch) => (opts, handler) =>
-  opts.idempotent && opts.retry
-    ? dispatch(opts, new Handler(opts, { handler, dispatch }))
-    : dispatch(opts, handler)

package/lib/interceptor/signal.js

@@ -1,57 +0,0 @@
-class Handler {
-  constructor(opts, { handler }) {
-    this.handler = handler
-    this.signal = opts.signal
-    this.abort = null
-  }
-
-  onConnect(abort) {
-    if (this.signal.aborted) {
-      abort(this.signal.reason)
-    } else {
-      this.abort = () => abort(this.signal.reason)
-      this.signal.addEventListener('abort', this.abort)
-
-      this.handler.onConnect(abort)
-    }
-  }
-
-  onUpgrade(statusCode, rawHeaders, socket) {
-    return this.handler.onUpgrade(statusCode, rawHeaders, socket)
-  }
-
-  onBodySent(chunk) {
-    return this.handler.onBodySent(chunk)
-  }
-
-  onRequestSent() {
-    return this.handler.onRequestSent()
-  }
-
-  onHeaders(statusCode, rawHeaders, resume, statusMessage) {
-    return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage)
-  }
-
-  onData(chunk) {
-    return this.handler.onData(chunk)
-  }
-
-  onComplete(rawTrailers) {
-    if (this.abort) {
-      this.signal.removeEventListener('abort', this.abort)
-    }
-
-    return this.handler.onComplete(rawTrailers)
-  }
-
-  onError(err) {
-    if (this.abort) {
-      this.signal.removeEventListener('abort', this.abort)
-    }
-
-    return this.handler.onError(err)
-  }
-}
-
-export default (dispatch) => (opts, handler) =>
-  opts.signal ? dispatch(opts, new Handler(opts, { handler })) : dispatch(opts, handler)