react-query-lightbase-codegen 3.1.6 → 3.1.7

package/dist/generator/schemaGenerator.js

@@ -18,10 +18,10 @@ function formatParamProperty(param, forceRequired = false) {
 function generateTypeDefinition(name, schema) {
     const description = !("$ref" in schema) && schema.description ? `/**\n * ${schema.description}\n */\n` : "";
     const typeValue = (0, utils_1.getTypeFromSchema)(schema);
-    // 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;
-    return isInterface
+    // Only emit `interface` when the body is a plain object literal. Composition
+    // (allOf/oneOf/anyOf) produces references or intersections that must use a type alias.
+    const canBeInterface = typeValue?.trimStart().startsWith("{");
+    return canBeInterface
         ? `${description}export interface ${(0, utils_1.sanitizeTypeName)(name)} ${typeValue}\n\n`
         : `${description}export type ${(0, utils_1.sanitizeTypeName)(name)} = ${typeValue}\n\n`;
 }

package/dist/utils.js

@@ -145,6 +145,36 @@ function specTitle(spec) {
     }
     return camelCase(title.toLowerCase().replace(/\s+/g, "-"));
 }
+/**
+ * Builds the object-literal fragment ({...} or Record<...>) from a schema's own
+ * `properties` or `additionalProperties`, ignoring composition keywords. Returns
+ * undefined when the schema contributes no own object shape.
+ */
+function getOwnObjectFragment(schema) {
+    if (schema.properties && Object.keys(schema.properties).length > 0) {
+        const properties = Object.entries(schema.properties)
+            .map(([key, prop]) => {
+            const isRequired = schema.required?.includes(key);
+            const propertyType = getTypeFromSchema(prop);
+            const safeName = sanitizePropertyName(key);
+            const isDeprecated = "deprecated" in prop && prop.deprecated;
+            const hasDescription = "description" in prop && prop.description;
+            const desc = hasDescription || isDeprecated
+                ? `/**${hasDescription ? `\n * ${prop.description}` : ""}${isDeprecated ? "\n * @deprecated" : ""}\n */\n`
+                : "";
+            return `${desc}${safeName}${isRequired ? "" : "?"}: ${propertyType};`;
+        })
+            .join("\n");
+        return `{${properties}\n}`;
+    }
+    if (schema.additionalProperties) {
+        const valueType = typeof schema.additionalProperties === "boolean"
+            ? "unknown"
+            : getTypeFromSchema(schema.additionalProperties);
+        return `Record<string, ${valueType}>`;
+    }
+    return undefined;
+}
 /**
  * Converts an OpenAPI schema object into a TypeScript type string.
  *
@@ -174,29 +204,36 @@ function getTypeFromSchema(schema) {
     }
     // Add "| null" for nullable types
     const nullable = "nullable" in schema && schema.nullable ? " | null" : "";
+    // Sibling properties / additionalProperties may appear next to allOf/oneOf/anyOf.
+    // Per the OpenAPI spec they constrain the parent and must be intersected with the composition.
+    const ownObjectFragment = getOwnObjectFragment(schema);
     // Handle allOf (intersection types)
     if ("allOf" in schema && schema.allOf) {
-        const types = schema.allOf.map((s) => getTypeFromSchema(s)).filter(Boolean);
-        if (types.length === 0)
+        const parts = schema.allOf.map((s) => getTypeFromSchema(s)).filter(Boolean);
+        if (ownObjectFragment)
+            parts.push(ownObjectFragment);
+        if (parts.length === 0)
             return "unknown";
-        const result = types.length === 1 ? types[0] : `(${types.join(" & ")})`;
+        const result = parts.length === 1 ? parts[0] : `(${parts.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);
-        if (types.length === 0)
+        if (types.length === 0 && !ownObjectFragment)
             return "unknown";
-        const result = types.length === 1 ? types[0] : `(${types.join(" | ")})`;
-        return `${result}${nullable}`;
+        const union = types.length === 1 ? types[0] : `(${types.join(" | ")})`;
+        const composed = ownObjectFragment ? `(${union} & ${ownObjectFragment})` : union;
+        return `${composed}${nullable}`;
     }
     // Handle anyOf (union types - one or more)
     if ("anyOf" in schema && schema.anyOf) {
         const types = schema.anyOf.map((s) => getTypeFromSchema(s)).filter(Boolean);
-        if (types.length === 0)
+        if (types.length === 0 && !ownObjectFragment)
             return "unknown";
-        const result = types.length === 1 ? types[0] : `(${types.join(" | ")})`;
-        return `${result}${nullable}`;
+        const union = types.length === 1 ? types[0] : `(${types.join(" | ")})`;
+        const composed = ownObjectFragment ? `(${union} & ${ownObjectFragment})` : union;
+        return `${composed}${nullable}`;
     }
     // Handle enums as union types
     if ("enum" in schema && schema.enum) {
@@ -242,33 +279,13 @@ function getTypeFromSchema(schema) {
                 const itemType = getTypeFromSchema(schema.items);
                 return `Array<${itemType}>${nullable}`;
             }
-            case "object":
-                // Handle objects with defined properties
-                if (schema.properties) {
-                    const properties = Object.entries(schema.properties)
-                        .map(([key, prop]) => {
-                        const isRequired = schema.required?.includes(key);
-                        const propertyType = getTypeFromSchema(prop);
-                        const safeName = sanitizePropertyName(key);
-                        const isDeprecated = "deprecated" in prop && prop.deprecated;
-                        const hasDescription = "description" in prop && prop.description;
-                        const desc = hasDescription || isDeprecated
-                            ? `/**${hasDescription ? `\n * ${prop.description}` : ""}${isDeprecated ? "\n * @deprecated" : ""}\n */\n`
-                            : "";
-                        return `${desc}${safeName}${isRequired ? "" : "?"}: ${propertyType};`;
-                    })
-                        .join("\n");
-                    return `{${properties}\n}${nullable}`;
-                }
-                // Handle objects with additionalProperties
-                if (schema.additionalProperties) {
-                    const valueType = typeof schema.additionalProperties === "boolean"
-                        ? "unknown"
-                        : getTypeFromSchema(schema.additionalProperties);
-                    return `Record<string, ${valueType}>${nullable}`;
-                }
+            case "object": {
+                const fragment = getOwnObjectFragment(schema);
+                if (fragment)
+                    return `${fragment}${nullable}`;
                 // Default object type when no properties specified
                 return `Record<string, unknown>${nullable}`;
+            }
             default:
                 return `unknown${nullable}`;
         }

package/package.json

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

package/src/generator/schemaGenerator.ts

@@ -31,11 +31,11 @@ function generateTypeDefinition(
 	const description = !("$ref" in schema) && schema.description ? `/**\n * ${schema.description}\n */\n` : "";
 	const typeValue = getTypeFromSchema(schema);
 
-	// 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;
+	// Only emit `interface` when the body is a plain object literal. Composition
+	// (allOf/oneOf/anyOf) produces references or intersections that must use a type alias.
+	const canBeInterface = typeValue?.trimStart().startsWith("{");
 
-	return isInterface
+	return canBeInterface
 		? `${description}export interface ${sanitizeTypeName(name)} ${typeValue}\n\n`
 		: `${description}export type ${sanitizeTypeName(name)} = ${typeValue}\n\n`;
 }

package/src/utils.ts

@@ -170,6 +170,41 @@ export function specTitle(spec: OpenAPIV3.Document): string {
 	return camelCase(title.toLowerCase().replace(/\s+/g, "-"));
 }
 
+/**
+ * Builds the object-literal fragment ({...} or Record<...>) from a schema's own
+ * `properties` or `additionalProperties`, ignoring composition keywords. Returns
+ * undefined when the schema contributes no own object shape.
+ */
+function getOwnObjectFragment(schema: OpenAPIV3.SchemaObject): string | undefined {
+	if (schema.properties && Object.keys(schema.properties).length > 0) {
+		const properties = Object.entries(schema.properties)
+			.map(([key, prop]) => {
+				const isRequired = schema.required?.includes(key);
+				const propertyType = getTypeFromSchema(prop);
+				const safeName = sanitizePropertyName(key);
+				const isDeprecated = "deprecated" in prop && prop.deprecated;
+				const hasDescription = "description" in prop && prop.description;
+				const desc =
+					hasDescription || isDeprecated
+						? `/**${hasDescription ? `\n * ${prop.description}` : ""}${isDeprecated ? "\n * @deprecated" : ""}\n */\n`
+						: "";
+				return `${desc}${safeName}${isRequired ? "" : "?"}: ${propertyType};`;
+			})
+			.join("\n");
+		return `{${properties}\n}`;
+	}
+
+	if (schema.additionalProperties) {
+		const valueType =
+			typeof schema.additionalProperties === "boolean"
+				? "unknown"
+				: getTypeFromSchema(schema.additionalProperties);
+		return `Record<string, ${valueType}>`;
+	}
+
+	return undefined;
+}
+
 /**
  * Converts an OpenAPI schema object into a TypeScript type string.
  *
@@ -202,28 +237,35 @@ export function getTypeFromSchema(
 	// Add "| null" for nullable types
 	const nullable = "nullable" in schema && schema.nullable ? " | null" : "";
 
+	// Sibling properties / additionalProperties may appear next to allOf/oneOf/anyOf.
+	// Per the OpenAPI spec they constrain the parent and must be intersected with the composition.
+	const ownObjectFragment = getOwnObjectFragment(schema as OpenAPIV3.SchemaObject);
+
 	// 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 "unknown";
-		const result = types.length === 1 ? types[0] : `(${types.join(" & ")})`;
+		const parts = schema.allOf.map((s) => getTypeFromSchema(s)).filter(Boolean) as string[];
+		if (ownObjectFragment) parts.push(ownObjectFragment);
+		if (parts.length === 0) return "unknown";
+		const result = parts.length === 1 ? parts[0] : `(${parts.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 "unknown";
-		const result = types.length === 1 ? types[0] : `(${types.join(" | ")})`;
-		return `${result}${nullable}`;
+		if (types.length === 0 && !ownObjectFragment) return "unknown";
+		const union = types.length === 1 ? types[0] : `(${types.join(" | ")})`;
+		const composed = ownObjectFragment ? `(${union} & ${ownObjectFragment})` : union;
+		return `${composed}${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 "unknown";
-		const result = types.length === 1 ? types[0] : `(${types.join(" | ")})`;
-		return `${result}${nullable}`;
+		if (types.length === 0 && !ownObjectFragment) return "unknown";
+		const union = types.length === 1 ? types[0] : `(${types.join(" | ")})`;
+		const composed = ownObjectFragment ? `(${union} & ${ownObjectFragment})` : union;
+		return `${composed}${nullable}`;
 	}
 
 	// Handle enums as union types
@@ -274,37 +316,13 @@ export function getTypeFromSchema(
 				return `Array<${itemType}>${nullable}`;
 			}
 
-			case "object":
-				// Handle objects with defined properties
-				if (schema.properties) {
-					const properties = Object.entries(schema.properties)
-						.map(([key, prop]) => {
-							const isRequired = schema.required?.includes(key);
-							const propertyType = getTypeFromSchema(prop);
-							const safeName = sanitizePropertyName(key);
-							const isDeprecated = "deprecated" in prop && prop.deprecated;
-							const hasDescription = "description" in prop && prop.description;
-							const desc =
-								hasDescription || isDeprecated
-									? `/**${hasDescription ? `\n * ${prop.description}` : ""}${isDeprecated ? "\n * @deprecated" : ""}\n */\n`
-									: "";
-							return `${desc}${safeName}${isRequired ? "" : "?"}: ${propertyType};`;
-						})
-						.join("\n");
-					return `{${properties}\n}${nullable}`;
-				}
-
-				// Handle objects with additionalProperties
-				if (schema.additionalProperties) {
-					const valueType =
-						typeof schema.additionalProperties === "boolean"
-							? "unknown"
-							: getTypeFromSchema(schema.additionalProperties);
-					return `Record<string, ${valueType}>${nullable}`;
-				}
+			case "object": {
+				const fragment = getOwnObjectFragment(schema);
+				if (fragment) return `${fragment}${nullable}`;
 
 				// Default object type when no properties specified
 				return `Record<string, unknown>${nullable}`;
+			}
 
 			default:
 				return `unknown${nullable}`;