@nxtedition/nxt-undici 6.2.17 → 6.2.19

package/lib/index.js

@@ -15,7 +15,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,
 }
 
@@ -61,7 +60,6 @@ function wrapDispatch(dispatcher) {
     wrappedDispatcher = compose(
       dispatcher,
       interceptors.log({ bindings: { intercept: 'upstream' } }),
-      interceptors.dns(),
       interceptors.requestBodyFactory(),
       interceptors.lookup(),
       interceptors.responseRetry(),
@@ -101,7 +99,6 @@ 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/cache.js

@@ -10,12 +10,14 @@ class CacheHandler extends DecoratorHandler {
   #key
   #value
   #store
+  #logger
   #maxEntrySize
 
-  constructor(key, { store, handler, maxEntrySize }) {
+  constructor(key, { store, logger, handler, maxEntrySize }) {
     super(handler)
 
     this.#key = key
+    this.#logger = logger
     this.#value = null
     this.#store = store
     this.#maxEntrySize = maxEntrySize ?? store.maxEntrySize ?? DEFAULT_MAX_ENTRY_SIZE
@@ -156,7 +158,11 @@ class CacheHandler extends DecoratorHandler {
   onComplete(trailers) {
     if (this.#value && (!trailers || Object.keys(trailers).length === 0)) {
       this.#value.end ??= this.#value.start + this.#value.size
-      this.#store.set(this.#key, this.#value)
+      try {
+        this.#store.set(this.#key, this.#value)
+      } catch (err) {
+        this.#logger?.error({ err }, 'failed to set cache entry')
+      }
       this.#value = null
     }
 
@@ -194,7 +200,12 @@ export default () => (dispatch) => (opts, handler) => {
 
   // TODO (fix): enable range requests
 
-  const entry = store.get(opts)
+  let entry
+  try {
+    entry = store.get(opts)
+  } catch (err) {
+    opts.logger?.error({ err }, 'failed to get cache entry')
+  }
 
   if (!entry && !cacheControlDirectives['only-if-cached']) {
     return dispatch(
@@ -204,6 +215,7 @@ export default () => (dispatch) => (opts, handler) => {
         : new CacheHandler(undici.util.cache.makeCacheKey(opts), {
             maxEntrySize: opts.cache.maxEntrySize,
             store,
+            logger: opts.logger,
             handler,
           }),
     )

package/package.json

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

package/lib/interceptor/dns.js

@@ -1,137 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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()
-})