Include optional TError on DataTag so that getQueryState can infer the error type correctly

packages/query-core/src/__tests__/queryClient.test-d.tsx

@@ -1,5 +1,6 @@
 import { describe, expectTypeOf, it } from 'vitest'
 import { QueryClient } from '../queryClient'
+import type { QueryState } from '../query'
 import type { DataTag, InfiniteData, QueryKey } from '../types'
 
 describe('getQueryData', () => {
@@ -101,6 +102,35 @@ describe('setQueryData', () => {
   })
 })
 
+describe('getQueryState', () => {
+  it('should be loose typed without tag', () => {
+    const queryKey = ['key'] as const
+    const queryClient = new QueryClient()
+    const data = queryClient.getQueryState(queryKey)
+
+    expectTypeOf(data).toEqualTypeOf<QueryState<unknown, Error> | undefined>()
+  })
+
+  it('should be typed if key is tagged', () => {
+    const queryKey = ['key'] as DataTag<Array<string>, number>
+    const queryClient = new QueryClient()
+    const data = queryClient.getQueryState(queryKey)
+
+    expectTypeOf(data).toEqualTypeOf<QueryState<number, Error> | undefined>()
+  })
+
+  it('should be typed including error if key is tagged', () => {
+    type CustomError = Error & { customError: string }
+    const queryKey = ['key'] as DataTag<Array<string>, number, CustomError>
+    const queryClient = new QueryClient()
+    const data = queryClient.getQueryState(queryKey)
+
+    expectTypeOf(data).toEqualTypeOf<
+      QueryState<number, CustomError> | undefined
+    >()
+  })
+})
+
 describe('fetchInfiniteQuery', () => {
   it('should allow passing pages', async () => {
     const data = await new QueryClient().fetchInfiniteQuery({

packages/query-core/src/__tests__/utils.test-d.tsx

@@ -6,9 +6,8 @@ import type { DataTag } from '../types'
 describe('QueryFilters', () => {
   it('should be typed if generics are passed', () => {
     type TData = { a: number; b: string }
-    type TError = { message: string }
 
-    const a: QueryFilters<TData, TError> = {
+    const a: QueryFilters<TData> = {
       predicate(query) {
         expectTypeOf(query.setData({ a: 1, b: '1' })).toEqualTypeOf<TData>()
         return true
@@ -22,7 +21,28 @@ describe('QueryFilters', () => {
     expectTypeOf(data).toEqualTypeOf<TData | undefined>()
 
     const error = queryClient.getQueryState(a.queryKey!)?.error
-    expectTypeOf(error).toEqualTypeOf<Error | null | undefined>() // maybe one day this can return TError
+    expectTypeOf(error).toEqualTypeOf<Error | null | undefined>()
+  })
+
+  it('should be typed if generics are passed including an error type', () => {
+    type TData = { a: number; b: string }
+    type TError = Error & { message: string }
+
+    const a: QueryFilters<TData, TError> = {
+      predicate(query) {
+        expectTypeOf(query.setData({ a: 1, b: '1' })).toEqualTypeOf<TData>()
+        return true
+      },
+      queryKey: ['key'] as DataTag<undefined, TData, TError>,
+    }
+
+    const queryClient = new QueryClient()
+
+    const data = queryClient.getQueryData(a.queryKey!)
+    expectTypeOf(data).toEqualTypeOf<TData | undefined>()
+
+    const error = queryClient.getQueryState(a.queryKey!)?.error
+    expectTypeOf(error).toEqualTypeOf<TError | null | undefined>()
   })
 
   it('should be loose typed if generics are defaults', () => {

packages/query-core/src/queryClient.ts

@@ -229,12 +229,22 @@ export class QueryClient {
     >
       ? TaggedValue
       : TQueryFnData,
+    TInferredError = TTaggedQueryKey extends DataTag<
+      unknown,
+      unknown,
+      infer TaggedError
+    >
+      ? unknown extends TaggedError
+        ? TError
+        : TaggedError
+      : TError,
   >(
     queryKey: TTaggedQueryKey,
-  ): QueryState<TInferredQueryFnData, TError> | undefined {
+  ): QueryState<TInferredQueryFnData, TInferredError> | undefined {
     const options = this.defaultQueryOptions({ queryKey })
-    return this.#queryCache.get<TInferredQueryFnData, TError>(options.queryHash)
-      ?.state
+    return this.#queryCache.get<TInferredQueryFnData, TInferredError>(
+      options.queryHash,
+    )?.state
   }
 
   removeQueries(filters?: QueryFilters): void {

packages/query-core/src/types.ts

@@ -43,8 +43,10 @@ export type DefaultError = Register extends {
 export type QueryKey = ReadonlyArray<unknown>
 
 export declare const dataTagSymbol: unique symbol
-export type DataTag<TType, TValue> = TType & {
+export declare const dataTagErrorSymbol: unique symbol
+export type DataTag<TType, TValue, TError = unknown> = TType & {
   [dataTagSymbol]: TValue
+  [dataTagErrorSymbol]: TError
 }
 
 export type QueryFunction<

packages/query-core/src/utils.ts

@@ -38,7 +38,7 @@ export interface QueryFilters<
    */
   queryKey?: unknown extends TQueryFnData
     ? QueryKey
-    : QueryKey & DataTag<unknown, TQueryFnData>
+    : QueryKey & DataTag<unknown, TQueryFnData, TError>
   /**
    * Include or exclude stale queries
    */