Allow infinite query invalidation and promise checks

Author: markerikson

packages/toolkit/src/query/core/module.ts

@@ -58,10 +58,12 @@ import { buildSelectors } from './buildSelectors'
 import type { SliceActions, UpsertEntries } from './buildSlice'
 import { buildSlice } from './buildSlice'
 import type {
+  AllQueryKeys,
   BuildThunksApiEndpointInfiniteQuery,
   BuildThunksApiEndpointMutation,
   BuildThunksApiEndpointQuery,
   PatchQueryDataThunk,
+  QueryArgFromAnyQueryDefinition,
   UpdateQueryDataThunk,
   UpsertQueryDataThunk,
 } from './buildThunks'
@@ -167,9 +169,9 @@ export interface ApiModules<
        *
        * See https://redux-toolkit.js.org/rtk-query/usage/server-side-rendering for details.
        */
-      getRunningQueryThunk<EndpointName extends QueryKeys<Definitions>>(
+      getRunningQueryThunk<EndpointName extends AllQueryKeys<Definitions>>(
         endpointName: EndpointName,
-        arg: QueryArgFrom<Definitions[EndpointName]>,
+        arg: QueryArgFromAnyQueryDefinition<Definitions, EndpointName>,
       ): ThunkWithReturnValue<
         | QueryActionCreatorResult<
             Definitions[EndpointName] & { type: 'query' }

packages/toolkit/src/query/endpointDefinitions.ts

@@ -595,7 +595,13 @@ export interface InfiniteQueryExtraOptions<
     CacheCollectionQueryExtraOptions {
   type: DefinitionType.infinitequery
 
-  providesTags?: never
+  providesTags?: ResultDescription<
+    TagTypes,
+    ResultType,
+    QueryArg,
+    BaseQueryError<BaseQuery>,
+    BaseQueryMeta<BaseQuery>
+  >
   /**
    * Not to be used. A query should not invalidate tags in the cache.
    */

packages/toolkit/src/query/tests/infiniteQueries.test.ts

@@ -101,6 +101,40 @@ describe('Infinite queries', () => {
     }),
   })
 
+  let hitCounter = 0
+
+  type HitCounter = { page: number; hitCounter: number }
+
+  const countersApi = createApi({
+    baseQuery: fakeBaseQuery(),
+    tagTypes: ['Counter'],
+    endpoints: (build) => ({
+      counters: build.infiniteQuery<HitCounter, string, number>({
+        queryFn(page) {
+          hitCounter++
+
+          return { data: { page, hitCounter } }
+        },
+        infiniteQueryOptions: {
+          initialPageParam: 0,
+          getNextPageParam: (
+            lastPage,
+            allPages,
+            lastPageParam,
+            allPageParams,
+          ) => lastPageParam + 1,
+        },
+        providesTags: ['Counter'],
+      }),
+      mutation: build.mutation<null, void>({
+        queryFn: async () => {
+          return { data: null }
+        },
+        invalidatesTags: ['Counter'],
+      }),
+    }),
+  })
+
   let storeRef = setupApiStore(
     pokemonApi,
     { ...actionsReducer },
@@ -133,6 +167,8 @@ describe('Infinite queries', () => {
 
     counters = {}
 
+    hitCounter = 0
+
     process.env.NODE_ENV = 'development'
   })
 
@@ -404,32 +440,60 @@ describe('Infinite queries', () => {
   })
 
   test('refetches all existing pages', async () => {
-    let hitCounter = 0
+    const checkResultData = (
+      result: InfiniteQueryResult,
+      expectedValues: HitCounter[],
+    ) => {
+      expect(result.status).toBe(QueryStatus.fulfilled)
+      if (result.status === QueryStatus.fulfilled) {
+        expect(result.data.pages).toEqual(expectedValues)
+      }
+    }
 
-    type HitCounter = { page: number; hitCounter: number }
+    const storeRef = setupApiStore(
+      countersApi,
+      { ...actionsReducer },
+      {
+        withoutTestLifecycles: true,
+      },
+    )
 
-    const countersApi = createApi({
-      baseQuery: fakeBaseQuery(),
-      endpoints: (build) => ({
-        counters: build.infiniteQuery<HitCounter, string, number>({
-          queryFn(page) {
-            hitCounter++
+    await storeRef.store.dispatch(
+      countersApi.endpoints.counters.initiate('item', {
+        initialPageParam: 3,
+      }),
+    )
 
-            return { data: { page, hitCounter } }
-          },
-          infiniteQueryOptions: {
-            initialPageParam: 0,
-            getNextPageParam: (
-              lastPage,
-              allPages,
-              lastPageParam,
-              allPageParams,
-            ) => lastPageParam + 1,
-          },
-        }),
+    await storeRef.store.dispatch(
+      countersApi.endpoints.counters.initiate('item', {
+        direction: 'forward',
       }),
-    })
+    )
 
+    const thirdPromise = storeRef.store.dispatch(
+      countersApi.endpoints.counters.initiate('item', {
+        direction: 'forward',
+      }),
+    )
+
+    const thirdRes = await thirdPromise
+
+    checkResultData(thirdRes, [
+      { page: 3, hitCounter: 1 },
+      { page: 4, hitCounter: 2 },
+      { page: 5, hitCounter: 3 },
+    ])
+
+    const fourthRes = await thirdPromise.refetch()
+
+    checkResultData(fourthRes, [
+      { page: 3, hitCounter: 4 },
+      { page: 4, hitCounter: 5 },
+      { page: 5, hitCounter: 6 },
+    ])
+  })
+
+  test('Refetches on invalidation', async () => {
     const checkResultData = (
       result: InfiniteQueryResult,
       expectedValues: HitCounter[],
@@ -474,9 +538,28 @@ describe('Infinite queries', () => {
       { page: 5, hitCounter: 3 },
     ])
 
-    const fourthRes = await thirdPromise.refetch()
+    await storeRef.store.dispatch(countersApi.endpoints.mutation.initiate())
 
-    checkResultData(fourthRes, [
+    let entry = countersApi.endpoints.counters.select('item')(
+      storeRef.store.getState(),
+    )
+    const promise = storeRef.store.dispatch(
+      countersApi.util.getRunningQueryThunk('counters', 'item'),
+    )
+    const promises = storeRef.store.dispatch(
+      countersApi.util.getRunningQueriesThunk(),
+    )
+    expect(entry).toMatchObject({
+      status: 'pending',
+    })
+
+    expect(promise).toBeInstanceOf(Promise)
+
+    expect(promises).toEqual([promise])
+
+    const finalRes = await promise
+
+    checkResultData(finalRes as any, [
       { page: 3, hitCounter: 4 },
       { page: 4, hitCounter: 5 },
       { page: 5, hitCounter: 6 },