fix: streamline naming conventions in client and query generators

This commit includes:
- Simplified the generation of operation IDs by removing unnecessary transformations.
- Updated the handling of Axios method calls to use the correct method name directly.
- Enhanced type definitions in the schema generator to utilize consistent naming practices.
- Improved the React Query generator to handle parameters more effectively.
- Cleaned up imports in the utils module by removing unused functions.

Author: owinter86

package.json

@@ -4,10 +4,7 @@
 	"license": "MIT",
 	"description": "Generate Axios API clients and React Query options from OpenAPI specifications",
 	"exports": "./dist/index.js",
-	"files": [
-		"src",
-		"dist"
-	],
+	"files": ["src", "dist"],
 	"author": {
 		"name": "Oliver Winter",
 		"email": "owinter86@gmail.com"

src/generator/clientGenerator.ts

@@ -95,7 +95,7 @@ function generateAxiosMethod(operation: OperationInfo, spec: OpenAPIV3.Document)
 	const hasData = (parameters && parameters.length > 0) || operation.requestBody;
 
 	let dataType = "undefined";
-	const namedType = pascalCase(operationId);
+	const namedType = operationId;
 	if (hasData) {
 		if (requestBody && dataProps.length > 0) {
 			dataType = `T.${namedType}Request & { ${dataProps.join("; ")} }`;
@@ -143,10 +143,10 @@ function generateAxiosMethod(operation: OperationInfo, spec: OpenAPIV3.Document)
 				})
 				.join("\n			")}`
 			: "",
-		`return apiClient.${method.toLowerCase()}<${responseType}>(url, {
+		`return apiClient.${method}<${responseType}>(url, {
 			${queryParams.length > 0 ? "params: queryData," : ""}
 			${requestBody ? `data: ${isFormData ? "formData" : "bodyData"},` : ""}
-			${isFormData ? `config: { headers: { 'Content-Type': 'multipart/form-data', ...config.headers }, ...config },` : "...config"}
+			${isFormData ? `config: { headers: { 'Content-Type': 'multipart/form-data', ...config?.headers }, ...config },` : "...config"}
 		});`,
 	]
 		.filter(Boolean)
@@ -212,9 +212,11 @@ export function generateApiClient(spec: OpenAPIV3.Document, config: OpenAPIConfi
 			const operation = pathItem[method as keyof OpenAPIV3.PathItemObject] as OpenAPIV3.OperationObject;
 			if (!operation) return;
 			operations.push({
-				method: method.toUpperCase(),
+				method: method,
 				path,
-				operationId: `${method}${sanitizeTypeName(operation.operationId || `${path.replace(/\W+/g, "_")}`)}`,
+				operationId: pascalCase(
+					`${method}_${sanitizeTypeName(operation.operationId || `${path.replace(/\W+/g, "_")}`)}`
+				),
 				summary: operation.summary,
 				description: operation.description,
 				parameters: resolveParameters([...(pathItem.parameters || []), ...(operation.parameters || [])]),

src/generator/reactQueryGenerator.ts

@@ -1,5 +1,5 @@
 import type { OpenAPIV3 } from "openapi-types";
-import { camelCase, sanitizeTypeName, specTitle } from "../utils";
+import { camelCase, pascalCase, sanitizeTypeName, specTitle } from "../utils";
 import type { OperationInfo } from "./clientGenerator";
 
 function generateQueryOptions(operation: OperationInfo, spec: OpenAPIV3.Document): string {
@@ -39,7 +39,7 @@ function generateQueryOptions(operation: OperationInfo, spec: OpenAPIV3.Document
 
 	return `
 export const ${namedQuery}QueryOptions = (
-  ${hasData ? `params: Partial<Parameters<typeof apiClient.${namedQuery}>[0]>, config?: Partial<Parameters<typeof apiClient.${namedQuery}>[1]>` : ""}
+  ${hasData ? `params: Partial<Parameters<typeof apiClient.${namedQuery}>[0]>, config?: Partial<Parameters<typeof apiClient.${namedQuery}>[1]>` : `_: undefined, config?: Partial<Parameters<typeof apiClient.${namedQuery}>[1]>`}
 ) => {
   const enabled = ${hasData ? `hasDefinedProps(params, ${requiredParams.join(", ")})` : "true"};
   return queryOptions({
@@ -65,7 +65,9 @@ export function generateReactQuery(spec: OpenAPIV3.Document): string {
 			operations.push({
 				method: method.toUpperCase(),
 				path,
-				operationId: `${method}${sanitizeTypeName(operation.operationId || `${path.replace(/\W+/g, "_")}`)}`,
+				operationId: pascalCase(
+					`${method}_${sanitizeTypeName(operation.operationId || `${path.replace(/\W+/g, "_")}`)}`
+				),
 				summary: operation.summary,
 				description: operation.description,
 				parameters: [

src/generator/schemaGenerator.ts

@@ -1,5 +1,5 @@
 import type { OpenAPIV3 } from "openapi-types";
-import { camelCase, pascalCase, sanitizePropertyName, sanitizeTypeName } from "../utils";
+import { pascalCase, sanitizePropertyName, sanitizeTypeName } from "../utils";
 
 interface SchemaContext {
 	schemas: { [key: string]: OpenAPIV3.SchemaObject };
@@ -63,23 +63,20 @@ function getTypeFromSchema(
 }
 
 function generateTypeDefinition(
-	badName: string,
+	name: string,
 	schema: OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject,
 	context: SchemaContext
 ): string {
 	const description = !("$ref" in schema) && schema.description ? `/**\n * ${schema.description}\n */\n` : "";
-
-	const name = sanitizeTypeName(badName);
-
 	const typeValue = getTypeFromSchema(schema, context);
 
 	// Use 'type' for primitives, unions, and simple types
 	// Use 'interface' only for complex objects with properties
 	const isInterface = !("$ref" in schema) && schema.type === "object" && schema.properties;
-	const namedInterface = pascalCase(name);
+
 	return isInterface
 		? `${description}export interface ${name} ${typeValue}\n\n`
-		: `${description}export type ${namedInterface} = ${typeValue}\n\n`;
+		: `${description}export type ${name} = ${typeValue}\n\n`;
 }
 
 /**
@@ -108,13 +105,16 @@ export function generateTypeDefinitions(spec: OpenAPIV3.Document): string {
 
 				const operationObject = operation as OpenAPIV3.OperationObject;
 				if (!operationObject) continue;
+				const operationId = pascalCase(
+					`${method}_${sanitizeTypeName(operationObject.operationId || `${path.replace(/\W+/g, "_")}`)}`
+				);
 
 				// Generate request body type
 				if (operationObject.requestBody) {
 					const content = (operationObject.requestBody as OpenAPIV3.RequestBodyObject).content;
 					const jsonContent = content["application/json"] || content["multipart/form-data"];
 					if (jsonContent?.schema) {
-						const typeName = sanitizeTypeName(`${operationObject.operationId}Request`);
+						const typeName = sanitizeTypeName(`${operationId}Request`);
 						output += generateTypeDefinition(typeName, jsonContent.schema as OpenAPIV3.SchemaObject, context);
 					}
 				}
@@ -125,8 +125,7 @@ export function generateTypeDefinitions(spec: OpenAPIV3.Document): string {
 						const responseObj = response as OpenAPIV3.ResponseObject;
 						const content = responseObj.content?.["application/json"];
 						if (content?.schema) {
-							const opName = `${method}${sanitizeTypeName(operationObject.operationId || `${path.replace(/\W+/g, "_")}`)}`;
-							const typeName = sanitizeTypeName(`${opName}_Response${code}`);
+							const typeName = sanitizeTypeName(`${operationId}Response${code}`);
 							output += generateTypeDefinition(typeName, content.schema as OpenAPIV3.SchemaObject, context);
 						}
 					}

src/utils.ts

@@ -9,7 +9,6 @@ export function camelCase(str: string): string {
 
 export function pascalCase(str: string): string {
 	return str
-		.toLowerCase()
 		.replace(/[^a-zA-Z0-9]+(.)/g, (_, chr) => chr.toUpperCase())
 		.replace(/^[a-z]/, (c) => c.toUpperCase());
 }