@nxtedition/nxt-undici 2.0.46 → 2.0.47

package/lib/index.js

@@ -2,7 +2,7 @@ import assert from 'node:assert'
 import createError from 'http-errors'
 import undici from 'undici'
 import { findHeader, parseHeaders, AbortError, isStream } from './utils.js'
-import { BodyReadable as Readable } from './readable.js'
+import { BodyReadable } from './readable.js'
 
 const dispatcherCache = new WeakMap()
 
@@ -19,14 +19,13 @@ function genReqId() {
   return `req-${nextReqId.toString(36)}`
 }
 
-const dispatchers = {
+export const interceptors = {
   responseError: (await import('./interceptor/response-error.js')).default,
   requestBodyFactory: (await import('./interceptor/request-body-factory.js')).default,
   responseContent: (await import('./interceptor/response-content.js')).default,
   log: (await import('./interceptor/log.js')).default,
   redirect: (await import('./interceptor/redirect.js')).default,
   responseRetry: (await import('./interceptor/response-retry.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,
@@ -110,16 +109,15 @@ 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.responseRetryBody(dispatch)
-    dispatch = dispatchers.responseContent(dispatch)
-    dispatch = dispatchers.cache(dispatch)
-    dispatch = dispatchers.redirect(dispatch)
-    dispatch = dispatchers.proxy(dispatch)
+    dispatch = interceptors.responseError(dispatch)
+    dispatch = interceptors.requestBodyFactory(dispatch)
+    dispatch = interceptors.log(dispatch)
+    dispatch = interceptors.requestId(dispatch)
+    dispatch = interceptors.responseRetry(dispatch)
+    dispatch = interceptors.responseContent(dispatch)
+    dispatch = interceptors.cache(dispatch)
+    dispatch = interceptors.redirect(dispatch)
+    dispatch = interceptors.proxy(dispatch)
     dispatcherCache.set(dispatcher, dispatch)
   }
 
@@ -192,7 +190,7 @@ export async function request(url, opts) {
           const contentLength = findHeader(headers, 'content-length')
           const contentType = findHeader(headers, 'content-type')
 
-          this.body = new Readable(this, {
+          this.body = new BodyReadable(this, {
             resume,
             abort: this.abort,
             highWaterMark: this.highWaterMark,

package/lib/interceptor/cache.js

@@ -1,30 +1,35 @@
 import assert from 'node:assert'
 import { LRUCache } from 'lru-cache'
-import { findHeader, parseCacheControl } from '../utils.js'
+import { parseHeaders, parseCacheControl } from '../utils.js'
+import { DecoratorHandler } from 'undici'
+
+class CacheHandler extends DecoratorHandler {
+  #handler
+  #store
+  #key
+  #value
 
-class CacheHandler {
   constructor({ key, handler, store }) {
-    this.key = key
-    this.handler = handler
-    this.store = store
-    this.value = null
+    super(handler)
+
+    this.#key = key
+    this.#handler = handler
+    this.#store = store
   }
 
   onConnect(abort) {
-    return this.handler.onConnect(abort)
-  }
+    this.#value = null
 
-  onUpgrade(statusCode, rawHeaders, socket, headers) {
-    return this.handler.onUpgrade(statusCode, rawHeaders, socket, headers)
+    return this.#handler.onConnect(abort)
   }
 
-  onHeaders(statusCode, rawHeaders, resume, statusMessage, headers) {
+  onHeaders(statusCode, rawHeaders, resume, statusMessage, headers = parseHeaders(rawHeaders)) {
     // NOTE: Only cache 307 respones for now...
     if (statusCode !== 307) {
-      return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage, headers)
+      return this.#handler.onHeaders(statusCode, rawHeaders, resume, statusMessage, headers)
     }
 
-    const cacheControl = parseCacheControl(findHeader(rawHeaders, 'cache-control'))
+    const cacheControl = parseCacheControl(headers['cache-control'])
 
     if (
       cacheControl &&
@@ -44,7 +49,7 @@ class CacheHandler {
         : Number(maxAge)
 
       if (ttl > 0) {
-        this.value = {
+        this.#value = {
           statusCode,
           statusMessage,
           rawHeaders,
@@ -56,31 +61,27 @@ class CacheHandler {
       }
     }
 
-    return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage, headers)
+    return this.#handler.onHeaders(statusCode, rawHeaders, resume, statusMessage, headers)
   }
 
   onData(chunk) {
-    if (this.value) {
-      this.value.size += chunk.bodyLength
-      if (this.value.size > this.store.maxEntrySize) {
-        this.value = null
+    if (this.#value) {
+      this.#value.size += chunk.bodyLength
+      if (this.#value.size > this.#store.maxEntrySize) {
+        this.#value = null
       } else {
-        this.value.body.push(chunk)
+        this.#value.body.push(chunk)
       }
     }
-    return this.handler.onData(chunk)
+    return this.#handler.onData(chunk)
   }
 
   onComplete(rawTrailers) {
-    if (this.value) {
-      this.value.rawTrailers = rawTrailers
-      this.store.set(this.key, this.value, this.value.ttl)
+    if (this.#value) {
+      this.#value.rawTrailers = rawTrailers
+      this.#store.set(this.#key, this.#value, this.#value.ttl)
     }
-    return this.handler.onComplete(rawTrailers)
-  }
-
-  onError(err) {
-    return this.handler.onError(err)
+    return this.#handler.onComplete(rawTrailers)
   }
 }
 

package/lib/interceptor/log.js

@@ -1,15 +1,24 @@
 import { performance } from 'node:perf_hooks'
 import { parseHeaders } from '../utils.js'
+import { DecoratorHandler } from 'undici'
+
+class Handler extends DecoratorHandler {
+  #handler
+  #opts
+  #abort
+  #aborted = false
+  #logger
+  #pos
+  #stats
 
-class Handler {
   constructor(opts, { handler }) {
-    this.handler = handler
-    this.opts = opts
-    this.abort = null
-    this.aborted = false
-    this.logger = opts.logger.child({ ureq: { id: opts.id } })
-    this.pos = 0
-    this.stats = {
+    super(handler)
+
+    this.#handler = handler
+    this.#opts = opts
+    this.#logger = opts.logger.child({ ureq: { id: opts.id } })
+    this.#stats = {
+      created: performance.now(),
       start: -1,
       end: -1,
       headers: -1,
@@ -19,89 +28,97 @@ class Handler {
   }
 
   onConnect(abort) {
-    this.abort = abort
-    this.stats.start = performance.now()
-    this.logger.debug({ ureq: this.opts }, 'upstream request started')
-
-    return this.handler.onConnect((reason) => {
-      this.aborted = true
-      this.abort(reason)
+    this.#pos = 0
+    this.#abort = abort
+    this.#stats.start = performance.now()
+    this.#stats.end = -1
+    this.#stats.headers = -1
+    this.#stats.firstBodyReceived = -1
+    this.#stats.lastBodyReceived = -1
+
+    this.#logger.debug({ ureq: this.#opts }, 'upstream request started')
+
+    return this.#handler.onConnect((reason) => {
+      this.#aborted = true
+      this.#abort(reason)
     })
   }
 
   onUpgrade(statusCode, rawHeaders, socket, headers) {
-    this.logger.debug('upstream request upgraded')
+    this.#logger.debug('upstream request upgraded')
     socket.on('close', () => {
-      this.logger.debug('upstream request socket closed')
+      this.#logger.debug('upstream request socket closed')
     })
 
-    return this.handler.onUpgrade(statusCode, rawHeaders, socket, headers)
+    return this.#handler.onUpgrade(statusCode, rawHeaders, socket, headers)
   }
 
   onHeaders(statusCode, rawHeaders, resume, statusMessage, headers = parseHeaders(rawHeaders)) {
-    this.stats.headers = performance.now() - this.stats.start
+    this.#stats.headers = performance.now() - this.#stats.start
 
-    this.logger.debug(
+    this.#logger.debug(
       {
         ures: { statusCode, headers },
-        elapsedTime: this.stats.headers,
+        elapsedTime: this.#stats.headers,
       },
       'upstream request response',
     )
 
-    return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage, headers)
+    return this.#handler.onHeaders(statusCode, rawHeaders, resume, statusMessage, headers)
   }
 
   onData(chunk) {
-    if (this.stats.firstBodyReceived === -1) {
-      this.stats.firstBodyReceived = performance.now() - this.stats.start
+    if (this.#stats.firstBodyReceived === -1) {
+      this.#stats.firstBodyReceived = performance.now() - this.#stats.start
     }
 
-    this.pos += chunk.length
+    this.#pos += chunk.length
 
-    return this.handler.onData(chunk)
+    return this.#handler.onData(chunk)
   }
 
   onComplete(rawTrailers) {
-    this.stats.lastBodyReceived = performance.now() - this.stats.start
-    this.stats.end = this.stats.lastBodyReceived
+    this.#stats.lastBodyReceived = performance.now() - this.#stats.start
+    this.#stats.end = this.#stats.lastBodyReceived
 
-    this.logger.debug(
-      { bytesRead: this.pos, elapsedTime: this.stats.end, stats: this.stats },
+    this.#logger.debug(
+      { bytesRead: this.#pos, elapsedTime: this.#stats.end, stats: this.#stats },
       'upstream request completed',
     )
 
-    return this.handler.onComplete(rawTrailers)
+    return this.#handler.onComplete(rawTrailers)
   }
 
   onError(err) {
-    this.stats.end = performance.now() - this.stats.start
+    if (this.#stats) {
+      this.#stats.end = performance.now() - this.#stats.start
+    }
 
-    if (this.aborted) {
-      this.logger.debug(
+    if (this.#aborted) {
+      this.#logger.debug(
         {
-          ureq: this.opts,
-          bytesRead: this.pos,
-          elapsedTime: this.stats.end,
-          stats: this.stats,
+          ureq: this.#opts,
+          bytesRead: this.#pos,
+          elapsedTime: this.#stats.end,
+          stats: this.#stats,
           err,
         },
         'upstream request aborted',
       )
     } else {
-      this.logger.error(
+      this.#logger.error(
         {
-          ureq: this.opts,
-          bytesRead: this.pos,
-          elapsedTime: this.stats.end,
-          stats: this.stats,
+          ureq: this.#opts,
+          bytesRead: this.#pos,
+          elapsedTime: this.#stats.end,
+          stats: this.#stats,
           err,
         },
         'upstream request failed',
       )
     }
 
-    return this.handler.onError(err)
+    return this.#handler.onError(err)
   }
 }
 

package/lib/interceptor/proxy.js

@@ -1,25 +1,27 @@
 import net from 'node:net'
 import createError from 'http-errors'
+import { DecoratorHandler } from 'undici'
 
-class Handler {
-  constructor(opts, { handler }) {
-    this.handler = handler
-    this.opts = opts
-  }
+class Handler extends DecoratorHandler {
+  #handler
+  #opts
+
+  constructor(proxyOpts, { handler }) {
+    super(handler)
 
-  onConnect(abort) {
-    return this.handler.onConnect(abort)
+    this.#handler = handler
+    this.#opts = proxyOpts
   }
 
   onUpgrade(statusCode, rawHeaders, socket) {
-    return this.handler.onUpgrade(
+    return this.#handler.onUpgrade(
       statusCode,
       reduceHeaders(
         {
           headers: rawHeaders,
-          httpVersion: this.opts.proxy.httpVersion ?? this.opts.proxy.req?.httpVersion,
+          httpVersion: this.#opts.httpVersion ?? this.#opts.req?.httpVersion,
           socket: null,
-          proxyName: this.opts.proxy.name,
+          proxyName: this.#opts.name,
         },
         (acc, key, val) => {
           acc.push(key, val)
@@ -32,14 +34,14 @@ class Handler {
   }
 
   onHeaders(statusCode, rawHeaders, resume, statusMessage) {
-    return this.handler.onHeaders(
+    return this.#handler.onHeaders(
       statusCode,
       reduceHeaders(
         {
           headers: rawHeaders,
-          httpVersion: this.opts.proxy.httpVersion ?? this.opts.proxy.req?.httpVersion,
+          httpVersion: this.#opts.httpVersion ?? this.#opts.req?.httpVersion,
           socket: null,
-          proxyName: this.opts.proxy.name,
+          proxyName: this.#opts.name,
         },
         (acc, key, val) => {
           acc.push(key, val)
@@ -51,18 +53,6 @@ class Handler {
       statusMessage,
     )
   }
-
-  onData(chunk) {
-    return this.handler.onData(chunk)
-  }
-
-  onComplete(rawTrailers) {
-    return this.handler.onComplete(rawTrailers)
-  }
-
-  onError(err) {
-    return this.handler.onError(err)
-  }
 }
 
 export default (dispatch) => (opts, handler) => {
@@ -84,9 +74,7 @@ export default (dispatch) => (opts, handler) => {
     {},
   )
 
-  opts = { ...opts, headers }
-
-  return dispatch(opts, new Handler(opts, { handler }))
+  return dispatch({ ...opts, headers }, new Handler(opts.proxy, { handler }))
 }
 
 // This expression matches hop-by-hop headers.

package/lib/interceptor/redirect.js

@@ -1,10 +1,13 @@
 import assert from 'node:assert'
 import { findHeader, isDisturbed, parseURL } from '../utils.js'
+import { DecoratorHandler } from 'undici'
 
 const redirectableStatusCodes = [300, 301, 302, 303, 307, 308]
 
-class Handler {
+class Handler extends DecoratorHandler {
   constructor(opts, { dispatch, handler }) {
+    super(handler)
+
     this.dispatch = dispatch
     this.handler = handler
     this.opts = opts

package/lib/interceptor/response-content.js

@@ -1,63 +1,80 @@
 import crypto from 'node:crypto'
-import { findHeader } from '../utils.js'
+import assert from 'node:assert'
+import { parseHeaders } from '../utils.js'
+import { DecoratorHandler } from 'undici'
+
+class Handler extends DecoratorHandler {
+  #handler
+
+  #contentMD5
+  #contentLength
+  #hasher
+  #pos
+  #errored
 
-class Handler {
   constructor(opts, { handler }) {
-    this.handler = handler
-    this.opts = opts
-    this.md5 = null
-    this.length = null
-    this.hasher = null
-    this.pos = 0
+    super(handler)
+
+    this.#handler = handler
   }
 
   onConnect(abort) {
-    return this.handler.onConnect(abort)
-  }
+    assert(!this.#pos)
 
-  onUpgrade(statusCode, rawHeaders, socket, headers) {
-    return this.handler.onUpgrade(statusCode, rawHeaders, socket, headers)
+    this.#contentMD5 = null
+    this.#contentLength = null
+    this.#hasher = null
+    this.#pos = 0
+    this.#errored = false
+
+    this.#handler.onConnect(abort)
   }
 
-  onHeaders(statusCode, rawHeaders, resume, statusMessage, headers) {
-    this.md5 = headers ? headers['content-md5'] : findHeader(rawHeaders, 'content-md5')
-    this.length = headers ? headers['content-length'] : findHeader(rawHeaders, 'content-length')
-    this.hasher = this.md5 != null ? crypto.createHash('md5') : null
+  onHeaders(statusCode, rawHeaders, resume, statusMessage, headers = parseHeaders(rawHeaders)) {
+    this.#contentMD5 = headers ? headers['content-md5'] : headers['content-md5']
+    this.#contentLength = headers ? headers['content-length'] : headers['content-length']
+    this.#hasher = this.#contentMD5 != null ? crypto.createHash('md5') : null
 
-    return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage, headers)
+    return this.#handler.onHeaders(statusCode, rawHeaders, resume, statusMessage, headers)
   }
 
   onData(chunk) {
-    this.pos += chunk.length
-    this.hasher?.update(chunk)
+    this.#pos += chunk.length
+    this.#hasher?.update(chunk)
 
-    return this.handler.onData(chunk)
+    return this.#handler.onData(chunk)
   }
 
   onComplete(rawTrailers) {
-    const hash = this.hasher?.digest('base64')
+    const contentMD5 = this.#hasher?.digest('base64')
 
-    if (this.length != null && this.pos !== Number(this.length)) {
-      return this.handler.onError(
+    if (this.#contentLength != null && this.#pos !== Number(this.#contentLength)) {
+      this.#errored = true
+      this.#handler.onError(
         Object.assign(new Error('Request Content-Length mismatch'), {
-          expected: Number(this.length),
-          actual: this.pos,
+          expected: Number(this.#contentLength),
+          actual: this.#pos,
         }),
       )
-    } else if (this.md5 != null && hash !== this.md5) {
-      return this.handler.onError(
+    } else if (this.#contentMD5 != null && contentMD5 !== this.#contentMD5) {
+      this.#errored = true
+      this.#handler.onError(
         Object.assign(new Error('Request Content-MD5 mismatch'), {
-          expected: this.md5,
-          actual: hash,
+          expected: this.#contentMD5,
+          actual: contentMD5,
         }),
       )
     } else {
-      return this.handler.onComplete(rawTrailers)
+      return this.#handler.onComplete(rawTrailers)
     }
   }
 
   onError(err) {
-    this.handler.onError(err)
+    if (this.#errored) {
+      // Do nothing...
+    } else {
+      this.#handler.onError(err)
+    }
   }
 }
 

package/lib/interceptor/response-error.js

@@ -1,106 +1,89 @@
-import { findHeader, parseHeaders } from '../utils.js'
+import { parseHeaders } from '../utils.js'
 import createHttpError from 'http-errors'
+import { DecoratorHandler } from 'undici'
 
-class Handler {
-  handler
-  opts
+class Handler extends DecoratorHandler {
+  #handler
 
-  statusCode
-  contentType
-  decoder
-  headers
-  body
+  #statusCode
+  #contentType
+  #decoder
+  #headers
+  #body
+  #errored
 
   constructor(opts, { handler }) {
-    this.handler = handler
-    this.opts = opts
-  }
-
-  onConnect(abort) {
-    this.statusCode = 0
-    this.contentType = null
-    this.decoder = null
-    this.headers = null
-    this.body = null
+    super(handler)
 
-    return this.handler.onConnect(abort)
+    this.#handler = handler
   }
 
-  onUpgrade(statusCode, rawHeaders, socket, headers) {
-    return this.handler.onUpgrade(statusCode, rawHeaders, socket, headers)
+  onConnect(abort) {
+    this.#statusCode = 0
+    this.#contentType = null
+    this.#decoder = null
+    this.#headers = null
+    this.#body = ''
+    this.#errored = false
+
+    return this.#handler.onConnect(abort)
   }
 
   onHeaders(statusCode, rawHeaders, resume, statusMessage, headers = parseHeaders(rawHeaders)) {
-    if (statusCode >= 400) {
-      this.statusCode = statusCode
-      this.headers = headers
-      this.contentType = headers ? headers['content-type'] : findHeader(rawHeaders, 'content-type')
-      if (this.contentType === 'application/json' || this.contentType === 'text/plain') {
-        this.decoder = new TextDecoder('utf-8')
-        this.body = ''
+    this.#statusCode = statusCode
+    this.#headers = headers
+    this.#contentType = headers['content-type']
+
+    if (this.#statusCode >= 400) {
+      // TODO (fix): Check content length
+      if (this.#contentType === 'application/json' || this.#contentType === 'text/plain') {
+        this.#decoder = new TextDecoder('utf-8')
       }
     } else {
-      return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage, headers)
+      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
+    if (this.#statusCode >= 400) {
+      this.#body += this.#decoder?.decode(chunk, { stream: true }) ?? ''
     } else {
-      return this.handler.onData(chunk)
+      return this.#handler.onData(chunk)
     }
   }
 
   onComplete(rawTrailers) {
-    this.onFinally(null, rawTrailers)
-  }
-
-  onError(err) {
-    this.onFinally(err, null)
-  }
-
-  onFinally(err, rawTrailers) {
-    if (this.statusCode >= 400) {
-      if (this.decoder != null) {
-        this.body += this.decoder.decode(undefined, { stream: false })
-        if (this.contentType === 'application/json') {
-          try {
-            this.body = JSON.parse(this.body)
-          } catch {
-            // Do nothing...
-          }
+    if (this.#statusCode >= 400) {
+      this.#body += this.#decoder?.decode(undefined, { stream: false }) ?? ''
+
+      if (this.#contentType === 'application/json') {
+        try {
+          this.#body = JSON.parse(this.#body)
+        } catch {
+          // Do nothing...
         }
       }
 
-      err = createHttpError(this.statusCode)
-
-      this.decoder = null
-      this.contentType = null
-      this.body = null
-    }
-
-    if (err) {
-      this.handler.onError(
-        Object.assign(err, {
-          ureq: {
-            origin: this.opts.origin,
-            path: this.opts.path,
-            method: this.opts.method,
-            headers: this.opts.headers,
-          },
-          ures: { statusCode: this.statusCode, headers: this.headers, body: this.body },
+      this.#errored = true
+      this.#handler.onError(
+        Object.assign(createHttpError(this.#statusCode), {
+          reason: this.#body?.reason,
+          error: this.#body?.error,
+          headers: this.#headers,
+          body: this.#body,
         }),
       )
     } else {
-      this.handler.onComplete(rawTrailers)
+      this.#handler.onComplete(rawTrailers)
     }
+  }
 
-    this.handler = null
+  onError(err) {
+    if (this.#errored) {
+      // Do nothing...
+    } else {
+      this.#handler.onError(err)
+    }
   }
 }
 

package/lib/interceptor/response-retry.js

@@ -1,121 +1,220 @@
 import assert from 'node:assert'
-import { isDisturbed, retry as retryFn } from '../utils.js'
-
-class Handler {
-  constructor(opts, { dispatch, handler }) {
-    this.dispatch = dispatch
-    this.handler = handler
-    this.opts = opts
-
-    this.headersSent = false
-    this.count = 0
-
-    this.reason = null
-    this.aborted = false
-
-    this.statusCode = null
-    this.rawHeaders = null
-    this.resume = null
-    this.statusMessage = null
-    this.headers = null
-
-    this.handler.onConnect((reason) => {
-      this.aborted = true
-      if (this.abort) {
-        this.abort(reason)
-      } else {
-        this.reason = reason
-      }
-    })
+import { isDisturbed, parseHeaders, parseRangeHeader, retry as retryFn } from '../utils.js'
+import { DecoratorHandler } from 'undici'
+
+// TODO (fix): What about onUpgrade?
+class Handler extends DecoratorHandler {
+  #handler
+  #dispatch
+  #opts
+
+  #retryCount = 0
+  #headersSent = false
+  #errorSent = false
+
+  #abort
+  #aborted = false
+  #reason = null
+
+  #pos
+  #end
+  #etag
+  #error
+
+  constructor(opts, { handler, dispatch }) {
+    super(handler)
+
+    this.#handler = handler
+    this.#dispatch = dispatch
+    this.#opts = opts
   }
 
   onConnect(abort) {
-    if (this.aborted) {
-      abort(this.reason)
+    if (!this.#headersSent) {
+      this.#pos = null
+      this.#end = null
+      this.#etag = null
+      this.#error = null
+
+      this.#handler.onConnect((reason) => {
+        if (!this.#aborted) {
+          this.#aborted = true
+          if (this.#abort) {
+            this.#abort(reason)
+          } else {
+            this.#reason = reason
+          }
+        }
+      })
+    }
+
+    if (this.#aborted) {
+      abort(this.#reason)
     } else {
-      this.abort = abort
+      this.#abort = abort
     }
   }
 
-  onUpgrade(statusCode, rawHeaders, socket, headers) {
-    return this.handler.onUpgrade(statusCode, rawHeaders, socket, headers)
-  }
+  onHeaders(statusCode, rawHeaders, resume, statusMessage, headers = parseHeaders(rawHeaders)) {
+    if (this.#error == null) {
+      assert(this.#etag == null)
+      assert(this.#pos == null)
+      assert(this.#end == null)
+      assert(this.#headersSent === false)
 
-  onHeaders(statusCode, rawHeaders, resume, statusMessage, headers) {
-    assert(!this.headersSent)
+      if (headers.trailer) {
+        return this.#onHeaders(statusCode, rawHeaders, resume, statusMessage, headers)
+      }
 
-    this.statusCode = statusCode
-    this.rawHeaders = rawHeaders
-    this.resume = resume
-    this.statusMessage = statusMessage
-    this.headers = headers
+      const contentLength = headers['content-length'] ? Number(headers['content-length']) : null
+      if (contentLength != null && !Number.isFinite(contentLength)) {
+        return this.#onHeaders(statusCode, rawHeaders, resume, statusMessage, headers)
+      }
 
-    return true
-  }
+      if (statusCode === 206) {
+        const range = parseRangeHeader(headers['content-range'])
+        if (!range) {
+          return this.#onHeaders(statusCode, rawHeaders, resume, statusMessage, headers)
+        }
 
-  onData(chunk) {
-    if (!this.headersSent) {
-      this.sendHeaders()
-    }
+        const { start, size, end = size } = range
+
+        assert(start != null && Number.isFinite(start), 'content-range mismatch')
+        assert(end != null && Number.isFinite(end), 'invalid content-length')
+        assert(
+          contentLength == null || end == null || contentLength === end + 1 - start,
+          'content-range mismatch',
+        )
+
+        this.#pos = start
+        this.#end = end ?? contentLength
+        this.#etag = headers.etag
+      } else if (statusCode === 200) {
+        this.#pos = 0
+        this.#end = contentLength
+        this.#etag = headers.etag
+      } else {
+        return this.#onHeaders(statusCode, rawHeaders, resume, statusMessage, headers)
+      }
 
-    return this.handler.onData(chunk)
-  }
+      assert(Number.isFinite(this.#pos))
+      assert(this.#end == null || Number.isFinite(this.#end))
+
+      return this.#onHeaders(statusCode, rawHeaders, resume, statusMessage, headers)
+    } else if (statusCode === 206 || (this.#pos === 0 && statusCode === 200)) {
+      assert(this.#etag != null || !this.#pos)
+
+      const etag = headers.etag
+      if (this.#pos > 0 && this.#etag !== etag) {
+        throw this.#error
+      }
 
-  onComplete(rawTrailers) {
-    if (!this.headersSent) {
-      this.sendHeaders()
+      const contentRange = parseRangeHeader(headers['content-range'])
+      if (!contentRange) {
+        throw this.#error
+      }
+
+      const { start, size, end = size } = contentRange
+      assert(this.#pos === start, 'content-range mismatch')
+      assert(this.#end == null || this.#end === end, 'content-range mismatch')
+
+      // TODO (fix): What if we were paused before the error?
+      return true
+    } else {
+      throw this.#error
     }
+  }
 
-    return this.handler.onComplete(rawTrailers)
+  onData(chunk) {
+    if (this.#pos != null) {
+      this.#pos += chunk.byteLength
+    }
+    return this.#handler.onData(chunk)
   }
 
   onError(err) {
-    if (this.aborted || this.headersSent || isDisturbed(this.opts.body)) {
-      return this.handler.onError(err)
+    if (this.#aborted || isDisturbed(this.#opts.body) || (this.#pos && !this.#etag)) {
+      this.#onError(err)
+      return
     }
 
-    const retryPromise = retryFn(err, this.count++, this.opts)
+    const retryPromise = retryFn(err, this.#retryCount++, this.#opts)
     if (retryPromise == null) {
-      return this.handler.onError(err)
+      this.#onError(err)
+      return
     }
 
-    this.opts.logger?.debug({ retryCount: this.count }, 'retrying response')
+    this.#error = err
 
     retryPromise
       .then(() => {
-        if (!this.aborted) {
-          this.dispatch(this.opts, this)
+        if (this.#aborted) {
+          this.#onError(this.#reason)
+        } else if (isDisturbed(this.#opts.body)) {
+          this.#onError(this.#error)
+        } else if (!this.#headersSent) {
+          this.#opts.logger?.debug({ retryCount: this.#retryCount }, 'retry response headers')
+          this.#dispatch(this.#opts, this)
+        } else {
+          assert(Number.isFinite(this.#pos))
+          assert(this.#end == null || Number.isFinite(this.#end))
+
+          this.#opts = {
+            ...this.#opts,
+            headers: {
+              ...this.#opts.headers,
+              'if-match': this.#etag,
+              range: `bytes=${this.#pos}-${this.#end ?? ''}`,
+            },
+          }
+
+          this.#opts.logger?.debug({ retryCount: this.#retryCount }, 'retry response body')
+          this.#dispatch(this.#opts, this)
         }
       })
       .catch((err) => {
-        if (!this.aborted) {
-          this.handler.onError(err)
+        if (!this.#errorSent) {
+          this.#onError(err)
         }
       })
   }
 
-  sendHeaders() {
-    assert(!this.headersSent)
-
-    this.headersSent = true
-    this.handler.onHeaders(
-      this.statusCode,
-      this.rawHeaders,
-      this.resume,
-      this.statusMessage,
-      this.headers,
-    )
-
-    this.statusCode = null
-    this.rawHeaders = null
-    this.resume = null
-    this.statusMessage = null
-    this.headers = null
+  #onError(err) {
+    assert(!this.#errorSent)
+    this.#errorSent = true
+    this.#handler.onError(err)
+  }
+
+  #onHeaders(...args) {
+    assert(!this.#headersSent)
+    this.#headersSent = true
+    return this.#handler.onHeaders(...args)
   }
 }
 
 export default (dispatch) => (opts, handler) => {
-  return opts.retry
+  return opts.idempotent && opts.retry && opts.method === 'GET' && !opts.upgrade
     ? dispatch(opts, new Handler(opts, { handler, dispatch }))
     : dispatch(opts, handler)
 }
+
+export function isConnectionError(err) {
+  // AWS compat.
+  const statusCode = err?.statusCode ?? err?.$metadata?.httpStatusCode
+  return err
+    ? err.code === 'ECONNRESET' ||
+        err.code === 'ECONNREFUSED' ||
+        err.code === 'ENOTFOUND' ||
+        err.code === 'ENETDOWN' ||
+        err.code === 'ENETUNREACH' ||
+        err.code === 'EHOSTDOWN' ||
+        err.code === 'EHOSTUNREACH' ||
+        err.code === 'EPIPE' ||
+        err.message === 'other side closed' ||
+        statusCode === 420 ||
+        statusCode === 429 ||
+        statusCode === 502 ||
+        statusCode === 503 ||
+        statusCode === 504
+    : false
+}

package/lib/utils.js

@@ -6,6 +6,21 @@ export function parseCacheControl(str) {
   return str ? cacheControlParser.parse(str) : null
 }
 
+// Parsed accordingly to RFC 9110
+// https://www.rfc-editor.org/rfc/rfc9110#field.content-range
+export function parseRangeHeader(range) {
+  if (range == null || range === '') return { start: 0, end: null, size: null }
+
+  const m = range ? range.match(/^bytes (\d+)-(\d+)\/(\d+)?$/) : null
+  return m
+    ? {
+        start: parseInt(m[1]),
+        end: m[2] ? parseInt(m[2]) : null,
+        size: m[3] ? parseInt(m[3]) : null,
+      }
+    : null
+}
+
 export function isDisturbed(body) {
   if (
     body == null ||
@@ -78,12 +93,20 @@ export function findHeader(headers, name) {
 }
 
 export function retry(err, retryCount, opts) {
-  if (opts.retry === null || opts.retry === false) {
+  if (!opts.retry) {
     return null
   }
 
   if (typeof opts.retry === 'function') {
-    return opts.retry(err, retryCount, opts)
+    try {
+      return opts.retry(err, retryCount, opts)
+    } catch (err) {
+      return Promise.reject(err)
+    }
+  }
+
+  if (typeof opts.retry === 'number') {
+    opts = { count: opts.retry }
   }
 
   const retryMax = opts.retry?.count ?? opts.maxRetries ?? 8
@@ -92,8 +115,10 @@ export function retry(err, retryCount, opts) {
     return null
   }
 
-  if (err.statusCode && [420, 429, 502, 503, 504].includes(err.statusCode)) {
-    let retryAfter = err.headers['retry-after'] ? err.headers['retry-after'] * 1e3 : null
+  const statusCode = err.statusCode ?? err.status ?? err.$metadata?.httpStatusCode ?? null
+
+  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 })
@@ -199,7 +224,7 @@ export function parseOrigin(url) {
 }
 
 export function parseHeaders(headers, obj = {}) {
-  return util.parseHeaders(headers, obj)
+  return Array.isArray(headers) ? util.parseHeaders(headers, obj) : headers
 }
 
 export class AbortError extends Error {

package/package.json

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

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

@@ -1,193 +0,0 @@
-import assert from 'node:assert'
-import { parseContentRange, isDisturbed, findHeader, retry as retryFn } from '../utils.js'
-
-class Handler {
-  constructor(opts, { dispatch, handler }) {
-    this.dispatch = dispatch
-    this.handler = handler
-    this.opts = opts
-
-    this.count = 0
-    this.pos = 0
-    this.end = null
-    this.error = null
-    this.etag = null
-
-    this.headersSent = false
-
-    this.reason = null
-    this.aborted = false
-
-    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, headers) {
-    return this.handler.onUpgrade(statusCode, rawHeaders, socket, headers)
-  }
-
-  onHeaders(statusCode, rawHeaders, resume, statusMessage, headers) {
-    const etag = headers ? headers.etag : findHeader(rawHeaders, 'etag')
-
-    if (this.resume) {
-      this.resume = null
-
-      // TODO (fix): Support other statusCode with skip?
-      if (statusCode !== 206) {
-        throw this.error
-      }
-
-      // TODO (fix): strict vs weak etag?
-      if (this.etag == null || this.etag !== etag) {
-        throw this.error
-      }
-
-      const contentRange = parseContentRange(
-        headers ? headers['content-range'] : findHeader(rawHeaders, 'content-range'),
-      )
-      if (!contentRange) {
-        throw this.error
-      }
-
-      const { start, size, end = size } = contentRange
-
-      assert(this.pos === start, 'content-range mismatch')
-      assert(this.end == null || this.end === end, 'content-range mismatch')
-
-      this.resume = resume
-      return true
-    }
-
-    if (this.end == null) {
-      if (statusCode === 206) {
-        const contentRange = parseContentRange(
-          headers ? headers['content-range'] : findHeader(rawHeaders, 'content-range'),
-        )
-        if (!contentRange) {
-          assert(!this.headersSent)
-          this.headersSent = true
-          return this.handler.onHeaders(
-            statusCode,
-            rawHeaders,
-            () => this.resume(),
-            statusMessage,
-            headers,
-          )
-        }
-
-        const { start, size, end = size } = contentRange
-
-        this.end = end
-        this.pos = Number(start)
-      } else {
-        const contentLength = headers
-          ? headers['content-length']
-          : findHeader(rawHeaders, 'content-length')
-        if (contentLength) {
-          this.end = Number(contentLength)
-        }
-      }
-
-      assert(Number.isFinite(this.pos))
-      assert(this.end == null || Number.isFinite(this.end), 'invalid content-length')
-    }
-
-    this.etag = etag
-    this.resume = resume
-
-    assert(!this.headersSent)
-    this.headersSent = true
-    return this.handler.onHeaders(
-      statusCode,
-      rawHeaders,
-      () => this.resume(),
-      statusMessage,
-      headers,
-    )
-  }
-
-  onData(chunk) {
-    this.pos += chunk.length
-    this.count = 0
-    return this.handler.onData(chunk)
-  }
-
-  onComplete(rawTrailers) {
-    return this.handler.onComplete(rawTrailers)
-  }
-
-  onError(err) {
-    if (this.aborted || !this.etag || isDisturbed(this.opts.body)) {
-      return this.handler.onError(err)
-    }
-
-    const retryPromise = retryFn(err, this.count++, this.opts)
-    if (retryPromise == null) {
-      return this.handler.onError(err)
-    }
-
-    this.error = err
-    this.opts = {
-      ...this.opts,
-      headers: {
-        ...this.opts.headers,
-        'if-match': this.etag,
-        range: `bytes=${this.pos}-${this.end ?? ''}`,
-      },
-    }
-
-    this.opts.logger?.debug({ retryCount: this.count }, 'retrying response body')
-
-    retryPromise
-      .then(() => {
-        if (!this.aborted) {
-          this.dispatch(this.opts, this)
-        }
-      })
-      .catch((err) => {
-        if (!this.aborted) {
-          this.handler.onError(err)
-        }
-      })
-  }
-}
-
-export default (dispatch) => (opts, handler) => {
-  return opts.idempotent && opts.retry && opts.method === 'GET' && !opts.upgrade
-    ? dispatch(opts, new Handler(opts, { handler, dispatch }))
-    : dispatch(opts, handler)
-}
-export function isConnectionError(err) {
-  // AWS compat.
-  const statusCode = err?.statusCode ?? err?.$metadata?.httpStatusCode
-  return err
-    ? err.code === 'ECONNRESET' ||
-        err.code === 'ECONNREFUSED' ||
-        err.code === 'ENOTFOUND' ||
-        err.code === 'ENETDOWN' ||
-        err.code === 'ENETUNREACH' ||
-        err.code === 'EHOSTDOWN' ||
-        err.code === 'EHOSTUNREACH' ||
-        err.code === 'EPIPE' ||
-        err.message === 'other side closed' ||
-        statusCode === 420 ||
-        statusCode === 429 ||
-        statusCode === 502 ||
-        statusCode === 503 ||
-        statusCode === 504
-    : false
-}