Codegen: update hooks to accept a boolean or granular config object (#1953)

* Add LazyQuery hooks to generateEndpoints

* Add granular hook generation config

* docs

* Update snapshots

Co-authored-by: Lenz Weber <lenz.weber@mayflower.de>

Author: msutkowski

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

@@ -87,7 +87,9 @@ interface SimpleUsage {
   exportName?: string
   argSuffix?: string
   responseSuffix?: string
-  hooks?: boolean
+  hooks?:
+    | boolean
+    | { queries: boolean; lazyQueries: boolean; mutations: boolean }
   outputFile: string
   filterEndpoints?:
     | string
@@ -131,6 +133,10 @@ const withOverride: ConfigFile = {
 }
 ```
 
+#### Generating hooks
+
+Setting `hooks: true` will generate `useQuery` and `useMuation` hook exports. If you also want `useLazyQuery` hooks generated or more granular control, you can also pass an object in the shape of: `{ queries: boolean; lazyQueries: boolean; mutations: boolean }`.
+
 #### Multiple output files
 
 ```ts no-transpile title="openapi-config.ts"

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

@@ -142,7 +142,14 @@ export async function generateApi(
         ...Object.values(interfaces),
         ...apiGen['aliases'],
         ...(hooks
-          ? [generateReactHooks({ exportName: generatedApiName, operationDefinitions, endpointOverrides })]
+          ? [
+              generateReactHooks({
+                exportName: generatedApiName,
+                operationDefinitions,
+                endpointOverrides,
+                config: hooks,
+              }),
+            ]
           : []),
       ],
       factory.createToken(ts.SyntaxKind.EndOfFileToken),

packages/rtk-query-codegen-openapi/src/generators/react-hooks.ts

@@ -1,49 +1,87 @@
 import ts from 'typescript';
 import { getOperationName } from '@rtk-query/oazapfts-patched/lib/codegen/generate';
 import { capitalize, isQuery } from '../utils';
-import type { OperationDefinition, EndpointOverrides } from '../types';
+import type { OperationDefinition, EndpointOverrides, ConfigFile } from '../types';
 import { getOverrides } from '../generate';
 import { factory } from '../utils/factory';
 
+type HooksConfigOptions = NonNullable<ConfigFile['hooks']>;
+
 type GetReactHookNameParams = {
   operationDefinition: OperationDefinition;
   endpointOverrides: EndpointOverrides[] | undefined;
+  config: HooksConfigOptions;
 };
 
-const getReactHookName = ({
-  operationDefinition: { verb, path, operation },
-  operationDefinition,
-  endpointOverrides,
-}: GetReactHookNameParams) => {
-  const overrides = getOverrides(operationDefinition, endpointOverrides);
+type CreateBindingParams = {
+  operationDefinition: OperationDefinition;
+  overrides?: EndpointOverrides;
+  isLazy?: boolean;
+};
 
-  return factory.createBindingElement(
+const createBinding = ({
+  operationDefinition: { verb, path, operation },
+  overrides,
+  isLazy = false,
+}: CreateBindingParams) =>
+  factory.createBindingElement(
     undefined,
     undefined,
     factory.createIdentifier(
-      `use${capitalize(getOperationName(verb, path, operation.operationId))}${
+      `use${isLazy ? 'Lazy' : ''}${capitalize(getOperationName(verb, path, operation.operationId))}${
         isQuery(verb, overrides) ? 'Query' : 'Mutation'
       }`
     ),
     undefined
   );
+
+const getReactHookName = ({ operationDefinition, endpointOverrides, config }: GetReactHookNameParams) => {
+  const overrides = getOverrides(operationDefinition, endpointOverrides);
+
+  const baseParams = {
+    operationDefinition,
+    overrides,
+  };
+
+  const _isQuery = isQuery(operationDefinition.verb, overrides);
+
+  // If `config` is true, just generate everything
+  if (typeof config === 'boolean') {
+    return createBinding(baseParams);
+  }
+
+  // `config` is an object and we need to check for the configuration of each property
+  if (_isQuery) {
+    return [
+      ...(config.queries ? [createBinding(baseParams)] : []),
+      ...(config.lazyQueries ? [createBinding({ ...baseParams, isLazy: true })] : []),
+    ];
+  }
+
+  return config.mutations ? createBinding(baseParams) : [];
 };
 
 type GenerateReactHooksParams = {
   exportName: string;
   operationDefinitions: OperationDefinition[];
   endpointOverrides: EndpointOverrides[] | undefined;
+  config: HooksConfigOptions;
 };
-export const generateReactHooks = ({ exportName, operationDefinitions, endpointOverrides }: GenerateReactHooksParams) =>
+export const generateReactHooks = ({
+  exportName,
+  operationDefinitions,
+  endpointOverrides,
+  config,
+}: GenerateReactHooksParams) =>
   factory.createVariableStatement(
     [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
     factory.createVariableDeclarationList(
       [
         factory.createVariableDeclaration(
           factory.createObjectBindingPattern(
-            operationDefinitions.map((operationDefinition) =>
-              getReactHookName({ operationDefinition, endpointOverrides })
-            )
+            operationDefinitions
+              .map((operationDefinition) => getReactHookName({ operationDefinition, endpointOverrides, config }))
+              .flat()
           ),
           undefined,
           undefined,

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

@@ -2,7 +2,7 @@ import path from 'path';
 import fs from 'fs';
 import type { CommonOptions, ConfigFile, GenerationOptions, OutputFileOptions } from './types';
 import { isValidUrl, prettify } from './utils';
-export { ConfigFile } from './types';
+export type { ConfigFile } from './types';
 
 export async function generateEndpoints(options: GenerationOptions): Promise<string | void> {
   const schemaLocation = options.schemaFile;

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

@@ -1,4 +1,3 @@
-import * as ts from 'typescript';
 import type { OpenAPIV3 } from 'openapi-types';
 
 export type OperationDefinition = {
@@ -48,9 +47,10 @@ export interface CommonOptions {
    */
   responseSuffix?: string;
   /**
-   * defaults to false
+   * defaults to `false`
+   * `true` will generate hooks for queries and mutations, but no lazyQueries
    */
-  hooks?: boolean;
+  hooks?: boolean | { queries: boolean; lazyQueries: boolean; mutations: boolean };
 
   /**
    * defaults to false