Does the invoke query function make use of the query cache?

[julianklumpers]

it does not seem to work. Also the queryKey is not what i would expect if you look at what getQueryKey returns.
example:

const getData = await () => {
 const data = await invoke(getDataQuery, { filters })
}

calling the function a second time does fire a new network request although the i can see the cache data in the ReactQueryDevTools. Also setting the cache manually does not seem to work, because the queryKey does not align. for example getQueryKey(getDataQuery) return /api/rpc/getDataQuery while the ReactQueryDevTools shows that the cache is under: /getDataQuery

[manimovassagh]

No, invoke does not use the React Query cache. This is by design.

When you call invoke(getDataQuery, { filters }), it makes a direct RPC call bypassing React Query entirely. It's meant for imperative data fetching (inside event handlers, useEffect, server-side, etc.), not for declarative cached queries.

If you want cache behavior, use the useQuery hook instead:

import { useQuery } from "@blitzjs/rpc"

function MyComponent() {
  const [data] = useQuery(getDataQuery, { filters })
  // This uses React Query under the hood - cached, deduped, refetched on window focus, etc.
}

Why the queryKey mismatch?

The key mismatch you're seeing (/api/rpc/getDataQuery vs /getDataQuery) is because getQueryKey returns the client-side cache key that useQuery uses, while invoke doesn't interact with the cache at all. They're completely separate paths.

If you need imperative access to cached data, use the query client directly:

import { getQueryClient, getQueryKey } from "@blitzjs/rpc"

const queryClient = getQueryClient()
const key = getQueryKey(getDataQuery, { filters })

// Read from cache without triggering a fetch
const cachedData = queryClient.getQueryData(key)

// Or fetch with cache behavior
const data = await queryClient.fetchQuery({
  queryKey: key,
  queryFn: () => invoke(getDataQuery, { filters }),
})

This way fetchQuery will return cached data if it's fresh, or call invoke if the cache is stale. That gives you the best of both worlds - imperative usage with caching.