Add introspection support for discovering an enum discriminator in a oneOf allOf polymorphic structure

Author: Mattias-Sehlstedt

modules/openapi-generator/src/main/java/org/openapitools/codegen/DefaultCodegen.java

@@ -93,6 +93,7 @@
 
 import static org.openapitools.codegen.CodegenConstants.*;
 import static org.openapitools.codegen.utils.CamelizeOption.LOWERCASE_FIRST_LETTER;
+import static org.openapitools.codegen.utils.DiscriminatorUtils.*;
 import static org.openapitools.codegen.utils.OnceLogger.once;
 import static org.openapitools.codegen.utils.StringUtils.*;
 
@@ -3453,7 +3454,7 @@ private CodegenProperty discriminatorFound(String composedSchemaName, Schema sc,
      * @param sc             The Schema that may contain the discriminator
      * @param visitedSchemas An array list of visited schemas
      */
-    private Discriminator recursiveGetDiscriminator(Schema sc, ArrayList<Schema> visitedSchemas) {
+    private DiscriminatorData recursiveGetDiscriminator(Schema sc, ArrayList<Schema> visitedSchemas) {
         return DiscriminatorUtils.recursiveGetDiscriminator(openAPI, this.getLegacyDiscriminatorBehavior(), sc, visitedSchemas);
     }
 
@@ -3590,7 +3591,7 @@ protected List<MappedModel> getAllOfDescendants(String thisSchemaName) {
     }
 
     protected CodegenDiscriminator createDiscriminator(String schemaName, Schema schema) {
-        Discriminator sourceDiscriminator = recursiveGetDiscriminator(schema, new ArrayList<Schema>());
+        DiscriminatorData sourceDiscriminator = recursiveGetDiscriminator(schema, new ArrayList<Schema>());
         if (sourceDiscriminator == null) {
             return null;
         }
@@ -3607,7 +3608,13 @@ protected CodegenDiscriminator createDiscriminator(String schemaName, Schema sch
         // FIXME: there are other ways to define the type of the discriminator property (inline
         //  for example). Handling those scenarios is too complicated for me, I'm leaving it for
         //  the future..
-        discriminator.setPropertyType(getDiscriminatorPropertyType(schema, discriminatorPropertyName));
+        String discriminatorType;
+        if (sourceDiscriminator.getPropertyType() != null) {
+            discriminatorType = toModelName(sourceDiscriminator.getPropertyType());
+        } else {
+            discriminatorType = getDiscriminatorPropertyType(schema, discriminatorPropertyName);
+        }
+        discriminator.setPropertyType(discriminatorType);
 
         // check to see if the discriminator property is an enum string
         boolean isEnum = Optional

modules/openapi-generator/src/main/java/org/openapitools/codegen/utils/DiscriminatorUtils.java

@@ -3,6 +3,7 @@
 import io.swagger.v3.oas.models.OpenAPI;
 import io.swagger.v3.oas.models.media.Discriminator;
 import io.swagger.v3.oas.models.media.Schema;
+import org.checkerframework.checker.nullness.qual.Nullable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -16,6 +17,8 @@ public class DiscriminatorUtils {
 
     private static final String CONFLICTING_DISCRIMINATOR_NAMES =
             "The alternative schemas have conflicting discriminator property names. The schemas must have the same property name, but found {}";
+    private static final String CONFLICTING_DISCRIMINATOR_TYPES =
+            "The alternative schemas have conflicting discriminator property types ({})";
 
     /**
      * Gets the simple ref name of the discriminator property type from the schema.
@@ -57,15 +60,20 @@ public static Schema getDiscriminatorSchema(Schema schema, String discriminatorN
      * @param sc                          The Schema that may contain the discriminator
      * @param visitedSchemas              an array list of visited schemas
      */
-    public static Discriminator recursiveGetDiscriminator(
+    public static DiscriminatorData recursiveGetDiscriminator(
             OpenAPI openAPI,
             boolean legacyDiscriminatorBehavior,
             Schema sc,
             ArrayList<Schema> visitedSchemas) {
         Schema refSchema = ModelUtils.getReferencedSchema(openAPI, sc);
-        Discriminator foundDisc = refSchema.getDiscriminator();
-        if (foundDisc != null) {
-            return foundDisc;
+        DiscriminatorData foundDisc = new DiscriminatorData(refSchema.getDiscriminator(), null);
+        if (foundDisc.getDiscriminator() != null) {
+            String discriminatorPropertyName = foundDisc.getDiscriminator().getPropertyName();
+            return new DiscriminatorData(
+                    foundDisc.getDiscriminator(),
+                    DiscriminatorUtils.getDiscriminatorPropertyType(refSchema, discriminatorPropertyName)
+                            .orElse(null)
+            );
         }
 
         if (legacyDiscriminatorBehavior) {
@@ -89,7 +97,7 @@ public static Discriminator recursiveGetDiscriminator(
                     if (foundDisc != null) {
                         disc.setPropertyName(foundDisc.getPropertyName());
                         disc.setMapping(foundDisc.getMapping());
-                        return disc;
+                        return new DiscriminatorData(disc, foundDisc.getPropertyType());
                     }
                 }
             }
@@ -115,16 +123,17 @@ public static Discriminator recursiveGetDiscriminator(
      * @param visitedSchemas              an array list of visited schemas
      * @return the discriminator if the alternatives correctly shares one, otherwise null
      */
-    private static Discriminator getDiscriminatorFromAlternatives(
+    private static DiscriminatorData getDiscriminatorFromAlternatives(
             OpenAPI openAPI,
             boolean legacyDiscriminatorBehavior,
             List<Schema> alternativeSchemas,
             ArrayList<Schema> visitedSchemas) {
         Discriminator discriminator = new Discriminator();
-        Discriminator foundDisc = null;
+        DiscriminatorData foundDisc = null;
         Integer hasDiscriminatorCnt = 0;
         Integer hasNullTypeCnt = 0;
         Set<String> discriminatorsPropNames = new HashSet<>();
+        Set<String> discriminatorTypes = new HashSet<>();
         for (Object alternative : alternativeSchemas) {
             if (ModelUtils.isNullType((Schema) alternative)) {
                 // The null type does not have a discriminator. Skip.
@@ -135,20 +144,59 @@ private static Discriminator getDiscriminatorFromAlternatives(
             if (foundDisc != null) {
                 discriminatorsPropNames.add(foundDisc.getPropertyName());
                 hasDiscriminatorCnt++;
+                if (foundDisc.getPropertyType() != null) {
+                    discriminatorTypes.add(foundDisc.getPropertyType());
+                }
             }
         }
         if (discriminatorsPropNames.size() > 1) {
             once(LOGGER).warn(CONFLICTING_DISCRIMINATOR_NAMES, String.join(", ", discriminatorsPropNames));
         }
+        if (discriminatorTypes.size() > 1) {
+            once(LOGGER).warn(CONFLICTING_DISCRIMINATOR_TYPES, String.join(", ", discriminatorTypes));
+        }
         boolean allAlternativesHaveADiscriminator = hasDiscriminatorCnt + hasNullTypeCnt == alternativeSchemas.size();
         if (foundDisc != null && allAlternativesHaveADiscriminator && discriminatorsPropNames.size() == 1) {
             discriminator.setPropertyName(foundDisc.getPropertyName());
             discriminator.setMapping(foundDisc.getMapping());
-            return discriminator;
+            String uniqueDiscriminatorType = discriminatorTypes.size() == 1 ? discriminatorTypes.iterator().next() : null;
+            return new DiscriminatorData(discriminator, uniqueDiscriminatorType);
         }
         // If the scenario when composite schema has two children and one of them is the 'null' type,
         // there is no need for a discriminator.
         return null;
     }
 
+    public static class DiscriminatorData {
+        private final Discriminator discriminator;
+
+        @Nullable
+        private final String propertyType;
+
+        public DiscriminatorData(Discriminator discriminator, @Nullable String propertyType) {
+            this.discriminator = discriminator;
+            this.propertyType = propertyType;
+        }
+
+        public Discriminator getDiscriminator() {
+            return discriminator;
+        }
+
+        public @Nullable String getPropertyType() {
+            return propertyType;
+        }
+
+        public String getPropertyName() {
+            return discriminator.getPropertyName();
+        }
+
+        public Map<String, String> getMapping() {
+            return discriminator.getMapping();
+        }
+
+        public Map<String, Object> getExtensions() {
+            return discriminator.getExtensions();
+        }
+    }
+
 }

modules/openapi-generator/src/main/java/org/openapitools/codegen/utils/OneOfImplementorAdditionalData.java

@@ -15,21 +15,21 @@
  * This class holds data to add to `oneOf` members. Let's consider this example:
  * <p>
  * Foo:
- * properties:
- * x:
- * oneOf:
- * - $ref: "#/components/schemas/One
- * - $ref: "#/components/schemas/Two
- * y:
- * type: string
+ *   properties:
+ *     x:
+ *       oneOf:
+ *         - $ref: "#/components/schemas/One"
+ *         - $ref: "#/components/schemas/Two"
+ *     y:
+ *       type: string
  * One:
- * properties:
- * z:
- * type: string
+ *   properties:
+ *     z:
+ *       type: string
  * Two:
- * properties:
- * a:
- * type: string
+ *   properties:
+ *     a:
+ *       type: string
  * <p>
  * In codegens that use this mechanism, `Foo` will become an interface and `One` will
  * become its implementing class. This class carries all data necessary to properly modify
@@ -99,7 +99,7 @@ public void addFromInterfaceModel(CodegenModel cm, List<Map<String, String>> mod
      * @param cc                  CodegenConfig running this operation
      * @param implcm              the implementing model
      * @param implImports         imports of the implementing model
-     * @param addInterfaceImports whether or not to add the interface model as import (will vary by language)
+     * @param addInterfaceImports whether to add the interface model as import (will vary by language)
      */
     @SuppressWarnings("unchecked")
     public void addToImplementor(CodegenConfig cc, CodegenModel implcm, List<Map<String, String>> implImports, boolean addInterfaceImports) {

modules/openapi-generator/src/test/java/org/openapitools/codegen/DefaultCodegenTest.java

@@ -1210,6 +1210,35 @@ public void testEnumDiscriminatorWithDescriptionOverridden3_1() {
         assertTrue(fruitModel.getVars().get(0).isEnumRef);
     }
 
+    @Test
+    public void testOneOfAllOfEnumDiscriminatorInheritance() {
+        final OpenAPI openAPI = TestUtils.parseFlattenSpec("src/test/resources/3_1/polymorphism-oneof-allof-and-enum-discriminator.yaml");
+        new OpenAPINormalizer(openAPI, Map.of()).normalize();
+        DefaultCodegen codegen = new DefaultCodegen();
+        codegen.setUseOneOfInterfaces(true);
+        codegen.setLegacyDiscriminatorBehavior(false);
+
+        Schema inner = openAPI.getComponents().getSchemas().get("getAllPets_200_response_inner");
+        codegen.setOpenAPI(openAPI);
+        CodegenModel innerModel = codegen.fromModel("getAllPets_200_response_inner", inner);
+        assertTrue(innerModel.getHasDiscriminatorWithNonEmptyMapping());
+        assertTrue(innerModel.discriminator.getIsEnum());
+        assertEquals("PetType", innerModel.discriminator.getPropertyType());
+        assertTrue(innerModel.getVars().get(0).isEnumRef);
+        
+        Schema cat = openAPI.getComponents().getSchemas().get("Cat");
+        CodegenModel catModel = codegen.fromModel("Cat", cat);
+        assertTrue(catModel.discriminator.getIsEnum());
+        assertEquals("PetType", catModel.discriminator.getPropertyType());
+        assertTrue(catModel.getVars().get(0).isEnumRef);
+
+        Schema dog = openAPI.getComponents().getSchemas().get("Dog");
+        CodegenModel dogModel = codegen.fromModel("Dog", dog);
+        assertTrue(dogModel.discriminator.getIsEnum());
+        assertEquals("PetType", dogModel.discriminator.getPropertyType());
+        assertTrue(dogModel.getVars().get(0).isEnumRef);
+    }
+
     @Test
     public void testParentName() {
         final OpenAPI openAPI = TestUtils.parseFlattenSpec("src/test/resources/3_0/allOf.yaml");

modules/openapi-generator/src/test/resources/3_1/polymorphism-oneof-allof-and-enum-discriminator.yaml

@@ -0,0 +1,65 @@
+openapi: 3.1.0
+info:
+  title: Polymorphism example with oneOf, allOf and enum-discriminator
+  version: "1.0"
+paths:
+  /pets:
+    get:
+      operationId: getAllPets
+      responses:
+        "200":
+          content:
+            application/json:
+              schema:
+                type: array
+                items:
+                  oneOf:
+                    - $ref: "#/components/schemas/Cat"
+                    - $ref: "#/components/schemas/Dog"
+          description: Success
+components:
+  schemas:
+    PetType:
+      type: string
+      enum:
+        - Cat
+        - Dog
+    Pet:
+      type: object
+      discriminator:
+        propertyName: petType
+      properties:
+        petType:
+          $ref: '#/components/schemas/PetType'
+      required:
+        - petType
+    Cat:
+      description: A representation of a cat
+      allOf:
+        - $ref: '#/components/schemas/Pet'
+        - type: object
+          properties:
+            huntingSkill:
+              type: string
+              description: The measured skill for hunting
+              enum:
+                - clueless
+                - lazy
+                - adventurous
+                - aggressive
+          required:
+            - huntingSkill
+    Dog:
+      description: A representation of a dog
+      allOf:
+        - $ref: '#/components/schemas/Pet'
+        - type: object
+          properties:
+            packSize:
+              type: integer
+              format: int32
+              description: the size of the pack the dog is from
+              default: 0
+              minimum: 0
+          required:
+            - packSize

samples/client/petstore/typescript-fetch/builds/kebab-case/models/enum-test.ts

@@ -142,7 +142,7 @@ export type EnumTestEnumNumberEnum = typeof EnumTestEnumNumberEnum[keyof typeof
  * Check if a given object implements the EnumTest interface.
  */
 export function instanceOfEnumTest(value: object): value is EnumTest {
-    if ((!('enumStringRequired' in value) && !('enum_string_required' in value)) || (value['enumStringRequired'] === undefined && value['enum_string_required'] === undefined)) return false;
+    if ((!('enumStringRequired' in (value as Record<string, any>)) && !('enum_string_required' in (value as Record<string, any>))) || ((value as Record<string, any>)['enumStringRequired'] === undefined && (value as Record<string, any>)['enum_string_required'] === undefined)) return false;
     return true;
 }
 

samples/client/petstore/typescript-fetch/builds/kebab-case/models/format-test.ts

@@ -122,7 +122,7 @@ export interface FormatTest {
  */
 export function instanceOfFormatTest(value: object): value is FormatTest {
     if (!('number' in value) || value['number'] === undefined) return false;
-    if ((!('_byte' in value) && !('byte' in value)) || (value['_byte'] === undefined && value['byte'] === undefined)) return false;
+    if ((!('_byte' in (value as Record<string, any>)) && !('byte' in (value as Record<string, any>))) || ((value as Record<string, any>)['_byte'] === undefined && (value as Record<string, any>)['byte'] === undefined)) return false;
     if (!('date' in value) || value['date'] === undefined) return false;
     if (!('password' in value) || value['password'] === undefined) return false;
     return true;