Removing queries manually from the cache

[sbruinsje]

I have created a utility function to update the query cache based on some patch function. I want this utility function to do the following:

• Get all queries for a given endpoint from the state.
• Iterate over each of them:
  • If the query has an active subscription, the query is updated using a provided patch function.
  • If the query has no active subscription, the query gets removed from the cache entirely.

This function is used when doing optimistic updates: instantly update all active queries with some patch function and purge the inactive queries for that endpoint so they won't be re-used in the future.

However, I haven't found a way to purge cache entries manually from the state. I don't want to invalidate tags because that causes a refetch of all the active queries as well which makes no sense cause we are optimistically updating those already. Is there a way to purge specific queries from the cache? Or do you see a better approach to what I am trying to do?

The utility function is a work in progress but looks something like this:

export function updateQueryCache<R>({
  getState,
  dispatch,
  api,
  endpointName,
  patchFunction,
}: UpdateQueryCacheArgs<R>): PatchResult[] {
  const state = getState();
  const allQueries = Object.entries(state.api.queries);
  const subscriptions = state.api.subscriptions;
  const endpointQueries = allQueries.filter(([key]) => key.startsWith(`${endpointName}(`));

  const patchResults: PatchResult[] = [];

  endpointQueries.forEach(([queryKey, query]) => {
    if (!query) return;

    // Check if this query has active subscriptions
    const hasActiveSubscriptions =
      subscriptions[queryKey] &&
      Object.keys(subscriptions[queryKey] as Record<string, unknown>).length > 0;

    // If The query has an active subscription then we want to update it using the patch function.
    // If the query has NO active subscription then we want to remove it from the cache which is
    // less work then patching it. If the query becomes active again it will be refetched instead of
    // re-used from the cache. This is safeguard against having to update many outdated cache
    // entries which will never be re-used (aka a performance optimization).
    
    if (hasActiveSubscriptions) {
      const patchResult = dispatch(
        api.util.updateQueryData(
          endpointName,
          (query as { originalArgs: unknown }).originalArgs,
          patchFunction,
        ),
      ) as PatchResult;
      patchResults.push(patchResult);
    } else {
      // TODO: how to remove cache entries?
    }
  });

[ArianMakiabadi]

RTK Query doesn’t expose a “delete this one cache entry” API on purpose. Cache entries are owned by the RTKQ reducer, and you’re not supposed to surgically remove arbitrary api.queries[cacheKey] records.

That said, you have a couple of supported options depending on what you actually want:

1. If your goal is “don’t reuse inactive results later”, you usually don’t need to purge manually
   RTKQ already drops unused cache entries after keepUnusedDataFor seconds once the last subscriber unsubscribes. If you want aggressive cleanup for an endpoint, set it low:

endpoints: (build) => ({
  getThing: build.query<Thing, Args>({
    query: (args) => ({ url: "...", params: args }),
    keepUnusedDataFor: 0, // or a small number
  }),
})

That makes “inactive” queries disappear essentially immediately after the last component unsubscribes, which matches the “don’t reuse” intent without custom purging logic.

2. Better approach for optimistic updates: update only currently active queries (and let RTKQ drop the rest naturally)
   What you’re doing with iterating subscriptions is fine for deciding “active vs inactive”, but instead of trying to delete inactive cache entries manually, let keepUnusedDataFor handle eviction. You can still patch active ones immediately:

• Patch active queries via updateQueryData (what you already do)
• Don’t touch inactive queries
• Set keepUnusedDataFor low enough that inactive entries are not hanging around and being reused later