update docs and remove enhanceEndpoints from typing (runtime fallback still exists)

Author: EskiMojo14

docs/rtk-query/api/created-api/code-splitting.mdx

@@ -13,7 +13,7 @@ Each API slice allows [additional endpoint definitions to be injected at runtime
 
 The individual API slice endpoint definitions can also be split across multiple files. This is primarily useful for working with API slices that were [code-generated from an API schema file](../../usage/code-generation.mdx), allowing you to add additional custom behavior and configuration to a set of automatically-generated endpoint definitions.
 
-Each API slice object has `injectEndpoints` and `enhanceEndpoints` functions to support these use cases.
+Each API slice object has `injectEndpoints`, `addTagTypes` and `enhanceEndpoint` functions to support these use cases.
 
 ## `injectEndpoints`
 
@@ -39,29 +39,44 @@ Endpoints will not be overridden unless `overrideExisting` is set to `true`. If
 
 This method is primarily useful for code splitting and hot reloading.
 
-## `enhanceEndpoints`
+## `addTagTypes`
 
 #### Signature
 
 ```ts no-transpile
-const enhanceEndpoints = (endpointOptions: EnhanceEndpointsOptions) =>
-  EnhancedApiSlice
+const addTagTypes = (...newTags: readonly string[]) => EnhancedApiSlice
+```
 
-interface EnhanceEndpointsOptions {
-  addTagTypes?: readonly string[]
-  endpoints?: Record<string, Partial<EndpointDefinition>>
-}
+#### Description
+
+Accepts a number of new tags to add to the API slice.
+
+Returns an updated and enhanced version of the API slice object, with the new tags added.
+
+This is primarily useful for chaining before `injectEndpoints` or `enhanceEndpoint`, to add tags which can then be used by new/enhanced endpoints.
+
+## `enhanceEndpoint`
+
+#### Signature
+
+```ts no-transpile
+const enhanceEndpoint = (
+  endpointName: string,
+  partialDefinition:
+    | Partial<EndpointDefinition>
+    | ((definition: EndpointDefinition) => void)
+) => EnhancedApiSlice
 ```
 
 #### Description
 
-Any provided tag types or endpoint definitions will be merged into the existing endpoint definitions for this API slice. Unlike `injectEndpoints`, the partial endpoint definitions will not _replace_ existing definitions, but are rather merged together on a per-definition basis (ie, `Object.assign(existingEndpoint, newPartialEndpoint)`).
+Provided partial definition will be merged into the existing endpoint definition for this API slice. Unlike `injectEndpoints`, the partial endpoint definition will not _replace_ the existing definition, but is rather merged together (i.e. `Object.assign(existingEndpoint, newPartialEndpoint)`).
 
 Returns an updated and enhanced version of the API slice object, containing the combined endpoint definitions.
 
 This is primarily useful for taking an API slice object that was code-generated from an API schema file like OpenAPI, and adding additional specific hand-written configuration for cache invalidation management on top of the generated endpoint definitions.
 
-For example, `enhanceEndpoints` can be used to modify caching behavior by changing the values of `providesTags`, `invalidatesTags`, and `keepUnusedDataFor`:
+For example, `enhanceEndpoint` can be used to modify caching behavior by changing the values of `providesTags`, `invalidatesTags`, and `keepUnusedDataFor`:
 
 ```ts
 // file: api.ts noEmit
@@ -91,20 +106,17 @@ export const api = createApi({
 // file: enhanceEndpoints.ts
 import { api } from './api'
 
-const enhancedApi = api.enhanceEndpoints({
-  addTagTypes: ['User'],
-  endpoints: {
-    getUserByUserId: {
-      providesTags: ['User'],
-    },
-    patchUserByUserId: {
-      invalidatesTags: ['User'],
-    },
-    // alternatively, define a function which is called with the endpoint definition as an argument
-    getUsers(endpoint) {
-      endpoint.providesTags = ['User']
-      endpoint.keepUnusedDataFor = 120
-    },
-  },
-})
+const enhancedApi = api
+  .addTagTypes('User')
+  .enhanceEndpoint('getUserByUserId', {
+    providesTags: ['User'],
+  })
+  .enhanceEndpoint('patchUserByUserId', {
+    invalidatesTags: ['User'],
+  })
+  // alternatively, define a function which is called with the endpoint definition as an argument
+  .enhanceEndpoint('getUsers', (endpoint) => {
+    endpoint.providesTags = ['User']
+    endpoint.keepUnusedDataFor = 120
+  })
 ```

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

@@ -42,7 +42,13 @@ type Api = {
 
   // Code splitting and generation
   injectEndpoints: (options: InjectEndpointsOptions) => UpdatedApi
-  enhanceEndpoints: (options: EnhanceEndpointsOptions) => UpdatedApi
+  addTagTypes: (...newTags: readonly string[]) => UpdatedApi
+  enhanceEndpoint: (
+    endpointName: string,
+    partialDefinition:
+      | Partial<EndpointDefinition>
+      | ((definition: EndpointDefinition) => void)
+  ) => UpdatedApi
 
   // Utilities
   utils: {
@@ -114,7 +120,7 @@ Each API slice allows [additional endpoint definitions to be injected at runtime
 
 The individual API slice endpoint definitions can also be split across multiple files. This is primarily useful for working with API slices that were [code-generated from an API schema file](../../usage/code-generation.mdx), allowing you to add additional custom behavior and configuration to a set of automatically-generated endpoint definitions.
 
-Each API slice object has `injectEndpoints` and `enhanceEndpoints` functions to support these use cases.
+Each API slice object has `injectEndpoints`, `addTagTypes` and `enhanceEndpoint` functions to support these use cases.
 
 :::info API Reference
 

docs/rtk-query/usage/code-generation.mdx

@@ -69,7 +69,7 @@ That will result in all generated endpoints having `providesTags`/`invalidatesTa
 
 Note that this will only result in string tags with no ids, so it might lead to scenarios where too much is invalidated and unneccessary requests are made on mutation.
 
-In that case it is still recommended to manually specify tags by using [`enhanceEndpoints`](../api/created-api/code-splitting.mdx) on top of the generated api and manually declare `providesTags`/`invalidatesTags`.
+In that case it is still recommended to manually specify tags by using [`addTagTypes` and `enhanceEndpoint`](../api/created-api/code-splitting.mdx) on top of the generated api and manually declare `providesTags`/`invalidatesTags`.
 
 ### Programmatic usage
 

examples/query/react/kitchen-sink/src/app/services/api.ts

@@ -20,7 +20,7 @@ const baseQueryWithRetry = retry(baseQuery, { maxRetries: 6 })
  * Create a base API to inject endpoints into elsewhere.
  * Components using this API should import from the injected site,
  * in order to get the appropriate types,
- * and to ensure that the file injecting the endpoints is loaded 
+ * and to ensure that the file injecting the endpoints is loaded
  */
 export const api = createApi({
   /**
@@ -47,9 +47,3 @@ export const api = createApi({
    */
   endpoints: () => ({}),
 })
-
-export const enhancedApi = api.enhanceEndpoints({
-  endpoints: () => ({
-    getPost: () => 'test',
-  }),
-})

packages/toolkit/src/query/apiTypes.ts

@@ -96,34 +96,7 @@ export type BaseApiMethods<
     Enhancers
   >
   /**
-   * A function to enhance a generated API with additional information. Useful with code-generation.
-   * @deprecated use addTagTypes and/or enhanceEndpoint instead
-   */
-  enhanceEndpoints<
-    NewTagTypes extends string = never,
-    NewDefinitions extends EndpointDefinitions = never
-  >(_: {
-    addTagTypes?: readonly NewTagTypes[]
-    endpoints?: UpdateDefinitions<
-      Definitions,
-      TagTypes | NoInfer<NewTagTypes>,
-      NewDefinitions
-    > extends infer NewDefinitions
-      ? {
-          [K in keyof NewDefinitions]?:
-            | Partial<NewDefinitions[K]>
-            | ((definition: NewDefinitions[K]) => void)
-        }
-      : never
-  }): Api<
-    BaseQuery,
-    UpdateDefinitions<Definitions, TagTypes | NewTagTypes, NewDefinitions>,
-    ReducerPath,
-    TagTypes | NewTagTypes,
-    Enhancers
-  >
-  /**
-   *A function to enhance a generated API with additional information. Useful with code-generation.
+   *A function to add tag types to a generated API. Useful with code-generation.
    */
   addTagTypes<NewTagTypes extends string = never>(
     ...addTagTypes: readonly NewTagTypes[]
@@ -136,7 +109,7 @@ export type BaseApiMethods<
   >
 
   /**
-   *A function to enhance a generated API with additional information. Useful with code-generation.
+   *A function to enhance a generated API endpoint with additional information. Useful with code-generation.
    */
   enhanceEndpoint<
     QueryName extends QueryKeys<Definitions>,

packages/toolkit/src/query/createApi.ts

@@ -319,21 +319,30 @@ export function buildCreateApi<Modules extends [Module<any>, ...Module<any>[]]>(
         }
         return api
       },
-      enhanceEndpoints({ addTagTypes, endpoints }) {
-        if (addTagTypes) {
-          api.addTagTypes(...addTagTypes)
-        }
-        if (endpoints) {
-          for (const [endpointName, partialDefinition] of Object.entries(
-            endpoints
-          )) {
-            ;(api.enhanceEndpoint as any)(endpointName, partialDefinition)
-          }
-        }
-        return api
-      },
     } as Api<BaseQueryFn, {}, string, string, Modules[number]['name']>
 
+    // add fallback for runtime - undocumented in TS
+    // @ts-ignore
+    api.enhanceEndpoints = ({
+      addTagTypes,
+      endpoints,
+    }: {
+      addTagTypes?: string[]
+      endpoints?: Record<string, object | Function>
+    }) => {
+      if (addTagTypes) {
+        api.addTagTypes(...addTagTypes)
+      }
+      if (endpoints) {
+        for (const [endpointName, partialDefinition] of Object.entries(
+          endpoints
+        )) {
+          ;(api.enhanceEndpoint as any)(endpointName, partialDefinition)
+        }
+      }
+      return api
+    }
+
     const initializedModules = modules.map((m) =>
       m.init(api as any, optionsWithDefaults as any, context)
     )