@tanstack/query-core 5.24.8 → 5.26.3

package/src/tests/queryClient.test.tsx

@@ -10,6 +10,7 @@ import {
   hydrate,
   onlineManager,
 } from '..'
+import { skipToken } from '../utils'
 import {
   createQueryClient,
   mockOnlineManagerIsOnline,
@@ -1354,6 +1355,7 @@ describe('queryClient', () => {
     test('should refetch all active queries', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
+      const key3 = queryKey()
       const queryFn1 = vi.fn<Array<unknown>, string>().mockReturnValue('data1')
       const queryFn2 = vi.fn<Array<unknown>, string>().mockReturnValue('data2')
       const observer1 = new QueryObserver(queryClient, {
@@ -1366,13 +1368,21 @@ describe('queryClient', () => {
         queryFn: queryFn2,
         enabled: false,
       })
+      const observer3 = new QueryObserver(queryClient, {
+        queryKey: key3,
+        queryFn: skipToken,
+      })
+      let didSkipTokenRun = false
       observer1.subscribe(() => undefined)
       observer2.subscribe(() => undefined)
+      observer3.subscribe(() => (didSkipTokenRun = true))
       await queryClient.resetQueries()
+      observer3.destroy()
       observer2.destroy()
       observer1.destroy()
       expect(queryFn1).toHaveBeenCalledTimes(2)
       expect(queryFn2).toHaveBeenCalledTimes(0)
+      expect(didSkipTokenRun).toBe(false)
     })
   })
 

package/src/tests/queryObserver.test-d.tsx

@@ -0,0 +1,108 @@
+import { afterEach, beforeEach, describe, expectTypeOf, it } from 'vitest'
+import { QueryObserver } from '..'
+import { createQueryClient, queryKey } from './utils'
+import type { QueryClient } from '..'
+
+describe('queryObserver', () => {
+  let queryClient: QueryClient
+
+  beforeEach(() => {
+    queryClient = createQueryClient()
+    queryClient.mount()
+  })
+
+  afterEach(() => {
+    queryClient.clear()
+  })
+
+  it('should be inferred as a correct result type', () => {
+    const observer = new QueryObserver(queryClient, {
+      queryKey: queryKey(),
+      queryFn: () => Promise.resolve({ value: 'data' }),
+    })
+
+    const result = observer.getCurrentResult()
+
+    if (result.isPending) {
+      expectTypeOf(result.data).toEqualTypeOf<undefined>()
+      expectTypeOf(result.error).toEqualTypeOf<null>()
+      expectTypeOf(result.isLoading).toEqualTypeOf<boolean>()
+      expectTypeOf(result.status).toEqualTypeOf<'pending'>()
+    }
+    if (result.isLoading) {
+      expectTypeOf(result.data).toEqualTypeOf<undefined>()
+      expectTypeOf(result.error).toEqualTypeOf<null>()
+      expectTypeOf(result.isPending).toEqualTypeOf<true>()
+      expectTypeOf(result.status).toEqualTypeOf<'pending'>()
+    }
+
+    if (result.isLoadingError) {
+      expectTypeOf(result.data).toEqualTypeOf<undefined>()
+      expectTypeOf(result.error).toEqualTypeOf<Error>()
+      expectTypeOf(result.status).toEqualTypeOf<'error'>()
+    }
+
+    if (result.isRefetchError) {
+      expectTypeOf(result.data).toEqualTypeOf<{ value: string }>()
+      expectTypeOf(result.error).toEqualTypeOf<Error>()
+      expectTypeOf(result.status).toEqualTypeOf<'error'>()
+    }
+
+    if (result.isSuccess) {
+      expectTypeOf(result.data).toEqualTypeOf<{ value: string }>()
+      expectTypeOf(result.error).toEqualTypeOf<null>()
+      expectTypeOf(result.status).toEqualTypeOf<'success'>()
+    }
+  })
+
+  describe('placeholderData', () => {
+    it('previousQuery should have typed queryKey', () => {
+      const testQueryKey = ['SomeQuery', 42, { foo: 'bar' }] as const
+
+      new QueryObserver(createQueryClient(), {
+        queryKey: testQueryKey,
+        placeholderData: (_, previousQuery) => {
+          if (previousQuery) {
+            expectTypeOf(previousQuery.queryKey).toEqualTypeOf<
+              typeof testQueryKey
+            >()
+          }
+        },
+      })
+    })
+
+    it('previousQuery should have typed error', () => {
+      class CustomError extends Error {
+        name = 'CustomError' as const
+      }
+
+      new QueryObserver<boolean, CustomError>(createQueryClient(), {
+        queryKey: ['key'],
+        placeholderData: (_, previousQuery) => {
+          if (previousQuery) {
+            expectTypeOf(
+              previousQuery.state.error,
+            ).toEqualTypeOf<CustomError | null>()
+          }
+          return undefined
+        },
+      })
+    })
+
+    it('previousData should have the same type as query data', () => {
+      const queryData = { foo: 'bar' } as const
+
+      new QueryObserver(createQueryClient(), {
+        queryKey: ['key'],
+        queryFn: () => queryData,
+        select: (data) => data.foo,
+        placeholderData: (previousData) => {
+          expectTypeOf(previousData).toEqualTypeOf<
+            typeof queryData | undefined
+          >()
+          return undefined
+        },
+      })
+    })
+  })
+})

package/src/tests/queryObserver.test.tsx

@@ -120,7 +120,9 @@ describe('queryObserver', () => {
     })
     let observerResult
     const unsubscribe = observer.subscribe((result) => {
-      expectTypeOf<QueryObserverResult<{ myCount: number }>>(result)
+      expectTypeOf(result).toEqualTypeOf<
+        QueryObserverResult<{ myCount: number }>
+      >()
       observerResult = result
     })
     await sleep(1)
@@ -136,7 +138,9 @@ describe('queryObserver', () => {
       select: (data) => ({ myCount: data.count }),
     })
     const observerResult = await observer.refetch()
-    expectTypeOf<{ myCount: number } | undefined>(observerResult.data)
+    expectTypeOf(observerResult.data).toEqualTypeOf<
+      { myCount: number } | undefined
+    >()
     expect(observerResult.data).toMatchObject({ myCount: 1 })
   })
 
@@ -894,42 +898,4 @@ describe('queryObserver', () => {
 
     unsubscribe()
   })
-
-  test('should be inferred as a correct result type', async () => {
-    const key = queryKey()
-    const data = { value: 'data' }
-    const observer = new QueryObserver(queryClient, {
-      queryKey: key,
-      queryFn: () => Promise.resolve(data),
-    })
-
-    const result = observer.getCurrentResult()
-
-    result.isPending &&
-      expectTypeOf<undefined>(result.data) &&
-      expectTypeOf<null>(result.error) &&
-      expectTypeOf<boolean>(result.isLoading) &&
-      expectTypeOf<'pending'>(result.status)
-
-    result.isLoading &&
-      expectTypeOf<undefined>(result.data) &&
-      expectTypeOf<null>(result.error) &&
-      expectTypeOf<true>(result.isPending) &&
-      expectTypeOf<'pending'>(result.status)
-
-    result.isLoadingError &&
-      expectTypeOf<undefined>(result.data) &&
-      expectTypeOf<Error>(result.error) &&
-      expectTypeOf<'error'>(result.status)
-
-    result.isRefetchError &&
-      expectTypeOf<{ value: string }>(result.data) &&
-      expectTypeOf<Error>(result.error) &&
-      expectTypeOf<'error'>(result.status)
-
-    result.isSuccess &&
-      expectTypeOf<{ value: string }>(result.data) &&
-      expectTypeOf<null>(result.error) &&
-      expectTypeOf<'success'>(result.status)
-  })
 })

package/src/tests/utils.ts

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

package/src/types.ts

@@ -3,7 +3,7 @@
 import type { MutationState } from './mutation'
 import type { FetchDirection, Query, QueryBehavior } from './query'
 import type { RetryDelayValue, RetryValue } from './retryer'
-import type { QueryFilters, QueryTypeFilter } from './utils'
+import type { QueryFilters, QueryTypeFilter, SkipToken } from './utils'
 import type { QueryCache } from './queryCache'
 import type { MutationCache } from './mutationCache'
 
@@ -147,7 +147,7 @@ export interface QueryOptions<
    * Setting it to `Infinity` will disable garbage collection.
    */
   gcTime?: number
-  queryFn?: QueryFunction<TQueryFnData, TQueryKey, TPageParam>
+  queryFn?: QueryFunction<TQueryFnData, TQueryKey, TPageParam> | SkipToken
   persister?: QueryPersister<
     NoInfer<TQueryFnData>,
     NoInfer<TQueryKey>,

package/src/utils.ts

@@ -342,3 +342,6 @@ export function addToStart<T>(items: Array<T>, item: T, max = 0): Array<T> {
   const newItems = [item, ...items]
   return max && newItems.length > max ? newItems.slice(0, -1) : newItems
 }
+
+export const skipToken = Symbol()
+export type SkipToken = typeof skipToken

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

@@ -1,174 +0,0 @@
-import { describe, it } from 'vitest'
-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/queryObserver.types.test.tsx

@@ -1,66 +0,0 @@
-import { describe, it } from 'vitest'
-import { QueryObserver } from '..'
-import { createQueryClient, doNotExecute } from './utils'
-import type { Equal, Expect } from './utils'
-
-describe('placeholderData', () => {
-  describe('placeholderData function', () => {
-    it('previousQuery should have typed queryKey', () => {
-      doNotExecute(() => {
-        const queryKey = ['SomeQuery', 42, { foo: 'bar' }] as const
-        type QueryKey = typeof queryKey
-
-        new QueryObserver(createQueryClient(), {
-          queryKey,
-          placeholderData: (_, previousQuery) => {
-            const previousQueryKey = previousQuery?.queryKey
-
-            const result: Expect<
-              Equal<typeof previousQueryKey, QueryKey | undefined>
-            > = true
-            return result
-          },
-        })
-      })
-    })
-
-    it('previousQuery should have typed error', () => {
-      doNotExecute(() => {
-        class CustomError extends Error {
-          name = 'CustomError' as const
-        }
-
-        new QueryObserver<boolean, CustomError>(createQueryClient(), {
-          queryKey: ['key'],
-          placeholderData: (_, previousQuery) => {
-            const error = previousQuery?.state.error
-
-            const result: Expect<
-              Equal<typeof error, CustomError | null | undefined>
-            > = true
-            return result
-          },
-        })
-      })
-    })
-
-    it('previousData should have the same type as query data', () => {
-      doNotExecute(() => {
-        const queryData = { foo: 'bar' } as const
-        type QueryData = typeof queryData
-
-        new QueryObserver(createQueryClient(), {
-          queryKey: ['key'],
-          queryFn: () => queryData,
-          select: (data) => data.foo,
-          placeholderData: (previousData) => {
-            const result: Expect<
-              Equal<typeof previousData, QueryData | undefined>
-            > = true
-            return result ? previousData : undefined
-          },
-        })
-      })
-    })
-  })
-})