@tanstack/vue-query 5.40.0 → 5.41.0

package/src/__tests__/queryOptions.types.test.ts

@@ -1,170 +0,0 @@
-import { describe, it } from 'vitest'
-import { reactive, ref } from 'vue-demi'
-import { QueryClient } from '../queryClient'
-import { queryOptions } from '../queryOptions'
-import { useQuery } from '../useQuery'
-import { doNotExecute } from './test-utils'
-import type { dataTagSymbol } from '@tanstack/query-core'
-import type { Equal, Expect } from './test-utils'
-
-describe('queryOptions', () => {
-  it('should not allow excess properties', () => {
-    doNotExecute(() => {
-      return queryOptions({
-        queryKey: ['key'],
-        queryFn: () => Promise.resolve(5),
-        // @ts-expect-error this is a good error, because stallTime does not exist!
-        stallTime: 1000,
-      })
-    })
-  })
-  it('should infer types for callbacks', () => {
-    doNotExecute(() => {
-      return queryOptions({
-        queryKey: ['key'],
-        queryFn: () => Promise.resolve(5),
-        staleTime: 1000,
-        select: (data) => {
-          const result: Expect<Equal<number, typeof data>> = true
-          return result
-        },
-      })
-    })
-  })
-  it('should work when passed to useQuery', () => {
-    doNotExecute(() => {
-      const options = queryOptions({
-        queryKey: ['key'],
-        queryFn: () => Promise.resolve(5),
-      })
-
-      const { data } = reactive(useQuery(options))
-
-      const result: Expect<Equal<typeof data, number | undefined>> = true
-
-      return result
-    })
-  })
-  it('should tag the queryKey with the result type of the QueryFn', () => {
-    doNotExecute(() => {
-      const { queryKey } = queryOptions({
-        queryKey: ['key'],
-        queryFn: () => Promise.resolve(5),
-      })
-
-      const result: Expect<
-        Equal<(typeof queryKey)[typeof dataTagSymbol], number>
-      > = true
-      return result
-    })
-  })
-  it('should tag the queryKey even if no promise is returned', () => {
-    doNotExecute(() => {
-      const { queryKey } = queryOptions({
-        queryKey: ['key'],
-        queryFn: () => 5,
-      })
-
-      const result: Expect<
-        Equal<(typeof queryKey)[typeof dataTagSymbol], number>
-      > = true
-      return result
-    })
-  })
-  it('should tag the queryKey with unknown if there is no queryFn', () => {
-    doNotExecute(() => {
-      const { queryKey } = queryOptions({
-        queryKey: ['key'],
-      })
-
-      const result: Expect<
-        Equal<(typeof queryKey)[typeof dataTagSymbol], unknown>
-      > = true
-      return result
-    })
-  })
-  it('should tag the queryKey with the result type of the QueryFn if select is used', () => {
-    doNotExecute(() => {
-      const { queryKey } = queryOptions({
-        queryKey: ['key'],
-        queryFn: () => Promise.resolve(5),
-        select: (data) => data.toString(),
-      })
-
-      const result: Expect<
-        Equal<(typeof queryKey)[typeof dataTagSymbol], number>
-      > = true
-      return result
-    })
-  })
-  it('should return the proper type when passed to getQueryData', () => {
-    doNotExecute(() => {
-      const { queryKey } = queryOptions({
-        queryKey: ['key'],
-        queryFn: () => Promise.resolve(5),
-      })
-
-      const queryClient = new QueryClient()
-      const data = queryClient.getQueryData(queryKey)
-
-      const result: Expect<Equal<typeof data, number | undefined>> = true
-      return result
-    })
-  })
-  it('should properly type updaterFn when passed to setQueryData', () => {
-    doNotExecute(() => {
-      const { queryKey } = queryOptions({
-        queryKey: ['key'],
-        queryFn: () => Promise.resolve(5),
-      })
-
-      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('should properly type value when passed to setQueryData', () => {
-    doNotExecute(() => {
-      const { queryKey } = queryOptions({
-        queryKey: ['key'],
-        queryFn: () => Promise.resolve(5),
-      })
-
-      const queryClient = new QueryClient()
-
-      // @ts-expect-error value should be a number
-      queryClient.setQueryData(queryKey, '5')
-      // @ts-expect-error value should be a number
-      queryClient.setQueryData(queryKey, () => '5')
-
-      const data = queryClient.setQueryData(queryKey, 5)
-
-      const result: Expect<Equal<typeof data, number | undefined>> = true
-      return result
-    })
-  })
-  it('should allow to be passed to QueryClient methods while containing ref in queryKey', () => {
-    doNotExecute(() => {
-      const options = queryOptions({
-        queryKey: ['key', ref(1), { nested: ref(2) }],
-        queryFn: () => Promise.resolve(5),
-      })
-
-      const queryClient = new QueryClient()
-
-      // Should not error
-      const data = queryClient.invalidateQueries(options)
-      // Should not error
-      const data2 = queryClient.fetchQuery(options)
-
-      const result: Expect<Equal<typeof data, Promise<void>>> = true
-      const result2: Expect<Equal<typeof data2, Promise<number>>> = true
-      return result || result2
-    })
-  })
-})

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

@@ -1,106 +0,0 @@
-import { describe, it } from 'vitest'
-import { reactive } from 'vue-demi'
-import { useInfiniteQuery } from '../useInfiniteQuery'
-import { doNotExecute, simpleFetcher } from './test-utils'
-import type { Equal, Expect } from './test-utils'
-import type { InfiniteData } from '@tanstack/query-core'
-
-describe('Discriminated union return type', () => {
-  it('data should be possibly undefined by default', () => {
-    doNotExecute(() => {
-      const query = reactive(
-        useInfiniteQuery({
-          queryKey: ['infiniteQuery'],
-          queryFn: simpleFetcher,
-          getNextPageParam: () => undefined,
-          initialPageParam: 0,
-        }),
-      )
-
-      // TODO: Order of generics prevents pageParams to be typed correctly. Using `unknown` for now
-      const result: Expect<
-        Equal<InfiniteData<string, unknown> | undefined, typeof query.data>
-      > = true
-      return result
-    })
-  })
-
-  it('data should be defined when query is success', () => {
-    doNotExecute(() => {
-      const query = reactive(
-        useInfiniteQuery({
-          queryKey: ['infiniteQuery'],
-          queryFn: simpleFetcher,
-          getNextPageParam: () => undefined,
-          initialPageParam: 0,
-        }),
-      )
-
-      if (query.isSuccess) {
-        // TODO: Order of generics prevents pageParams to be typed correctly. Using `unknown` for now
-        const result: Expect<
-          Equal<InfiniteData<string, unknown>, typeof query.data>
-        > = true
-        return result
-      }
-      return
-    })
-  })
-
-  it('error should be null when query is success', () => {
-    doNotExecute(() => {
-      const query = reactive(
-        useInfiniteQuery({
-          queryKey: ['infiniteQuery'],
-          queryFn: simpleFetcher,
-          getNextPageParam: () => undefined,
-          initialPageParam: 0,
-        }),
-      )
-
-      if (query.isSuccess) {
-        const result: Expect<Equal<null, typeof query.error>> = true
-        return result
-      }
-      return
-    })
-  })
-
-  it('data should be undefined when query is pending', () => {
-    doNotExecute(() => {
-      const query = reactive(
-        useInfiniteQuery({
-          queryKey: ['infiniteQuery'],
-          queryFn: simpleFetcher,
-          getNextPageParam: () => undefined,
-          initialPageParam: 0,
-        }),
-      )
-
-      if (query.isPending) {
-        const result: Expect<Equal<undefined, typeof query.data>> = true
-        return result
-      }
-      return
-    })
-  })
-
-  it('error should be defined when query is error', () => {
-    doNotExecute(() => {
-      const query = reactive(
-        useInfiniteQuery({
-          queryKey: ['infiniteQuery'],
-          queryFn: simpleFetcher,
-          getNextPageParam: () => undefined,
-          initialPageParam: 0,
-        }),
-      )
-
-      if (query.isError) {
-        const result: Expect<Equal<Error, typeof query.error>> = true
-        return result
-      }
-      return
-    })
-  })
-})

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

@@ -1,98 +0,0 @@
-import { describe, it } from 'vitest'
-import { reactive } from 'vue-demi'
-import { useMutation } from '../useMutation'
-import { doNotExecute, successMutator } from './test-utils'
-import type { Equal, Expect } from './test-utils'
-
-describe('Discriminated union return type', () => {
-  it('data should be possibly undefined by default', () => {
-    doNotExecute(() => {
-      const mutation = reactive(
-        useMutation({ mutationFn: successMutator<string> }),
-      )
-
-      const result: Expect<Equal<string | undefined, typeof mutation.data>> =
-        true
-      return result
-    })
-  })
-
-  it('data should be defined when mutation is success', () => {
-    doNotExecute(() => {
-      const mutation = reactive(
-        useMutation({ mutationFn: successMutator<string> }),
-      )
-
-      if (mutation.isSuccess) {
-        const result: Expect<Equal<string, typeof mutation.data>> = true
-        return result
-      }
-      return
-    })
-  })
-
-  it('error should be null when mutation is success', () => {
-    doNotExecute(() => {
-      const mutation = reactive(
-        useMutation({ mutationFn: successMutator<string> }),
-      )
-
-      if (mutation.isSuccess) {
-        const result: Expect<Equal<null, typeof mutation.error>> = true
-        return result
-      }
-      return
-    })
-  })
-
-  it('data should be undefined when mutation is pending', () => {
-    doNotExecute(() => {
-      const mutation = reactive(
-        useMutation({ mutationFn: successMutator<string> }),
-      )
-
-      if (mutation.isPending) {
-        const result: Expect<Equal<undefined, typeof mutation.data>> = true
-        return result
-      }
-      return
-    })
-  })
-
-  it('error should be defined when mutation is error', () => {
-    doNotExecute(() => {
-      const mutation = reactive(
-        useMutation({ mutationFn: successMutator<string> }),
-      )
-
-      if (mutation.isError) {
-        const result: Expect<Equal<Error, typeof mutation.error>> = true
-        return result
-      }
-      return
-    })
-  })
-
-  it('should narrow variables', () => {
-    doNotExecute(() => {
-      const mutation = reactive(
-        useMutation({ mutationFn: successMutator<string> }),
-      )
-
-      if (mutation.isIdle) {
-        const result: Expect<Equal<undefined, typeof mutation.variables>> = true
-        return result
-      }
-      if (mutation.isPending) {
-        const result: Expect<Equal<string, typeof mutation.variables>> = true
-        return result
-      }
-      if (mutation.isSuccess) {
-        const result: Expect<Equal<string, typeof mutation.variables>> = true
-        return result
-      }
-      const result: Expect<Equal<string, typeof mutation.variables>> = true
-      return result
-    })
-  })
-})

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

@@ -1,176 +0,0 @@
-import { describe, it } from 'vitest'
-import { reactive } from 'vue'
-import { skipToken, useQueries } from '..'
-import { queryOptions } from '../queryOptions'
-import { doNotExecute } from './test-utils'
-import type { OmitKeyof } from '..'
-import type { UseQueryOptions } from '../useQuery'
-import type { Equal, Expect } from './test-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 = queryOptions({
-      queryKey: ['key2'],
-      queryFn: () => 'Query Data',
-      initialData: 'initial data',
-    })
-
-    const query3 = {
-      queryKey: ['key2'],
-      queryFn: () => 'Query Data',
-    }
-
-    doNotExecute(() => {
-      const { value: queriesState } = useQueries({
-        queries: [query1, query2, query3],
-      })
-
-      const query1Data = queriesState[0].data
-      const query2Data = queriesState[1].data
-      const query3Data = queriesState[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 { value: queriesState } = useQueries({ queries: [options] })
-
-      const data = queriesState[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 useQueries', () => {
-    doNotExecute(() => {
-      const query1 = queryOptions({
-        queryKey: ['key'],
-        queryFn: () => Promise.resolve(1),
-        select: (data) => data > 1,
-      })
-
-      const query2 = {
-        queryKey: ['key'],
-        queryFn: () => Promise.resolve(1),
-        select: (data: any) => data > 1,
-      }
-
-      const queriesState = reactive(useQueries({ queries: [query1, query2] }))
-      const query1Data = queriesState.value[0].data
-      const query2Data = queriesState.value[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 { value: queriesState } = useQueries({
-        queries: [
-          {
-            queryKey: ['key'],
-            queryFn: () => {
-              return {
-                wow: true,
-              }
-            },
-            initialData: () => undefined as { wow: boolean } | undefined,
-          },
-        ],
-      })
-
-      const data = queriesState[0].data
-
-      const result: Expect<Equal<{ wow: boolean } | undefined, typeof data>> =
-        true
-      return result
-    })
-  })
-
-  it('TData should have correct type when conditional skipToken is passed', () => {
-    doNotExecute(() => {
-      const { value: queriesState } = useQueries({
-        queries: [
-          {
-            queryKey: ['key'],
-            queryFn: Math.random() > 0.5 ? skipToken : () => Promise.resolve(5),
-          },
-        ],
-      })
-
-      const data = queriesState[0].data
-
-      const result: Expect<Equal<number | undefined, typeof data>> = true
-      return result
-    })
-  })
-
-  describe('custom hook', () => {
-    it('should allow custom hooks using UseQueryOptions', () => {
-      doNotExecute(() => {
-        type Data = string
-
-        const useCustomQueries = (
-          options?: OmitKeyof<
-            UseQueryOptions<Data>,
-            'queryKey' | 'queryFn',
-            'safely'
-          >,
-        ) => {
-          return useQueries({
-            queries: [
-              {
-                ...options,
-                queryKey: ['todos-key'],
-                queryFn: () => Promise.resolve('data'),
-              },
-            ],
-          })
-        }
-
-        const { value: queriesState } = useCustomQueries()
-        const data = queriesState[0].data
-
-        const result: Expect<Equal<Data | undefined, typeof data>> = true
-        return result
-      })
-    })
-  })
-})