Would it be possible to have similar functionality as Apollo Client's fetch policy?

[Kaltsoon]

I find myself in situations (such as initializing forms) where I would like to skip caching entirely. To achieve this I have for example implemented the following wrapper for useQuery:

import { useQuery as useBaseQuery } from 'react-query'

import useId from './useId'

const normalizeQueryKey = (key) => (Array.isArray(key) ? key : [key])

const useQuery = (queryKey, queryFn, options = {}) => {
  const { skipCache = false, ...restOptions } = options
  const id = useId()

  const normalizedQueryKey = normalizeQueryKey(queryKey)
  const key = skipCache ? [...normalizedQueryKey, id] : normalizedQueryKey

  return useBaseQuery(key, queryFn, {
    ...restOptions,
    ...(skipCache && { cacheTime: 0 }),
  })
}

export default useQuery

Basically, the hook adds a unique key suffix for the query to make it "isolated" to make sure that other hooks don't mess up with the cache. I could for example have a custom hook useUser that is used in two separate mounted components: one wants to utilize cache, other doesn't:

// For example a component, that renders a form and uses data as initial values. The data should be always fresh.
const { user } = useUser(userId, { skipCache: true })

// ...

// For example a component that renders the user's information. Stale data is fine.
const { user } = useUser(userId)

I have previously worked a lot with Apollo Client which provides a fetch policy option to define the cache behavior. For example, to skip cache entirely, I could set the fetch policy as network-only. I find the similar option useful for React Query as well. At least to have similar fetch policies as Apollo Client's cache-and-network (as far as I understand, this is how React Query works at the moment), network-only (skip cache, only use the query function to get the data), cache-only (only use cache data, never use the query function to get the data).

The "network" part of the naming is perhaps a bit off because React Query isn't strictly only for network fetching. But I find the idea extremely useful.

[TkDodo]

• cache-and-network is our default behaviour, yes.
• cache-only is a bit weird to me because you would need to at least fetch if there is no data yet, no? If you want to fetch once and then, as soon as you have data, always read from cache, use staleTime: Infinity.
• network-only is also weird because the data needs to be cached somewhere. Otherwise, every component re-render would need to fetch again. So at the minimum, it needs to be "cached" on local component level. It is something that we don't have at the moment and I also don't plan to add it.