interceptors: move throwOnError to interceptor

lib/api/index.js

@@ -5,3 +5,6 @@ module.exports.stream = require('./api-stream')
 module.exports.pipeline = require('./api-pipeline')
 module.exports.upgrade = require('./api-upgrade')
 module.exports.connect = require('./api-connect')
+
+module.exports.responseErrorInterceptor = require('../interceptor/response-error')
+module.exports.retryInterceptor = require('../interceptor/retry')

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

@@ -0,0 +1,87 @@
+'use strict'
+
+const { parseHeaders } = require('../core/util')
+const { DecoratorHandler } = require('undici')
+const { ResponseError } = require('../core/errors')
+
+class Handler extends DecoratorHandler {
+  #handler
+  #statusCode
+  #contentType
+  #decoder
+  #headers
+  #body
+  #errored
+
+  constructor (opts, { handler }) {
+    super(handler)
+    this.#handler = handler
+    this.opts = opts
+  }
+
+  onConnect (abort) {
+    this.#statusCode = 0
+    this.#contentType = null
+    this.#decoder = null
+    this.#headers = null
+    this.#body = ''
+    this.#errored = false
+
+    return this.#handler.onConnect(abort)
+  }
+
+  onHeaders (statusCode, rawHeaders, resume, statusMessage, headers = parseHeaders(rawHeaders)) {
+    this.#statusCode = statusCode
+    this.#headers = headers
+    this.#contentType = headers['content-type']
+
+    if (this.#statusCode < 400) {
+      return this.#handler.onHeaders(statusCode, rawHeaders, resume, statusMessage, headers)
+    }
+
+    if (this.#contentType === 'application/json' || this.#contentType === 'text/plain') {
+      this.#decoder = new TextDecoder('utf-8')
+    }
+  }
+
+  onData (chunk) {
+    if (this.#statusCode >= 400) {
+      this.#body += this.#decoder?.decode(chunk, { stream: true }) ?? ''
+    } else {
+      return this.#handler.onData(chunk)
+    }
+  }
+
+  onComplete (rawTrailers) {
+    if (this.#statusCode >= 400) {
+      this.#body += this.#decoder?.decode(undefined, { stream: false }) ?? ''
+
+      if (this.#contentType === 'application/json') {
+        try {
+          this.#body = JSON.parse(this.#body)
+        } catch {
+          // Do nothing...
+        }
+      }
+
+      this.#errored = true
+
+      const err = new ResponseError('Response Error', this.#statusCode, this.#headers, this.#body)
+
+      if (this.opts.throwOnError !== false && (this.opts.error !== false || (Array.isArray(this.opts.statusCodes) && this.opts.statusCodes.includes(this.#statusCode)))) {
+        this.#handler.onError(err)
+      } else {
+        this.#handler.onComplete(rawTrailers)
+      }
+    } else {
+      this.#handler.onComplete(rawTrailers)
+    }
+  }
+
+  onError (err) {
+    this.#handler.onError(err)
+  }
+}
+
+module.exports = (dispatch) => (opts, handler) =>
+  dispatch(opts, new Handler(opts, { handler }))

test/interceptors/response-error.js

@@ -0,0 +1,18 @@
+'use strict'
+
+const assert = require('assert')
+const { test } = require('node:test')
+const createResponseErrorInterceptor = require('../../lib/interceptor/response-error')
+
+test('should not error if request is not meant to be retried', async (t) => {
+  const response = { statusCode: 400 }
+  const handler = {
+    onError: () => {},
+    onData: () => {},
+    onComplete: () => {}
+  }
+
+  const interceptor = createResponseErrorInterceptor((opts, handler) => handler.onComplete())
+
+  assert.doesNotThrow(() => interceptor({ response, throwOnError: false }, handler))
+})