@nxtedition/nxt-undici 6.0.12 → 6.0.15

package/lib/interceptor/dns.js

@@ -1,9 +1,7 @@
 import net from 'node:net'
-import { resolve4 } from 'node:dns/promises'
+import { resolve4 } from 'node:dns'
 import { DecoratorHandler, getFastNow } from '../utils.js'
 
-function noop() {}
-
 const MAX_TTL = 10e3
 
 class Handler extends DecoratorHandler {
@@ -42,22 +40,32 @@ export default () => (dispatch) => {
   function resolve(hostname) {
     let promise = promises.get(hostname)
     if (!promise) {
-      promise = resolve4(hostname, { ttl: true })
-        .then((records) => {
-          const now = getFastNow()
-          const ret = records.map(({ address, ttl }) => ({
-            address,
-            expires: now + Math.min(MAX_TTL, 1e3 * ttl),
-            pending: 0,
-            errored: 0,
-            counter: 0,
-          }))
+      promise = new Promise((resolve) =>
+        resolve4(hostname, { ttl: true }, (err, records) => {
+          let ret
+
+          if (err) {
+            ret = { error: err }
+          } else {
+            const now = getFastNow()
+            ret = {
+              value: records.map(({ address, ttl }) => ({
+                address,
+                expires: now + Math.min(MAX_TTL, 1e3 * ttl),
+                pending: 0,
+                errored: 0,
+                counter: 0,
+              })),
+            }
+          }
+
           cache.set(hostname, ret)
-          return ret
-        })
-        .finally(() => {
+
           promises.delete(hostname)
-        })
+
+          resolve(ret)
+        }),
+      )
       promises.set(hostname, promise)
     }
     return promise
@@ -74,44 +82,34 @@ export default () => (dispatch) => {
       return dispatch(opts, handler)
     }
 
-    const { host, hostname } = origin
-
-    const now = getFastNow()
+    try {
+      const { host, hostname } = origin
 
-    let records = cache.get(hostname)
+      const now = getFastNow()
 
-    if (records == null || records.every((x) => x.expires < now)) {
-      records = await resolve(hostname)
-    } else if (records.some((x) => x.expires < now + 1e3)) {
-      resolve(hostname).catch(noop)
-    }
+      let records = cache.get(hostname)?.value
 
-    records.sort((a, b) => {
-      if (a.errored !== b.errored) {
-        return a.errored - b.errored
+      if (records == null || records.every((x) => x.expires < now)) {
+        records = await resolve(hostname)
+      } else if (records.some((x) => x.expires < now + 1e3)) {
+        resolve(hostname)
       }
 
-      if (a.pending !== b.pending) {
-        return a.pending - b.pending
-      }
-
-      return a.counter - b.counter
-    })
+      records.sort(
+        (a, b) => a.errored - b.errored || a.pending - b.pending || a.counter - b.counter,
+      )
 
-    const record = records.find((x) => x.expires >= now)
+      const record = records.find((x) => x.expires >= now)
 
-    if (!record) {
-      throw Object.assign(new Error(`No available DNS records found for ${hostname}`), {
-        code: 'ENOTFOUND',
-      })
-    }
+      if (!record) {
+        throw Object.assign(new Error(`No available DNS records found for ${hostname}`), {
+          code: 'ENOTFOUND',
+        })
+      }
 
-    origin.hostname = record.address
+      origin.hostname = record.address
 
-    record.counter++
-    record.pending++
-    try {
-      return dispatch(
+      dispatch(
         { ...opts, origin, headers: { ...opts.headers, host } },
         new Handler(handler, (err, statusCode) => {
           record.pending--
@@ -123,9 +121,11 @@ export default () => (dispatch) => {
           }
         }),
       )
+
+      record.counter++
+      record.pending++
     } catch (err) {
-      record.pending--
-      throw err
+      handler.onError(err)
     }
   }
 }

package/lib/interceptor/response-retry.js

@@ -152,7 +152,7 @@ class Handler extends DecoratorHandler {
 
     let retryPromise
     try {
-      retryPromise = retryFn(err, this.#retryCount, { ...this.#opts.retry })
+      retryPromise = retryFn(err, this.#retryCount, this.#opts)
     } catch (err) {
       retryPromise = Promise.reject(err)
     }

package/lib/utils.js

@@ -80,19 +80,21 @@ export function parseContentRange(range) {
 }
 
 export async function retry(err, retryCount, opts) {
-  if (!opts) {
+  let retryOpts = opts?.retry
+
+  if (retryOpts) {
     throw err
   }
 
-  if (typeof opts === 'function') {
-    return opts(err, retryCount, opts, (opts) => retry(err, retryCount, opts))
+  if (typeof retryOpts === 'function') {
+    return retryOpts(err, retryCount, opts, () => retry(err, retryCount, opts))
   }
 
-  if (typeof opts === 'number') {
-    opts = { count: opts }
+  if (typeof retryOpts === 'number') {
+    retryOpts = { count: retryOpts }
   }
 
-  const retryMax = opts?.count ?? 8
+  const retryMax = retryOpts?.count ?? 8
 
   if (retryCount > retryMax) {
     throw err

package/package.json

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