@tanstack/vue-query 5.59.17 → 5.59.20

package/src/__tests__/useQuery.test.ts

@@ -1,497 +0,0 @@
-import { describe, expect, test, vi } from 'vitest'
-import {
-  computed,
-  getCurrentInstance,
-  onScopeDispose,
-  reactive,
-  ref,
-} from 'vue-demi'
-import { QueryObserver } from '@tanstack/query-core'
-import { useQuery } from '../useQuery'
-import { useBaseQuery } from '../useBaseQuery'
-import {
-  flushPromises,
-  getSimpleFetcherWithReturnData,
-  rejectFetcher,
-  simpleFetcher,
-} from './test-utils'
-import type { Mock, MockedFunction } from 'vitest'
-
-vi.mock('../useQueryClient')
-vi.mock('../useBaseQuery')
-
-describe('useQuery', () => {
-  test('should properly execute query', () => {
-    useQuery({ queryKey: ['key0'], queryFn: simpleFetcher, staleTime: 1000 })
-
-    expect(useBaseQuery).toBeCalledWith(
-      QueryObserver,
-      {
-        queryKey: ['key0'],
-        queryFn: simpleFetcher,
-        staleTime: 1000,
-      },
-      undefined,
-    )
-  })
-
-  test('should return pending status initially', () => {
-    const query = useQuery({ queryKey: ['key1'], queryFn: simpleFetcher })
-
-    expect(query).toMatchObject({
-      status: { value: 'pending' },
-      isPending: { value: true },
-      isFetching: { value: true },
-      isStale: { value: true },
-    })
-  })
-
-  test('should resolve to success and update reactive state: useQuery(key, dataFn)', async () => {
-    const query = useQuery({
-      queryKey: ['key2'],
-      queryFn: getSimpleFetcherWithReturnData('result2'),
-    })
-
-    await flushPromises()
-
-    expect(query).toMatchObject({
-      status: { value: 'success' },
-      data: { value: 'result2' },
-      isPending: { value: false },
-      isFetching: { value: false },
-      isFetched: { value: true },
-      isSuccess: { value: true },
-    })
-  })
-
-  test('should resolve to success and update reactive state: useQuery(optionsObj)', async () => {
-    const query = useQuery({
-      queryKey: ['key31'],
-      queryFn: getSimpleFetcherWithReturnData('result31'),
-      enabled: true,
-    })
-
-    await flushPromises()
-
-    expect(query).toMatchObject({
-      status: { value: 'success' },
-      data: { value: 'result31' },
-      isPending: { value: false },
-      isFetching: { value: false },
-      isFetched: { value: true },
-      isSuccess: { value: true },
-    })
-  })
-
-  test('should resolve to success and update reactive state: useQuery(key, optionsObj)', async () => {
-    const query = useQuery({
-      queryKey: ['key32'],
-      queryFn: getSimpleFetcherWithReturnData('result32'),
-      enabled: true,
-    })
-
-    await flushPromises()
-
-    expect(query).toMatchObject({
-      status: { value: 'success' },
-      data: { value: 'result32' },
-      isPending: { value: false },
-      isFetching: { value: false },
-      isFetched: { value: true },
-      isSuccess: { value: true },
-    })
-  })
-
-  test('should reject and update reactive state', async () => {
-    const query = useQuery({
-      queryKey: ['key3'],
-      queryFn: rejectFetcher,
-    })
-
-    await flushPromises()
-
-    expect(query).toMatchObject({
-      status: { value: 'error' },
-      data: { value: undefined },
-      error: { value: { message: 'Some error' } },
-      isPending: { value: false },
-      isFetching: { value: false },
-      isFetched: { value: true },
-      isError: { value: true },
-      failureCount: { value: 1 },
-      failureReason: { value: { message: 'Some error' } },
-    })
-  })
-
-  test('should update query on reactive (Ref) key change', async () => {
-    const secondKeyRef = ref('key7')
-    const query = useQuery({
-      queryKey: ['key6', secondKeyRef],
-      queryFn: simpleFetcher,
-    })
-
-    await flushPromises()
-
-    expect(query).toMatchObject({
-      status: { value: 'success' },
-    })
-
-    secondKeyRef.value = 'key8'
-    await flushPromises()
-
-    expect(query).toMatchObject({
-      status: { value: 'pending' },
-      data: { value: undefined },
-    })
-
-    await flushPromises()
-
-    expect(query).toMatchObject({
-      status: { value: 'success' },
-    })
-  })
-
-  test("should update query when an option is passed as Ref and it's changed", async () => {
-    const enabled = ref(false)
-    const query = useQuery({
-      queryKey: ['key9'],
-      queryFn: simpleFetcher,
-      enabled,
-    })
-
-    await flushPromises()
-
-    expect(query).toMatchObject({
-      fetchStatus: { value: 'idle' },
-      data: { value: undefined },
-    })
-
-    enabled.value = true
-
-    await flushPromises()
-
-    expect(query).toMatchObject({
-      fetchStatus: { value: 'fetching' },
-      data: { value: undefined },
-    })
-
-    await flushPromises()
-
-    expect(query).toMatchObject({
-      status: { value: 'success' },
-    })
-  })
-
-  test('should properly execute dependant queries', async () => {
-    const { data } = useQuery({
-      queryKey: ['dependant1'],
-      queryFn: simpleFetcher,
-    })
-
-    const enabled = computed(() => !!data.value)
-
-    const dependentQueryFn = vi.fn().mockImplementation(simpleFetcher)
-    const { fetchStatus, status } = useQuery(
-      reactive({
-        queryKey: ['dependant2'],
-        queryFn: dependentQueryFn,
-        enabled,
-      }),
-    )
-
-    expect(data.value).toStrictEqual(undefined)
-    expect(fetchStatus.value).toStrictEqual('idle')
-    expect(dependentQueryFn).not.toHaveBeenCalled()
-
-    await flushPromises()
-
-    expect(data.value).toStrictEqual('Some data')
-    expect(fetchStatus.value).toStrictEqual('fetching')
-
-    await flushPromises()
-
-    expect(fetchStatus.value).toStrictEqual('idle')
-    expect(status.value).toStrictEqual('success')
-    expect(dependentQueryFn).toHaveBeenCalledTimes(1)
-    expect(dependentQueryFn).toHaveBeenCalledWith(
-      expect.objectContaining({ queryKey: ['dependant2'] }),
-    )
-  })
-
-  test('should stop listening to changes on onScopeDispose', async () => {
-    const onScopeDisposeMock = onScopeDispose as MockedFunction<
-      typeof onScopeDispose
-    >
-    onScopeDisposeMock.mockImplementationOnce((fn) => fn())
-
-    const { status } = useQuery({
-      queryKey: ['onScopeDispose'],
-      queryFn: simpleFetcher,
-    })
-
-    expect(status.value).toStrictEqual('pending')
-
-    await flushPromises()
-
-    expect(status.value).toStrictEqual('pending')
-
-    await flushPromises()
-
-    expect(status.value).toStrictEqual('pending')
-  })
-
-  test('should use the current value for the queryKey when refetch is called', async () => {
-    const fetchFn = vi.fn()
-    const keyRef = ref('key11')
-    const query = useQuery({
-      queryKey: ['key10', keyRef],
-      queryFn: fetchFn,
-      enabled: false,
-    })
-
-    expect(fetchFn).not.toHaveBeenCalled()
-    await query.refetch()
-    expect(fetchFn).toHaveBeenCalledTimes(1)
-    expect(fetchFn).toHaveBeenCalledWith(
-      expect.objectContaining({
-        queryKey: ['key10', 'key11'],
-      }),
-    )
-
-    keyRef.value = 'key12'
-    await query.refetch()
-    expect(fetchFn).toHaveBeenCalledTimes(2)
-    expect(fetchFn).toHaveBeenCalledWith(
-      expect.objectContaining({
-        queryKey: ['key10', 'key12'],
-      }),
-    )
-  })
-
-  test('should be `enabled` to accept getter function', async () => {
-    const fetchFn = vi.fn()
-    const checked = ref(false)
-
-    useQuery({
-      queryKey: ['enabled'],
-      queryFn: fetchFn,
-      enabled: () => checked.value,
-    })
-
-    expect(fetchFn).not.toHaveBeenCalled()
-
-    checked.value = true
-
-    await flushPromises()
-
-    expect(fetchFn).toHaveBeenCalled()
-  })
-
-  test('should allow getters for query keys', async () => {
-    const fetchFn = vi.fn()
-    const key1 = ref('key1')
-    const key2 = ref('key2')
-
-    useQuery({
-      queryKey: ['key', () => key1.value, () => key2.value],
-      queryFn: fetchFn,
-    })
-
-    expect(fetchFn).toHaveBeenCalledTimes(1)
-
-    key1.value = 'key3'
-
-    await flushPromises()
-
-    expect(fetchFn).toHaveBeenCalledTimes(2)
-
-    key2.value = 'key4'
-
-    await flushPromises()
-
-    expect(fetchFn).toHaveBeenCalledTimes(3)
-  })
-
-  test('should allow arbitrarily nested getters for query keys', async () => {
-    const fetchFn = vi.fn()
-    const key1 = ref('key1')
-    const key2 = ref('key2')
-    const key3 = ref('key3')
-    const key4 = ref('key4')
-    const key5 = ref('key5')
-
-    useQuery({
-      queryKey: [
-        'key',
-        key1,
-        () => key2.value,
-        { key: () => key3.value },
-        [{ foo: { bar: () => key4.value } }],
-        () => ({
-          foo: {
-            bar: {
-              baz: () => key5.value,
-            },
-          },
-        }),
-      ],
-      queryFn: fetchFn,
-    })
-
-    expect(fetchFn).toHaveBeenCalledTimes(1)
-
-    key1.value = 'key1-updated'
-
-    await flushPromises()
-
-    expect(fetchFn).toHaveBeenCalledTimes(2)
-
-    key2.value = 'key2-updated'
-
-    await flushPromises()
-
-    expect(fetchFn).toHaveBeenCalledTimes(3)
-
-    key3.value = 'key3-updated'
-
-    await flushPromises()
-
-    expect(fetchFn).toHaveBeenCalledTimes(4)
-
-    key4.value = 'key4-updated'
-
-    await flushPromises()
-
-    expect(fetchFn).toHaveBeenCalledTimes(5)
-
-    key5.value = 'key5-updated'
-
-    await flushPromises()
-
-    expect(fetchFn).toHaveBeenCalledTimes(6)
-  })
-
-  describe('throwOnError', () => {
-    test('should evaluate throwOnError when query is expected to throw', async () => {
-      const boundaryFn = vi.fn()
-      useQuery({
-        queryKey: ['key0'],
-        queryFn: rejectFetcher,
-        retry: false,
-        throwOnError: boundaryFn,
-      })
-
-      await flushPromises()
-
-      expect(boundaryFn).toHaveBeenCalledTimes(1)
-      expect(boundaryFn).toHaveBeenCalledWith(
-        Error('Some error'),
-        expect.objectContaining({
-          state: expect.objectContaining({ status: 'error' }),
-        }),
-      )
-    })
-  })
-
-  describe('suspense', () => {
-    test('should return a Promise', () => {
-      const getCurrentInstanceSpy = getCurrentInstance as Mock
-      getCurrentInstanceSpy.mockImplementation(() => ({ suspense: {} }))
-
-      const query = useQuery({ queryKey: ['suspense'], queryFn: simpleFetcher })
-      const result = query.suspense()
-
-      expect(result).toBeInstanceOf(Promise)
-    })
-
-    test('should resolve after being enabled', () => {
-      const getCurrentInstanceSpy = getCurrentInstance as Mock
-      getCurrentInstanceSpy.mockImplementation(() => ({ suspense: {} }))
-
-      let afterTimeout = false
-      const isEnabled = ref(false)
-      const query = useQuery({
-        queryKey: ['suspense2'],
-        queryFn: simpleFetcher,
-        enabled: isEnabled,
-      })
-
-      setTimeout(() => {
-        afterTimeout = true
-        isEnabled.value = true
-      }, 200)
-
-      return query.suspense().then(() => {
-        expect(afterTimeout).toBe(true)
-      })
-    })
-
-    test('should resolve immediately when stale without refetching', () => {
-      const getCurrentInstanceSpy = getCurrentInstance as Mock
-      getCurrentInstanceSpy.mockImplementation(() => ({ suspense: {} }))
-
-      const fetcherSpy = vi.fn(() => simpleFetcher())
-
-      // let afterTimeout = false;
-      const query = useQuery({
-        queryKey: ['suspense3'],
-        queryFn: simpleFetcher,
-        staleTime: 10000,
-        initialData: 'foo',
-      })
-
-      return query.suspense().then(() => {
-        expect(fetcherSpy).toHaveBeenCalledTimes(0)
-      })
-    })
-
-    test('should not throw from suspense by default', async () => {
-      const getCurrentInstanceSpy = getCurrentInstance as Mock
-      getCurrentInstanceSpy.mockImplementation(() => ({ suspense: {} }))
-
-      const query = useQuery({
-        queryKey: ['suspense4'],
-        queryFn: rejectFetcher,
-        staleTime: 10000,
-      })
-
-      await flushPromises()
-
-      expect(query).toMatchObject({
-        status: { value: 'error' },
-        isError: { value: true },
-      })
-    })
-
-    test('should throw from suspense when throwOnError is true', async () => {
-      const getCurrentInstanceSpy = getCurrentInstance as Mock
-      getCurrentInstanceSpy.mockImplementation(() => ({ suspense: {} }))
-
-      const boundaryFn = vi.fn()
-      const query = useQuery({
-        queryKey: ['suspense5'],
-        queryFn: rejectFetcher,
-        staleTime: 10000,
-        throwOnError: boundaryFn,
-      })
-
-      await query.suspense()
-
-      expect(boundaryFn).toHaveBeenCalledTimes(2)
-      expect(boundaryFn).toHaveBeenNthCalledWith(
-        1,
-        Error('Some error'),
-        expect.objectContaining({
-          state: expect.objectContaining({ status: 'error' }),
-        }),
-      )
-      expect(boundaryFn).toHaveBeenNthCalledWith(
-        2,
-        Error('Some error'),
-        expect.objectContaining({
-          state: expect.objectContaining({ status: 'error' }),
-        }),
-      )
-    })
-  })
-})

package/src/__tests__/useQueryClient.test.ts

@@ -1,51 +0,0 @@
-import { beforeEach, describe, expect, test, vi } from 'vitest'
-import { hasInjectionContext, inject } from 'vue-demi'
-import { useQueryClient } from '../useQueryClient'
-import { VUE_QUERY_CLIENT } from '../utils'
-import type { Mock } from 'vitest'
-
-describe('useQueryClient', () => {
-  const injectSpy = inject as Mock
-  const hasInjectionContextSpy = hasInjectionContext as Mock
-
-  beforeEach(() => {
-    vi.restoreAllMocks()
-  })
-
-  test('should return queryClient when it is provided in the context', () => {
-    const queryClientMock = { name: 'Mocked client' }
-    injectSpy.mockReturnValueOnce(queryClientMock)
-
-    const queryClient = useQueryClient()
-
-    expect(queryClient).toStrictEqual(queryClientMock)
-    expect(injectSpy).toHaveBeenCalledTimes(1)
-    expect(injectSpy).toHaveBeenCalledWith(VUE_QUERY_CLIENT)
-  })
-
-  test('should throw an error when queryClient does not exist in the context', () => {
-    injectSpy.mockReturnValueOnce(undefined)
-
-    expect(useQueryClient).toThrowError()
-    expect(injectSpy).toHaveBeenCalledTimes(1)
-    expect(injectSpy).toHaveBeenCalledWith(VUE_QUERY_CLIENT)
-  })
-
-  test('should throw an error when used outside of setup function', () => {
-    hasInjectionContextSpy.mockReturnValueOnce(false)
-
-    expect(useQueryClient).toThrowError()
-    expect(hasInjectionContextSpy).toHaveBeenCalledTimes(1)
-  })
-
-  test('should call inject with a custom key as a suffix', () => {
-    const queryClientKey = 'foo'
-    const expectedKeyParameter = `${VUE_QUERY_CLIENT}:${queryClientKey}`
-    const queryClientMock = { name: 'Mocked client' }
-    injectSpy.mockReturnValueOnce(queryClientMock)
-
-    useQueryClient(queryClientKey)
-
-    expect(injectSpy).toHaveBeenCalledWith(expectedKeyParameter)
-  })
-})

package/src/__tests__/utils.test.ts

@@ -1,155 +0,0 @@
-import { describe, expect, test } from 'vitest'
-import { reactive, ref } from 'vue-demi'
-import { cloneDeep, cloneDeepUnref, updateState } from '../utils'
-
-describe('utils', () => {
-  describe('updateState', () => {
-    test('should update first object with values from the second one', () => {
-      const origin = { option1: 'a', option2: 'b', option3: 'c' }
-      const update = { option1: 'x', option2: 'y', option3: 'z' }
-      const expected = { option1: 'x', option2: 'y', option3: 'z' }
-
-      updateState(origin, update)
-      expect(origin).toEqual(expected)
-    })
-
-    test('should update only existing keys', () => {
-      const origin = { option1: 'a', option2: 'b' }
-      const update = { option1: 'x', option2: 'y', option3: 'z' }
-      const expected = { option1: 'x', option2: 'y' }
-
-      updateState(origin, update)
-      expect(origin).toEqual(expected)
-    })
-
-    test('should remove non existing keys', () => {
-      const origin = { option1: 'a', option2: 'b', option3: 'c' }
-      const update = { option1: 'x', option2: 'y' }
-      const expected = { option1: 'x', option2: 'y' }
-
-      updateState(origin, update)
-      expect(origin).toEqual(expected)
-    })
-  })
-
-  describe('cloneDeep', () => {
-    test('should copy primitives and functions AS-IS', () => {
-      expect(cloneDeep(3456)).toBe(3456)
-      expect(cloneDeep('theString')).toBe('theString')
-      expect(cloneDeep(null)).toBe(null)
-    })
-
-    test('should copy Maps and Sets AS-IS', () => {
-      const setVal = new Set([3, 4, 5])
-      const setValCopy = cloneDeep(setVal)
-      expect(setValCopy).toBe(setVal)
-      expect(setValCopy).toStrictEqual(new Set([3, 4, 5]))
-
-      const mapVal = new Map([
-        ['a', 'aVal'],
-        ['b', 'bVal'],
-      ])
-      const mapValCopy = cloneDeep(mapVal)
-      expect(mapValCopy).toBe(mapVal)
-      expect(mapValCopy).toStrictEqual(
-        new Map([
-          ['a', 'aVal'],
-          ['b', 'bVal'],
-        ]),
-      )
-    })
-
-    test('should deeply copy arrays', () => {
-      const val = [
-        25,
-        'str',
-        null,
-        new Set([3, 4]),
-        [5, 6, { a: 1 }],
-        undefined,
-      ]
-      const cp = cloneDeep(val)
-      expect(cp).toStrictEqual([
-        25,
-        'str',
-        null,
-        new Set([3, 4]),
-        [5, 6, { a: 1 }],
-        undefined,
-      ])
-      expect(cp).not.toBe(val)
-      expect(cp[3]).toBe(val[3]) // Set([3, 4])
-      expect(cp[4]).not.toBe(val[4]) // [5, 6, { a: 1 }]
-      expect((cp[4] as Array<number>)[2]).not.toBe((val[4] as Array<number>)[2]) // { a : 1 }
-    })
-
-    test('should deeply copy object', () => {
-      const val = reactive({
-        a: 25,
-        b: 'str',
-        c: null,
-        d: undefined,
-        e: new Set([5, 6]),
-        f: [3, 4],
-        g: { fa: 26 },
-      })
-      const cp = cloneDeep(val)
-
-      expect(cp).toStrictEqual({
-        a: 25,
-        b: 'str',
-        c: null,
-        d: undefined,
-        e: new Set([5, 6]),
-        f: [3, 4],
-        g: { fa: 26 },
-      })
-
-      expect(cp.e).toBe(val.e) // Set
-      expect(cp.f).not.toBe(val.f) // []
-      expect(cp.g).not.toBe(val.g) // {}
-    })
-  })
-
-  describe('cloneDeepUnref', () => {
-    test('should unref primitives', () => {
-      expect(cloneDeepUnref(ref(34))).toBe(34)
-      expect(cloneDeepUnref(ref('myStr'))).toBe('myStr')
-    })
-
-    test('should deeply unref arrays', () => {
-      const val = ref([2, 3, ref(4), ref('5'), { a: ref(6) }, [ref(7)]])
-      const cp = cloneDeepUnref(val)
-      expect(cp).toStrictEqual([2, 3, 4, '5', { a: 6 }, [7]])
-    })
-
-    test('should deeply unref objects', () => {
-      const val = ref({
-        a: 1,
-        b: ref(2),
-        c: [ref('c1'), ref(['c2'])],
-        d: {
-          e: ref('e'),
-        },
-      })
-      const cp = cloneDeepUnref(val)
-
-      expect(cp).toEqual({
-        a: 1,
-        b: 2,
-        c: ['c1', ['c2']],
-        d: { e: 'e' },
-      })
-    })
-
-    test('should clone getters returning values in queryKey', () => {
-      const val = ref({ queryKey: [1, 2, () => '3'] })
-      const cp = cloneDeepUnref(val)
-      expect(cp).toStrictEqual({ queryKey: [1, 2, '3'] })
-    })
-
-    test('should unref undefined', () => {
-      expect(cloneDeepUnref(ref(undefined))).toBe(undefined)
-    })
-  })
-})