@tanstack/react-query 5.24.1 → 5.24.5

package/src/__tests__/suspense.types.test.tsx

@@ -1,147 +0,0 @@
-import { describe, it } from 'vitest'
-import { useSuspenseQuery } from '../useSuspenseQuery'
-import { useSuspenseInfiniteQuery } from '../useSuspenseInfiniteQuery'
-import { doNotExecute } from './utils'
-import type { InfiniteData } from '@tanstack/query-core'
-import type { Equal, Expect } from './utils'
-
-describe('useSuspenseQuery', () => {
-  it('should always have data defined', () => {
-    doNotExecute(() => {
-      const { data } = useSuspenseQuery({
-        queryKey: ['key'],
-        queryFn: () => Promise.resolve(5),
-      })
-
-      const result: Expect<Equal<typeof data, number>> = true
-      return result
-    })
-  })
-
-  it('should not have pending status', () => {
-    doNotExecute(() => {
-      const { status } = useSuspenseQuery({
-        queryKey: ['key'],
-        queryFn: () => Promise.resolve(5),
-      })
-
-      const result: Expect<Equal<typeof status, 'error' | 'success'>> = true
-      return result
-    })
-  })
-
-  it('should not allow placeholderData, enabled or throwOnError props', () => {
-    doNotExecute(() => {
-      useSuspenseQuery({
-        queryKey: ['key'],
-        queryFn: () => Promise.resolve(5),
-        // @ts-expect-error TS2345
-        placeholderData: 5,
-        enabled: true,
-      })
-
-      useSuspenseQuery({
-        queryKey: ['key'],
-        queryFn: () => Promise.resolve(5),
-        // @ts-expect-error TS2345
-        enabled: true,
-      })
-
-      useSuspenseQuery({
-        queryKey: ['key'],
-        queryFn: () => Promise.resolve(5),
-        // @ts-expect-error TS2345
-        throwOnError: true,
-      })
-    })
-  })
-
-  it('should not return isPlaceholderData', () => {
-    doNotExecute(() => {
-      const query = useSuspenseQuery({
-        queryKey: ['key'],
-        queryFn: () => Promise.resolve(5),
-      })
-
-      // @ts-expect-error TS2339
-      void query.isPlaceholderData
-    })
-  })
-})
-
-describe('useSuspenseInfiniteQuery', () => {
-  it('should always have data defined', () => {
-    doNotExecute(() => {
-      const { data } = useSuspenseInfiniteQuery({
-        queryKey: ['key'],
-        queryFn: () => Promise.resolve(5),
-        initialPageParam: 1,
-        getNextPageParam: () => 1,
-      })
-
-      const result: Expect<Equal<typeof data, InfiniteData<number, unknown>>> =
-        true
-      return result
-    })
-  })
-
-  it('should not have pending status', () => {
-    doNotExecute(() => {
-      const { status } = useSuspenseInfiniteQuery({
-        queryKey: ['key'],
-        queryFn: () => Promise.resolve(5),
-        initialPageParam: 1,
-        getNextPageParam: () => 1,
-      })
-
-      const result: Expect<Equal<typeof status, 'error' | 'success'>> = true
-      return result
-    })
-  })
-
-  it('should not allow placeholderData, enabled or throwOnError props', () => {
-    doNotExecute(() => {
-      useSuspenseInfiniteQuery({
-        queryKey: ['key'],
-        queryFn: () => Promise.resolve(5),
-        initialPageParam: 1,
-        getNextPageParam: () => 1,
-        // @ts-expect-error TS2345
-        placeholderData: 5,
-        enabled: true,
-      })
-
-      useSuspenseInfiniteQuery({
-        queryKey: ['key'],
-        queryFn: () => Promise.resolve(5),
-        initialPageParam: 1,
-        getNextPageParam: () => 1,
-        // @ts-expect-error TS2345
-        enabled: true,
-      })
-
-      useSuspenseInfiniteQuery({
-        queryKey: ['key'],
-        queryFn: () => Promise.resolve(5),
-        initialPageParam: 1,
-        getNextPageParam: () => 1,
-        // @ts-expect-error TS2345
-        throwOnError: true,
-      })
-    })
-  })
-
-  it('should not return isPlaceholderData', () => {
-    doNotExecute(() => {
-      const query = useSuspenseInfiniteQuery({
-        queryKey: ['key'],
-        queryFn: () => Promise.resolve(5),
-        initialPageParam: 1,
-        getNextPageParam: () => 1,
-      })
-
-      // @ts-expect-error TS2339
-      void query.isPlaceholderData
-    })
-  })
-})

package/src/__tests__/useInfiniteQuery.type.test.tsx

@@ -1,224 +0,0 @@
-import { describe, it } from 'vitest'
-import { QueryClient } from '@tanstack/query-core'
-import { useInfiniteQuery } from '../useInfiniteQuery'
-import { useQuery } from '../useQuery'
-import { doNotExecute } from './utils'
-import type { Equal, Expect } from './utils'
-import type { InfiniteData } from '@tanstack/query-core'
-
-describe('pageParam', () => {
-  it('initialPageParam should define type of param passed to queryFunctionContext', () => {
-    doNotExecute(() => {
-      useInfiniteQuery({
-        queryKey: ['key'],
-        queryFn: ({ pageParam }) => {
-          const result: Expect<Equal<number, typeof pageParam>> = true
-          return result
-        },
-        initialPageParam: 1,
-        getNextPageParam: () => undefined,
-      })
-    })
-  })
-
-  it('direction should be passed to queryFn of useInfiniteQuery', () => {
-    doNotExecute(() => {
-      useInfiniteQuery({
-        queryKey: ['key'],
-        queryFn: ({ direction }) => {
-          const result: Expect<
-            Equal<'forward' | 'backward', typeof direction>
-          > = true
-          return result
-        },
-        initialPageParam: 1,
-        getNextPageParam: () => undefined,
-      })
-    })
-  })
-
-  it('there should be no pageParam passed to the queryFn of useQuery', () => {
-    doNotExecute(() => {
-      useQuery({
-        queryKey: ['key'],
-        // @ts-expect-error there should be no pageParam passed to queryFn of useQuery
-        queryFn: ({ pageParam }) => {
-          return String(pageParam)
-        },
-      })
-    })
-  })
-
-  it('there should be no direction passed to the queryFn of useQuery', () => {
-    doNotExecute(() => {
-      useQuery({
-        queryKey: ['key'],
-        // @ts-expect-error there should be no pageParam passed to queryFn of useQuery
-        queryFn: ({ direction }) => {
-          return String(direction)
-        },
-      })
-    })
-  })
-
-  it('initialPageParam should define type of param passed to queryFunctionContext for fetchInfiniteQuery', () => {
-    doNotExecute(() => {
-      const queryClient = new QueryClient()
-      queryClient.fetchInfiniteQuery({
-        queryKey: ['key'],
-        queryFn: ({ pageParam }) => {
-          const result: Expect<Equal<number, typeof pageParam>> = true
-          return result
-        },
-        initialPageParam: 1,
-      })
-    })
-  })
-
-  it('initialPageParam should define type of param passed to queryFunctionContext for prefetchInfiniteQuery', () => {
-    doNotExecute(() => {
-      const queryClient = new QueryClient()
-      queryClient.prefetchInfiniteQuery({
-        queryKey: ['key'],
-        queryFn: ({ pageParam }) => {
-          const result: Expect<Equal<number, typeof pageParam>> = true
-          return result
-        },
-        initialPageParam: 1,
-      })
-    })
-  })
-})
-describe('select', () => {
-  it('should still return paginated data if no select result', () => {
-    doNotExecute(() => {
-      const infiniteQuery = useInfiniteQuery({
-        queryKey: ['key'],
-        queryFn: ({ pageParam }) => {
-          return pageParam * 5
-        },
-        initialPageParam: 1,
-        getNextPageParam: () => undefined,
-      })
-
-      // TODO: Order of generics prevents pageParams to be typed correctly. Using `unknown` for now
-      const result: Expect<
-        Equal<
-          InfiniteData<number, unknown> | undefined,
-          (typeof infiniteQuery)['data']
-        >
-      > = true
-
-      return result
-    })
-  })
-
-  it('should be able to transform data to arbitrary result', () => {
-    doNotExecute(() => {
-      const infiniteQuery = useInfiniteQuery({
-        queryKey: ['key'],
-        queryFn: ({ pageParam }) => {
-          return pageParam * 5
-        },
-        initialPageParam: 1,
-        getNextPageParam: () => undefined,
-        select: (data) => {
-          const result: Expect<
-            Equal<InfiniteData<number, number>, typeof data>
-          > = true
-          return result
-        },
-      })
-
-      const result: Expect<
-        Equal<true | undefined, (typeof infiniteQuery)['data']>
-      > = true
-      return result
-    })
-  })
-})
-describe('getNextPageParam / getPreviousPageParam', () => {
-  it('should get typed params', () => {
-    doNotExecute(() => {
-      const infiniteQuery = useInfiniteQuery({
-        queryKey: ['key'],
-        queryFn: ({ pageParam }) => {
-          return String(pageParam)
-        },
-        initialPageParam: 1,
-        getNextPageParam: (
-          lastPage,
-          allPages,
-          lastPageParam,
-          allPageParams,
-        ) => {
-          doNotExecute(() => {
-            const lastPageResult: Expect<Equal<string, typeof lastPage>> = true
-            return lastPageResult
-          })
-          doNotExecute(() => {
-            const allPagesResult: Expect<
-              Equal<Array<string>, typeof allPages>
-            > = true
-            return allPagesResult
-          })
-          doNotExecute(() => {
-            const lastPageParamResult: Expect<
-              Equal<number, typeof lastPageParam>
-            > = true
-            return lastPageParamResult
-          })
-          doNotExecute(() => {
-            const allPageParamsResult: Expect<
-              Equal<Array<number>, typeof allPageParams>
-            > = true
-            return allPageParamsResult
-          })
-
-          return undefined
-        },
-        getPreviousPageParam: (
-          firstPage,
-          allPages,
-          firstPageParam,
-          allPageParams,
-        ) => {
-          doNotExecute(() => {
-            const firstPageResult: Expect<Equal<string, typeof firstPage>> =
-              true
-            return firstPageResult
-          })
-          doNotExecute(() => {
-            const allPagesResult: Expect<
-              Equal<Array<string>, typeof allPages>
-            > = true
-            return allPagesResult
-          })
-          doNotExecute(() => {
-            const firstPageParamResult: Expect<
-              Equal<number, typeof firstPageParam>
-            > = true
-            return firstPageParamResult
-          })
-          doNotExecute(() => {
-            const allPageParamsResult: Expect<
-              Equal<Array<number>, typeof allPageParams>
-            > = true
-            return allPageParamsResult
-          })
-
-          return undefined
-        },
-      })
-
-      // TODO: Order of generics prevents pageParams to be typed correctly. Using `unknown` for now
-      const result: Expect<
-        Equal<
-          InfiniteData<string, unknown> | undefined,
-          (typeof infiniteQuery)['data']
-        >
-      > = true
-      return result
-    })
-  })
-})

package/src/__tests__/useQueries.types.test.tsx

@@ -1,148 +0,0 @@
-import { describe, it } from 'vitest'
-import { queryOptions, useQueries } from '..'
-import { doNotExecute } from './utils'
-import type { UseQueryOptions } from '..'
-import type { Equal, Expect } from './utils'
-
-describe('UseQueries config object overload', () => {
-  it('TData should always be defined when initialData is provided as an object', () => {
-    const query1 = {
-      queryKey: ['key1'],
-      queryFn: () => {
-        return {
-          wow: true,
-        }
-      },
-      initialData: {
-        wow: false,
-      },
-    }
-
-    const query2 = {
-      queryKey: ['key2'],
-      queryFn: () => 'Query Data',
-      initialData: 'initial data',
-    }
-
-    const query3 = {
-      queryKey: ['key2'],
-      queryFn: () => 'Query Data',
-    }
-
-    doNotExecute(() => {
-      const queryResults = useQueries({ queries: [query1, query2, query3] })
-
-      const query1Data = queryResults[0].data
-      const query2Data = queryResults[1].data
-      const query3Data = queryResults[2].data
-
-      const result1: Expect<Equal<{ wow: boolean }, typeof query1Data>> = true
-
-      const result2: Expect<Equal<string, typeof query2Data>> = true
-
-      const result3: Expect<Equal<string | undefined, typeof query3Data>> = true
-
-      return result1 && result2 && result3
-    })
-  })
-
-  it('TData should be defined when passed through queryOptions', () => {
-    doNotExecute(() => {
-      const options = queryOptions({
-        queryKey: ['key'],
-        queryFn: () => {
-          return {
-            wow: true,
-          }
-        },
-        initialData: {
-          wow: true,
-        },
-      })
-      const queryResults = useQueries({ queries: [options] })
-
-      const data = queryResults[0].data
-
-      const result: Expect<Equal<{ wow: boolean }, typeof data>> = true
-      return result
-    })
-  })
-
-  it('it should be possible to define a different TData than TQueryFnData using select with queryOptions spread into useQuery', () => {
-    doNotExecute(() => {
-      const query1 = queryOptions({
-        queryKey: ['key'],
-        queryFn: () => Promise.resolve(1),
-        select: (data) => data > 1,
-      })
-
-      const query2 = {
-        queryKey: ['key'],
-        queryFn: () => Promise.resolve(1),
-        select: (data: number) => data > 1,
-      }
-
-      const queryResults = useQueries({ queries: [query1, query2] })
-      const query1Data = queryResults[0].data
-      const query2Data = queryResults[1].data
-
-      const result1: Expect<Equal<boolean | undefined, typeof query1Data>> =
-        true
-      const result2: Expect<Equal<boolean | undefined, typeof query2Data>> =
-        true
-      return result1 && result2
-    })
-  })
-
-  it('TData should have undefined in the union when initialData is provided as a function which can return undefined', () => {
-    doNotExecute(() => {
-      const queryResults = useQueries({
-        queries: [
-          {
-            queryKey: ['key'],
-            queryFn: () => {
-              return {
-                wow: true,
-              }
-            },
-            initialData: () => undefined as { wow: boolean } | undefined,
-          },
-        ],
-      })
-
-      const data = queryResults[0].data
-
-      const result: Expect<Equal<{ wow: boolean } | undefined, typeof data>> =
-        true
-      return result
-    })
-  })
-
-  describe('custom hook', () => {
-    it('should allow custom hooks using UseQueryOptions', () => {
-      doNotExecute(() => {
-        type Data = string
-
-        const useCustomQueries = (
-          options?: Omit<UseQueryOptions<Data>, 'queryKey' | 'queryFn'>,
-        ) => {
-          return useQueries({
-            queries: [
-              {
-                ...options,
-                queryKey: ['todos-key'],
-                queryFn: () => Promise.resolve('data'),
-              },
-            ],
-          })
-        }
-
-        const queryResults = useCustomQueries()
-        const data = queryResults[0].data
-
-        const result: Expect<Equal<Data | undefined, typeof data>> = true
-        return result
-      })
-    })
-  })
-})

package/src/__tests__/useQuery.types.test.tsx

@@ -1,179 +0,0 @@
-import { describe, it } from 'vitest'
-import { useQuery } from '../useQuery'
-import { queryOptions } from '../queryOptions'
-import { doNotExecute } from './utils'
-import type { UseQueryOptions } from '../types'
-import type { Equal, Expect } from './utils'
-
-describe('initialData', () => {
-  describe('Config object overload', () => {
-    it('TData should always be defined when initialData is provided as an object', () => {
-      doNotExecute(() => {
-        const { data } = useQuery({
-          queryKey: ['key'],
-          queryFn: () => {
-            return {
-              wow: true,
-            }
-          },
-          initialData: {
-            wow: true,
-          },
-        })
-
-        const result: Expect<Equal<{ wow: boolean }, typeof data>> = true
-        return result
-      })
-    })
-
-    it('TData should be defined when passed through queryOptions', () => {
-      doNotExecute(() => {
-        const options = queryOptions({
-          queryKey: ['key'],
-          queryFn: () => {
-            return {
-              wow: true,
-            }
-          },
-          initialData: {
-            wow: true,
-          },
-        })
-        const { data } = useQuery(options)
-
-        const result: Expect<Equal<{ wow: boolean }, typeof data>> = true
-        return result
-      })
-    })
-
-    it('it should be possible to define a different TData than TQueryFnData using select with queryOptions spread into useQuery', () => {
-      doNotExecute(() => {
-        const options = queryOptions({
-          queryKey: ['key'],
-          queryFn: () => Promise.resolve(1),
-        })
-
-        const query = useQuery({
-          ...options,
-          select: (data) => data > 1,
-        })
-
-        const result: Expect<
-          Equal<boolean | undefined, (typeof query)['data']>
-        > = true
-        return result
-      })
-    })
-
-    it('TData should always be defined when initialData is provided as a function which ALWAYS returns the data', () => {
-      doNotExecute(() => {
-        const { data } = useQuery({
-          queryKey: ['key'],
-          queryFn: () => {
-            return {
-              wow: true,
-            }
-          },
-          initialData: () => ({
-            wow: true,
-          }),
-        })
-
-        const result: Expect<Equal<{ wow: boolean }, typeof data>> = true
-        return result
-      })
-    })
-
-    it('TData should have undefined in the union when initialData is NOT provided', () => {
-      doNotExecute(() => {
-        const { data } = useQuery({
-          queryKey: ['key'],
-          queryFn: () => {
-            return {
-              wow: true,
-            }
-          },
-        })
-
-        const result: Expect<Equal<{ wow: boolean } | undefined, typeof data>> =
-          true
-        return result
-      })
-    })
-
-    it('TData should have undefined in the union when initialData is provided as a function which can return undefined', () => {
-      doNotExecute(() => {
-        const { data } = useQuery({
-          queryKey: ['key'],
-          queryFn: () => {
-            return {
-              wow: true,
-            }
-          },
-          initialData: () => undefined as { wow: boolean } | undefined,
-        })
-
-        const result: Expect<Equal<{ wow: boolean } | undefined, typeof data>> =
-          true
-        return result
-      })
-    })
-
-    it('TData should be narrowed after an isSuccess check when initialData is provided as a function which can return undefined', () => {
-      doNotExecute(() => {
-        const { data, isSuccess } = useQuery({
-          queryKey: ['key'],
-          queryFn: () => {
-            return {
-              wow: true,
-            }
-          },
-          initialData: () => undefined as { wow: boolean } | undefined,
-        })
-
-        if (isSuccess) {
-          const result: Expect<Equal<{ wow: boolean }, typeof data>> = true
-          return result
-        }
-        return false
-      })
-    })
-  })
-
-  describe('custom hook', () => {
-    it('should allow custom hooks using UseQueryOptions', () => {
-      doNotExecute(() => {
-        type Data = string
-
-        const useCustomQuery = (
-          options?: Omit<UseQueryOptions<Data>, 'queryKey' | 'queryFn'>,
-        ) => {
-          return useQuery({
-            ...options,
-            queryKey: ['todos-key'],
-            queryFn: () => Promise.resolve('data'),
-          })
-        }
-
-        const { data } = useCustomQuery()
-
-        const result: Expect<Equal<Data | undefined, typeof data>> = true
-        return result
-      })
-    })
-  })
-
-  describe('structuralSharing', () => {
-    it('should restrict to same types', () => {
-      doNotExecute(() => {
-        useQuery({
-          queryKey: ['key'],
-          queryFn: () => 5,
-          structuralSharing: (_oldData, newData) => {
-            return newData
-          },
-        })
-      })
-    })
-  })
-})