@7nohe/openapi-react-query-codegen 0.0.0-1712acfb083e0b1eec43cfc6f917f780ae5b5815

package/dist/createSource.mjs

@@ -0,0 +1,93 @@
+import { join } from "node:path";
+import { Project } from "ts-morph";
+import ts from "typescript";
+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) => {
+    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
+        // with the associated source files.
+        // Read more: https://ts-morph.com/setup/
+        skipAddingFilesFromTsConfig: true,
+    });
+    const sourceFiles = join(process.cwd(), outputPath);
+    project.addSourceFilesAtPaths(`${sourceFiles}/**/*`);
+    const service = await getServices(project);
+    const imports = createImports({
+        serviceEndName,
+        project,
+    });
+    const exports = createExports(service, pageParam, nextPageParam);
+    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);
+    const queriesExport = ts.factory.createExportDeclaration(undefined, false, undefined, ts.factory.createStringLiteral(`./${OpenApiRqFiles.queries}`), undefined);
+    const mainSource = ts.factory.createSourceFile([commonImport, ...imports, ...exports.mainExports], ts.factory.createToken(ts.SyntaxKind.EndOfFileToken), ts.NodeFlags.None);
+    const infiniteQueriesSource = ts.factory.createSourceFile([commonImport, ...imports, ...exports.infiniteQueriesExports], ts.factory.createToken(ts.SyntaxKind.EndOfFileToken), ts.NodeFlags.None);
+    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);
+    return {
+        commonSource,
+        infiniteQueriesSource,
+        mainSource,
+        suspenseSource,
+        indexSource,
+        prefetchSource,
+    };
+};
+export const createSource = async ({ outputPath, version, serviceEndName, pageParam, nextPageParam, }) => {
+    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 printer = ts.createPrinter({
+        newLine: ts.NewLineKind.LineFeed,
+        removeComments: false,
+    });
+    const { commonSource, mainSource, infiniteQueriesSource, suspenseSource, indexSource, prefetchSource, } = await createSourceFile(outputPath, serviceEndName, pageParam, nextPageParam);
+    const comment = `// generated with @7nohe/openapi-react-query-codegen@${version} \n\n`;
+    const commonResult = comment +
+        printer.printNode(ts.EmitHint.Unspecified, commonSource, commonFile);
+    const mainResult = comment +
+        printer.printNode(ts.EmitHint.Unspecified, mainSource, queriesFile);
+    const infiniteQueriesResult = comment +
+        printer.printNode(ts.EmitHint.Unspecified, infiniteQueriesSource, infiniteQueriesFile);
+    const suspenseResult = comment +
+        printer.printNode(ts.EmitHint.Unspecified, suspenseSource, suspenseFile);
+    const indexResult = comment +
+        printer.printNode(ts.EmitHint.Unspecified, indexSource, indexFile);
+    const prefetchResult = comment +
+        printer.printNode(ts.EmitHint.Unspecified, prefetchSource, prefetchFile);
+    return [
+        {
+            name: `${OpenApiRqFiles.index}.ts`,
+            content: indexResult,
+        },
+        {
+            name: `${OpenApiRqFiles.common}.ts`,
+            content: commonResult,
+        },
+        {
+            name: `${OpenApiRqFiles.infiniteQueries}.ts`,
+            content: infiniteQueriesResult,
+        },
+        {
+            name: `${OpenApiRqFiles.queries}.ts`,
+            content: mainResult,
+        },
+        {
+            name: `${OpenApiRqFiles.suspense}.ts`,
+            content: suspenseResult,
+        },
+        {
+            name: `${OpenApiRqFiles.prefetch}.ts`,
+            content: prefetchResult,
+        },
+    ];
+};

package/dist/createUseMutation.mjs

@@ -0,0 +1,76 @@
+import ts from "typescript";
+import { BuildCommonTypeName, TContext, TData, TError, capitalizeFirstLetter, extractPropertiesFromObjectParam, getNameFromMethod, getShortType, } from "./common.mjs";
+import { addJSDocToNode } from "./util.mjs";
+/**
+ *  Awaited<ReturnType<typeof myClass.myMethod>>
+ */
+function generateAwaitedReturnType({ className, 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),
+        ]),
+    ]);
+}
+export const createUseMutation = ({ className, method, jsDoc, }) => {
+    const methodName = getNameFromMethod(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 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)))));
+        }))
+        : 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([
+            responseDataType,
+            ts.factory.createTypeParameterDeclaration(undefined, TError, undefined, 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("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),
+                    ts.factory.createTypeReferenceNode(TError),
+                    methodParameters,
+                    ts.factory.createTypeReferenceNode(TContext),
+                ]),
+                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),
+            ts.factory.createTypeReferenceNode(TError),
+            methodParameters,
+            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.createSpreadAssignment(ts.factory.createIdentifier("options")),
+            ]),
+        ]))),
+    ], ts.NodeFlags.Const));
+    const hookWithJsDoc = addJSDocToNode(exportHook, jsDoc);
+    return {
+        mutationResult,
+        mutationHook: hookWithJsDoc,
+    };
+};

package/dist/createUseQuery.mjs

@@ -0,0 +1,268 @@
+import ts from "typescript";
+import { BuildCommonTypeName, EqualsOrGreaterThanToken, QuestionToken, TData, TError, capitalizeFirstLetter, extractPropertiesFromObjectParam, getNameFromMethod, getShortType, queryKeyConstraint, queryKeyGenericType, } from "./common.mjs";
+import { addJSDocToNode } from "./util.mjs";
+export const createApiResponseType = ({ className, methodName, }) => {
+    /** Awaited<ReturnType<typeof myClass.myMethod>> */
+    const awaitedResponseDataType = 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),
+        ]),
+    ]);
+    /** 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 responseDataType = ts.factory.createTypeParameterDeclaration(undefined, TData.text, undefined, ts.factory.createTypeReferenceNode(BuildCommonTypeName(apiResponse.name)));
+    return {
+        /**
+         * DefaultResponseDataType
+         *
+         * export type MyClassMethodDefaultResponse = Awaited<ReturnType<typeof myClass.myMethod>>
+         */
+        apiResponse,
+        /**
+         * This will be the name of the type of the response type of the method
+         *
+         * MyClassMethodDefaultResponse
+         */
+        responseDataType,
+    };
+};
+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`), [
+        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"), [
+        ts.factory.createTypeReferenceNode(TData),
+        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 createQueryKeyFromMethod({ method, className, }) {
+    const customHookName = hookNameFromMethod({ method, className });
+    const queryKey = `${customHookName}Key`;
+    return queryKey;
+}
+/**
+ * Creates a custom hook for a query
+ * @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, }) {
+    const methodName = getNameFromMethod(method);
+    const customHookName = hookNameFromMethod({ method, className });
+    const queryKey = createQueryKeyFromMethod({ method, className });
+    const isInfiniteQuery = pageParam !== undefined && nextPageParam !== undefined;
+    const responseDataTypeRef = responseDataType.default;
+    const responseDataTypeIdentifier = responseDataTypeRef.typeName;
+    const hookExport = ts.factory.createVariableStatement([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
+        ts.factory.createVariableDeclaration(ts.factory.createIdentifier(`${customHookName}${suffix}`), undefined, undefined, ts.factory.createArrowFunction(undefined, ts.factory.createNodeArray([
+            isInfiniteQuery
+                ? ts.factory.createTypeParameterDeclaration(undefined, TData, undefined, ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("InfiniteData"), [
+                    ts.factory.createTypeReferenceNode(responseDataTypeIdentifier),
+                ]))
+                : responseDataType,
+            ts.factory.createTypeParameterDeclaration(undefined, TError, undefined, ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword)),
+            ts.factory.createTypeParameterDeclaration(undefined, "TQueryKey", queryKeyConstraint, ts.factory.createArrayTypeNode(ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword))),
+        ]), [
+            ...requestParams,
+            ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier("queryKey"), 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(isInfiniteQuery
+                    ? "UseInfiniteQueryOptions"
+                    : "UseQueryOptions"), [
+                    ts.factory.createTypeReferenceNode(TData),
+                    ts.factory.createTypeReferenceNode(TError),
+                ]),
+                ts.factory.createUnionTypeNode([
+                    ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral("queryKey")),
+                    ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral("queryFn")),
+                ]),
+            ])),
+        ], undefined, EqualsOrGreaterThanToken, ts.factory.createCallExpression(ts.factory.createIdentifier(queryString), isInfiniteQuery
+            ? []
+            : [
+                ts.factory.createTypeReferenceNode(TData),
+                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("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
+                    ? [
+                        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))))),
+                    ]
+                    : undefined), ts.factory.createTypeReferenceNode(TData)))),
+                ...createInfiniteQueryParams(pageParam, nextPageParam),
+                ts.factory.createSpreadAssignment(ts.factory.createIdentifier("options")),
+            ]),
+        ]))),
+    ], ts.NodeFlags.Const));
+    return hookExport;
+}
+export const createUseQuery = ({ className, method, jsDoc }, pageParam, nextPageParam) => {
+    const methodName = getNameFromMethod(method);
+    const queryKey = createQueryKeyFromMethod({ method, className });
+    const { apiResponse: defaultApiResponse, responseDataType } = createApiResponseType({
+        className,
+        methodName,
+    });
+    const requestParam = getRequestParamFromMethod(method);
+    const infiniteRequestParam = getRequestParamFromMethod(method, pageParam);
+    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,
+        requestParams,
+        method,
+        className,
+    });
+    const suspenseQueryHook = createQueryHook({
+        queryString: "useSuspenseQuery",
+        suffix: "Suspense",
+        responseDataType,
+        requestParams,
+        method,
+        className,
+    });
+    const isInfiniteQuery = requestParamTexts?.includes(pageParam) ?? false;
+    const infiniteQueryHook = isInfiniteQuery
+        ? createQueryHook({
+            queryString: "useInfiniteQuery",
+            suffix: "Infinite",
+            responseDataType,
+            requestParams: infiniteRequestParam ? [infiniteRequestParam] : [],
+            method,
+            className,
+            pageParam,
+            nextPageParam,
+        })
+        : undefined;
+    const hookWithJsDoc = addJSDocToNode(queryHook, jsDoc);
+    const suspenseHookWithJsDoc = addJSDocToNode(suspenseQueryHook, jsDoc);
+    const infiniteHookWithJsDoc = infiniteQueryHook
+        ? addJSDocToNode(infiniteQueryHook, jsDoc)
+        : undefined;
+    const returnTypeExport = createReturnTypeExport({
+        className,
+        methodName,
+        defaultApiResponse,
+    });
+    const queryKeyExport = createQueryKeyExport({
+        className,
+        methodName,
+        queryKey,
+    });
+    const queryKeyFn = createQueryKeyFnExport(queryKey, method);
+    return {
+        apiResponse: defaultApiResponse,
+        returnType: returnTypeExport,
+        key: queryKeyExport,
+        queryHook: hookWithJsDoc,
+        suspenseQueryHook: suspenseHookWithJsDoc,
+        infiniteQueryHook: infiniteHookWithJsDoc,
+        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) {
+    if (pageParam === undefined || nextPageParam === undefined) {
+        return [];
+    }
+    return [
+        ts.factory.createPropertyAssignment(ts.factory.createIdentifier("initialPageParam"), ts.factory.createNumericLiteral(1)),
+        ts.factory.createPropertyAssignment(ts.factory.createIdentifier("getNextPageParam"), 
+        // (response) => (response as { nextPage: number }).nextPage,
+        ts.factory.createArrowFunction(undefined, undefined, [
+            ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier("response"), undefined, undefined),
+        ], undefined, EqualsOrGreaterThanToken, ts.factory.createPropertyAccessExpression(ts.factory.createParenthesizedExpression(ts.factory.createAsExpression(ts.factory.createIdentifier("response"), ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(`{ ${nextPageParam}: number }`)))), ts.factory.createIdentifier(nextPageParam)))),
+    ];
+}

package/dist/format.mjs

@@ -0,0 +1,21 @@
+import { IndentationText, NewLineKind, Project, QuoteKind } from "ts-morph";
+export const formatOutput = async (outputPath) => {
+    const project = new Project({
+        skipAddingFilesFromTsConfig: true,
+        manipulationSettings: {
+            indentationText: IndentationText.TwoSpaces,
+            newLineKind: NewLineKind.LineFeed,
+            quoteKind: QuoteKind.Double,
+            usePrefixAndSuffixTextForRename: false,
+            useTrailingCommas: true,
+        },
+    });
+    const sourceFiles = project.addSourceFilesAtPaths(`${outputPath}/**/*`);
+    const tasks = sourceFiles.map((sourceFile) => {
+        sourceFile.formatText();
+        sourceFile.fixMissingImports();
+        sourceFile.organizeImports();
+        return sourceFile.save();
+    });
+    await Promise.all(tasks);
+};

package/dist/generate.mjs

@@ -0,0 +1,48 @@
+import { createClient } from "@hey-api/openapi-ts";
+import { buildQueriesOutputPath, buildRequestsOutputPath, formatOptions, } from "./common.mjs";
+import { createSource } from "./createSource.mjs";
+import { formatOutput } from "./format.mjs";
+import { print } from "./print.mjs";
+export async function generate(options, version) {
+    const openApiOutputPath = buildRequestsOutputPath(options.output);
+    const formattedOptions = formatOptions(options);
+    const config = {
+        base: formattedOptions.base,
+        client: formattedOptions.client,
+        debug: formattedOptions.debug,
+        dryRun: false,
+        exportCore: true,
+        output: {
+            format: formattedOptions.format,
+            lint: formattedOptions.lint,
+            path: openApiOutputPath,
+        },
+        input: formattedOptions.input,
+        request: formattedOptions.request,
+        schemas: {
+            export: !formattedOptions.noSchemas,
+            type: formattedOptions.schemaType,
+        },
+        services: {
+            export: true,
+            response: formattedOptions.serviceResponse,
+        },
+        types: {
+            dates: formattedOptions.useDateType,
+            export: true,
+            enums: formattedOptions.enums,
+        },
+        useOptions: true,
+    };
+    await createClient(config);
+    const source = await createSource({
+        outputPath: openApiOutputPath,
+        version,
+        serviceEndName: "Service", // we are hard coding this because changing the service end name was depreciated in @hey-api/openapi-ts
+        pageParam: formattedOptions.pageParam,
+        nextPageParam: formattedOptions.nextPageParam,
+    });
+    await print(source, formattedOptions);
+    const queriesOutputPath = buildQueriesOutputPath(options.output);
+    await formatOutput(queriesOutputPath);
+}

package/dist/print.mjs

@@ -0,0 +1,22 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { buildQueriesOutputPath, exists } from "./common.mjs";
+async function printGeneratedTS(result, options) {
+    const dir = buildQueriesOutputPath(options.output);
+    const dirExists = await exists(dir);
+    if (!dirExists) {
+        await mkdir(dir, { recursive: true });
+    }
+    await writeFile(path.join(dir, result.name), result.content);
+}
+export async function print(results, options) {
+    const outputPath = options.output;
+    const dirExists = await exists(outputPath);
+    if (!dirExists) {
+        await mkdir(outputPath);
+    }
+    const promises = results.map(async (result) => {
+        await printGeneratedTS(result, options);
+    });
+    await Promise.all(promises);
+}

package/dist/service.mjs

@@ -0,0 +1,79 @@
+import ts from "typescript";
+import { getClassNameFromClassNode, getClassesFromService, } from "./common.mjs";
+import { serviceFileName } from "./constants.mjs";
+export async function getServices(project) {
+    const node = project
+        .getSourceFiles()
+        .find((sourceFile) => sourceFile.getFilePath().includes(serviceFileName));
+    if (!node) {
+        throw new Error("No service node found");
+    }
+    const klasses = getClassesFromService(node);
+    return {
+        klasses: klasses.map(({ klass, className }) => ({
+            className,
+            klass,
+            methods: getMethodsFromService(node, klass),
+        })),
+        node,
+    };
+}
+function getMethodsFromService(node, klass) {
+    const methods = klass.getMethods();
+    if (!methods.length) {
+        throw new Error("No methods found");
+    }
+    return methods.map((method) => {
+        const methodBlockNode = method.compilerNode
+            .getChildren(node.compilerNode)
+            .find((child) => child.kind === ts.SyntaxKind.Block);
+        if (!methodBlockNode) {
+            throw new Error("Method block not found");
+        }
+        const methodBlock = methodBlockNode;
+        const foundReturnStatement = methodBlock.statements.find((s) => s.kind === ts.SyntaxKind.ReturnStatement);
+        if (!foundReturnStatement) {
+            throw new Error("Return statement not found");
+        }
+        const returnStatement = foundReturnStatement;
+        const foundCallExpression = returnStatement.expression;
+        if (!foundCallExpression) {
+            throw new Error("Call expression not found");
+        }
+        const callExpression = foundCallExpression;
+        const properties = callExpression.arguments[1].properties;
+        const httpMethodName = properties
+            .find((p) => p.name?.getText(node.compilerNode) === "method")
+            ?.initializer?.getText(node.compilerNode);
+        if (!httpMethodName) {
+            throw new Error("httpMethodName not found");
+        }
+        const getAllChildren = (tsNode) => {
+            const childItems = tsNode.getChildren(node.compilerNode);
+            if (childItems.length) {
+                const allChildren = childItems.map(getAllChildren);
+                return [tsNode].concat(allChildren.flat());
+            }
+            return [tsNode];
+        };
+        const children = getAllChildren(method.compilerNode);
+        // get all JSDoc comments
+        // this should be an array of 1 or 0
+        const jsDocs = children
+            .filter((c) => c.kind === ts.SyntaxKind.JSDoc)
+            .map((c) => c.getText(node.compilerNode));
+        // get the first JSDoc comment
+        const jsDoc = jsDocs?.[0];
+        const isDeprecated = children.some((c) => c.kind === ts.SyntaxKind.JSDocDeprecatedTag);
+        const className = getClassNameFromClassNode(klass);
+        return {
+            className,
+            node,
+            method,
+            methodBlock,
+            httpMethodName,
+            jsDoc,
+            isDeprecated,
+        };
+    });
+}

package/dist/util.mjs

@@ -0,0 +1,16 @@
+import ts from "typescript";
+export function addJSDocToNode(node, jsDoc) {
+    if (!jsDoc) {
+        return node;
+    }
+    // replace the first /** with *
+    // we do this because ts.addSyntheticLeadingComment will add /* to the beginning but we want /**
+    const removedFirstLine = jsDoc.trim().replace(/^\/\*\*/, "*");
+    // remove the last */ because ts.addSyntheticLeadingComment will add it
+    const removedSecondLine = removedFirstLine.replace(/\*\/$/, "");
+    const split = removedSecondLine.split("\n");
+    const trimmed = split.map((line) => line.trim());
+    const joined = trimmed.join("\n");
+    const nodeWithJSDoc = ts.addSyntheticLeadingComment(node, ts.SyntaxKind.MultiLineCommentTrivia, joined, true);
+    return nodeWithJSDoc;
+}