@tanstack/solid-query 5.59.17 → 5.59.20

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

@@ -1,81 +0,0 @@
-import { describe, expectTypeOf, it } from 'vitest'
-import { dataTagSymbol } from '@tanstack/query-core'
-import { createInfiniteQuery } from '../createInfiniteQuery'
-import { infiniteQueryOptions } from '../infiniteQueryOptions'
-import type { InfiniteData } from '@tanstack/query-core'
-import type {
-  DefinedInitialDataInfiniteOptions,
-  UndefinedInitialDataInfiniteOptions,
-} from '../infiniteQueryOptions'
-
-const doNotRun = (_callback: () => void) => {}
-
-describe('infiniteQueryOptions', () => {
-  it('should infer defined types', () => {
-    const options = infiniteQueryOptions({
-      getNextPageParam: () => 10,
-      queryKey: ['key'],
-      queryFn: () => ({ wow: true }),
-      initialData: {
-        pageParams: [undefined],
-        pages: [{ wow: true }],
-      },
-      initialPageParam: 0,
-    })
-
-    doNotRun(() => {
-      expectTypeOf(createInfiniteQuery(() => options).data).toEqualTypeOf<
-        InfiniteData<{ wow: boolean }, unknown>
-      >()
-
-      expectTypeOf(options).toMatchTypeOf<
-        ReturnType<
-          DefinedInitialDataInfiniteOptions<
-            { wow: boolean },
-            Error,
-            InfiniteData<{ wow: boolean }, unknown>,
-            Array<string>,
-            number | undefined
-          >
-        >
-      >()
-
-      expectTypeOf(options.queryKey[dataTagSymbol]).toEqualTypeOf<
-        InfiniteData<{ wow: boolean }>
-      >()
-    })
-  })
-
-  it('should work without defined types', () => {
-    const options = infiniteQueryOptions({
-      getNextPageParam: () => undefined,
-      queryKey: ['key'],
-      queryFn: () => ({ wow: true }),
-      initialPageParam: 0,
-    })
-
-    doNotRun(() => {
-      expectTypeOf(() => createInfiniteQuery(() => options).data).toEqualTypeOf<
-        () => InfiniteData<{ wow: boolean }, unknown> | undefined
-      >()
-
-      expectTypeOf(options).toMatchTypeOf<
-        ReturnType<
-          UndefinedInitialDataInfiniteOptions<
-            { wow: boolean },
-            Error,
-            InfiniteData<{ wow: boolean }, unknown>,
-            Array<string>,
-            number
-          >
-        >
-      >()
-
-      expectTypeOf(options.queryKey[dataTagSymbol]).toEqualTypeOf<
-        InfiniteData<{
-          wow: boolean
-        }>
-      >()
-    })
-  })
-})

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

@@ -1,146 +0,0 @@
-import { describe, expectTypeOf, it } from 'vitest'
-import { QueryClient, dataTagSymbol, skipToken } from '@tanstack/query-core'
-import { createQuery } from '../createQuery'
-import { queryOptions } from '../queryOptions'
-
-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 createQuery', () => {
-    const options = queryOptions({
-      queryKey: ['key'],
-      queryFn: () => Promise.resolve(5),
-    })
-
-    const { data } = createQuery(() => options)
-    expectTypeOf(data).toEqualTypeOf<number | undefined>()
-  })
-  it('should work when passed to fetchQuery', async () => {
-    const options = queryOptions({
-      queryKey: ['key'],
-      queryFn: () => Promise.resolve(5),
-    })
-
-    const data = await new QueryClient().fetchQuery(options)
-    expectTypeOf(data).toEqualTypeOf<number>()
-  })
-  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 return the proper type when passed to getQueryState', () => {
-    const { queryKey } = queryOptions({
-      queryKey: ['key'],
-      queryFn: () => Promise.resolve(5),
-    })
-
-    const queryClient = new QueryClient()
-    const state = queryClient.getQueryState(queryKey)
-    expectTypeOf(state?.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 infer even if there is a conditional skipToken', () => {
-    const options = queryOptions({
-      queryKey: ['key'],
-      queryFn: Math.random() > 0.5 ? skipToken : () => Promise.resolve(5),
-    })
-
-    const queryClient = new QueryClient()
-    const data = queryClient.getQueryData(options.queryKey)
-    expectTypeOf(data).toEqualTypeOf<number | undefined>()
-  })
-
-  it('should infer to unknown if we disable a query with just a skipToken', () => {
-    const options = queryOptions({
-      queryKey: ['key'],
-      queryFn: skipToken,
-    })
-
-    const queryClient = new QueryClient()
-    const data = queryClient.getQueryData(options.queryKey)
-    expectTypeOf(data).toEqualTypeOf<unknown>()
-  })
-})