@nxtedition/nxt-undici 6.1.1 → 6.1.3

package/lib/index.js

@@ -60,15 +60,15 @@ function wrapDispatch(dispatcher) {
     wrappedDispatcher = compose(
       dispatcher,
       interceptors.log({ bindings: { intercept: 'upstream' } }),
-      interceptors.responseError(),
-      interceptors.requestBodyFactory(),
       interceptors.dns(),
+      interceptors.requestBodyFactory(),
       interceptors.lookup(),
       interceptors.requestId(),
       interceptors.responseRetry(),
       interceptors.responseVerify(),
       interceptors.proxy(),
       interceptors.cache(),
+      interceptors.responseError(),
       interceptors.redirect(),
       interceptors.log({ bindings: { intercept: 'downstream' } }),
       (dispatch) => (opts, handler) => {
@@ -88,7 +88,7 @@ function wrapDispatch(dispatcher) {
             headers,
             signal: opts.signal,
             reset: opts.reset ?? false,
-            blocking: opts.blocking ?? opts.method !== 'HEAD',
+            blocking: opts.blocking ?? true,
             headersTimeout: opts.headersTimeout,
             bodyTimeout: opts.bodyTimeout,
             idempotent: opts.idempotent,
@@ -96,8 +96,8 @@ function wrapDispatch(dispatcher) {
             proxy: opts.proxy ?? false,
             cache: opts.cache ?? false,
             upgrade: opts.upgrade ?? false,
-            follow: opts.follow ?? 8,
-            error: opts.error ?? true,
+            follow: opts.follow ?? opts.redirect ?? 8,
+            error: opts.error ?? opts.throwOnError ?? true,
             verify: opts.verify ?? false,
             logger: opts.logger ?? null,
             dns: opts.dns ?? true,

package/lib/interceptor/cache.js

@@ -3,7 +3,6 @@ import { DecoratorHandler, parseCacheControl } from '../utils.js'
 
 const DEFAULT_STORE = new undici.cacheStores.SqliteCacheStore({ location: ':memory:' })
 const DEFAULT_MAX_ENTRY_SIZE = 128 * 1024
-const EMPTY_BUFFER = Buffer.alloc(0)
 const NOOP = () => {}
 
 class CacheHandler extends DecoratorHandler {
@@ -201,9 +200,11 @@ export default () => (dispatch) => (opts, handler) => {
     return
   }
 
-  handler.onData(body ?? EMPTY_BUFFER)
-  if (aborted) {
-    return
+  if (body?.byteLength) {
+    handler.onData(body)
+    if (aborted) {
+      return
+    }
   }
 
   handler.onComplete({})

package/lib/interceptor/dns.js

@@ -23,11 +23,7 @@ class Handler extends DecoratorHandler {
   }
 
   onError(err) {
-    if (err?.statusCode == null) {
-      this.#callback(err)
-    } else if (err.statusCode) {
-      this.#callback(null, err.statusCode)
-    }
+    this.#callback(err, this.#statusCode)
     super.onError(err)
   }
 }
@@ -124,10 +120,10 @@ export default () => (dispatch) => {
         new Handler(handler, (err, statusCode) => {
           record.pending--
 
-          if (statusCode != null && statusCode >= 500) {
-            record.errored++
-          } else if (err != null && err.name !== 'AbortError') {
+          if (err != null && err.name !== 'AbortError') {
             record.expires = 0
+          } else if (statusCode != null && statusCode >= 500) {
+            record.errored++
           }
         }),
       )

package/lib/interceptor/response-error.js

@@ -122,6 +122,6 @@ class Handler extends DecoratorHandler {
 }
 
 export default () => (dispatch) => (opts, handler) =>
-  opts.throwOnError !== false
+  opts.throwOnError !== false && opts.error !== false
     ? dispatch(opts, new Handler(opts, { handler }))
     : dispatch(opts, handler)

package/lib/interceptor/response-retry.js

@@ -1,5 +1,6 @@
 import assert from 'node:assert'
-import { DecoratorHandler, isDisturbed, parseRangeHeader, retry as retryFn } from '../utils.js'
+import tp from 'node:timers/promises'
+import { DecoratorHandler, isDisturbed, parseRangeHeader } from '../utils.js'
 
 // TODO (fix): What about onUpgrade?
 class Handler extends DecoratorHandler {
@@ -10,6 +11,8 @@ class Handler extends DecoratorHandler {
   #headersSent = false
   #errorSent = false
 
+  #statusCode = 0
+
   #abort
   #aborted = false
   #reason
@@ -37,6 +40,8 @@ class Handler extends DecoratorHandler {
   }
 
   onConnect(abort) {
+    this.#statusCode = 0
+
     if (!this.#headersSent) {
       this.#pos = null
       this.#end = null
@@ -101,6 +106,9 @@ class Handler extends DecoratorHandler {
         this.#pos = 0
         this.#end = contentLength
         this.#etag = headers.etag
+      } else if (statusCode >= 400) {
+        this.#statusCode = statusCode
+        return true
       } else {
         return this.#onHeaders(statusCode, headers, resume)
       }
@@ -144,6 +152,11 @@ class Handler extends DecoratorHandler {
   }
 
   onData(chunk) {
+    if (this.#statusCode >= 400) {
+      // TODO (fix): Limit the amount of data we read?
+      return true
+    }
+
     if (this.#pos != null) {
       this.#pos += chunk.byteLength
     }
@@ -151,6 +164,18 @@ class Handler extends DecoratorHandler {
   }
 
   onError(err) {
+    this.#maybeRetry(err)
+  }
+
+  onComplete(trailers) {
+    if (this.#statusCode >= 400) {
+      this.#maybeRetry({ statusCode: this.#statusCode })
+    } else {
+      super.onComplete(trailers)
+    }
+  }
+
+  #maybeRetry(err) {
     if (this.#aborted || isDisturbed(this.#opts.body) || (this.#pos && !this.#etag)) {
       this.#onError(err)
       return
@@ -221,7 +246,69 @@ class Handler extends DecoratorHandler {
 }
 
 export default () => (dispatch) => (opts, handler) =>
-  // TODO (fix): HEAD, PUT, PATCH, DELETE, OPTIONS?
-  opts.retry !== false && opts.method === 'GET' && !opts.upgrade
+  opts.retry !== false &&
+  !opts.upgrade &&
+  (opts.method === 'HEAD' ||
+    opts.method === 'GET' ||
+    opts.method === 'PUT' ||
+    opts.method === 'PATCH' ||
+    opts.idempotent)
     ? dispatch(opts, new Handler(opts, { handler, dispatch }))
     : dispatch(opts, handler)
+
+async function retryFn(err, retryCount, opts) {
+  let retryOpts = opts?.retry
+
+  if (!retryOpts) {
+    throw err
+  }
+
+  if (typeof retryOpts === 'function') {
+    return retryOpts(err, retryCount, opts, () => retryFn(err, retryCount, opts))
+  }
+
+  if (typeof retryOpts === 'number') {
+    retryOpts = { count: retryOpts }
+  }
+
+  const retryMax = retryOpts?.count ?? 8
+
+  if (retryCount > retryMax) {
+    throw err
+  }
+
+  const statusCode = err.statusCode ?? err.status ?? err.$metadata?.httpStatusCode ?? null
+
+  if (statusCode && [420, 429, 502, 503, 504].includes(statusCode)) {
+    let retryAfter = err.headers?.['retry-after'] ? err.headers['retry-after'] * 1e3 : null
+    retryAfter = Number.isFinite(retryAfter) ? retryAfter : Math.min(10e3, retryCount * 1e3)
+    if (retryAfter != null && Number.isFinite(retryAfter)) {
+      return tp.setTimeout(retryAfter, undefined, { signal: opts.signal })
+    } else {
+      return null
+    }
+  }
+
+  if (
+    err.code &&
+    [
+      'ECONNRESET',
+      'ECONNREFUSED',
+      'ENOTFOUND',
+      'ENETDOWN',
+      'ENETUNREACH',
+      'EHOSTDOWN',
+      'EHOSTUNREACH',
+      'EPIPE',
+      'UND_ERR_CONNECT_TIMEOUT',
+    ].includes(err.code)
+  ) {
+    return tp.setTimeout(Math.min(10e3, retryCount * 1e3), undefined, { signal: opts.signal })
+  }
+
+  if (err.message && ['other side closed'].includes(err.message)) {
+    return tp.setTimeout(Math.min(10e3, retryCount * 1e3), undefined, { signal: opts.signal })
+  }
+
+  throw err
+}

package/lib/utils.js

@@ -1,4 +1,3 @@
-import tp from 'node:timers/promises'
 import cacheControlParser from 'cache-control-parser'
 import stream from 'node:stream'
 import { util } from '@nxtedition/undici'
@@ -79,63 +78,6 @@ export function parseContentRange(range) {
   return { start, end: end ? end + 1 : size, size }
 }
 
-export async function retry(err, retryCount, opts) {
-  let retryOpts = opts?.retry
-
-  if (!retryOpts) {
-    throw err
-  }
-
-  if (typeof retryOpts === 'function') {
-    return retryOpts(err, retryCount, opts, () => retry(err, retryCount, opts))
-  }
-
-  if (typeof retryOpts === 'number') {
-    retryOpts = { count: retryOpts }
-  }
-
-  const retryMax = retryOpts?.count ?? 8
-
-  if (retryCount > retryMax) {
-    throw err
-  }
-
-  const statusCode = err.statusCode ?? err.status ?? err.$metadata?.httpStatusCode ?? null
-
-  if (statusCode && [420, 429, 502, 503, 504].includes(statusCode)) {
-    let retryAfter = err.headers?.['retry-after'] ? err.headers['retry-after'] * 1e3 : null
-    retryAfter = Number.isFinite(retryAfter) ? retryAfter : Math.min(10e3, retryCount * 1e3)
-    if (retryAfter != null && Number.isFinite(retryAfter)) {
-      return tp.setTimeout(retryAfter, undefined, { signal: opts.signal })
-    } else {
-      return null
-    }
-  }
-
-  if (
-    err.code &&
-    [
-      'ECONNRESET',
-      'ECONNREFUSED',
-      'ENOTFOUND',
-      'ENETDOWN',
-      'ENETUNREACH',
-      'EHOSTDOWN',
-      'EHOSTUNREACH',
-      'EPIPE',
-      'UND_ERR_CONNECT_TIMEOUT',
-    ].includes(err.code)
-  ) {
-    return tp.setTimeout(Math.min(10e3, retryCount * 1e3), undefined, { signal: opts.signal })
-  }
-
-  if (err.message && ['other side closed'].includes(err.message)) {
-    return tp.setTimeout(Math.min(10e3, retryCount * 1e3), undefined, { signal: opts.signal })
-  }
-
-  throw err
-}
-
 export function parseURL(url) {
   if (typeof url === 'string') {
     url = new URL(url)

package/package.json

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