This has been a recurring error on our site, on latest browser version. Couldn't reproduce myself yet. Reporting here for the record, I will see if I can fix this

                return response
            })
            .catch(error => {
                // Reject pending promises on error
                inflight.get(_key).forEach(([resolve, reject]) => reject(error))  <--- HERE
                inflight.delete(_key)
                throw error
            })
    }

When the request fails, no retry is performed when net::ERR_HTTP2_PING_FAILED is returned

I have noticed that both the retry and dedupe modules call response.clone() at least once for each request, even when the body is not read. This can be harmful to performance in applications such as serverless functions (eg. Cloudflare Workers), in situations where the body is never read or is streamed through in the function's response.

I would recommend to remove these response.clone() calls. Instead a disclaimer could be added in the documentation reminding the user that, if their until or onRetry function reads the response body, they should call response.clone() themselves. I can create a PR with this changed, but wanted to get feedback on such a change first.

Is there a way to make retry middleware work only on specified error (503 with specified json result)?

Hey, I am working on a NodeJS project (using TypeScript) and I had the following code roughly:

const data = await wretch(url)
        .middlewares([
          retry()
        ])
        .get()
        .json();

And having the middleware in there causes an infinitely pending await.

At first I thought I did something wrong, and tried different things.

For that I changed it to the following:

const response = await wretch(url)
  .middlewares([
    retry()
  ])
  .get()
  .res();

let data;
try {
  data = await response.json();
} catch (e) {
  console.log(e);
}

This now correctly returns a response object, where I can see that the request was successful.

But as soon as I call .json() I once again have a indefinitely hanging promise. The same is true for other Promises based resolvers for the body like .text().

I setup the polyfills for NodeJS as described on the main repository.

So I had the idea that it might be caused by the node-fetch polyfill. So I compiled the Typescript files, and ran it with the flag --experimental-fetch (Node version 17.5.0) and indeed, it works flawlessly when using the built-in fetch function.

But the problem is, in my project setup using this experimental flag is rather awkward and I would prefer to not use it, while keeping the middleware in there.

So my final question is:

Do you have any idea how to fix this (/circumvent it). Maybe a different resolver can already give me what I want, but so far I didn't get anything working which I wanted to work.

I want to mention two more things:

The delay middleware works without any issues.

Also the request I am doing does not do a single retry, but is successful in the first try. I also didn't consume the Request in any way.

Apologies for the basic question and thank you for this code

How does one retrieve the original raised error here? If I am making a request to an endpoint and that endpoint is returning a 403 my request will fail after e.g. 3 attempts and the raised error will be "max attempts exceeded" in the catch block - how do we instead raise the error in a forbidden block:

client
            .url('cs_auth')
            .post({ id })
            .forbidden(() => {
                // This block will never be run even though it should be
                setTryingActivation(false);
                setError({severity: 'error', message: "id number is not preapproved. Please contact your administrator"})
            })
            .json((json) => {
                setId(json.id);
                setTryingActivation(false);
            })
            .catch((err) => {
                // This block will be the only one run even though the error is a 403
                setTryingActivation(false);
                console.log(err)
                return setError({ severity: 'error', message: err.toString() });
            });

I would like to change the onRetry method and make it asynchronous. For example it would be nice to refresh an authentication token before retrying the request. Do you plan on adding this feature?

This seems like a strange question, but is it possible to get the retry middleware to retry a request without returning the request error, unless it fails the maximum number of retries?

I am trying to implement a use case when a user performs a request without internet. When I use the retry middleware, the retry is not called if the user isOffline. How would you implement it?