@nxtedition/nxt-undici 2.0.51 → 2.0.52

package/lib/index.js

@@ -1,31 +1,18 @@
 import assert from 'node:assert'
 import createError from 'http-errors'
 import undici from 'undici'
-import { parseHeaders, AbortError, headerNameToString, isStream } from './utils.js'
+import { parseHeaders, AbortError, isStream } from './utils.js'
 import { BodyReadable } from './readable.js'
 
 const dispatcherCache = new WeakMap()
 
-// https://github.com/fastify/fastify/blob/main/lib/reqIdGenFactory.js
-// 2,147,483,647 (2^31 − 1) stands for max SMI value (an internal optimization of V8).
-// With this upper bound, if you'll be generating 1k ids/sec, you're going to hit it in ~25 days.
-// This is very likely to happen in real-world applications, hence the limit is enforced.
-// Growing beyond this value will make the id generation slower and cause a deopt.
-// In the worst cases, it will become a float, losing accuracy.
-const maxInt = 2147483647
-let nextReqId = Math.floor(Math.random() * maxInt)
-function genReqId() {
-  nextReqId = (nextReqId + 1) & maxInt
-  return `req-${nextReqId.toString(36)}`
-}
-
 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,
+  responseError: (await import('./interceptor/response-error.js')).default,
+  responseRetry: (await import('./interceptor/response-retry.js')).default,
+  responseVerify: (await import('./interceptor/response-verify.js')).default,
   log: (await import('./interceptor/log.js')).default,
   redirect: (await import('./interceptor/redirect.js')).default,
-  responseRetry: (await import('./interceptor/response-retry.js')).default,
   proxy: (await import('./interceptor/proxy.js')).default,
   cache: (await import('./interceptor/cache.js')).default,
   requestId: (await import('./interceptor/request-id.js')).default,
@@ -59,16 +46,7 @@ export async function request(url, opts) {
   }
 
   const method = opts.method ?? (opts.body ? 'POST' : 'GET')
-  const idempotent = opts.idempotent ?? (method === 'GET' || method === 'HEAD')
-
-  let headers = {}
-  if (Array.isArray(opts.headers)) {
-    headers = parseHeaders(opts.headers)
-  } else if (opts.headers != null) {
-    for (const [key, val] of Object.entries(opts.headers)) {
-      headers[headerNameToString(key)] = val
-    }
-  }
+  const headers = parseHeaders(opts.headers)
 
   const userAgent = opts.userAgent ?? globalThis.userAgent
   if (userAgent && headers?.['user-agent'] !== userAgent) {
@@ -79,6 +57,7 @@ export async function request(url, opts) {
     throw new createError.MethodNotAllowed()
   }
 
+  // TODO (fix): Move into undici?
   if (
     headers != null &&
     (method === 'HEAD' || method === 'GET') &&
@@ -87,6 +66,7 @@ export async function request(url, opts) {
     throw new createError.BadRequest('HEAD and GET cannot have body')
   }
 
+  // TODO (fix): Move into undici?
   if (
     opts.body != null &&
     (opts.body.size > 0 || opts.body.length > 0) &&
@@ -104,11 +84,11 @@ export async function request(url, opts) {
     // semantics do not anticipate such a body.
 
     // undici will error if provided an unexpected content-length: 0 header.
-    headers = { ...headers }
     delete headers['content-length']
   }
 
   if (isStream(opts.body)) {
+    // TODO (fix): Remove this somehow?
     // Workaround: https://github.com/nodejs/undici/pull/2497
     opts.body.on('error', () => {})
   }
@@ -123,7 +103,7 @@ export async function request(url, opts) {
     dispatch = interceptors.log(dispatch)
     dispatch = interceptors.requestId(dispatch)
     dispatch = interceptors.responseRetry(dispatch)
-    dispatch = interceptors.responseContent(dispatch)
+    dispatch = interceptors.responseVerify(dispatch)
     dispatch = interceptors.cache(dispatch)
     dispatch = interceptors.redirect(dispatch)
     dispatch = interceptors.proxy(dispatch)
@@ -133,7 +113,7 @@ export async function request(url, opts) {
   return await new Promise((resolve, reject) =>
     dispatch(
       {
-        id: opts.id ?? headers['request-id'] ?? headers['Request-Id'] ?? genReqId(),
+        id: opts.id,
         url,
         method,
         body: opts.body,
@@ -145,13 +125,15 @@ export async function request(url, opts) {
         blocking: opts.blocking ?? false,
         headersTimeout: opts.headersTimeout,
         bodyTimeout: opts.bodyTimeout,
-        idempotent,
+        idempotent: opts.idempotent,
         retry: opts.retry ?? 8,
-        proxy: opts.proxy,
-        cache: opts.cache,
-        upgrade: opts.upgrade,
+        proxy: opts.proxy ?? false,
+        cache: opts.cache ?? true,
+        upgrade: opts.upgrade ?? false,
         follow: opts.follow ?? 8,
-        logger: opts.logger,
+        error: opts.error ?? true,
+        verify: opts.verify ?? true,
+        logger: opts.logger ?? null,
       },
       {
         resolve,

package/lib/interceptor/cache.js

@@ -117,6 +117,7 @@ export default (dispatch) => (opts, handler) => {
     return dispatch(opts, handler)
   }
 
+  // TODO (fix): Cache other methods?
   if (opts.method !== 'GET' && opts.method !== 'HEAD') {
     dispatch(opts, handler)
     return

package/lib/interceptor/response-error.js

@@ -95,4 +95,7 @@ class Handler extends DecoratorHandler {
   }
 }
 
-export default (dispatch) => (opts, handler) => dispatch(opts, new Handler(opts, { handler }))
+export default (dispatch) => (opts, handler) =>
+  opts.error !== false && opts.throwOnError !== false
+    ? dispatch(opts, new Handler(opts, { handler }))
+    : dispatch(opts, handler)

package/lib/interceptor/response-retry.js

@@ -200,7 +200,7 @@ class Handler extends DecoratorHandler {
 
 export default (dispatch) => (opts, handler) => {
   // TODO (fix): HEAD, PUT, PATCH, DELETE, OPTIONS?
-  return opts.retry && opts.method === 'GET' && !opts.upgrade
+  return opts.retry !== false && opts.method === 'GET' && !opts.upgrade
     ? dispatch(opts, new Handler(opts, { handler, dispatch }))
     : dispatch(opts, handler)
 }

package/lib/interceptor/{response-content.js → response-verify.js}

@@ -6,6 +6,7 @@ import { DecoratorHandler } from 'undici'
 class Handler extends DecoratorHandler {
   #handler
 
+  #verifyOpts
   #contentMD5
   #contentLength
   #hasher
@@ -16,6 +17,7 @@ class Handler extends DecoratorHandler {
     super(handler)
 
     this.#handler = handler
+    this.#verifyOpts = opts.verify === true ? { hash: true, size: true } : opts.verify
   }
 
   onConnect(abort) {
@@ -31,8 +33,8 @@ class Handler extends DecoratorHandler {
   }
 
   onHeaders(statusCode, rawHeaders, resume, statusMessage, headers = parseHeaders(rawHeaders)) {
-    this.#contentMD5 = headers['content-md5']
-    this.#contentLength = headers['content-length']
+    this.#contentMD5 = this.#verifyOpts.hash ? headers['content-md5'] : null
+    this.#contentLength = this.#verifyOpts.hash ? headers['content-length'] : null
     this.#hasher = this.#contentMD5 != null ? crypto.createHash('md5') : null
 
     return this.#handler.onHeaders(statusCode, rawHeaders, resume, statusMessage, headers)
@@ -79,4 +81,6 @@ class Handler extends DecoratorHandler {
 }
 
 export default (dispatch) => (opts, handler) =>
-  !opts.upgrade ? dispatch(opts, new Handler(opts, { handler })) : dispatch(opts, handler)
+  !opts.upgrade && opts.verify !== false
+    ? dispatch(opts, new Handler(opts, { handler }))
+    : dispatch(opts, handler)

package/lib/readable.js

@@ -1,11 +1,8 @@
 import assert from 'node:assert'
 import { Readable, isDisturbed } from 'node:stream'
-import {
-  RequestAbortedError,
-  NotSupportedError,
-  InvalidArgumentError,
-  AbortError,
-} from './errors.js'
+import { errors as undiciErrors } from 'undici'
+
+const { RequestAbortedError, NotSupportedError, InvalidArgumentError, AbortError } = undiciErrors
 
 const kConsume = Symbol('kConsume')
 const kReading = Symbol('kReading')

package/lib/utils.js

@@ -202,7 +202,14 @@ export function parseOrigin(url) {
 }
 
 export function parseHeaders(headers, obj = {}) {
-  return Array.isArray(headers) ? util.parseHeaders(headers, obj) : headers
+  if (Array.isArray(headers)) {
+    return util.parseHeaders(headers, obj)
+  } else if (headers != null) {
+    for (const [key, val] of Object.entries(headers)) {
+      obj[headerNameToString(key)] = val
+    }
+  }
+  return obj
 }
 
 export class AbortError extends Error {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/nxt-undici",
-  "version": "2.0.51",
+  "version": "2.0.52",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "main": "lib/index.js",
@@ -13,15 +13,15 @@
     "cacheable-lookup": "^7.0.0",
     "http-errors": "^2.0.0",
     "lru-cache": "^10.2.0",
-    "undici": "^6.13.0"
+    "undici": "^6.16.1"
   },
   "devDependencies": {
-    "@types/node": "^20.12.7",
+    "@types/node": "^20.12.11",
     "eslint": "^8.0.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-config-standard": "^17.0.0",
     "eslint-plugin-import": "^2.29.1",
-    "eslint-plugin-n": "^17.2.0",
+    "eslint-plugin-n": "^17.6.0",
     "eslint-plugin-promise": "^6.1.1",
     "husky": "^9.0.11",
     "lint-staged": "^15.2.2",

package/lib/errors.js

@@ -1,214 +0,0 @@
-export class UndiciError extends Error {
-  constructor(message) {
-    super(message)
-    this.name = 'UndiciError'
-    this.code = 'UND_ERR'
-  }
-}
-
-export class ConnectTimeoutError extends UndiciError {
-  constructor(message) {
-    super(message)
-    Error.captureStackTrace(this, ConnectTimeoutError)
-    this.name = 'ConnectTimeoutError'
-    this.message = message || 'Connect Timeout Error'
-    this.code = 'UND_ERR_CONNECT_TIMEOUT'
-  }
-}
-
-export class HeadersTimeoutError extends UndiciError {
-  constructor(message) {
-    super(message)
-    Error.captureStackTrace(this, HeadersTimeoutError)
-    this.name = 'HeadersTimeoutError'
-    this.message = message || 'Headers Timeout Error'
-    this.code = 'UND_ERR_HEADERS_TIMEOUT'
-  }
-}
-
-export class HeadersOverflowError extends UndiciError {
-  constructor(message) {
-    super(message)
-    Error.captureStackTrace(this, HeadersOverflowError)
-    this.name = 'HeadersOverflowError'
-    this.message = message || 'Headers Overflow Error'
-    this.code = 'UND_ERR_HEADERS_OVERFLOW'
-  }
-}
-
-export class BodyTimeoutError extends UndiciError {
-  constructor(message) {
-    super(message)
-    Error.captureStackTrace(this, BodyTimeoutError)
-    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)
-    Error.captureStackTrace(this, ResponseStatusCodeError)
-    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)
-    Error.captureStackTrace(this, InvalidArgumentError)
-    this.name = 'InvalidArgumentError'
-    this.message = message || 'Invalid Argument Error'
-    this.code = 'UND_ERR_INVALID_ARG'
-  }
-}
-
-export class InvalidReturnValueError extends UndiciError {
-  constructor(message) {
-    super(message)
-    Error.captureStackTrace(this, InvalidReturnValueError)
-    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)
-    Error.captureStackTrace(this, AbortError)
-    this.name = 'AbortError'
-    this.message = message || 'The operation was aborted'
-  }
-}
-
-export class RequestAbortedError extends AbortError {
-  constructor(message) {
-    super(message)
-    Error.captureStackTrace(this, RequestAbortedError)
-    this.name = 'AbortError'
-    this.message = message || 'Request aborted'
-    this.code = 'UND_ERR_ABORTED'
-  }
-}
-
-export class InformationalError extends UndiciError {
-  constructor(message) {
-    super(message)
-    Error.captureStackTrace(this, InformationalError)
-    this.name = 'InformationalError'
-    this.message = message || 'Request information'
-    this.code = 'UND_ERR_INFO'
-  }
-}
-
-export class RequestContentLengthMismatchError extends UndiciError {
-  constructor(message) {
-    super(message)
-    Error.captureStackTrace(this, RequestContentLengthMismatchError)
-    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)
-    Error.captureStackTrace(this, ResponseContentLengthMismatchError)
-    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)
-    Error.captureStackTrace(this, ClientDestroyedError)
-    this.name = 'ClientDestroyedError'
-    this.message = message || 'The client is destroyed'
-    this.code = 'UND_ERR_DESTROYED'
-  }
-}
-
-export class ClientClosedError extends UndiciError {
-  constructor(message) {
-    super(message)
-    Error.captureStackTrace(this, ClientClosedError)
-    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)
-    Error.captureStackTrace(this, SocketError)
-    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)
-    Error.captureStackTrace(this, NotSupportedError)
-    this.name = 'NotSupportedError'
-    this.message = message || 'Not supported error'
-    this.code = 'UND_ERR_NOT_SUPPORTED'
-  }
-}
-
-export class BalancedPoolMissingUpstreamError extends UndiciError {
-  constructor(message) {
-    super(message)
-    Error.captureStackTrace(this, NotSupportedError)
-    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)
-    Error.captureStackTrace(this, HTTPParserError)
-    this.name = 'HTTPParserError'
-    this.code = code ? `HPE_${code}` : undefined
-    this.data = data ? data.toString() : undefined
-  }
-}
-
-export class ResponseExceededMaxSizeError extends UndiciError {
-  constructor(message) {
-    super(message)
-    Error.captureStackTrace(this, ResponseExceededMaxSizeError)
-    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)
-    Error.captureStackTrace(this, RequestRetryError)
-    this.name = 'RequestRetryError'
-    this.message = message || 'Request retry error'
-    this.code = 'UND_ERR_REQ_RETRY'
-    this.statusCode = code
-    this.data = data
-    this.headers = headers
-  }
-}