@nxtedition/nxt-undici 2.0.46 → 2.0.48

package/lib/index.js

@@ -1,8 +1,8 @@
 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 { parseHeaders, AbortError, headerNameToString, isStream } from './utils.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,
@@ -62,17 +61,18 @@ export async function request(url, opts) {
   const method = opts.method ?? (opts.body ? 'POST' : 'GET')
   const idempotent = opts.idempotent ?? (method === 'GET' || method === 'HEAD')
 
-  let headers
+  let headers = {}
   if (Array.isArray(opts.headers)) {
     headers = parseHeaders(opts.headers)
   } else if (opts.headers != null) {
-    // TODO (fix): Object.values(opts.headers)?
-    headers = opts.headers
+    for (const [key, val] of Object.entries(opts.headers)) {
+      headers[headerNameToString(key)] = val
+    }
   }
 
   const userAgent = opts.userAgent ?? globalThis.userAgent
   if (userAgent && headers?.['user-agent'] !== userAgent) {
-    headers = { 'user-agent': userAgent, ...headers }
+    headers['user-agent'] = userAgent
   }
 
   if (method === 'CONNECT') {
@@ -87,6 +87,14 @@ export async function request(url, opts) {
     throw new createError.BadRequest('HEAD and GET cannot have body')
   }
 
+  if (
+    opts.body != null &&
+    (opts.body.size > 0 || opts.body.length > 0) &&
+    (method === 'HEAD' || method === 'GET')
+  ) {
+    throw new createError.BadRequest('HEAD and GET cannot have body')
+  }
+
   const expectsPayload = opts.method === 'PUT' || opts.method === 'POST' || opts.method === 'PATCH'
 
   if (headers != null && headers['content-length'] === '0' && !expectsPayload) {
@@ -110,23 +118,22 @@ 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)
   }
 
   return await new Promise((resolve, reject) =>
     dispatch(
       {
-        id: opts.id ?? findHeader(headers, 'request-id') ?? genReqId(),
+        id: opts.id ?? headers['request-id'] ?? headers['Request-Id'] ?? genReqId(),
         url,
         method,
         body: opts.body,
@@ -189,10 +196,10 @@ export async function request(url, opts) {
         ) {
           assert(statusCode >= 200)
 
-          const contentLength = findHeader(headers, 'content-length')
-          const contentType = findHeader(headers, 'content-type')
+          const contentLength = headers['content-length']
+          const contentType = 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,107 +1,116 @@
 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
+  #timing
+  #startTime
 
-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 = {
-      start: -1,
-      end: -1,
-      headers: -1,
-      firstBodyReceived: -1,
-      lastBodyReceived: -1,
-    }
+    super(handler)
+
+    this.#handler = handler
+    this.#opts = opts
+    this.#logger = opts.logger.child({ ureq: { id: opts.id } })
   }
 
   onConnect(abort) {
-    this.abort = abort
-    this.stats.start = performance.now()
-    this.logger.debug({ ureq: this.opts }, 'upstream request started')
+    this.#pos = 0
+    this.#abort = abort
+    this.#timing = {
+      headers: -1,
+      data: -1,
+      complete: -1,
+      error: -1,
+    }
+    this.#startTime = performance.now()
+
+    this.#logger.debug({ ureq: this.#opts }, 'upstream request started')
 
-    return this.handler.onConnect((reason) => {
-      this.aborted = true
-      this.abort(reason)
+    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.#timing.headers = performance.now() - this.#startTime
 
-    this.logger.debug(
+    this.#logger.debug(
       {
         ures: { statusCode, headers },
-        elapsedTime: this.stats.headers,
+        elapsedTime: this.#timing.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.#timing.data === -1) {
+      this.#timing.data = performance.now() - this.#startTime
     }
 
-    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.#timing.complete = performance.now() - this.#startTime
 
-    this.logger.debug(
-      { bytesRead: this.pos, elapsedTime: this.stats.end, stats: this.stats },
+    this.#logger.debug(
+      { elapsedTime: this.#timing.complete, bytesRead: this.#pos, timing: this.#timing },
       'upstream request completed',
     )
 
-    return this.handler.onComplete(rawTrailers)
+    return this.#handler.onComplete(rawTrailers)
   }
 
   onError(err) {
-    this.stats.end = performance.now() - this.stats.start
+    this.#timing.error = performance.now() - this.#startTime
 
-    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,
+          timing: this.#timing,
+          elapsedTime: this.#timing.error,
           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,
+          timing: this.#timing,
+          elapsedTime: this.#timing.error,
           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,94 +1,101 @@
 import assert from 'node:assert'
-import { findHeader, isDisturbed, parseURL } from '../utils.js'
+import { isDisturbed, parseHeaders, parseURL } from '../utils.js'
+import { DecoratorHandler } from 'undici'
 
 const redirectableStatusCodes = [300, 301, 302, 303, 307, 308]
 
-class Handler {
+class Handler extends DecoratorHandler {
+  #dispatch
+  #handler
+
+  #opts
+  #abort
+  #aborted = false
+  #reason
+  #maxCount
+  #headersSent = false
+  #count = 0
+  #location
+  #history = []
+
   constructor(opts, { dispatch, handler }) {
-    this.dispatch = dispatch
-    this.handler = handler
-    this.opts = opts
-    this.abort = null
-    this.aborted = false
-    this.reason = null
-    this.maxCount = Number.isFinite(opts.follow) ? opts.follow : opts.follow?.count ?? 0
-
-    this.headersSent = false
-
-    this.count = 0
-    this.location = null
-    this.history = []
-
-    this.handler.onConnect((reason) => {
-      this.aborted = true
-      if (this.abort) {
-        this.abort(reason)
+    super(handler)
+
+    this.#dispatch = dispatch
+    this.#handler = handler
+    this.#opts = opts
+    this.#maxCount = Number.isFinite(opts.follow) ? opts.follow : opts.follow?.count ?? 0
+
+    this.#handler.onConnect((reason) => {
+      this.#aborted = true
+      if (this.#abort) {
+        this.#abort(reason)
       } else {
-        this.reason = reason
+        this.#reason = reason
       }
     })
   }
 
   onConnect(abort) {
-    if (this.aborted) {
-      abort(this.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)
+    return this.#handler.onUpgrade(statusCode, rawHeaders, socket, headers)
   }
 
-  onHeaders(statusCode, rawHeaders, resume, statusText, headers) {
+  onHeaders(statusCode, rawHeaders, resume, statusText, headers = parseHeaders(rawHeaders)) {
     if (redirectableStatusCodes.indexOf(statusCode) === -1) {
-      assert(!this.headersSent)
-      this.headersSent = true
-      return this.handler.onHeaders(statusCode, rawHeaders, resume, statusText, headers)
+      assert(!this.#headersSent)
+      this.#headersSent = true
+      return this.#handler.onHeaders(statusCode, rawHeaders, resume, statusText, headers)
     }
 
-    if (isDisturbed(this.opts.body)) {
+    if (isDisturbed(this.#opts.body)) {
       throw new Error(`Disturbed request cannot be redirected.`)
     }
 
-    this.location = headers ? headers.location : findHeader(rawHeaders, 'location')
+    this.#location = headers.location
 
-    if (!this.location) {
+    if (!this.#location) {
       throw new Error(`Missing redirection location .`)
     }
 
-    this.history.push(this.location)
-    this.count += 1
+    this.#history.push(this.#location)
+    this.#count += 1
 
-    if (typeof this.opts.follow === 'function') {
-      if (!this.opts.follow(this.location, this.count)) {
-        assert(!this.headersSent)
-        this.headersSent = true
-        return this.handler.onHeaders(statusCode, rawHeaders, resume, statusText, headers)
+    if (typeof this.#opts.follow === 'function') {
+      if (!this.#opts.follow(this.#location, this.#count)) {
+        assert(!this.#headersSent)
+        this.#headersSent = true
+        return this.#handler.onHeaders(statusCode, rawHeaders, resume, statusText, headers)
       }
     } else {
-      if (this.count >= this.maxCount) {
-        throw Object.assign(new Error(`Max redirections reached: ${this.maxCount}.`), {
-          history: this.history,
+      if (this.#count >= this.#maxCount) {
+        throw Object.assign(new Error(`Max redirections reached: ${this.#maxCount}.`), {
+          history: this.#history,
         })
       }
     }
 
     const { origin, pathname, search } = parseURL(
-      new URL(this.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.opts = {
-      ...this.opts,
+    this.#opts = {
+      ...this.#opts,
       headers: cleanRequestHeaders(
-        this.opts.headers,
+        this.#opts.headers,
         statusCode === 303,
-        this.opts.origin !== origin,
+        this.#opts.origin !== origin,
       ),
       path,
       origin,
@@ -97,13 +104,13 @@ class Handler {
 
     // 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.opts.method !== 'HEAD') {
-      this.opts = { ...this.opts, method: 'GET', body: null }
+    if (statusCode === 303 && this.#opts.method !== 'HEAD') {
+      this.#opts = { ...this.#opts, method: 'GET', body: null }
     }
   }
 
   onData(chunk) {
-    if (this.location) {
+    if (this.#location) {
       /*
         https://tools.ietf.org/html/rfc7231#section-6.4
 
@@ -122,12 +129,12 @@ class Handler {
         servers and browsers implementors, we ignore the body as there is no specified way to eventually parse it.
       */
     } else {
-      return this.handler.onData(chunk)
+      return this.#handler.onData(chunk)
     }
   }
 
   onComplete(trailers) {
-    if (this.location) {
+    if (this.#location) {
       /*
         https://tools.ietf.org/html/rfc7231#section-6.4
 
@@ -137,16 +144,16 @@ class Handler {
         See comment on onData method above for more detailed informations.
       */
 
-      this.location = null
+      this.#location = null
 
-      this.dispatch(this.opts, this)
+      this.#dispatch(this.#opts, this)
     } else {
-      return this.handler.onComplete(trailers)
+      return this.#handler.onComplete(trailers)
     }
   }
 
   onError(error) {
-    return this.handler.onError(error)
+    return this.#handler.onError(error)
   }
 }
 

package/lib/interceptor/request-id.js

@@ -12,7 +12,7 @@ function genReqId() {
 }
 
 export default (dispatch) => (opts, handler) => {
-  let id = opts.id ?? opts.headers?.['request-id'] ?? opts.headers?.['Request-Id']
+  let id = opts.id ?? opts.headers?.['request-id']
   id = id ? `${id},${genReqId()}` : genReqId()
 
   return dispatch(