Refetch is ignored if fired during initial fetching of a query about query HOT 4 CLOSED

Aaah, apologies, seems to be my mistake, related with how query client was being imported. Query canceling seems to be working just as described. Thanks for your help! I believe this issue can be closed

from query.

I think you're right, that's why the flag is called cancelRefetch and not cancelFetch - it can only cancel a refetch, and a refetch is a fetch where we already have data.

Not sure why we have that implementation / limitation. I would argue that cancelFetch is more appropriate - why would we only do this for refetches. But not sure if we can fix this in a non-breaking way? If we change the implementation and remove the this.state.dataUpdatedAt check - it would change the behaviour and the cancelRefetch name would be confusing.

I tried that, but we do have a test that covers this scenario:

So, I really don't think we can change this right now. next major maybe? I always prefer less code and less surprising behaviour, but I also don't want to change this now without renaming the flag.

For your cases - what you can do is call queryClient.cancelQueries({ queryKey }) to manually cancel it instead of letting refetch take care of it. That should work.

from query.

Hi @TkDodo, thanks for your answer!

I agree that the current flag name (cancelRefetch) works exactly as the name implies - it only cancels refetches. cancelFetch would make more sense, since the current behavior of cancelRefetch creates that blind spot, which might not be obvious for library users. Both flags could potentially coexist, but it would only make dx more confusing IMO, so I also agree with you that it would only make sense introducing it as a breaking change somewhere down the road (if such decision would be made).

P.S queryClient.cancelQueries was what I tried initially - this does not seem to cancel the initial fetch either, only the following ones. This also matches with the cancelQueries description, where canceling refetches is mentioned as a use case:

This is most useful when performing optimistic updates since you will likely need to cancel any outgoing query refetches so they don't clobber your optimistic update when they resolve.

from query.

this does not seem to cancel the initial fetch either

Hmm I looked at the code and queryClient.cancelQueries should also cancel initial fetches.

I wrote a quick test for that to confirm, and it passes:

test('should also cancel initial queries', async () => {
  const key = queryKey()
  void queryClient.fetchQuery({
    queryKey: key,
    queryFn: async () => {
      await sleep(10)
      return 'data'
    },
  })
  await queryClient.cancelQueries({ queryKey: key })

  const state = queryClient.getQueryState(key)

  expect(state).toMatchObject({
    data: undefined,
    status: 'pending',
  })
})

from query.