docs(preact-query): updated docs for Preact usePrefetchQuery

.changeset/cute-cloths-switch.md

@@ -0,0 +1,5 @@
+---
+'@tanstack/preact-query': minor
+---
+
+update usePrefetchQuery to use new methods

.changeset/true-cameras-wash.md

@@ -0,0 +1,5 @@
+---
+'@tanstack/query-core': minor
+---
+
+add query and infiniteQuery methods, deprecate old imperative methods

docs/framework/preact/reference/functions/usePrefetchQuery.md

@@ -33,7 +33,7 @@ Defined in: [preact-query/src/usePrefetchQuery.tsx:5](https://github.com/theVeda
 
 ### options
 
-[`UsePrefetchQueryOptions`](../interfaces/UsePrefetchQueryOptions.md)\<`TQueryFnData`, `TError`, `TData`, `TQueryKey`\>
+`QueryExecuteOptions`\<`TQueryFnData`, `TError`, `TData`, `TQueryKey`\>
 
 ### queryClient?
 

docs/framework/preact/reference/index.md

@@ -12,7 +12,6 @@ title: "@tanstack/preact-query"
 - [UseBaseQueryOptions](interfaces/UseBaseQueryOptions.md)
 - [UseInfiniteQueryOptions](interfaces/UseInfiniteQueryOptions.md)
 - [UseMutationOptions](interfaces/UseMutationOptions.md)
-- [UsePrefetchQueryOptions](interfaces/UsePrefetchQueryOptions.md)
 - [UseQueryOptions](interfaces/UseQueryOptions.md)
 - [UseSuspenseInfiniteQueryOptions](interfaces/UseSuspenseInfiniteQueryOptions.md)
 - [UseSuspenseQueryOptions](interfaces/UseSuspenseQueryOptions.md)

packages/angular-query-experimental/src/__tests__/infinite-query-options.test-d.ts

@@ -1,6 +1,6 @@
 import { assertType, describe, expectTypeOf, it } from 'vitest'
 import { queryKey } from '@tanstack/query-test-utils'
-import { QueryClient, dataTagSymbol } from '@tanstack/query-core'
+import { QueryClient, dataTagSymbol, skipToken } from '@tanstack/query-core'
 import { infiniteQueryOptions } from '../infinite-query-options'
 import { injectInfiniteQuery } from '../inject-infinite-query'
 import { injectQuery } from '../inject-query'
@@ -67,6 +67,61 @@ describe('infiniteQueryOptions', () => {
 
     expectTypeOf(data).toEqualTypeOf<InfiniteData<string, number>>()
   })
+
+  it('should work when passed to infiniteQuery', async () => {
+    const options = infiniteQueryOptions({
+      queryKey: ['key'],
+      queryFn: () => Promise.resolve('string'),
+      getNextPageParam: () => 1,
+      initialPageParam: 1,
+    })
+
+    const data = await new QueryClient().infiniteQuery(options)
+
+    expectTypeOf(data).toEqualTypeOf<InfiniteData<string, number>>()
+  })
+
+  it('should work when passed to infiniteQuery with select', async () => {
+    const options = infiniteQueryOptions({
+      queryKey: ['key'],
+      queryFn: () => Promise.resolve('string'),
+      getNextPageParam: () => 1,
+      initialPageParam: 1,
+      select: (data) => data.pages,
+    })
+
+    const data = await new QueryClient().infiniteQuery(options)
+
+    expectTypeOf(data).toEqualTypeOf<Array<string>>()
+  })
+
+  it('should work when passed to infiniteQuery with enabled: false', async () => {
+    const options = infiniteQueryOptions({
+      queryKey: ['key'],
+      queryFn: () => Promise.resolve('string'),
+      getNextPageParam: () => 1,
+      initialPageParam: 1,
+      enabled: false,
+    })
+
+    const data = await new QueryClient().infiniteQuery(options)
+
+    expectTypeOf(data).toEqualTypeOf<InfiniteData<string, number>>()
+  })
+
+  it('should work when passed to infiniteQuery with skipToken', async () => {
+    const options = infiniteQueryOptions({
+      queryKey: ['key'],
+      queryFn: skipToken,
+      getNextPageParam: () => 1,
+      initialPageParam: 1,
+    })
+
+    const data = await new QueryClient().infiniteQuery(options)
+
+    expectTypeOf(data).toEqualTypeOf<InfiniteData<unknown, number>>()
+  })
+
   it('should tag the queryKey with the result type of the QueryFn', () => {
     const key = queryKey()
     const { queryKey: tagged } = infiniteQueryOptions({

packages/angular-query-experimental/src/__tests__/query-options.test-d.ts

@@ -1,6 +1,12 @@
 import { assertType, describe, expectTypeOf, it } from 'vitest'
 import { queryKey } from '@tanstack/query-test-utils'
-import { QueryClient, dataTagSymbol, injectQuery, queryOptions } from '..'
+import {
+  QueryClient,
+  dataTagSymbol,
+  injectQuery,
+  queryOptions,
+  skipToken,
+} from '..'
 import type { Signal } from '@angular/core'
 
 describe('queryOptions', () => {
@@ -67,6 +73,48 @@ it('should work when passed to fetchQuery', () => {
   assertType<Promise<number>>(data)
 })
 
+it('should work when passed to query', () => {
+  const options = queryOptions({
+    queryKey: ['key'],
+    queryFn: () => Promise.resolve(5),
+  })
+
+  const data = new QueryClient().query(options)
+  assertType<Promise<number>>(data)
+})
+
+it('should work when passed to query with select', () => {
+  const options = queryOptions({
+    queryKey: ['key'],
+    queryFn: () => Promise.resolve(5),
+    select: (data) => data.toString(),
+  })
+
+  const data = new QueryClient().query(options)
+  assertType<Promise<string>>(data)
+})
+
+it('should work when passed to query with enabled: false', () => {
+  const options = queryOptions({
+    queryKey: ['key'],
+    queryFn: () => Promise.resolve(5),
+    enabled: false,
+  })
+
+  const data = new QueryClient().query(options)
+  assertType<Promise<number>>(data)
+})
+
+it('should work when passed to query with skipToken', () => {
+  const options = queryOptions({
+    queryKey: ['key'],
+    queryFn: skipToken,
+  })
+
+  const data = new QueryClient().query(options)
+  assertType<Promise<unknown>>(data)
+})
+
 it('should tag the queryKey with the result type of the QueryFn', () => {
   const key = queryKey()
   const { queryKey: tagged } = queryOptions({

packages/lit-query/src/tests/type-inference.test.ts

@@ -1,7 +1,9 @@
 import {
   dataTagSymbol,
   QueryClient,
+  skipToken,
   type DefinedQueryObserverResult,
+  type InfiniteData,
   type QueryObserverResult,
 } from '@tanstack/query-core'
 import { describe, expectTypeOf, it } from 'vitest'
@@ -207,4 +209,118 @@ describe('type inference', () => {
       Array<{ page: number }> | undefined
     >()
   })
+
+  it('L3: queryOptions integrates with queryClient.query', async () => {
+    const options = queryOptions({
+      queryKey: ['type-inference', 'query'] as const,
+      queryFn: () => Promise.resolve(5),
+    })
+
+    const data = await new QueryClient().query(options)
+    expectTypeOf(data).toEqualTypeOf<number>()
+  })
+
+  it('L4: queryOptions with select integrates with queryClient.query', async () => {
+    const options = queryOptions({
+      queryKey: ['type-inference', 'query-select'] as const,
+      queryFn: () => Promise.resolve(5),
+      select: (data) => data.toString(),
+    })
+
+    const data = await new QueryClient().query(options)
+    expectTypeOf(data).toEqualTypeOf<string>()
+  })
+
+  it('L5: queryOptions with enabled: false integrates with queryClient.query', async () => {
+    const options = queryOptions({
+      queryKey: ['type-inference', 'query-enabled-false'] as const,
+      queryFn: () => Promise.resolve(5),
+      enabled: false,
+    })
+
+    const client = new QueryClient()
+    // Disabled imperative queries require cached data; otherwise query() throws before type assertions run.
+    client.setQueryData(options.queryKey, 5)
+
+    const data = await client.query(options)
+    expectTypeOf(data).toEqualTypeOf<number>()
+  })
+
+  it('L6: queryOptions with skipToken integrates with queryClient.query', async () => {
+    const options = queryOptions({
+      queryKey: ['type-inference', 'query-skip-token'] as const,
+      queryFn: skipToken,
+    })
+
+    const client = new QueryClient()
+    // skipToken disables the query, so seed matching data to exercise the return type.
+    client.setQueryData(options.queryKey, 5)
+
+    const data = await client.query(options)
+    expectTypeOf(data).toEqualTypeOf<unknown>()
+  })
+
+  it('L7: infiniteQueryOptions integrates with queryClient.infiniteQuery', async () => {
+    const options = infiniteQueryOptions({
+      queryKey: ['type-inference', 'infinite-query'] as const,
+      queryFn: () => Promise.resolve('data'),
+      getNextPageParam: () => 1,
+      initialPageParam: 1,
+    })
+
+    const data = await new QueryClient().infiniteQuery(options)
+    expectTypeOf(data).toEqualTypeOf<InfiniteData<string, number>>()
+  })
+
+  it('L8: infiniteQueryOptions with select integrates with queryClient.infiniteQuery', async () => {
+    const options = infiniteQueryOptions({
+      queryKey: ['type-inference', 'infinite-query-select'] as const,
+      queryFn: () => Promise.resolve('data'),
+      getNextPageParam: () => 1,
+      initialPageParam: 1,
+      select: (data) => data.pages,
+    })
+
+    const data = await new QueryClient().infiniteQuery(options)
+    expectTypeOf(data).toEqualTypeOf<Array<string>>()
+  })
+
+  it('L9: infiniteQueryOptions with enabled: false integrates with queryClient.infiniteQuery', async () => {
+    const options = infiniteQueryOptions({
+      queryKey: ['type-inference', 'infinite-query-enabled-false'] as const,
+      queryFn: () => Promise.resolve('data'),
+      getNextPageParam: () => 1,
+      initialPageParam: 1,
+      enabled: false,
+    })
+
+    const client = new QueryClient()
+    // Disabled imperative infinite queries require cached data to avoid throwing before type assertions.
+    client.setQueryData(options.queryKey, {
+      pages: ['data'],
+      pageParams: [1],
+    })
+
+    const data = await client.infiniteQuery(options)
+    expectTypeOf(data).toEqualTypeOf<InfiniteData<string, number>>()
+  })
+
+  it('L10: infiniteQueryOptions with skipToken integrates with queryClient.infiniteQuery', async () => {
+    const options = infiniteQueryOptions({
+      queryKey: ['type-inference', 'infinite-query-skip-token'] as const,
+      queryFn: skipToken,
+      getNextPageParam: () => 1,
+      initialPageParam: 1,
+    })
+
+    const client = new QueryClient()
+    // skipToken disables the infinite query, so seed data matching the InfiniteData shape.
+    client.setQueryData(options.queryKey, {
+      pages: ['data'],
+      pageParams: [1],
+    })
+
+    const data = await client.infiniteQuery(options)
+    expectTypeOf(data).toEqualTypeOf<InfiniteData<unknown, number>>()
+  })
 })

packages/preact-query/src/__tests__/infiniteQueryOptions.test-d.tsx

@@ -64,6 +64,56 @@ describe('infiniteQueryOptions', () => {
 
     expectTypeOf(data).toEqualTypeOf<InfiniteData<string, unknown>>()
   })
+  it('should work when passed to infiniteQuery', async () => {
+    const options = infiniteQueryOptions({
+      queryKey: ['key'],
+      queryFn: () => Promise.resolve('string'),
+      getNextPageParam: () => 1,
+      initialPageParam: 1,
+    })
+
+    const data = await new QueryClient().infiniteQuery(options)
+
+    expectTypeOf(data).toEqualTypeOf<InfiniteData<string, number>>()
+  })
+  it('should work when passed to infiniteQuery with select', async () => {
+    const options = infiniteQueryOptions({
+      queryKey: ['key'],
+      queryFn: () => Promise.resolve('string'),
+      getNextPageParam: () => 1,
+      initialPageParam: 1,
+      select: (data) => data.pages,
+    })
+
+    const data = await new QueryClient().infiniteQuery(options)
+
+    expectTypeOf(data).toEqualTypeOf<Array<string>>()
+  })
+  it('should work when passed to infiniteQuery with enabled: false', async () => {
+    const options = infiniteQueryOptions({
+      queryKey: ['key'],
+      queryFn: () => Promise.resolve('string'),
+      getNextPageParam: () => 1,
+      initialPageParam: 1,
+      enabled: false,
+    })
+
+    const data = await new QueryClient().infiniteQuery(options)
+
+    expectTypeOf(data).toEqualTypeOf<InfiniteData<string, number>>()
+  })
+  it('should work when passed to infiniteQuery with skipToken', async () => {
+    const options = infiniteQueryOptions({
+      queryKey: ['key'],
+      queryFn: skipToken,
+      getNextPageParam: () => 1,
+      initialPageParam: 1,
+    })
+
+    const data = await new QueryClient().infiniteQuery(options)
+
+    expectTypeOf(data).toEqualTypeOf<InfiniteData<unknown, number>>()
+  })
   it('should work when passed to fetchInfiniteQuery', async () => {
     const options = infiniteQueryOptions({
       queryKey: queryKey(),