@nxtedition/nxt-undici 4.2.26 → 5.0.1

package/lib/errors.js

@@ -0,0 +1,218 @@
+'use strict'
+
+export class UndiciError extends Error {
+  constructor(message, options) {
+    super(message, options)
+    this.name = 'UndiciError'
+    this.code = 'UND_ERR'
+  }
+}
+
+export class ConnectTimeoutError extends UndiciError {
+  constructor(message) {
+    super(message)
+    this.name = 'ConnectTimeoutError'
+    this.message = message || 'Connect Timeout Error'
+    this.code = 'UND_ERR_CONNECT_TIMEOUT'
+  }
+}
+
+export class HeadersTimeoutError extends UndiciError {
+  constructor(message) {
+    super(message)
+    this.name = 'HeadersTimeoutError'
+    this.message = message || 'Headers Timeout Error'
+    this.code = 'UND_ERR_HEADERS_TIMEOUT'
+  }
+}
+
+export class HeadersOverflowError extends UndiciError {
+  constructor(message) {
+    super(message)
+    this.name = 'HeadersOverflowError'
+    this.message = message || 'Headers Overflow Error'
+    this.code = 'UND_ERR_HEADERS_OVERFLOW'
+  }
+}
+
+export class BodyTimeoutError extends UndiciError {
+  constructor(message) {
+    super(message)
+    this.name = 'BodyTimeoutError'
+    this.message = message || 'Body Timeout Error'
+    this.code = 'UND_ERR_BODY_TIMEOUT'
+  }
+}
+
+export class ResponseStatusCodeError extends UndiciError {
+  constructor(message, statusCode, headers, body) {
+    super(message)
+    this.name = 'ResponseStatusCodeError'
+    this.message = message || 'Response Status Code Error'
+    this.code = 'UND_ERR_RESPONSE_STATUS_CODE'
+    this.body = body
+    this.status = statusCode
+    this.statusCode = statusCode
+    this.headers = headers
+  }
+}
+
+export class InvalidArgumentError extends UndiciError {
+  constructor(message) {
+    super(message)
+    this.name = 'InvalidArgumentError'
+    this.message = message || 'Invalid Argument Error'
+    this.code = 'UND_ERR_INVALID_ARG'
+  }
+}
+
+export class InvalidReturnValueError extends UndiciError {
+  constructor(message) {
+    super(message)
+    this.name = 'InvalidReturnValueError'
+    this.message = message || 'Invalid Return Value Error'
+    this.code = 'UND_ERR_INVALID_RETURN_VALUE'
+  }
+}
+
+export class AbortError extends UndiciError {
+  constructor(message) {
+    super(message)
+    this.name = 'AbortError'
+    this.message = message || 'The operation was aborted'
+  }
+}
+
+export class RequestAbortedError extends AbortError {
+  constructor(message) {
+    super(message)
+    this.name = 'AbortError'
+    this.message = message || 'Request aborted'
+    this.code = 'UND_ERR_ABORTED'
+  }
+}
+
+export class InformationalError extends UndiciError {
+  constructor(message) {
+    super(message)
+    this.name = 'InformationalError'
+    this.message = message || 'Request information'
+    this.code = 'UND_ERR_INFO'
+  }
+}
+
+export class RequestContentLengthMismatchError extends UndiciError {
+  constructor(message) {
+    super(message)
+    this.name = 'RequestContentLengthMismatchError'
+    this.message = message || 'Request body length does not match content-length header'
+    this.code = 'UND_ERR_REQ_CONTENT_LENGTH_MISMATCH'
+  }
+}
+
+export class ResponseContentLengthMismatchError extends UndiciError {
+  constructor(message) {
+    super(message)
+    this.name = 'ResponseContentLengthMismatchError'
+    this.message = message || 'Response body length does not match content-length header'
+    this.code = 'UND_ERR_RES_CONTENT_LENGTH_MISMATCH'
+  }
+}
+
+export class ClientDestroyedError extends UndiciError {
+  constructor(message) {
+    super(message)
+    this.name = 'ClientDestroyedError'
+    this.message = message || 'The client is destroyed'
+    this.code = 'UND_ERR_DESTROYED'
+  }
+}
+
+export class ClientClosedError extends UndiciError {
+  constructor(message) {
+    super(message)
+    this.name = 'ClientClosedError'
+    this.message = message || 'The client is closed'
+    this.code = 'UND_ERR_CLOSED'
+  }
+}
+
+export class SocketError extends UndiciError {
+  constructor(message, socket) {
+    super(message)
+    this.name = 'SocketError'
+    this.message = message || 'Socket error'
+    this.code = 'UND_ERR_SOCKET'
+    this.socket = socket
+  }
+}
+
+export class NotSupportedError extends UndiciError {
+  constructor(message) {
+    super(message)
+    this.name = 'NotSupportedError'
+    this.message = message || 'Not supported error'
+    this.code = 'UND_ERR_NOT_SUPPORTED'
+  }
+}
+
+export class BalancedPoolMissingUpstreamError extends UndiciError {
+  constructor(message) {
+    super(message)
+    this.name = 'MissingUpstreamError'
+    this.message = message || 'No upstream has been added to the BalancedPool'
+    this.code = 'UND_ERR_BPL_MISSING_UPSTREAM'
+  }
+}
+
+export class HTTPParserError extends Error {
+  constructor(message, code, data) {
+    super(message)
+    this.name = 'HTTPParserError'
+    this.code = code ? `HPE_${code}` : undefined
+    this.data = data ? data.toString() : undefined
+  }
+}
+
+export class ResponseExceededMaxSizeError extends UndiciError {
+  constructor(message) {
+    super(message)
+    this.name = 'ResponseExceededMaxSizeError'
+    this.message = message || 'Response content exceeded max size'
+    this.code = 'UND_ERR_RES_EXCEEDED_MAX_SIZE'
+  }
+}
+
+export class RequestRetryError extends UndiciError {
+  constructor(message, code, { headers, data }) {
+    super(message)
+    this.name = 'RequestRetryError'
+    this.message = message || 'Request retry error'
+    this.code = 'UND_ERR_REQ_RETRY'
+    this.statusCode = code
+    this.data = data
+    this.headers = headers
+  }
+}
+
+export class ResponseError extends UndiciError {
+  constructor(message, code, { headers, body }) {
+    super(message)
+    this.name = 'ResponseError'
+    this.message = message || 'Response error'
+    this.code = 'UND_ERR_RESPONSE'
+    this.statusCode = code
+    this.body = body
+    this.headers = headers
+  }
+}
+
+export class SecureProxyConnectionError extends UndiciError {
+  constructor(cause, message, options = {}) {
+    super(message, { cause, ...options })
+    this.name = 'SecureProxyConnectionError'
+    this.message = message || 'Secure Proxy Connection failed'
+    this.code = 'UND_ERR_PRX_TLS'
+    this.cause = cause
+  }
+}

package/lib/index.js

@@ -1,5 +1,6 @@
 import undici from 'undici'
 import { parseHeaders } from './utils.js'
+import { request as _request } from './request.js'
 
 const dispatcherCache = new WeakMap()
 
@@ -23,10 +24,36 @@ function defaultLookup(origin, opts, callback) {
   callback(null, Array.isArray(origin) ? origin[Math.floor(Math.random() * origin.length)] : origin)
 }
 
-function wrapDispatcher(dispatcher) {
+export function compose(...interceptors) {
+  let dispatch = interceptors.shift()
+  if (typeof dispatch?.dispatch === 'function') {
+    dispatch = dispatch.dispatch.bind(dispatch)
+  }
+
+  for (const interceptor of interceptors) {
+    if (interceptor == null) {
+      continue
+    }
+
+    if (typeof interceptor !== 'function') {
+      throw new TypeError(`invalid interceptor, expected function received ${typeof interceptor}`)
+    }
+
+    dispatch = interceptor(dispatch)
+
+    if (dispatch == null || typeof dispatch !== 'function' || dispatch.length !== 2) {
+      throw new TypeError('invalid interceptor')
+    }
+  }
+
+  return dispatch
+}
+
+function wrapDispatch(dispatcher) {
   let wrappedDispatcher = dispatcherCache.get(dispatcher)
   if (wrappedDispatcher == null) {
-    wrappedDispatcher = dispatcher.compose(
+    wrappedDispatcher = compose(
+      dispatcher,
       interceptors.responseError(),
       interceptors.requestBodyFactory(),
       interceptors.log(),
@@ -84,26 +111,13 @@ function wrapDispatcher(dispatcher) {
 }
 
 export function dispatch(dispatcher, opts, handler) {
-  return wrapDispatcher(dispatcher).dispatch(opts, handler)
+  return wrapDispatch(dispatcher)(opts, handler)
 }
 
-// HACK
-const _request = undici.Dispatcher.prototype.request
-
 export async function request(url, opts) {
-  // TODO (fix): More argument validation...
-
-  if (typeof url === 'string') {
-    opts = { url: new URL(url), ...opts }
-  } else if (url instanceof URL) {
-    opts = { url, ...opts }
-  } else if (typeof url.origin === 'string' && typeof (url.path ?? url.pathname) === 'string') {
-    opts = opts ? { ...url, ...opts } : url
-  }
-
-  if (opts == null && typeof url === 'object' && url != null) {
-    opts = url
-  }
-
-  return _request.call(await wrapDispatcher(opts.dispatcher ?? undici.getGlobalDispatcher()), opts)
+  return _request(
+    await wrapDispatch(opts?.dispatch ?? opts?.dispatcher ?? undici.getGlobalDispatcher()),
+    url,
+    opts,
+  )
 }

package/lib/interceptor/cache.js

@@ -1,16 +1,13 @@
-import assert from 'node:assert'
 import { LRUCache } from 'lru-cache'
-import { DecoratorHandler, parseHeaders, parseCacheControl } from '../utils.js'
+import { parseHeaders, parseCacheControl } from '../utils.js'
 
-class CacheHandler extends DecoratorHandler {
+class CacheHandler {
   #handler
   #store
   #key
-  #value = null
+  #value
 
   constructor({ key, handler, store }) {
-    super(handler)
-
     this.#key = key
     this.#handler = handler
     this.#store = store
@@ -24,7 +21,7 @@ class CacheHandler extends DecoratorHandler {
 
   onHeaders(statusCode, rawHeaders, resume, statusMessage, headers = parseHeaders(rawHeaders)) {
     if (statusCode !== 307) {
-      return this.#handler.onHeaders(statusCode, rawHeaders, resume, statusMessage, headers)
+      return this.#handler.onHeaders(statusCode, null, resume, statusMessage, headers)
     }
 
     // TODO (fix): Support vary header.
@@ -34,7 +31,7 @@ class CacheHandler extends DecoratorHandler {
     const maxEntrySize = this.#store.maxEntrySize ?? Infinity
 
     if (
-      contentLength < maxEntrySize &&
+      (!contentLength || contentLength < maxEntrySize) &&
       cacheControl &&
       cacheControl.public &&
       !cacheControl.private &&
@@ -47,29 +44,21 @@ class CacheHandler extends DecoratorHandler {
       !cacheControl['proxy-revalidate']
     ) {
       const maxAge = cacheControl['s-max-age'] ?? cacheControl['max-age']
-      const ttl = cacheControl.immutable
-        ? 31556952 // 1 year
-        : Number(maxAge)
+      const ttl = cacheControl.immutable ? 31556952 : Number(maxAge)
 
       if (ttl > 0) {
         this.#value = {
-          data: {
-            statusCode,
-            statusMessage,
-            rawHeaders,
-            rawTrailers: null,
-            body: [],
-          },
-          size:
-            (rawHeaders?.reduce((xs, x) => xs + x.length, 0) ?? 0) +
-            (statusMessage?.length ?? 0) +
-            64,
+          statusCode,
+          statusMessage,
+          headers,
+          body: [],
+          size: 256, // TODO (fix): Measure headers size...
           ttl: ttl * 1e3,
         }
       }
     }
 
-    return this.#handler.onHeaders(statusCode, rawHeaders, resume, statusMessage, headers)
+    return this.#handler.onHeaders(statusCode, null, resume, statusMessage, headers)
   }
 
   onData(chunk) {
@@ -86,26 +75,46 @@ class CacheHandler extends DecoratorHandler {
     return this.#handler.onData(chunk)
   }
 
-  onComplete(rawTrailers) {
+  onComplete() {
     if (this.#value) {
-      this.#value.data.rawTrailers = rawTrailers
-      this.#value.size += rawTrailers?.reduce((xs, x) => xs + x.length, 0) ?? 0
-      this.#store.set(this.#key, this.#value.data, { ttl: this.#value.ttl, size: this.#value.size })
+      this.#store.set(
+        this.#key,
+        {
+          statusCode: this.#value.statusCode,
+          statusMessage: this.#value.statusMessage,
+          headers: this.#value.headers,
+          body: Buffer.concat(this.#value.body),
+        },
+        { ttl: this.#value.ttl, size: this.#value.size },
+      )
     }
-    return this.#handler.onComplete(rawTrailers)
+    return this.#handler.onComplete()
+  }
+
+  onError(err) {
+    this.#handler.onError(err)
   }
 }
 
-// TODO (fix): Async filesystem cache.
-class CacheStore {
-  constructor({ maxSize = 1024 * 1024, maxEntrySize = 128 * 1024 }) {
+class MemoryCacheStore {
+  constructor({ maxSize = 1024 * 1024, maxEntrySize = 128 * 1024, maxTTL = 48 * 3600e3 }) {
     this.maxSize = maxSize
     this.maxEntrySize = maxEntrySize
+    this.maxTTL = maxTTL
     this.cache = new LRUCache({ maxSize })
   }
 
   set(key, value, opts) {
-    this.cache.set(key, value, opts)
+    this.cache.set(
+      key,
+      value,
+      opts
+        ? {
+            ttl: opts.ttl ? Math.min(opts.ttl, this.maxTTL) : undefined,
+            size: opts.size,
+          }
+        : undefined,
+    )
   }
 
   get(key) {
@@ -118,14 +127,13 @@ function makeKey(opts) {
   return `${opts.origin}:${opts.method}:${opts.path}`
 }
 
-const DEFAULT_CACHE_STORE = new CacheStore({ maxSize: 128 * 1024, maxEntrySize: 1024 })
+const DEFAULT_CACHE_STORE = new MemoryCacheStore({ maxSize: 128 * 1024, maxEntrySize: 1024 })
 
 export default (opts) => (dispatch) => (opts, handler) => {
   if (!opts.cache || opts.upgrade) {
     return dispatch(opts, handler)
   }
 
-  // TODO (fix): Cache other methods?
   if (opts.method !== 'GET' && opts.method !== 'HEAD') {
     return dispatch(opts, handler)
   }
@@ -143,9 +151,6 @@ export default (opts) => (dispatch) => (opts, handler) => {
     return dispatch(opts, handler)
   }
 
-  // TODO (fix): Support body...
-  assert(opts.method === 'GET' || opts.method === 'HEAD')
-
   // Dump body...
   opts.body?.on('error', () => {}).resume()
 
@@ -155,47 +160,43 @@ export default (opts) => (dispatch) => (opts, handler) => {
     throw new Error(`Cache store not provided.`)
   }
 
-  let key = makeKey(opts)
-  let value = store.get(key)
+  const key = makeKey(opts)
+  const entry = store.get(key)
 
-  if (value == null && opts.method === 'HEAD') {
-    key = makeKey({ ...opts, method: 'GET' })
-    value = store.get(key)
+  if (!entry) {
+    return dispatch(opts, new CacheHandler({ handler, store, key: makeKey(opts) }))
   }
 
-  if (value) {
-    const { statusCode, statusMessage, rawHeaders, rawTrailers, body } = value
-    const ac = new AbortController()
-    const signal = ac.signal
+  const { statusCode, statusMessage, headers, body } = entry
+
+  let aborted = false
+  const abort = () => {
+    aborted = true
+  }
+  const resume = () => {}
 
-    const resume = () => {}
-    const abort = () => {
-      ac.abort()
+  try {
+    handler.onConnect(abort)
+    if (aborted) {
+      return true
     }
 
-    try {
-      handler.onConnect(abort)
-      signal.throwIfAborted()
-      handler.onHeaders(statusCode, rawHeaders, resume, statusMessage)
-      signal.throwIfAborted()
-      if (opts.method !== 'HEAD') {
-        for (const chunk of body) {
-          const ret = handler.onData(chunk)
-          signal.throwIfAborted()
-          if (ret === false) {
-            // TODO (fix): back pressure...
-          }
-        }
-        handler.onComplete(rawTrailers)
-      } else {
-        handler.onComplete([])
+    handler.onHeaders(statusCode, null, resume, statusMessage, headers)
+    if (aborted) {
+      return true
+    }
+
+    if (body.byteKength > 0) {
+      handler.onData(body)
+      if (aborted) {
+        return true
       }
-    } catch (err) {
-      handler.onError(err)
     }
 
-    return true
-  } else {
-    return dispatch(opts, new CacheHandler({ handler, store, key: makeKey(opts) }))
+    handler.onComplete()
+  } catch (err) {
+    handler.onError(err)
   }
+
+  return true
 }

package/lib/interceptor/log.js

@@ -5,7 +5,7 @@ class Handler extends DecoratorHandler {
   #opts
   #logger
 
-  #abort = null
+  #abort
   #aborted = false
   #pos = 0
   #created = 0
@@ -59,14 +59,14 @@ class Handler extends DecoratorHandler {
 
     this.#logger.debug(
       {
-        ureq: { id: this.#opts.id, url: this.#opts.url },
+        ureq: { id: this.#opts.id, url: String(this.#opts.url) },
         ures: { statusCode, headers },
         elapsedTime: this.#timing.headers,
       },
       'upstream request response',
     )
 
-    return this.#handler.onHeaders(statusCode, rawHeaders, resume, statusMessage, headers)
+    return this.#handler.onHeaders(statusCode, null, resume, statusMessage, headers)
   }
 
   onData(chunk) {
@@ -79,7 +79,7 @@ class Handler extends DecoratorHandler {
     return this.#handler.onData(chunk)
   }
 
-  onComplete(rawTrailers) {
+  onComplete() {
     this.#timing.end = performance.now() - this.#created
 
     this.#logger.debug(
@@ -94,7 +94,7 @@ class Handler extends DecoratorHandler {
       'upstream request completed',
     )
 
-    return this.#handler.onComplete(rawTrailers)
+    return this.#handler.onComplete()
   }
 
   onError(err) {

package/lib/interceptor/proxy.js

@@ -1,6 +1,6 @@
 import net from 'node:net'
 import createError from 'http-errors'
-import { DecoratorHandler } from '../utils.js'
+import { DecoratorHandler, parseHeaders } from '../utils.js'
 
 class Handler extends DecoratorHandler {
   #handler
@@ -33,12 +33,12 @@ class Handler extends DecoratorHandler {
     )
   }
 
-  onHeaders(statusCode, rawHeaders, resume, statusMessage) {
+  onHeaders(statusCode, rawHeaders, resume, statusMessage, headers = parseHeaders(rawHeaders)) {
     return this.#handler.onHeaders(
       statusCode,
       reduceHeaders(
         {
-          headers: rawHeaders,
+          headers,
           httpVersion: this.#opts.httpVersion ?? this.#opts.req?.httpVersion,
           socket: this.#opts.socket,
           proxyName: this.#opts.name,
@@ -61,18 +61,6 @@ class Handler extends DecoratorHandler {
 const HOP_EXPR =
   /^(te|host|upgrade|trailers|connection|keep-alive|http2-settings|transfer-encoding|proxy-connection|proxy-authenticate|proxy-authorization)$/i
 
-function forEachHeader(headers, fn) {
-  if (Array.isArray(headers)) {
-    for (let n = 0; n < headers.length; n += 2) {
-      fn(headers[n + 0], headers[n + 1])
-    }
-  } else {
-    for (const [key, val] of Object.entries(headers)) {
-      fn(key, val)
-    }
-  }
-}
-
 // Removes hop-by-hop and pseudo headers.
 // Updates via and forwarded headers.
 // Only hop-by-hop headers may be set using the Connection general header.
@@ -83,33 +71,31 @@ function reduceHeaders({ headers, proxyName, httpVersion, socket }, fn, acc) {
   let authority = ''
   let connection = ''
 
-  forEachHeader(headers, (key, val) => {
+  for (const [key, val] of Object.entries(headers)) {
     const len = key.length
-    if (len === 3 && !via && key.toString().toLowerCase() === 'via') {
-      via = val.toString()
-    } else if (len === 4 && !host && key.toString().toLowerCase() === 'host') {
-      host = val.toString()
-    } else if (len === 9 && !forwarded && key.toString().toLowerCase() === 'forwarded') {
-      forwarded = val.toString()
-    } else if (len === 10 && !connection && key.toString().toLowerCase() === 'connection') {
-      connection = val.toString()
-    } else if (len === 10 && !authority && key.toString().toLowerCase() === ':authority') {
-      authority = val.toString()
+    if (len === 3 && !via && key === 'via') {
+      via = val
+    } else if (len === 4 && !host && key === 'host') {
+      host = val
+    } else if (len === 9 && !forwarded && key === 'forwarded') {
+      forwarded = val
+    } else if (len === 10 && !connection && key === 'connection') {
+      connection = val
+    } else if (len === 10 && !authority && key === ':authority') {
+      authority = val
     }
-  })
+  }
 
   let remove = []
   if (connection && !HOP_EXPR.test(connection)) {
     remove = connection.split(/,\s*/)
   }
 
-  forEachHeader(headers, (key, val) => {
-    key = key.toString()
-
+  for (const [key, val] of Object.entries(headers)) {
     if (key.charAt(0) !== ':' && !remove.includes(key) && !HOP_EXPR.test(key)) {
       acc = fn(acc, key, val.toString())
     }
-  })
+  }
 
   if (socket) {
     const forwardedHost = authority || host