@tanstack/vue-query 5.59.17 → 5.59.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/vue-query",
-  "version": "5.59.17",
+  "version": "5.59.20",
   "description": "Hooks for managing, caching and syncing asynchronous and remote data in Vue",
   "author": "Damian Osipiuk",
   "license": "MIT",
@@ -34,7 +34,8 @@
   "sideEffects": false,
   "files": [
     "build",
-    "src"
+    "src",
+    "!src/__tests__"
   ],
   "nx": {
     "targets": {
@@ -49,7 +50,7 @@
     "@tanstack/match-sorter-utils": "^8.15.1",
     "@vue/devtools-api": "^6.6.3",
     "vue-demi": "^0.14.10",
-    "@tanstack/query-core": "5.59.17"
+    "@tanstack/query-core": "5.59.20"
   },
   "devDependencies": {
     "@vitejs/plugin-vue": "^5.1.1",

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

@@ -1,111 +0,0 @@
-import { describe, expectTypeOf, it } from 'vitest'
-import { QueryClient, dataTagSymbol } from '@tanstack/query-core'
-import { reactive } from 'vue-demi'
-import { infiniteQueryOptions } from '../infiniteQueryOptions'
-import { useInfiniteQuery } from '../useInfiniteQuery'
-import type { InfiniteData } from '@tanstack/query-core'
-
-describe('infiniteQueryOptions', () => {
-  it('should not allow excess properties', () => {
-    infiniteQueryOptions({
-      queryKey: ['key'],
-      queryFn: () => Promise.resolve('data'),
-      getNextPageParam: () => 1,
-      initialPageParam: 1,
-      // @ts-expect-error this is a good error, because stallTime does not exist!
-      stallTime: 1000,
-    })
-  })
-  it('should infer types for callbacks', () => {
-    infiniteQueryOptions({
-      queryKey: ['key'],
-      queryFn: () => Promise.resolve('data'),
-      staleTime: 1000,
-      getNextPageParam: () => 1,
-      initialPageParam: 1,
-      select: (data) => {
-        expectTypeOf(data).toEqualTypeOf<InfiniteData<string, number>>()
-      },
-    })
-  })
-  it('should work when passed to useInfiniteQuery', () => {
-    const options = infiniteQueryOptions({
-      queryKey: ['key'],
-      queryFn: () => Promise.resolve('string'),
-      getNextPageParam: () => 1,
-      initialPageParam: 1,
-    })
-
-    const { data } = reactive(useInfiniteQuery(options))
-
-    expectTypeOf(data).toEqualTypeOf<
-      InfiniteData<string, unknown> | undefined
-    >()
-  })
-  it('should tag the queryKey with the result type of the QueryFn', () => {
-    const { queryKey } = infiniteQueryOptions({
-      queryKey: ['key'],
-      queryFn: () => Promise.resolve('string'),
-      getNextPageParam: () => 1,
-      initialPageParam: 1,
-    })
-
-    expectTypeOf(queryKey[dataTagSymbol]).toEqualTypeOf<InfiniteData<string>>()
-  })
-  it('should tag the queryKey even if no promise is returned', () => {
-    const { queryKey } = infiniteQueryOptions({
-      queryKey: ['key'],
-      queryFn: () => 'string',
-      getNextPageParam: () => 1,
-      initialPageParam: 1,
-    })
-
-    expectTypeOf(queryKey[dataTagSymbol]).toEqualTypeOf<InfiniteData<string>>()
-  })
-  it('should tag the queryKey with the result type of the QueryFn if select is used', () => {
-    const { queryKey } = infiniteQueryOptions({
-      queryKey: ['key'],
-      queryFn: () => Promise.resolve('string'),
-      select: (data) => data.pages,
-      getNextPageParam: () => 1,
-      initialPageParam: 1,
-    })
-
-    expectTypeOf(queryKey[dataTagSymbol]).toEqualTypeOf<InfiniteData<string>>()
-  })
-  it('should return the proper type when passed to getQueryData', () => {
-    const { queryKey } = infiniteQueryOptions({
-      queryKey: ['key'],
-      queryFn: () => Promise.resolve('string'),
-      getNextPageParam: () => 1,
-      initialPageParam: 1,
-    })
-
-    const queryClient = new QueryClient()
-    const data = queryClient.getQueryData(queryKey)
-
-    expectTypeOf(data).toEqualTypeOf<
-      InfiniteData<string, unknown> | undefined
-    >()
-  })
-  it('should properly type when passed to setQueryData', () => {
-    const { queryKey } = infiniteQueryOptions({
-      queryKey: ['key'],
-      queryFn: () => Promise.resolve('string'),
-      getNextPageParam: () => 1,
-      initialPageParam: 1,
-    })
-
-    const queryClient = new QueryClient()
-    const data = queryClient.setQueryData(queryKey, (prev) => {
-      expectTypeOf(prev).toEqualTypeOf<
-        InfiniteData<string, unknown> | undefined
-      >()
-      return prev
-    })
-
-    expectTypeOf(data).toEqualTypeOf<
-      InfiniteData<string, unknown> | undefined
-    >()
-  })
-})

package/src/__tests__/mutationCache.test.ts

@@ -1,39 +0,0 @@
-import { beforeAll, describe, expect, test, vi } from 'vitest'
-import { ref } from 'vue-demi'
-import { MutationCache as MutationCacheOrigin } from '@tanstack/query-core'
-import { MutationCache } from '../mutationCache'
-
-describe('MutationCache', () => {
-  beforeAll(() => {
-    vi.spyOn(MutationCacheOrigin.prototype, 'find')
-    vi.spyOn(MutationCacheOrigin.prototype, 'findAll')
-  })
-
-  describe('find', () => {
-    test('should properly unwrap parameters', async () => {
-      const mutationCache = new MutationCache()
-
-      mutationCache.find({
-        mutationKey: ref(['baz']),
-      })
-
-      expect(MutationCacheOrigin.prototype.find).toBeCalledWith({
-        mutationKey: ['baz'],
-      })
-    })
-  })
-
-  describe('findAll', () => {
-    test('should properly unwrap parameters', async () => {
-      const mutationCache = new MutationCache()
-
-      mutationCache.findAll({
-        mutationKey: ref(['baz']),
-      })
-
-      expect(MutationCacheOrigin.prototype.findAll).toBeCalledWith({
-        mutationKey: ['baz'],
-      })
-    })
-  })
-})

package/src/__tests__/queryCache.test.ts

@@ -1,47 +0,0 @@
-import { beforeAll, describe, expect, test, vi } from 'vitest'
-import { ref } from 'vue-demi'
-import { QueryCache as QueryCacheOrigin } from '@tanstack/query-core'
-import { QueryCache } from '../queryCache'
-
-describe('QueryCache', () => {
-  beforeAll(() => {
-    vi.spyOn(QueryCacheOrigin.prototype, 'find')
-    vi.spyOn(QueryCacheOrigin.prototype, 'findAll')
-  })
-
-  describe('find', () => {
-    test('should properly unwrap parameters', async () => {
-      const queryCache = new QueryCache()
-
-      queryCache.find({
-        queryKey: ['foo', ref('bar')],
-      })
-
-      expect(QueryCacheOrigin.prototype.find).toBeCalledWith({
-        queryKey: ['foo', 'bar'],
-      })
-    })
-  })
-
-  describe('findAll', () => {
-    test('should properly unwrap two parameters', async () => {
-      const queryCache = new QueryCache()
-
-      queryCache.findAll({
-        queryKey: ['foo', ref('bar')],
-      })
-
-      expect(QueryCacheOrigin.prototype.findAll).toBeCalledWith({
-        queryKey: ['foo', 'bar'],
-      })
-    })
-
-    test('should default to empty filters', async () => {
-      const queryCache = new QueryCache()
-
-      queryCache.findAll()
-
-      expect(QueryCacheOrigin.prototype.findAll).toBeCalledWith({})
-    })
-  })
-})

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

@@ -1,132 +0,0 @@
-import { describe, expectTypeOf, it } from 'vitest'
-import { QueryClient } from '../queryClient'
-import type { DataTag, InfiniteData } from '@tanstack/query-core'
-
-describe('getQueryData', () => {
-  it('should be typed if key is tagged', () => {
-    const queryKey = ['key'] as DataTag<Array<string>, number>
-    const queryClient = new QueryClient()
-    const data = queryClient.getQueryData(queryKey)
-
-    expectTypeOf(data).toEqualTypeOf<number | undefined>()
-  })
-
-  it('should infer unknown if key is not tagged', () => {
-    const queryKey = ['key'] as const
-    const queryClient = new QueryClient()
-    const data = queryClient.getQueryData(queryKey)
-
-    expectTypeOf(data).toEqualTypeOf<unknown>()
-  })
-
-  it('should infer passed generic if passed', () => {
-    const queryKey = ['key'] as const
-    const queryClient = new QueryClient()
-    const data = queryClient.getQueryData<number>(queryKey)
-
-    expectTypeOf(data).toEqualTypeOf<number | undefined>()
-  })
-
-  it('should only allow Arrays to be passed', () => {
-    const queryKey = 'key'
-    const queryClient = new QueryClient()
-    // @ts-expect-error TS2345: Argument of type 'string' is not assignable to parameter of type 'QueryKey'
-    return queryClient.getQueryData(queryKey)
-  })
-})
-
-describe('setQueryData', () => {
-  it('updater should be typed if key is tagged', () => {
-    const queryKey = ['key'] as DataTag<Array<string>, number>
-    const queryClient = new QueryClient()
-    const data = queryClient.setQueryData(queryKey, (prev) => {
-      expectTypeOf(prev).toEqualTypeOf<number | undefined>()
-      return prev
-    })
-    expectTypeOf(data).toEqualTypeOf<number | undefined>()
-  })
-
-  it('value should be typed if key is tagged', () => {
-    const queryKey = ['key'] as DataTag<Array<string>, number>
-    const queryClient = new QueryClient()
-
-    // @ts-expect-error value should be a number
-    queryClient.setQueryData(queryKey, '1')
-
-    // @ts-expect-error value should be a number
-    queryClient.setQueryData(queryKey, () => '1')
-
-    const data = queryClient.setQueryData(queryKey, 1)
-
-    expectTypeOf(data).toEqualTypeOf<number | undefined>()
-  })
-
-  it('should infer unknown for updater if key is not tagged', () => {
-    const queryKey = ['key'] as const
-    const queryClient = new QueryClient()
-    const data = queryClient.setQueryData(queryKey, (prev) => {
-      expectTypeOf(prev).toEqualTypeOf<unknown>()
-      return prev
-    })
-    expectTypeOf(data).toEqualTypeOf<unknown>()
-  })
-
-  it('should infer unknown for value if key is not tagged', () => {
-    const queryKey = ['key'] as const
-    const queryClient = new QueryClient()
-    const data = queryClient.setQueryData(queryKey, 'foo')
-
-    expectTypeOf(data).toEqualTypeOf<unknown>()
-  })
-
-  it('should infer passed generic if passed', () => {
-    const queryKey = ['key'] as const
-    const queryClient = new QueryClient()
-    const data = queryClient.setQueryData<string>(queryKey, (prev) => {
-      expectTypeOf(prev).toEqualTypeOf<string | undefined>()
-      return prev
-    })
-    expectTypeOf(data).toEqualTypeOf<string | undefined>()
-  })
-
-  it('should infer passed generic for value', () => {
-    const queryKey = ['key'] as const
-    const queryClient = new QueryClient()
-    const data = queryClient.setQueryData<string>(queryKey, 'foo')
-
-    expectTypeOf(data).toEqualTypeOf<string | undefined>()
-  })
-})
-
-describe('fetchInfiniteQuery', () => {
-  it('should allow passing pages', async () => {
-    const data = await new QueryClient().fetchInfiniteQuery({
-      queryKey: ['key'],
-      queryFn: () => Promise.resolve('string'),
-      getNextPageParam: () => 1,
-      initialPageParam: 1,
-      pages: 5,
-    })
-
-    expectTypeOf(data).toEqualTypeOf<InfiniteData<string, number>>()
-  })
-
-  it('should not allow passing getNextPageParam without pages', () => {
-    new QueryClient().fetchInfiniteQuery({
-      queryKey: ['key'],
-      queryFn: () => Promise.resolve('string'),
-      initialPageParam: 1,
-      getNextPageParam: () => 1,
-    })
-  })
-
-  it('should not allow passing pages without getNextPageParam', () => {
-    // @ts-expect-error Property 'getNextPageParam' is missing
-    new QueryClient().fetchInfiniteQuery({
-      queryKey: ['key'],
-      queryFn: () => Promise.resolve('string'),
-      initialPageParam: 1,
-      pages: 5,
-    })
-  })
-})