feat: infer discriminator mapping

Author: PatrickFeiring

modules/swagger-core/src/main/java/io/swagger/v3/core/jackson/ModelResolver.java

@@ -17,16 +17,21 @@
 import com.fasterxml.jackson.databind.JavaType;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.PropertyMetadata;
+import com.fasterxml.jackson.databind.SerializationConfig;
 import com.fasterxml.jackson.databind.SerializationFeature;
 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
 import com.fasterxml.jackson.databind.introspect.Annotated;
 import com.fasterxml.jackson.databind.introspect.AnnotatedClass;
+import com.fasterxml.jackson.databind.introspect.AnnotatedClassResolver;
 import com.fasterxml.jackson.databind.introspect.AnnotatedField;
 import com.fasterxml.jackson.databind.introspect.AnnotatedMember;
 import com.fasterxml.jackson.databind.introspect.AnnotatedMethod;
 import com.fasterxml.jackson.databind.introspect.BeanPropertyDefinition;
 import com.fasterxml.jackson.databind.introspect.POJOPropertyBuilder;
 import com.fasterxml.jackson.databind.jsontype.NamedType;
+import com.fasterxml.jackson.databind.jsontype.TypeIdResolver;
+import com.fasterxml.jackson.databind.jsontype.TypeResolverBuilder;
+import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
 import com.fasterxml.jackson.databind.util.Annotations;
 import io.swagger.v3.core.converter.AnnotatedType;
 import io.swagger.v3.core.converter.ModelConverter;
@@ -39,6 +44,7 @@
 import io.swagger.v3.core.util.ReferenceTypeUtils;
 import io.swagger.v3.core.util.PrimitiveType;
 import io.swagger.v3.core.util.ReflectionUtils;
+import io.swagger.v3.core.util.RefUtils;
 import io.swagger.v3.core.util.ValidatorProcessor;
 import io.swagger.v3.oas.annotations.Hidden;
 import io.swagger.v3.oas.annotations.Parameter;
@@ -2775,6 +2781,30 @@ protected Discriminator resolveDiscriminator(JavaType type, ModelConverterContex
                         }
                     }
                 }
+            } else {
+                SerializationConfig config = _mapper.getSerializationConfig();
+                AnnotationIntrospector introspector = config.getAnnotationIntrospector();
+                List<NamedType> subTypes = introspector.findSubtypes(
+                        AnnotatedClassResolver.resolveWithoutSuperTypes(config, type.getRawClass())
+                );
+
+                if (subTypes != null && !subTypes.isEmpty()) {
+                    BeanDescription bean = config.introspect(type);
+                    TypeResolverBuilder builder = introspector.findTypeResolver(config, bean.getClassInfo(), type);
+                    TypeSerializer serializer = builder.buildTypeSerializer(config, type, subTypes);
+                    TypeIdResolver resolver = serializer.getTypeIdResolver();
+
+                    for (NamedType subType : subTypes) {
+                        String schemaName = context.resolve(new AnnotatedType().type(subType.getType())).getName();
+                        String subTypeName = resolver.idFromValueAndType(null, subType.getType());
+
+                        // Per the specification, there is an implicit map to schemas with the same name
+                        // We skip writing the mappings that are implied to keep the schema minimal
+                        if (!subTypeName.equals(schemaName)) {
+                            discriminator.mapping(subTypeName, RefUtils.constructRef(schemaName));
+                        }
+                    }
+                }
             }
 
             return discriminator;

modules/swagger-core/src/test/java/io/swagger/v3/core/converting/CompositionTest.java

@@ -8,6 +8,7 @@
 import io.swagger.v3.core.oas.models.composition.AnimalWithSchemaSubtypes;
 import io.swagger.v3.core.oas.models.composition.Human;
 import io.swagger.v3.core.oas.models.composition.ModelWithFieldWithSubTypes;
+import io.swagger.v3.core.oas.models.composition.ModelWithDiscriminatorMapping;
 import io.swagger.v3.core.util.Json;
 import io.swagger.v3.core.util.ResourceUtils;
 import io.swagger.v3.oas.models.media.Schema;
@@ -48,6 +49,11 @@ public void createModelWithFieldWithSubTypes() throws IOException {
         compareAsJson(ModelWithFieldWithSubTypes.class, "ModelWithFieldWithSubTypes.json");
     }
 
+    @Test(description = "create a ModelWithFieldWithSubTypes")
+    public void createModelWithDiscriminatorMapping() throws IOException {
+        compareAsJson(ModelWithDiscriminatorMapping.class, "ModelWithDiscriminatorMapping.json");
+    }
+
     private void compareAsJson(Class<?> cls, String fileName) throws IOException {
         final Map<String, Schema> schemas = ModelConverters.getInstance().readAll(cls);
         Json.prettyPrint(schemas);

modules/swagger-core/src/test/java/io/swagger/v3/core/oas/models/composition/ModelWithDiscriminatorMapping.java

@@ -0,0 +1,28 @@
+package io.swagger.v3.core.oas.models.composition;
+
+import com.fasterxml.jackson.annotation.JsonSubTypes;
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+
+@JsonTypeInfo(use= JsonTypeInfo.Id.SIMPLE_NAME, include = JsonTypeInfo.As.PROPERTY, property="kind")
+@JsonSubTypes({
+        @JsonSubTypes.Type(value = ModelWithDiscriminatorMapping.First.class),
+        @JsonSubTypes.Type(value = ModelWithDiscriminatorMapping.Second.class, name = "second"),
+})
+public class ModelWithDiscriminatorMapping {
+
+    static class First extends ModelWithDiscriminatorMapping {
+        private String name;
+
+        String getName() { return name; }
+
+        void setName(String name) { this.name = name; }
+    }
+
+    static class Second extends ModelWithDiscriminatorMapping {
+        private String value;
+
+        String getValue() { return value; }
+
+        void setValue(String mountain) { this.value = mountain; }
+    }
+}

modules/swagger-core/src/test/resources/Animal.json

@@ -10,7 +10,11 @@
             }
         },
         "discriminator" : {
-            "propertyName" : "type"
+            "propertyName" : "type",
+            "mapping" : {
+                "human" : "#/components/schemas/Human",
+                "pet" : "#/components/schemas/Pet"
+            }
         }
     },
     "Human": {

modules/swagger-core/src/test/resources/AnimalClass.json

@@ -10,7 +10,11 @@
             }
         },
         "discriminator" : {
-            "propertyName" : "type"
+            "propertyName" : "type",
+            "mapping" : {
+                "human" : "#/components/schemas/HumanClass",
+                "pet" : "#/components/schemas/PetClass"
+            }
         }
     },
     "HumanClass": {

modules/swagger-core/src/test/resources/ModelWithDiscriminatorMapping.json

@@ -0,0 +1,45 @@
+{
+  "First" : {
+    "type" : "object",
+    "allOf" : [ {
+      "$ref" : "#/components/schemas/ModelWithDiscriminatorMapping"
+    }, {
+      "type" : "object",
+      "properties" : {
+        "name" : {
+          "type" : "string",
+          "writeOnly" : true
+        }
+      }
+    } ]
+  },
+  "ModelWithDiscriminatorMapping" : {
+    "required" : [ "kind" ],
+    "type" : "object",
+    "properties" : {
+      "kind" : {
+        "type" : "string"
+      }
+    },
+    "discriminator" : {
+      "propertyName" : "kind",
+      "mapping" : {
+        "second" : "#/components/schemas/Second"
+      }
+    }
+  },
+  "Second" : {
+    "type" : "object",
+    "allOf" : [ {
+      "$ref" : "#/components/schemas/ModelWithDiscriminatorMapping"
+    }, {
+      "type" : "object",
+      "properties" : {
+        "value" : {
+          "type" : "string",
+          "writeOnly" : true
+        }
+      }
+    } ]
+  }
+}