react-query-lightbase-codegen 1.6.3 → 2.0.0

package/src/generator/clientGenerator.ts

@@ -0,0 +1,234 @@
+import type { OpenAPIV3 } from "openapi-types";
+import type { OpenAPIConfig } from "../types/config";
+import { camelCase, pascalCase, sanitizePropertyName, 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;
+}
+
+function generateAxiosMethod(operation: OperationInfo, spec: OpenAPIV3.Document): string {
+	const { method, path, operationId, summary, description, parameters, requestBody, responses } = operation;
+	// Generate JSDoc
+	const jsDocLines = ["/**"];
+	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}`
+		);
+	});
+
+	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"));
+	if (responseDetails) {
+		const [code, response] = responseDetails;
+		const responseObj = response as OpenAPIV3.ResponseObject;
+		const desc = "description" in responseObj ? responseObj.description : "";
+		const contentType = responseObj.content?.["application/json"]?.schema;
+		const typeName = `${operationId}Response${code}`;
+
+		if (contentType) {
+			if (desc) {
+				jsDocLines.push(` * @returns ${desc}`);
+			}
+			jsDocLines.push(` * @see ${typeName}`);
+		} else if (desc) {
+			jsDocLines.push(` * @returns ${desc}`);
+		}
+	}
+
+	jsDocLines.push(" */");
+
+	const urlParams = parameters?.filter((p) => p.in === "path") || [];
+	const queryParams = parameters?.filter((p) => p.in === "query") || [];
+
+	const isFormData = requestBody && "content" in requestBody && requestBody.content?.["multipart/form-data"];
+
+	const formDataSchema = isFormData
+		? resolveSchema(requestBody.content["multipart/form-data"].schema, spec)
+		: undefined;
+
+	const requestBodySchema = requestBody?.content?.["application/json"]?.schema
+		? resolveSchema(requestBody.content["application/json"].schema, spec)
+		: undefined;
+
+	// Build data type parts
+	const dataProps: string[] = [];
+
+	// Add path and query parameters
+	urlParams.forEach((p) => {
+		const safeName = sanitizePropertyName(p.name);
+		dataProps.push(`${safeName}: ${getTypeFromParam(p)}`);
+	});
+	queryParams.forEach((p) => {
+		const safeName = sanitizePropertyName(p.name);
+		dataProps.push(`${safeName}${p.required ? "" : "?"}: ${getTypeFromParam(p)}`);
+	});
+
+	// Add request body type if it exists
+	const hasData = (parameters && parameters.length > 0) || operation.requestBody;
+
+	let dataType = "undefined";
+	const namedType = pascalCase(operationId);
+	if (hasData) {
+		if (requestBody && dataProps.length > 0) {
+			dataType = `T.${namedType}Request & { ${dataProps.join("; ")} }`;
+		} else if (requestBody) {
+			dataType = `T.${namedType}Request`;
+		} else if (dataProps.length > 0) {
+			dataType = `{ ${dataProps.join("; ")} }`;
+		} else {
+			dataType = "Record<string, never>";
+		}
+	}
+
+	// Get response type from 2xx response
+	const successResponse = Object.entries(responses).find(([code]) => code.startsWith("2"));
+	const responseType = successResponse ? `T.${`${namedType}Response${successResponse[0]}`}` : "any";
+
+	const urlWithParams = urlParams.length > 0 ? path.replace(/{(\w+)}/g, "${data.$1}") : path;
+
+	const methodBody = [
+		"const apiClient = getApiClient();",
+		`const url = \`${urlWithParams}\`;`,
+		queryParams.length > 0
+			? `const queryData = {
+				${queryParams.map((p) => `["${p.name}"]: data["${p.name}"]`).join(",\n				")}
+			};`
+			: "",
+		requestBodySchema?.properties
+			? `const bodyData = {
+				${Object.entries(requestBodySchema.properties)
+					.map(([key]) => `${key}: data.${key}`)
+					.join(",\n				")}
+			};`
+			: "",
+		formDataSchema?.properties
+			? `const formData = new FormData();
+			${Object.entries(formDataSchema.properties)
+				.map(([key, prop]) => {
+					const schemaProperty = prop as OpenAPIV3.SchemaObject;
+					const isBinary = schemaProperty.format === "binary";
+					return formDataSchema?.required?.includes(key)
+						? `formData.append("${key}", ${isBinary ? "" : "String("}${queryParams.length > 0 ? "bodyData" : "data"}.${key}${isBinary ? "" : ")"});`
+						: `if (${queryParams.length > 0 ? "bodyData" : "data"}.${key} != null) {
+							formData.append("${key}", ${isBinary ? "" : "String("}${queryParams.length > 0 ? "bodyData" : "data"}.${key}${isBinary ? "" : ")"});
+						}`;
+				})
+				.join("\n			")}`
+			: "",
+		`return apiClient.${method.toLowerCase()}<${responseType}>(url, {
+			${queryParams.length > 0 ? "params: queryData," : ""}
+			${requestBody ? `data: ${isFormData ? "formData" : "bodyData"},` : ""}
+			${isFormData ? `config: { headers: { 'Content-Type': 'multipart/form-data', ...config.headers }, ...config },` : "...config"}
+		});`,
+	]
+		.filter(Boolean)
+		.join("\n	");
+
+	return `
+	${jsDocLines.join("\n	")}
+	export function ${camelCase(operationId)}(data${hasData ? `: ${dataType}` : "?: undefined"}, config?: AxiosRequestConfig): Promise<AxiosResponse<${responseType}>> {
+		${methodBody}
+	}`;
+}
+
+function getTypeFromParam(param: OpenAPIV3.ParameterObject): string {
+	if ("schema" in param) {
+		const schema = param.schema as OpenAPIV3.SchemaObject;
+		switch (schema.type) {
+			case "string":
+				return "string";
+			case "integer":
+			case "number":
+				return "number";
+			case "boolean":
+				return "boolean";
+			case "array":
+				return "Array<any>"; // You might want to make this more specific
+			default:
+				return "any";
+		}
+	}
+	return "any";
+}
+
+export function generateApiClient(spec: OpenAPIV3.Document, config: OpenAPIConfig): 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.toUpperCase(),
+				path,
+				operationId: `${method}${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 title = specTitle(spec);
+
+	return `import type { AxiosResponse, AxiosRequestConfig } from 'axios';
+import { getApiClient } from './apiClient';
+import type * as T from './${title}.schema';
+
+${operations.map((op) => generateAxiosMethod(op, spec)).join("\n\n")}`;
+}

package/src/generator/instanceGenerator.ts

@@ -0,0 +1,20 @@
+import type { OpenAPIV3 } from "openapi-types";
+
+export function generateInstance(): string {
+	return `import type { AxiosInstance } from 'axios';
+
+let apiClient: AxiosInstance;
+
+export function setApiClient(instance: AxiosInstance): void {
+	apiClient = instance;
+}
+
+export function getApiClient(): AxiosInstance {
+	if (!apiClient) {
+		throw new Error('API client not configured. Call setApiClient with an axios instance first.');
+	}
+	return apiClient;
+}
+
+export { apiClient };`;
+}

package/src/generator/reactQueryGenerator.ts

@@ -0,0 +1,92 @@
+import type { OpenAPIV3 } from "openapi-types";
+import { camelCase, sanitizeTypeName, specTitle } from "../utils";
+import type { OperationInfo } from "./clientGenerator";
+
+function generateQueryOptions(operation: OperationInfo, spec: OpenAPIV3.Document): string {
+	const { operationId, parameters, requestBody } = operation;
+
+	const hasData = (parameters && parameters.length > 0) || operation.requestBody;
+
+	// Helper to get required fields from a schema
+	const getRequiredFields = (
+		schema: OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject,
+		context: { schemas: { [key: string]: OpenAPIV3.SchemaObject } }
+	): string[] => {
+		if ("$ref" in schema) {
+			const refType = schema.$ref.split("/").pop();
+			const refSchema = context.schemas[refType as string];
+			return refSchema?.required?.map((p) => `'${p}'`) || [];
+		}
+		return schema.required?.map((p) => `'${p}'`) || [];
+	};
+
+	// Get required parameter names from both parameters and request body
+	const requiredParams = [
+		...(parameters?.filter((p) => p.required).map((p) => `'${p.name}'`) || []),
+		...(requestBody && "content" in requestBody && requestBody.content?.["application/json"]?.schema
+			? getRequiredFields(requestBody.content["application/json"].schema, {
+					schemas: (spec.components?.schemas as { [key: string]: OpenAPIV3.SchemaObject }) || {},
+				})
+			: []),
+		...(requestBody && "content" in requestBody && requestBody.content?.["multipart/form-data"]?.schema
+			? getRequiredFields(requestBody.content["multipart/form-data"].schema, {
+					schemas: (spec.components?.schemas as { [key: string]: OpenAPIV3.SchemaObject }) || {},
+				})
+			: []),
+	];
+
+	const namedQuery = camelCase(operationId);
+
+	return `
+export const ${namedQuery}QueryOptions = (
+  ${hasData ? `params: Partial<Parameters<typeof apiClient.${namedQuery}>[0]>, config?: Partial<Parameters<typeof apiClient.${namedQuery}>[1]>` : ""}
+) => {
+  const enabled = ${hasData ? `hasDefinedProps(params, ${requiredParams.join(", ")})` : "true"};
+  return queryOptions({
+    queryKey: ['${camelCase(operationId)}', ${hasData ? "params" : "undefined"}],
+    queryFn: enabled ? async () => {
+      const response = await apiClient.${namedQuery}(${hasData ? "params" : "undefined"}, config);
+      return response.data;
+    } : skipToken,
+  });
+};`;
+}
+
+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.toUpperCase(),
+				path,
+				operationId: `${method}${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,
+			});
+		});
+	});
+
+	return `import { queryOptions, skipToken } from '@tanstack/react-query';
+	import * as apiClient from './${specTitle(spec)}.client';
+const hasDefinedProps = <T extends { [P in K]?: any }, K extends PropertyKey>(
+  obj: T,
+  ...keys: K[]
+): obj is T & { [P in K]-?: Exclude<T[P], undefined> } => {
+  return keys.every((k) => obj[k] !== undefined);
+};
+
+${operations.map((op) => generateQueryOptions(op, spec)).join("\n\n")}
+`;
+}

package/src/generator/schemaGenerator.ts

@@ -0,0 +1,139 @@
+import type { OpenAPIV3 } from "openapi-types";
+import { camelCase, pascalCase, sanitizePropertyName, sanitizeTypeName } from "../utils";
+
+interface SchemaContext {
+	schemas: { [key: string]: OpenAPIV3.SchemaObject };
+	generatedTypes: Set<string>;
+}
+
+/**
+ * Converts OpenAPI schema type to TypeScript type
+ */
+function getTypeFromSchema(
+	schema: OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject,
+	context: SchemaContext
+): string {
+	if (!schema) return "any";
+
+	if ("$ref" in schema) {
+		const refType = schema.$ref.split("/").pop();
+		return sanitizeTypeName(refType as string);
+	}
+
+	// Handle enum types properly
+	if (schema.enum) {
+		return schema.enum.map((e) => (typeof e === "string" ? `'${e}'` : e)).join(" | ");
+	}
+
+	switch (schema.type) {
+		case "string":
+			return "string";
+		case "number":
+		case "integer":
+			return "number";
+		case "boolean":
+			return "boolean";
+		case "array": {
+			const itemType = getTypeFromSchema(schema.items, context);
+			return `Array<${itemType}>`;
+		}
+		case "object":
+			if (schema.properties) {
+				const properties = Object.entries(schema.properties)
+					.map(([key, prop]) => {
+						const isRequired = schema.required?.includes(key);
+						const propertyType = getTypeFromSchema(prop, context);
+						const safeName = sanitizePropertyName(key);
+						return `  ${safeName}${isRequired ? "" : "?"}: ${propertyType};`;
+					})
+					.join("\n");
+				return `{\n${properties}\n}`;
+			}
+			if (schema.additionalProperties) {
+				const valueType =
+					typeof schema.additionalProperties === "boolean"
+						? "any"
+						: getTypeFromSchema(schema.additionalProperties, context);
+				return `Record<string, ${valueType}>`;
+			}
+			return "Record<string, any>";
+		default:
+			return "any";
+	}
+}
+
+function generateTypeDefinition(
+	badName: 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`;
+}
+
+/**
+ * Generates TypeScript interface definitions from OpenAPI schemas
+ */
+export function generateTypeDefinitions(spec: OpenAPIV3.Document): string {
+	const context: SchemaContext = {
+		schemas: (spec.components?.schemas as { [key: string]: OpenAPIV3.SchemaObject }) || {},
+		generatedTypes: new Set(),
+	};
+
+	let output = "/* Generated TypeScript Definitions */\n\n";
+
+	// Generate types for all schema definitions
+	for (const [name, schema] of Object.entries(context.schemas)) {
+		if (context.generatedTypes.has(name)) continue;
+		output += generateTypeDefinition(name, schema, context);
+		context.generatedTypes.add(name);
+	}
+
+	// Generate request/response types
+	if (spec.paths) {
+		for (const [path, pathItem] of Object.entries(spec.paths)) {
+			for (const [method, operation] of Object.entries(pathItem as OpenAPIV3.PathItemObject)) {
+				if (method === "$ref") continue;
+
+				const operationObject = operation as OpenAPIV3.OperationObject;
+				if (!operationObject) continue;
+
+				// 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`);
+						output += generateTypeDefinition(typeName, jsonContent.schema as OpenAPIV3.SchemaObject, context);
+					}
+				}
+
+				// Generate response types
+				if (operationObject.responses) {
+					for (const [code, response] of Object.entries(operationObject.responses)) {
+						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}`);
+							output += generateTypeDefinition(typeName, content.schema as OpenAPIV3.SchemaObject, context);
+						}
+					}
+				}
+			}
+		}
+	}
+
+	return output;
+}

package/src/index.ts

@@ -1,3 +1,78 @@
-import { convertSwaggerFile } from './convertSwaggerFile.js';
-import { importSpecs } from './importSpecs.js';
-export { importSpecs, convertSwaggerFile };
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import axios from "axios";
+import type { OpenAPIV3 } from "openapi-types";
+import * as yaml from "yaml";
+import { generateApiClient } from "./generator/clientGenerator";
+import { generateInstance } from "./generator/instanceGenerator";
+import { generateReactQuery } from "./generator/reactQueryGenerator";
+import { generateTypeDefinitions } from "./generator/schemaGenerator";
+import type { OpenAPIConfig } from "./types/config";
+import { specTitle } from "./utils";
+
+/**
+ * Loads the OpenAPI specification from either a URL or local file
+ */
+async function loadOpenAPISpec(specSource: string): Promise<OpenAPIV3.Document> {
+	try {
+		if (specSource.startsWith("http")) {
+			const response = await axios.get(specSource);
+			// Check if response is YAML by looking for common YAML indicators
+			const isYaml =
+				typeof response.data === "string" &&
+				(response.data.trim().startsWith("openapi:") || response.data.trim().startsWith("swagger:"));
+
+			return isYaml ? yaml.parse(response.data) : response.data;
+		}
+
+		const content = await readFile(specSource, "utf-8");
+		// Handle both JSON and YAML formats
+		return specSource.endsWith(".json") ? JSON.parse(content) : yaml.parse(content);
+	} catch (error) {
+		if (error instanceof Error) {
+			throw new Error(`Failed to load OpenAPI spec: ${error.message}`);
+		}
+		throw new Error("Failed to load OpenAPI spec: Unknown error");
+	}
+}
+
+/**
+ * Main function to generate the API client
+ */
+export async function codegenerate(config: OpenAPIConfig): Promise<void> {
+	try {
+		// Load specs
+		const specs = Array.isArray(config.specSource)
+			? await Promise.all(config.specSource.map(loadOpenAPISpec))
+			: [await loadOpenAPISpec(config.specSource)];
+
+		// Create export directory if it doesn't exist
+		await mkdir(config.exportDir, { recursive: true });
+
+		// Generate and write type definitions
+		const instance = generateInstance();
+		await writeFile(resolve(config.exportDir, "apiClient.ts"), instance, "utf-8");
+
+		// Generate for each spec...
+		for (const spec of specs) {
+			const title = specTitle(spec);
+
+			// Generate and write type definitions
+			const typeDefinitions = generateTypeDefinitions(spec);
+			await writeFile(resolve(config.exportDir, `${title}.schema.ts`), typeDefinitions, "utf-8");
+
+			// Generate and write API client
+			const clientCode = generateApiClient(spec, config);
+			await writeFile(resolve(config.exportDir, `${title}.client.ts`), clientCode, "utf-8");
+
+			// Generate and write React Query options
+			const queryCode = generateReactQuery(spec);
+			await writeFile(resolve(config.exportDir, `${title}.queryOptions.ts`), queryCode, "utf-8");
+		}
+	} catch (error) {
+		if (error instanceof Error) {
+			throw new Error(`Failed to generate API client: ${error.message}`);
+		}
+		throw new Error("Failed to generate API client: Unknown error");
+	}
+}

package/src/types/config.ts

@@ -0,0 +1,12 @@
+export interface OpenAPIConfig {
+	/**
+	 * OpenAPI specification source - can be a URL or local file path
+	 * Supports JSON, YAML, or YML formats
+	 */
+	specSource: string | string[];
+
+	/**
+	 * Directory where generated files will be exported
+	 */
+	exportDir: string;
+}

package/src/types.ts

@@ -0,0 +1,5 @@
+export interface Config {
+	input: string;
+	output: string;
+	axiosInstancePath: string; // Path to the file exporting the axios instance
+}