fix(query-core): use built-in NoInfer for generic indexed-access types (#10593)

* fix(query-core): use built-in NoInfer to support generic indexed-access types

The local `NoInfer<T> = [T][T extends any ? 0 : never]` trick breaks down
when `T` is a generic indexed-access type such as `DataTypeToEntity[DT]`,
producing errors like "Type '[DataTypeToEntity[DT]]' is not assignable to
type 'DataTypeToEntity'".

Since the project already requires TypeScript >= 5.4, delegate the public
`NoInfer<T>` alias to TypeScript's built-in `NoInfer` (introduced in 5.4).
A small `noInfer.ts` helper exposes it as `IntrinsicNoInfer<T>` to avoid
the local-shadow recursion problem.

Vue's `setQueryData` implementation now forwards the `<TData>` generic to
`super.setQueryData<TData>(...)` so its declared `NoInfer<TData> | undefined`
return type stays satisfied under the stricter built-in `NoInfer`.

Fixes #9937

* test(react-query): move 'generic indexed access TData' describe out of 'initialData'

Block was nested inside `describe('initialData', ...)` but is unrelated
to initialData behavior. Lift it to sibling level under
`describe('useQuery', ...)` so test output groups it correctly.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* test(react-query): document implicit regression guard for generic indexed-access NoInfer

Per CodeRabbit nitpick: clarify that the `getLabel(props.dataType, data)` call
itself is the regression guard. With the previous hand-rolled NoInfer, this
call failed to type-check; with built-in NoInfer (TS 5.4+), it compiles.

An explicit `expectTypeOf(data).toEqualTypeOf<...>()` / `toMatchTypeOf<...>()`
cannot work here — vitest's type-relation checks reduce to
`Extends<NoInfer<T>, T>` which TS leaves unresolved under a generic
`TDataType extends DataType` constraint.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* refactor(query-core): drop NoInfer re-export, use built-in everywhere

Per @TkDodo's review: TypeScript's intrinsic NoInfer (TS ≥ 5.4) is the
canonical type, and the package already requires TS ≥ 5.4. Removing the
re-export sidesteps the self-shadowing issue entirely and avoids
encouraging consumers to import a duplicate.

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Co-authored-by: Dominik Dorfmeister 🔮 <office@dorfmeister.cc>

Author: 3 people

.changeset/query-core-noinfer-builtin.md

@@ -0,0 +1,6 @@
+---
+'@tanstack/query-core': patch
+'@tanstack/vue-query': patch
+---
+
+fix(query-core): drop the custom `NoInfer<T>` re-export and rely on TypeScript's built-in `NoInfer` (TS ≥ 5.4) so `NoInfer<X[K]>` stays assignable to `X[K]` in generic contexts (fixes #9937)

packages/preact-query/src/useQuery.ts

@@ -1,10 +1,5 @@
 import { QueryObserver } from '@tanstack/query-core'
-import type {
-  DefaultError,
-  NoInfer,
-  QueryClient,
-  QueryKey,
-} from '@tanstack/query-core'
+import type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'
 
 import type {
   DefinedInitialDataOptions,

packages/query-core/src/queryClient.ts

@@ -29,7 +29,6 @@ import type {
   MutationKey,
   MutationObserverOptions,
   MutationOptions,
-  NoInfer,
   OmitKeyof,
   QueryClientConfig,
   QueryKey,

packages/query-core/src/types.ts

@@ -34,8 +34,6 @@ export type Override<TTargetA, TTargetB> = {
     : TTargetA[AKey]
 }
 
-export type NoInfer<T> = [T][T extends any ? 0 : never]
-
 export interface Register {
   // defaultError: Error
   // queryMeta: Record<string, unknown>

packages/react-query/src/__tests__/useQuery.test-d.tsx

@@ -338,4 +338,52 @@ describe('useQuery', () => {
       })
     })
   })
+
+  describe('generic indexed access TData', () => {
+    // https://github.com/TanStack/query/issues/9937
+    it('should be assignable back to its source indexed type when passed to a generic function parameter', () => {
+      enum DataType {
+        Account = 'account',
+        Product = 'product',
+      }
+
+      interface Account {
+        name: string
+      }
+      interface Product {
+        code: string
+      }
+
+      type DataTypeToEntity = {
+        [DataType.Account]: Account
+        [DataType.Product]: Product
+      }
+
+      const getData = <TDataType extends DataType>(
+        _dataType: TDataType,
+      ): Promise<DataTypeToEntity[TDataType]> =>
+        Promise.resolve({} as DataTypeToEntity[TDataType])
+
+      const getLabel = <TDataType extends DataType>(
+        _dataType: TDataType,
+        _data: DataTypeToEntity[TDataType],
+      ) => 'test'
+
+      function Test<TDataType extends DataType>(props: {
+        dataType: TDataType
+      }) {
+        const { data } = useQuery({
+          queryKey: ['test'],
+          queryFn: () => getData(props.dataType),
+        })
+
+        // Regression guard: this call must compile. With the previous
+        // hand-rolled NoInfer, `data` failed to flow back into the generic
+        // indexed-access parameter `DataTypeToEntity[TDataType]`.
+        return data ? getLabel(props.dataType, data) : null
+      }
+
+      expectTypeOf(Test).toBeFunction()
+    })
+  })
 })

packages/react-query/src/useQuery.ts

@@ -1,12 +1,7 @@
 'use client'
 import { QueryObserver } from '@tanstack/query-core'
 import { useBaseQuery } from './useBaseQuery'
-import type {
-  DefaultError,
-  NoInfer,
-  QueryClient,
-  QueryKey,
-} from '@tanstack/query-core'
+import type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'
 import type {
   DefinedUseQueryResult,
   UseQueryOptions,

packages/vue-query/src/queryClient.ts

@@ -21,7 +21,6 @@ import type {
   MutationFilters,
   MutationKey,
   MutationObserverOptions,
-  NoInfer,
   OmitKeyof,
   QueryFilters,
   QueryKey,
@@ -125,7 +124,7 @@ export class QueryClient extends QC {
     updater: Updater<TData | undefined, TData | undefined>,
     options: MaybeRefDeep<SetDataOptions> = {},
   ): NoInfer<TData> | undefined {
-    return super.setQueryData(
+    return super.setQueryData<TData>(
       cloneDeepUnref(queryKey),
       updater,
       cloneDeepUnref(options),