refetch does not respect enabled false

[SleeplessByte]

Describe the bug

Is it possible that this (#1797) has regressed? I'm on ^3.12.1 and running into exactly this.

When calling refetch, there does not seem to be a way to respect enabled. Manually refetching the query always goes through. This by itself is not an issue, but that means that the only way to use a refetch-but-respect-query-options is to:

• use queryClient directly
• copy the enabled logic and execute it before calling refetch

When the refetch is in flight, it will actually keep retrying the query too if the query fails. This can be overcome by copying the enabled logic once more to the retry function.

Expected behavior
There is a way to refetchIfEnabled.

---

Perhaps this can be added to the optional options of refetch as a flag?

[TkDodo]

can you explain what you are trying to do? refetch is often used with disabled queries for imperative fetching, so that is expected. However, most “refetches” can and should be triggered declaratively by changing the query key.

[SleeplessByte]

I have quite a few needs in react-native apps:

• Custom revalidation logic
• Custom focus logic (not the same as screen/window is focussed)
• Custom triggers such as notification/socket/webhook

I currently feel that the code I've written is working around certain limitation. Changing the query key is not what we want, because it should use the same key across the application for the same data.

If using queryClient is the only way to do it, then that's fine. I would suggest documenting refetch for a future user 😄

[TkDodo]

Out of curiosity: which method are you using on the queryClient that refetches but respects enabled? Are you just invalidating ?

[SleeplessByte]

I've tried both invalidate + moving enabled logic inside query and returning a cached result when it's not, and moving the enabled logic around .refetchQuery.

I've also tried moving enabled inside the query function and throwing a custom error which I capture in retry and then ignore from retrying.

[TkDodo]

so I think if you do queryClient.invalidateQueries, it should respect the enabled flag - does it not?

[SleeplessByte]

It does because it doesn't actually refetch the query (invalidate doesn't, react-query will, and THAT respects enabled -- but now I lost the imperative "just refetch regardless of the query being mounted"), but it means requiring at least 4 lines of code per instance, including the bikeshedding where I need this behaviour, only because there is no way to have refetch respect enabled, if I want to keep the imperative fetching.

[TkDodo]

I would suggest documenting refetch for a future user

please feel free to open a PR to the docs.

[kitsune7]

Wait, why did this get closed? It's definitely still an issue. Is having refetch ignore the enabled option intentional? If so, why?

[kitsune7]

I'm having an issue where I'm not explicitly calling refetch anywhere and enabled is set to false. The second time my component renders, even though enabled is still set to false and no data relevant to useQuery has changed, the API call is still made regardless.

[TkDodo]

The second time my component renders, even though enabled is still set to false and no data relevant to useQuery has changed, the API call is still made regardless.

@kitsune7 can you provide a codesandbox that shows this issue please? I can certainly look into it if there is a reproducibility issue.

[gfox1984]

I have a use case where I would like to have a "refetchIfEnabled" too.

1. My app sets "enabled: false" as default option until the user is authenticated.
2. Once I have a valid token, I set the bearer token on Axios (which I use to fetch), and then I reset the default options.
3. From that point, I instruct react query to start fetching data using queryClient.refetchQueries()

But as mentioned earlier, this causes ALL queries to be re-fetched, even the ones that are explicitly marked as disabled. I tried using queryClient.invalidateQueries() as suggested by @TkDodo, but this does not trigger a fetch as they've never been fetched before. An option if refetchQueries or a refetchIfEnabled method would be handy here.

[TkDodo]

@gfox1984 this sounds more like you’d want to disable the query until you have a valid token? Generally speaking, using refetch bypass the declarative nature of RQ

[gfox1984]

Correct, this is about disabling ALL queries until I have a valid token, and then run ALL queries, with the exception of the ones that explicitly specify enabled: false. Maybe it's wrong of speaking of reftech but, in other terms, what solution would you advise to trigger a run of all queries but the disabled ones?