useQuery `refetchOnWindowFocus` option does not respect `retry` value

[himankpathak]

Describe the bug

useQuery option refetchOnWindowFocus does not verify if the retry option value.
Queries are fetched unnecessary even when retry is set to false, retryCount resets every time on window focus.

Your minimal, reproducible example

https://codesandbox.io/s/react-query-continuous-fetching-on-error-40liyc

Steps to reproduce

1. Create a useQuery hook which should always fail
2. Set the retry option value to false
3. As the refetchOnWindowFocus is true by default, the query will be refetched every time you switch tab and focus on window.

Expected behavior

As the retry option is set on per query basis, it should have higher precedence. refetchOnWindowFocus can't be disabled as it's a useful feature. If the dev is setting the retry option by checking the error message in the function to prevent retrying. It should not be overridden by the refetchOnWindowFocus feature.

Using enabled option to control this would add unnecessary state to the custom query hook for managing this behaviour. In my opinion, this looks like a very common use case and react-query should support this out of the box.

How often does this bug happen?

Every time

Screenshots or Videos

No response

Platform

• OS: MacOS
• Chrome v100.0

react-query version

v3.38.0

TypeScript version

No response

Additional context

No response

[TkDodo]

I don't quite understand what you are trying to achieve, but let me elaborate on the ideas:

• generally, refetchOnWindowFocus, as all smart refetches, are driven by staleTime. Only stale queries will be refetched. If you don't want to refetch every time for a query, set a higher staleTime.
• erroneous queries are always considered stale - because they have no data yet, so that they are refetched at the next convenient time. This is different from a retry. A retry is an internal mechanism to retry one fetch multiple times. The query will stay in the loading state while it retries. only after all retries have failed, it will go into error state. Then, if you refetch (for whatever reason), it will do a fetch + the potential retries again. So retries and refetches are two different things that don't have much in common.

The best way to not refetch erroneous queries on window focus is to use the functional syntax:

refetchOnWindowFocus: (query) => query.state.status !== 'error'

you can set that globally, and it will set refetchOnWindowFocus to false as soon as query goes to error state. That feature was added in v3.37.0

[himankpathak]

Thanks @TkDodo ,
My only concern was with erroneous queries refetching on focus.
The suggested fix for setting refetchOnWindowFocus to function, works like a charm, that's all I needed.
query.state.status and query.state.errorUpdateCount are enough to set func globally in my use case.