@nxtedition/nxt-undici 2.0.14 → 2.0.16

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,6 +73,11 @@ 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)
   }
 
@@ -127,16 +134,14 @@ 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,
   proxy: (await import('./interceptor/proxy.js')).default,
   cache: (await import('./interceptor/cache.js')).default,
   requestId: (await import('./interceptor/request-id.js')).default,
@@ -222,23 +227,21 @@ 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.responseContent(dispatch)
     dispatch = dispatchers.requestContent(dispatch)
     dispatch = dispatchers.redirect(dispatch)
-    dispatch = dispatchers.signal(dispatch)
     dispatch = dispatchers.cache(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(),
@@ -253,7 +256,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,10 +268,26 @@ 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)
@@ -283,14 +301,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,15 +326,21 @@ export async function request(url, opts) {
           this.resolve = null
           this.reject = null
 
-          return false
+          return true
         },
         onData(chunk) {
           return this.body.push(chunk)
         },
         onComplete() {
+          this.signal?.removeEventListener('abort', this.onAbort)
+          this.signal = null
+
           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 +352,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 }) {
@@ -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

@@ -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

@@ -4,16 +4,34 @@ import { findHeader, isDisturbed, parseURL } from '../utils.js'
 const redirectableStatusCodes = [300, 301, 302, 303, 307, 308]
 
 class Handler {
-  constructor(opts, { dispatch, handler, count = 0 }) {
+  constructor(opts, { dispatch, handler }) {
     this.dispatch = dispatch
     this.handler = handler
     this.opts = opts
-    this.redirectOpts = null
-    this.count = count
+    this.abort = null
+    this.aborted = false
+    this.reason = null
+    this.maxCount = Number.isFinite(opts.follow) ? opts.follow : opts.follow?.count ?? 0
+
+    this.count = 0
+    this.location = null
+
+    this.handler.onConnect((reason) => {
+      this.aborted = true
+      if (this.abort) {
+        this.abort(reason)
+      } else {
+        this.reason = reason
+      }
+    })
   }
 
   onConnect(abort) {
-    return this.handler.onConnect(abort)
+    if (this.aborted) {
+      abort(this.reason)
+    } else {
+      this.abort = abort
+    }
   }
 
   onUpgrade(statusCode, headers, socket) {
@@ -28,47 +46,42 @@ 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)
     }
 
-    const location = findHeader(headers, 'location')
+    if (isDisturbed(this.opts.body)) {
+      throw new Error(`Disturbed request cannot be redirected.`)
+    }
+
+    this.location = findHeader(rawHeaders, 'location')
 
-    if (!location) {
-      // TODO (perf): Consume body?
+    if (!this.location) {
       throw new Error(`Missing redirection location .`)
     }
 
     this.count += 1
 
-    // TODO (feat): follow as function...
-
-    const maxCount = Number.isFinite(this.opts.follow)
-      ? this.opts.follow
-      : Number.isFinite(this.opts.follow?.count)
-        ? this.opts.follow?.count
-        : 0
-
-    if (this.count >= maxCount) {
-      // TODO (perf): Consume body?
-      throw new Error(`Max redirections reached: ${maxCount}.`)
-    }
-
-    if (isDisturbed(this.opts.body)) {
-      // TODO (perf): Consume body?
-      throw new Error(`Disturbed request cannot be redirected.`)
+    if (typeof this.opts.follow === 'function') {
+      if (!this.opts.follow(this.location, this.count)) {
+        return this.handler.onHeaders(statusCode, rawHeaders, resume, statusText, headers)
+      }
+    } else {
+      if (this.count >= this.maxCount) {
+        throw new Error(`Max redirections reached: ${this.maxCount}.`)
+      }
     }
 
     const { origin, pathname, search } = parseURL(
-      new URL(location, this.opts.origin && new URL(this.opts.path, this.opts.origin)),
+      new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin)),
     )
     const path = search ? `${pathname}${search}` : pathname
 
     // Remove headers referring to the original URL.
     // By default it is Host only, unless it's a 303 (see below), which removes also all Content-* headers.
     // https://tools.ietf.org/html/rfc7231#section-6.4
-    this.redirectOpts = {
+    this.opts = {
       ...this.opts,
       headers: cleanRequestHeaders(
         this.opts.headers,
@@ -77,17 +90,18 @@ class Handler {
       ),
       path,
       origin,
+      query: null,
     }
 
     // https://tools.ietf.org/html/rfc7231#section-6.4.4
     // In case of HTTP 303, always replace method to be either HEAD or GET
-    if (statusCode === 303 && this.redirectOpts.method !== 'HEAD') {
-      this.redirectOpts = { ...this.redirectOpts, method: 'GET', body: null }
+    if (statusCode === 303 && this.opts.method !== 'HEAD') {
+      this.opts = { ...this.opts, method: 'GET', body: null }
     }
   }
 
   onData(chunk) {
-    if (this.redirectOpts) {
+    if (this.location) {
       /*
         https://tools.ietf.org/html/rfc7231#section-6.4
 
@@ -111,7 +125,7 @@ class Handler {
   }
 
   onComplete(trailers) {
-    if (this.redirectOpts) {
+    if (this.location) {
       /*
         https://tools.ietf.org/html/rfc7231#section-6.4
 
@@ -120,15 +134,10 @@ class Handler {
 
         See comment on onData method above for more detailed informations.
       */
-      this.dispatch(
-        this.redirectOpts,
-        new Handler(this.redirectOpts, {
-          handler: this.handler,
-          dispatch: this.dispatch,
-          count: this.count,
-        }),
-      )
-      this.handler = null
+
+      this.location = null
+
+      this.dispatch(this.opts, this)
     } else {
       return this.handler.onComplete(trailers)
     }
@@ -169,5 +178,5 @@ function cleanRequestHeaders(headers, removeContent, unknownOrigin) {
 
 export default (dispatch) => (opts, handler) =>
   opts.follow != null
-    ? dispatch(opts, new Handler(opts, { handler, dispatch, count: 0 }))
+    ? dispatch(opts, new Handler(opts, { handler, dispatch }))
     : dispatch(opts, handler)

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

@@ -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

@@ -51,8 +51,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/response-content.js

@@ -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,89 @@
+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) {
+    return this.handler.onUpgrade(statusCode, rawHeaders, socket)
+  }
+
+  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) {
+      const stackTraceLimit = Error.stackTraceLimit
+      Error.stackTraceLimit = 0
+      try {
+        if (this.decoder != null) {
+          this.body += this.decoder.decode(undefined, { stream: false })
+          if (this.contentType === 'application/json') {
+            this.body = JSON.parse(this.body)
+          }
+        }
+        this.handler.onError(
+          createHttpError(this.statusCode, { headers: this.headers, body: this.body }),
+        )
+      } finally {
+        Error.stackTraceLimit = stackTraceLimit
+      }
+    } else if (err) {
+      this.handler.onError(err)
+    } else {
+      this.handler.onComplete(rawTrailers)
+    }
+  }
+}
+
+export default (dispatch) => (opts, handler) => dispatch(opts, new Handler(opts, { handler }))

package/lib/interceptor/response-retry.js

@@ -1,34 +1,27 @@
-import { isDisturbed, retry as retryFn } from '../utils.js'
+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.abort = null
-    this.aborted = false
-    this.reason = null
-    this.statusCode = 0
-
-    this.retryCount = 0
-    this.retryPromise = null
 
-    this.handler.onConnect((reason) => {
-      this.aborted = true
-      if (this.abort) {
-        this.abort(reason)
-      } else {
-        this.reason = reason
-      }
-    })
+    this.hasBody = false
+    this.aborted = false
+    this.count = 0
+    this.pos = 0
+    this.end = null
+    this.error = null
+    this.etag = null
   }
 
   onConnect(abort) {
-    if (this.aborted) {
-      abort(this.reason)
-    } else {
-      this.abort = abort
-    }
+    this.aborted = false
+    return this.handler.onConnect((reason) => {
+      this.aborted = true
+      abort(reason)
+    })
   }
 
   onUpgrade(statusCode, rawHeaders, socket) {
@@ -43,12 +36,81 @@ 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) {
+    const 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(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(findHeader(rawHeaders, 'content-range'))
+        if (!contentRange) {
+          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 = 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
+
+    return this.handler.onHeaders(
+      statusCode,
+      rawHeaders,
+      () => this.resume(),
+      statusMessage,
+      headers,
+    )
   }
 
   onData(chunk) {
+    this.pos += chunk.length
+    this.count = 0
+    this.hasBody = true
+
     return this.handler.onData(chunk)
   }
 
@@ -57,23 +119,34 @@ class Handler {
   }
 
   onError(err) {
-    if (this.aborted || this.statusCode || isDisturbed(this.opts.body)) {
+    if (this.aborted || (this.hasBody && !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)
     }
 
+    this.error = err
+
+    if (this.hasBody) {
+      this.opts = {
+        ...this.opts,
+        headers: {
+          ...this.opts.headers,
+          'if-match': this.etag,
+          range: `bytes=${this.pos}-${this.end ?? ''}`,
+        },
+      }
+    }
+
+    this.opts.logger?.debug('retrying response body')
+
     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 +154,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.idempotent && opts.retry && opts.method === 'GET' && !opts.upgrade
     ? 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 (
@@ -50,10 +65,11 @@ export function findHeader(rawHeaders, name) {
 
   for (let i = 0; i < rawHeaders.length; i += 2) {
     const key = rawHeaders[i + 0]
-    if (key.length === len && key.toString().toLowerCase() === name) {
+    if (key.length === len && toLowerCase(key.toString()) === name) {
       return rawHeaders[i + 1].toString()
     }
   }
+
   return null
 }
 
@@ -178,18 +194,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.14",
+  "version": "2.0.16",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "main": "lib/index.js",

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

@@ -1,162 +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.abort = null
-    this.aborted = false
-    this.reason = null
-
-    this.retryCount = 0
-    this.retryPromise = null
-
-    this.pos = 0
-    this.end = null
-    this.error = null
-    this.etag = 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) {
-    const 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(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(findHeader(rawHeaders, 'content-range'))
-        if (!contentRange) {
-          return this.handler.onHeaders(statusCode, rawHeaders, () => this.resume(), statusMessage)
-        }
-
-        const { start, size, end = size } = contentRange
-
-        this.end = end
-        this.pos = Number(start)
-      } else {
-        const contentLength = 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
-    return this.handler.onHeaders(statusCode, rawHeaders, () => this.resume(), statusMessage)
-  }
-
-  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.resume || this.aborted || !this.etag || isDisturbed(this.opts.body)) {
-      return this.handler.onError(err)
-    }
-
-    const retryPromise = retryFn(err, this.retryCount++, 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,
-      headers: {
-        ...this.opts.headers,
-        'if-match': this.etag,
-        range: `bytes=${this.pos}-${this.end ?? ''}`,
-      },
-    }
-
-    this.opts.logger?.debug('retrying response body')
-  }
-}
-
-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)
-}

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)