@7nohe/openapi-react-query-codegen 0.0.0-13d458778df8db161111e788ed4207a13a110724

package/README.md

@@ -0,0 +1,300 @@
+# OpenAPI React Query Codegen
+
+> Node.js library that generates [React Query (also called TanStack Query)](https://tanstack.com/query) hooks based on an OpenAPI specification file.
+
+[![npm version](https://badge.fury.io/js/%407nohe%2Fopenapi-react-query-codegen.svg)](https://badge.fury.io/js/%407nohe%2Fopenapi-react-query-codegen)
+
+## Features
+
+- Generates custom react hooks that use React Query's `useQuery`, `useSuspenseQuery` and `useMutation` hooks
+- Generates query keys and functions for query caching
+- Generates pure TypeScript clients generated by [@hey-api/openapi-ts](https://github.com/hey-api/openapi-ts)
+
+## Installation
+
+```
+$ npm install -D @7nohe/openapi-react-query-codegen
+```
+
+Register the command to the `scripts` property in your package.json file.
+
+```json
+{
+  "scripts": {
+    "codegen": "openapi-rq -i ./petstore.yaml -c @hey-api/client-fetch"
+  }
+}
+```
+
+You can also run the command without installing it in your project using the npx command.
+
+```bash
+$ npx --package @7nohe/openapi-react-query-codegen openapi-rq -i ./petstore.yaml -c @hey-api/client-fetch
+```
+
+## Usage
+
+```
+$ openapi-rq --help
+
+Usage: openapi-rq [options]
+
+Generate React Query code based on OpenAPI
+
+Options:
+  -V, --version              output the version number
+  -i, --input <value>        OpenAPI specification, can be a path, url or string content (required)
+  -o, --output <value>       Output directory (default: "openapi")
+  -c, --client <value>       HTTP client to generate [@hey-api/client-fetch, @hey-api/client-axios] (default: "@hey-api/client-fetch")
+  --request <value>          Path to custom request file
+  --format <value>           Process output folder with formatter? ['biome', 'prettier']
+  --lint   <value>           Process output folder with linter? ['eslint', 'biome']
+  --operationId              Use operation ID to generate operation names?
+  --serviceResponse <value>  Define shape of returned value from service calls ['body', 'response'] (default: "body")
+  --base <value>             Manually set base in OpenAPI config instead of inferring from server value
+  --enums <value>            Generate JavaScript objects from enum definitions? ['javascript', 'typescript']
+  --useDateType              Use Date type instead of string for date types for models, this will not convert the data to a Date object
+  --debug                    Enable debug mode
+  --noSchemas                Disable generating schemas for request and response objects
+  --schemaTypes <value>      Define the type of schema generation ['form', 'json'] (default: "json")
+  -h, --help                 display help for command
+```
+
+### Example Usage
+
+#### Command
+
+```
+$ openapi-rq -i ./petstore.yaml
+```
+
+#### Output directory structure
+
+```
+- openapi
+  - queries
+    - index.ts <- main file that exports common types, variables, and queries. Does not export suspense or prefetch hooks
+    - common.ts <- common types
+    - queries.ts <- generated query hooks
+    - suspenses.ts <- generated suspense hooks
+    - prefetch.ts <- generated prefetch hooks learn more about prefetching in in link below
+  - requests <- output code generated by @hey-api/openapi-ts
+```
+
+- [Prefetching docs](https://tanstack.com/query/latest/docs/framework/react/guides/advanced-ssr#prefetching-and-dehydrating-data)
+
+#### In your app
+
+##### Using the generated hooks
+
+```tsx
+// App.tsx
+import { usePetServiceFindPetsByStatus } from "../openapi/queries";
+function App() {
+  const { data } = usePetServiceFindPetsByStatus({ status: ["available"] });
+
+  return (
+    <div className="App">
+      <h1>Pet List</h1>
+      <ul>{data?.map((pet) => <li key={pet.id}>{pet.name}</li>)}</ul>
+    </div>
+  );
+}
+
+export default App;
+```
+
+##### Using the generated typescript client
+
+```tsx
+import { useQuery } from "@tanstack/react-query";
+import { PetService } from "../openapi/requests/services";
+import { usePetServiceFindPetsByStatusKey } from "../openapi/queries";
+
+function App() {
+  // You can still use the auto-generated query key
+  const { data } = useQuery({
+    queryKey: [usePetServiceFindPetsByStatusKey],
+    queryFn: () => {
+      // Do something here
+      return PetService.findPetsByStatus(["available"]);
+    },
+  });
+
+  return <div className="App">{/* .... */}</div>;
+}
+
+export default App;
+```
+
+##### Using Suspense Hooks
+
+```tsx
+// App.tsx
+import { useDefaultClientFindPetsSuspense } from "../openapi/queries/suspense";
+function ChildComponent() {
+  const { data } = useDefaultClientFindPetsSuspense({ tags: [], limit: 10 });
+
+  return <ul>{data?.map((pet, index) => <li key={pet.id}>{pet.name}</li>)}</ul>;
+}
+
+function ParentComponent() {
+  return (
+    <>
+      <Suspense fallback={<>loading...</>}>
+        <ChildComponent />
+      </Suspense>
+    </>
+  );
+}
+
+function App() {
+  return (
+    <div className="App">
+      <h1>Pet List</h1>
+      <ParentComponent />
+    </div>
+  );
+}
+
+export default App;
+```
+
+##### Using Mutation hooks
+
+```tsx
+// App.tsx
+import { usePetServiceAddPet } from "../openapi/queries";
+
+function App() {
+  const { mutate } = usePetServiceAddPet();
+
+  const handleAddPet = () => {
+    mutate({ name: "Fluffy", status: "available" });
+  };
+
+  return (
+    <div className="App">
+      <h1>Add Pet</h1>
+      <button onClick={handleAddPet}>Add Pet</button>
+    </div>
+  );
+}
+
+export default App;
+```
+
+##### Invalidating queries after mutation
+
+Invalidating queries after a mutation is important to ensure the cache is updated with the new data. This is done by calling the `queryClient.invalidateQueries` function with the query key used by the query hook.
+
+Learn more about invalidating queries [here](https://tanstack.com/query/latest/docs/framework/react/guides/query-invalidation).
+
+To ensure the query key is created the same way as the query hook, you can use the query key function exported by the generated query hooks.
+
+```tsx
+import {
+  usePetServiceFindPetsByStatus,
+  usePetServiceAddPet,
+  UsePetServiceFindPetsByStatusKeyFn,
+} from "../openapi/queries";
+
+// App.tsx
+function App() {
+  const [status, setStatus] = React.useState(["available"]);
+  const { data } = usePetServiceFindPetsByStatus({ status });
+  const { mutate } = usePetServiceAddPet({
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        // Call the query key function to get the query key
+        // This is important to ensure the query key is created the same way as the query hook
+        // This insures the cache is invalidated correctly and is typed correctly
+        queryKey: [UsePetServiceFindPetsByStatusKeyFn({
+          status
+        })],
+      });
+    },
+  });
+
+  return (
+    <div className="App">
+      <h1>Pet List</h1>
+      <ul>{data?.map((pet) => <li key={pet.id}>{pet.name}</li>)}</ul>
+      <button
+        onClick={() => {
+          mutate({ name: "Fluffy", status: "available" });
+        }}
+      >
+        Add Pet
+      </button>
+    </div>
+  );
+}
+
+export default App;
+```
+
+##### Runtime Configuration
+
+You can modify the default values used by the generated service calls by modifying the OpenAPI configuration singleton object.
+
+It's default location is `openapi/requests/core/OpenAPI.ts` and it is also exported from `openapi/index.ts`
+
+Import the constant into your runtime and modify it before setting up the react app.
+
+```typescript
+/** main.tsx */
+import { OpenAPI as OpenAPIConfig } from './openapi/requests/core/OpenAPI';
+...
+OpenAPIConfig.BASE = 'www.domain.com/api';
+OpenAPIConfig.HEADERS = {
+  'x-header-1': 'value-1',
+  'x-header-2': 'value-2',
+};
+...
+ReactDOM.createRoot(document.getElementById("root") as HTMLElement).render(
+  <React.StrictMode>
+    <QueryClientProvider client={queryClient}>
+      <App />
+    </QueryClientProvider>
+  </React.StrictMode>
+);
+
+```
+
+## Development
+
+### Install dependencies
+
+```bash
+pnpm install
+```
+
+### Run tests
+```bash
+pnpm test
+```
+
+### Run linter
+```bash
+pnpm lint
+```
+
+### Run linter and fix
+```bash
+pnpm lint:fix
+```
+
+### Update snapshots
+```bash
+pnpm snapshot
+```
+
+### Build example and validate generated code
+```bash
+npm run build && pnpm --filter @7nohe/react-app generate:api && pnpm --filter @7nohe/react-app test:generated 
+```
+
+## License
+
+MIT

package/dist/cli.mjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Command, Option } from "commander";
+import { defaultOutputPath } from "./constants.mjs";
+import { generate } from "./generate.mjs";
+const program = new Command();
+async function setupProgram() {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const file = await readFile(join(__dirname, "../package.json"), "utf-8");
+    const packageJson = JSON.parse(file);
+    const version = packageJson.version;
+    program
+        .name("openapi-rq")
+        .version(version)
+        .description("Generate React Query code based on OpenAPI")
+        .requiredOption("-i, --input <value>", "OpenAPI specification, can be a path, url or string content (required)")
+        .option("-o, --output <value>", "Output directory", defaultOutputPath)
+        .addOption(new Option("-c, --client <value>", "HTTP client to generate")
+        .choices(["@hey-api/client-fetch", "@hey-api/client-axios"])
+        .default("@hey-api/client-fetch"))
+        .option("--request <value>", "Path to custom request file")
+        .addOption(new Option("--format <value>", "Process output folder with formatter?").choices(["biome", "prettier"]))
+        .addOption(new Option("--lint <value>", "Process output folder with linter?").choices(["biome", "eslint"]))
+        .option("--operationId", "Use operation ID to generate operation names?")
+        .addOption(new Option("--serviceResponse <value>", "Define shape of returned value from service calls")
+        .choices(["body", "response"])
+        .default("body"))
+        .option("--base <value>", "Manually set base in OpenAPI config instead of inferring from server value")
+        .addOption(new Option("--enums <value>", "Generate JavaScript objects from enum definitions?").choices(["javascript", "typescript"]))
+        .option("--useDateType", "Use Date type instead of string for date types for models, this will not convert the data to a Date object")
+        .option("--debug", "Run in debug mode?")
+        .option("--noSchemas", "Disable generating JSON schemas")
+        .addOption(new Option("--schemaType <value>", "Type of JSON schema [Default: 'json']").choices(["form", "json"]))
+        .parse();
+    const options = program.opts();
+    await generate(options, version);
+}
+setupProgram();

package/dist/common.mjs

@@ -0,0 +1,151 @@
+import { stat } from "node:fs/promises";
+import path from "node:path";
+import { ArrowFunction } from "ts-morph";
+import ts from "typescript";
+import { queriesOutputPath, requestsOutputPath } from "./constants.mjs";
+export const TData = ts.factory.createIdentifier("TData");
+export const TError = ts.factory.createIdentifier("TError");
+export const TContext = ts.factory.createIdentifier("TContext");
+export const EqualsOrGreaterThanToken = ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken);
+export const QuestionToken = ts.factory.createToken(ts.SyntaxKind.QuestionToken);
+export const queryKeyGenericType = ts.factory.createTypeReferenceNode("TQueryKey");
+export const queryKeyConstraint = ts.factory.createTypeReferenceNode("Array", [
+    ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword),
+]);
+export const capitalizeFirstLetter = (str) => {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+};
+export const lowercaseFirstLetter = (str) => {
+    return str.charAt(0).toLowerCase() + str.slice(1);
+};
+export const getVariableArrowFunctionParameters = (variable) => {
+    const initializer = variable.getInitializer();
+    if (!initializer) {
+        throw new Error("Initializer not found");
+    }
+    if (!ArrowFunction.isArrowFunction(initializer)) {
+        throw new Error("Initializer is not an arrow function");
+    }
+    return initializer.getParameters();
+};
+export const getNameFromVariable = (variable) => {
+    const variableName = variable.getName();
+    if (!variableName) {
+        throw new Error("Variable name not found");
+    }
+    return variableName;
+};
+export async function exists(f) {
+    try {
+        await stat(f);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const Common = "Common";
+/**
+ * Build a common type name by prepending the Common namespace.
+ */
+export function BuildCommonTypeName(name) {
+    if (typeof name === "string") {
+        return ts.factory.createIdentifier(`${Common}.${name}`);
+    }
+    return ts.factory.createIdentifier(`${Common}.${name.text}`);
+}
+/**
+ * Safely parse a value into a number. Checks for NaN and Infinity.
+ * Returns NaN if the string is not a valid number.
+ * @param value The value to parse.
+ * @returns The parsed number or NaN if the value is not a valid number.
+ */
+export function safeParseNumber(value) {
+    const parsed = Number(value);
+    if (!Number.isNaN(parsed) && Number.isFinite(parsed)) {
+        return parsed;
+    }
+    return Number.NaN;
+}
+export function extractPropertiesFromObjectParam(param) {
+    const referenced = param.findReferences()[0];
+    const def = referenced.getDefinition();
+    const paramNodes = def
+        .getNode()
+        .getType()
+        .getProperties()
+        .filter((prop) => prop.getValueDeclaration()?.getType())
+        .map((prop) => {
+        return {
+            name: prop.getName(),
+            optional: prop.isOptional(),
+            type: prop.getValueDeclaration()?.getType(),
+        };
+    });
+    return paramNodes;
+}
+/**
+ * Replace the import("...") surrounding the type if there is one.
+ * This can happen when the type is imported from another file, but
+ * we are already importing all the types from that file.
+ *
+ * https://regex101.com/r/3DyHaQ/1
+ *
+ * TODO: Replace with a more robust solution.
+ */
+export function getShortType(type) {
+    return type.replaceAll(/import\(".*"\)\./g, "");
+}
+export function getClassesFromService(node) {
+    const klasses = node.getClasses();
+    if (!klasses.length) {
+        throw new Error("No classes found");
+    }
+    return klasses.map((klass) => {
+        const className = klass.getName();
+        if (!className) {
+            throw new Error("Class name not found");
+        }
+        return {
+            className,
+            klass,
+        };
+    });
+}
+export function getClassNameFromClassNode(klass) {
+    const className = klass.getName();
+    if (!className) {
+        throw new Error("Class name not found");
+    }
+    return className;
+}
+export function formatOptions(options) {
+    // loop through properties on the options object
+    // if the property is a string of number then convert it to a number
+    // if the property is a string of boolean then convert it to a boolean
+    const formattedOptions = Object.entries(options).reduce((acc, [key, value]) => {
+        const typedKey = key;
+        const typedValue = value;
+        const parsedNumber = safeParseNumber(typedValue);
+        if (value === "true" || value === true) {
+            acc[typedKey] = true;
+        }
+        else if (value === "false" || value === false) {
+            acc[typedKey] = false;
+        }
+        else if (!Number.isNaN(parsedNumber)) {
+            acc[typedKey] = parsedNumber;
+        }
+        else {
+            acc[typedKey] = typedValue;
+        }
+        return acc;
+    }, options);
+    return formattedOptions;
+}
+export function buildRequestsOutputPath(outputPath) {
+    return path.join(outputPath, requestsOutputPath);
+}
+export function buildQueriesOutputPath(outputPath) {
+    return path.join(outputPath, queriesOutputPath);
+}

package/dist/constants.mjs

@@ -0,0 +1,12 @@
+export const defaultOutputPath = "openapi";
+export const queriesOutputPath = "queries";
+export const requestsOutputPath = "requests";
+export const serviceFileName = "services.gen";
+export const modalsFileName = "types.gen";
+export const OpenApiRqFiles = {
+    queries: "queries",
+    common: "common",
+    suspense: "suspense",
+    index: "index",
+    prefetch: "prefetch",
+};

package/dist/createExports.mjs

@@ -0,0 +1,66 @@
+import { createPrefetch } from "./createPrefetch.mjs";
+import { createUseMutation } from "./createUseMutation.mjs";
+import { createUseQuery } from "./createUseQuery.mjs";
+export const createExports = (service) => {
+    const { methods } = service;
+    // const methods = klasses.flatMap((k) => k.methods);
+    const allGet = methods.filter((m) => m.httpMethodName.toUpperCase().includes("GET"));
+    const allPost = methods.filter((m) => m.httpMethodName.toUpperCase().includes("POST"));
+    const allPut = methods.filter((m) => m.httpMethodName.toUpperCase().includes("PUT"));
+    const allPatch = methods.filter((m) => m.httpMethodName.toUpperCase().includes("PATCH"));
+    const allDelete = methods.filter((m) => m.httpMethodName.toUpperCase().includes("DELETE"));
+    const allGetQueries = allGet.map((m) => createUseQuery(m));
+    const allPrefetchQueries = allGet.map((m) => createPrefetch(m));
+    const allPostMutations = allPost.map((m) => createUseMutation(m));
+    const allPutMutations = allPut.map((m) => createUseMutation(m));
+    const allPatchMutations = allPatch.map((m) => createUseMutation(m));
+    const allDeleteMutations = allDelete.map((m) => createUseMutation(m));
+    const allQueries = [...allGetQueries];
+    const allMutations = [
+        ...allPostMutations,
+        ...allPutMutations,
+        ...allPatchMutations,
+        ...allDeleteMutations,
+    ];
+    const commonInQueries = allQueries.flatMap(({ apiResponse, returnType, key, queryKeyFn }) => [
+        apiResponse,
+        returnType,
+        key,
+        queryKeyFn,
+    ]);
+    const commonInMutations = allMutations.flatMap(({ mutationResult }) => [
+        mutationResult,
+    ]);
+    const allCommon = [...commonInQueries, ...commonInMutations];
+    const mainQueries = allQueries.flatMap(({ queryHook }) => [queryHook]);
+    const mainMutations = allMutations.flatMap(({ mutationHook }) => [
+        mutationHook,
+    ]);
+    const mainExports = [...mainQueries, ...mainMutations];
+    const suspenseQueries = allQueries.flatMap(({ suspenseQueryHook }) => [
+        suspenseQueryHook,
+    ]);
+    const suspenseExports = [...suspenseQueries];
+    const allPrefetches = allPrefetchQueries.flatMap(({ prefetchHook }) => [
+        prefetchHook,
+    ]);
+    const allPrefetchExports = [...allPrefetches];
+    return {
+        /**
+         * Common types and variables between queries (regular and suspense) and mutations
+         */
+        allCommon,
+        /**
+         * Main exports are the hooks that are used in the components
+         */
+        mainExports,
+        /**
+         * Suspense exports are the hooks that are used in the suspense components
+         */
+        suspenseExports,
+        /**
+         * Prefetch exports are the hooks that are used in the prefetch components
+         */
+        allPrefetchExports,
+    };
+};

package/dist/createImports.mjs

@@ -0,0 +1,43 @@
+import { posix } from "node:path";
+import ts from "typescript";
+import { modalsFileName, serviceFileName } from "./constants.mjs";
+const { join } = posix;
+export const createImports = ({ project, }) => {
+    const modelsFile = project
+        .getSourceFiles()
+        .find((sourceFile) => sourceFile.getFilePath().includes(modalsFileName));
+    const serviceFile = project.getSourceFileOrThrow(`${serviceFileName}.ts`);
+    if (!modelsFile) {
+        console.warn(`
+⚠️ WARNING: No models file found.
+  This may be an error if \`.components.schemas\` or \`.components.parameters\` is defined in your OpenAPI input.`);
+    }
+    const modelNames = modelsFile
+        ? Array.from(modelsFile.getExportedDeclarations().keys())
+        : [];
+    const serviceExports = Array.from(serviceFile.getExportedDeclarations().keys());
+    const serviceNames = serviceExports;
+    const imports = [
+        ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([
+            ts.factory.createImportSpecifier(true, undefined, ts.factory.createIdentifier("QueryClient")),
+            ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("useQuery")),
+            ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("useSuspenseQuery")),
+            ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("useMutation")),
+            ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("UseQueryResult")),
+            ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("UseQueryOptions")),
+            ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("UseMutationOptions")),
+            ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("UseMutationResult")),
+        ])), ts.factory.createStringLiteral("@tanstack/react-query"), undefined),
+        ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([
+            // import all class names from service file
+            ...serviceNames.map((serviceName) => ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(serviceName))),
+        ])), ts.factory.createStringLiteral(join("../requests", serviceFileName)), undefined),
+    ];
+    if (modelsFile) {
+        // import all the models by name
+        imports.push(ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([
+            ...modelNames.map((modelName) => ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(modelName))),
+        ])), ts.factory.createStringLiteral(join("../requests/", modalsFileName)), undefined));
+    }
+    return imports;
+};

package/dist/createPrefetch.mjs

@@ -0,0 +1,48 @@
+import ts from "typescript";
+import { BuildCommonTypeName, extractPropertiesFromObjectParam, getNameFromVariable, getVariableArrowFunctionParameters, } from "./common.mjs";
+import { createQueryKeyFromMethod, getQueryKeyFnName, getRequestParamFromMethod, hookNameFromMethod, } from "./createUseQuery.mjs";
+import { addJSDocToNode } from "./util.mjs";
+/**
+ * Creates a prefetch function for a query
+ */
+function createPrefetchHook({ requestParams, method, }) {
+    const methodName = getNameFromVariable(method);
+    const queryName = hookNameFromMethod({ method });
+    const customHookName = `prefetch${queryName.charAt(0).toUpperCase() + queryName.slice(1)}`;
+    const queryKey = createQueryKeyFromMethod({ method });
+    // const
+    const hookExport = ts.factory.createVariableStatement(
+    // export
+    [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
+        ts.factory.createVariableDeclaration(ts.factory.createIdentifier(customHookName), undefined, undefined, ts.factory.createArrowFunction(undefined, undefined, [
+            ts.factory.createParameterDeclaration(undefined, undefined, "queryClient", undefined, ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("QueryClient"))),
+            ...requestParams,
+        ], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createCallExpression(ts.factory.createIdentifier("queryClient.prefetchQuery"), undefined, [
+            ts.factory.createObjectLiteralExpression([
+                ts.factory.createPropertyAssignment(ts.factory.createIdentifier("queryKey"), ts.factory.createCallExpression(BuildCommonTypeName(getQueryKeyFnName(queryKey)), undefined, getVariableArrowFunctionParameters(method).length
+                    ? [
+                        ts.factory.createObjectLiteralExpression(getVariableArrowFunctionParameters(method).flatMap((param) => extractPropertiesFromObjectParam(param).map((p) => ts.factory.createShorthandPropertyAssignment(ts.factory.createIdentifier(p.name))))),
+                    ]
+                    : [])),
+                ts.factory.createPropertyAssignment(ts.factory.createIdentifier("queryFn"), ts.factory.createArrowFunction(undefined, undefined, [], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createCallExpression(ts.factory.createIdentifier(methodName), undefined, getVariableArrowFunctionParameters(method).length
+                    ? [
+                        ts.factory.createObjectLiteralExpression(getVariableArrowFunctionParameters(method).flatMap((param) => extractPropertiesFromObjectParam(param).map((p) => ts.factory.createShorthandPropertyAssignment(ts.factory.createIdentifier(p.name))))),
+                    ]
+                    : undefined))),
+            ]),
+        ]))),
+    ], ts.NodeFlags.Const));
+    return hookExport;
+}
+export const createPrefetch = ({ method, jsDoc }) => {
+    const requestParam = getRequestParamFromMethod(method);
+    const requestParams = requestParam ? [requestParam] : [];
+    const prefetchHook = createPrefetchHook({
+        requestParams,
+        method,
+    });
+    const hookWithJsDoc = addJSDocToNode(prefetchHook, jsDoc);
+    return {
+        prefetchHook: hookWithJsDoc,
+    };
+};