Code review cleanup

Author: markerikson

docs/rtk-query/api/createApi.mdx

@@ -273,28 +273,28 @@ export type InfiniteQueryDefinition<
        */
       initialPageParam: PageParam
       /**
-       * If specified, only keep this many pages in cache at once.
-       * If additional pages are fetched, older pages in the other
-       * direction will be dropped from the cache.
+       * This function is required to automatically get the next cursor for infinite queries.
+       * The result will also be used to determine the value of `hasNextPage`.
        */
-      maxPages?: number
+      getNextPageParam: PageParamFunction<DataType, PageParam>
       /**
        * This function can be set to automatically get the previous cursor for infinite queries.
        * The result will also be used to determine the value of `hasPreviousPage`.
        */
       getPreviousPageParam?: PageParamFunction<DataType, PageParam>
       /**
-       * This function is required to automatically get the next cursor for infinite queries.
-       * The result will also be used to determine the value of `hasNextPage`.
+       * If specified, only keep this many pages in cache at once.
+       * If additional pages are fetched, older pages in the other
+       * direction will be dropped from the cache.
        */
-      getNextPageParam: PageParamFunction<DataType, PageParam>
+      maxPages?: number
     }
   }
 ```
 
 #### Mutation endpoint definition
 
-Mutation endpoints (defined with build.mutation()`) are used to send updates to the server, and force invalidation and refetching of query endpoints.
+Mutation endpoints (defined with `build.mutation()`) are used to send updates to the server, and force invalidation and refetching of query endpoints.
 
 As with queries, you must specify either the `query` option or the `queryFn` async method.
 
@@ -543,12 +543,9 @@ _(only for `infiniteQuery` endpoints)_
 The `infiniteQueryOptions` field includes:
 
 - `initialPageParam`: the default page param value used for the first request, if this was not specified at the usage site
-- `maxPages`: an optional limit to how many fetched pages will be kept in the cache entry at a time
 - `getNextPageParam`: a required callback you must provide to calculate the next page param, given the existing cached pages and page params
 - `getPreviousPageParam`: an optional callback that will be used to calculate the previous page param, if you try to fetch backwards.
-
-Both `initialPageParam` and `getNextPageParam` are required, to
-ensure the infinite query can properly fetch the next page of data.Also, `initialPageParam` may be specified when using the endpoint, to override the default value. `maxPages` and `getPreviousPageParam` are both optional.
+- `maxPages`: an optional limit to how many fetched pages will be kept in the cache entry at a time
 
 [examples](docblock://query/endpointDefinitions.ts?token=InfiniteQueryExtraOptions.infiniteQueryOptions)
 

docs/rtk-query/api/created-api/hooks.mdx

@@ -11,15 +11,15 @@ hide_title: true
 
 ## Hooks Overview
 
-The core RTK Query `createApi` method is UI-agnostic, in the same way that the Redux core library and Redux Toolkit are UI-agnostic. They are all plain JS logic that can be used anywhere.
+The core RTK Query `createApi` method is UI-agnostic, in the same way that the Redux core library and Redux Toolkit are UI-agnostic. They are all plain JS logic that can be used anywhere. So, if you import `createApi` from `'@reduxjs/toolkit/query'`, it does not have any specific UI integrations included.
 
-However, RTK Query also provides the ability to auto-generate React hooks for each of your endpoints. Since this specifically depends on React itself, RTK Query provides an alternate entry point that exposes a customized version of `createApi` that includes that functionality:
+However, RTK Query also provides the ability to auto-generate React hooks for each of your endpoints. Since this specifically depends on React itself, RTK Query provides an additional entry point that exposes a customized version of `createApi` that includes that functionality:
 
 ```ts no-transpile
 import { createApi } from '@reduxjs/toolkit/query/react'
 ```
 
-If you have used the React-specific version of `createApi`, the generated `api` slice structure will also contain a set of React hooks. The primary endpoint hooks are available as `api.endpoints[endpointName].useQuery` or `api.endpoints[endpointName].useMutation`, matching how you defined that endpoint.
+If you have used the React-specific version of `createApi`, the generated `api` slice structure will also contain a set of React hooks. The primary endpoint hooks are available as `api.endpoints[endpointName].useQuery`, `api.endpoints[endpointName].useMutation`, and `api.endpoints[endpointName].useInfiniteQuery`, matching how you defined that endpoint.
 
 ### Generated Hook Names
 
@@ -37,15 +37,15 @@ const { data } = api.useGetPostsQuery()
 const [updatePost, { data }] = api.useUpdatePostMutation()
 ```
 
-The general format is `use(Endpointname)(Query|Mutation)` - `use` is prefixed, the first letter of your endpoint name is capitalized, then `Query` or `Mutation` is appended depending on the type.
+The general format is `use(Endpointname)(Query|Mutation|InfiniteQuery)` - `use` is prefixed, the first letter of your endpoint name is capitalized, then `Query` or `Mutation` or `InfiniteQuery` is appended depending on the type.
 
 ### Available Hooks
 
 RTK Query provides additional hooks for more advanced use-cases, although not all are generated directly on the `api` object as well.
 
 Most of the hooks are generated on a per-endpoint basis.
 
-The full list of hooks generated in the React-specific version of `createApi` is as follows:
+The full list of hooks generated in the React-specific version of `createApi` is:
 
 - Endpoint-specific, generated the `api` object with a unique name and on the endpoint object with a generic name:
   - [`useQuery`](#usequery) (all standard queries)
@@ -54,10 +54,10 @@ The full list of hooks generated in the React-specific version of `createApi` is
   - [`useLazyQuery`](#uselazyquery) (all standard queries)
 - Endpoint-specific, only generated on the endpoint object with a generic name:
   - [`useQueryState`](#usequerystate)
-  - [`useQuerySubscription](#usequerysubscription)
-  - [`useLazyQuerySubscription](#uselazyquerysubscription)
+  - [`useQuerySubscription`](#usequerysubscription)
+  - [`useLazyQuerySubscription`](#uselazyquerysubscription)
   - [`useInfiniteQueryState`](#useinfinitequerystate)
-  - [`useInfiniteQuerySubscription](#useinfinitequerysubscription)
+  - [`useInfiniteQuerySubscription`](#useinfinitequerysubscription)
 - Endpoint-agnostic, generated on the `api` object:
   - [`usePrefetch`](#useprefetch)
 

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

@@ -43,21 +43,21 @@ export type InfiniteQueryConfigOptions<DataType, PageParam> = {
    */
   initialPageParam: PageParam
   /**
-   * If specified, only keep this many pages in cache at once.
-   * If additional pages are fetched, older pages in the other
-   * direction will be dropped from the cache.
+   * This function is required to automatically get the next cursor for infinite queries.
+   * The result will also be used to determine the value of `hasNextPage`.
    */
-  maxPages?: number
+  getNextPageParam: PageParamFunction<DataType, PageParam>
   /**
    * This function can be set to automatically get the previous cursor for infinite queries.
    * The result will also be used to determine the value of `hasPreviousPage`.
    */
   getPreviousPageParam?: PageParamFunction<DataType, PageParam>
   /**
-   * This function is required to automatically get the next cursor for infinite queries.
-   * The result will also be used to determine the value of `hasNextPage`.
+   * If specified, only keep this many pages in cache at once.
+   * If additional pages are fetched, older pages in the other
+   * direction will be dropped from the cache.
    */
-  getNextPageParam: PageParamFunction<DataType, PageParam>
+  maxPages?: number
 }
 
 export interface InfiniteData<DataType, PageParam> {

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

@@ -96,8 +96,6 @@ type StartQueryActionCreator<
   options?: StartQueryActionCreatorOptions,
 ) => ThunkAction<QueryActionCreatorResult<D>, any, any, UnknownAction>
 
-// placeholder type which
-// may attempt to derive the list of args to query in pagination
 export type StartInfiniteQueryActionCreator<
   D extends InfiniteQueryDefinition<any, any, any, any, any>,
 > = (

packages/toolkit/src/query/core/buildMiddleware/cacheLifecycle.ts

@@ -142,7 +142,6 @@ export type CacheLifecycleQueryExtraOptions<
   ): Promise<void> | void
 }
 
-// copying QueryDefinition to get past initial build
 export type CacheLifecycleInfiniteQueryExtraOptions<
   ResultType,
   QueryArg,

packages/toolkit/src/query/core/buildMiddleware/queryLifecycle.ts

@@ -121,7 +121,6 @@ export type QueryLifecycleQueryExtraOptions<
   ): Promise<void> | void
 }
 
-// temporarily cloned QueryOptions again to just get the definition to build for now
 export type QueryLifecycleInfiniteQueryExtraOptions<
   ResultType,
   QueryArg,

packages/toolkit/src/query/endpointDefinitions.ts

@@ -219,7 +219,6 @@ export type BaseEndpointDefinition<
 export enum DefinitionType {
   query = 'query',
   mutation = 'mutation',
-  // hijacking query temporarily to get the definition to build
   infinitequery = 'infinitequery',
 }
 
@@ -545,7 +544,6 @@ export type QueryDefinition<
 > = BaseEndpointDefinition<QueryArg, BaseQuery, ResultType> &
   QueryExtraOptions<TagTypes, ResultType, QueryArg, BaseQuery, ReducerPath>
 
-// cloning Query Endpoint Definition with an extra option to begin with
 export interface InfiniteQueryTypes<
   QueryArg,
   PageParam,
@@ -613,6 +611,7 @@ export interface InfiniteQueryExtraOptions<
    * ensure the infinite query can properly fetch the next page of data.
    * `initialPageParam` may be specified when using the
    * endpoint, to override the default value.
+   * `maxPages` and `getPreviousPageParam` are both optional.
    * 
    * @example
    * 
@@ -625,30 +624,30 @@ export interface InfiniteQueryExtraOptions<
    *   name: string
    * }
    * 
-    const pokemonApi = createApi({
-      baseQuery: fetchBaseQuery({ baseUrl: 'https://pokeapi.co/api/v2/' }),
-      endpoints: (build) => ({
-        getInfinitePokemonWithMax: build.infiniteQuery<Pokemon[], string, number>({
-          infiniteQueryOptions: {
-            initialPageParam: 0,
-            maxPages: 3,
-            getNextPageParam: (lastPage, allPages, lastPageParam, allPageParams) =>
-              lastPageParam + 1,
-            getPreviousPageParam: (
-              firstPage,
-              allPages,
-              firstPageParam,
-              allPageParams,
-            ) => {
-              return firstPageParam > 0 ? firstPageParam - 1 : undefined
-            },
-          },
-          query({pageParam}) {
-            return `https://example.com/listItems?page=${pageParam}`
-          },
-        }),
-      }),
-    })
+   * const pokemonApi = createApi({
+   *   baseQuery: fetchBaseQuery({ baseUrl: 'https://pokeapi.co/api/v2/' }),
+   *   endpoints: (build) => ({
+   *     getInfinitePokemonWithMax: build.infiniteQuery<Pokemon[], string, number>({
+   *       infiniteQueryOptions: {
+   *         initialPageParam: 0,
+   *         maxPages: 3,
+   *         getNextPageParam: (lastPage, allPages, lastPageParam, allPageParams) =>
+   *           lastPageParam + 1,
+   *         getPreviousPageParam: (
+   *           firstPage,
+   *           allPages,
+   *           firstPageParam,
+   *           allPageParams,
+   *         ) => {
+   *           return firstPageParam > 0 ? firstPageParam - 1 : undefined
+   *         },
+   *       },
+   *       query({pageParam}) {
+   *         return `https://example.com/listItems?page=${pageParam}`
+   *       },
+   *     }),
+   *   }),
+   * })
    
    * ```
    */
@@ -736,7 +735,7 @@ export type InfiniteQueryDefinition<
   ResultType,
   ReducerPath extends string = string,
 > =
-  // Intentionally use `PageParam` as the `QueryArg` type
+  // Infinite query endpoints receive `{queryArg, pageParam}`
   BaseEndpointDefinition<
     InfiniteQueryCombinedArg<QueryArg, PageParam>,
     BaseQuery,

packages/toolkit/src/query/react/buildHooks.ts

@@ -1913,13 +1913,10 @@ export function buildHooks<Definitions extends EndpointDefinitions>({
 
       return useMemo(() => {
         const fetchNextPage = () => {
-          // TODO the hasNextPage bailout breaks things
-          //if (!hasNextPage) return
           return trigger(arg, 'forward')
         }
 
         const fetchPreviousPage = () => {
-          //if (!hasPreviousPage) return
           return trigger(arg, 'backward')
         }
 

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

@@ -642,8 +642,6 @@ describe('Infinite queries', () => {
       }),
     )
 
-    console.log('Awaiting promises 1 and 2')
-
     const entry1 = await promise1
     const entry2 = await promise2