Should Lazy Queries Auto-Refetch on Cache Tag Invalidation?

[User6531]

Should Lazy Queries Auto-Refetch on Cache Tag Invalidation?

Question

Hi RTK Query team! I have a question about lazy query behavior with cache tags. Currently, lazy queries (useLazyQuery) automatically refetch when cache tags are invalidated, even though they're only meant to fetch when explicitly triggered. Is this the intended behavior, or is there a way to prevent this?

Why We Use Tags with Lazy Queries

We use providesTags with lazy queries because:

1. Shared Endpoint: The same endpoint is used by both lazy and regular queries. Regular queries need tags for automatic cache invalidation/refetching.
2. Cache Consistency: We want lazy query cache to be invalidated when data changes, so subsequent calls fetch fresh data.
3. Regular Query Requirements: Regular queries need to automatically refetch when cache tags are invalidated.

Since both queries share the same endpoint definition, we can't configure them differently. We need tags for regular queries, but we're wondering if lazy queries should auto-refetch.

Current Behavior

When a lazy query is executed and cached with tags, RTK Query automatically refetches it when those tags are invalidated, even though:

• The lazy query was only meant to be called on-demand
• This causes unnecessary network requests

Should lazy queries:

• Only fetch when explicitly called via the trigger function?
• NOT automatically refetch when cache tags are invalidated?
• Still have their cache invalidated (so they fetch fresh data on next call)?
• Allow regular queries to refetch on cache invalidation?

About useLazyQuerySubscription

I noticed there's mention of useLazyQuerySubscription in some discussions. The naming suggests it should subscribe to cache updates, while regular useLazyQuery should not. However, it seems useLazyQuery is currently subscribing to cache updates and auto-refetching on tag invalidation. Is this the intended behavior, or should useLazyQuery not subscribe by default?

Use Case

We have an endpoint used in two scenarios:

• Regular query: Used in a component that should automatically refetch when cache is invalidated
• Lazy query: Used in a form initialization hook that should only fetch when explicitly called

Both share the same endpoint definition. We need providesTags for the regular query, but we're unsure if the lazy query should automatically refetch.

Possible Solutions (If This Is Unintended)

If lazy queries shouldn't auto-refetch, could we have a configuration option to prevent auto-refetch on cache invalidation

Additional Context

This appears to occur because RTK Query refetches ALL queries that provided a tag when it's invalidated, regardless of whether they're lazy or regular. We're wondering if lazy queries should be excluded from automatic refetching, which would align with the "on-demand" principle while still allowing cache invalidation.

Thank you for your time and for the great work on RTK Query!

[phryneas]

Yes, they should.

The lazy thing about lazy queries is that they don't do the initial request at component mount, but after that they behave like a normal query in any way.

They do not "only do requests when called", they are just "lazily initialized queries".

[User6531]

thank you

[markerikson]

@phryneas can probably give a better answer because he designed RTKQ and lazy queries in the first place, but in general I'd say:

The "laziness" in a lazy query is solely about initiating the first request. In other words, it's roughly similar to having skip: true passed to a standard query hook, except that you can imperatively trigger the request via calling the trigger function.

Once the query cache entry exists, all the normal RTKQ behavior rules apply as usual.

(aaaand I see he just replied with that same response.)

[User6531]

thank you