[dart-dio] fix the issue of multi layer issues with dart-dio code generation

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

@@ -77,6 +77,9 @@ public class DartDioClientCodegen extends AbstractDartCodegen {
     public static final String SKIP_COPY_WITH_DEFAULT_VALUE = "false";
 
     private static final String CLIENT_NAME = "clientName";
+    private static final String X_DISCRIMINATOR_MAPPED_MODELS_NONSELF = "x-discriminator-mapped-models-nonself";
+    private static final String X_HAS_DISCRIMINATOR_SELF_MAPPING = "x-has-discriminator-self-mapping";
+    private static final String X_DISCRIMINATOR_SELF_MAPPING_NAME = "x-discriminator-self-mapping-name";
 
     @Getter @Setter
     private String dateLibrary;
@@ -582,36 +585,200 @@ private void adaptToDartInheritance(Map<String, ModelsMap> objs) {
         }
     }
 
+    private int getSchemaInheritanceDepth(String schemaName, String ancestorSchemaName, Set<String> visited) {
+        if (schemaName == null || ancestorSchemaName == null) {
+            return -1;
+        }
+        if (schemaName.equals(ancestorSchemaName)) {
+            return 0;
+        }
+
+        Schema currentSchema = ModelUtils.getSchema(openAPI, schemaName);
+        if (currentSchema == null || currentSchema.getAllOf() == null || currentSchema.getAllOf().isEmpty()) {
+            return -1;
+        }
+
+        int maxDepth = -1;
+        for (Object parentObj : currentSchema.getAllOf()) {
+            if (!(parentObj instanceof Schema)) {
+                continue;
+            }
+            Schema parentSchema = (Schema) parentObj;
+            String parentRef = parentSchema.get$ref();
+            if (parentRef == null) {
+                continue;
+            }
+
+            String parentSchemaName = ModelUtils.getSimpleRef(parentRef);
+            if (ancestorSchemaName.equals(parentSchemaName)) {
+                maxDepth = Math.max(maxDepth, 1);
+                continue;
+            }
+
+            if (parentSchemaName != null && visited.add(parentSchemaName)) {
+                int parentDepth = getSchemaInheritanceDepth(parentSchemaName, ancestorSchemaName, visited);
+                if (parentDepth >= 0) {
+                    maxDepth = Math.max(maxDepth, parentDepth + 1);
+                }
+                visited.remove(parentSchemaName);
+            }
+        }
+
+        return maxDepth;
+    }
+
     /// override the default behavior of createDiscriminator
     /// to remove extra mappings added as a side effect of setLegacyDiscriminatorBehavior(false)
     /// this ensures 1-1 schema mapping instead of 1-many
     @Override
     protected CodegenDiscriminator createDiscriminator(String schemaName, Schema schema) {
         CodegenDiscriminator sub = super.createDiscriminator(schemaName, schema);
-        Discriminator originalDiscriminator = schema.getDiscriminator();
+        if (sub == null) {
+            return null;
+        }
+
+        if (sub.getMapping() != null) {
+            // Defensive copy: avoid mutating shared mapping objects from the parsed spec.
+            sub.setMapping(new LinkedHashMap<>(sub.getMapping()));
+        }
+
+        Discriminator originalDiscriminator = getSchemaLocalDiscriminator(schema);
         if (originalDiscriminator != null) {
             Map<String, String> originalMapping = originalDiscriminator.getMapping();
             if (originalMapping != null && !originalMapping.isEmpty()) {
-                //we already have a discriminator mapping, remove everything else
-                for (MappedModel currentMappings : new HashSet<>(sub.getMappedModels())) {
-                    if (originalMapping.containsKey(currentMappings.getMappingName())) {
-                        //all good
-                    } else {
-                        sub.getMapping().remove(currentMappings.getMappingName());
-                        sub.getMappedModels().remove(currentMappings);
-                    }
-                }
+                // keep only explicitly declared mappings on the schema-local discriminator
+                filterMappedModels(sub, mappedModel -> originalMapping.containsKey(mappedModel.getMappingName()));
             }
+            orderMappedModelsBySchemaSpecificity(sub, schemaName);
+            prepareDiscriminatorTemplateData(sub, schemaName, toModelName(schemaName));
+            return sub;
         }
+
+        // For inherited discriminators, keep only real allOf descendants of this schema
+        // (e.g. Reptile keeps Crocodile/Turtle, but not Bird from Animal's mapping).
+        Set<String> descendantSchemaNames = getAllOfDescendants(schemaName).stream()
+                .map(MappedModel::getSchemaName)
+                .filter(Objects::nonNull)
+                .collect(Collectors.toSet());
+
+        if (ModelUtils.isComposedSchema(schema) && schema.getAllOf() != null) {
+            filterMappedModels(sub, mappedModel -> descendantSchemaNames.contains(mappedModel.getSchemaName())
+                    || schemaName.equals(mappedModel.getSchemaName()));
+        }
+
+        orderMappedModelsBySchemaSpecificity(sub, schemaName);
+        prepareDiscriminatorTemplateData(sub, schemaName, toModelName(schemaName));
         return sub;
     }
 
+    private void prepareDiscriminatorTemplateData(CodegenDiscriminator discriminator, String schemaName, String modelName) {
+        if (discriminator == null || discriminator.getMappedModels() == null) {
+            return;
+        }
+
+        String selfMappingName = null;
+        List<MappedModel> nonSelfMappedModels = new ArrayList<>();
+        for (MappedModel mappedModel : discriminator.getMappedModels()) {
+            boolean isSelfMapping = Objects.equals(schemaName, mappedModel.getSchemaName())
+                    || Objects.equals(modelName, mappedModel.getModelName());
+            if (isSelfMapping) {
+                selfMappingName = mappedModel.getMappingName();
+            } else {
+                nonSelfMappedModels.add(mappedModel);
+            }
+        }
+
+        discriminator.getVendorExtensions().put(X_DISCRIMINATOR_MAPPED_MODELS_NONSELF, nonSelfMappedModels);
+        discriminator.getVendorExtensions().put(X_HAS_DISCRIMINATOR_SELF_MAPPING, selfMappingName != null);
+        if (selfMappingName != null) {
+            discriminator.getVendorExtensions().put(X_DISCRIMINATOR_SELF_MAPPING_NAME, selfMappingName);
+        } else {
+            discriminator.getVendorExtensions().remove(X_DISCRIMINATOR_SELF_MAPPING_NAME);
+        }
+    }
+
+    private void orderMappedModelsBySchemaSpecificity(CodegenDiscriminator discriminator, String ownerSchemaName) {
+        if (discriminator.getMappedModels() == null || discriminator.getMappedModels().size() < 2) {
+            return;
+        }
+
+        List<MappedModel> ordered = new ArrayList<>(discriminator.getMappedModels());
+        Map<String, Integer> inheritanceDepthBySchema = new HashMap<>();
+        Map<MappedModel, Integer> originalOrder = new HashMap<>();
+        for (int i = 0; i < ordered.size(); i++) {
+            MappedModel mappedModel = ordered.get(i);
+            originalOrder.put(mappedModel, i);
+            inheritanceDepthBySchema.computeIfAbsent(
+                    mappedModel.getSchemaName(),
+                    schemaName -> getSchemaInheritanceDepth(schemaName, ownerSchemaName, new HashSet<>())
+            );
+        }
+
+        ordered.sort((left, right) -> {
+            int leftDepth = inheritanceDepthBySchema.getOrDefault(left.getSchemaName(), -1);
+            int rightDepth = inheritanceDepthBySchema.getOrDefault(right.getSchemaName(), -1);
+            if (leftDepth != rightDepth) {
+                return Integer.compare(rightDepth, leftDepth);
+            }
+
+            return Integer.compare(originalOrder.get(left), originalOrder.get(right));
+        });
+
+        discriminator.setMappedModels(new LinkedHashSet<>(ordered));
+    }
+
+    private void filterMappedModels(CodegenDiscriminator discriminator, java.util.function.Predicate<MappedModel> keepPredicate) {
+        for (MappedModel mappedModel : new HashSet<>(discriminator.getMappedModels())) {
+            if (!keepPredicate.test(mappedModel)) {
+                if (discriminator.getMapping() != null) {
+                    discriminator.getMapping().remove(mappedModel.getMappingName());
+                }
+                discriminator.getMappedModels().remove(mappedModel);
+            }
+        }
+    }
+
+    private Discriminator getSchemaLocalDiscriminator(Schema schema) {
+        if (schema == null) {
+            return null;
+        }
+
+        if (schema.getDiscriminator() != null) {
+            return schema.getDiscriminator();
+        }
+
+        if (ModelUtils.isComposedSchema(schema) && schema.getAllOf() != null) {
+            // Prefer inline allOf discriminator (child-local) over inherited parent discriminators.
+            for (Object allOfSchemaObj : schema.getAllOf()) {
+                if (!(allOfSchemaObj instanceof Schema)) {
+                    continue;
+                }
+                Schema allOfSchema = (Schema) allOfSchemaObj;
+                if (allOfSchema.getDiscriminator() != null) {
+                    return allOfSchema.getDiscriminator();
+                }
+            }
+        }
+
+        return null;
+    }
+
     @Override
     public Map<String, ModelsMap> postProcessAllModels(Map<String, ModelsMap> objs) {
         objs = super.postProcessAllModels(objs);
         if (SERIALIZATION_LIBRARY_BUILT_VALUE.equals(library)) {
             adaptToDartInheritance(objs);
             syncRootTypesWithInnerVars(objs);
+            for (ModelsMap entry : objs.values()) {
+                for (ModelMap mo : entry.getModels()) {
+                    CodegenModel cm = mo.getModel();
+                    if (cm != null && cm.discriminator != null) {
+                        String ownerSchemaName = ObjectUtils.firstNonNull(cm.getSchemaName(), cm.getName(), cm.getClassname());
+                        orderMappedModelsBySchemaSpecificity(cm.discriminator, ownerSchemaName);
+                        prepareDiscriminatorTemplateData(cm.discriminator, cm.getSchemaName(), cm.classname);
+                    }
+                }
+            }
         }
 
         // loop through models to update the imports

modules/openapi-generator/src/main/resources/dart/libraries/dio/serialization/built_value/class_discriminator.mustache

@@ -1,20 +1,31 @@
 extension {{classname}}DiscriminatorExt on {{classname}} {
     String? get discriminatorValue {
-        {{#mappedModels}}
+        {{#vendorExtensions.x-discriminator-mapped-models-nonself}}
         if (this is {{modelName}}) {
             return r'{{mappingName}}';
         }
-        {{/mappedModels}}
+        {{/vendorExtensions.x-discriminator-mapped-models-nonself}}
+        {{#vendorExtensions.x-has-discriminator-self-mapping}}
+        return r'{{vendorExtensions.x-discriminator-self-mapping-name}}';
+        {{/vendorExtensions.x-has-discriminator-self-mapping}}
+        {{^vendorExtensions.x-has-discriminator-self-mapping}}
         return null;
+        {{/vendorExtensions.x-has-discriminator-self-mapping}}
     }
 }
 extension {{classname}}BuilderDiscriminatorExt on {{classname}}Builder {
     String? get discriminatorValue {
-        {{#mappedModels}}
+        {{#vendorExtensions.x-discriminator-mapped-models-nonself}}
         if (this is {{modelName}}Builder) {
             return r'{{mappingName}}';
         }
-        {{/mappedModels}}
+        {{/vendorExtensions.x-discriminator-mapped-models-nonself}}
+        {{#vendorExtensions.x-has-discriminator-self-mapping}}
+        return r'{{vendorExtensions.x-discriminator-self-mapping-name}}';
+        {{/vendorExtensions.x-has-discriminator-self-mapping}}
+        {{^vendorExtensions.x-has-discriminator-self-mapping}}
         return null;
+        {{/vendorExtensions.x-has-discriminator-self-mapping}}
     }
-}
+}
+

modules/openapi-generator/src/main/resources/dart/libraries/dio/serialization/built_value/class_serializer.mustache

@@ -75,11 +75,11 @@ class _${{classname}}Serializer implements PrimitiveSerializer<{{classname}}> {
     {{#hasDiscriminatorWithNonEmptyMapping}}
     {{#discriminator}}
     {{! handle discriminator }}
-    {{#mappedModels}}
+    {{#vendorExtensions.x-discriminator-mapped-models-nonself}}
     if (object is {{modelName}}) {
       return serializers.serialize(object, specifiedType: FullType({{modelName}}))!;
     }
-    {{/mappedModels}}
+    {{/vendorExtensions.x-discriminator-mapped-models-nonself}}
     {{/discriminator}}
     {{/hasDiscriminatorWithNonEmptyMapping}}
     return _serializeProperties(serializers, object, specifiedType: specifiedType).toList();
@@ -271,10 +271,10 @@ class _${{classname}}Serializer implements PrimitiveSerializer<{{classname}}> {
     final discIndex = serializedList.indexOf({{classname}}.discriminatorFieldName) + 1;
     final discValue = serializers.deserialize(serializedList[discIndex], specifiedType: FullType(String)) as String;
     switch (discValue) {
-      {{#mappedModels}}
+      {{#vendorExtensions.x-discriminator-mapped-models-nonself}}
       case r'{{mappingName}}':
         return serializers.deserialize(serialized, specifiedType: FullType({{modelName}})) as {{modelName}};
-      {{/mappedModels}}
+      {{/vendorExtensions.x-discriminator-mapped-models-nonself}}
       default:
         return serializers.deserialize(serialized, specifiedType: FullType(${{classname}})) as ${{classname}};
     }

modules/openapi-generator/src/test/java/org/openapitools/codegen/dart/dio/DartDioModelTest.java

@@ -387,6 +387,104 @@ public void mapModelTest() {
         Assert.assertEquals(cm.vars.size(), 0);
     }
 
+    @Test(description = "uses schema-local discriminator mapping for dart-dio")
+    public void localDiscriminatorUsesDeclaredMappingsOnly() {
+        OpenAPI openAPI = TestUtils.parseSpec("src/test/resources/bugs/issue_15467.json");
+
+        final DefaultCodegen codegen = new DartDioClientCodegen();
+        codegen.additionalProperties().put(CodegenConstants.SERIALIZATION_LIBRARY, DartDioClientCodegen.SERIALIZATION_LIBRARY_BUILT_VALUE);
+        codegen.processOpts();
+        codegen.setOpenAPI(openAPI);
+
+        final String modelName = "Animal";
+        final Schema model = openAPI.getComponents().getSchemas().get(modelName);
+        final CodegenModel cm = codegen.fromModel(modelName, model);
+
+        Assert.assertNotNull(cm.discriminator);
+        Assert.assertEquals(cm.discriminator.getMapping().size(), 4);
+        Assert.assertTrue(cm.discriminator.getMapping().containsKey("Bird"));
+        Assert.assertTrue(cm.discriminator.getMapping().containsKey("Reptile"));
+        Assert.assertTrue(cm.discriminator.getMapping().containsKey("Crocodile"));
+        Assert.assertTrue(cm.discriminator.getMapping().containsKey("Turtle"));
+        Assert.assertFalse(cm.discriminator.getMapping().containsKey("Lizard"));
+    }
+
+    @Test(description = "does not leak sibling mappings into inherited discriminator for intermediate allOf models")
+    public void inheritedDiscriminatorKeepsOnlyDescendantsForIntermediateModel() {
+        OpenAPI openAPI = TestUtils.parseSpec("src/test/resources/bugs/issue_15467.json");
+
+        final DefaultCodegen codegen = new DartDioClientCodegen();
+        codegen.additionalProperties().put(CodegenConstants.SERIALIZATION_LIBRARY, DartDioClientCodegen.SERIALIZATION_LIBRARY_BUILT_VALUE);
+        codegen.processOpts();
+        codegen.setOpenAPI(openAPI);
+
+        final Schema reptileSchema = openAPI.getComponents().getSchemas().get("Reptile");
+        final CodegenModel reptileModel = codegen.fromModel("Reptile", reptileSchema);
+
+        Assert.assertNotNull(reptileModel.discriminator);
+        Assert.assertNotNull(reptileModel.discriminator.getMapping());
+        Assert.assertTrue(reptileModel.discriminator.getMapping().containsKey("Crocodile"));
+        Assert.assertTrue(reptileModel.discriminator.getMapping().containsKey("Turtle"));
+        Assert.assertTrue(reptileModel.discriminator.getMapping().containsKey("Reptile"));
+        Assert.assertFalse(reptileModel.discriminator.getMapping().containsKey("Bird"));
+
+        java.util.List<String> reptileMappedModelOrder = reptileModel.discriminator.getMappedModels().stream()
+                .map(CodegenDiscriminator.MappedModel::getModelName)
+                .collect(java.util.stream.Collectors.toList());
+        Assert.assertEquals(reptileMappedModelOrder.get(reptileMappedModelOrder.size() - 1), "Reptile");
+
+        Assert.assertEquals(reptileModel.discriminator.getVendorExtensions().get("x-has-discriminator-self-mapping"), Boolean.TRUE);
+        Assert.assertEquals(reptileModel.discriminator.getVendorExtensions().get("x-discriminator-self-mapping-name"), "Reptile");
+        @SuppressWarnings("unchecked")
+        java.util.List<CodegenDiscriminator.MappedModel> reptileNonSelfMappedModels =
+                (java.util.List<CodegenDiscriminator.MappedModel>) reptileModel.discriminator.getVendorExtensions().get("x-discriminator-mapped-models-nonself");
+        Assert.assertNotNull(reptileNonSelfMappedModels);
+        Assert.assertEquals(
+                reptileNonSelfMappedModels.stream()
+                        .map(CodegenDiscriminator.MappedModel::getModelName)
+                        .collect(java.util.stream.Collectors.toList()),
+                java.util.Arrays.asList("Crocodile", "Turtle"));
+
+        final Schema animalSchema = openAPI.getComponents().getSchemas().get("Animal");
+        final CodegenModel animalModel = codegen.fromModel("Animal", animalSchema);
+        Assert.assertNotNull(animalModel.discriminator);
+        Assert.assertNotNull(animalModel.discriminator.getMapping());
+        Assert.assertTrue(animalModel.discriminator.getMapping().containsKey("Bird"));
+        Assert.assertTrue(animalModel.discriminator.getMapping().containsKey("Reptile"));
+        Assert.assertEquals(animalModel.discriminator.getVendorExtensions().get("x-has-discriminator-self-mapping"), Boolean.FALSE);
+    }
+
+    @Test(description = "orders discriminator mappings so subclasses are checked before ancestor types")
+    public void discriminatorChecksSubclassesBeforeParentTypes() {
+        OpenAPI openAPI = TestUtils.parseSpec("src/test/resources/bugs/issue_15467.json");
+
+        final DefaultCodegen codegen = new DartDioClientCodegen();
+        codegen.additionalProperties().put(CodegenConstants.SERIALIZATION_LIBRARY, DartDioClientCodegen.SERIALIZATION_LIBRARY_BUILT_VALUE);
+        codegen.processOpts();
+        codegen.setOpenAPI(openAPI);
+
+        final Schema animalSchema = openAPI.getComponents().getSchemas().get("Animal");
+        final CodegenModel animalModel = codegen.fromModel("Animal", animalSchema);
+
+        Assert.assertNotNull(animalModel.discriminator);
+        java.util.List<String> mappedModelOrder = animalModel.discriminator.getMappedModels().stream()
+                .map(CodegenDiscriminator.MappedModel::getModelName)
+                .collect(java.util.stream.Collectors.toList());
+
+        Assert.assertTrue(mappedModelOrder.indexOf("Turtle") < mappedModelOrder.indexOf("Reptile"));
+        Assert.assertTrue(mappedModelOrder.indexOf("Crocodile") < mappedModelOrder.indexOf("Reptile"));
+
+        @SuppressWarnings("unchecked")
+        java.util.List<CodegenDiscriminator.MappedModel> animalNonSelfMappedModels =
+                (java.util.List<CodegenDiscriminator.MappedModel>) animalModel.discriminator.getVendorExtensions().get("x-discriminator-mapped-models-nonself");
+        Assert.assertNotNull(animalNonSelfMappedModels);
+        java.util.List<String> animalNonSelfMappedModelOrder = animalNonSelfMappedModels.stream()
+                .map(CodegenDiscriminator.MappedModel::getModelName)
+                .collect(java.util.stream.Collectors.toList());
+        Assert.assertTrue(animalNonSelfMappedModelOrder.indexOf("Turtle") < animalNonSelfMappedModelOrder.indexOf("Reptile"));
+        Assert.assertTrue(animalNonSelfMappedModelOrder.indexOf("Crocodile") < animalNonSelfMappedModelOrder.indexOf("Reptile"));
+    }
+
     @DataProvider(name = "modelNames")
     public static Object[][] modelNames() {
         return new Object[][]{