feat: added new undiciError

lib/core/errors.js

@@ -195,6 +195,18 @@ class RequestRetryError extends UndiciError {
   }
 }
 
+class ResponseError extends UndiciError {
+  constructor (message, code, { headers, data }) {
+    super(message)
+    this.name = 'ResponseError'
+    this.message = message || 'Response error'
+    this.code = 'UND_ERR_RESPONSE'
+    this.statusCode = code
+    this.data = data
+    this.headers = headers
+  }
+}
+
 class SecureProxyConnectionError extends UndiciError {
   constructor (cause, message, options) {
     super(message, { cause, ...(options ?? {}) })
@@ -227,5 +239,6 @@ module.exports = {
   BalancedPoolMissingUpstreamError,
   ResponseExceededMaxSizeError,
   RequestRetryError,
+  ResponseError,
   SecureProxyConnectionError
 }

lib/interceptor/response-error.js

@@ -1,8 +1,8 @@
 'use strict'
 
 const { parseHeaders } = require('../core/util')
-const http = require('node:http')
 const { DecoratorHandler } = require('undici')
+const { ResponseError } = require('../core/errors')
 
 class Handler extends DecoratorHandler {
   #handler
@@ -66,22 +66,7 @@ class Handler extends DecoratorHandler {
 
       this.#errored = true
 
-      let err
-
-      const stackTraceLimit = Error.stackTraceLimit
-      Error.stackTraceLimit = 0
-      try {
-        err = Object.assign(new Error(http.STATUS_CODES[this.#statusCode]), {
-          statusCode: this.#statusCode,
-          status: this.#statusCode,
-          reason: this.#body?.reason,
-          error: this.#body?.error,
-          headers: this.#headers,
-          body: this.#body
-        })
-      } finally {
-        Error.stackTraceLimit = stackTraceLimit
-      }
+      const err = new ResponseError('Response Error', this.#statusCode, this.#headers, this.#body)
 
       if (this.opts.throwOnError !== false && this.opts.error !== false) {
         this.#handler.onError(err)

lib/interceptor/retry.js

@@ -1,27 +1,19 @@
 'use strict'
-
 const RetryHandler = require('../handler/retry-handler')
-const createResponseErrorInterceptor = require('./response-error')
 
 module.exports = globalOpts => {
   return dispatch => {
-    const responseErrorInterceptor = createResponseErrorInterceptor(dispatch)
-
     return function retryInterceptor (opts, handler) {
-      const wrappedHandler = {
-        onConnect: handler.onConnect ? handler.onConnect.bind(handler) : undefined,
-        onHeaders: handler.onHeaders.bind(handler),
-        onData: handler.onData.bind(handler),
-        onComplete: handler.onComplete.bind(handler),
-        onError: handler.onError.bind(handler)
-      }
-
-      const finalHandler = new RetryHandler(
-        { ...opts, retryOptions: { ...globalOpts, ...opts.retryOptions } },
-        { handler: wrappedHandler, dispatch }
+      return dispatch(
+        opts,
+        new RetryHandler(
+          { ...opts, retryOptions: { ...globalOpts, ...opts.retryOptions } },
+          {
+            handler,
+            dispatch
+          }
+        )
       )
-
-      return responseErrorInterceptor(opts, finalHandler)
     }
   }
 }