@7nohe/openapi-react-query-codegen 2.0.0 → 2.2.0

package/dist/common.mjs

@@ -192,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")),

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"), [
@@ -17,11 +17,17 @@ const createApiResponseType = ({ methodName, client, }) => {
     const suspenseResponseDataType = ts.factory.createTypeParameterDeclaration(undefined, TData.text, undefined, ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("NonNullable"), [
         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`));
+    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
@@ -87,6 +93,9 @@ function createQueryHook({ queryString, suffix, responseDataType, responseErrorT
     }
     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([
@@ -169,6 +178,7 @@ export const createUseQuery = ({ functionDescription: { method, jsDoc }, client,
     const { apiResponse: defaultApiResponse, responseDataType, suspenseResponseDataType, responseErrorType, } = createApiResponseType({
         methodName,
         client,
+        modelNames,
     });
     const requestParam = getRequestParamFromMethod(method, undefined, modelNames);
     const infiniteRequestParam = getRequestParamFromMethod(method, pageParam, modelNames);

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,50 @@ 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` was deprecated in favor of `operations.nesting`
+            operations: {
+                nesting: "id",
+            },
+        }
+        : "@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",
+  "version": "2.2.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.99.0",
     "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": "^28.0.0",
+    "typescript": "^6.0.3",
     "vitest": "^1.5.0"
   },
   "peerDependencies": {
     "commander": "12.x",
-    "ts-morph": "23.x",
-    "typescript": "5.x"
+    "ts-morph": "28.x",
+    "typescript": "5.x || 6.x"
   },
   "engines": {
-    "node": ">=14",
+    "node": ">=22.18.0",
     "pnpm": ">=9"
   },
   "scripts": {