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

package/dist/format.mjs

@@ -1,3 +1,4 @@
+import { sync } from "cross-spawn";
 import { IndentationText, NewLineKind, Project, QuoteKind } from "ts-morph";
 export const formatOutput = async (outputPath) => {
     const project = new Project({
@@ -19,3 +20,48 @@ export const formatOutput = async (outputPath) => {
     });
     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", "--write", 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

@@ -1,13 +1,12 @@
 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 { 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,
@@ -18,15 +17,16 @@ export async function generate(options, version) {
             path: openApiOutputPath,
         },
         input: formattedOptions.input,
-        request: formattedOptions.request,
         schemas: {
             export: !formattedOptions.noSchemas,
             type: formattedOptions.schemaType,
         },
         services: {
             export: true,
-            response: formattedOptions.serviceResponse,
-            asClass: true,
+            asClass: false,
+            operationId: formattedOptions.operationId !== undefined
+                ? formattedOptions.operationId
+                : true,
         },
         types: {
             dates: formattedOptions.useDateType,
@@ -38,8 +38,8 @@ export async function generate(options, version) {
     await createClient(config);
     const source = await createSource({
         outputPath: openApiOutputPath,
+        client: formattedOptions.client,
         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,
         initialPageParam: formattedOptions.initialPageParam.toString(),
@@ -47,4 +47,9 @@ export async function generate(options, 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/service.mjs

@@ -1,5 +1,4 @@
 import ts from "typescript";
-import { getClassNameFromClassNode, getClassesFromService, } from "./common.mjs";
 import { serviceFileName } from "./constants.mjs";
 export async function getServices(project) {
     const node = project
@@ -8,72 +7,73 @@ export async function getServices(project) {
     if (!node) {
         throw new Error("No service node found");
     }
-    const klasses = getClassesFromService(node);
+    const methods = getMethodsFromService(node);
     return {
-        klasses: klasses.map(({ klass, className }) => ({
-            className,
-            klass,
-            methods: getMethodsFromService(node, klass),
-        })),
+        methods,
         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());
+export function getMethodsFromService(node) {
+    const variableStatements = node.getVariableStatements();
+    // The first variable statement is `const client = createClient(createConfig())`, so we skip it
+    return variableStatements.splice(1).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");
             }
-            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,
-        };
+            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/package.json

@@ -1,7 +1,31 @@
 {
   "name": "@7nohe/openapi-react-query-codegen",
-  "version": "1.6.1",
+  "version": "2.0.0-beta.1",
   "description": "OpenAPI React Query Codegen",
+  "bin": {
+    "openapi-rq": "dist/cli.mjs"
+  },
+  "private": false,
+  "type": "module",
+  "workspaces": [
+    "examples/*"
+  ],
+  "exports": [
+    {
+      "import": "./dist/generate.mjs",
+      "require": "./dist/generate.mjs",
+      "types": "./dist/generate.d.mts"
+    }
+  ],
+  "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",
@@ -12,44 +36,28 @@
     "openapi-typescript-codegen",
     "@hey-api/openapi-ts"
   ],
-  "homepage": "https://github.com/7nohe/openapi-react-query-codegen",
-  "bugs": "https://github.com/7nohe/openapi-react-query-codegen/issues",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/7nohe/openapi-react-query-codegen.git"
-  },
   "license": "MIT",
   "author": "Daiki Urata (@7nohe)",
-  "type": "module",
-  "bin": {
-    "openapi-rq": "dist/cli.mjs"
-  },
-  "files": [
-    "dist"
-  ],
-  "workspaces": [
-    "examples/*"
-  ],
   "dependencies": {
-    "@hey-api/openapi-ts": "0.52.0"
+    "@hey-api/client-fetch": "0.4.0",
+    "@hey-api/openapi-ts": "0.53.8",
+    "cross-spawn": "^7.0.3"
   },
   "devDependencies": {
-    "@biomejs/biome": "^1.7.2",
-    "@types/node": "^20.10.6",
+    "@biomejs/biome": "^1.9.3",
+    "@types/cross-spawn": "^6.0.6",
+    "@types/node": "^22.7.4",
     "@vitest/coverage-v8": "^1.5.0",
     "commander": "^12.0.0",
-    "glob": "^10.3.10",
     "lefthook": "^1.6.10",
     "rimraf": "^5.0.5",
     "ts-morph": "^23.0.0",
-    "ts-node": "^10.9.2",
     "typescript": "^5.5.4",
     "vitest": "^1.5.0"
   },
   "peerDependencies": {
     "commander": "12.x",
-    "glob": "10.x",
-    "ts-morph": "22.x",
+    "ts-morph": "23.x",
     "typescript": "5.x"
   },
   "engines": {
@@ -60,9 +68,11 @@
     "build": "rimraf dist && tsc -p tsconfig.json",
     "lint": "biome check .",
     "lint:fix": "biome check --write .",
-    "preview": "npm run build && npm -C examples/react-app run generate:api",
+    "preview:react": "npm run build && npm -C examples/react-app run generate:api",
+    "preview:nextjs": "npm run build && npm -C examples/nextjs-app run generate:api",
+    "preview:tanstack-router": "npm run build && npm -C examples/tanstack-router-app run generate:api",
     "release": "npx git-ensure -a && npx bumpp --commit --tag --push",
-    "snapshot": "vitest --update",
-    "test": "vitest --coverage.enabled true"
+    "test": "vitest --coverage.enabled true",
+    "snapshot": "vitest --update"
   }
 }

package/dist/createPrefetch.mjs

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