exclude key in QueryFilters

[Sheraff]

When manipulating the cache, I find that exact?: boolean and queryKey?: QueryKey don't really cover all my bases and predicate?: (query: Query) => boolean feels like a bit of a sledgehammer.

Imagine I have an arbitrary number of queries on the same entity:

const useQueryOne = () =>
  useQuery({
    queryFn: () => axios.request({url: '/api/endpoint', method: 'GET'}),
    queryKey: ['endpoint'],
  })
const useQueryTwo = () =>
  useQuery({
    queryFn: () => axios.request({url: '/api/endpoint', method: 'GET', params: { include: { documents: true } }}),
    queryKey: ['endpoint', 'documents'],
  })
const useQueryThree = () =>
  useQuery({
    queryFn: () => axios.request({url: '/api/endpoint', method: 'GET', params: { include: { records: true } }}),
    queryKey: ['endpoint', 'records'],
  })

When mutating an entity associated with /api/endpoint, I'd like to be able to setQueryData for a specific query (or queries) and invalidate all the other ones.

What that looks like right now:

const useMutationOne = () => 
  const queryClient = useQueryClient()
  useMutation({
    mutationFn: ({id}) => axios.request({url: `/api/endpoint/${id}`}),
    onSuccess: (data) => {
      queryClient.setQueryData(['endpoint', 'records'], () => /* some update logic */)
      queryClient.invalidateQueries(['endpoint'], { exact: true })
      queryClient.invalidateQueries(['endpoint', 'documents'], { exact: true })
    },
  })

This example is a little contrived but with an arbitrary amount of various queries on the same endpoint, it could quickly become messy.

What that could look like with an exclude key in QueryFilters:

const useMutationOne = () => 
  const queryClient = useQueryClient()
  useMutation({
    mutationFn: ({id}) => axios.request({url: `/api/endpoint/${id}`}),
    onSuccess: (data) => {
      queryClient.setQueryData(['endpoint', 'records'], () => /* some update logic */)
      queryClient.invalidateQueries(['endpoint'], { exclude: [['endpoint', 'records']] })
    },
  })

[TkDodo]

calling invalidateQueries marks the query as invalid, but calling setQueryData actually marks it as valid again because you successfully give it data. With that in mind, what you can do is:

await queryClient.invalidateQueries(['endpoint'], { refetchType: 'none' }) // mark all 3 (or N) endpoints as stale, but don't refetch
queryClient.setQueryData(['endpoint', 'records'], () => /* some update logic */)
queryClient.invalidateQueries(['endpoint']) // now refetch all stale ones, which shouldn't contain the 'records'

Please note that refetchType is v4 syntax already, in v3, it would be refetchActive: false I think.

Granted, I'm not sure that this is a lot better, but it can handle the arbitrary amount of queries under the endpoint key.

Also, predicate is not that bad, you'd just need to do a negative match for the one key you'd like to exclude.