@nxtedition/nxt-undici 6.2.16 → 6.2.18

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/response-retry.js

@@ -252,29 +252,26 @@ class Handler extends DecoratorHandler {
     let retryPromise
     try {
       if (typeof this.#opts.retry === 'function') {
-        retryPromise = this.#opts.retry(
-          decorateError(err, this.#opts, {
-            statusCode: this.#statusCode,
-            headers: this.#headers,
-            trailers: this.#trailers,
-            body: this.#body,
-          }),
-          this.#retryCount,
-          this.#opts,
-          () => this.#retryFn(err, this.#retryCount, this.#opts),
+        retryPromise = Promise.resolve(
+          this.#opts.retry(
+            decorateError(err, this.#opts, {
+              statusCode: this.#statusCode,
+              headers: this.#headers,
+              trailers: this.#trailers,
+              body: this.#body,
+            }),
+            this.#retryCount,
+            this.#opts,
+            () => this.#retryFn(err, this.#retryCount, this.#opts),
+          ),
         )
       } else {
-        retryPromise = this.#retryFn(err, this.#retryCount, this.#opts)
+        retryPromise = Promise.resolve(this.#retryFn(err, this.#retryCount, this.#opts))
       }
     } catch (err) {
       retryPromise = Promise.reject(err)
     }
 
-    if (retryPromise == null) {
-      this.#maybeError(err)
-      return
-    }
-
     retryPromise
       .then((shouldRetry) => {
         if (this.#aborted) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/nxt-undici",
-  "version": "6.2.16",
+  "version": "6.2.18",
   "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()
-})