react-query-lightbase-codegen 2.5.11 → 3.0.0

package/src/generator/clientGenerator.ts

@@ -1,28 +1,13 @@
 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;
@@ -34,9 +19,15 @@ function generateAxiosMethod(operation: OperationInfo, spec: OpenAPIV3.Document)
 	// 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."
+						: "";
+		jsDocLines.push(` * @param ${prefix}${param.name}${desc}`);
 	});
 
 	if (requestBody && "description" in requestBody) {
@@ -49,15 +40,10 @@ function generateAxiosMethod(operation: OperationInfo, spec: OpenAPIV3.Document)
 		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}`);
 			}
@@ -79,15 +65,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 =
@@ -151,15 +131,12 @@ function generateAxiosMethod(operation: OperationInfo, spec: OpenAPIV3.Document)
 				.join("\n			")}`
 			: "",
 		queryParams.length > 0 ? "axiosConfig.params = { ...axiosConfig.params, ...queryData };" : "",
+		headerParams.length > 0
+			? `axiosConfig.headers = { ...axiosConfig.headers, ${headerParams.map((p) => `["${p.name}"]: data["${p.name}"]`).join(", ")} };`
+			: "",
 		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				")}
-		};`
-			: "",
-		headerParams.length > 0 ? "axiosConfig.headers = { ...axiosConfig.headers, ...headerData };" : "",
 		requestBody
 			? `const res = await apiClient.${method}<${responseType}>(url, ${formDataSchema?.properties || requestBodySchema?.properties ? "bodyData" : "data"}, axiosConfig);`
 			: `const res = await apiClient.${method}<${responseType}>(url, axiosConfig);`,
@@ -168,10 +145,6 @@ function generateAxiosMethod(operation: OperationInfo, spec: OpenAPIV3.Document)
 		.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 +159,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 } = 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)
@@ -104,30 +92,7 @@ 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';

package/src/generator/schemaGenerator.ts

@@ -1,9 +1,27 @@
 import type { OpenAPIV3 } from "openapi-types";
-import { getTypeFromSchema, pascalCase, sanitizePropertyName, sanitizeTypeName } from "../utils";
+import {
+	getContentSchema,
+	getTypeFromSchema,
+	pascalCase,
+	sanitizePropertyName,
+	sanitizeTypeName,
+} from "../utils";
 
-interface SchemaContext {
-	schemas: { [key: string]: OpenAPIV3.SchemaObject };
-	generatedTypes: Set<string>;
+/**
+ * Formats a parameter as a TypeScript property string with optional JSDoc.
+ */
+function formatParamProperty(param: OpenAPIV3.ParameterObject, forceRequired = false): string {
+	const safeName = sanitizePropertyName(param.name);
+	const isDeprecated = param.deprecated;
+	const hasDescription = param.description;
+	const isOptional = forceRequired ? false : !param.required;
+
+	const desc =
+		hasDescription || isDeprecated
+			? `/**${hasDescription ? `\n * ${param.description}` : ""}${isDeprecated ? "\n * @deprecated" : ""}\n */\n`
+			: "";
+
+	return `${desc}${safeName}${isOptional ? "?" : ""}: ${getTypeFromSchema(param.schema)}`;
 }
 
 function generateTypeDefinition(
@@ -26,18 +44,16 @@ function generateTypeDefinition(
  * 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(),
-	};
+	const schemas = (spec.components?.schemas as { [key: string]: OpenAPIV3.SchemaObject }) || {};
+	const generatedTypes = new Set<string>();
 
 	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;
+	for (const [name, schema] of Object.entries(schemas)) {
+		if (generatedTypes.has(name)) continue;
 		output += generateTypeDefinition(name, schema);
-		context.generatedTypes.add(name);
+		generatedTypes.add(name);
 	}
 
 	// Generate request/response types
@@ -54,34 +70,36 @@ export function generateTypeDefinitions(spec: OpenAPIV3.Document): string {
 				// Generate request body type
 				if (requestBody) {
 					const content = (requestBody as OpenAPIV3.RequestBodyObject).content;
-					const jsonContent =
-						content["application/ld+json"] ??
-						content["application/json"] ??
-						content["multipart/form-data"] ??
-						content["application/octet-stream"] ??
-						content["application/json;charset=UTF-8"];
-					if (jsonContent?.schema) {
+					const requestSchema = getContentSchema(content);
+					if (requestSchema) {
 						const typeName = `${operationId}Request`;
-						output += generateTypeDefinition(typeName, jsonContent.schema as OpenAPIV3.SchemaObject);
+						output += generateTypeDefinition(typeName, requestSchema as OpenAPIV3.SchemaObject);
 					}
 				}
 
 				// Generate response types
+				const errorTypes: string[] = [];
 				if (responses) {
 					for (const [code, response] of Object.entries(responses)) {
 						const responseObj = response as OpenAPIV3.ResponseObject;
-						const content =
-							responseObj.content?.["application/ld+json"] ??
-							responseObj.content?.["application/json"] ??
-							responseObj.content?.["application/octet-stream"] ??
-							responseObj.content?.["application/json;charset=UTF-8"];
-						if (content?.schema) {
+						const responseSchema = getContentSchema(responseObj.content);
+						if (responseSchema) {
 							const typeName = `${operationId}Response${code}`;
-							output += generateTypeDefinition(typeName, content.schema as OpenAPIV3.SchemaObject);
+							output += generateTypeDefinition(typeName, responseSchema as OpenAPIV3.SchemaObject);
+
+							// Track non-2xx responses for error union type
+							if (!code.startsWith("2")) {
+								errorTypes.push(typeName);
+							}
 						}
 					}
 				}
 
+				// Generate error union type if there are error responses
+				if (errorTypes.length > 0) {
+					output += `export type ${pascalCase(operationId)}Error = ${errorTypes.join(" | ")};\n\n`;
+				}
+
 				// Build data type parts
 				const dataProps: string[] = [];
 
@@ -92,42 +110,10 @@ export function generateTypeDefinitions(spec: OpenAPIV3.Document): string {
 				const headerParams = (parameters?.filter((p) => "in" in p && p.in === "header") ||
 					[]) as OpenAPIV3.ParameterObject[];
 
-				// Add path and query parameters
-				urlParams.forEach((p) => {
-					const safeName = sanitizePropertyName(p.name);
-					const isDeprecated = "deprecated" in p && p.deprecated;
-					const hasDescription = "description" in p && p.description;
-					const desc =
-						hasDescription || isDeprecated
-							? `/**${hasDescription ? `\n* ${p.description}` : ""}${isDeprecated ? "\n* @deprecated" : ""}
-							*/\n`
-							: "";
-					dataProps.push(`${desc}${safeName}: ${getTypeFromSchema(p.schema)}`);
-				});
-
-				queryParams.forEach((p) => {
-					const safeName = sanitizePropertyName(p.name);
-					const isDeprecated = "deprecated" in p && p.deprecated;
-					const hasDescription = "description" in p && p.description;
-					const desc =
-						hasDescription || isDeprecated
-							? `\n/**${hasDescription ? `\n* ${p.description}` : ""}${isDeprecated ? "\n* @deprecated" : ""}
-							*/\n`
-							: "";
-					dataProps.push(`${desc}${safeName}${p.required ? "" : "?"}: ${getTypeFromSchema(p.schema)}`);
-				});
-
-				headerParams.forEach((p) => {
-					const safeName = sanitizePropertyName(p.name);
-					const isDeprecated = "deprecated" in p && p.deprecated;
-					const hasDescription = "description" in p && p.description;
-					const desc =
-						hasDescription || isDeprecated
-							? `\n/**${hasDescription ? `\n* ${p.description}` : ""}${isDeprecated ? "\n* @deprecated" : ""}
-							*/\n`
-							: "";
-					dataProps.push(`${desc}${safeName}${p.required ? "" : "?"}: ${getTypeFromSchema(p.schema)}`);
-				});
+				// Add path, query, and header parameters
+				urlParams.forEach((p) => dataProps.push(formatParamProperty(p, true))); // Path params always required
+				queryParams.forEach((p) => dataProps.push(formatParamProperty(p)));
+				headerParams.forEach((p) => dataProps.push(formatParamProperty(p)));
 
 				// Add request body type if it exists
 				const hasData = (parameters && parameters.length > 0) || requestBody;

package/src/utils.ts

@@ -1,5 +1,115 @@
 import type { OpenAPIV3 } from "openapi-types";
 
+/**
+ * Supported content types in order of preference
+ */
+export const CONTENT_TYPES = [
+	"application/ld+json",
+	"application/json",
+	"multipart/form-data",
+	"application/octet-stream",
+	"application/json;charset=UTF-8",
+] as const;
+
+/**
+ * Resolves a schema reference to its actual schema object.
+ * If the schema is already a concrete schema (not a $ref), returns it as-is.
+ */
+export 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;
+}
+
+/**
+ * Extracts the schema from a content object, checking supported content types in order.
+ */
+export function getContentSchema(
+	content: { [media: string]: OpenAPIV3.MediaTypeObject } | undefined
+): OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject | undefined {
+	if (!content) return undefined;
+	for (const type of CONTENT_TYPES) {
+		if (content[type]?.schema) {
+			return content[type].schema;
+		}
+	}
+	return undefined;
+}
+
+/**
+ * Operation info extracted from OpenAPI paths
+ */
+export interface OperationInfo {
+	method: string;
+	path: string;
+	operationId: string;
+	summary?: string;
+	description?: string;
+	parameters: OpenAPIV3.ParameterObject[];
+	requestBody?: OpenAPIV3.RequestBodyObject;
+	responses: OpenAPIV3.ResponsesObject;
+}
+
+const HTTP_METHODS = ["get", "post", "put", "delete", "patch"] as const;
+
+/**
+ * Collects all operations from an OpenAPI spec, resolving parameter and request body references.
+ */
+export function collectOperations(spec: OpenAPIV3.Document): OperationInfo[] {
+	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?.parameters?.[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?.requestBodies?.[index as string] as OpenAPIV3.RequestBodyObject;
+		}
+		return requestBody;
+	};
+
+	Object.entries(spec.paths || {}).forEach(([path, pathItem]) => {
+		if (!pathItem) return;
+
+		HTTP_METHODS.forEach((method) => {
+			const operation = pathItem[method] as OpenAPIV3.OperationObject | undefined;
+			if (!operation) return;
+
+			operations.push({
+				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,
+			});
+		});
+	});
+
+	return operations;
+}
+
 export function camelCase(str: string): string {
 	return str
 		.replace(/[^a-zA-Z0-9]+(.)/g, (_, chr) => chr.toUpperCase())
@@ -63,6 +173,7 @@ export function specTitle(spec: OpenAPIV3.Document): string {
  * Handles:
  * - References ($ref) by extracting the type name
  * - Nullable types by appending "| null"
+ * - Composition types (allOf → intersection, oneOf/anyOf → union)
  * - Enums by creating union types of the values
  * - OneOf schemas as union types
  * - Basic types (string, number, boolean)
@@ -72,7 +183,7 @@ export function specTitle(spec: OpenAPIV3.Document): string {
  * - Objects with additionalProperties as Records
  * - Fallback to "any" for unknown types
  *
- * @param param - The OpenAPI schema/parameter object to convert
+ * @param schema - The OpenAPI schema/parameter object to convert
  * @returns The TypeScript type as a string
  */
 export function getTypeFromSchema(
@@ -88,6 +199,30 @@ export function getTypeFromSchema(
 	// Add "| null" for nullable types
 	const nullable = "nullable" in schema && schema.nullable ? " | null" : "";
 
+	// Handle allOf (intersection types)
+	if ("allOf" in schema && schema.allOf) {
+		const types = schema.allOf.map((s) => getTypeFromSchema(s)).filter(Boolean) as string[];
+		if (types.length === 0) return "any";
+		const result = types.length === 1 ? types[0] : `(${types.join(" & ")})`;
+		return `${result}${nullable}`;
+	}
+
+	// Handle oneOf (union types - exactly one)
+	if ("oneOf" in schema && schema.oneOf) {
+		const types = schema.oneOf.map((s) => getTypeFromSchema(s)).filter(Boolean) as string[];
+		if (types.length === 0) return "any";
+		const result = types.length === 1 ? types[0] : `(${types.join(" | ")})`;
+		return `${result}${nullable}`;
+	}
+
+	// Handle anyOf (union types - one or more)
+	if ("anyOf" in schema && schema.anyOf) {
+		const types = schema.anyOf.map((s) => getTypeFromSchema(s)).filter(Boolean) as string[];
+		if (types.length === 0) return "any";
+		const result = types.length === 1 ? types[0] : `(${types.join(" | ")})`;
+		return `${result}${nullable}`;
+	}
+
 	// Handle enums as union types
 	if ("enum" in schema && schema.enum) {
 		if (Object.values(schema.enum)?.length > 0) {
@@ -100,14 +235,6 @@ export function getTypeFromSchema(
 		return schema.enum.map((e) => (typeof e === "string" ? `'${e}'` : e)).join(" | ") + nullable;
 	}
 
-	// Handle oneOf as union types
-	if ("oneOf" in schema && schema.oneOf) {
-		const unionTypes = schema.oneOf
-			.map((subSchema) => getTypeFromSchema(subSchema))
-			.filter((type): type is string => type !== undefined);
-		return unionTypes.length > 0 ? `${unionTypes.join(" | ")}${nullable}` : `any${nullable}`;
-	}
-
 	// Handle types based on the "type" property
 	if ("type" in schema) {
 		switch (schema.type) {
@@ -143,8 +270,7 @@ export function getTypeFromSchema(
 							const hasDescription = "description" in prop && prop.description;
 							const desc =
 								hasDescription || isDeprecated
-									? `/**${hasDescription ? `\n* ${prop.description}` : ""}${isDeprecated ? "\n* @deprecated" : ""}
-									*/\n`
+									? `/**${hasDescription ? `\n * ${prop.description}` : ""}${isDeprecated ? "\n * @deprecated" : ""}\n */\n`
 									: "";
 							return `${desc}${safeName}${isRequired ? "" : "?"}: ${propertyType};`;
 						})