react-query-lightbase-codegen 2.0.0 → 2.0.1

package/dist/generator/clientGenerator.js

@@ -69,7 +69,7 @@ function generateAxiosMethod(operation, spec) {
     // Add request body type if it exists
     const hasData = (parameters && parameters.length > 0) || operation.requestBody;
     let dataType = "undefined";
-    const namedType = (0, utils_1.pascalCase)(operationId);
+    const namedType = operationId;
     if (hasData) {
         if (requestBody && dataProps.length > 0) {
             dataType = `T.${namedType}Request & { ${dataProps.join("; ")} }`;
@@ -117,10 +117,10 @@ function generateAxiosMethod(operation, spec) {
             })
                 .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)
@@ -179,9 +179,9 @@ function generateApiClient(spec, config) {
             if (!operation)
                 return;
             operations.push({
-                method: method.toUpperCase(),
+                method: method,
                 path,
-                operationId: `${method}${(0, utils_1.sanitizeTypeName)(operation.operationId || `${path.replace(/\W+/g, "_")}`)}`,
+                operationId: (0, utils_1.pascalCase)(`${method}_${(0, utils_1.sanitizeTypeName)(operation.operationId || `${path.replace(/\W+/g, "_")}`)}`),
                 summary: operation.summary,
                 description: operation.description,
                 parameters: resolveParameters([...(pathItem.parameters || []), ...(operation.parameters || [])]),

package/dist/generator/reactQueryGenerator.js

@@ -31,7 +31,7 @@ function generateQueryOptions(operation, spec) {
     const namedQuery = (0, utils_1.camelCase)(operationId);
     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({
@@ -56,7 +56,7 @@ function generateReactQuery(spec) {
             operations.push({
                 method: method.toUpperCase(),
                 path,
-                operationId: `${method}${(0, utils_1.sanitizeTypeName)(operation.operationId || `${path.replace(/\W+/g, "_")}`)}`,
+                operationId: (0, utils_1.pascalCase)(`${method}_${(0, utils_1.sanitizeTypeName)(operation.operationId || `${path.replace(/\W+/g, "_")}`)}`),
                 summary: operation.summary,
                 description: operation.description,
                 parameters: [

package/dist/generator/schemaGenerator.js

@@ -51,17 +51,15 @@ function getTypeFromSchema(schema, context) {
             return "any";
     }
 }
-function generateTypeDefinition(badName, schema, context) {
+function generateTypeDefinition(name, schema, context) {
     const description = !("$ref" in schema) && schema.description ? `/**\n * ${schema.description}\n */\n` : "";
-    const name = (0, utils_1.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 = (0, utils_1.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`;
 }
 /**
  * Generates TypeScript interface definitions from OpenAPI schemas
@@ -88,12 +86,13 @@ function generateTypeDefinitions(spec) {
                 const operationObject = operation;
                 if (!operationObject)
                     continue;
+                const operationId = (0, utils_1.pascalCase)(`${method}_${(0, utils_1.sanitizeTypeName)(operationObject.operationId || `${path.replace(/\W+/g, "_")}`)}`);
                 // Generate request body type
                 if (operationObject.requestBody) {
                     const content = operationObject.requestBody.content;
                     const jsonContent = content["application/json"] || content["multipart/form-data"];
                     if (jsonContent?.schema) {
-                        const typeName = (0, utils_1.sanitizeTypeName)(`${operationObject.operationId}Request`);
+                        const typeName = (0, utils_1.sanitizeTypeName)(`${operationId}Request`);
                         output += generateTypeDefinition(typeName, jsonContent.schema, context);
                     }
                 }
@@ -103,8 +102,7 @@ function generateTypeDefinitions(spec) {
                         const responseObj = response;
                         const content = responseObj.content?.["application/json"];
                         if (content?.schema) {
-                            const opName = `${method}${(0, utils_1.sanitizeTypeName)(operationObject.operationId || `${path.replace(/\W+/g, "_")}`)}`;
-                            const typeName = (0, utils_1.sanitizeTypeName)(`${opName}_Response${code}`);
+                            const typeName = (0, utils_1.sanitizeTypeName)(`${operationId}Response${code}`);
                             output += generateTypeDefinition(typeName, content.schema, context);
                         }
                     }

package/dist/utils.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "react-query-lightbase-codegen",
-	"version": "2.0.0",
+	"version": "2.0.1",
 	"license": "MIT",
 	"description": "Generate Axios API clients and React Query options from OpenAPI specifications",
 	"exports": "./dist/index.js",

package/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 || [])]),

package/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: [

package/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);
 						}
 					}

package/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());
 }