🐛 Fix custom error conflicting with catchers

Author: elbywan

.github/workflows/node.yml

@@ -28,7 +28,7 @@ jobs:
       - name: Build
         run: npm run build
       - name: Unit tests
-        run: npm run test
+        run: npm run test:node
       - name: Coveralls
         if: ${{ success() }}
         uses: coverallsapp/github-action@master

package.json

@@ -116,7 +116,8 @@
     "prebuild": "rimraf dist && rimraf coverage && npm run lint",
     "build": "tsc && tsc --project tsconfig.cjs.json && echo '{\"type\": \"commonjs\"}' > ./dist/cjs/package.json && rolldown -c ./rolldown.config.ts",
     "mock": "node scripts/mockServer.js",
-    "test": "node scripts/runWithMockServer.js \"c8 node --import tsx --test test/node/*.spec.ts --test test/node/**/*.spec.ts\"",
+    "test": "npm run test:node && npm run test:browser && npm run test:deno && npm run test:bun && npm run test:snippets",
+    "test:node": "node scripts/runWithMockServer.js \"c8 node --import tsx --test test/node/*.spec.ts --test test/node/**/*.spec.ts\"",
     "test:browser": "node scripts/runWithMockServer.js web-test-runner",
     "test:browser:watch": "node scripts/runWithMockServer.js \"web-test-runner --watch\"",
     "test:deno": "node scripts/runWithMockServer.js \"deno test --allow-net --allow-read --no-check --sloppy-imports --config test/deno/deno.json test/deno/wretch.spec.ts\"",

src/resolver.ts

@@ -1,6 +1,6 @@
 import { middlewareHelper } from "./middleware.js"
 import type { Wretch, WretchResponse, WretchResponseChain, WretchError as WretchErrorType } from "./types.js"
-import { FETCH_ERROR, CATCHER_FALLBACK } from "./constants.js"
+import { CATCHER_FALLBACK, FETCH_ERROR } from "./constants.js"
 
 /**
  * This class inheriting from Error is thrown when the fetch response is not "ok".
@@ -45,9 +45,6 @@ export const resolver = <T, Chain, R, E>(wretch: T & Wretch<T, Chain, R, E>) =>
   // Throws on an http error
   const referenceError = new Error()
   const throwingPromise: Promise<void | WretchResponse> = _fetchReq
-    .catch(error => {
-      throw { [FETCH_ERROR]: error }
-    })
     .then(async response => {
       if (!response.ok) {
         const err = new WretchError()
@@ -57,19 +54,14 @@ export const resolver = <T, Chain, R, E>(wretch: T & Wretch<T, Chain, R, E>) =>
         err.status = response.status
         err.url = finalUrl
 
-        if (response.type === "opaque") {
-          err.message = response.statusText
-          throw err
-        }
-
-        if (errorTransformer) {
-          throw await errorTransformer(err, response)
-        }
-
-        try {
-          err.message = await response.text()
-        } catch {
+        if (response.type === "opaque" || errorTransformer) {
           err.message = response.statusText
+        } else {
+          try {
+            err.message = await response.text()
+          } catch {
+            err.message = response.statusText
+          }
         }
 
         throw err
@@ -78,16 +70,18 @@ export const resolver = <T, Chain, R, E>(wretch: T & Wretch<T, Chain, R, E>) =>
     })
   // Wraps the Promise in order to dispatch the error to a matching catcher
   const catchersWrapper = <T>(promise: Promise<T>): Promise<void | T> =>
-    promise.catch(err => {
-      const fetchErrorFlag = FETCH_ERROR in err
-      const error = fetchErrorFlag ? err[FETCH_ERROR] : err
+    promise.catch(async error => {
 
       const catcher =
-        (error?.status && catchers.get(error.status)) ||
+        catchers.get(error?.status) ||
         catchers.get(error?.name) ||
-        (fetchErrorFlag && catchers.get(FETCH_ERROR)) ||
+        (!(error instanceof WretchError) && catchers.get(FETCH_ERROR)) ||
         catchers.get(CATCHER_FALLBACK)
 
+      if(error.response && errorTransformer) {
+        error = await errorTransformer(error, error.response)
+      }
+
       if (catcher)
         return catcher(error, wretch)
 

test/shared/wretch.spec.ts

@@ -529,11 +529,13 @@ export function createWretchTests(ctx: TestContext): void {
 
     it("should allow transforming errors with fully typed error bodies", async function () {
       await wretch(`${_URL}/json500raw`)
-        .customError(async (error, response) => {
-          return { ...error, message: response.statusText, json: await response.json() }
+        .customError(async (_error, response) => {
+          const err = new Error(response.statusText)
+          err["json"] = await response.json()
+          return err
         })
         .get()
-        .internalError(error => {
+        .internalError((error: any) => {
           expect(error.json).toEqual({ error: 500, message: "ok" })
           expect(error.message).toEqual("Internal Server Error")
         })