@nxtedition/nxt-undici 4.2.18 → 4.2.20

package/lib/index.js

@@ -13,7 +13,6 @@ export const interceptors = {
   proxy: (await import('./interceptor/proxy.js')).default,
   cache: (await import('./interceptor/cache.js')).default,
   requestId: (await import('./interceptor/request-id.js')).default,
-  dns: (await import('./interceptor/dns.js')).default,
   lookup: (await import('./interceptor/lookup.js')).default,
 }
 
@@ -31,7 +30,6 @@ function wrapDispatcher(dispatcher) {
       interceptors.responseError(),
       interceptors.requestBodyFactory(),
       interceptors.log(),
-      interceptors.dns(),
       interceptors.lookup(),
       interceptors.requestId(),
       interceptors.responseRetry(),
@@ -59,7 +57,7 @@ function wrapDispatcher(dispatcher) {
             query: opts.query,
             headers,
             signal: opts.signal,
-            reset: opts.reset ?? null,
+            reset: opts.reset ?? false,
             blocking: opts.blocking ?? null,
             headersTimeout: opts.headersTimeout,
             bodyTimeout: opts.bodyTimeout,
@@ -72,7 +70,6 @@ function wrapDispatcher(dispatcher) {
             error: opts.error ?? true,
             verify: opts.verify ?? true,
             logger: opts.logger ?? null,
-            dns: opts.dns ?? false,
             connect: opts.connect,
             lookup: opts.lookup ?? defaultLookup,
             maxRedirections: 0, // TODO (fix): Ugly hack to disable undici redirections.

package/lib/interceptor/response-error.js

@@ -91,14 +91,41 @@ class Handler extends DecoratorHandler {
   }
 
   #decorateError(err) {
-    return Object.assign(err, {
-      url: new URL(this.#opts.path, this.#opts.origin).href,
-      headers: this.#headers,
-      reason: this.#body?.reason,
-      code: this.#body?.code,
-      error: this.#body?.error,
-      body: typeof this.#body !== 'string' || this.#body.length < 1024 ? this.#body : undefined,
-    })
+    try {
+      err.url ??= new URL(this.#opts.path, this.#opts.origin).href
+
+      err.req = {
+        method: this.#opts?.method,
+        headers: this.#opts?.headers,
+        body:
+          // TODO (fix): JSON.stringify POJO
+          typeof this.#opts?.body !== 'string' || this.#opts.body.length > 1024
+            ? undefined
+            : this.#opts.body,
+      }
+
+      err.res = {
+        headers: this.#headers,
+        // TODO (fix): JSON.stringify POJO
+        body: typeof this.#body !== 'string' || this.#body.length < 1024 ? undefined : this.#body,
+      }
+
+      if (this.#body) {
+        if (this.#body.reason != null) {
+          err.reason ??= this.#body.reason
+        }
+        if (this.#body.code != null) {
+          err.code ??= this.#body.code
+        }
+        if (this.#body.error != null) {
+          err.error ??= this.#body.errorq
+        }
+      }
+
+      return err
+    } catch {
+      return err
+    }
   }
 }
 

package/package.json

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

package/lib/interceptor/dns.js

@@ -1,103 +0,0 @@
-import assert from 'node:assert'
-import net from 'node:net'
-import dns from 'node:dns'
-import { DecoratorHandler } from '../utils.js'
-
-const DEFAULT_RESOLVER = {
-  lookup(hostname, options, callback) {
-    dns.lookup(hostname, options, callback)
-  },
-}
-
-class Handler extends DecoratorHandler {
-  #handler
-  #resolver
-  #key
-
-  constructor({ resolver, key }, { handler }) {
-    super(handler)
-
-    this.#handler = handler
-    this.#resolver = resolver
-    this.#key = key
-  }
-
-  onError(err) {
-    if (
-      err.code &&
-      [
-        'ECONNRESET',
-        'ECONNREFUSED',
-        'ENOTFOUND',
-        'ENETDOWN',
-        'ENETUNREACH',
-        'EHOSTDOWN',
-        'EHOSTUNREACH',
-        'EHOSTNOTFOUND',
-        'ENODATA',
-        'EPIPE',
-      ].includes(err.code)
-    ) {
-      this.#resolver.clear(this.#key)
-    }
-
-    return this.#handler.onError(err)
-  }
-}
-
-export default (interceptorOpts) => (dispatch) => (opts, handler) => {
-  const dns = opts.dns
-
-  if (!dns) {
-    return dispatch(opts, handler)
-  }
-
-  const {
-    resolver = interceptorOpts?.resolver ?? DEFAULT_RESOLVER,
-    family = interceptorOpts?.family,
-    hints = interceptorOpts?.hints,
-    order = interceptorOpts?.order ?? 'ipv4first',
-    all = interceptorOpts?.all ?? true,
-  } = dns
-
-  assert(typeof resolver.lookup === 'function')
-
-  const { hostname, host } = new URL(opts.origin)
-
-  if (net.isIP(hostname) || opts.headers?.host) {
-    return dispatch(opts, handler)
-  }
-
-  const callback = (err, val) => {
-    if (err) {
-      handler.onError(err)
-    } else {
-      const url = new URL(opts.origin)
-      url.hostname = Array.isArray(val)
-        ? val[Math.floor(val.length * Math.random())].address
-        : (val?.address ?? val)
-      dispatch(
-        {
-          ...opts,
-          origin: url.origin,
-          headers: { ...opts.headers, host },
-        },
-        resolver.clear ? new Handler({ resolver, key: hostname }, { handler }) : handler,
-      )
-    }
-  }
-
-  try {
-    const thenable = resolver.lookup(hostname, { family, hints, order, all }, callback)
-    if (typeof thenable?.then === 'function') {
-      thenable.then(
-        (val) => callback(null, val),
-        (err) => callback(err),
-      )
-    }
-  } catch (err) {
-    handler.onError(err)
-  }
-
-  return true
-}