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

package/dist/createSource.mjs

@@ -0,0 +1,83 @@
+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) => {
+    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({
+        project,
+    });
+    const exports = createExports(service);
+    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 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,
+        mainSource,
+        suspenseSource,
+        indexSource,
+        prefetchSource,
+    };
+};
+export const createSource = async ({ outputPath, version, }) => {
+    const queriesFile = ts.createSourceFile(`${OpenApiRqFiles.queries}.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, suspenseSource, indexSource, prefetchSource, } = await createSourceFile(outputPath);
+    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 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.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, getNameFromVariable, getShortType, getVariableArrowFunctionParameters, } from "./common.mjs";
+import { addJSDocToNode } from "./util.mjs";
+/**
+ *  Awaited<ReturnType<typeof myClass.myMethod>>
+ */
+function generateAwaitedReturnType({ methodName, }) {
+    return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("Awaited"), [
+        ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("ReturnType"), [
+            ts.factory.createTypeQueryNode(ts.factory.createIdentifier(methodName), undefined),
+        ]),
+    ]);
+}
+export const createUseMutation = ({ method, jsDoc }) => {
+    const methodName = getNameFromVariable(method);
+    const awaitedResponseDataType = generateAwaitedReturnType({
+        methodName,
+    });
+    const mutationResult = ts.factory.createTypeAliasDeclaration([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier(`${capitalizeFirstLetter(methodName)}MutationResult`), undefined, awaitedResponseDataType);
+    const responseDataType = ts.factory.createTypeParameterDeclaration(undefined, TData, undefined, ts.factory.createTypeReferenceNode(BuildCommonTypeName(mutationResult.name)));
+    const methodParameters = getVariableArrowFunctionParameters(method).length !== 0
+        ? ts.factory.createTypeLiteralNode(getVariableArrowFunctionParameters(method).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${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, getVariableArrowFunctionParameters(method).length !== 0
+                    ? [
+                        ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createObjectBindingPattern(getVariableArrowFunctionParameters(method).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.createIdentifier(methodName), undefined, getVariableArrowFunctionParameters(method)
+                    .length !== 0
+                    ? [
+                        ts.factory.createObjectLiteralExpression(getVariableArrowFunctionParameters(method).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,201 @@
+import ts from "typescript";
+import { BuildCommonTypeName, EqualsOrGreaterThanToken, QuestionToken, TData, TError, capitalizeFirstLetter, extractPropertiesFromObjectParam, getNameFromVariable, getShortType, getVariableArrowFunctionParameters, queryKeyConstraint, queryKeyGenericType, } from "./common.mjs";
+import { addJSDocToNode } from "./util.mjs";
+export const createApiResponseType = ({ methodName, }) => {
+    /** Awaited<ReturnType<typeof myClass.myMethod>> */
+    const awaitedResponseDataType = ts.factory.createIndexedAccessTypeNode(ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("Awaited"), [
+        ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("ReturnType"), [
+            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(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) {
+    if (!getVariableArrowFunctionParameters(method).length) {
+        return null;
+    }
+    const params = getVariableArrowFunctionParameters(method).flatMap((param) => {
+        const paramNodes = extractPropertiesFromObjectParam(param);
+        return paramNodes.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({ 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"), [
+        ts.factory.createTypeReferenceNode(TData),
+        ts.factory.createTypeReferenceNode(TError),
+    ]));
+}
+/**
+ * QueryKey
+ */
+export function createQueryKeyExport({ 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(`${capitalizeFirstLetter(methodName)}`)),
+    ], ts.NodeFlags.Const));
+}
+export function hookNameFromMethod({ method, }) {
+    const methodName = getNameFromVariable(method);
+    return `use${capitalizeFirstLetter(methodName)}`;
+}
+export function createQueryKeyFromMethod({ method, }) {
+    const customHookName = hookNameFromMethod({ method });
+    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, }) {
+    const methodName = getNameFromVariable(method);
+    const customHookName = hookNameFromMethod({ method });
+    const queryKey = createQueryKeyFromMethod({ method });
+    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([
+            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("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), [
+            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, getVariableArrowFunctionParameters(method).length
+                    ? [
+                        ts.factory.createObjectLiteralExpression(getVariableArrowFunctionParameters(method).flatMap((param) => extractPropertiesFromObjectParam(param).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, [], undefined, EqualsOrGreaterThanToken, ts.factory.createAsExpression(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(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.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)))),
+                ts.factory.createSpreadAssignment(ts.factory.createIdentifier("options")),
+            ]),
+        ]))),
+    ], ts.NodeFlags.Const));
+    return hookExport;
+}
+export const createUseQuery = ({ method, jsDoc }) => {
+    const methodName = getNameFromVariable(method);
+    const queryKey = createQueryKeyFromMethod({ method });
+    const { apiResponse: defaultApiResponse, responseDataType } = createApiResponseType({
+        methodName,
+    });
+    const requestParam = getRequestParamFromMethod(method);
+    const requestParams = requestParam ? [requestParam] : [];
+    const queryHook = createQueryHook({
+        queryString: "useQuery",
+        suffix: "",
+        responseDataType,
+        requestParams,
+        method,
+    });
+    const suspenseQueryHook = createQueryHook({
+        queryString: "useSuspenseQuery",
+        suffix: "Suspense",
+        responseDataType,
+        requestParams,
+        method,
+    });
+    const hookWithJsDoc = addJSDocToNode(queryHook, jsDoc);
+    const suspenseHookWithJsDoc = addJSDocToNode(suspenseQueryHook, jsDoc);
+    const returnTypeExport = createReturnTypeExport({
+        methodName,
+        defaultApiResponse,
+    });
+    const queryKeyExport = createQueryKeyExport({
+        methodName,
+        queryKey,
+    });
+    const queryKeyFn = createQueryKeyFnExport(queryKey, method);
+    return {
+        apiResponse: defaultApiResponse,
+        returnType: returnTypeExport,
+        key: queryKeyExport,
+        queryHook: hookWithJsDoc,
+        suspenseQueryHook: suspenseHookWithJsDoc,
+        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), getVariableArrowFunctionParameters(method)
+            ? ts.factory.createArrayLiteralExpression([
+                ts.factory.createObjectLiteralExpression(getVariableArrowFunctionParameters(method).flatMap((param) => extractPropertiesFromObjectParam(param).map((p) => ts.factory.createShorthandPropertyAssignment(ts.factory.createIdentifier(p.name))))),
+            ])
+            : ts.factory.createArrayLiteralExpression([])))),
+    ], false);
+}

package/dist/format.mjs

@@ -0,0 +1,67 @@
+import { sync } from "cross-spawn";
+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);
+};
+const formatters = {
+    biome: {
+        args: (path) => ["format", "--write", path],
+        command: "biome",
+        name: "Biome (Format)",
+    },
+    prettier: {
+        args: (path) => [
+            "--ignore-unknown",
+            path,
+            "--write",
+            "--ignore-path",
+            "./.prettierignore",
+        ],
+        command: "prettier",
+        name: "Prettier",
+    },
+};
+/**
+ * Map of supported linters
+ */
+const linters = {
+    biome: {
+        args: (path) => ["lint", "--apply", path],
+        command: "biome",
+        name: "Biome (Lint)",
+    },
+    eslint: {
+        args: (path) => [path, "--fix"],
+        command: "eslint",
+        name: "ESLint",
+    },
+};
+export const processOutput = async ({ output, format, lint, }) => {
+    if (format) {
+        const module = formatters[format];
+        console.log(`✨ Running ${module.name} on queries`);
+        sync(module.command, module.args(output));
+    }
+    if (lint) {
+        const module = linters[lint];
+        console.log(`✨ Running ${module.name} on queries`);
+        sync(module.command, module.args(output));
+    }
+};

package/dist/generate.mjs

@@ -0,0 +1,50 @@
+import { createClient } from "@hey-api/openapi-ts";
+import { buildQueriesOutputPath, buildRequestsOutputPath, formatOptions, } from "./common.mjs";
+import { createSource } from "./createSource.mjs";
+import { formatOutput, processOutput } 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,
+    });
+    await print(source, formattedOptions);
+    const queriesOutputPath = buildQueriesOutputPath(options.output);
+    await formatOutput(queriesOutputPath);
+    await processOutput({
+        output: queriesOutputPath,
+        format: formattedOptions.format,
+        lint: formattedOptions.lint,
+    });
+}

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 { 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 methods = getMethodsFromService(node);
+    return {
+        methods,
+        node,
+    };
+}
+function getMethodsFromService(node) {
+    const variableStatements = node.getVariableStatements();
+    // const methodDescriptions: FunctionDescription[] = [];
+    return variableStatements.flatMap((variableStatement) => {
+        const declarations = variableStatement.getDeclarations();
+        return declarations.map((declaration) => {
+            if (!ts.isVariableDeclaration(declaration.compilerNode)) {
+                throw new Error("Variable declaration not found");
+            }
+            const initializer = declaration.getInitializer();
+            if (!initializer) {
+                throw new Error("Initializer not found");
+            }
+            if (!ts.isArrowFunction(initializer.compilerNode)) {
+                throw new Error("Arrow function not found");
+            }
+            const methodBlockNode = initializer.compilerNode.body;
+            if (!methodBlockNode || !ts.isBlock(methodBlockNode)) {
+                throw new Error("Method block not found");
+            }
+            const foundReturnStatement = methodBlockNode.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 propertyAccessExpression = callExpression.expression;
+            const httpMethodName = propertyAccessExpression.name.getText();
+            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(initializer.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 methodDescription = {
+                node,
+                method: declaration,
+                methodBlock: methodBlockNode,
+                httpMethodName,
+                jsDoc,
+                isDeprecated,
+            };
+            return methodDescription;
+        });
+    });
+}

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;
+}