react-query-lightbase-codegen 2.5.11 → 3.1.0

package/src/cli.ts

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+
+import { readFile, stat } from "node:fs/promises";
+import { resolve } from "node:path";
+import { codegenerate } from "./index";
+import type { OpenAPIConfig } from "./types/config";
+
+const VERSION = "2.5.11";
+
+const HELP = `
+react-query-lightbase-codegen - Generate React Query clients from OpenAPI specs
+
+USAGE:
+  npx react-query-lightbase-codegen [options] <spec...> -o <output>
+  npx react-query-lightbase-codegen --config <config-file>
+
+ARGUMENTS:
+  <spec...>           One or more OpenAPI spec files (local paths or URLs)
+
+OPTIONS:
+  -o, --output <dir>  Output directory for generated files (default: ./generated)
+  -c, --config <file> Path to JSON config file
+  -h, --help          Show this help message
+  -v, --version       Show version number
+
+EXAMPLES:
+  # Single local spec
+  npx react-query-lightbase-codegen ./api.yaml -o ./src/generated
+
+  # Remote spec
+  npx react-query-lightbase-codegen https://api.example.com/openapi.json -o ./generated
+
+  # Multiple specs
+  npx react-query-lightbase-codegen ./auth.yaml ./users.yaml -o ./generated
+
+  # Using config file
+  npx react-query-lightbase-codegen --config ./codegen.json
+
+CONFIG FILE FORMAT:
+  {
+    "specSource": "./api.yaml",        // or ["./auth.yaml", "./users.yaml"]
+    "exportDir": "./src/generated"
+  }
+`;
+
+interface ParsedArgs {
+	specs: string[];
+	output: string;
+	config?: string;
+	help: boolean;
+	version: boolean;
+}
+
+function parseArgs(args: string[]): ParsedArgs {
+	const result: ParsedArgs = {
+		specs: [],
+		output: "./generated",
+		help: false,
+		version: false,
+	};
+
+	let i = 0;
+	while (i < args.length) {
+		const arg = args[i];
+
+		switch (arg) {
+			case "-h":
+			case "--help":
+				result.help = true;
+				break;
+
+			case "-v":
+			case "--version":
+				result.version = true;
+				break;
+
+			case "-o":
+			case "--output":
+				i++;
+				if (i >= args.length) {
+					throw new Error("Missing value for --output");
+				}
+				result.output = args[i];
+				break;
+
+			case "-c":
+			case "--config":
+				i++;
+				if (i >= args.length) {
+					throw new Error("Missing value for --config");
+				}
+				result.config = args[i];
+				break;
+
+			default:
+				if (arg.startsWith("-")) {
+					throw new Error(`Unknown option: ${arg}`);
+				}
+				result.specs.push(arg);
+				break;
+		}
+		i++;
+	}
+
+	return result;
+}
+
+async function loadConfigFile(configPath: string): Promise<OpenAPIConfig> {
+	try {
+		const content = await readFile(configPath, "utf-8");
+		const config = JSON.parse(content);
+
+		if (!config.specSource) {
+			throw new Error("Config file must contain 'specSource'");
+		}
+		if (!config.exportDir) {
+			throw new Error("Config file must contain 'exportDir'");
+		}
+
+		return {
+			specSource: config.specSource,
+			exportDir: resolve(process.cwd(), config.exportDir),
+		};
+	} catch (error) {
+		if (error instanceof Error) {
+			throw new Error(`Failed to load config file: ${error.message}`);
+		}
+		throw new Error("Failed to load config file");
+	}
+}
+
+function resolveSpecPath(spec: string): string {
+	// Keep URLs as-is
+	if (spec.startsWith("http://") || spec.startsWith("https://")) {
+		return spec;
+	}
+	// Resolve local paths relative to cwd
+	return resolve(process.cwd(), spec);
+}
+
+async function main(): Promise<void> {
+	const args = process.argv.slice(2);
+
+	if (args.length === 0) {
+		console.log(HELP);
+		process.exit(0);
+	}
+
+	let parsed: ParsedArgs;
+	try {
+		parsed = parseArgs(args);
+	} catch (error) {
+		if (error instanceof Error) {
+			console.error(`Error: ${error.message}`);
+		}
+		console.error("Use --help for usage information");
+		process.exit(1);
+	}
+
+	if (parsed.help) {
+		console.log(HELP);
+		process.exit(0);
+	}
+
+	if (parsed.version) {
+		console.log(`react-query-lightbase-codegen v${VERSION}`);
+		process.exit(0);
+	}
+
+	let config: OpenAPIConfig;
+
+	if (parsed.config) {
+		// Load from config file
+		config = await loadConfigFile(parsed.config);
+	} else {
+		// Build config from CLI args
+		if (parsed.specs.length === 0) {
+			console.error("Error: No spec files provided");
+			console.error("Use --help for usage information");
+			process.exit(1);
+		}
+
+		const resolvedSpecs = parsed.specs.map(resolveSpecPath);
+
+		config = {
+			specSource: resolvedSpecs.length === 1 ? resolvedSpecs[0] : resolvedSpecs,
+			exportDir: resolve(process.cwd(), parsed.output),
+		};
+	}
+
+	try {
+		console.log("Generating API client...");
+		console.log(
+			`  Specs: ${Array.isArray(config.specSource) ? config.specSource.join(", ") : config.specSource}`
+		);
+		console.log(`  Output: ${config.exportDir}`);
+		console.log("");
+
+		await codegenerate(config);
+
+		console.log("Generation complete!");
+	} catch (error) {
+		if (error instanceof Error) {
+			console.error(`Error: ${error.message}`);
+		} else {
+			console.error("An unknown error occurred");
+		}
+		process.exit(1);
+	}
+}
+
+main();

package/src/generator/clientGenerator.ts

@@ -1,63 +1,55 @@
 import type { OpenAPIV3 } from "openapi-types";
-import { camelCase, pascalCase, sanitizeTypeName, specTitle } from "../utils";
-
-export interface OperationInfo {
-	method: string;
-	path: string;
-	operationId: string;
-	summary?: string;
-	description?: string;
-	parameters?: OpenAPIV3.ParameterObject[];
-	requestBody?: OpenAPIV3.RequestBodyObject;
-	responses: OpenAPIV3.ResponsesObject;
-}
-
-function resolveSchema(
-	schema: OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject | undefined,
-	spec: OpenAPIV3.Document
-): OpenAPIV3.SchemaObject | undefined {
-	if (!schema) return undefined;
-	if ("$ref" in schema) {
-		const index = schema.$ref.split("/").pop();
-		return spec.components?.schemas?.[index as string] as OpenAPIV3.SchemaObject;
-	}
-	return schema;
-}
+import {
+	type OperationInfo,
+	camelCase,
+	collectOperations,
+	getContentSchema,
+	pascalCase,
+	resolveSchema,
+	specTitle,
+} from "../utils";
 
 function generateAxiosMethod(operation: OperationInfo, spec: OpenAPIV3.Document): string {
-	const { method, path, operationId, summary, description, parameters, requestBody, responses } = operation;
+	const { method, path, operationId, summary, description, deprecated, parameters, requestBody, responses } =
+		operation;
 	// Generate JSDoc
 	const jsDocLines = ["/**"];
+	if (deprecated) jsDocLines.push(" * @deprecated");
 	if (summary) jsDocLines.push(` * ${summary}`);
 	if (description) jsDocLines.push(` * ${description}`);
 
 	// Add parameter descriptions
 	parameters?.forEach((param) => {
 		const desc = param.description ? ` - ${param.description}` : "";
-		jsDocLines.push(
-			` * @param ${param.in === "path" ? "params." : param.in === "query" ? "query." : ""}${param.name}${desc}`
-		);
+		const prefix =
+			param.in === "path"
+				? "params."
+				: param.in === "query"
+					? "query."
+					: param.in === "header"
+						? "headers."
+						: param.in === "cookie"
+							? "cookies."
+							: "";
+		jsDocLines.push(` * @param ${prefix}${param.name}${desc}`);
 	});
 
 	if (requestBody && "description" in requestBody) {
 		jsDocLines.push(` * @param data - ${requestBody.description}`);
 	}
 
-	// Add return type description
-	const responseDetails = Object.entries(responses).find(([code]) => code.startsWith("2"));
+	// Add return type description - prefer 2xx responses, fall back to "default"
+	const responseDetails =
+		Object.entries(responses).find(([code]) => code.startsWith("2")) ||
+		Object.entries(responses).find(([code]) => code === "default");
 	if (responseDetails) {
 		const [code, response] = responseDetails;
 		const responseObj = response as OpenAPIV3.ResponseObject;
 		const desc = "description" in responseObj ? responseObj.description : "";
-		const contentType =
-			responseObj.content?.["application/ld+json"]?.schema ??
-			responseObj.content?.["application/json"]?.schema ??
-			responseObj.content?.["application/octet-stream"]?.schema ??
-			responseObj.content?.["application/json;charset=UTF-8"]?.schema;
-
+		const contentSchema = getContentSchema(responseObj.content);
 		const typeName = pascalCase(`${operationId}Response${code}`);
 
-		if (contentType) {
+		if (contentSchema) {
 			if (desc) {
 				jsDocLines.push(` * @returns ${desc}`);
 			}
@@ -72,6 +64,7 @@ function generateAxiosMethod(operation: OperationInfo, spec: OpenAPIV3.Document)
 	const urlParams = parameters?.filter((p) => p.in === "path") || [];
 	const queryParams = parameters?.filter((p) => p.in === "query") || [];
 	const headerParams = parameters?.filter((p) => p.in === "header") || [];
+	const cookieParams = parameters?.filter((p) => p.in === "cookie") || [];
 
 	const isFormData = requestBody && "content" in requestBody && requestBody.content?.["multipart/form-data"];
 
@@ -79,15 +72,9 @@ function generateAxiosMethod(operation: OperationInfo, spec: OpenAPIV3.Document)
 		? resolveSchema(requestBody.content["multipart/form-data"].schema, spec)
 		: undefined;
 
-	const content =
-		requestBody && "content" in requestBody
-			? (requestBody.content?.["application/ld+json"]?.schema ??
-				requestBody.content?.["application/json"]?.schema ??
-				requestBody.content?.["application/octet-stream"]?.schema ??
-				requestBody.content?.["application/json;charset=UTF-8"]?.schema)
-			: undefined;
-
-	const requestBodySchema = content ? resolveSchema(content, spec) : undefined;
+	const requestBodyContent =
+		requestBody && "content" in requestBody ? getContentSchema(requestBody.content) : undefined;
+	const requestBodySchema = requestBodyContent ? resolveSchema(requestBodyContent, spec) : undefined;
 
 	// Check if request body is a primitive type (string, number, boolean)
 	const isPrimitiveRequestBody =
@@ -102,11 +89,19 @@ function generateAxiosMethod(operation: OperationInfo, spec: OpenAPIV3.Document)
 	const namedType = pascalCase(operationId);
 
 	// Get response type from 2xx response
-
-	const responseType =
-		responseDetails?.[0] && "content" in responseDetails[1]
-			? `T.${`${namedType}Response${responseDetails[0]}`}`
-			: "unknown";
+	const responseType = (() => {
+		if (!responseDetails) return "unknown";
+		const [code, response] = responseDetails;
+		// If response has content, use the generated type
+		if ("content" in response && response.content) {
+			return `T.${namedType}Response${code}`;
+		}
+		// 204 (No Content) and 205 (Reset Content) should return void
+		if (code === "204" || code === "205") {
+			return "void";
+		}
+		return "unknown";
+	})();
 
 	const urlWithParams =
 		urlParams.length > 0 ? `\`${path.replace(/{(\w+)}/g, "${encodeURIComponent(data.$1)}")}\`` : `"${path}"`;
@@ -151,27 +146,25 @@ function generateAxiosMethod(operation: OperationInfo, spec: OpenAPIV3.Document)
 				.join("\n			")}`
 			: "",
 		queryParams.length > 0 ? "axiosConfig.params = { ...axiosConfig.params, ...queryData };" : "",
-		isFormData
-			? "axiosConfig.headers = { ...axiosConfig.headers, 'Content-Type': 'multipart/form-data' };"
-			: "",
 		headerParams.length > 0
-			? `const headerData = {
-			${headerParams.map((p) => `["${p.name}"]: data["${p.name}"]`).join(",\n				")}
-		};`
+			? `axiosConfig.headers = { ...axiosConfig.headers, ${headerParams.map((p) => `["${p.name}"]: data["${p.name}"]`).join(", ")} };`
 			: "",
-		headerParams.length > 0 ? "axiosConfig.headers = { ...axiosConfig.headers, ...headerData };" : "",
+		cookieParams.length > 0
+			? `axiosConfig.headers = { ...axiosConfig.headers, Cookie: [${cookieParams.map((p) => `data["${p.name}"] != null ? \`${p.name}=\${data["${p.name}"]}\` : null`).join(", ")}].filter(Boolean).join("; ") };`
+			: "",
+		// Note: Don't set Content-Type for FormData - Axios will set it automatically with the correct boundary
 		requestBody
-			? `const res = await apiClient.${method}<${responseType}>(url, ${formDataSchema?.properties || requestBodySchema?.properties ? "bodyData" : "data"}, axiosConfig);`
-			: `const res = await apiClient.${method}<${responseType}>(url, axiosConfig);`,
-		"return res.data;",
+			? responseType === "void"
+				? `await apiClient.${method}<${responseType}>(url, ${formDataSchema?.properties || requestBodySchema?.properties ? "bodyData" : "data"}, axiosConfig);`
+				: `const res = await apiClient.${method}<${responseType}>(url, ${formDataSchema?.properties || requestBodySchema?.properties ? "bodyData" : "data"}, axiosConfig);`
+			: responseType === "void"
+				? `await apiClient.${method}<${responseType}>(url, axiosConfig);`
+				: `const res = await apiClient.${method}<${responseType}>(url, axiosConfig);`,
+		responseType !== "void" ? "return res.data;" : "",
 	]
 		.filter(Boolean)
 		.join("\n	");
 
-	// ${queryParams.length > 0 ? "params: queryData," : ""}
-	// ${requestBody ? `data: ${isFormData ? "formData" : "bodyData"},` : ""}
-	// ${isFormData ? `config: { headers: { 'Content-Type': 'multipart/form-data', ...axiosConfig?.headers }, ...axiosConfig },` : "...axiosConfig"}
-
 	const requestParms = hasData
 		? isPrimitiveRequestBody
 			? `props: { data: T.${pascalCase(operationId)}Params; axiosConfig?: AxiosRequestConfig; }`
@@ -186,53 +179,10 @@ function generateAxiosMethod(operation: OperationInfo, spec: OpenAPIV3.Document)
 }
 
 export function generateApiClient(spec: OpenAPIV3.Document): string {
-	const operations: OperationInfo[] = [];
-
-	const resolveParameters = (
-		parameters: (OpenAPIV3.ParameterObject | OpenAPIV3.ReferenceObject)[]
-	): OpenAPIV3.ParameterObject[] => {
-		return parameters.map((p) => {
-			if ("$ref" in p) {
-				const index = p.$ref.split("/").pop();
-				return spec.components?.schemas?.[index as string] as OpenAPIV3.ParameterObject;
-			}
-			return p;
-		});
-	};
-
-	const resolveRequestBody = (
-		requestBody: OpenAPIV3.RequestBodyObject | OpenAPIV3.ReferenceObject | undefined
-	): OpenAPIV3.RequestBodyObject | undefined => {
-		if (!requestBody) return undefined;
-		if ("$ref" in requestBody) {
-			const index = requestBody.$ref.split("/").pop();
-			return spec.components?.schemas?.[index as string] as OpenAPIV3.RequestBodyObject;
-		}
-		return requestBody;
-	};
-
-	// Collect all operations
-	Object.entries(spec.paths || {}).forEach(([path, pathItem]) => {
-		if (!pathItem) return;
-		["get", "post", "put", "delete", "patch"].forEach((method) => {
-			const operation = pathItem[method as keyof OpenAPIV3.PathItemObject] as OpenAPIV3.OperationObject;
-			if (!operation) return;
-			operations.push({
-				method: method,
-				path,
-				operationId: `${sanitizeTypeName(operation.operationId || `${path.replace(/\W+/g, "_")}`)}`,
-				summary: operation.summary,
-				description: operation.description,
-				parameters: resolveParameters([...(pathItem.parameters || []), ...(operation.parameters || [])]),
-				requestBody: resolveRequestBody(operation.requestBody),
-				responses: operation.responses,
-			});
-		});
-	});
-
+	const operations = collectOperations(spec);
 	const title = specTitle(spec);
 
-	return `import type { AxiosResponse, AxiosRequestConfig } from 'axios';
+	return `import type { AxiosRequestConfig } from 'axios';
 import { getApiClient } from './apiClient';
 import type * as T from './${title}.schema';
 

package/src/generator/reactQueryGenerator.ts

@@ -1,21 +1,15 @@
 import type { OpenAPIV3 } from "openapi-types";
-import { camelCase, sanitizeTypeName, specTitle } from "../utils";
-import type { OperationInfo } from "./clientGenerator";
-
-function resolveSchema(
-	schema: OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject | undefined,
-	spec: OpenAPIV3.Document
-): OpenAPIV3.SchemaObject | undefined {
-	if (!schema) return undefined;
-	if ("$ref" in schema) {
-		const index = schema.$ref.split("/").pop();
-		return spec.components?.schemas?.[index as string] as OpenAPIV3.SchemaObject;
-	}
-	return schema;
-}
+import {
+	type OperationInfo,
+	camelCase,
+	collectOperations,
+	getContentSchema,
+	resolveSchema,
+	specTitle,
+} from "../utils";
 
 function generateQueryOptions(operation: OperationInfo, spec: OpenAPIV3.Document): string {
-	const { operationId, parameters, requestBody, method } = operation;
+	const { operationId, parameters, requestBody, deprecated } = operation;
 
 	const hasData = (parameters && parameters.length > 0) || operation.requestBody;
 
@@ -32,13 +26,7 @@ function generateQueryOptions(operation: OperationInfo, spec: OpenAPIV3.Document
 		return schema.required?.map((p) => `'${p}'`) || [];
 	};
 
-	const content =
-		requestBody && "content" in requestBody
-			? (requestBody.content?.["application/ld+json"]?.schema ??
-				requestBody.content?.["application/json"]?.schema ??
-				requestBody.content?.["application/octet-stream"]?.schema)
-			: undefined;
-
+	const content = requestBody && "content" in requestBody ? getContentSchema(requestBody.content) : undefined;
 	const requestBodySchema = content ? resolveSchema(content, spec) : undefined;
 
 	// Check if request body is a primitive type (string, number, boolean)
@@ -90,8 +78,10 @@ function generateQueryOptions(operation: OperationInfo, spec: OpenAPIV3.Document
 			: `hasDefinedProps(${paramsVariable}, ${requiredParams.join(", ")})`
 		: "true";
 
+	const deprecatedComment = deprecated ? "/** @deprecated */\n" : "";
+
 	return `
-export const ${namedQueryOptions} = ( 
+${deprecatedComment}export const ${namedQueryOptions} = (
   ${hasData ? `props: Partial<Parameters<typeof apiClient.${namedQuery}>[0]>` : `props?: Partial<Parameters<typeof apiClient.${namedQuery}>[0]>`}
 ) => {
   ${destructuringLine}
@@ -104,37 +94,12 @@ export const ${namedQueryOptions} = (
 }
 
 export function generateReactQuery(spec: OpenAPIV3.Document): string {
-	const operations: OperationInfo[] = [];
-
-	// Collect operations (same as in clientGenerator)
-	Object.entries(spec.paths || {}).forEach(([path, pathItem]) => {
-		if (!pathItem) return;
-
-		["get", "post", "put", "delete", "patch"].forEach((method) => {
-			const operation = pathItem[method as keyof OpenAPIV3.PathItemObject] as OpenAPIV3.OperationObject;
-			if (!operation) return;
-			operations.push({
-				method: method,
-				path,
-				operationId: sanitizeTypeName(`${operation.operationId || `${path.replace(/\W+/g, "_")}`}`),
-				summary: operation.summary,
-				description: operation.description,
-				parameters: [
-					...(pathItem.parameters || []),
-					...(operation.parameters || []),
-				] as OpenAPIV3.ParameterObject[],
-				requestBody: operation.requestBody as OpenAPIV3.RequestBodyObject,
-				responses: operation.responses,
-			});
-		});
-	});
+	const operations = collectOperations(spec);
 
 	return `import { queryOptions, skipToken } from '@tanstack/react-query';
 	import * as apiClient from './${specTitle(spec)}.client';
-	// TEMPORARY: allows for backward compatibility imports
-	export * from './${specTitle(spec)}.client';
 
-const hasDefinedProps = <T extends { [P in K]?: any }, K extends PropertyKey>(
+const hasDefinedProps = <T extends { [P in K]?: unknown }, K extends PropertyKey>(
   obj: T,
   ...keys: K[]
 ): obj is T & { [P in K]-?: Exclude<T[P], undefined> } => {