Fix OpenAPI OneOf/allOf merge

Author: nolannbiron

packages/react-openapi/src/OpenAPISchema.tsx

@@ -382,7 +382,7 @@ export function OpenAPISchemaPresentation(props: {
         <div id={id} className="openapi-schema-presentation">
             <OpenAPISchemaName
                 schema={schema}
-                type={getSchemaTitle(schema)}
+                type={getSchemaTitle(schema, { ignoreAlternatives: !propertyName })}
                 propertyName={propertyName}
                 isDiscriminatorProperty={isDiscriminatorProperty}
                 required={required}
@@ -686,36 +686,102 @@ function flattenAlternatives(
     schemasOrRefs: (OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject)[],
     ancestors: Set<OpenAPIV3.SchemaObject>
 ): OpenAPIV3.SchemaObject[] {
-    // Get the parent schema's required fields from the most recent ancestor
     const latestAncestor = Array.from(ancestors).pop();
+    const result: OpenAPIV3.SchemaObject[] = [];
 
-    return schemasOrRefs.reduce<OpenAPIV3.SchemaObject[]>((acc, schemaOrRef) => {
+    for (const schemaOrRef of schemasOrRefs) {
         if (checkIsReference(schemaOrRef)) {
-            return acc;
+            continue;
         }
 
-        if (schemaOrRef[alternativeType] && !ancestors.has(schemaOrRef)) {
-            const alternatives = getSchemaAlternatives(schemaOrRef, ancestors);
-            if (alternatives?.schemas) {
-                acc.push(
-                    ...alternatives.schemas.map((schema) => ({
-                        ...schema,
-                        required: mergeRequiredFields(schema, latestAncestor),
-                    }))
-                );
+        const flattened = flattenSchema(schemaOrRef, alternativeType, ancestors, latestAncestor);
+
+        if (flattened) {
+            result.push(...flattened);
+        }
+    }
+
+    return result;
+}
+
+function flattenSchema(
+    schema: OpenAPIV3.SchemaObject,
+    alternativeType: AlternativeType,
+    ancestors: Set<OpenAPIV3.SchemaObject>,
+    latestAncestor: OpenAPIV3.SchemaObject | undefined
+): OpenAPIV3.SchemaObject[] {
+    if (schema[alternativeType] && !ancestors.has(schema)) {
+        const alternatives = getSchemaAlternatives(schema, ancestors);
+        if (alternatives?.schemas && alternatives.type === alternativeType) {
+            return alternatives.schemas.map((s) => ({
+                ...s,
+                required: mergeRequiredFields(s, latestAncestor),
+            }));
+        }
+
+        return [
+            {
+                ...schema,
+                required: mergeRequiredFields(schema, latestAncestor),
+            },
+        ];
+    }
+
+    if (
+        (alternativeType === 'oneOf' || alternativeType === 'anyOf') &&
+        schema.allOf &&
+        Array.isArray(schema.allOf) &&
+        !ancestors.has(schema)
+    ) {
+        const allOfSchemas = schema.allOf.filter(
+            (s): s is OpenAPIV3.SchemaObject => !checkIsReference(s)
+        );
+
+        if (allOfSchemas.length > 0) {
+            const merged = mergeAlternatives('allOf', allOfSchemas);
+            if (merged && merged.length > 0) {
+                return merged.map((s) => {
+                    const required = mergeRequiredFields(s, latestAncestor);
+                    const result: OpenAPIV3.SchemaObject = {
+                        ...s,
+                        ...(required !== undefined && { required }),
+                    };
+
+                    if (schema.title && !s.title) {
+                        result.title = schema.title;
+                    }
+
+                    return result;
+                });
             }
-            return acc;
         }
+    }
 
-        // For direct schemas, handle required fields
-        const schema = {
-            ...schemaOrRef,
-            required: mergeRequiredFields(schemaOrRef, latestAncestor),
-        };
+    const title = inferSchemaTitle(schema);
+    const required = mergeRequiredFields(schema, latestAncestor);
+
+    return [
+        {
+            ...schema,
+            ...(required !== undefined && { required }),
+            ...(title ? { title } : {}),
+        },
+    ];
+}
+
+function inferSchemaTitle(schema: OpenAPIV3.SchemaObject): string | undefined {
+    if (schema.title) {
+        return schema.title;
+    }
+
+    if (schema.properties) {
+        const keys = Object.keys(schema.properties);
+        if (keys.length > 0) {
+            return keys[0];
+        }
+    }
 
-        acc.push(schema);
-        return acc;
-    }, []);
+    return undefined;
 }
 
 /**

packages/react-openapi/src/utils.ts

@@ -218,15 +218,18 @@ function getStatusCodeCategory(statusCode: number | string): number | string {
     return category;
 }
 
-export function getSchemaTitle(schema: OpenAPIV3.SchemaObject): string {
+export function getSchemaTitle(
+    schema: OpenAPIV3.SchemaObject,
+    options?: { ignoreAlternatives?: boolean }
+): string {
     // Otherwise try to infer a nice title
     let type = 'any';
 
     if (schema.enum || schema['x-enumDescriptions'] || schema['x-gitbook-enum']) {
         type = `${schema.type} · enum`;
         // check array AND schema.items as this is sometimes null despite what the type indicates
     } else if (schema.type === 'array' && !!schema.items) {
-        type = `${getSchemaTitle(schema.items)}[]`;
+        type = `${getSchemaTitle(schema.items, options)}[]`;
     } else if (Array.isArray(schema.type)) {
         type = schema.type.join(' | ');
     } else if (schema.type || schema.properties) {
@@ -242,14 +245,17 @@ export function getSchemaTitle(schema: OpenAPIV3.SchemaObject): string {
         }
     }
 
-    if ('anyOf' in schema) {
-        type = 'any of';
-    } else if ('oneOf' in schema) {
-        type = 'one of';
-    } else if ('allOf' in schema) {
-        type = 'all of';
-    } else if ('not' in schema) {
-        type = 'not';
+    // Skip alternative type labels if ignoreAlternatives is true (useful when rendering alternatives)
+    if (!options?.ignoreAlternatives) {
+        if ('anyOf' in schema) {
+            type = 'any of';
+        } else if ('oneOf' in schema) {
+            type = 'one of';
+        } else if ('allOf' in schema) {
+            type = 'all of';
+        } else if ('not' in schema) {
+            type = 'not';
+        }
     }
 
     return type;