@nxtedition/nxt-undici 3.2.2 → 3.3.0

package/lib/index.js

@@ -20,6 +20,31 @@ export const interceptors = {
 export { parseHeaders } from './utils.js'
 export { Client, Pool, Agent, getGlobalDispatcher, setGlobalDispatcher } from '@nxtedition/undici'
 
+function wrapdDispatcher(dispatcher) {
+  let wrappedDispatcher = dispatcherCache.get(dispatcher)
+  if (wrappedDispatcher == null) {
+    wrappedDispatcher = dispatcher.compose(
+      interceptors.responseError(),
+      interceptors.requestBodyFactory(),
+      interceptors.log(),
+      interceptors.dns(),
+      interceptors.lookup(),
+      interceptors.requestId(),
+      interceptors.responseRetry(),
+      interceptors.responseVerify(),
+      interceptors.redirect(),
+      interceptors.cache(),
+      interceptors.proxy(),
+    )
+    dispatcherCache.set(dispatcher, wrappedDispatcher)
+  }
+  return wrappedDispatcher
+}
+
+export function dispatch(dispatcher, opts, handler) {
+  return wrapdDispatcher(opts.dispatcher ?? undici.getGlobalDispatcher()).dispatch(opts, handler)
+}
+
 export async function request(url, opts) {
   // TODO (fix): More argument validation...
 
@@ -55,30 +80,11 @@ export async function request(url, opts) {
     headers['user-agent'] = userAgent
   }
 
-  const baseDispatcher = opts.dispatcher ?? undici.getGlobalDispatcher()
-
-  let dispatcher = dispatcherCache.get(baseDispatcher)
-  if (dispatcher == null) {
-    dispatcher = baseDispatcher.compose(
-      interceptors.responseError(),
-      interceptors.requestBodyFactory(),
-      interceptors.log(),
-      interceptors.dns(),
-      interceptors.lookup(),
-      interceptors.requestId(),
-      interceptors.responseRetry(),
-      interceptors.responseVerify(),
-      interceptors.redirect(),
-      interceptors.cache(),
-      interceptors.proxy(),
-    )
-    dispatcherCache.set(baseDispatcher, dispatcher)
-  }
-
-  return await undici.request(url, {
+  return await wrapdDispatcher(opts.dispatcher ?? undici.getGlobalDispatcher()).request({
     id: opts.id,
+    origin: url.origin,
+    path: url.path ?? (url.search ? `${url.pathname}${url.search}` : url.pathname),
     method,
-    dispatcher,
     body: opts.body,
     query: opts.query,
     headers,
@@ -97,6 +103,6 @@ export async function request(url, opts) {
     verify: opts.verify ?? true,
     logger: opts.logger ?? null,
     lookup: opts.lookup ?? null,
-    dns: opts.dns ?? null,
+    dns: opts.dns ?? true,
   })
 }

package/lib/interceptor/cache.js

@@ -127,8 +127,7 @@ export default (opts) => (dispatch) => (opts, handler) => {
 
   // TODO (fix): Cache other methods?
   if (opts.method !== 'GET' && opts.method !== 'HEAD') {
-    dispatch(opts, handler)
-    return
+    return dispatch(opts, handler)
   }
 
   if (opts.headers?.['cache-control'] || opts.headers?.authorization) {
@@ -141,8 +140,7 @@ export default (opts) => (dispatch) => (opts, handler) => {
     // cacheControl['min-fresh']
     // cacheControl['no-transform']
     // cacheControl['only-if-cached']
-    dispatch(opts, handler)
-    return
+    return dispatch(opts, handler)
   }
 
   // TODO (fix): Support body...

package/lib/interceptor/dns.js

@@ -1,19 +1,20 @@
 import assert from 'node:assert'
 import { DecoratorHandler } from '../utils.js'
 import CacheableLookup from 'cacheable-lookup'
+import net from 'net'
 
-let DEFAULT_DNS
+const DEFAULT_RESOLVER = new CacheableLookup()
 
 class Handler extends DecoratorHandler {
   #handler
-  #store
+  #resolver
   #key
 
-  constructor({ store, key }, { handler }) {
+  constructor({ resolver, key }, { handler }) {
     super(handler)
 
     this.#handler = handler
-    this.#store = store
+    this.#resolver = resolver
     this.#key = key
   }
 
@@ -28,53 +29,66 @@ class Handler extends DecoratorHandler {
         'ENETUNREACH',
         'EHOSTDOWN',
         'EHOSTUNREACH',
+        'ENODATA',
         'EPIPE',
       ].includes(err.code)
     ) {
-      this.#store.clear(this.#key)
+      this.#resolver.clear(this.#key)
     }
 
     return this.#handler.onError(err)
   }
 }
 
-export default (opts) => (dispatch) => (opts, handler) => {
-  const dns = opts.dns ?? (DEFAULT_DNS ??= new CacheableLookup())
+export default (interceptorOpts) => (dispatch) => (opts, handler) => {
+  const dns = opts.dns
 
   if (!dns) {
-    dispatch(opts, handler)
-    return
+    return dispatch(opts, handler)
   }
 
-  try {
-    assert(typeof dns.lookup === 'function')
-    assert(typeof dns.clear === 'function')
+  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 } = new URL(opts.origin)
+  const { hostname } = new URL(opts.origin)
 
-    const callback = (err, entries) => {
+  if (net.isIP(hostname)) {
+    dispatch(opts, handler)
+  } else {
+    const callback = (err, val) => {
       if (err) {
         handler.onConnect(() => {})
         handler.onError(err)
       } else {
         const url = new URL(opts.origin)
-        url.hostname = entries[Math.floor(entries.length * Math.random())].address
+        url.hostname = Array.isArray(val)
+          ? val[Math.floor(val.length * Math.random())].address
+          : val?.address ?? val
         dispatch(
           { ...opts, origin: url.origin },
-          new Handler({ store: dns, key: hostname }, { handler }),
+          resolver.clear ? new Handler({ resolver, key: hostname }, { handler }) : handler,
         )
       }
     }
 
-    const thenable = dns.lookup(hostname, { all: true }, callback)
-    if (typeof thenable?.then === 'function') {
-      thenable.then(
-        (val) => callback(null, val),
-        (err) => callback(err),
-      )
+    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.onConnect(() => {})
+      handler.onError(err)
     }
-  } catch (err) {
-    handler.onConnect(() => {})
-    handler.onError(err)
   }
 }

package/lib/interceptor/lookup.js

@@ -2,8 +2,7 @@ export default (opts) => (dispatch) => (opts, handler) => {
   const lookup = opts.lookup
 
   if (!lookup) {
-    dispatch(opts, handler)
-    return
+    return dispatch(opts, handler)
   }
 
   const callback = (err, origin) => {
@@ -24,6 +23,6 @@ export default (opts) => (dispatch) => (opts, handler) => {
       )
     }
   } catch (err) {
-    queueMicrotask(() => callback(err))
+    callback(err)
   }
 }

package/lib/interceptor/proxy.js

@@ -55,45 +55,6 @@ class Handler extends DecoratorHandler {
   }
 }
 
-export default (opts) => (dispatch) => (opts, handler) => {
-  if (!opts.proxy) {
-    return dispatch(opts, handler)
-  }
-
-  const expectsPayload =
-    opts.method === 'PUT' ||
-    opts.method === 'POST' ||
-    opts.method === 'PATCH' ||
-    opts.method === 'QUERY'
-
-  const headers = reduceHeaders(
-    {
-      headers: opts.headers ?? {},
-      httpVersion: opts.proxy.httpVersion ?? opts.proxy.req?.httpVersion,
-      socket: opts.proxy.socket ?? opts.proxy.req?.socket,
-      proxyName: opts.proxy.name,
-    },
-    (obj, key, val) => {
-      if (key === 'content-length' && !expectsPayload) {
-        // https://tools.ietf.org/html/rfc7230#section-3.3.2
-        // A user agent SHOULD NOT send a Content-Length header field when
-        // the request message does not contain a payload body and the method
-        // semantics do not anticipate such a body.
-        // undici will error if provided an unexpected content-length: 0 header.
-      }
-      if (key === 'expect') {
-        // undici doesn't support expect header.
-      } else {
-        obj[key] = val
-      }
-      return obj
-    },
-    {},
-  )
-
-  return dispatch({ ...opts, headers }, new Handler(opts.proxy, { handler }))
-}
-
 // This expression matches hop-by-hop headers.
 // These headers are meaningful only for a single transport-level connection,
 // and must not be retransmitted by proxies or cached.
@@ -201,3 +162,42 @@ function printIp(address, port) {
   }
   return str
 }
+
+export default (opts) => (dispatch) => (opts, handler) => {
+  if (!opts.proxy) {
+    return dispatch(opts, handler)
+  }
+
+  const expectsPayload =
+    opts.method === 'PUT' ||
+    opts.method === 'POST' ||
+    opts.method === 'PATCH' ||
+    opts.method === 'QUERY'
+
+  const headers = reduceHeaders(
+    {
+      headers: opts.headers ?? {},
+      httpVersion: opts.proxy.httpVersion ?? opts.proxy.req?.httpVersion,
+      socket: opts.proxy.socket ?? opts.proxy.req?.socket,
+      proxyName: opts.proxy.name,
+    },
+    (obj, key, val) => {
+      if (key === 'content-length' && !expectsPayload) {
+        // https://tools.ietf.org/html/rfc7230#section-3.3.2
+        // A user agent SHOULD NOT send a Content-Length header field when
+        // the request message does not contain a payload body and the method
+        // semantics do not anticipate such a body.
+        // undici will error if provided an unexpected content-length: 0 header.
+      }
+      if (key === 'expect') {
+        // undici doesn't support expect header.
+      } else {
+        obj[key] = val
+      }
+      return obj
+    },
+    {},
+  )
+
+  return dispatch({ ...opts, headers }, new Handler(opts.proxy, { handler }))
+}

package/package.json

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