Consistently use arg name

Author: markerikson

docs/rtk-query/api/created-api/api-slice-utils.mdx

@@ -23,12 +23,14 @@ Some of the TS types on this page are pseudocode to illustrate intent, as the ac
 
 ### `updateQueryData`
 
+A Redux thunk action creator that, when dispatched, creates and applies a set of JSON diff/patch objects to the current state. This immediately updates the Redux state with those changes.
+
 #### Signature
 
 ```ts no-transpile
 const updateQueryData = (
   endpointName: string,
-  args: any,
+  arg: any,
   updateRecipe: (draft: Draft<CachedState>) => void,
   updateProvided?: boolean,
 ) => ThunkAction<PatchCollection, PartialState, any, AnyAction>
@@ -42,21 +44,19 @@ interface PatchCollection {
 
 - **Parameters**
   - `endpointName`: a string matching an existing endpoint name
-  - `args`: an argument matching that used for a previous query call, used to determine which cached dataset needs to be updated
+  - `arg`: an argument matching that used for a previous query call, used to determine which cached dataset needs to be updated
   - `updateRecipe`: an Immer `produce` callback that can apply changes to the cached state
   - `updateProvided`: a boolean indicating whether the endpoint's provided tags should be re-calculated based on the updated cache. Defaults to `false`.
 
 #### Description
 
-A Redux thunk action creator that, when dispatched, creates and applies a set of JSON diff/patch objects to the current state. This immediately updates the Redux state with those changes.
-
 The thunk action creator accepts three arguments: the name of the endpoint we are updating (such as `'getPost'`), any relevant query arguments, and a callback function. The callback receives an Immer-wrapped `draft` of the current state, and may modify the draft to match the expected results after the mutation completes successfully.
 
 The thunk returns an object containing `{patches: Patch[], inversePatches: Patch[], undo: () => void}`. The `patches` and `inversePatches` are generated using Immer's [`produceWithPatches` method](https://immerjs.github.io/immer/patches).
 
-This is typically used as the first step in implementing optimistic updates. The generated `inversePatches` can be used to revert the updates by calling `dispatch(patchQueryData(endpointName, args, inversePatches))`. Alternatively, the `undo` method can be called directly to achieve the same effect.
+This is typically used as the first step in implementing optimistic updates. The generated `inversePatches` can be used to revert the updates by calling `dispatch(patchQueryData(endpointName, arg, inversePatches))`. Alternatively, the `undo` method can be called directly to achieve the same effect.
 
-Note that the first two arguments (`endpointName` and `args`) are used to determine which existing cache entry to update. If no existing cache entry is found, the `updateRecipe` callback will not run.
+Note that the first two arguments (`endpointName` and `arg`) are used to determine which existing cache entry to update. If no existing cache entry is found, the `updateRecipe` callback will not run.
 
 #### Example 1
 
@@ -69,7 +69,7 @@ const patchCollection = dispatch(
 ```
 
 In the example above, `'getPosts'` is provided for the `endpointName`, and `undefined` is provided
-for `args`. This will match a query cache key of `'getPosts(undefined)'`.
+for `arg`. This will match a query cache key of `'getPosts(undefined)'`.
 
 i.e. it will match a cache entry that may have been created via any of the following calls:
 
@@ -96,7 +96,7 @@ const patchCollection = dispatch(
 ```
 
 In the example above, `'getPostById'` is provided for the `endpointName`, and `1` is provided
-for `args`. This will match a query cache key of `'getPostById(1)'`.
+for `arg`. This will match a query cache key of `'getPostById(1)'`.
 
 i.e. it will match a cache entry that may have been created via any of the following calls:
 
@@ -114,27 +114,27 @@ dispatch(api.endpoints.getPostById.initiate(1, { ...options }))
 
 ### `upsertQueryData`
 
+A Redux thunk action creator that, when dispatched, acts as an artificial API request to upsert a value into the cache.
+
 #### Signature
 
 ```ts no-transpile
-const upsertQueryData = <T>(endpointName: string, args: any, newEntryData: T) =>
+const upsertQueryData = <T>(endpointName: string, arg: any, newEntryData: T) =>
   ThunkAction<Promise<CacheEntry<T>>, PartialState, any, UnknownAction>
 ```
 
 - **Parameters**
   - `endpointName`: a string matching an existing endpoint name
-  - `args`: an argument matching that used for a previous query call, used to determine which cached dataset needs to be updated
+  - `arg`: an argument matching that used for a previous query call, used to determine which cached dataset needs to be updated
   - `newEntryValue`: the value to be written into the corresponding cache entry's `data` field
 
 #### Description
 
-A Redux thunk action creator that, when dispatched, acts as an artificial API request to upsert a value into the cache.
-
 The thunk action creator accepts three arguments: the name of the endpoint we are updating (such as `'getPost'`), the appropriate query arg values to construct the desired cache key, and the data to upsert.
 
 If no cache entry for that cache key exists, a cache entry will be created and the data added. If a cache entry already exists, this will _overwrite_ the existing cache entry data.
 
-The thunk executes _asynchronously_, and returns a promise that resolves when the store has been updated.
+The thunk executes _asynchronously_, and returns a promise that resolves when the store has been updated. This includes executing the `transformResponse` callback if defined for that endpoint.
 
 If dispatched while an actual request is in progress, both the upsert and request will be handled as soon as they resolve, resulting in a "last result wins" update behavior.
 
@@ -148,27 +148,27 @@ await dispatch(
 
 ### `patchQueryData`
 
+A Redux thunk action creator that, when dispatched, applies a JSON diff/patch array to the cached data for a given query result. This immediately updates the Redux state with those changes.
+
 #### Signature
 
 ```ts no-transpile
 const patchQueryData = (
   endpointName: string,
-  args: any
+  arg: any
   patches: Patch[],
   updateProvided?: boolean
 ) => ThunkAction<void, PartialState, any, UnknownAction>;
 ```
 
 - **Parameters**
   - `endpointName`: a string matching an existing endpoint name
-  - `args`: a cache key, used to determine which cached dataset needs to be updated
+  - `arg`: a cache key, used to determine which cached dataset needs to be updated
   - `patches`: an array of patches (or inverse patches) to apply to cached state. These would typically be obtained from the result of dispatching [`updateQueryData`](#updatequerydata)
   - `updateProvided`: a boolean indicating whether the endpoint's provided tags should be re-calculated based on the updated cache. Defaults to `false`.
 
 #### Description
 
-A Redux thunk action creator that, when dispatched, applies a JSON diff/patch array to the cached data for a given query result. This immediately updates the Redux state with those changes.
-
 The thunk action creator accepts three arguments: the name of the endpoint we are updating (such as `'getPost'`), the appropriate query arg values to construct the desired cache key, and a JSON diff/patch array as produced by Immer's `produceWithPatches`.
 
 This is typically used as the second step in implementing optimistic updates. If a request fails, the optimistically-applied changes can be reverted by dispatching `patchQueryData` with the `inversePatches` that were generated by `updateQueryData` earlier.
@@ -279,6 +279,8 @@ const api = createApi({
 
 ### `prefetch`
 
+A Redux thunk action creator that can be used to manually trigger pre-fetching of data.
+
 #### Signature
 
 ```ts no-transpile
@@ -298,8 +300,6 @@ const prefetch = (endpointName: string, arg: any, options: PrefetchOptions) =>
 
 #### Description
 
-A Redux thunk action creator that can be used to manually trigger pre-fetching of data.
-
 The thunk action creator accepts three arguments: the name of the endpoint we are updating (such as `'getPost'`), any relevant query arguments, and a set of options used to determine if the data actually should be re-fetched based on cache staleness.
 
 React Hooks users will most likely never need to use this directly, as the `usePrefetch` hook will dispatch the thunk action creator result internally as needed when you call the prefetching function supplied by the hook.
@@ -312,6 +312,8 @@ dispatch(api.util.prefetch('getPosts', undefined, { force: true }))
 
 ### `selectInvalidatedBy`
 
+A selector function that can select query parameters to be invalidated.
+
 #### Signature
 
 ```ts no-transpile
@@ -334,8 +336,6 @@ function selectInvalidatedBy(
 
 #### Description
 
-A function that can select query parameters to be invalidated.
-
 The function accepts two arguments
 
 - the root state and
@@ -360,6 +360,8 @@ const entries = api.util.selectInvalidatedBy(state, [
 
 ### `invalidateTags`
 
+A Redux action creator that can be used to manually invalidate cache tags for [automated re-fetching](../../usage/automated-refetching.mdx).
+
 #### Signature
 
 ```ts no-transpile
@@ -379,8 +381,6 @@ const invalidateTags = (
 
 #### Description
 
-A Redux action creator that can be used to manually invalidate cache tags for [automated re-fetching](../../usage/automated-refetching.mdx).
-
 The action creator accepts one argument: the cache tags to be invalidated. It returns an action with those tags as a payload, and the corresponding `invalidateTags` action type for the api.
 
 Dispatching the result of this action creator will [invalidate](../../usage/automated-refetching.mdx#invalidating-cache-data) the given tags, causing queries to automatically re-fetch if they are subscribed to cache data that [provides](../../usage/automated-refetching.mdx#providing-cache-data) the corresponding tags.
@@ -400,6 +400,8 @@ dispatch(
 
 ### `selectCachedArgsForQuery`
 
+A selector function that can select arguments for currently cached queries.
+
 #### Signature
 
 ```ts no-transpile
@@ -415,8 +417,6 @@ function selectCachedArgsForQuery(
 
 #### Description
 
-A function that can select arguments for currently cached queries.
-
 The function accepts two arguments
 
 - the root state and

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

@@ -156,7 +156,7 @@ export type PatchQueryDataThunk<
   PartialState,
 > = <EndpointName extends QueryKeys<Definitions>>(
   endpointName: EndpointName,
-  args: QueryArgFrom<Definitions[EndpointName]>,
+  arg: QueryArgFrom<Definitions[EndpointName]>,
   patches: readonly Patch[],
   updateProvided?: boolean,
 ) => ThunkAction<void, PartialState, any, UnknownAction>
@@ -166,7 +166,7 @@ export type UpdateQueryDataThunk<
   PartialState,
 > = <EndpointName extends QueryKeys<Definitions>>(
   endpointName: EndpointName,
-  args: QueryArgFrom<Definitions[EndpointName]>,
+  arg: QueryArgFrom<Definitions[EndpointName]>,
   updateRecipe: Recipe<ResultTypeFrom<Definitions[EndpointName]>>,
   updateProvided?: boolean,
 ) => ThunkAction<PatchCollection, PartialState, any, UnknownAction>
@@ -176,7 +176,7 @@ export type UpsertQueryDataThunk<
   PartialState,
 > = <EndpointName extends QueryKeys<Definitions>>(
   endpointName: EndpointName,
-  args: QueryArgFrom<Definitions[EndpointName]>,
+  arg: QueryArgFrom<Definitions[EndpointName]>,
   value: ResultTypeFrom<Definitions[EndpointName]>,
 ) => ThunkAction<
   QueryActionCreatorResult<
@@ -229,11 +229,11 @@ export function buildThunks<
   type State = RootState<any, string, ReducerPath>
 
   const patchQueryData: PatchQueryDataThunk<EndpointDefinitions, State> =
-    (endpointName, args, patches, updateProvided) => (dispatch, getState) => {
+    (endpointName, arg, patches, updateProvided) => (dispatch, getState) => {
       const endpointDefinition = endpointDefinitions[endpointName]
 
       const queryCacheKey = serializeQueryArgs({
-        queryArgs: args,
+        queryArgs: arg,
         endpointDefinition,
         endpointName,
       })
@@ -246,7 +246,7 @@ export function buildThunks<
         return
       }
 
-      const newValue = api.endpoints[endpointName].select(args)(
+      const newValue = api.endpoints[endpointName].select(arg)(
         // Work around TS 4.1 mismatch
         getState() as RootState<any, any, any>,
       )
@@ -255,7 +255,7 @@ export function buildThunks<
         endpointDefinition.providesTags,
         newValue.data,
         undefined,
-        args,
+        arg,
         {},
         assertTagType,
       )
@@ -266,11 +266,11 @@ export function buildThunks<
     }
 
   const updateQueryData: UpdateQueryDataThunk<EndpointDefinitions, State> =
-    (endpointName, args, updateRecipe, updateProvided = true) =>
+    (endpointName, arg, updateRecipe, updateProvided = true) =>
     (dispatch, getState) => {
       const endpointDefinition = api.endpoints[endpointName]
 
-      const currentState = endpointDefinition.select(args)(
+      const currentState = endpointDefinition.select(arg)(
         // Work around TS 4.1 mismatch
         getState() as RootState<any, any, any>,
       )
@@ -282,7 +282,7 @@ export function buildThunks<
           dispatch(
             api.util.patchQueryData(
               endpointName,
-              args,
+              arg,
               ret.inversePatches,
               updateProvided,
             ),
@@ -317,26 +317,21 @@ export function buildThunks<
       }
 
       dispatch(
-        api.util.patchQueryData(
-          endpointName,
-          args,
-          ret.patches,
-          updateProvided,
-        ),
+        api.util.patchQueryData(endpointName, arg, ret.patches, updateProvided),
       )
 
       return ret
     }
 
   const upsertQueryData: UpsertQueryDataThunk<Definitions, State> =
-    (endpointName, args, value) => (dispatch) => {
+    (endpointName, arg, value) => (dispatch) => {
       return dispatch(
         (
           api.endpoints[endpointName] as ApiEndpointQuery<
             QueryDefinition<any, any, any, any, any>,
             Definitions
           >
-        ).initiate(args, {
+        ).initiate(arg, {
           subscribe: false,
           forceRefetch: true,
           [forceQueryFnSymbol]: () => ({

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

@@ -150,7 +150,7 @@ export interface ApiModules<
     util: {
       /**
        * A thunk that (if dispatched) will return a specific running query, identified
-       * by `endpointName` and `args`.
+       * by `endpointName` and `arg`.
        * If that query is not running, dispatching the thunk will result in `undefined`.
        *
        * Can be used to await a specific query triggered in any way,
@@ -160,7 +160,7 @@ export interface ApiModules<
        */
       getRunningQueryThunk<EndpointName extends QueryKeys<Definitions>>(
         endpointName: EndpointName,
-        args: QueryArgFrom<Definitions[EndpointName]>,
+        arg: QueryArgFrom<Definitions[EndpointName]>,
       ): ThunkWithReturnValue<
         | QueryActionCreatorResult<
             Definitions[EndpointName] & { type: 'query' }
@@ -237,9 +237,9 @@ export interface ApiModules<
        *
        * The thunk executes _synchronously_, and returns an object containing `{patches: Patch[], inversePatches: Patch[], undo: () => void}`. The `patches` and `inversePatches` are generated using Immer's [`produceWithPatches` method](https://immerjs.github.io/immer/patches).
        *
-       * This is typically used as the first step in implementing optimistic updates. The generated `inversePatches` can be used to revert the updates by calling `dispatch(patchQueryData(endpointName, args, inversePatches))`. Alternatively, the `undo` method can be called directly to achieve the same effect.
+       * This is typically used as the first step in implementing optimistic updates. The generated `inversePatches` can be used to revert the updates by calling `dispatch(patchQueryData(endpointName, arg, inversePatches))`. Alternatively, the `undo` method can be called directly to achieve the same effect.
        *
-       * Note that the first two arguments (`endpointName` and `args`) are used to determine which existing cache entry to update. If no existing cache entry is found, the `updateRecipe` callback will not run.
+       * Note that the first two arguments (`endpointName` and `arg`) are used to determine which existing cache entry to update. If no existing cache entry is found, the `updateRecipe` callback will not run.
        *
        * @example
        *