Split enhanceEndpoints into addTagTypes and enhanceEndpoint

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`
 
@@ -46,29 +46,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
@@ -98,20 +113,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: {
@@ -118,7 +124,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

@@ -47,9 +47,3 @@ export const api = createApi({
    */
   endpoints: () => ({}),
 })
-
-export const enhancedApi = api.enhanceEndpoints({
-  endpoints: () => ({
-    getPost: () => 'test',
-  }),
-})

packages/rtk-codemods/transforms/enhanceEndpoint/README.md

@@ -0,0 +1,28 @@
+# enhanceEndpoint
+
+Transforms enhanceEndpoints calls into addTagType and enhanceEndpoint calls, in preparation for RTK 3.0.
+
+## Usage
+
+```
+npx @reduxjs/rtk-codemods enhanceEndpoint path/of/files/ or/some**/*glob.js
+
+# or
+
+yarn global add @reduxjs/rtk-codemods
+@reduxjs/rtk-codemods enhanceEndpoint path/of/files/ or/some**/*glob.js
+```
+
+## Local Usage
+
+```
+node ./bin/cli.js enhanceEndpoint path/of/files/ or/some**/*glob.js
+```
+
+## Input / Output
+
+<!--FIXTURES_TOC_START-->
+<!--FIXTURES_TOC_END-->
+
+<!--FIXTURES_CONTENT_START-->
+<!--FIXTURES_CONTENT_END-->

packages/rtk-codemods/transforms/enhanceEndpoint/__testfixtures__/basic.input.js

@@ -0,0 +1,38 @@
+const withTags = api.enhanceEndpoints({
+    addTagTypes: ['tag1']
+});
+
+const mutation2 = 'mutation2';
+
+const withPartials = withTags.enhanceEndpoints({
+    endpoints: {
+        query1: {
+            providesTags: ['tag1']
+        },
+        mutation1(definition) {
+            definition.invalidatesTags = ['tag1']
+        },
+        [mutation2]: (definition) => {}
+    }
+})
+
+const tags = ['tag1']
+
+const withBoth = api.enhanceEndpoints({
+    addTagTypes: tags,
+    endpoints: {
+        ["query1"]: {
+            providesTags: ['tag1']
+        },
+    }
+})
+
+const addTagTypes = tags
+
+const chained = api
+    .enhanceEndpoints({
+        addTagTypes
+    })
+    .injectEndpoints({
+        endpoints: () => {}
+    })

packages/rtk-codemods/transforms/enhanceEndpoint/__testfixtures__/basic.output.js

@@ -0,0 +1,22 @@
+const withTags = api.addTagTypes('tag1');
+
+const mutation2 = 'mutation2';
+
+const withPartials = withTags.enhanceEndpoint("query1", {
+    providesTags: ['tag1']
+}).enhanceEndpoint("mutation1", (definition) => {
+    definition.invalidatesTags = ['tag1']
+}).enhanceEndpoint(mutation2, (definition) => {})
+
+const tags = ['tag1']
+
+const withBoth = api.addTagTypes(...tags).enhanceEndpoint("query1", {
+    providesTags: ['tag1']
+})
+
+const addTagTypes = tags
+
+const chained = api.addTagTypes(...addTagTypes)
+    .injectEndpoints({
+        endpoints: () => {}
+    })

packages/rtk-codemods/transforms/enhanceEndpoint/index.ts

@@ -0,0 +1,126 @@
+import type {
+  Transform,
+  MemberExpression,
+  ObjectExpression,
+  RestElement,
+  JSCodeshift
+} from 'jscodeshift'
+
+type Prop = Extract<
+  ObjectExpression['properties'][number],
+  { value: unknown }
+>['value']
+
+const createAddTagTypesCall = (
+  j: JSCodeshift,
+  object: MemberExpression['object'],
+  addTagTypes: Prop
+) => {
+  const newCall = j.callExpression(
+    j.memberExpression(object, j.identifier('addTagTypes')),
+    []
+  )
+  if (addTagTypes.type === 'Identifier') {
+    newCall.arguments.push(j.spreadElement(addTagTypes))
+  } else if (addTagTypes.type === 'ArrayExpression') {
+    newCall.arguments = addTagTypes.elements.filter(
+      (el): el is Exclude<typeof el, RestElement | null> =>
+        !!(el && el.type !== 'RestElement')
+    )
+  }
+  return newCall
+}
+
+const transform: Transform = (file, api) => {
+  const j = api.jscodeshift
+
+  const root = j(file.source)
+
+  return root
+    .find(j.CallExpression, {
+      callee: {
+        property: {
+          name: 'enhanceEndpoints'
+        }
+      }
+    })
+    .forEach((path) => {
+      const callee = path.value.callee as MemberExpression
+      const [config] = path.value.arguments
+      if (config.type === 'ObjectExpression') {
+        let addTagTypes: Prop | undefined = undefined
+        let endpoints: Prop | undefined = undefined
+        for (const property of config.properties) {
+          if (
+            (property.type === 'ObjectProperty' ||
+              property.type === 'Property') &&
+            property.key.type === 'Identifier'
+          ) {
+            switch (property.key.name) {
+              case 'addTagTypes':
+                addTagTypes = property.value
+                break
+              case 'endpoints':
+                endpoints = property.value
+                break
+            }
+          }
+        }
+        if (!endpoints) {
+          if (!addTagTypes) {
+            return
+          }
+          // no endpoints - we can go ahead and replace
+          path.replace(createAddTagTypesCall(j, callee.object, addTagTypes))
+        } else {
+          let calleeObject = addTagTypes
+            ? createAddTagTypesCall(j, callee.object, addTagTypes)
+            : callee.object
+          if (endpoints.type === 'ObjectExpression') {
+            for (const endpointProp of endpoints.properties) {
+              if (endpointProp.type === 'ObjectProperty') {
+                const endpointName =
+                  endpointProp.key.type === 'Identifier' &&
+                  !endpointProp.computed
+                    ? j.stringLiteral(endpointProp.key.name)
+                    : endpointProp.key
+                calleeObject = j.callExpression(
+                  j.memberExpression(
+                    calleeObject,
+                    j.identifier('enhanceEndpoint')
+                  ),
+                  [endpointName, endpointProp.value as any]
+                )
+              } else if (endpointProp.type === 'ObjectMethod') {
+                const endpointName =
+                  endpointProp.key.type === 'Identifier'
+                    ? j.stringLiteral(endpointProp.key.name)
+                    : endpointProp.key
+                calleeObject = j.callExpression(
+                  j.memberExpression(
+                    calleeObject,
+                    j.identifier('enhanceEndpoint')
+                  ),
+                  [
+                    endpointName,
+                    j.arrowFunctionExpression(
+                      endpointProp.params,
+                      endpointProp.body
+                    )
+                  ]
+                )
+              }
+            }
+          }
+          path.replace(calleeObject)
+        }
+      }
+    })
+    .toSource({
+      arrowParensAlways: true
+    })
+}
+
+export const parser = 'tsx'
+
+export default transform

packages/rtk-codemods/transforms/enhanceEndpoint/test.js

@@ -0,0 +1,9 @@
+'use strict'
+
+const { runTransformTest } = require('codemod-cli')
+
+runTransformTest({
+  name: 'enhanceEndpoint',
+  path: require.resolve('./index.ts'),
+  fixtureDir: `${__dirname}/__testfixtures__/`
+})

packages/rtk-query-codegen-openapi/src/codegen.ts

@@ -53,10 +53,6 @@ export function generateCreateApiCall({
     true
   );
   if (tag) {
-    const enhanceEndpointsObjectLiteralExpression = factory.createObjectLiteralExpression(
-      [factory.createShorthandPropertyAssignment(factory.createIdentifier('addTagTypes'), undefined)],
-      true
-    );
     return factory.createVariableStatement(
       undefined,
       factory.createVariableDeclarationList(
@@ -70,10 +66,10 @@ export function generateCreateApiCall({
                 factory.createCallExpression(
                   factory.createPropertyAccessExpression(
                     factory.createIdentifier('api'),
-                    factory.createIdentifier('enhanceEndpoints')
+                    factory.createIdentifier('addTagTypes')
                   ),
                   undefined,
-                  [enhanceEndpointsObjectLiteralExpression]
+                  [factory.createSpreadElement(factory.createIdentifier('addTagTypes'))]
                 ),
                 factory.createIdentifier('injectEndpoints')
               ),