@tanstack/vue-query 5.59.17 → 5.59.20

package/src/__tests__/queryClient.test.ts

@@ -1,433 +0,0 @@
-import { describe, expect, test, vi } from 'vitest'
-import { ref } from 'vue-demi'
-import { QueryClient as QueryClientOrigin } from '@tanstack/query-core'
-import { QueryClient } from '../queryClient'
-import { infiniteQueryOptions } from '../infiniteQueryOptions'
-import { flushPromises } from './test-utils'
-
-vi.mock('@tanstack/query-core')
-
-const queryKeyRef = ['foo', ref('bar')]
-const queryKeyUnref = ['foo', 'bar']
-
-const fn = () => 'mock'
-
-describe('QueryCache', () => {
-  describe('isFetching', () => {
-    test('should properly unwrap 1 parameter', async () => {
-      const queryClient = new QueryClient()
-
-      queryClient.isFetching({
-        queryKey: queryKeyRef,
-      })
-
-      expect(QueryClientOrigin.prototype.isFetching).toBeCalledWith({
-        queryKey: queryKeyUnref,
-      })
-    })
-  })
-
-  describe('isMutating', () => {
-    test('should properly unwrap 1 parameter', async () => {
-      const queryClient = new QueryClient()
-
-      queryClient.isMutating({
-        mutationKey: queryKeyRef,
-      })
-
-      expect(QueryClientOrigin.prototype.isMutating).toBeCalledWith({
-        mutationKey: queryKeyUnref,
-      })
-    })
-  })
-
-  describe('getQueryData', () => {
-    test('should properly unwrap 1 parameter', async () => {
-      const queryClient = new QueryClient()
-
-      queryClient.getQueryData(queryKeyRef)
-
-      expect(QueryClientOrigin.prototype.getQueryData).toBeCalledWith(
-        queryKeyUnref,
-      )
-    })
-  })
-
-  describe('getQueriesData', () => {
-    test('should properly unwrap queryKey param', async () => {
-      const queryClient = new QueryClient()
-
-      queryClient.getQueriesData({ queryKey: queryKeyRef })
-
-      expect(QueryClientOrigin.prototype.getQueriesData).toBeCalledWith({
-        queryKey: queryKeyUnref,
-      })
-    })
-
-    test('should properly unwrap filters param', async () => {
-      const queryClient = new QueryClient()
-
-      queryClient.getQueriesData({ queryKey: queryKeyRef })
-
-      expect(QueryClientOrigin.prototype.getQueriesData).toBeCalledWith({
-        queryKey: queryKeyUnref,
-      })
-    })
-  })
-
-  describe('setQueryData', () => {
-    test('should properly unwrap 3 parameter', async () => {
-      const queryClient = new QueryClient()
-
-      queryClient.setQueryData(queryKeyRef, fn, {
-        updatedAt: ref(3),
-      })
-
-      expect(QueryClientOrigin.prototype.setQueryData).toBeCalledWith(
-        queryKeyUnref,
-        fn,
-        { updatedAt: 3 },
-      )
-    })
-  })
-
-  describe('setQueriesData', () => {
-    test('should properly unwrap params with queryKey', async () => {
-      const queryClient = new QueryClient()
-
-      queryClient.setQueriesData({ queryKey: queryKeyRef }, fn, {
-        updatedAt: ref(3),
-      })
-
-      expect(QueryClientOrigin.prototype.setQueriesData).toBeCalledWith(
-        { queryKey: queryKeyUnref },
-        fn,
-        { updatedAt: 3 },
-      )
-    })
-
-    test('should properly unwrap params with filters', async () => {
-      const queryClient = new QueryClient()
-
-      queryClient.setQueriesData({ queryKey: queryKeyRef }, fn, {
-        updatedAt: ref(3),
-      })
-
-      expect(QueryClientOrigin.prototype.setQueriesData).toBeCalledWith(
-        { queryKey: queryKeyUnref },
-        fn,
-        { updatedAt: 3 },
-      )
-    })
-  })
-
-  describe('getQueryState', () => {
-    test('should properly unwrap 1 parameter', async () => {
-      const queryClient = new QueryClient()
-
-      queryClient.getQueryState(queryKeyRef)
-
-      expect(QueryClientOrigin.prototype.getQueryState).toBeCalledWith(
-        queryKeyUnref,
-      )
-    })
-  })
-
-  describe('removeQueries', () => {
-    test('should properly unwrap 1 parameter', async () => {
-      const queryClient = new QueryClient()
-
-      queryClient.removeQueries({
-        queryKey: queryKeyRef,
-      })
-
-      expect(QueryClientOrigin.prototype.removeQueries).toBeCalledWith({
-        queryKey: queryKeyUnref,
-      })
-    })
-  })
-
-  describe('resetQueries', () => {
-    test('should properly unwrap 2 parameter', async () => {
-      const queryClient = new QueryClient()
-
-      queryClient.resetQueries(
-        {
-          queryKey: queryKeyRef,
-        },
-        { cancelRefetch: ref(false) },
-      )
-
-      expect(QueryClientOrigin.prototype.resetQueries).toBeCalledWith(
-        {
-          queryKey: queryKeyUnref,
-        },
-        { cancelRefetch: false },
-      )
-    })
-  })
-
-  describe('cancelQueries', () => {
-    test('should properly unwrap 2 parameter', async () => {
-      const queryClient = new QueryClient()
-
-      queryClient.cancelQueries(
-        {
-          queryKey: queryKeyRef,
-        },
-        { revert: ref(false) },
-      )
-
-      expect(QueryClientOrigin.prototype.cancelQueries).toBeCalledWith(
-        {
-          queryKey: queryKeyUnref,
-        },
-        { revert: false },
-      )
-    })
-  })
-
-  describe('invalidateQueries', () => {
-    test('should properly unwrap 2 parameter', () => {
-      const queryClient = new QueryClient()
-
-      queryClient.invalidateQueries(
-        {
-          queryKey: queryKeyRef,
-        },
-        { cancelRefetch: ref(false) },
-      )
-
-      expect(QueryClientOrigin.prototype.invalidateQueries).toBeCalledWith(
-        {
-          queryKey: queryKeyUnref,
-          refetchType: 'none',
-        },
-        { cancelRefetch: false },
-      )
-    })
-
-    // #7694
-    test('should call invalidateQueries immediately and refetchQueries after flushPromises', async () => {
-      const invalidateQueries = vi.spyOn(
-        QueryClientOrigin.prototype,
-        'invalidateQueries',
-      )
-      const refetchQueries = vi.spyOn(
-        QueryClientOrigin.prototype,
-        'refetchQueries',
-      )
-
-      const queryClient = new QueryClient()
-
-      queryClient.invalidateQueries({
-        queryKey: queryKeyRef,
-      })
-
-      expect(invalidateQueries).toBeCalled()
-      expect(refetchQueries).not.toBeCalled()
-
-      await flushPromises()
-
-      expect(refetchQueries).toBeCalled()
-    })
-
-    test('should call invalidateQueries immediately and not call refetchQueries', async () => {
-      const invalidateQueries = vi.spyOn(
-        QueryClientOrigin.prototype,
-        'invalidateQueries',
-      )
-      const refetchQueries = vi.spyOn(
-        QueryClientOrigin.prototype,
-        'refetchQueries',
-      )
-
-      const queryClient = new QueryClient()
-
-      queryClient.invalidateQueries({
-        queryKey: queryKeyRef,
-        refetchType: 'none',
-      })
-
-      expect(invalidateQueries).toBeCalled()
-      expect(refetchQueries).not.toBeCalled()
-
-      await flushPromises()
-
-      expect(refetchQueries).not.toBeCalled()
-    })
-  })
-
-  describe('refetchQueries', () => {
-    test('should properly unwrap 2 parameter', async () => {
-      const queryClient = new QueryClient()
-
-      queryClient.refetchQueries(
-        {
-          queryKey: queryKeyRef,
-        },
-        { cancelRefetch: ref(false) },
-      )
-
-      expect(QueryClientOrigin.prototype.refetchQueries).toBeCalledWith(
-        {
-          queryKey: queryKeyUnref,
-        },
-        { cancelRefetch: false },
-      )
-    })
-  })
-
-  describe('fetchQuery', () => {
-    test('should properly unwrap parameter', async () => {
-      const queryClient = new QueryClient()
-
-      queryClient.fetchQuery({
-        queryKey: queryKeyRef,
-      })
-
-      expect(QueryClientOrigin.prototype.fetchQuery).toBeCalledWith({
-        queryKey: queryKeyUnref,
-      })
-    })
-  })
-
-  describe('prefetchQuery', () => {
-    test('should properly unwrap parameters', async () => {
-      const queryClient = new QueryClient()
-
-      queryClient.prefetchQuery({ queryKey: queryKeyRef, queryFn: fn })
-
-      expect(QueryClientOrigin.prototype.prefetchQuery).toBeCalledWith({
-        queryKey: queryKeyUnref,
-        queryFn: fn,
-      })
-    })
-  })
-
-  describe('fetchInfiniteQuery', () => {
-    test('should properly unwrap parameter', async () => {
-      const queryClient = new QueryClient()
-
-      queryClient.fetchInfiniteQuery({
-        queryKey: queryKeyRef,
-        initialPageParam: 0,
-      })
-
-      expect(QueryClientOrigin.prototype.fetchInfiniteQuery).toBeCalledWith({
-        initialPageParam: 0,
-        queryKey: queryKeyUnref,
-      })
-    })
-    test('should properly unwrap parameter using infiniteQueryOptions with unref', async () => {
-      const queryClient = new QueryClient()
-
-      const options = infiniteQueryOptions({
-        queryKey: queryKeyUnref,
-        initialPageParam: 0,
-        getNextPageParam: () => 12,
-      })
-
-      queryClient.fetchInfiniteQuery(options)
-
-      expect(QueryClientOrigin.prototype.fetchInfiniteQuery).toBeCalledWith({
-        initialPageParam: 0,
-        queryKey: queryKeyUnref,
-      })
-    })
-  })
-
-  describe('prefetchInfiniteQuery', () => {
-    test('should properly unwrap parameters', async () => {
-      const queryClient = new QueryClient()
-
-      queryClient.prefetchInfiniteQuery({
-        queryKey: queryKeyRef,
-        queryFn: fn,
-        initialPageParam: 0,
-      })
-
-      expect(QueryClientOrigin.prototype.prefetchInfiniteQuery).toBeCalledWith({
-        initialPageParam: 0,
-        queryKey: queryKeyUnref,
-        queryFn: fn,
-      })
-    })
-  })
-
-  describe('setDefaultOptions', () => {
-    test('should properly unwrap parameters', async () => {
-      const queryClient = new QueryClient()
-
-      queryClient.setDefaultOptions({
-        queries: {
-          enabled: ref(false),
-        },
-      })
-
-      expect(QueryClientOrigin.prototype.setDefaultOptions).toBeCalledWith({
-        queries: {
-          enabled: false,
-        },
-      })
-    })
-  })
-
-  describe('setQueryDefaults', () => {
-    test('should properly unwrap parameters', async () => {
-      const queryClient = new QueryClient()
-
-      queryClient.setQueryDefaults(queryKeyRef, {
-        enabled: ref(false),
-      })
-
-      expect(QueryClientOrigin.prototype.setQueryDefaults).toBeCalledWith(
-        queryKeyUnref,
-        {
-          enabled: false,
-        },
-      )
-    })
-  })
-
-  describe('getQueryDefaults', () => {
-    test('should properly unwrap parameters', async () => {
-      const queryClient = new QueryClient()
-
-      queryClient.getQueryDefaults(queryKeyRef)
-
-      expect(QueryClientOrigin.prototype.getQueryDefaults).toBeCalledWith(
-        queryKeyUnref,
-      )
-    })
-  })
-
-  describe('setMutationDefaults', () => {
-    test('should properly unwrap parameters', async () => {
-      const queryClient = new QueryClient()
-
-      queryClient.setMutationDefaults(queryKeyRef, {
-        mutationKey: queryKeyRef,
-      })
-
-      expect(QueryClientOrigin.prototype.setMutationDefaults).toBeCalledWith(
-        queryKeyUnref,
-        {
-          mutationKey: queryKeyUnref,
-        },
-      )
-    })
-  })
-
-  describe('getMutationDefaults', () => {
-    test('should properly unwrap parameters', async () => {
-      const queryClient = new QueryClient()
-
-      queryClient.getMutationDefaults(queryKeyRef)
-
-      expect(QueryClientOrigin.prototype.getMutationDefaults).toBeCalledWith(
-        queryKeyUnref,
-      )
-    })
-  })
-})

package/src/__tests__/queryOptions.test-d.ts

@@ -1,125 +0,0 @@
-import { describe, expectTypeOf, it } from 'vitest'
-import { reactive, ref } from 'vue-demi'
-import { dataTagSymbol } from '@tanstack/query-core'
-import { QueryClient } from '../queryClient'
-import { queryOptions } from '../queryOptions'
-import { useQuery } from '../useQuery'
-
-describe('queryOptions', () => {
-  it('should not allow excess properties', () => {
-    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', () => {
-    queryOptions({
-      queryKey: ['key'],
-      queryFn: () => Promise.resolve(5),
-      staleTime: 1000,
-      select: (data) => {
-        expectTypeOf(data).toEqualTypeOf<number>()
-      },
-    })
-  })
-  it('should work when passed to useQuery', () => {
-    const options = queryOptions({
-      queryKey: ['key'],
-      queryFn: () => Promise.resolve(5),
-    })
-
-    const { data } = reactive(useQuery(options))
-    expectTypeOf(data).toEqualTypeOf<number | undefined>()
-  })
-  it('should tag the queryKey with the result type of the QueryFn', () => {
-    const { queryKey } = queryOptions({
-      queryKey: ['key'],
-      queryFn: () => Promise.resolve(5),
-    })
-
-    expectTypeOf(queryKey[dataTagSymbol]).toEqualTypeOf<number>()
-  })
-  it('should tag the queryKey even if no promise is returned', () => {
-    const { queryKey } = queryOptions({
-      queryKey: ['key'],
-      queryFn: () => 5,
-    })
-
-    expectTypeOf(queryKey[dataTagSymbol]).toEqualTypeOf<number>()
-  })
-  it('should tag the queryKey with unknown if there is no queryFn', () => {
-    const { queryKey } = queryOptions({
-      queryKey: ['key'],
-    })
-
-    expectTypeOf(queryKey[dataTagSymbol]).toEqualTypeOf<unknown>()
-  })
-  it('should tag the queryKey with the result type of the QueryFn if select is used', () => {
-    const { queryKey } = queryOptions({
-      queryKey: ['key'],
-      queryFn: () => Promise.resolve(5),
-      select: (data) => data.toString(),
-    })
-
-    expectTypeOf(queryKey[dataTagSymbol]).toEqualTypeOf<number>()
-  })
-  it('should return the proper type when passed to getQueryData', () => {
-    const { queryKey } = queryOptions({
-      queryKey: ['key'],
-      queryFn: () => Promise.resolve(5),
-    })
-
-    const queryClient = new QueryClient()
-    const data = queryClient.getQueryData(queryKey)
-
-    expectTypeOf(data).toEqualTypeOf<number | undefined>()
-  })
-  it('should properly type updaterFn when passed to setQueryData', () => {
-    const { queryKey } = queryOptions({
-      queryKey: ['key'],
-      queryFn: () => Promise.resolve(5),
-    })
-
-    const queryClient = new QueryClient()
-    const data = queryClient.setQueryData(queryKey, (prev) => {
-      expectTypeOf(prev).toEqualTypeOf<number | undefined>()
-      return prev
-    })
-    expectTypeOf(data).toEqualTypeOf<number | undefined>()
-  })
-  it('should properly type value when passed to setQueryData', () => {
-    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)
-
-    expectTypeOf(data).toEqualTypeOf<number | undefined>()
-  })
-  it('should allow to be passed to QueryClient methods while containing ref in queryKey', () => {
-    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)
-
-    expectTypeOf(data).toEqualTypeOf<Promise<void>>()
-    expectTypeOf(data2).toEqualTypeOf<Promise<number>>()
-  })
-})

package/src/__tests__/test-utils.ts

@@ -1,52 +0,0 @@
-/* istanbul ignore file */
-
-export function flushPromises(timeout = 0): Promise<unknown> {
-  return new Promise(function (resolve) {
-    setTimeout(resolve, timeout)
-  })
-}
-
-export function simpleFetcher(): Promise<string> {
-  return new Promise((resolve) => {
-    setTimeout(() => {
-      return resolve('Some data')
-    }, 0)
-  })
-}
-
-export function getSimpleFetcherWithReturnData(returnData: unknown) {
-  return () =>
-    new Promise((resolve) => setTimeout(() => resolve(returnData), 0))
-}
-
-export function infiniteFetcher({
-  pageParam,
-}: {
-  pageParam?: number
-}): Promise<string> {
-  return new Promise((resolve) => {
-    setTimeout(() => {
-      return resolve('data on page ' + pageParam)
-    }, 0)
-  })
-}
-
-export function rejectFetcher(): Promise<Error> {
-  return new Promise((_, reject) => {
-    setTimeout(() => {
-      return reject(new Error('Some error'))
-    }, 0)
-  })
-}
-
-export function successMutator<T>(param: T): Promise<T> {
-  return new Promise((resolve) => {
-    setTimeout(() => {
-      return resolve(param)
-    }, 0)
-  })
-}
-
-export function errorMutator<T>(_: T): Promise<Error> {
-  return rejectFetcher()
-}

package/src/__tests__/useInfiniteQuery.test-d.tsx

@@ -1,84 +0,0 @@
-import { describe, expectTypeOf, it } from 'vitest'
-import { reactive } from 'vue-demi'
-import { useInfiniteQuery } from '../useInfiniteQuery'
-import { simpleFetcher } from './test-utils'
-import type { InfiniteData } from '@tanstack/query-core'
-
-describe('Discriminated union return type', () => {
-  it('data should be possibly undefined by default', () => {
-    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
-    expectTypeOf(query.data).toEqualTypeOf<
-      InfiniteData<string, unknown> | undefined
-    >()
-  })
-
-  it('data should be defined when query is success', () => {
-    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
-      expectTypeOf(query.data).toEqualTypeOf<InfiniteData<string, unknown>>()
-    }
-  })
-
-  it('error should be null when query is success', () => {
-    const query = reactive(
-      useInfiniteQuery({
-        queryKey: ['infiniteQuery'],
-        queryFn: simpleFetcher,
-        getNextPageParam: () => undefined,
-        initialPageParam: 0,
-      }),
-    )
-
-    if (query.isSuccess) {
-      expectTypeOf(query.error).toEqualTypeOf<null>()
-    }
-  })
-
-  it('data should be undefined when query is pending', () => {
-    const query = reactive(
-      useInfiniteQuery({
-        queryKey: ['infiniteQuery'],
-        queryFn: simpleFetcher,
-        getNextPageParam: () => undefined,
-        initialPageParam: 0,
-      }),
-    )
-
-    if (query.isPending) {
-      expectTypeOf(query.data).toEqualTypeOf<undefined>()
-    }
-  })
-
-  it('error should be defined when query is error', () => {
-    const query = reactive(
-      useInfiniteQuery({
-        queryKey: ['infiniteQuery'],
-        queryFn: simpleFetcher,
-        getNextPageParam: () => undefined,
-        initialPageParam: 0,
-      }),
-    )
-
-    if (query.isError) {
-      expectTypeOf(query.error).toEqualTypeOf<Error>()
-    }
-  })
-})