@tanstack/query-core 5.25.0 → 5.27.1

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

@@ -0,0 +1,135 @@
+import { describe, expectTypeOf, it } from 'vitest'
+import { QueryClient } from '../queryClient'
+import type { DataTag, InfiniteData } from '../types'
+
+describe('getQueryData', () => {
+  it('should be typed if key is tagged', () => {
+    const queryKey = ['key'] as DataTag<Array<string>, number>
+    const queryClient = new QueryClient()
+    const data = queryClient.getQueryData(queryKey)
+
+    expectTypeOf(data).toEqualTypeOf<number | undefined>()
+  })
+
+  it('should infer unknown if key is not tagged', () => {
+    const queryKey = ['key'] as const
+    const queryClient = new QueryClient()
+    const data = queryClient.getQueryData(queryKey)
+
+    expectTypeOf(data).toEqualTypeOf<unknown>()
+  })
+
+  it('should infer passed generic if passed', () => {
+    const queryKey = ['key'] as const
+    const queryClient = new QueryClient()
+    const data = queryClient.getQueryData<number>(queryKey)
+
+    expectTypeOf(data).toEqualTypeOf<number | undefined>()
+  })
+
+  it('should only allow Arrays to be passed', () => {
+    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', () => {
+    const queryKey = ['key'] as DataTag<Array<string>, number>
+    const queryClient = new QueryClient()
+    const data = queryClient.setQueryData(queryKey, (prev) => {
+      expectTypeOf(prev).toEqualTypeOf<number | undefined>()
+      return prev
+    })
+
+    expectTypeOf(data).toEqualTypeOf<number | undefined>()
+  })
+
+  it('value should be typed if key is tagged', () => {
+    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)
+
+    expectTypeOf(data).toEqualTypeOf<number | undefined>()
+  })
+
+  it('should infer unknown for updater if key is not tagged', () => {
+    const queryKey = ['key'] as const
+    const queryClient = new QueryClient()
+    const data = queryClient.setQueryData(queryKey, (prev) => {
+      expectTypeOf(prev).toEqualTypeOf<unknown>()
+      return prev
+    })
+
+    expectTypeOf(data).toEqualTypeOf<unknown>()
+  })
+
+  it('should infer unknown for value if key is not tagged', () => {
+    const queryKey = ['key'] as const
+    const queryClient = new QueryClient()
+    const data = queryClient.setQueryData(queryKey, 'foo')
+
+    expectTypeOf(data).toEqualTypeOf<unknown>()
+  })
+
+  it('should infer passed generic if passed', () => {
+    const queryKey = ['key'] as const
+    const queryClient = new QueryClient()
+    const data = queryClient.setQueryData<string>(queryKey, (prev) => {
+      expectTypeOf(prev).toEqualTypeOf<string | undefined>()
+      return prev
+    })
+
+    expectTypeOf(data).toEqualTypeOf<string | undefined>()
+  })
+
+  it('should infer passed generic for value', () => {
+    const queryKey = ['key'] as const
+    const queryClient = new QueryClient()
+    const data = queryClient.setQueryData<string>(queryKey, 'foo')
+
+    expectTypeOf(data).toEqualTypeOf<string | undefined>()
+  })
+})
+
+describe('fetchInfiniteQuery', () => {
+  it('should allow passing pages', async () => {
+    const data = await new QueryClient().fetchInfiniteQuery({
+      queryKey: ['key'],
+      queryFn: () => Promise.resolve('string'),
+      getNextPageParam: () => 1,
+      initialPageParam: 1,
+      pages: 5,
+    })
+
+    expectTypeOf(data).toEqualTypeOf<InfiniteData<string, number>>()
+  })
+
+  it('should not allow passing getNextPageParam without pages', () => {
+    new QueryClient().fetchInfiniteQuery({
+      queryKey: ['key'],
+      queryFn: () => Promise.resolve('string'),
+      initialPageParam: 1,
+      getNextPageParam: () => 1,
+    })
+  })
+
+  it('should not allow passing pages without getNextPageParam', () => {
+    // @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.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/utils.ts

@@ -62,7 +62,7 @@ export type QueryTypeFilter = 'all' | 'active' | 'inactive'
 
 // UTILS
 
-export const isServer = typeof window === 'undefined' || 'Deno' in window
+export const isServer = typeof window === 'undefined' || 'Deno' in globalThis
 
 export function noop(): undefined {
   return undefined

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
-          },
-        })
-      })
-    })
-  })
-})