fix(types): Remove predicate typing for query filters (TanStack#8958)

Nick-Lucas · TkDodo · web-flow · commit f580d4d395ca · 2025-04-14T14:45:45.000+02:00
* Remove prdicate typing

* Removing generics everywhere

* Fix type errors

---------

Co-authored-by: Dominik Dorfmeister &lt;office@dorfmeister.cc&gt;
diff --git a/packages/query-core/src/__tests__/queryClient.test-d.tsx b/packages/query-core/src/__tests__/queryClient.test-d.tsx
@@ -225,18 +225,13 @@ describe('fully typed usage', () => {
       }
     const mutationOptions: MutationOptions<TData, TError> = {}
 
-    const queryFilters: QueryFilters<
-      TData,
-      TError,
-      TData,
-      DataTag<QueryKey, TData, TError>
-    > = {
+    const queryFilters: QueryFilters<DataTag<QueryKey, TData, TError>> = {
       predicate(query) {
         expectTypeOf(query).toEqualTypeOf<
-          Query<TData, TError, TData, DataTag<QueryKey, TData, TError>>
+          Query<unknown, Error, unknown, ReadonlyArray<unknown>>
         >()
-        expectTypeOf(query.state.data).toEqualTypeOf<TData | undefined>()
-        expectTypeOf(query.state.error).toEqualTypeOf<TError | null>()
+        expectTypeOf(query.state.data).toEqualTypeOf<unknown>()
+        expectTypeOf(query.state.error).toEqualTypeOf<Error | null>()
         return false
       },
     }
@@ -267,7 +262,7 @@ describe('fully typed usage', () => {
 
     const queriesData = queryClient.getQueriesData(queryFilters)
     expectTypeOf(queriesData).toEqualTypeOf<
-      Array<[QueryKey, TData | undefined]>
+      Array<[ReadonlyArray<unknown>, unknown]>
     >()
 
     const queryData3 = queryClient.setQueryData(queryKey, { foo: '' })
@@ -286,11 +281,9 @@ describe('fully typed usage', () => {
     >[1]
 
     expectTypeOf<SetQueriesDataUpdaterArg>().toEqualTypeOf<
-      Updater<TData | undefined, TData | undefined>
-    >()
-    expectTypeOf(queriesData2).toEqualTypeOf<
-      Array<[QueryKey, TData | undefined]>
+      Updater<unknown, unknown>
     >()
+    expectTypeOf(queriesData2).toEqualTypeOf<Array<[QueryKey, unknown]>>()
 
     const queryState = queryClient.getQueryState(queryKey)
     expectTypeOf(queryState).toEqualTypeOf<
@@ -530,10 +523,8 @@ describe('invalidateQueries', () => {
     queryClient.invalidateQueries({
       queryKey,
       predicate: (query) => {
-        expectTypeOf(query.state.data).toEqualTypeOf<number | undefined>()
-        expectTypeOf(query.queryKey).toEqualTypeOf<
-          DataTag<Array<string>, number>
-        >()
+        expectTypeOf(query.state.data).toEqualTypeOf<unknown>()
+        expectTypeOf(query.queryKey).toEqualTypeOf<QueryKey>()
         return true
       },
     })
@@ -547,10 +538,8 @@ describe('cancelQueries', () => {
     queryClient.cancelQueries({
       queryKey,
       predicate: (query) => {
-        expectTypeOf(query.state.data).toEqualTypeOf<number | undefined>()
-        expectTypeOf(query.queryKey).toEqualTypeOf<
-          DataTag<Array<string>, number>
-        >()
+        expectTypeOf(query.state.data).toEqualTypeOf<unknown>()
+        expectTypeOf(query.queryKey).toEqualTypeOf<QueryKey>()
         return true
       },
     })
@@ -564,10 +553,8 @@ describe('removeQueries', () => {
     queryClient.removeQueries({
       queryKey,
       predicate: (query) => {
-        expectTypeOf(query.state.data).toEqualTypeOf<number | undefined>()
-        expectTypeOf(query.queryKey).toEqualTypeOf<
-          DataTag<Array<string>, number>
-        >()
+        expectTypeOf(query.state.data).toEqualTypeOf<unknown>()
+        expectTypeOf(query.queryKey).toEqualTypeOf<QueryKey>()
         return true
       },
     })
@@ -581,10 +568,8 @@ describe('refetchQueries', () => {
     queryClient.refetchQueries({
       queryKey,
       predicate: (query) => {
-        expectTypeOf(query.state.data).toEqualTypeOf<number | undefined>()
-        expectTypeOf(query.queryKey).toEqualTypeOf<
-          DataTag<Array<string>, number>
-        >()
+        expectTypeOf(query.state.data).toEqualTypeOf<unknown>()
+        expectTypeOf(query.queryKey).toEqualTypeOf<QueryKey>()
         return true
       },
     })
@@ -598,10 +583,8 @@ describe('resetQueries', () => {
     queryClient.resetQueries({
       queryKey,
       predicate: (query) => {
-        expectTypeOf(query.state.data).toEqualTypeOf<number | undefined>()
-        expectTypeOf(query.queryKey).toEqualTypeOf<
-          DataTag<Array<string>, number>
-        >()
+        expectTypeOf(query.state.data).toEqualTypeOf<unknown>()
+        expectTypeOf(query.queryKey).toEqualTypeOf<QueryKey>()
         return true
       },
     })
diff --git a/packages/query-core/src/__tests__/utils.test-d.tsx b/packages/query-core/src/__tests__/utils.test-d.tsx
@@ -4,43 +4,13 @@ import type { QueryFilters } from '../utils'
 import type { DataTag, QueryKey } from '../types'
 
 describe('QueryFilters', () => {
-  it('should be typed if generics are passed', () => {
-    type TData = { a: number; b: string }
-
-    const filters: QueryFilters<
-      TData,
-      Error,
-      TData,
-      DataTag<QueryKey, TData>
-    > = {
-      predicate(query) {
-        expectTypeOf(query.setData({ a: 1, b: '1' })).toEqualTypeOf<TData>()
-        return true
-      },
-      queryKey: ['key'] as DataTag<undefined, TData>,
-    }
-
-    const queryClient = new QueryClient()
-
-    const data = queryClient.getQueryData(filters.queryKey!)
-    expectTypeOf(data).toEqualTypeOf<TData | undefined>()
-
-    const error = queryClient.getQueryState(filters.queryKey!)?.error
-    expectTypeOf(error).toEqualTypeOf<Error | null | undefined>()
-  })
-
-  it('should be typed if generics are passed including an error type', () => {
+  it('should be typed unknown even if tagged generics are passed', () => {
     type TData = { a: number; b: string }
     type TError = Error & { message: string }
 
-    const filters: QueryFilters<
-      TData,
-      TError,
-      TData,
-      DataTag<QueryKey, TData, TError>
-    > = {
+    const filters: QueryFilters<DataTag<QueryKey, TData, TError>> = {
       predicate(query) {
-        expectTypeOf(query.setData({ a: 1, b: '1' })).toEqualTypeOf<TData>()
+        expectTypeOf(query.setData({ a: 1, b: '1' })).toEqualTypeOf<unknown>()
         return true
       },
       queryKey: ['key'] as DataTag<undefined, TData, TError>,
diff --git a/packages/query-core/src/queryCache.ts b/packages/query-core/src/queryCache.ts
@@ -190,7 +190,7 @@ export class QueryCache extends Subscribable<QueryCacheListener> {
     ) as Query<TQueryFnData, TError, TData> | undefined
   }
 
-  findAll(filters: QueryFilters<any, any, any, any> = {}): Array<Query> {
+  findAll(filters: QueryFilters<any> = {}): Array<Query> {
     const queries = this.getAll()
     return Object.keys(filters).length > 0
       ? queries.filter((query) => matchQuery(filters, query))
diff --git a/packages/query-core/src/queryClient.ts b/packages/query-core/src/queryClient.ts
@@ -106,9 +106,9 @@ export class QueryClient {
     this.#unsubscribeOnline = undefined
   }
 
-  isFetching<
-    TQueryFilters extends QueryFilters<any, any, any, any> = QueryFilters,
-  >(filters?: TQueryFilters): number {
+  isFetching<TQueryFilters extends QueryFilters<any> = QueryFilters>(
+    filters?: TQueryFilters,
+  ): number {
     return this.#queryCache.findAll({ ...filters, fetchStatus: 'fetching' })
       .length
   }
@@ -166,25 +166,10 @@ export class QueryClient {
 
   getQueriesData<
     TQueryFnData = unknown,
-    TQueryFilters extends QueryFilters<
-      any,
-      any,
-      any,
-      any
-    > = QueryFilters<TQueryFnData>,
-    TInferredQueryFnData = TQueryFilters extends QueryFilters<
-      infer TData,
-      any,
-      any,
-      any
-    >
-      ? TData
-      : TQueryFnData,
-  >(
-    filters: TQueryFilters,
-  ): Array<[QueryKey, TInferredQueryFnData | undefined]> {
+    TQueryFilters extends QueryFilters<any> = QueryFilters,
+  >(filters: TQueryFilters): Array<[QueryKey, TQueryFnData | undefined]> {
     return this.#queryCache.findAll(filters).map(({ queryKey, state }) => {
-      const data = state.data as TInferredQueryFnData | undefined
+      const data = state.data as TQueryFnData | undefined
       return [queryKey, data]
     })
   }
@@ -226,34 +211,21 @@ export class QueryClient {
 
   setQueriesData<
     TQueryFnData,
-    TQueryFilters extends QueryFilters<
-      any,
-      any,
-      any,
-      any
-    > = QueryFilters<TQueryFnData>,
-    TInferredQueryFnData = TQueryFilters extends QueryFilters<
-      infer TData,
-      any,
-      any,
-      any
-    >
-      ? TData
-      : TQueryFnData,
+    TQueryFilters extends QueryFilters<any> = QueryFilters,
   >(
     filters: TQueryFilters,
     updater: Updater<
-      NoInfer<TInferredQueryFnData> | undefined,
-      NoInfer<TInferredQueryFnData> | undefined
+      NoInfer<TQueryFnData> | undefined,
+      NoInfer<TQueryFnData> | undefined
     >,
     options?: SetDataOptions,
-  ): Array<[QueryKey, TInferredQueryFnData | undefined]> {
+  ): Array<[QueryKey, TQueryFnData | undefined]> {
     return notifyManager.batch(() =>
       this.#queryCache
         .findAll(filters)
         .map(({ queryKey }) => [
           queryKey,
-          this.setQueryData<TInferredQueryFnData>(queryKey, updater, options),
+          this.setQueryData<TQueryFnData>(queryKey, updater, options),
         ]),
     )
   }
@@ -273,19 +245,8 @@ export class QueryClient {
     )?.state
   }
 
-  removeQueries<
-    TQueryFnData = unknown,
-    TError = DefaultError,
-    TTaggedQueryKey extends QueryKey = QueryKey,
-    TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>,
-    TInferredError = InferErrorFromTag<TError, TTaggedQueryKey>,
-  >(
-    filters?: QueryFilters<
-      TInferredQueryFnData,
-      TInferredError,
-      TInferredQueryFnData,
-      TTaggedQueryKey
-    >,
+  removeQueries<TTaggedQueryKey extends QueryKey = QueryKey>(
+    filters?: QueryFilters<TTaggedQueryKey>,
   ): void {
     const queryCache = this.#queryCache
     notifyManager.batch(() => {
@@ -295,19 +256,8 @@ export class QueryClient {
     })
   }
 
-  resetQueries<
-    TQueryFnData = unknown,
-    TError = DefaultError,
-    TTaggedQueryKey extends QueryKey = QueryKey,
-    TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>,
-    TInferredError = InferErrorFromTag<TError, TTaggedQueryKey>,
-  >(
-    filters?: QueryFilters<
-      TInferredQueryFnData,
-      TInferredError,
-      TInferredQueryFnData,
-      TTaggedQueryKey
-    >,
+  resetQueries<TTaggedQueryKey extends QueryKey = QueryKey>(
+    filters?: QueryFilters<TTaggedQueryKey>,
     options?: ResetOptions,
   ): Promise<void> {
     const queryCache = this.#queryCache
@@ -326,19 +276,8 @@ export class QueryClient {
     })
   }
 
-  cancelQueries<
-    TQueryFnData = unknown,
-    TError = DefaultError,
-    TTaggedQueryKey extends QueryKey = QueryKey,
-    TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>,
-    TInferredError = InferErrorFromTag<TError, TTaggedQueryKey>,
-  >(
-    filters?: QueryFilters<
-      TInferredQueryFnData,
-      TInferredError,
-      TInferredQueryFnData,
-      TTaggedQueryKey
-    >,
+  cancelQueries<TTaggedQueryKey extends QueryKey = QueryKey>(
+    filters?: QueryFilters<TTaggedQueryKey>,
     cancelOptions: CancelOptions = {},
   ): Promise<void> {
     const defaultedCancelOptions = { revert: true, ...cancelOptions }
@@ -352,19 +291,8 @@ export class QueryClient {
     return Promise.all(promises).then(noop).catch(noop)
   }
 
-  invalidateQueries<
-    TQueryFnData = unknown,
-    TError = DefaultError,
-    TTaggedQueryKey extends QueryKey = QueryKey,
-    TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>,
-    TInferredError = InferErrorFromTag<TError, TTaggedQueryKey>,
-  >(
-    filters?: InvalidateQueryFilters<
-      TInferredQueryFnData,
-      TInferredError,
-      TInferredQueryFnData,
-      TTaggedQueryKey
-    >,
+  invalidateQueries<TTaggedQueryKey extends QueryKey = QueryKey>(
+    filters?: InvalidateQueryFilters<TTaggedQueryKey>,
     options: InvalidateOptions = {},
   ): Promise<void> {
     return notifyManager.batch(() => {
@@ -385,19 +313,8 @@ export class QueryClient {
     })
   }
 
-  refetchQueries<
-    TQueryFnData = unknown,
-    TError = DefaultError,
-    TTaggedQueryKey extends QueryKey = QueryKey,
-    TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>,
-    TInferredError = InferErrorFromTag<TError, TTaggedQueryKey>,
-  >(
-    filters?: RefetchQueryFilters<
-      TInferredQueryFnData,
-      TInferredError,
-      TInferredQueryFnData,
-      TTaggedQueryKey
-    >,
+  refetchQueries<TTaggedQueryKey extends QueryKey = QueryKey>(
+    filters?: RefetchQueryFilters<TTaggedQueryKey>,
     options: RefetchOptions = {},
   ): Promise<void> {
     const fetchOptions = {
diff --git a/packages/query-core/src/types.ts b/packages/query-core/src/types.ts
@@ -576,21 +576,13 @@ export interface RefetchOptions extends ResultOptions {
   cancelRefetch?: boolean
 }
 
-export interface InvalidateQueryFilters<
-  TQueryFnData = unknown,
-  TError = DefaultError,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
-> extends QueryFilters<TQueryFnData, TError, TData, TQueryKey> {
+export interface InvalidateQueryFilters<TQueryKey extends QueryKey = QueryKey>
+  extends QueryFilters<TQueryKey> {
   refetchType?: QueryTypeFilter | 'none'
 }
 
-export interface RefetchQueryFilters<
-  TQueryFnData = unknown,
-  TError = DefaultError,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
-> extends QueryFilters<TQueryFnData, TError, TData, TQueryKey> {}
+export interface RefetchQueryFilters<TQueryKey extends QueryKey = QueryKey>
+  extends QueryFilters<TQueryKey> {}
 
 export interface InvalidateOptions extends RefetchOptions {}
 export interface ResetOptions extends RefetchOptions {}
diff --git a/packages/query-core/src/utils.ts b/packages/query-core/src/utils.ts
diff --git a/packages/vue-query/src/queryClient.ts b/packages/vue-query/src/queryClient.ts

Original file line number	Diff line number	Diff line change
`@@ -190,7 +190,7 @@ export class QueryCache extends Subscribable<QueryCacheListener> {`
`190`	`190`	`) as Query<TQueryFnData, TError, TData> \| undefined`
`191`	`191`	`}`
`192`	`192`
`193`		`- findAll(filters: QueryFilters<any, any, any, any> = {}): Array<Query> {`
	`193`	`+ findAll(filters: QueryFilters<any> = {}): Array<Query> {`
`194`	`194`	`const queries = this.getAll()`
`195`	`195`	`return Object.keys(filters).length > 0`
`196`	`196`	`? queries.filter((query) => matchQuery(filters, query))`