@tanstack/vue-query 5.40.0 → 5.40.1

package/src/__tests__/useInfiniteQuery.types.test.tsx

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

package/src/__tests__/useMutation.types.test.tsx

@@ -1,98 +0,0 @@
-import { describe, it } from 'vitest'
-import { reactive } from 'vue-demi'
-import { useMutation } from '../useMutation'
-import { doNotExecute, successMutator } from './test-utils'
-import type { Equal, Expect } from './test-utils'
-
-describe('Discriminated union return type', () => {
-  it('data should be possibly undefined by default', () => {
-    doNotExecute(() => {
-      const mutation = reactive(
-        useMutation({ mutationFn: successMutator<string> }),
-      )
-
-      const result: Expect<Equal<string | undefined, typeof mutation.data>> =
-        true
-      return result
-    })
-  })
-
-  it('data should be defined when mutation is success', () => {
-    doNotExecute(() => {
-      const mutation = reactive(
-        useMutation({ mutationFn: successMutator<string> }),
-      )
-
-      if (mutation.isSuccess) {
-        const result: Expect<Equal<string, typeof mutation.data>> = true
-        return result
-      }
-      return
-    })
-  })
-
-  it('error should be null when mutation is success', () => {
-    doNotExecute(() => {
-      const mutation = reactive(
-        useMutation({ mutationFn: successMutator<string> }),
-      )
-
-      if (mutation.isSuccess) {
-        const result: Expect<Equal<null, typeof mutation.error>> = true
-        return result
-      }
-      return
-    })
-  })
-
-  it('data should be undefined when mutation is pending', () => {
-    doNotExecute(() => {
-      const mutation = reactive(
-        useMutation({ mutationFn: successMutator<string> }),
-      )
-
-      if (mutation.isPending) {
-        const result: Expect<Equal<undefined, typeof mutation.data>> = true
-        return result
-      }
-      return
-    })
-  })
-
-  it('error should be defined when mutation is error', () => {
-    doNotExecute(() => {
-      const mutation = reactive(
-        useMutation({ mutationFn: successMutator<string> }),
-      )
-
-      if (mutation.isError) {
-        const result: Expect<Equal<Error, typeof mutation.error>> = true
-        return result
-      }
-      return
-    })
-  })
-
-  it('should narrow variables', () => {
-    doNotExecute(() => {
-      const mutation = reactive(
-        useMutation({ mutationFn: successMutator<string> }),
-      )
-
-      if (mutation.isIdle) {
-        const result: Expect<Equal<undefined, typeof mutation.variables>> = true
-        return result
-      }
-      if (mutation.isPending) {
-        const result: Expect<Equal<string, typeof mutation.variables>> = true
-        return result
-      }
-      if (mutation.isSuccess) {
-        const result: Expect<Equal<string, typeof mutation.variables>> = true
-        return result
-      }
-      const result: Expect<Equal<string, typeof mutation.variables>> = true
-      return result
-    })
-  })
-})

package/src/__tests__/useQueries.types.test.ts

@@ -1,176 +0,0 @@
-import { describe, it } from 'vitest'
-import { reactive } from 'vue'
-import { skipToken, useQueries } from '..'
-import { queryOptions } from '../queryOptions'
-import { doNotExecute } from './test-utils'
-import type { OmitKeyof } from '..'
-import type { UseQueryOptions } from '../useQuery'
-import type { Equal, Expect } from './test-utils'
-
-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',
-    }
-
-    doNotExecute(() => {
-      const { value: queriesState } = useQueries({
-        queries: [query1, query2, query3],
-      })
-
-      const query1Data = queriesState[0].data
-      const query2Data = queriesState[1].data
-      const query3Data = queriesState[2].data
-
-      const result1: Expect<Equal<{ wow: boolean }, typeof query1Data>> = true
-
-      const result2: Expect<Equal<string, typeof query2Data>> = true
-
-      const result3: Expect<Equal<string | undefined, typeof query3Data>> = true
-
-      return result1 && result2 && result3
-    })
-  })
-
-  it('TData should be defined when passed through queryOptions', () => {
-    doNotExecute(() => {
-      const options = queryOptions({
-        queryKey: ['key'],
-        queryFn: () => {
-          return {
-            wow: true,
-          }
-        },
-        initialData: {
-          wow: true,
-        },
-      })
-
-      const { value: queriesState } = useQueries({ queries: [options] })
-
-      const data = queriesState[0].data
-
-      const result: Expect<Equal<{ wow: boolean }, typeof data>> = true
-      return result
-    })
-  })
-
-  it('it should be possible to define a different TData than TQueryFnData using select with queryOptions spread into useQueries', () => {
-    doNotExecute(() => {
-      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] }))
-      const query1Data = queriesState.value[0].data
-      const query2Data = queriesState.value[1].data
-
-      const result1: Expect<Equal<boolean | undefined, typeof query1Data>> =
-        true
-      const result2: Expect<Equal<boolean | undefined, typeof query2Data>> =
-        true
-      return result1 && result2
-    })
-  })
-
-  it('TData should have undefined in the union when initialData is provided as a function which can return undefined', () => {
-    doNotExecute(() => {
-      const { value: queriesState } = useQueries({
-        queries: [
-          {
-            queryKey: ['key'],
-            queryFn: () => {
-              return {
-                wow: true,
-              }
-            },
-            initialData: () => undefined as { wow: boolean } | undefined,
-          },
-        ],
-      })
-
-      const data = queriesState[0].data
-
-      const result: Expect<Equal<{ wow: boolean } | undefined, typeof data>> =
-        true
-      return result
-    })
-  })
-
-  it('TData should have correct type when conditional skipToken is passed', () => {
-    doNotExecute(() => {
-      const { value: queriesState } = useQueries({
-        queries: [
-          {
-            queryKey: ['key'],
-            queryFn: Math.random() > 0.5 ? skipToken : () => Promise.resolve(5),
-          },
-        ],
-      })
-
-      const data = queriesState[0].data
-
-      const result: Expect<Equal<number | undefined, typeof data>> = true
-      return result
-    })
-  })
-
-  describe('custom hook', () => {
-    it('should allow custom hooks using UseQueryOptions', () => {
-      doNotExecute(() => {
-        type Data = string
-
-        const useCustomQueries = (
-          options?: OmitKeyof<
-            UseQueryOptions<Data>,
-            'queryKey' | 'queryFn',
-            'safely'
-          >,
-        ) => {
-          return useQueries({
-            queries: [
-              {
-                ...options,
-                queryKey: ['todos-key'],
-                queryFn: () => Promise.resolve('data'),
-              },
-            ],
-          })
-        }
-
-        const { value: queriesState } = useCustomQueries()
-        const data = queriesState[0].data
-
-        const result: Expect<Equal<Data | undefined, typeof data>> = true
-        return result
-      })
-    })
-  })
-})

package/src/__tests__/useQuery.types.test.ts

@@ -1,282 +0,0 @@
-import { describe, it } from 'vitest'
-import { reactive } from 'vue-demi'
-import { useQuery } from '../useQuery'
-import { queryOptions } from '../queryOptions'
-import { doNotExecute, simpleFetcher } from './test-utils'
-import type { OmitKeyof } from '..'
-import type { UseQueryOptions } from '../useQuery'
-import type { Equal, Expect } from './test-utils'
-
-describe('initialData', () => {
-  describe('Config object overload', () => {
-    it('TData should always be defined when initialData is provided as an object', () => {
-      doNotExecute(() => {
-        const { data } = reactive(
-          useQuery({
-            queryKey: ['key'],
-            queryFn: () => {
-              return {
-                wow: true,
-              }
-            },
-            initialData: {
-              wow: true,
-            },
-          }),
-        )
-
-        const result: Expect<Equal<{ wow: boolean }, typeof data>> = true
-
-        return result
-      })
-    })
-
-    it('TData should be defined when passed through queryOptions', () => {
-      doNotExecute(() => {
-        const options = queryOptions({
-          queryKey: ['key'],
-          queryFn: () => {
-            return {
-              wow: true,
-            }
-          },
-          initialData: {
-            wow: true,
-          },
-        })
-        const { data } = reactive(useQuery(options))
-
-        const result: Expect<Equal<{ wow: boolean }, typeof data>> = true
-        return result
-      })
-    })
-
-    it('it should be possible to define a different TData than TQueryFnData using select with queryOptions spread into useQuery', () => {
-      doNotExecute(() => {
-        const options = queryOptions({
-          queryKey: ['key'],
-          queryFn: () => Promise.resolve(1),
-        })
-
-        const query = reactive(
-          useQuery({
-            ...options,
-            select: (data) => data > 1,
-          }),
-        )
-
-        const result: Expect<Equal<boolean | undefined, typeof query.data>> =
-          true
-        return result
-      })
-    })
-
-    it('TData should always be defined when initialData is provided as a function which ALWAYS returns the data', () => {
-      doNotExecute(() => {
-        const { data } = reactive(
-          useQuery({
-            queryKey: ['key'],
-            queryFn: () => {
-              return {
-                wow: true,
-              }
-            },
-            initialData: () => ({
-              wow: true,
-            }),
-          }),
-        )
-
-        const result: Expect<Equal<{ wow: boolean }, typeof data>> = true
-        return result
-      })
-    })
-
-    it('TData should have undefined in the union when initialData is NOT provided', () => {
-      doNotExecute(() => {
-        const { data } = reactive(
-          useQuery({
-            queryKey: ['key'],
-            queryFn: () => {
-              return {
-                wow: true,
-              }
-            },
-          }),
-        )
-
-        const result: Expect<Equal<{ wow: boolean } | undefined, typeof data>> =
-          true
-        return result
-      })
-    })
-
-    it('TData should have undefined in the union when initialData is provided as a function which can return undefined', () => {
-      doNotExecute(() => {
-        const { data } = reactive(
-          useQuery({
-            queryKey: ['key'],
-            queryFn: () => {
-              return {
-                wow: true,
-              }
-            },
-            initialData: () => undefined as { wow: boolean } | undefined,
-          }),
-        )
-
-        const result: Expect<Equal<{ wow: boolean } | undefined, typeof data>> =
-          true
-        return result
-      })
-    })
-
-    it('TData should be narrowed after an isSuccess check when initialData is provided as a function which can return undefined', () => {
-      doNotExecute(() => {
-        const { data, isSuccess } = reactive(
-          useQuery({
-            queryKey: ['key'],
-            queryFn: () => {
-              return {
-                wow: true,
-              }
-            },
-            initialData: () => undefined as { wow: boolean } | undefined,
-          }),
-        )
-
-        if (isSuccess) {
-          const result: Expect<Equal<{ wow: boolean }, typeof data>> = true
-          return result
-        }
-        return false
-      })
-    })
-  })
-
-  describe('custom composable', () => {
-    it('should allow custom composable using UseQueryOptions', () => {
-      doNotExecute(() => {
-        type Data = string
-
-        const useCustomQuery = (
-          options?: OmitKeyof<
-            UseQueryOptions<Data>,
-            'queryKey' | 'queryFn',
-            'safely'
-          >,
-        ) => {
-          return useQuery({
-            ...options,
-            queryKey: ['todos-key'],
-            queryFn: () => Promise.resolve('data'),
-          })
-        }
-
-        const { data } = reactive(useCustomQuery())
-
-        const result: Expect<Equal<Data | undefined, typeof data>> = true
-        return result
-      })
-    })
-  })
-
-  describe('structuralSharing', () => {
-    it('should restrict to same types', () => {
-      doNotExecute(() => {
-        useQuery({
-          queryKey: ['key'],
-          queryFn: () => 5,
-          structuralSharing: (_oldData, newData) => {
-            return newData
-          },
-        })
-      })
-    })
-  })
-
-  describe('Discriminated union return type', () => {
-    it('data should be possibly undefined by default', () => {
-      doNotExecute(() => {
-        const query = reactive(
-          useQuery({
-            queryKey: ['key'],
-            queryFn: simpleFetcher,
-          }),
-        )
-
-        const result: Expect<Equal<string | undefined, typeof query.data>> =
-          true
-        return result
-      })
-    })
-
-    it('data should be defined when query is success', () => {
-      doNotExecute(() => {
-        const query = reactive(
-          useQuery({
-            queryKey: ['key'],
-            queryFn: simpleFetcher,
-          }),
-        )
-
-        if (query.isSuccess) {
-          const result: Expect<Equal<string, typeof query.data>> = true
-          return result
-        }
-        return
-      })
-    })
-
-    it('error should be null when query is success', () => {
-      doNotExecute(() => {
-        const query = reactive(
-          useQuery({
-            queryKey: ['key'],
-            queryFn: simpleFetcher,
-          }),
-        )
-
-        if (query.isSuccess) {
-          const result: Expect<Equal<null, typeof query.error>> = true
-          return result
-        }
-        return
-      })
-    })
-
-    it('data should be undefined when query is pending', () => {
-      doNotExecute(() => {
-        const query = reactive(
-          useQuery({
-            queryKey: ['key'],
-            queryFn: simpleFetcher,
-          }),
-        )
-
-        if (query.isPending) {
-          const result: Expect<Equal<undefined, typeof query.data>> = true
-          return result
-        }
-        return
-      })
-    })
-
-    it('error should be defined when query is error', () => {
-      doNotExecute(() => {
-        const query = reactive(
-          useQuery({
-            queryKey: ['key'],
-            queryFn: simpleFetcher,
-          }),
-        )
-
-        if (query.isError) {
-          const result: Expect<Equal<Error, typeof query.error>> = true
-          return result
-        }
-        return
-      })
-    })
-  })
-})