@tanstack/vue-query 5.59.17 → 5.59.20

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

@@ -1,222 +0,0 @@
-import { describe, expectTypeOf, it } from 'vitest'
-import { reactive } from 'vue'
-import { skipToken, useQueries } from '..'
-import { queryOptions } from '../queryOptions'
-import type { OmitKeyof, QueryObserverResult } from '..'
-import type { UseQueryOptions } from '../useQuery'
-
-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',
-    }
-
-    const { value: queriesState } = useQueries({
-      queries: [query1, query2, query3],
-    })
-
-    expectTypeOf(queriesState[0].data).toEqualTypeOf<{ wow: boolean }>()
-    expectTypeOf(queriesState[1].data).toEqualTypeOf<string>()
-    expectTypeOf(queriesState[2].data).toEqualTypeOf<string | undefined>()
-  })
-
-  it('TData should be defined when passed through queryOptions', () => {
-    const options = queryOptions({
-      queryKey: ['key'],
-      queryFn: () => {
-        return {
-          wow: true,
-        }
-      },
-      initialData: {
-        wow: true,
-      },
-    })
-
-    const { value: queriesState } = useQueries({ queries: [options] })
-
-    expectTypeOf(queriesState[0].data).toEqualTypeOf<{ wow: boolean }>()
-  })
-
-  it('should be possible to define a different TData than TQueryFnData using select with queryOptions spread into useQueries', () => {
-    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] }))
-
-    expectTypeOf(queriesState.value[0].data).toEqualTypeOf<
-      boolean | undefined
-    >()
-    expectTypeOf(queriesState.value[1].data).toEqualTypeOf<
-      boolean | undefined
-    >()
-  })
-
-  it('TData should have undefined in the union when initialData is provided as a function which can return undefined', () => {
-    const { value: queriesState } = useQueries({
-      queries: [
-        {
-          queryKey: ['key'],
-          queryFn: () => {
-            return {
-              wow: true,
-            }
-          },
-          initialData: () => undefined as { wow: boolean } | undefined,
-        },
-      ],
-    })
-
-    expectTypeOf(queriesState[0].data).toEqualTypeOf<
-      { wow: boolean } | undefined
-    >()
-  })
-
-  it('TData should have correct type when conditional skipToken is passed', () => {
-    const { value: queriesState } = useQueries({
-      queries: [
-        queryOptions({
-          queryKey: ['key'],
-          queryFn: Math.random() > 0.5 ? skipToken : () => Promise.resolve(5),
-        }),
-      ],
-    })
-
-    const firstResult = queriesState[0]
-
-    expectTypeOf(firstResult).toEqualTypeOf<
-      QueryObserverResult<number, Error>
-    >()
-    expectTypeOf(firstResult.data).toEqualTypeOf<number | undefined>()
-  })
-
-  describe('custom hook', () => {
-    it('should allow custom hooks using UseQueryOptions', () => {
-      const useCustomQueries = (
-        options?: OmitKeyof<
-          UseQueryOptions<string>,
-          'queryKey' | 'queryFn',
-          'safely'
-        >,
-      ) =>
-        useQueries({
-          queries: [
-            {
-              ...options,
-              queryKey: ['todos-key'],
-              queryFn: () => Promise.resolve('data'),
-            },
-          ],
-        })
-
-      const { value: queriesState } = useCustomQueries()
-
-      expectTypeOf(queriesState[0].data).toEqualTypeOf<string | undefined>()
-    })
-  })
-
-  // Fix #7270
-  it('should have proper type inference with different options provided', () => {
-    const numbers = [1, 2, 3]
-    const queryKey = (n: number) => [n]
-    const queryFn = (n: number) => () => Promise.resolve(n)
-    const select = (data: number) => data.toString()
-
-    const queries = numbers.map((n) => ({
-      queryKey: [n],
-      queryFn: () => Promise.resolve(n),
-      select: (data: number) => data.toString(),
-    }))
-
-    const queriesWithoutSelect = numbers.map((n) => ({
-      queryKey: queryKey(n),
-      queryFn: queryFn(n),
-    }))
-
-    const queriesWithQueryOptions = numbers.map((n) =>
-      queryOptions({
-        queryKey: queryKey(n),
-        queryFn: queryFn(n),
-        select,
-      }),
-    )
-
-    const queriesWithQueryOptionsWithoutSelect = numbers.map((n) =>
-      queryOptions({
-        queryKey: queryKey(n),
-        queryFn: queryFn(n),
-      }),
-    )
-
-    const query1 = useQueries({ queries: queries })
-    expectTypeOf(query1.value).toEqualTypeOf<
-      Array<QueryObserverResult<string, Error>>
-    >()
-
-    const query2 = useQueries({ queries: queriesWithoutSelect })
-    expectTypeOf(query2.value).toEqualTypeOf<
-      Array<QueryObserverResult<number, Error>>
-    >()
-
-    const query3 = useQueries({ queries: queriesWithQueryOptions })
-    expectTypeOf(query3.value).toEqualTypeOf<
-      Array<QueryObserverResult<string, Error>>
-    >()
-
-    const query4 = useQueries({ queries: queriesWithQueryOptionsWithoutSelect })
-    expectTypeOf(query4.value).toEqualTypeOf<
-      Array<QueryObserverResult<number, Error>>
-    >()
-
-    const queryCombine = useQueries({
-      queries: queries,
-      combine: (data) => {
-        return data.reduce((acc, i) => {
-          acc.push(i.data ?? '')
-          return acc
-        }, [] as Array<string>)
-      },
-    })
-    expectTypeOf(queryCombine.value).toEqualTypeOf<Array<string>>()
-
-    const queryCombineWithoutSelect = useQueries({
-      queries: queriesWithoutSelect,
-      combine: (data) => {
-        return data.reduce((acc, i) => {
-          acc.push(i.data ?? 0)
-          return acc
-        }, [] as Array<number>)
-      },
-    })
-
-    expectTypeOf(queryCombineWithoutSelect.value).toEqualTypeOf<Array<number>>()
-  })
-})

package/src/__tests__/useQueries.test.ts

@@ -1,370 +0,0 @@
-import { beforeEach, describe, expect, test, vi } from 'vitest'
-import { onScopeDispose, ref } from 'vue-demi'
-import { useQueries } from '../useQueries'
-import { useQueryClient } from '../useQueryClient'
-import { QueryClient } from '../queryClient'
-import {
-  flushPromises,
-  getSimpleFetcherWithReturnData,
-  rejectFetcher,
-  simpleFetcher,
-} from './test-utils'
-import type { MockedFunction } from 'vitest'
-
-vi.mock('../useQueryClient')
-
-describe('useQueries', () => {
-  beforeEach(() => {
-    vi.restoreAllMocks()
-  })
-
-  test('should return result for each query', () => {
-    const queries = [
-      {
-        queryKey: ['key1'],
-        queryFn: simpleFetcher,
-      },
-      {
-        queryKey: ['key2'],
-        queryFn: simpleFetcher,
-      },
-    ]
-    const queriesState = useQueries({ queries })
-
-    expect(queriesState.value).toMatchObject([
-      {
-        status: 'pending',
-        isPending: true,
-        isFetching: true,
-        isStale: true,
-      },
-      {
-        status: 'pending',
-        isPending: true,
-        isFetching: true,
-        isStale: true,
-      },
-    ])
-  })
-
-  test('should resolve to success and update reactive state', async () => {
-    const queries = [
-      {
-        queryKey: ['key11'],
-        queryFn: simpleFetcher,
-      },
-      {
-        queryKey: ['key12'],
-        queryFn: simpleFetcher,
-      },
-    ]
-    const queriesState = useQueries({ queries })
-
-    await flushPromises()
-
-    expect(queriesState.value).toMatchObject([
-      {
-        status: 'success',
-        isPending: false,
-        isFetching: false,
-        isStale: true,
-      },
-      {
-        status: 'success',
-        isPending: false,
-        isFetching: false,
-        isStale: true,
-      },
-    ])
-  })
-
-  test('should reject one of the queries and update reactive state', async () => {
-    const queries = [
-      {
-        queryKey: ['key21'],
-        queryFn: rejectFetcher,
-      },
-      {
-        queryKey: ['key22'],
-        queryFn: simpleFetcher,
-      },
-    ]
-    const queriesState = useQueries({ queries })
-
-    await flushPromises()
-
-    expect(queriesState.value).toMatchObject([
-      {
-        status: 'error',
-        isPending: false,
-        isFetching: false,
-        isStale: true,
-      },
-      {
-        status: 'success',
-        isPending: false,
-        isFetching: false,
-        isStale: true,
-      },
-    ])
-  })
-
-  test('should return state for new queries', async () => {
-    const queries = ref([
-      {
-        queryKey: ['key31'],
-        queryFn: getSimpleFetcherWithReturnData('value31'),
-      },
-      {
-        queryKey: ['key32'],
-        queryFn: getSimpleFetcherWithReturnData('value32'),
-      },
-      {
-        queryKey: ['key33'],
-        queryFn: getSimpleFetcherWithReturnData('value33'),
-      },
-    ])
-    const queriesState = useQueries({ queries })
-
-    await flushPromises()
-
-    queries.value.splice(
-      0,
-      queries.value.length,
-      {
-        queryKey: ['key31'],
-        queryFn: getSimpleFetcherWithReturnData('value31'),
-      },
-      {
-        queryKey: ['key34'],
-        queryFn: getSimpleFetcherWithReturnData('value34'),
-      },
-    )
-
-    await flushPromises()
-    await flushPromises()
-
-    expect(queriesState.value.length).toEqual(2)
-    expect(queriesState.value).toMatchObject([
-      {
-        data: 'value31',
-        status: 'success',
-        isPending: false,
-        isFetching: false,
-        isStale: true,
-      },
-      {
-        data: 'value34',
-        status: 'success',
-        isPending: false,
-        isFetching: false,
-        isStale: true,
-      },
-    ])
-  })
-
-  test('should stop listening to changes on onScopeDispose', async () => {
-    const onScopeDisposeMock = onScopeDispose as MockedFunction<
-      typeof onScopeDispose
-    >
-    onScopeDisposeMock.mockImplementationOnce((fn) => fn())
-
-    const queries = [
-      {
-        queryKey: ['key41'],
-        queryFn: simpleFetcher,
-      },
-      {
-        queryKey: ['key42'],
-        queryFn: simpleFetcher,
-      },
-    ]
-    const queriesState = useQueries({ queries })
-    await flushPromises()
-
-    expect(queriesState.value).toMatchObject([
-      {
-        status: 'pending',
-        isPending: true,
-        isFetching: true,
-        isStale: true,
-      },
-      {
-        status: 'pending',
-        isPending: true,
-        isFetching: true,
-        isStale: true,
-      },
-    ])
-  })
-
-  test('should use queryClient provided via options', async () => {
-    const queryClient = new QueryClient()
-    const queries = [
-      {
-        queryKey: ['key41'],
-        queryFn: simpleFetcher,
-      },
-      {
-        queryKey: ['key42'],
-        queryFn: simpleFetcher,
-      },
-    ]
-
-    useQueries({ queries }, queryClient)
-    await flushPromises()
-
-    expect(useQueryClient).toHaveBeenCalledTimes(0)
-  })
-
-  test('should combine queries', async () => {
-    const firstResult = 'first result'
-    const secondResult = 'second result'
-
-    const queryClient = new QueryClient()
-    const queries = [
-      {
-        queryKey: ['key41'],
-        queryFn: getSimpleFetcherWithReturnData(firstResult),
-      },
-      {
-        queryKey: ['key42'],
-        queryFn: getSimpleFetcherWithReturnData(secondResult),
-      },
-    ]
-
-    const queriesResult = useQueries(
-      {
-        queries,
-        combine: (results) => {
-          return {
-            combined: true,
-            res: results.map((res) => res.data),
-          }
-        },
-      },
-      queryClient,
-    )
-    await flushPromises()
-
-    expect(queriesResult.value).toMatchObject({
-      combined: true,
-      res: [firstResult, secondResult],
-    })
-  })
-
-  test('should be `enabled` to accept getter function', async () => {
-    const fetchFn = vi.fn()
-    const checked = ref(false)
-
-    useQueries({
-      queries: [
-        {
-          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')
-
-    useQueries({
-      queries: [
-        {
-          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')
-
-    useQueries({
-      queries: [
-        {
-          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)
-  })
-})