feat: imperative infinite queries

eslint.config.js

@@ -61,4 +61,10 @@ export default [
     },
     settings: { vitest: { typecheck: true } },
   },
+  {
+    files: ['**/*.test-d.ts', '**/*.test-d.tsx'],
+    rules: {
+      'vitest/expect-expect': 'off',
+    },
+  },
 ]

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

@@ -38,24 +38,50 @@ describe('infiniteQueryOptions', () => {
     const options = infiniteQueryOptions({
       queryKey: ['key'],
       queryFn: () => Promise.resolve('string'),
-      getNextPageParam: () => 1,
       initialPageParam: 1,
+      mode: 'manual',
     })
 
-    const { data } = injectInfiniteQuery(() => options)
+    const { data, fetchNextPage } = injectInfiniteQuery(() => options)
 
     // known issue: type of pageParams is unknown when returned from useInfiniteQuery
     expectTypeOf(data()).toEqualTypeOf<
       InfiniteData<string, unknown> | undefined
     >()
+    fetchNextPage({ pageParam: 2 })
+
+    // @ts-expect-error pageParam is required in manual mode
+    fetchNextPage()
+  })
+
+  it('should preserve manual fetch method types', () => {
+    const options = infiniteQueryOptions({
+      queryKey: ['key'],
+      queryFn: ({ pageParam }) => {
+        expectTypeOf(pageParam).toEqualTypeOf<number>()
+        return pageParam * 5
+      },
+      initialPageParam: 1,
+      mode: 'manual',
+    })
+
+    const { fetchNextPage, fetchPreviousPage } = injectInfiniteQuery(
+      () => options,
+    )
+
+    fetchNextPage({ pageParam: 2 })
+    fetchPreviousPage({ pageParam: 0 })
+
+    // @ts-expect-error pageParam is required in manual mode
+    fetchNextPage()
   })
 
   it('should work when passed to fetchInfiniteQuery', async () => {
     const options = infiniteQueryOptions({
       queryKey: ['key'],
       queryFn: () => Promise.resolve('string'),
-      getNextPageParam: () => 1,
       initialPageParam: 1,
+      mode: 'manual',
     })
 
     const data = await new QueryClient().fetchInfiniteQuery(options)
@@ -155,6 +181,33 @@ describe('infiniteQueryOptions', () => {
     )
   })
 
+  it('should reject missing mode / getNextPageParam and reject getters in manual mode', () => {
+    // @ts-expect-error getNextPageParam is required unless mode is manual
+    infiniteQueryOptions({
+      queryKey: ['key'],
+      queryFn: () => Promise.resolve('string'),
+      initialPageParam: 1,
+    })
+
+    // @ts-expect-error getNextPageParam is not allowed in manual mode
+    infiniteQueryOptions({
+      queryKey: ['key'],
+      queryFn: () => Promise.resolve('string'),
+      initialPageParam: 1,
+      mode: 'manual',
+      getNextPageParam: () => 1,
+    })
+
+    // @ts-expect-error getPreviousPageParam is not allowed in manual mode
+    infiniteQueryOptions({
+      queryKey: ['key'],
+      queryFn: () => Promise.resolve('string'),
+      initialPageParam: 1,
+      mode: 'manual',
+      getPreviousPageParam: () => 0,
+    })
+  })
+
   test('allow optional initialData function', () => {
     const initialData: { example: boolean } | undefined = { example: true }
     const queryOptions = infiniteQueryOptions({

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

@@ -39,4 +39,21 @@ describe('injectInfiniteQuery', () => {
       expectTypeOf(data).toEqualTypeOf<InfiniteData<string, unknown>>()
     }
   })
+
+  test('should require pageParam on manual fetch methods', () => {
+    const query = TestBed.runInInjectionContext(() => {
+      return injectInfiniteQuery(() => ({
+        queryKey: ['infiniteQuery'],
+        queryFn: ({ pageParam }) => 'data on page ' + pageParam,
+        initialPageParam: 0,
+        mode: 'manual',
+      }))
+    })
+
+    query.fetchNextPage({ pageParam: 1 })
+    query.fetchPreviousPage({ pageParam: 0 })
+
+    // @ts-expect-error pageParam is required in manual mode
+    query.fetchNextPage()
+  })
 })