@tanstack/query-core 5.0.0-rc.0 → 5.0.0-rc.12

package/src/tests/hydration.test.tsx

@@ -514,7 +514,7 @@ describe('dehydration and rehydration', () => {
     queryClient.clear()
   })
 
-  test('should set the fetchStatus to idle in all cases when dehydrating', async () => {
+  test('should set the fetchStatus to idle when creating a query with dehydrate', async () => {
     const queryCache = new QueryCache()
     const queryClient = createQueryClient({ queryCache })
 
@@ -668,4 +668,40 @@ describe('dehydration and rehydration', () => {
       undefined,
     )
   })
+
+  test('should not change fetchStatus when updating a query with dehydrate', async () => {
+    const queryClient = createQueryClient()
+
+    const options = {
+      queryKey: ['string'],
+      queryFn: async () => {
+        await sleep(10)
+        return 'string'
+      },
+    } as const
+
+    await queryClient.prefetchQuery(options)
+
+    const dehydrated = dehydrate(queryClient)
+    expect(
+      dehydrated.queries.find((q) => q.queryHash === '["string"]')?.state
+        .fetchStatus,
+    ).toBe('idle')
+    const stringified = JSON.stringify(dehydrated)
+
+    // ---
+    const parsed = JSON.parse(stringified)
+    const hydrationCache = new QueryCache()
+    const hydrationClient = createQueryClient({ queryCache: hydrationCache })
+
+    const promise = hydrationClient.prefetchQuery(options)
+    hydrate(hydrationClient, parsed)
+    expect(
+      hydrationCache.find({ queryKey: ['string'] })?.state.fetchStatus,
+    ).toBe('fetching')
+    await promise
+    expect(
+      hydrationCache.find({ queryKey: ['string'] })?.state.fetchStatus,
+    ).toBe('idle')
+  })
 })

package/src/tests/queryClient.types.test.tsx

@@ -0,0 +1,173 @@
+import { QueryClient } from '../queryClient'
+import { doNotExecute } from './utils'
+import type { Equal, Expect } from './utils'
+import type { DataTag, InfiniteData } from '../types'
+
+describe('getQueryData', () => {
+  it('should be typed if key is tagged', () => {
+    doNotExecute(() => {
+      const queryKey = ['key'] as DataTag<Array<string>, number>
+      const queryClient = new QueryClient()
+      const data = queryClient.getQueryData(queryKey)
+
+      const result: Expect<Equal<typeof data, number | undefined>> = true
+      return result
+    })
+  })
+
+  it('should infer unknown if key is not tagged', () => {
+    doNotExecute(() => {
+      const queryKey = ['key'] as const
+      const queryClient = new QueryClient()
+      const data = queryClient.getQueryData(queryKey)
+
+      const result: Expect<Equal<typeof data, unknown>> = true
+      return result
+    })
+  })
+
+  it('should infer passed generic if passed', () => {
+    doNotExecute(() => {
+      const queryKey = ['key'] as const
+      const queryClient = new QueryClient()
+      const data = queryClient.getQueryData<number>(queryKey)
+
+      const result: Expect<Equal<typeof data, number | undefined>> = true
+      return result
+    })
+  })
+
+  it('should only allow Arrays to be passed', () => {
+    doNotExecute(() => {
+      const queryKey = 'key' as const
+      const queryClient = new QueryClient()
+      // @ts-expect-error TS2345: Argument of type 'string' is not assignable to parameter of type 'QueryKey'
+      return queryClient.getQueryData(queryKey)
+    })
+  })
+})
+
+describe('setQueryData', () => {
+  it('updater should be typed if key is tagged', () => {
+    doNotExecute(() => {
+      const queryKey = ['key'] as DataTag<Array<string>, number>
+      const queryClient = new QueryClient()
+      const data = queryClient.setQueryData(queryKey, (prev) => {
+        const result: Expect<Equal<typeof prev, number | undefined>> = true
+        return result ? prev : 1
+      })
+
+      const result: Expect<Equal<typeof data, number | undefined>> = true
+      return result
+    })
+  })
+
+  it('value should be typed if key is tagged', () => {
+    doNotExecute(() => {
+      const queryKey = ['key'] as DataTag<Array<string>, number>
+      const queryClient = new QueryClient()
+
+      // @ts-expect-error value should be a number
+      queryClient.setQueryData(queryKey, '1')
+
+      // @ts-expect-error value should be a number
+      queryClient.setQueryData(queryKey, () => '1')
+
+      const data = queryClient.setQueryData(queryKey, 1)
+
+      const result: Expect<Equal<typeof data, number | undefined>> = true
+      return result
+    })
+  })
+
+  it('should infer unknown for updater if key is not tagged', () => {
+    doNotExecute(() => {
+      const queryKey = ['key'] as const
+      const queryClient = new QueryClient()
+      const data = queryClient.setQueryData(queryKey, (prev) => {
+        const result: Expect<Equal<typeof prev, unknown>> = true
+        return result ? prev : 1
+      })
+
+      const result: Expect<Equal<typeof data, unknown>> = true
+      return result
+    })
+  })
+
+  it('should infer unknown for value if key is not tagged', () => {
+    doNotExecute(() => {
+      const queryKey = ['key'] as const
+      const queryClient = new QueryClient()
+      const data = queryClient.setQueryData(queryKey, 'foo')
+
+      const result: Expect<Equal<typeof data, unknown>> = true
+      return result
+    })
+  })
+
+  it('should infer passed generic if passed', () => {
+    doNotExecute(() => {
+      const queryKey = ['key'] as const
+      const queryClient = new QueryClient()
+      const data = queryClient.setQueryData<string>(queryKey, (prev) => {
+        const result: Expect<Equal<typeof prev, string | undefined>> = true
+        return result ? prev : '1'
+      })
+
+      const result: Expect<Equal<typeof data, string | undefined>> = true
+      return result
+    })
+  })
+
+  it('should infer passed generic for value', () => {
+    doNotExecute(() => {
+      const queryKey = ['key'] as const
+      const queryClient = new QueryClient()
+      const data = queryClient.setQueryData<string>(queryKey, 'foo')
+
+      const result: Expect<Equal<typeof data, string | undefined>> = true
+      return result
+    })
+  })
+})
+
+describe('fetchInfiniteQuery', () => {
+  it('should allow passing pages', () => {
+    doNotExecute(async () => {
+      const data = await new QueryClient().fetchInfiniteQuery({
+        queryKey: ['key'],
+        queryFn: () => Promise.resolve('string'),
+        getNextPageParam: () => 1,
+        initialPageParam: 1,
+        pages: 5,
+      })
+
+      const result: Expect<Equal<typeof data, InfiniteData<string, number>>> =
+        true
+      return result
+    })
+  })
+
+  it('should not allow passing getNextPageParam without pages', () => {
+    doNotExecute(async () => {
+      return new QueryClient().fetchInfiniteQuery({
+        queryKey: ['key'],
+        queryFn: () => Promise.resolve('string'),
+        initialPageParam: 1,
+        getNextPageParam: () => 1,
+      })
+    })
+  })
+
+  it('should not allow passing pages without getNextPageParam', () => {
+    doNotExecute(async () => {
+      // @ts-expect-error Property 'getNextPageParam' is missing
+      return new QueryClient().fetchInfiniteQuery({
+        queryKey: ['key'],
+        queryFn: () => Promise.resolve('string'),
+        initialPageParam: 1,
+        pages: 5,
+      })
+    })
+  })
+})

package/src/tests/utils.ts

@@ -66,3 +66,13 @@ export function setIsServer(isServer: boolean) {
     })
   }
 }
+
+export const doNotExecute = (_func: () => void) => true
+
+export type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <
+  T,
+>() => T extends Y ? 1 : 2
+  ? true
+  : false
+
+export type Expect<T extends true> = T

package/src/types.ts

@@ -7,7 +7,7 @@ import type { QueryFilters, QueryTypeFilter } from './utils'
 import type { QueryCache } from './queryCache'
 import type { MutationCache } from './mutationCache'
 
-type NoInfer<T> = [T][T extends any ? 0 : never]
+export type NoInfer<T> = [T][T extends any ? 0 : never]
 
 export interface Register {
   // defaultError: Error
@@ -23,6 +23,11 @@ export type DefaultError = Register extends {
 
 export type QueryKey = ReadonlyArray<unknown>
 
+export declare const dataTagSymbol: unique symbol
+export type DataTag<Type, Value> = Type & {
+  [dataTagSymbol]: Value
+}
+
 export type QueryFunction<
   T = unknown,
   TQueryKey extends QueryKey = QueryKey,
@@ -76,9 +81,10 @@ export type PlaceholderDataFunction<
   previousQuery: Query<TQueryFnData, TError, TQueryData, TQueryKey> | undefined,
 ) => TQueryData | undefined
 
-export type QueriesPlaceholderDataFunction<TQueryData> = () =>
-  | TQueryData
-  | undefined
+export type QueriesPlaceholderDataFunction<TQueryData> = (
+  previousData: undefined,
+  previousQuery: undefined,
+) => TQueryData | undefined
 
 export type QueryKeyHashFunction<TQueryKey extends QueryKey> = (
   queryKey: TQueryKey,
@@ -231,7 +237,6 @@ export interface QueryObserverOptions<
     | number
     | false
     | ((
-        data: TData | undefined,
         query: Query<TQueryFnData, TError, TQueryData, TQueryKey>,
       ) => number | false | undefined)
   /**
@@ -386,7 +391,7 @@ export interface FetchQueryOptions<
 }
 
 type FetchInfiniteQueryPages<TQueryFnData = unknown, TPageParam = unknown> =
-  | { pages?: never; getNextPageParam?: never }
+  | { pages?: never }
   | {
       pages: number
       getNextPageParam: GetNextPageParamFunction<TPageParam, TQueryFnData>

package/src/utils.ts

@@ -56,11 +56,7 @@ export interface MutationFilters {
   status?: MutationStatus
 }
 
-export type DataUpdateFunction<TInput, TOutput> = (input: TInput) => TOutput
-
-export type Updater<TInput, TOutput> =
-  | TOutput
-  | DataUpdateFunction<TInput, TOutput>
+export type Updater<TInput, TOutput> = TOutput | ((input: TInput) => TOutput)
 
 export type QueryTypeFilter = 'all' | 'active' | 'inactive'
 
@@ -77,7 +73,7 @@ export function functionalUpdate<TInput, TOutput>(
   input: TInput,
 ): TOutput {
   return typeof updater === 'function'
-    ? (updater as DataUpdateFunction<TInput, TOutput>)(input)
+    ? (updater as (_: TInput) => TOutput)(input)
     : updater
 }