@7nohe/openapi-react-query-codegen 1.6.1 → 2.0.0-beta.1

package/dist/createImports.mjs

@@ -1,11 +1,11 @@
 import { posix } from "node:path";
 import ts from "typescript";
-import { modalsFileName, serviceFileName } from "./constants.mjs";
+import { modelsFileName, serviceFileName } from "./constants.mjs";
 const { join } = posix;
-export const createImports = ({ serviceEndName, project, }) => {
+export const createImports = ({ project, client, }) => {
     const modelsFile = project
         .getSourceFiles()
-        .find((sourceFile) => sourceFile.getFilePath().includes(modalsFileName));
+        .find((sourceFile) => sourceFile.getFilePath().includes(modelsFileName));
     const serviceFile = project.getSourceFileOrThrow(`${serviceFileName}.ts`);
     if (!modelsFile) {
         console.warn(`
@@ -16,7 +16,7 @@ export const createImports = ({ serviceEndName, project, }) => {
         ? Array.from(modelsFile.getExportedDeclarations().keys())
         : [];
     const serviceExports = Array.from(serviceFile.getExportedDeclarations().keys());
-    const serviceNames = serviceExports.filter((name) => name.endsWith(serviceEndName));
+    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")),
@@ -37,7 +37,12 @@ export const createImports = ({ serviceEndName, project, }) => {
         // 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));
+        ])), ts.factory.createStringLiteral(join("../requests/", modelsFileName)), undefined));
+    }
+    if (client === "@hey-api/client-axios") {
+        imports.push(ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([
+            ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("AxiosError")),
+        ])), ts.factory.createStringLiteral("axios")));
     }
     return imports;
 };

package/dist/createPrefetchOrEnsure.mjs

@@ -0,0 +1,56 @@
+import ts from "typescript";
+import { BuildCommonTypeName, EqualsOrGreaterThanToken, getNameFromVariable, getQueryKeyFnName, getRequestParamFromMethod, getVariableArrowFunctionParameters, } from "./common.mjs";
+import { createQueryKeyFromMethod, hookNameFromMethod, } from "./createUseQuery.mjs";
+import { addJSDocToNode } from "./util.mjs";
+/**
+ * Creates a prefetch/ensure function for a query
+ */
+function createPrefetchOrEnsureHook({ requestParams, method, functionType, }) {
+    const methodName = getNameFromVariable(method);
+    const queryName = hookNameFromMethod({ method });
+    let customHookName = `prefetch${queryName.charAt(0).toUpperCase() + queryName.slice(1)}`;
+    if (functionType === "ensure") {
+        customHookName = `ensure${queryName.charAt(0).toUpperCase() + queryName.slice(1)}Data`;
+    }
+    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, EqualsOrGreaterThanToken, ts.factory.createCallExpression(ts.factory.createIdentifier(`queryClient.${functionType === "prefetch" ? "prefetchQuery" : "ensureQueryData"}`), undefined, [
+            ts.factory.createObjectLiteralExpression([
+                ts.factory.createPropertyAssignment(ts.factory.createIdentifier("queryKey"), ts.factory.createCallExpression(BuildCommonTypeName(getQueryKeyFnName(queryKey)), undefined, [ts.factory.createIdentifier("clientOptions")])),
+                ts.factory.createPropertyAssignment(ts.factory.createIdentifier("queryFn"), ts.factory.createArrowFunction(undefined, undefined, [], undefined, EqualsOrGreaterThanToken, ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createCallExpression(ts.factory.createIdentifier(methodName), undefined, 
+                // { ...clientOptions }
+                getVariableArrowFunctionParameters(method).length
+                    ? [
+                        ts.factory.createObjectLiteralExpression([
+                            ts.factory.createSpreadAssignment(ts.factory.createIdentifier("clientOptions")),
+                        ]),
+                    ]
+                    : undefined), ts.factory.createIdentifier("then")), undefined, [
+                    ts.factory.createArrowFunction(undefined, undefined, [
+                        ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier("response"), undefined, undefined, undefined),
+                    ], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("response"), ts.factory.createIdentifier("data"))),
+                ]))),
+            ]),
+        ]))),
+    ], ts.NodeFlags.Const));
+    return hookExport;
+}
+export const createPrefetchOrEnsure = ({ method, jsDoc, functionType, modelNames, }) => {
+    const requestParam = getRequestParamFromMethod(method, undefined, modelNames);
+    const requestParams = requestParam ? [requestParam] : [];
+    const prefetchOrEnsureHook = createPrefetchOrEnsureHook({
+        requestParams,
+        method,
+        functionType,
+    });
+    const hookWithJsDoc = addJSDocToNode(prefetchOrEnsureHook, jsDoc);
+    return {
+        hook: hookWithJsDoc,
+    };
+};

package/dist/createSource.mjs

@@ -5,7 +5,7 @@ import { OpenApiRqFiles } from "./constants.mjs";
 import { createExports } from "./createExports.mjs";
 import { createImports } from "./createImports.mjs";
 import { getServices } from "./service.mjs";
-const createSourceFile = async (outputPath, serviceEndName, pageParam, nextPageParam, initialPageParam) => {
+const createSourceFile = async ({ outputPath, client, pageParam, nextPageParam, initialPageParam, }) => {
     const project = new Project({
         // Optionally specify compiler options, tsconfig.json, in-memory file system, and more here.
         // If you initialize with a tsconfig.json, then it will automatically populate the project
@@ -17,10 +17,17 @@ const createSourceFile = async (outputPath, serviceEndName, pageParam, nextPageP
     project.addSourceFilesAtPaths(`${sourceFiles}/**/*`);
     const service = await getServices(project);
     const imports = createImports({
-        serviceEndName,
         project,
+        client,
+    });
+    const exports = createExports({
+        service,
+        client,
+        project,
+        pageParam,
+        nextPageParam,
+        initialPageParam,
     });
-    const exports = createExports(service, pageParam, nextPageParam, initialPageParam);
     const commonSource = ts.factory.createSourceFile([...imports, ...exports.allCommon], ts.factory.createToken(ts.SyntaxKind.EndOfFileToken), ts.NodeFlags.None);
     const commonImport = ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, ts.factory.createIdentifier("* as Common"), undefined), ts.factory.createStringLiteral(`./${OpenApiRqFiles.common}`), undefined);
     const commonExport = ts.factory.createExportDeclaration(undefined, false, undefined, ts.factory.createStringLiteral(`./${OpenApiRqFiles.common}`), undefined);
@@ -30,6 +37,7 @@ const createSourceFile = async (outputPath, serviceEndName, pageParam, nextPageP
     const suspenseSource = ts.factory.createSourceFile([commonImport, ...imports, ...exports.suspenseExports], ts.factory.createToken(ts.SyntaxKind.EndOfFileToken), ts.NodeFlags.None);
     const indexSource = ts.factory.createSourceFile([commonExport, queriesExport], ts.factory.createToken(ts.SyntaxKind.EndOfFileToken), ts.NodeFlags.None);
     const prefetchSource = ts.factory.createSourceFile([commonImport, ...imports, ...exports.allPrefetchExports], ts.factory.createToken(ts.SyntaxKind.EndOfFileToken), ts.NodeFlags.None);
+    const ensureSource = ts.factory.createSourceFile([commonImport, ...imports, ...exports.allEnsures], ts.factory.createToken(ts.SyntaxKind.EndOfFileToken), ts.NodeFlags.None);
     return {
         commonSource,
         infiniteQueriesSource,
@@ -37,20 +45,28 @@ const createSourceFile = async (outputPath, serviceEndName, pageParam, nextPageP
         suspenseSource,
         indexSource,
         prefetchSource,
+        ensureSource,
     };
 };
-export const createSource = async ({ outputPath, version, serviceEndName, pageParam, nextPageParam, initialPageParam, }) => {
+export const createSource = async ({ outputPath, client, version, pageParam, nextPageParam, initialPageParam, }) => {
     const queriesFile = ts.createSourceFile(`${OpenApiRqFiles.queries}.ts`, "", ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
     const infiniteQueriesFile = ts.createSourceFile(`${OpenApiRqFiles.infiniteQueries}.ts`, "", ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
     const commonFile = ts.createSourceFile(`${OpenApiRqFiles.common}.ts`, "", ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
     const suspenseFile = ts.createSourceFile(`${OpenApiRqFiles.suspense}.ts`, "", ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
     const indexFile = ts.createSourceFile(`${OpenApiRqFiles.index}.ts`, "", ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
     const prefetchFile = ts.createSourceFile(`${OpenApiRqFiles.prefetch}.ts`, "", ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
+    const ensureQueryDataFile = ts.createSourceFile(`${OpenApiRqFiles.ensureQueryData}.ts`, "", ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
     const printer = ts.createPrinter({
         newLine: ts.NewLineKind.LineFeed,
         removeComments: false,
     });
-    const { commonSource, mainSource, infiniteQueriesSource, suspenseSource, indexSource, prefetchSource, } = await createSourceFile(outputPath, serviceEndName, pageParam, nextPageParam, initialPageParam);
+    const { commonSource, mainSource, infiniteQueriesSource, suspenseSource, indexSource, prefetchSource, ensureSource, } = await createSourceFile({
+        outputPath,
+        client,
+        pageParam,
+        nextPageParam,
+        initialPageParam,
+    });
     const comment = `// generated with @7nohe/openapi-react-query-codegen@${version} \n\n`;
     const commonResult = comment +
         printer.printNode(ts.EmitHint.Unspecified, commonSource, commonFile);
@@ -64,6 +80,8 @@ export const createSource = async ({ outputPath, version, serviceEndName, pagePa
         printer.printNode(ts.EmitHint.Unspecified, indexSource, indexFile);
     const prefetchResult = comment +
         printer.printNode(ts.EmitHint.Unspecified, prefetchSource, prefetchFile);
+    const enqureResult = comment +
+        printer.printNode(ts.EmitHint.Unspecified, ensureSource, ensureQueryDataFile);
     return [
         {
             name: `${OpenApiRqFiles.index}.ts`,
@@ -89,5 +107,9 @@ export const createSource = async ({ outputPath, version, serviceEndName, pagePa
             name: `${OpenApiRqFiles.prefetch}.ts`,
             content: prefetchResult,
         },
+        {
+            name: `${OpenApiRqFiles.ensureQueryData}.ts`,
+            content: enqureResult,
+        },
     ];
 };

package/dist/createUseMutation.mjs

@@ -1,38 +1,49 @@
 import ts from "typescript";
-import { BuildCommonTypeName, TContext, TData, TError, capitalizeFirstLetter, extractPropertiesFromObjectParam, getNameFromMethod, getShortType, } from "./common.mjs";
+import { BuildCommonTypeName, EqualsOrGreaterThanToken, TContext, TData, TError, capitalizeFirstLetter, createQueryKeyExport, createQueryKeyFnExport, getNameFromVariable, getQueryKeyFnName, getVariableArrowFunctionParameters, queryKeyConstraint, queryKeyGenericType, } from "./common.mjs";
+import { createQueryKeyFromMethod } from "./createUseQuery.mjs";
 import { addJSDocToNode } from "./util.mjs";
 /**
  *  Awaited<ReturnType<typeof myClass.myMethod>>
  */
-function generateAwaitedReturnType({ className, methodName, }) {
+function generateAwaitedReturnType({ methodName }) {
     return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("Awaited"), [
         ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("ReturnType"), [
-            ts.factory.createTypeQueryNode(ts.factory.createQualifiedName(ts.factory.createIdentifier(className), ts.factory.createIdentifier(methodName)), undefined),
+            ts.factory.createTypeQueryNode(ts.factory.createIdentifier(methodName), undefined),
         ]),
     ]);
 }
-export const createUseMutation = ({ className, method, jsDoc, }) => {
-    const methodName = getNameFromMethod(method);
+export const createUseMutation = ({ functionDescription: { method, jsDoc }, modelNames, client, }) => {
+    const methodName = getNameFromVariable(method);
+    const mutationKey = createQueryKeyFromMethod({ method });
     const awaitedResponseDataType = generateAwaitedReturnType({
-        className,
         methodName,
     });
-    const mutationResult = ts.factory.createTypeAliasDeclaration([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier(`${className}${capitalizeFirstLetter(methodName)}MutationResult`), undefined, awaitedResponseDataType);
+    const mutationResult = ts.factory.createTypeAliasDeclaration([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier(`${capitalizeFirstLetter(methodName)}MutationResult`), undefined, awaitedResponseDataType);
+    // `TData = Common.AddPetMutationResult`
     const responseDataType = ts.factory.createTypeParameterDeclaration(undefined, TData, undefined, ts.factory.createTypeReferenceNode(BuildCommonTypeName(mutationResult.name)));
-    const methodParameters = method.getParameters().length !== 0
-        ? ts.factory.createTypeLiteralNode(method.getParameters().flatMap((param) => {
-            const paramNodes = extractPropertiesFromObjectParam(param);
-            return paramNodes.map((refParam) => ts.factory.createPropertySignature(undefined, ts.factory.createIdentifier(refParam.name), refParam.optional
-                ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
-                : undefined, ts.factory.createTypeReferenceNode(getShortType(refParam.type?.getText(param) ?? ""))));
-        }))
+    // @hey-api/client-axios -> `TError = AxiosError<AddPetError>`
+    // @hey-api/client-fetch -> `TError = AddPetError`
+    const responseErrorType = ts.factory.createTypeParameterDeclaration(undefined, TError, undefined, client === "@hey-api/client-axios"
+        ? ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("AxiosError"), [
+            ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(`${capitalizeFirstLetter(methodName)}Error`)),
+        ])
+        : ts.factory.createTypeReferenceNode(`${capitalizeFirstLetter(methodName)}Error`));
+    const methodParameters = getVariableArrowFunctionParameters(method).length !== 0
+        ? ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("Options"), [
+            ts.factory.createTypeReferenceNode(modelNames.includes(`${capitalizeFirstLetter(methodName)}Data`)
+                ? `${capitalizeFirstLetter(methodName)}Data`
+                : "unknown"),
+            ts.factory.createLiteralTypeNode(ts.factory.createTrue()),
+        ])
         : ts.factory.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword);
     const exportHook = ts.factory.createVariableStatement([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
-        ts.factory.createVariableDeclaration(ts.factory.createIdentifier(`use${className}${capitalizeFirstLetter(methodName)}`), undefined, undefined, ts.factory.createArrowFunction(undefined, ts.factory.createNodeArray([
+        ts.factory.createVariableDeclaration(ts.factory.createIdentifier(`use${capitalizeFirstLetter(methodName)}`), undefined, undefined, ts.factory.createArrowFunction(undefined, ts.factory.createNodeArray([
             responseDataType,
-            ts.factory.createTypeParameterDeclaration(undefined, TError, undefined, ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword)),
+            responseErrorType,
+            ts.factory.createTypeParameterDeclaration(undefined, "TQueryKey", queryKeyConstraint, ts.factory.createArrayTypeNode(ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword))),
             ts.factory.createTypeParameterDeclaration(undefined, TContext, undefined, ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword)),
         ]), [
+            ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier("mutationKey"), ts.factory.createToken(ts.SyntaxKind.QuestionToken), queryKeyGenericType),
             ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier("options"), ts.factory.createToken(ts.SyntaxKind.QuestionToken), ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("Omit"), [
                 ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("UseMutationOptions"), [
                     ts.factory.createTypeReferenceNode(TData),
@@ -40,7 +51,10 @@ export const createUseMutation = ({ className, method, jsDoc, }) => {
                     methodParameters,
                     ts.factory.createTypeReferenceNode(TContext),
                 ]),
-                ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral("mutationFn")),
+                ts.factory.createUnionTypeNode([
+                    ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral("mutationKey")),
+                    ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral("mutationFn")),
+                ]),
             ]), undefined),
         ], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createCallExpression(ts.factory.createIdentifier("useMutation"), [
             ts.factory.createTypeReferenceNode(TData),
@@ -49,28 +63,29 @@ export const createUseMutation = ({ className, method, jsDoc, }) => {
             ts.factory.createTypeReferenceNode(TContext),
         ], [
             ts.factory.createObjectLiteralExpression([
-                ts.factory.createPropertyAssignment(ts.factory.createIdentifier("mutationFn"), ts.factory.createArrowFunction(undefined, undefined, method.getParameters().length !== 0
-                    ? [
-                        ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createObjectBindingPattern(method.getParameters().flatMap((param) => {
-                            const paramNodes = extractPropertiesFromObjectParam(param);
-                            return paramNodes.map((refParam) => ts.factory.createBindingElement(undefined, undefined, ts.factory.createIdentifier(refParam.name), undefined));
-                        })), undefined, undefined, undefined),
-                    ]
-                    : [], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createAsExpression(ts.factory.createAsExpression(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(className), ts.factory.createIdentifier(methodName)), undefined, method.getParameters().length !== 0
-                    ? [
-                        ts.factory.createObjectLiteralExpression(method.getParameters().flatMap((params) => {
-                            const paramNodes = extractPropertiesFromObjectParam(params);
-                            return paramNodes.map((refParam) => ts.factory.createShorthandPropertyAssignment(refParam.name));
-                        })),
-                    ]
-                    : []), ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword)), ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("Promise"), [ts.factory.createTypeReferenceNode(TData)])))),
+                ts.factory.createPropertyAssignment(ts.factory.createIdentifier("mutationKey"), ts.factory.createCallExpression(BuildCommonTypeName(getQueryKeyFnName(mutationKey)), undefined, [ts.factory.createIdentifier("mutationKey")])),
+                ts.factory.createPropertyAssignment(ts.factory.createIdentifier("mutationFn"), 
+                // (clientOptions) => addPet(clientOptions).then(response => response.data as TData) as unknown as Promise<TData>
+                ts.factory.createArrowFunction(undefined, undefined, [
+                    ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier("clientOptions"), undefined, undefined, undefined),
+                ], undefined, EqualsOrGreaterThanToken, ts.factory.createAsExpression(ts.factory.createAsExpression(ts.factory.createCallExpression(ts.factory.createIdentifier(methodName), undefined, getVariableArrowFunctionParameters(method).length >
+                    0
+                    ? [ts.factory.createIdentifier("clientOptions")]
+                    : undefined), ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword)), ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("Promise"), [ts.factory.createTypeReferenceNode(TData)])))),
                 ts.factory.createSpreadAssignment(ts.factory.createIdentifier("options")),
             ]),
         ]))),
     ], ts.NodeFlags.Const));
     const hookWithJsDoc = addJSDocToNode(exportHook, jsDoc);
+    const mutationKeyExport = createQueryKeyExport({
+        methodName,
+        queryKey: mutationKey,
+    });
+    const mutationKeyFn = createQueryKeyFnExport(mutationKey, method, "mutation");
     return {
         mutationResult,
+        key: mutationKeyExport,
         mutationHook: hookWithJsDoc,
+        mutationKeyFn,
     };
 };

package/dist/createUseQuery.mjs

@@ -1,18 +1,23 @@
 import ts from "typescript";
-import { BuildCommonTypeName, EqualsOrGreaterThanToken, QuestionToken, TData, TError, capitalizeFirstLetter, extractPropertiesFromObjectParam, getNameFromMethod, getShortType, queryKeyConstraint, queryKeyGenericType, } from "./common.mjs";
+import { BuildCommonTypeName, EqualsOrGreaterThanToken, TData, TError, capitalizeFirstLetter, createQueryKeyExport, createQueryKeyFnExport, getNameFromVariable, getQueryKeyFnName, getRequestParamFromMethod, getVariableArrowFunctionParameters, queryKeyConstraint, queryKeyGenericType, } from "./common.mjs";
 import { addJSDocToNode } from "./util.mjs";
-export const createApiResponseType = ({ className, methodName, }) => {
+const createApiResponseType = ({ methodName, client, }) => {
     /** Awaited<ReturnType<typeof myClass.myMethod>> */
-    const awaitedResponseDataType = ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("Awaited"), [
+    const awaitedResponseDataType = ts.factory.createIndexedAccessTypeNode(ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("Awaited"), [
         ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("ReturnType"), [
-            ts.factory.createTypeQueryNode(ts.factory.createQualifiedName(ts.factory.createIdentifier(className), ts.factory.createIdentifier(methodName)), undefined),
+            ts.factory.createTypeQueryNode(ts.factory.createIdentifier(methodName), undefined),
         ]),
-    ]);
+    ]), ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral("data")));
     /** DefaultResponseDataType
      * export type MyClassMethodDefaultResponse = Awaited<ReturnType<typeof myClass.myMethod>>
      */
-    const apiResponse = ts.factory.createTypeAliasDeclaration([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier(`${capitalizeFirstLetter(className)}${capitalizeFirstLetter(methodName)}DefaultResponse`), undefined, awaitedResponseDataType);
+    const apiResponse = ts.factory.createTypeAliasDeclaration([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier(`${capitalizeFirstLetter(methodName)}DefaultResponse`), undefined, awaitedResponseDataType);
     const responseDataType = ts.factory.createTypeParameterDeclaration(undefined, TData.text, undefined, ts.factory.createTypeReferenceNode(BuildCommonTypeName(apiResponse.name)));
+    const responseErrorType = ts.factory.createTypeParameterDeclaration(undefined, TError.text, undefined, client === "@hey-api/client-axios"
+        ? ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("AxiosError"), [
+            ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(`${capitalizeFirstLetter(methodName)}Error`)),
+        ])
+        : ts.factory.createTypeReferenceNode(`${capitalizeFirstLetter(methodName)}Error`));
     return {
         /**
          * DefaultResponseDataType
@@ -26,41 +31,21 @@ export const createApiResponseType = ({ className, methodName, }) => {
          * MyClassMethodDefaultResponse
          */
         responseDataType,
+        /**
+         * ErrorDataType
+         *
+         * MyClassMethodError
+         */
+        responseErrorType,
     };
 };
-export function getRequestParamFromMethod(method, pageParam) {
-    if (!method.getParameters().length) {
-        return null;
-    }
-    const params = method.getParameters().flatMap((param) => {
-        const paramNodes = extractPropertiesFromObjectParam(param);
-        return paramNodes
-            .filter((p) => p.name !== pageParam)
-            .map((refParam) => ({
-            name: refParam.name,
-            typeName: getShortType(refParam.type?.getText() ?? ""),
-            optional: refParam.optional,
-        }));
-    });
-    const areAllPropertiesOptional = params.every((param) => param.optional);
-    return ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createObjectBindingPattern(params.map((refParam) => ts.factory.createBindingElement(undefined, undefined, ts.factory.createIdentifier(refParam.name), undefined))), undefined, ts.factory.createTypeLiteralNode(params.map((refParam) => {
-        return ts.factory.createPropertySignature(undefined, ts.factory.createIdentifier(refParam.name), refParam.optional
-            ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
-            : undefined, ts.factory.createTypeReferenceNode(refParam.typeName));
-    })), 
-    // if all params are optional, we create an empty object literal
-    // so the hook can be called without any parameters
-    areAllPropertiesOptional
-        ? ts.factory.createObjectLiteralExpression()
-        : undefined);
-}
 /**
  * Return Type
  *
  * export const classNameMethodNameQueryResult<TData = MyClassMethodDefaultResponse, TError = unknown> = UseQueryResult<TData, TError>;
  */
-export function createReturnTypeExport({ className, methodName, defaultApiResponse, }) {
-    return ts.factory.createTypeAliasDeclaration([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier(`${capitalizeFirstLetter(className)}${capitalizeFirstLetter(methodName)}QueryResult`), [
+function createReturnTypeExport({ methodName, defaultApiResponse, }) {
+    return ts.factory.createTypeAliasDeclaration([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier(`${capitalizeFirstLetter(methodName)}QueryResult`), [
         ts.factory.createTypeParameterDeclaration(undefined, TData, undefined, ts.factory.createTypeReferenceNode(defaultApiResponse.name)),
         ts.factory.createTypeParameterDeclaration(undefined, TError, undefined, ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword)),
     ], ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("UseQueryResult"), [
@@ -68,20 +53,12 @@ export function createReturnTypeExport({ className, methodName, defaultApiRespon
         ts.factory.createTypeReferenceNode(TError),
     ]));
 }
-/**
- * QueryKey
- */
-export function createQueryKeyExport({ className, methodName, queryKey, }) {
-    return ts.factory.createVariableStatement([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
-        ts.factory.createVariableDeclaration(ts.factory.createIdentifier(queryKey), undefined, undefined, ts.factory.createStringLiteral(`${className}${capitalizeFirstLetter(methodName)}`)),
-    ], ts.NodeFlags.Const));
-}
-export function hookNameFromMethod({ method, className, }) {
-    const methodName = getNameFromMethod(method);
-    return `use${className}${capitalizeFirstLetter(methodName)}`;
+export function hookNameFromMethod({ method, }) {
+    const methodName = getNameFromVariable(method);
+    return `use${capitalizeFirstLetter(methodName)}`;
 }
-export function createQueryKeyFromMethod({ method, className, }) {
-    const customHookName = hookNameFromMethod({ method, className });
+export function createQueryKeyFromMethod({ method, }) {
+    const customHookName = hookNameFromMethod({ method });
     const queryKey = `${customHookName}Key`;
     return queryKey;
 }
@@ -90,10 +67,10 @@ export function createQueryKeyFromMethod({ method, className, }) {
  * @param queryString The type of query to use from react-query
  * @param suffix The suffix to append to the hook name
  */
-export function createQueryHook({ queryString, suffix, responseDataType, requestParams, method, className, pageParam, nextPageParam, initialPageParam, }) {
-    const methodName = getNameFromMethod(method);
-    const customHookName = hookNameFromMethod({ method, className });
-    const queryKey = createQueryKeyFromMethod({ method, className });
+function createQueryHook({ queryString, suffix, responseDataType, responseErrorType, requestParams, method, pageParam, nextPageParam, initialPageParam, }) {
+    const methodName = getNameFromVariable(method);
+    const customHookName = hookNameFromMethod({ method });
+    const queryKey = createQueryKeyFromMethod({ method });
     if (queryString === "useInfiniteQuery" &&
         (pageParam === undefined || nextPageParam === undefined)) {
         throw new Error("pageParam and nextPageParam are required for infinite queries");
@@ -108,7 +85,7 @@ export function createQueryHook({ queryString, suffix, responseDataType, request
                     ts.factory.createTypeReferenceNode(responseDataTypeIdentifier),
                 ]))
                 : responseDataType,
-            ts.factory.createTypeParameterDeclaration(undefined, TError, undefined, ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword)),
+            responseErrorType,
             ts.factory.createTypeParameterDeclaration(undefined, "TQueryKey", queryKeyConstraint, ts.factory.createArrayTypeNode(ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword))),
         ]), [
             ...requestParams,
@@ -132,29 +109,40 @@ export function createQueryHook({ queryString, suffix, responseDataType, request
                 ts.factory.createTypeReferenceNode(TError),
             ], [
             ts.factory.createObjectLiteralExpression([
-                ts.factory.createPropertyAssignment(ts.factory.createIdentifier("queryKey"), ts.factory.createCallExpression(BuildCommonTypeName(getQueryKeyFnName(queryKey)), undefined, method.getParameters().length
-                    ? [
-                        ts.factory.createObjectLiteralExpression(method.getParameters().flatMap((param) => extractPropertiesFromObjectParam(param)
-                            .filter((p) => p.name !== pageParam)
-                            .map((p) => ts.factory.createShorthandPropertyAssignment(ts.factory.createIdentifier(p.name))))),
-                        ts.factory.createIdentifier("queryKey"),
-                    ]
-                    : [ts.factory.createIdentifier("queryKey")])),
+                ts.factory.createPropertyAssignment(ts.factory.createIdentifier("queryKey"), ts.factory.createCallExpression(BuildCommonTypeName(getQueryKeyFnName(queryKey)), undefined, [
+                    ts.factory.createIdentifier("clientOptions"),
+                    ts.factory.createIdentifier("queryKey"),
+                ])),
                 ts.factory.createPropertyAssignment(ts.factory.createIdentifier("queryFn"), ts.factory.createArrowFunction(undefined, undefined, isInfiniteQuery
                     ? [
                         ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createObjectBindingPattern([
                             ts.factory.createBindingElement(undefined, undefined, ts.factory.createIdentifier("pageParam"), undefined),
                         ]), undefined, undefined),
                     ]
-                    : [], undefined, EqualsOrGreaterThanToken, ts.factory.createAsExpression(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(className), ts.factory.createIdentifier(methodName)), undefined, method.getParameters().length
+                    : [], undefined, EqualsOrGreaterThanToken, ts.factory.createAsExpression(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createCallExpression(ts.factory.createIdentifier(methodName), undefined, pageParam && isInfiniteQuery
                     ? [
-                        ts.factory.createObjectLiteralExpression(method
-                            .getParameters()
-                            .flatMap((param) => extractPropertiesFromObjectParam(param).map((p) => p.name === pageParam
-                            ? ts.factory.createPropertyAssignment(ts.factory.createIdentifier(p.name), ts.factory.createAsExpression(ts.factory.createIdentifier("pageParam"), ts.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)))
-                            : ts.factory.createShorthandPropertyAssignment(ts.factory.createIdentifier(p.name))))),
+                        // { ...clientOptions, query: { ...clientOptions.query, page: pageParam as number } }
+                        ts.factory.createObjectLiteralExpression([
+                            ts.factory.createSpreadAssignment(ts.factory.createIdentifier("clientOptions")),
+                            ts.factory.createPropertyAssignment(ts.factory.createIdentifier("query"), ts.factory.createObjectLiteralExpression([
+                                ts.factory.createSpreadAssignment(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("clientOptions"), ts.factory.createIdentifier("query"))),
+                                ts.factory.createPropertyAssignment(ts.factory.createIdentifier(pageParam), ts.factory.createAsExpression(ts.factory.createIdentifier("pageParam"), ts.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword))),
+                            ])),
+                        ]),
                     ]
-                    : undefined), ts.factory.createTypeReferenceNode(TData)))),
+                    : // { ...clientOptions }
+                        getVariableArrowFunctionParameters(method)
+                            .length > 0
+                            ? [
+                                ts.factory.createObjectLiteralExpression([
+                                    ts.factory.createSpreadAssignment(ts.factory.createIdentifier("clientOptions")),
+                                ]),
+                            ]
+                            : undefined), ts.factory.createIdentifier("then")), undefined, [
+                    ts.factory.createArrowFunction(undefined, undefined, [
+                        ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier("response"), undefined, undefined, undefined),
+                    ], undefined, EqualsOrGreaterThanToken, ts.factory.createAsExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("response"), ts.factory.createIdentifier("data")), ts.factory.createTypeReferenceNode(TData))),
+                ]), ts.factory.createTypeReferenceNode(TData)))),
                 ...createInfiniteQueryParams(pageParam, nextPageParam, initialPageParam),
                 ts.factory.createSpreadAssignment(ts.factory.createIdentifier("options")),
             ]),
@@ -162,48 +150,41 @@ export function createQueryHook({ queryString, suffix, responseDataType, request
     ], ts.NodeFlags.Const));
     return hookExport;
 }
-export const createUseQuery = ({ className, method, jsDoc }, pageParam, nextPageParam, initialPageParam) => {
-    const methodName = getNameFromMethod(method);
-    const queryKey = createQueryKeyFromMethod({ method, className });
-    const { apiResponse: defaultApiResponse, responseDataType } = createApiResponseType({
-        className,
+export const createUseQuery = ({ functionDescription: { method, jsDoc }, client, pageParam, nextPageParam, initialPageParam, paginatableMethods, modelNames, }) => {
+    const methodName = getNameFromVariable(method);
+    const queryKey = createQueryKeyFromMethod({ method });
+    const { apiResponse: defaultApiResponse, responseDataType, responseErrorType, } = createApiResponseType({
         methodName,
+        client,
     });
-    const requestParam = getRequestParamFromMethod(method);
-    const infiniteRequestParam = getRequestParamFromMethod(method, pageParam);
+    const requestParam = getRequestParamFromMethod(method, undefined, modelNames);
+    const infiniteRequestParam = getRequestParamFromMethod(method, pageParam, modelNames);
     const requestParams = requestParam ? [requestParam] : [];
-    const requestParamNames = requestParams
-        .filter((p) => p.name.kind === ts.SyntaxKind.ObjectBindingPattern)
-        .map((p) => p.name);
-    const requestParamTexts = requestParamNames
-        .at(0)
-        ?.elements.filter((e) => e.name.kind === ts.SyntaxKind.Identifier)
-        .map((e) => e.name.escapedText);
     const queryHook = createQueryHook({
         queryString: "useQuery",
         suffix: "",
         responseDataType,
+        responseErrorType,
         requestParams,
         method,
-        className,
     });
     const suspenseQueryHook = createQueryHook({
         queryString: "useSuspenseQuery",
         suffix: "Suspense",
         responseDataType,
+        responseErrorType,
         requestParams,
         method,
-        className,
     });
-    const isInfiniteQuery = requestParamTexts?.includes(pageParam) ?? false;
+    const isInfiniteQuery = paginatableMethods.includes(methodName);
     const infiniteQueryHook = isInfiniteQuery
         ? createQueryHook({
             queryString: "useInfiniteQuery",
             suffix: "Infinite",
             responseDataType,
+            responseErrorType,
             requestParams: infiniteRequestParam ? [infiniteRequestParam] : [],
             method,
-            className,
             pageParam,
             nextPageParam,
             initialPageParam,
@@ -215,12 +196,10 @@ export const createUseQuery = ({ className, method, jsDoc }, pageParam, nextPage
         ? addJSDocToNode(infiniteQueryHook, jsDoc)
         : undefined;
     const returnTypeExport = createReturnTypeExport({
-        className,
         methodName,
         defaultApiResponse,
     });
     const queryKeyExport = createQueryKeyExport({
-        className,
         methodName,
         queryKey,
     });
@@ -235,29 +214,6 @@ export const createUseQuery = ({ className, method, jsDoc }, pageParam, nextPage
         queryKeyFn,
     };
 };
-export function getQueryKeyFnName(queryKey) {
-    return `${capitalizeFirstLetter(queryKey)}Fn`;
-}
-function createQueryKeyFnExport(queryKey, method) {
-    const params = getRequestParamFromMethod(method);
-    // override key is used to allow the user to override the the queryKey values
-    const overrideKey = ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier("queryKey"), QuestionToken, ts.factory.createTypeReferenceNode("Array<unknown>", []));
-    return ts.factory.createVariableStatement([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
-        ts.factory.createVariableDeclaration(ts.factory.createIdentifier(getQueryKeyFnName(queryKey)), undefined, undefined, ts.factory.createArrowFunction(undefined, undefined, params ? [params, overrideKey] : [overrideKey], undefined, EqualsOrGreaterThanToken, queryKeyFn(queryKey, method))),
-    ], ts.NodeFlags.Const));
-}
-function queryKeyFn(queryKey, method) {
-    return ts.factory.createArrayLiteralExpression([
-        ts.factory.createIdentifier(queryKey),
-        ts.factory.createSpreadElement(ts.factory.createParenthesizedExpression(ts.factory.createBinaryExpression(ts.factory.createIdentifier("queryKey"), ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken), method.getParameters().length
-            ? ts.factory.createArrayLiteralExpression([
-                ts.factory.createObjectLiteralExpression(method
-                    .getParameters()
-                    .flatMap((param) => extractPropertiesFromObjectParam(param).map((p) => ts.factory.createShorthandPropertyAssignment(ts.factory.createIdentifier(p.name))))),
-            ])
-            : ts.factory.createArrayLiteralExpression([])))),
-    ], false);
-}
 function createInfiniteQueryParams(pageParam, nextPageParam, initialPageParam = "1") {
     if (pageParam === undefined || nextPageParam === undefined) {
         return [];