@7nohe/openapi-react-query-codegen 2.0.0-beta.3 → 2.1.0

package/dist/common.mjs

@@ -160,9 +160,11 @@ export function createQueryKeyExport({ methodName, queryKey, }) {
         ts.factory.createVariableDeclaration(ts.factory.createIdentifier(queryKey), undefined, undefined, ts.factory.createStringLiteral(`${capitalizeFirstLetter(methodName)}`)),
     ], ts.NodeFlags.Const));
 }
-export function createQueryKeyFnExport(queryKey, method, type = "query") {
+export function createQueryKeyFnExport(queryKey, method, type = "query", modelNames = []) {
     // Mutation keys don't require clientOptions
-    const params = type === "query" ? getRequestParamFromMethod(method) : null;
+    const params = type === "query"
+        ? getRequestParamFromMethod(method, undefined, modelNames)
+        : null;
     // override key is used to allow the user to override the the queryKey values
     const overrideKey = ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier(type === "query" ? "queryKey" : "mutationKey"), QuestionToken, ts.factory.createTypeReferenceNode("Array<unknown>", []));
     return ts.factory.createVariableStatement([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
@@ -190,22 +192,15 @@ function mutationKeyFn(mutationKey) {
     ], false);
 }
 export function getRequestParamFromMethod(method, pageParam, modelNames = []) {
-    if (!getVariableArrowFunctionParameters(method).length) {
+    const sdkParams = getVariableArrowFunctionParameters(method);
+    if (!sdkParams.length) {
         return null;
     }
     const methodName = getNameFromVariable(method);
-    const params = getVariableArrowFunctionParameters(method).flatMap((param) => {
-        const paramNodes = extractPropertiesFromObjectParam(param);
-        return paramNodes
-            .filter((p) => p.name !== pageParam)
-            .map((refParam) => ({
-            name: refParam.name,
-            // TODO: Client<Request, Response, unknown, RequestOptions> -> Client<Request, Response, unknown>
-            typeName: getShortType(refParam.type?.getText() ?? ""),
-            optional: refParam.optional,
-        }));
-    });
-    const areAllPropertiesOptional = params.every((param) => param.optional);
+    // Use the SDK function's parameter optionality as the authoritative check.
+    // Generic types like Options<XData, ThrowOnError> may not resolve correctly
+    // via extractPropertiesFromObjectParam for type alias properties (path, url).
+    const areAllPropertiesOptional = sdkParams[0].isOptional();
     return ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier("clientOptions"), undefined, ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("Options"), [
         ts.factory.createTypeReferenceNode(modelNames.includes(`${capitalizeFirstLetter(methodName)}Data`)
             ? `${capitalizeFirstLetter(methodName)}Data`

package/dist/constants.mjs

@@ -1,7 +1,7 @@
 export const defaultOutputPath = "openapi";
 export const queriesOutputPath = "queries";
 export const requestsOutputPath = "requests";
-export const serviceFileName = "services.gen";
+export const serviceFileName = "sdk.gen";
 export const modelsFileName = "types.gen";
 export const OpenApiRqFiles = {
     queries: "queries",

package/dist/createExports.mjs

@@ -24,14 +24,16 @@ export const createExports = ({ service, client, project, pageParam, nextPagePar
         if (ts.isTypeAliasDeclaration(node) && methodDataNames[key] !== undefined) {
             // get the type alias declaration
             const typeAliasDeclaration = node.type;
-            if (typeAliasDeclaration.kind === ts.SyntaxKind.TypeLiteral) {
-                const query = typeAliasDeclaration.members.find((m) => m.kind === ts.SyntaxKind.PropertySignature &&
-                    m.name?.getText() === "query");
-                if (query &&
-                    query.type.members
-                        .map((m) => m.name?.getText())
-                        .includes(pageParam)) {
-                    paginatableMethods.push(methodDataNames[key]);
+            if (ts.isTypeLiteralNode(typeAliasDeclaration)) {
+                const query = typeAliasDeclaration.members.find((m) => ts.isPropertySignature(m) && m.name?.getText() === "query");
+                if (query) {
+                    const queryType = query.type;
+                    const members = queryType && ts.isTypeLiteralNode(queryType)
+                        ? queryType.members
+                        : undefined;
+                    if (members?.map((m) => m.name?.getText()).includes(pageParam)) {
+                        paginatableMethods.push(methodDataNames[key]);
+                    }
                 }
             }
         }
@@ -82,7 +84,7 @@ export const createExports = ({ service, client, project, pageParam, nextPagePar
     const mainExports = [...mainQueries, ...mainMutations];
     const infiniteQueriesExports = allQueries
         .flatMap(({ infiniteQueryHook }) => [infiniteQueryHook])
-        .filter(Boolean);
+        .filter((x) => x != null);
     const suspenseQueries = allQueries.flatMap(({ suspenseQueryHook }) => [
         suspenseQueryHook,
     ]);

package/dist/createImports.mjs

@@ -16,13 +16,13 @@ export const createImports = ({ project, client, }) => {
         ? Array.from(modelsFile.getExportedDeclarations().keys())
         : [];
     const serviceExports = Array.from(serviceFile.getExportedDeclarations().keys());
-    const serviceNames = serviceExports;
+    // Filter out type-only exports (e.g. Options) to avoid duplicate imports,
+    // since Options is already imported separately from the client module.
+    const serviceNames = serviceExports.filter((name) => name !== "Options");
     const imports = [
-        ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([
-            ts.factory.createImportSpecifier(true, undefined, ts.factory.createIdentifier("Options")),
-        ])), ts.factory.createStringLiteral(client === "@hey-api/client-axios"
-            ? "@hey-api/client-axios"
-            : "@hey-api/client-fetch"), undefined),
+        ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(true, undefined, ts.factory.createNamedImports([
+            ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("Options")),
+        ])), ts.factory.createStringLiteral(join("../requests", serviceFileName)), undefined),
         ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([
             ts.factory.createImportSpecifier(true, undefined, ts.factory.createIdentifier("QueryClient")),
             ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("useQuery")),
@@ -32,6 +32,7 @@ export const createImports = ({ project, client, }) => {
             ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("UseQueryOptions")),
             ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("UseMutationOptions")),
             ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("UseMutationResult")),
+            ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("UseSuspenseQueryOptions")),
         ])), ts.factory.createStringLiteral("@tanstack/react-query"), undefined),
         ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([
             // import all class names from service file

package/dist/createUseMutation.mjs

@@ -23,11 +23,17 @@ export const createUseMutation = ({ functionDescription: { method, jsDoc }, mode
     const responseDataType = ts.factory.createTypeParameterDeclaration(undefined, TData, undefined, ts.factory.createTypeReferenceNode(BuildCommonTypeName(mutationResult.name)));
     // @hey-api/client-axios -> `TError = AxiosError<AddPetError>`
     // @hey-api/client-fetch -> `TError = AddPetError`
-    const responseErrorType = ts.factory.createTypeParameterDeclaration(undefined, TError, undefined, client === "@hey-api/client-axios"
-        ? ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("AxiosError"), [
-            ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(`${capitalizeFirstLetter(methodName)}Error`)),
-        ])
-        : ts.factory.createTypeReferenceNode(`${capitalizeFirstLetter(methodName)}Error`));
+    const errorTypeName = `${capitalizeFirstLetter(methodName)}Error`;
+    const hasErrorType = modelNames.includes(errorTypeName);
+    const responseErrorType = ts.factory.createTypeParameterDeclaration(undefined, TError, undefined, hasErrorType
+        ? client === "@hey-api/client-axios"
+            ? ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("AxiosError"), [
+                ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(errorTypeName)),
+            ])
+            : ts.factory.createTypeReferenceNode(errorTypeName)
+        : client === "@hey-api/client-axios"
+            ? ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("AxiosError"), [ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword)])
+            : ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword));
     const methodParameters = getVariableArrowFunctionParameters(method).length !== 0
         ? ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("Options"), [
             ts.factory.createTypeReferenceNode(modelNames.includes(`${capitalizeFirstLetter(methodName)}Data`)

package/dist/createUseQuery.mjs

@@ -1,7 +1,7 @@
 import ts from "typescript";
 import { BuildCommonTypeName, EqualsOrGreaterThanToken, TData, TError, capitalizeFirstLetter, createQueryKeyExport, createQueryKeyFnExport, getNameFromVariable, getQueryKeyFnName, getRequestParamFromMethod, getVariableArrowFunctionParameters, queryKeyConstraint, queryKeyGenericType, } from "./common.mjs";
 import { addJSDocToNode } from "./util.mjs";
-const createApiResponseType = ({ methodName, client, }) => {
+const createApiResponseType = ({ methodName, client, modelNames, }) => {
     /** Awaited<ReturnType<typeof myClass.myMethod>> */
     const awaitedResponseDataType = ts.factory.createIndexedAccessTypeNode(ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("Awaited"), [
         ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("ReturnType"), [
@@ -13,11 +13,21 @@ const createApiResponseType = ({ methodName, client, }) => {
      */
     const apiResponse = ts.factory.createTypeAliasDeclaration([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier(`${capitalizeFirstLetter(methodName)}DefaultResponse`), undefined, awaitedResponseDataType);
     const responseDataType = ts.factory.createTypeParameterDeclaration(undefined, TData.text, undefined, ts.factory.createTypeReferenceNode(BuildCommonTypeName(apiResponse.name)));
-    const responseErrorType = ts.factory.createTypeParameterDeclaration(undefined, TError.text, undefined, client === "@hey-api/client-axios"
-        ? ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("AxiosError"), [
-            ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(`${capitalizeFirstLetter(methodName)}Error`)),
-        ])
-        : ts.factory.createTypeReferenceNode(`${capitalizeFirstLetter(methodName)}Error`));
+    // Response data type for suspense - wrap with NonNullable to exclude undefined
+    const suspenseResponseDataType = ts.factory.createTypeParameterDeclaration(undefined, TData.text, undefined, ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("NonNullable"), [
+        ts.factory.createTypeReferenceNode(BuildCommonTypeName(apiResponse.name)),
+    ]));
+    const errorTypeName = `${capitalizeFirstLetter(methodName)}Error`;
+    const hasErrorType = modelNames.includes(errorTypeName);
+    const responseErrorType = ts.factory.createTypeParameterDeclaration(undefined, TError.text, undefined, hasErrorType
+        ? client === "@hey-api/client-axios"
+            ? ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("AxiosError"), [
+                ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(errorTypeName)),
+            ])
+            : ts.factory.createTypeReferenceNode(errorTypeName)
+        : client === "@hey-api/client-axios"
+            ? ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("AxiosError"), [ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword)])
+            : ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword));
     return {
         /**
          * DefaultResponseDataType
@@ -31,6 +41,12 @@ const createApiResponseType = ({ methodName, client, }) => {
          * MyClassMethodDefaultResponse
          */
         responseDataType,
+        /**
+         * ResponseDataType for suspense - wrap with NonNullable to exclude undefined
+         *
+         * NonNullable<MyClassMethodDefaultResponse>
+         */
+        suspenseResponseDataType,
         /**
          * ErrorDataType
          *
@@ -76,6 +92,10 @@ function createQueryHook({ queryString, suffix, responseDataType, responseErrorT
         throw new Error("pageParam and nextPageParam are required for infinite queries");
     }
     const isInfiniteQuery = queryString === "useInfiniteQuery";
+    const isSuspenseQuery = queryString === "useSuspenseQuery";
+    // ts.TypeParameterDeclaration.default is ts.TypeNode | undefined.
+    // We know it's a TypeReferenceNode with an Identifier typeName because we created it
+    // via ts.factory in createApiResponseType, but TypeScript cannot infer the specific subtype.
     const responseDataTypeRef = responseDataType.default;
     const responseDataTypeIdentifier = responseDataTypeRef.typeName;
     const hookExport = ts.factory.createVariableStatement([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
@@ -93,7 +113,9 @@ function createQueryHook({ queryString, suffix, responseDataType, responseErrorT
             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"), [
+                    : isSuspenseQuery
+                        ? "UseSuspenseQueryOptions"
+                        : "UseQueryOptions"), [
                     ts.factory.createTypeReferenceNode(TData),
                     ts.factory.createTypeReferenceNode(TError),
                 ]),
@@ -153,9 +175,10 @@ function createQueryHook({ queryString, suffix, responseDataType, responseErrorT
 export const createUseQuery = ({ functionDescription: { method, jsDoc }, client, pageParam, nextPageParam, initialPageParam, paginatableMethods, modelNames, }) => {
     const methodName = getNameFromVariable(method);
     const queryKey = createQueryKeyFromMethod({ method });
-    const { apiResponse: defaultApiResponse, responseDataType, responseErrorType, } = createApiResponseType({
+    const { apiResponse: defaultApiResponse, responseDataType, suspenseResponseDataType, responseErrorType, } = createApiResponseType({
         methodName,
         client,
+        modelNames,
     });
     const requestParam = getRequestParamFromMethod(method, undefined, modelNames);
     const infiniteRequestParam = getRequestParamFromMethod(method, pageParam, modelNames);
@@ -171,7 +194,7 @@ export const createUseQuery = ({ functionDescription: { method, jsDoc }, client,
     const suspenseQueryHook = createQueryHook({
         queryString: "useSuspenseQuery",
         suffix: "Suspense",
-        responseDataType,
+        responseDataType: suspenseResponseDataType,
         responseErrorType,
         requestParams,
         method,
@@ -203,7 +226,7 @@ export const createUseQuery = ({ functionDescription: { method, jsDoc }, client,
         methodName,
         queryKey,
     });
-    const queryKeyFn = createQueryKeyFnExport(queryKey, method);
+    const queryKeyFn = createQueryKeyFnExport(queryKey, method, "query", modelNames);
     return {
         apiResponse: defaultApiResponse,
         returnType: returnTypeExport,

package/dist/generate.mjs

@@ -1,3 +1,5 @@
+import { writeFile } from "node:fs/promises";
+import path from "node:path";
 import { createClient } from "@hey-api/openapi-ts";
 import { buildQueriesOutputPath, buildRequestsOutputPath, formatOptions, } from "./common.mjs";
 import { createSource } from "./createSource.mjs";
@@ -6,34 +8,47 @@ import { print } from "./print.mjs";
 export async function generate(options, version) {
     const openApiOutputPath = buildRequestsOutputPath(options.output);
     const formattedOptions = formatOptions(options);
+    // Map CLI options to new plugins system
+    const clientPlugin = formattedOptions.client === "@hey-api/client-axios"
+        ? "@hey-api/client-axios"
+        : "@hey-api/client-fetch";
+    const typescriptPlugin = formattedOptions.enums
+        ? {
+            name: "@hey-api/typescript",
+            enums: formattedOptions.enums,
+        }
+        : "@hey-api/typescript";
+    const sdkPlugin = formattedOptions.noOperationId
+        ? {
+            name: "@hey-api/sdk",
+            operationId: false,
+        }
+        : "@hey-api/sdk";
+    const plugins = [
+        clientPlugin,
+        typescriptPlugin,
+        sdkPlugin,
+    ];
+    // Conditionally add schemas plugin
+    if (!formattedOptions.noSchemas) {
+        plugins.push(formattedOptions.schemaType
+            ? {
+                name: "@hey-api/schemas",
+                type: formattedOptions.schemaType,
+            }
+            : "@hey-api/schemas");
+    }
     const config = {
-        client: formattedOptions.client,
-        debug: formattedOptions.debug,
         dryRun: false,
-        exportCore: true,
-        output: {
-            format: formattedOptions.format,
-            lint: formattedOptions.lint,
-            path: openApiOutputPath,
-        },
         input: formattedOptions.input,
-        schemas: {
-            export: !formattedOptions.noSchemas,
-            type: formattedOptions.schemaType,
-        },
-        services: {
-            export: true,
-            asClass: false,
-            operationId: !formattedOptions.noOperationId,
-        },
-        types: {
-            dates: formattedOptions.useDateType,
-            export: true,
-            enums: formattedOptions.enums,
-        },
-        useOptions: true,
+        output: openApiOutputPath,
+        plugins,
     };
     await createClient(config);
+    // Generate backward-compatible services.gen.ts shim
+    // client.gen.ts has the `client` instance; sdk.gen.ts has SDK functions
+    const shimContent = `// This file is auto-generated for backward compatibility\nexport * from './client.gen.js';\nexport * from './sdk.gen.js';\n`;
+    await writeFile(path.join(openApiOutputPath, "services.gen.ts"), shimContent);
     const source = await createSource({
         outputPath: openApiOutputPath,
         client: formattedOptions.client,

package/dist/service.mjs

@@ -15,36 +15,55 @@ export async function getServices(project) {
 }
 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) => {
+    // Filter to only exported variable statements that contain arrow functions
+    const exportedStatements = variableStatements.filter((statement) => {
+        if (!statement.isExported())
+            return false;
+        const declarations = statement.getDeclarations();
+        return declarations.some((decl) => {
+            const initializer = decl.getInitializer();
+            return initializer && ts.isArrowFunction(initializer.compilerNode);
+        });
+    });
+    return exportedStatements.flatMap((variableStatement) => {
         const declarations = variableStatement.getDeclarations();
-        return declarations.map((declaration) => {
-            if (!ts.isVariableDeclaration(declaration.compilerNode)) {
-                throw new Error("Variable declaration not found");
-            }
+        // Filter to only arrow function declarations within the statement
+        const arrowDeclarations = declarations.filter((declaration) => {
             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");
+            return initializer && ts.isArrowFunction(initializer.compilerNode);
+        });
+        return arrowDeclarations.map((declaration) => {
+            const initializer = declaration.getInitializerOrThrow();
+            const compilerNode = initializer.compilerNode;
+            const arrowBody = compilerNode.body;
+            // Find the call expression - either from block's return statement or direct expression
+            let callExpression;
+            let methodBlockNode;
+            if (ts.isBlock(arrowBody)) {
+                // Old style: arrow function with block body
+                methodBlockNode = arrowBody;
+                const returnStatement = arrowBody.statements.find(ts.isReturnStatement);
+                if (!returnStatement) {
+                    throw new Error("Return statement not found");
+                }
+                if (!returnStatement.expression) {
+                    throw new Error("Call expression not found");
+                }
+                callExpression = returnStatement.expression;
             }
-            const foundReturnStatement = methodBlockNode.statements.find((s) => s.kind === ts.SyntaxKind.ReturnStatement);
-            if (!foundReturnStatement) {
-                throw new Error("Return statement not found");
+            else {
+                // New style: arrow function with expression body (no block)
+                // The body is a call expression like: (options?.client ?? client).post<...>({...})
+                callExpression = arrowBody;
             }
-            const returnStatement = foundReturnStatement;
-            const foundCallExpression = returnStatement.expression;
-            if (!foundCallExpression) {
-                throw new Error("Call expression not found");
+            // Navigate to find the HTTP method name (get, post, put, delete, etc.)
+            let httpMethodName;
+            if (ts.isCallExpression(callExpression)) {
+                const expr = callExpression.expression;
+                if (ts.isPropertyAccessExpression(expr)) {
+                    httpMethodName = expr.name.text;
+                }
             }
-            const callExpression = foundCallExpression;
-            const propertyAccessExpression = callExpression.expression;
-            const httpMethodName = propertyAccessExpression.name.getText();
             if (!httpMethodName) {
                 throw new Error("httpMethodName not found");
             }
@@ -56,7 +75,7 @@ export function getMethodsFromService(node) {
                 }
                 return [tsNode];
             };
-            const children = getAllChildren(initializer.compilerNode);
+            const children = getAllChildren(variableStatement.compilerNode);
             // get all JSDoc comments
             // this should be an array of 1 or 0
             const jsDocs = children

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@7nohe/openapi-react-query-codegen",
-  "version": "2.0.0-beta.3",
+  "version": "2.1.0",
   "description": "OpenAPI React Query Codegen",
   "bin": {
     "openapi-rq": "dist/cli.mjs"
@@ -39,29 +39,29 @@
   "license": "MIT",
   "author": "Daiki Urata (@7nohe)",
   "dependencies": {
-    "@hey-api/client-fetch": "0.4.0",
-    "@hey-api/openapi-ts": "0.53.8",
+    "@hey-api/openapi-ts": "0.92.3",
     "cross-spawn": "^7.0.3"
   },
   "devDependencies": {
     "@biomejs/biome": "^1.9.3",
     "@types/cross-spawn": "^6.0.6",
     "@types/node": "^22.7.4",
+    "@types/semver": "^7.7.1",
     "@vitest/coverage-v8": "^1.5.0",
     "commander": "^12.0.0",
     "lefthook": "^1.6.10",
     "rimraf": "^5.0.5",
-    "ts-morph": "^23.0.0",
-    "typescript": "^5.5.4",
+    "ts-morph": "^27.0.2",
+    "typescript": "^5.9.3",
     "vitest": "^1.5.0"
   },
   "peerDependencies": {
     "commander": "12.x",
-    "ts-morph": "23.x",
+    "ts-morph": "27.x",
     "typescript": "5.x"
   },
   "engines": {
-    "node": ">=14",
+    "node": ">=20.19.0",
     "pnpm": ">=9"
   },
   "scripts": {