Enhance discriminator handling in OpenAPISchema

Author: nolannbiron

packages/react-openapi/src/OpenAPISchema.tsx

@@ -36,9 +36,19 @@ function OpenAPISchemaProperty(
         context: OpenAPIClientContext;
         circularRefs: CircularRefsIds;
         className?: string;
+        discriminator?: OpenAPIV3.DiscriminatorObject;
+        discriminatorValue?: string;
     } & Omit<ComponentPropsWithoutRef<'div'>, 'property' | 'context' | 'circularRefs' | 'className'>
 ) {
-    const { circularRefs: parentCircularRefs, context, className, property, ...rest } = props;
+    const {
+        circularRefs: parentCircularRefs,
+        context,
+        className,
+        property,
+        discriminator,
+        discriminatorValue,
+        ...rest
+    } = props;
 
     const { schema } = property;
 
@@ -59,33 +69,47 @@ function OpenAPISchemaProperty(
     const circularRefs = new Map(parentCircularRefs);
     circularRefs.set(schema, id);
 
-    const properties = getSchemaProperties(schema);
+    const properties = getSchemaProperties(schema, discriminator, discriminatorValue);
 
     const ancestors = new Set(circularRefs.keys());
     const alternatives = getSchemaAlternatives(schema, ancestors);
 
     const header = <OpenAPISchemaPresentation id={id} context={context} property={property} />;
     const content = (() => {
         if (alternatives?.schemas) {
-            const { schemas, discriminator } = alternatives;
+            const { schemas, discriminator: alternativeDiscriminator, type } = alternatives;
             return (
                 <div className="openapi-schema-alternatives">
-                    {schemas.map((alternativeSchema, index) => (
-                        <div key={index} className="openapi-schema-alternative">
-                            <OpenAPISchemaAlternative
-                                schema={alternativeSchema}
-                                discriminator={discriminator}
-                                circularRefs={circularRefs}
-                                context={context}
-                            />
-                            {index < schemas.length - 1 ? (
-                                <OpenAPISchemaAlternativeSeparator
-                                    schema={schema}
+                    {schemas.map((alternativeSchema, index) => {
+                        // If the alternative has its own discriminator, use it.
+                        const effectiveDiscriminator =
+                            alternativeDiscriminator ||
+                            (type === 'allOf' ? discriminator : undefined);
+
+                        // If we are inheriting and using parent discriminator, pass down the value.
+                        const effectiveDiscriminatorValue =
+                            !alternativeDiscriminator && type === 'allOf'
+                                ? discriminatorValue
+                                : undefined;
+
+                        return (
+                            <div key={index} className="openapi-schema-alternative">
+                                <OpenAPISchemaAlternative
+                                    schema={alternativeSchema}
+                                    discriminator={effectiveDiscriminator}
+                                    discriminatorValue={effectiveDiscriminatorValue}
+                                    circularRefs={circularRefs}
                                     context={context}
                                 />
-                            ) : null}
-                        </div>
-                    ))}
+                                {index < schemas.length - 1 ? (
+                                    <OpenAPISchemaAlternativeSeparator
+                                        schema={schema}
+                                        context={context}
+                                    />
+                                ) : null}
+                            </div>
+                        );
+                    })}
                 </div>
             );
         }
@@ -187,11 +211,49 @@ function OpenAPIRootSchema(props: {
     const id = useId();
     const properties = getSchemaProperties(schema);
     const description = resolveDescription(schema);
+    const ancestors = new Set(parentCircularRefs.keys());
+    const alternatives = getSchemaAlternatives(schema, ancestors);
 
-    if (properties?.length) {
-        const circularRefs = new Map(parentCircularRefs);
-        circularRefs.set(schema, id);
+    const circularRefs = new Map(parentCircularRefs);
+    circularRefs.set(schema, id);
+
+    // Handle root-level oneOf/allOf/anyOf
+    if (alternatives?.schemas) {
+        const { schemas, discriminator: alternativeDiscriminator, type } = alternatives;
+        return (
+            <>
+                {description ? (
+                    <Markdown source={description} className="openapi-schema-root-description" />
+                ) : null}
+                <div className="openapi-schema-alternatives">
+                    {schemas.map((alternativeSchema, index) => {
+                        // If the alternative has its own discriminator, use it.
+                        const effectiveDiscriminator =
+                            alternativeDiscriminator || (type === 'allOf' ? undefined : undefined);
+
+                        return (
+                            <div key={index} className="openapi-schema-alternative">
+                                <OpenAPISchemaAlternative
+                                    schema={alternativeSchema}
+                                    discriminator={effectiveDiscriminator}
+                                    circularRefs={circularRefs}
+                                    context={context}
+                                />
+                                {index < schemas.length - 1 ? (
+                                    <OpenAPISchemaAlternativeSeparator
+                                        schema={schema}
+                                        context={context}
+                                    />
+                                ) : null}
+                            </div>
+                        );
+                    })}
+                </div>
+            </>
+        );
+    }
 
+    if (properties?.length) {
         return (
             <>
                 {description ? (
@@ -228,6 +290,56 @@ export function OpenAPIRootSchemaFromServer(props: {
     );
 }
 
+/**
+ * Get the discriminator value for a schema.
+ */
+function getDiscriminatorValue(
+    schema: OpenAPIV3.SchemaObject,
+    discriminator: OpenAPIV3.DiscriminatorObject | undefined
+): string | undefined {
+    if (!discriminator) {
+        return undefined;
+    }
+
+    if (discriminator.mapping) {
+        const mappingEntry = Object.entries(discriminator.mapping).find(([key, ref]) => {
+            if (schema.title === ref || (!!schema.title && ref.endsWith(`/${schema.title}`))) {
+                return true;
+            }
+
+            // Fallback: check if the title contains the key (normalized)
+            if (schema.title?.toLowerCase().replace(/\s/g, '').includes(key.toLowerCase())) {
+                return true;
+            }
+
+            return false;
+        });
+
+        if (mappingEntry) {
+            return mappingEntry[0];
+        }
+    }
+
+    if (!discriminator.propertyName || !schema.properties) {
+        return undefined;
+    }
+
+    const property = schema.properties[discriminator.propertyName];
+    if (!property || checkIsReference(property)) {
+        return undefined;
+    }
+
+    if (property.const) {
+        return String(property.const);
+    }
+
+    if (property.enum?.length === 1) {
+        return String(property.enum[0]);
+    }
+
+    return;
+}
+
 /**
  * Render a tab for an alternative schema.
  * It renders directly the properties if relevant;
@@ -236,11 +348,14 @@ export function OpenAPIRootSchemaFromServer(props: {
 function OpenAPISchemaAlternative(props: {
     schema: OpenAPIV3.SchemaObject;
     discriminator: OpenAPIV3.DiscriminatorObject | undefined;
+    discriminatorValue?: string;
     circularRefs: CircularRefsIds;
     context: OpenAPIClientContext;
 }) {
     const { schema, discriminator, circularRefs, context } = props;
-    const properties = getSchemaProperties(schema, discriminator);
+    const discriminatorValue =
+        props.discriminatorValue || getDiscriminatorValue(schema, discriminator);
+    const properties = getSchemaProperties(schema, discriminator, discriminatorValue);
 
     return properties?.length ? (
         <OpenAPIDisclosure
@@ -257,6 +372,8 @@ function OpenAPISchemaAlternative(props: {
     ) : (
         <OpenAPISchemaProperty
             property={{ schema }}
+            discriminator={discriminator}
+            discriminatorValue={discriminatorValue}
             circularRefs={circularRefs}
             context={context}
         />
@@ -435,12 +552,13 @@ export function OpenAPISchemaPresentation(props: {
  */
 function getSchemaProperties(
     schema: OpenAPIV3.SchemaObject,
-    discriminator?: OpenAPIV3.DiscriminatorObject | undefined
+    discriminator?: OpenAPIV3.DiscriminatorObject | undefined,
+    discriminatorValue?: string | undefined
 ): null | OpenAPISchemaPropertyEntry[] {
     // check array AND schema.items as this is sometimes null despite what the type indicates
     if (schema.type === 'array' && schema.items && !checkIsReference(schema.items)) {
         const items = schema.items;
-        const itemProperties = getSchemaProperties(items);
+        const itemProperties = getSchemaProperties(items, discriminator, discriminatorValue);
         if (itemProperties) {
             return itemProperties.map((prop) => ({
                 ...prop,
@@ -467,17 +585,29 @@ function getSchemaProperties(
 
         if (schema.properties) {
             Object.entries(schema.properties).forEach(([propertyName, propertySchema]) => {
+                const isDiscriminator = discriminator?.propertyName === propertyName;
                 if (checkIsReference(propertySchema)) {
-                    return;
+                    if (!isDiscriminator || !discriminatorValue) {
+                        return;
+                    }
+                }
+
+                let finalSchema = propertySchema;
+                if (isDiscriminator && discriminatorValue) {
+                    finalSchema = {
+                        ...propertySchema,
+                        const: discriminatorValue,
+                        enum: [discriminatorValue],
+                    };
                 }
 
                 result.push({
                     propertyName,
                     required: Array.isArray(schema.required)
                         ? schema.required.includes(propertyName)
                         : undefined,
-                    isDiscriminatorProperty: discriminator?.propertyName === propertyName,
-                    schema: propertySchema,
+                    isDiscriminatorProperty: isDiscriminator,
+                    schema: finalSchema,
                 });
             });
         }