@nxtedition/nxt-undici 6.3.1 → 6.3.3

package/lib/index.js

@@ -16,6 +16,7 @@ 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,
 }
 
@@ -82,7 +83,7 @@ function wrapDispatch(dispatcher) {
   if (wrappedDispatcher == null) {
     wrappedDispatcher = compose(
       dispatcher,
-      interceptors.log({ bindings: { intercept: 'upstream' } }),
+      interceptors.dns(),
       interceptors.requestBodyFactory(),
       interceptors.responseRetry(),
       interceptors.responseVerify(),
@@ -90,7 +91,7 @@ function wrapDispatch(dispatcher) {
       interceptors.cache(),
       interceptors.redirect(),
       interceptors.lookup(),
-      interceptors.log({ bindings: { intercept: 'downstream' } }),
+      interceptors.log(),
       interceptors.requestId(),
       interceptors.responseError(),
       interceptors.query(),
@@ -123,6 +124,7 @@ function wrapDispatch(dispatcher) {
             error: opts.error ?? opts.throwOnError ?? true,
             verify: opts.verify ?? false,
             logger: opts.logger ?? null,
+            dns: opts.dns ?? true,
             connect: opts.connect,
             lookup: opts.lookup ?? defaultLookup,
           },

package/lib/interceptor/dns.js

@@ -0,0 +1,137 @@
+import net from 'node:net'
+import assert from 'node:assert'
+import * as dns from 'node:dns'
+import { DecoratorHandler, getFastNow } from '../utils.js'
+
+class Handler extends DecoratorHandler {
+  #callback
+  #statusCode
+
+  constructor(handler, callback) {
+    super(handler)
+    this.#callback = callback
+  }
+
+  onHeaders(statusCode, headers, resume) {
+    this.#statusCode = statusCode
+    return super.onHeaders(statusCode, headers, resume)
+  }
+
+  onComplete(trailers) {
+    this.#callback(null, this.#statusCode)
+    super.onComplete(trailers)
+  }
+
+  onError(err) {
+    this.#callback(err, this.#statusCode)
+    super.onError(err)
+  }
+}
+
+export default () => (dispatch) => {
+  const cache = new Map()
+  const promises = new Map()
+
+  function resolve(hostname, { logger }) {
+    let promise = promises.get(hostname)
+    if (!promise) {
+      promise = new Promise((resolve) => {
+        logger?.debug({ dns: { hostname } }, 'lookup started')
+        dns.resolve4(hostname, { ttl: true }, (err, records) => {
+          promises.delete(hostname)
+
+          if (err) {
+            logger?.error({ err, dns: { hostname } }, 'lookup failed')
+
+            resolve([err, null])
+          } else {
+            logger?.debug({ dns: { hostname, records } }, 'lookup completed')
+
+            const now = getFastNow()
+            const val = records.map(({ address, ttl }) => ({
+              address,
+              expires: now + 1e3 * ttl,
+              pending: 0,
+              errored: 0,
+              counter: 0,
+            }))
+
+            cache.set(hostname, val)
+
+            resolve([null, val])
+          }
+        })
+      })
+      promises.set(hostname, promise)
+    }
+    return promise
+  }
+
+  return async (opts, handler) => {
+    if (!opts || !opts.dns || !opts.origin) {
+      return dispatch(opts, handler)
+    }
+
+    const origin = new URL(opts.origin)
+
+    if (net.isIP(origin.hostname)) {
+      return dispatch(opts, handler)
+    }
+
+    try {
+      const { host, hostname } = origin
+
+      const now = getFastNow()
+
+      const logger = opts.dns.logger ?? opts.logger
+
+      let records = cache.get(hostname)
+
+      if (records == null || records.every((x) => x.expires < now)) {
+        const [err, val] = await resolve(hostname, { logger })
+
+        if (err) {
+          throw err
+        }
+
+        assert(val.every((x) => x.expires > 0))
+
+        records = val
+      } else if (records.some((x) => x.expires < now + 1e3)) {
+        resolve(hostname, { logger })
+      }
+
+      records.sort(
+        (a, b) => a.errored - b.errored || a.pending - b.pending || a.counter - b.counter,
+      )
+
+      const record = records.find((x) => x.expires >= now)
+
+      if (!record) {
+        throw Object.assign(new Error(`No available DNS records found for ${hostname}`), {
+          code: 'ENOTFOUND',
+        })
+      }
+
+      origin.hostname = record.address
+
+      dispatch(
+        { ...opts, origin, headers: { ...opts.headers, host } },
+        new Handler(handler, (err, statusCode) => {
+          record.pending--
+
+          if (err != null && err.name !== 'AbortError') {
+            record.expires = 0
+          } else if (statusCode != null && statusCode >= 500) {
+            record.errored++
+          }
+        }),
+      )
+
+      record.counter++
+      record.pending++
+    } catch (err) {
+      handler.onError(err)
+    }
+  }
+}

package/lib/interceptor/dns.test.js

@@ -0,0 +1,82 @@
+import { once } from 'node:events'
+import http from 'node:http'
+import { test } from 'tap'
+import { request } from '../index.js'
+
+test('retry destroy pre response', async (t) => {
+  const { body, statusCode } = await request(`http://google.com`)
+  await body.dump()
+  t.equal(statusCode, 200)
+  t.end()
+})
+
+test('expire & retry on error', async (t) => {
+  t.plan(3)
+
+  const server = http
+    .createServer((req, res) => {
+      res.end()
+    })
+    .listen(0)
+  t.teardown(server.close.bind(server))
+
+  await once(server, 'listening')
+
+  let counter = 0
+  const { body } = await request(`http://asd.com:${server.address().port}`, {
+    dns: {
+      resolve4(hostname, opts, callback) {
+        t.pass()
+        if (counter++ === 0) {
+          process.nextTick(callback, null, [{ address: '11.9.9.9', ttl: 600 }])
+        } else {
+          process.nextTick(callback, null, [{ address: '127.0.0.1', ttl: 600 }])
+        }
+      },
+    },
+    retry: 2,
+  })
+  await body.dump()
+
+  t.pass()
+})
+
+test('expire on error', async (t) => {
+  t.plan(2)
+
+  const server = http
+    .createServer((req, res) => {
+      res.end()
+    })
+    .listen(0)
+  t.teardown(server.close.bind(server))
+
+  await once(server, 'listening')
+
+  try {
+    const { body } = await request(`http://123.com:${server.address().port}`, {
+      dns: {
+        resolve4(hostname, opts, callback) {
+          process.nextTick(callback, null, [{ address: '10.9.9.9', ttl: 600 }])
+        },
+      },
+      retry: false,
+    })
+    await body.dump()
+  } catch (err) {
+    t.equal(err.code, 'UND_ERR_CONNECT_TIMEOUT')
+  }
+
+  const { body } = await request(`http://123.com:${server.address().port}`, {
+    dns: {
+      resolve4(hostname, opts, callback) {
+        process.nextTick(callback, null, [{ address: '127.0.0.1', ttl: 600 }])
+      },
+    },
+    retry: false,
+  })
+  await body.dump()
+
+  console.error('### 4')
+  t.pass()
+})

package/package.json

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