@nxtedition/nxt-undici 6.0.10 → 6.0.12

package/lib/interceptor/dns.js

@@ -8,19 +8,29 @@ const MAX_TTL = 10e3
 
 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.#callback(null, this.#statusCode)
     super.onComplete(trailers)
   }
 
   onError(err) {
-    this.#callback(err)
+    if (err?.statusCode == null) {
+      this.#callback(err)
+    } else if (err.statusCode) {
+      this.#callback(null, err.statusCode)
+    }
     super.onError(err)
   }
 }
@@ -35,14 +45,15 @@ export default () => (dispatch) => {
       promise = resolve4(hostname, { ttl: true })
         .then((records) => {
           const now = getFastNow()
-          const prev = cache.get(hostname)
-          const next = records.map(({ address, ttl }) => ({
+          const ret = records.map(({ address, ttl }) => ({
             address,
             expires: now + Math.min(MAX_TTL, 1e3 * ttl),
-            stats: prev?.find((x) => x.address === address)?.stats || { pending: 0, errored: 0 },
+            pending: 0,
+            errored: 0,
+            counter: 0,
           }))
-          cache.set(hostname, next)
-          return next
+          cache.set(hostname, ret)
+          return ret
         })
         .finally(() => {
           promises.delete(hostname)
@@ -69,22 +80,22 @@ export default () => (dispatch) => {
 
     let records = cache.get(hostname)
 
-    if (records == null || records.every((x) => x.stats.errored || x.expires < now)) {
+    if (records == null || records.every((x) => x.expires < now)) {
       records = await resolve(hostname)
-    } else if (records.some((x) => x.errored || x.expires < now + 1e3)) {
+    } else if (records.some((x) => x.expires < now + 1e3)) {
       resolve(hostname).catch(noop)
     }
 
     records.sort((a, b) => {
-      if (a.stats.errored !== b.stats.errored) {
-        return a.stats.errored - b.stats.errored
+      if (a.errored !== b.errored) {
+        return a.errored - b.errored
       }
 
-      if (a.stats.pending !== b.stats.pending) {
-        return a.stats.pending - b.stats.pending
+      if (a.pending !== b.pending) {
+        return a.pending - b.pending
       }
 
-      return 0
+      return a.counter - b.counter
     })
 
     const record = records.find((x) => x.expires >= now)
@@ -97,25 +108,23 @@ export default () => (dispatch) => {
 
     origin.hostname = record.address
 
-    record.stats.pending++
+    record.counter++
+    record.pending++
     try {
       return dispatch(
         { ...opts, origin, headers: { ...opts.headers, host } },
-        new Handler(handler, (err) => {
-          record.stats.pending--
-          if (err == null) {
-            record.stats.errored = 0
-          } else if (err.name === 'AbortError') {
-            // Do nothing...
-          } else if (err.statusCode == null || err.statusCode >= 500) {
-            record.stats.errored++
-          } else {
-            record.stats.errored = 0
+        new Handler(handler, (err, statusCode) => {
+          record.pending--
+
+          if (statusCode != null && statusCode >= 500) {
+            record.errored++
+          } else if (err != null && err.name !== 'AbortError') {
+            record.expires = 0
           }
         }),
       )
     } catch (err) {
-      record.stats.pending--
+      record.pending--
       throw err
     }
   }

package/package.json

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