@7nohe/openapi-react-query-codegen 0.5.3 → 1.0.6

package/dist/createUseQuery.mjs

@@ -0,0 +1,187 @@
+import ts from "typescript";
+import { BuildCommonTypeName, capitalizeFirstLetter, extractPropertiesFromObjectParam, getNameFromMethod, queryKeyConstraint, queryKeyGenericType, TData, TError, } 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,
+        /**
+         * will be the name of the type of the response type of the method
+         * MyClassMethodDefaultResponse
+         */
+        responseDataType,
+    };
+};
+export function getRequestParamFromMethod(method) {
+    if (!method.getParameters().length) {
+        return null;
+    }
+    // we need to get the properties of the object
+    return ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createObjectBindingPattern(method
+        .getParameters()
+        .map((param) => {
+        const paramNodes = extractPropertiesFromObjectParam(param);
+        return paramNodes.map((refParam) => ts.factory.createBindingElement(undefined, undefined, ts.factory.createIdentifier(refParam.name), undefined));
+    })
+        .flat()), undefined, ts.factory.createTypeLiteralNode(method
+        .getParameters()
+        .map((param) => {
+        const paramNodes = extractPropertiesFromObjectParam(param);
+        return paramNodes.map((refParam) => {
+            return ts.factory.createPropertySignature(undefined, ts.factory.createIdentifier(refParam.name), refParam.optional
+                ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
+                : undefined, 
+            // param.hasQuestionToken() ?? param.getInitializer()?.compilerNode
+            //   ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
+            //   : param.getQuestionTokenNode()?.compilerNode,
+            ts.factory.createTypeReferenceNode(refParam.type.getText()));
+        });
+    })
+        .flat()));
+}
+/**
+ * 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));
+}
+function hookNameFromMethod({ method, className, }) {
+    const methodName = getNameFromMethod(method);
+    return `use${className}${capitalizeFirstLetter(methodName)}`;
+}
+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
+ */
+function createQueryHook({ queryString, suffix, responseDataType, requestParams, method, className, }) {
+    const methodName = getNameFromMethod(method);
+    const customHookName = hookNameFromMethod({ method, className });
+    const queryKey = createQueryKeyFromMethod({ method, className });
+    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")),
+                    ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral("initialData")),
+                ]),
+            ])),
+        ], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), 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.createArrayLiteralExpression([
+                    BuildCommonTypeName(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()
+                                .map((param) => extractPropertiesFromObjectParam(param).map((p) => ts.factory.createShorthandPropertyAssignment(ts.factory.createIdentifier(p.name))))
+                                .flat()),
+                        ])
+                        : ts.factory.createArrayLiteralExpression([])))),
+                ], false)),
+                ts.factory.createPropertyAssignment(ts.factory.createIdentifier("queryFn"), ts.factory.createArrowFunction(undefined, undefined, [], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), 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()
+                            .map((param) => extractPropertiesFromObjectParam(param).map((p) => ts.factory.createShorthandPropertyAssignment(ts.factory.createIdentifier(p.name))))
+                            .flat()),
+                    ]
+                    : undefined), ts.factory.createTypeReferenceNode(TData)))),
+                ts.factory.createSpreadAssignment(ts.factory.createIdentifier("options")),
+            ]),
+        ]))),
+    ], ts.NodeFlags.Const));
+    return hookExport;
+}
+export const createUseQuery = ({ node, className, method, jsDoc = [], isDeprecated: deprecated = false, }) => {
+    const methodName = getNameFromMethod(method);
+    const queryKey = createQueryKeyFromMethod({ method, className });
+    const { apiResponse: defaultApiResponse, responseDataType } = createApiResponseType({
+        className,
+        methodName,
+    });
+    const requestParam = getRequestParamFromMethod(method);
+    const requestParams = requestParam ? [requestParam] : [];
+    const queryHook = createQueryHook({
+        queryString: "useQuery",
+        suffix: "",
+        responseDataType,
+        requestParams,
+        method,
+        className,
+    });
+    const suspenseQueryHook = createQueryHook({
+        queryString: "useSuspenseQuery",
+        suffix: "Suspense",
+        responseDataType,
+        requestParams,
+        method,
+        className,
+    });
+    const hookWithJsDoc = addJSDocToNode(queryHook, node, deprecated, jsDoc);
+    const suspenseHookWithJsDoc = addJSDocToNode(suspenseQueryHook, node, deprecated, jsDoc);
+    const returnTypeExport = createReturnTypeExport({
+        className,
+        methodName,
+        defaultApiResponse,
+    });
+    const queryKeyExport = createQueryKeyExport({
+        className,
+        methodName,
+        queryKey,
+    });
+    return {
+        apiResponse: defaultApiResponse,
+        returnType: returnTypeExport,
+        key: queryKeyExport,
+        queryHook: hookWithJsDoc,
+        suspenseQueryHook: suspenseHookWithJsDoc,
+    };
+};

package/dist/generate.mjs

@@ -0,0 +1,43 @@
+import { createClient } from "@hey-api/openapi-ts";
+import { print } from "./print.mjs";
+import path from "path";
+import { createSource } from "./createSource.mjs";
+import { defaultOutputPath, requestsOutputPath } from "./constants.mjs";
+import { safeParseNumber } from "./common.mjs";
+export async function generate(options, version) {
+    const openApiOutputPath = path.join(options.output ?? defaultOutputPath, requestsOutputPath);
+    // loop through properties on the options object
+    // if the property is a string of number then convert it to a number
+    // if the property is a string of boolean then convert it to a boolean
+    const formattedOptions = Object.entries(options).reduce((acc, [key, value]) => {
+        const typedKey = key;
+        const typedValue = value;
+        const parsedNumber = safeParseNumber(typedValue);
+        if (!isNaN(parsedNumber)) {
+            acc[typedKey] = parsedNumber;
+        }
+        else if (value === "true") {
+            acc[typedKey] = true;
+        }
+        else if (value === "false") {
+            acc[typedKey] = false;
+        }
+        return acc;
+    }, options);
+    const config = {
+        ...formattedOptions,
+        output: openApiOutputPath,
+        useOptions: true,
+        exportCore: true,
+        exportModels: true,
+        exportServices: true,
+        write: 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
+    });
+    await print(source, formattedOptions);
+}

package/dist/print.mjs

@@ -0,0 +1,23 @@
+import { mkdir, writeFile } from "fs/promises";
+import path from "path";
+import { defaultOutputPath, queriesOutputPath } from "./constants.mjs";
+import { exists } from "./common.mjs";
+async function printGeneratedTS(result, options) {
+    const dir = path.join(options.output ?? defaultOutputPath, queriesOutputPath);
+    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 ?? defaultOutputPath;
+    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,94 @@
+import ts from "typescript";
+export async function getServices(project) {
+    const node = project
+        .getSourceFiles()
+        .find((sourceFile) => sourceFile.getFilePath().includes("services.ts"));
+    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 getClassesFromService(node) {
+    const klasses = node.getClasses();
+    if (!klasses.length) {
+        throw new Error("No classes found");
+    }
+    return klasses.map((klass) => {
+        const className = klass.getName();
+        if (!className) {
+            throw new Error("Class name not found");
+        }
+        return {
+            className,
+            klass,
+        };
+    });
+}
+function getClassNameFromClassNode(klass) {
+    const className = klass.getName();
+    if (!className) {
+        throw new Error("Class name not found");
+    }
+    return className;
+}
+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);
+        const jsDoc = method.getJsDocs().map((jsDoc) => jsDoc);
+        const isDeprecated = children.some((c) => c.kind === ts.SyntaxKind.JSDocDeprecatedTag);
+        const className = getClassNameFromClassNode(klass);
+        return {
+            className,
+            node,
+            method,
+            methodBlock,
+            httpMethodName,
+            jsDoc,
+            isDeprecated,
+        };
+    });
+}

package/dist/{src/util.js → util.mjs}

@@ -1,11 +1,5 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addJSDocToNode = void 0;
-const typescript_1 = __importDefault(require("typescript"));
-function addJSDocToNode(node, sourceFile, deprecated, jsDoc = []) {
+import ts from "typescript";
+export function addJSDocToNode(node, sourceFile, deprecated, jsDoc = []) {
     const deprecatedString = deprecated ? "@deprecated" : "";
     const jsDocString = [deprecatedString]
         .concat(jsDoc.map((comment) => {
@@ -28,8 +22,7 @@ function addJSDocToNode(node, sourceFile, deprecated, jsDoc = []) {
         // replace new lines with \n *
         .replace(/\n/g, "\n * ");
     const nodeWithJSDoc = jsDocString
-        ? typescript_1.default.addSyntheticLeadingComment(node, typescript_1.default.SyntaxKind.MultiLineCommentTrivia, `*\n ${jsDocString}\n `, true)
+        ? ts.addSyntheticLeadingComment(node, ts.SyntaxKind.MultiLineCommentTrivia, `*\n ${jsDocString}\n `, true)
         : node;
     return nodeWithJSDoc;
 }
-exports.addJSDocToNode = addJSDocToNode;

package/package.json

@@ -1,10 +1,14 @@
 {
   "name": "@7nohe/openapi-react-query-codegen",
-  "version": "0.5.3",
+  "version": "1.0.6",
   "description": "OpenAPI React Query Codegen",
   "bin": {
-    "openapi-rq": "dist/src/cli.js"
+    "openapi-rq": "dist/cli.mjs"
   },
+  "type": "module",
+  "workspaces": [
+    "examples/*"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/7nohe/openapi-react-query-codegen.git"
@@ -21,25 +25,32 @@
     "openapi",
     "swagger",
     "typescript",
-    "openapi-typescript-codegen"
+    "openapi-typescript-codegen",
+    "@hey-api/openapi-ts"
   ],
   "author": "Daiki Urata (@7nohe)",
   "license": "MIT",
   "devDependencies": {
+    "@hey-api/openapi-ts": "0.36.0",
     "@types/node": "^20.10.6",
     "commander": "^12.0.0",
     "glob": "^10.3.10",
-    "openapi-typescript-codegen": "0.25.0",
+    "rimraf": "^5.0.5",
+    "ts-morph": "^22.0.0",
     "typescript": "^5.3.3"
   },
   "peerDependencies": {
+    "@hey-api/openapi-ts": "0.36.0",
     "commander": ">= 11 < 13",
     "glob": ">= 10",
-    "openapi-typescript-codegen": "^0.24.0",
+    "ts-morph": ">= 22 < 23",
     "typescript": ">= 4.8.3"
   },
+  "engines": {
+    "node": ">=14"
+  },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "rimraf dist && tsc -p tsconfig.json",
     "preview": "npm run build && npm -C examples/react-app run generate:api",
     "release": "npx git-ensure -a && npx bumpp --commit --tag --push"
   }

package/dist/node_modules/.bin/glob

@@ -1,17 +0,0 @@
-#!/bin/sh
-basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
-
-case `uname` in
-    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
-esac
-
-if [ -z "$NODE_PATH" ]; then
-  export NODE_PATH="/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/glob@10.3.10/node_modules/glob/dist/esm/node_modules:/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/glob@10.3.10/node_modules/glob/dist/node_modules:/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/glob@10.3.10/node_modules/glob/node_modules:/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/glob@10.3.10/node_modules:/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/node_modules"
-else
-  export NODE_PATH="/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/glob@10.3.10/node_modules/glob/dist/esm/node_modules:/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/glob@10.3.10/node_modules/glob/dist/node_modules:/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/glob@10.3.10/node_modules/glob/node_modules:/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/glob@10.3.10/node_modules:/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/node_modules:$NODE_PATH"
-fi
-if [ -x "$basedir/node" ]; then
-  exec "$basedir/node"  "$basedir/../glob/dist/esm/bin.mjs" "$@"
-else
-  exec node  "$basedir/../glob/dist/esm/bin.mjs" "$@"
-fi

package/dist/node_modules/.bin/openapi

@@ -1,17 +0,0 @@
-#!/bin/sh
-basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
-
-case `uname` in
-    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
-esac
-
-if [ -z "$NODE_PATH" ]; then
-  export NODE_PATH="/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/openapi-typescript-codegen@0.25.0/node_modules/openapi-typescript-codegen/bin/node_modules:/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/openapi-typescript-codegen@0.25.0/node_modules/openapi-typescript-codegen/node_modules:/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/openapi-typescript-codegen@0.25.0/node_modules:/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/node_modules"
-else
-  export NODE_PATH="/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/openapi-typescript-codegen@0.25.0/node_modules/openapi-typescript-codegen/bin/node_modules:/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/openapi-typescript-codegen@0.25.0/node_modules/openapi-typescript-codegen/node_modules:/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/openapi-typescript-codegen@0.25.0/node_modules:/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/node_modules:$NODE_PATH"
-fi
-if [ -x "$basedir/node" ]; then
-  exec "$basedir/node"  "$basedir/../openapi-typescript-codegen/bin/index.js" "$@"
-else
-  exec node  "$basedir/../openapi-typescript-codegen/bin/index.js" "$@"
-fi

package/dist/node_modules/.bin/tsc

@@ -1,17 +0,0 @@
-#!/bin/sh
-basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
-
-case `uname` in
-    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
-esac
-
-if [ -z "$NODE_PATH" ]; then
-  export NODE_PATH="/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/typescript@5.3.3/node_modules/typescript/bin/node_modules:/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/typescript@5.3.3/node_modules/typescript/node_modules:/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/typescript@5.3.3/node_modules:/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/node_modules"
-else
-  export NODE_PATH="/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/typescript@5.3.3/node_modules/typescript/bin/node_modules:/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/typescript@5.3.3/node_modules/typescript/node_modules:/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/typescript@5.3.3/node_modules:/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/node_modules:$NODE_PATH"
-fi
-if [ -x "$basedir/node" ]; then
-  exec "$basedir/node"  "$basedir/../typescript/bin/tsc" "$@"
-else
-  exec node  "$basedir/../typescript/bin/tsc" "$@"
-fi

package/dist/node_modules/.bin/tsserver

@@ -1,17 +0,0 @@
-#!/bin/sh
-basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
-
-case `uname` in
-    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
-esac
-
-if [ -z "$NODE_PATH" ]; then
-  export NODE_PATH="/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/typescript@5.3.3/node_modules/typescript/bin/node_modules:/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/typescript@5.3.3/node_modules/typescript/node_modules:/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/typescript@5.3.3/node_modules:/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/node_modules"
-else
-  export NODE_PATH="/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/typescript@5.3.3/node_modules/typescript/bin/node_modules:/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/typescript@5.3.3/node_modules/typescript/node_modules:/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/typescript@5.3.3/node_modules:/Users/daiki/Development/openapi-react-query-codegen/node_modules/.pnpm/node_modules:$NODE_PATH"
-fi
-if [ -x "$basedir/node" ]; then
-  exec "$basedir/node"  "$basedir/../typescript/bin/tsserver" "$@"
-else
-  exec node  "$basedir/../typescript/bin/tsserver" "$@"
-fi

package/dist/package.json

@@ -1,47 +0,0 @@
-{
-    "name": "@7nohe/openapi-react-query-codegen",
-    "version": "0.5.3",
-    "description": "OpenAPI React Query Codegen",
-    "bin": {
-        "openapi-rq": "dist/src/cli.js"
-    },
-    "scripts": {
-        "build": "tsc -p tsconfig.json",
-        "preview": "npm run build && npm -C examples/react-app run generate:api",
-        "prepublishOnly": "npm run build",
-        "release": "npx git-ensure -a && npx bumpp --commit --tag --push"
-    },
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/7nohe/openapi-react-query-codegen.git"
-    },
-    "homepage": "https://github.com/7nohe/openapi-react-query-codegen",
-    "bugs": "https://github.com/7nohe/openapi-react-query-codegen/issues",
-    "files": [
-        "dist"
-    ],
-    "keywords": [
-        "codegen",
-        "react-query",
-        "react",
-        "openapi",
-        "swagger",
-        "typescript",
-        "openapi-typescript-codegen"
-    ],
-    "author": "Daiki Urata (@7nohe)",
-    "license": "MIT",
-    "devDependencies": {
-        "@types/node": "^20.10.6",
-        "commander": "^12.0.0",
-        "glob": "^10.3.10",
-        "openapi-typescript-codegen": "0.25.0",
-        "typescript": "^5.3.3"
-    },
-    "peerDependencies": {
-        "commander": ">= 11 < 13",
-        "glob": ">= 10",
-        "openapi-typescript-codegen": "^0.24.0",
-        "typescript": ">= 4.8.3"
-    }
-}

package/dist/src/cli.js

@@ -1,27 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const generate_1 = require("./generate");
-const commander_1 = require("commander");
-const package_json_1 = __importDefault(require("../package.json"));
-const program = new commander_1.Command();
-program
-    .name("openapi-rq")
-    .version(package_json_1.default.version)
-    .description("Generate React Query code based on OpenAPI")
-    .requiredOption("-i, --input <value>", "OpenAPI specification, can be a path, url or string content (required)")
-    .option("-o, --output <value>", "Output directory", "openapi")
-    .option("-c, --client <value>", "HTTP client to generate [fetch, xhr, node, axios, angular]", "fetch")
-    .option("--useUnionTypes", "Use union types", false)
-    .option("--exportSchemas <value>", "Write schemas to disk", false)
-    .option("--indent <value>", "Indentation options [4, 2, tabs]", "4")
-    .option("--postfixServices <value>", "Service name postfix", "Service")
-    .option("--postfixModels <value>", "Modal name postfix")
-    .option("--request <value>", "Path to custom request file")
-    .parse();
-const options = program.opts();
-console.log(`Generating React Query code using OpenApi file ${options.output}`);
-(0, generate_1.generate)(options);

package/dist/src/common.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.lowercaseFirstLetter = exports.capitalizeFirstLetter = void 0;
-const capitalizeFirstLetter = (str) => {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-};
-exports.capitalizeFirstLetter = capitalizeFirstLetter;
-const lowercaseFirstLetter = (str) => {
-    return str.charAt(0).toLowerCase() + str.slice(1);
-};
-exports.lowercaseFirstLetter = lowercaseFirstLetter;

package/dist/src/constants.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.requestsOutputPath = exports.queriesOutputPath = exports.defaultOutputPath = void 0;
-exports.defaultOutputPath = "openapi";
-exports.queriesOutputPath = "queries";
-exports.requestsOutputPath = "requests";