Jersey2 supports additional properties with composed schema

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

@@ -1646,10 +1646,24 @@ public void setAdditionalModelTypeAnnotations(final List<String> additionalModel
 
     @Override
     protected void addAdditionPropertiesToCodeGenModel(CodegenModel codegenModel, Schema schema) {
-        super.addAdditionPropertiesToCodeGenModel(codegenModel, schema);
+        if (!supportsAdditionalPropertiesWithComposedSchema) {
+            // The additional (undeclared) propertiees are modeled in Java as a HashMap.
+            // 
+            // 1. supportsAdditionalPropertiesWithComposedSchema is set to false:
+            //    The generated model class extends from the HashMap. That does not work
+            //    with composed schemas that also use a discriminator because the model class
+            //    is supposed to extend from the generated parent model class.
+            // 2. supportsAdditionalPropertiesWithComposedSchema is set to true:
+            //    The HashMap is a field.
+            super.addAdditionPropertiesToCodeGenModel(codegenModel, schema);
+        }
 
         // See https://github.com/OpenAPITools/openapi-generator/pull/1729#issuecomment-449937728
-        codegenModel.additionalPropertiesType = getSchemaType(getAdditionalProperties(schema));
-        addImport(codegenModel, codegenModel.additionalPropertiesType);
+        Schema s = getAdditionalProperties(schema);
+        // 's' may be null if 'additionalProperties: false' in the OpenAPI schema.
+        if (s != null) {
+            codegenModel.additionalPropertiesType = getSchemaType(s);
+            addImport(codegenModel, codegenModel.additionalPropertiesType);
+        }
     }
 }

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

@@ -176,6 +176,7 @@ public JavaClientCodegen() {
         // inherit from self, any oneOf schemas, any anyOf schemas, any x-discriminator-values,
         // and the discriminator mapping schemas in the OAS document.
         this.setLegacyDiscriminatorBehavior(false);
+
     }
 
     @Override
@@ -371,6 +372,14 @@ public void processOpts() {
             }
             supportingFiles.add(new SupportingFile("AbstractOpenApiSchema.mustache", (sourceFolder + File.separator + modelPackage().replace('.', File.separatorChar)).replace('/', File.separatorChar), "AbstractOpenApiSchema.java"));
             forceSerializationLibrary(SERIALIZATION_LIBRARY_JACKSON);
+
+            // Composed schemas can have the 'additionalProperties' keyword, as specified in JSON schema.
+            // In principle, this should be enabled by default for all code generators. However due to limitations
+            // in other code generators, support needs to be enabled on a case-by-case basis.
+            // The flag below should be set for all Java libraries, but the templates need to be ported
+            // one by one for each library.
+            supportsAdditionalPropertiesWithComposedSchema = true;
+
         } else if (NATIVE.equals(getLibrary())) {
             setJava8Mode(true);
             additionalProperties.put("java8", "true");

modules/openapi-generator/src/main/resources/Java/libraries/jersey2/AbstractOpenApiSchema.mustache

@@ -30,29 +30,29 @@ public abstract class AbstractOpenApiSchema {
         this.isNullable = isNullable;
     }
 
-    /***
-     * Get the list of schemas allowed to be stored in this object
+    /**
+     * Get the list of oneOf/anyOf composed schemas allowed to be stored in this object
      *
      * @return an instance of the actual schema/object
      */
     public abstract Map<String, GenericType> getSchemas();
 
-    /***
+    /**
      * Get the actual instance
      *
      * @return an instance of the actual schema/object
      */
     @JsonValue
     public Object getActualInstance() {return instance;}
 
-    /***
+    /**
      * Set the actual instance
      *
      * @param instance the actual instance of the schema/object
      */
     public void setActualInstance(Object instance) {this.instance = instance;}
 
-    /***
+    /**
      * Get the schema type (e.g. anyOf, oneOf)
      *
      * @return the schema type
@@ -101,7 +101,7 @@ public abstract class AbstractOpenApiSchema {
         return Objects.hash(instance, isNullable, schemaType);
     }
 
-    /***
+    /**
      * Is nullalble
      *
      * @return true if it's nullable
@@ -113,4 +113,7 @@ public abstract class AbstractOpenApiSchema {
             return Boolean.FALSE;
         }
     }
+
+{{>libraries/jersey2/additional_properties}}
+
 }

modules/openapi-generator/src/main/resources/Java/libraries/jersey2/JSON.mustache

@@ -15,9 +15,16 @@ import com.fasterxml.jackson.datatype.joda.JodaModule;
 {{#threetenbp}}
 import com.fasterxml.jackson.datatype.threetenbp.ThreeTenModule;
 {{/threetenbp}}
+{{#models.0}}
+import {{modelPackage}}.*;
+{{/models.0}}
 
 import java.text.DateFormat;
-
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import javax.ws.rs.core.GenericType;
 import javax.ws.rs.ext.ContextResolver;
 
 {{>generatedAnnotation}}
@@ -69,4 +76,180 @@ public class JSON implements ContextResolver<ObjectMapper> {
    * @return object mapper
    */
   public ObjectMapper getMapper() { return mapper; }
+
+  /**
+   * Returns the target model class that should be used to deserialize the input data.
+   * The discriminator mappings are used to determine the target model class.
+   *
+   * @param node The input data.
+   * @param modelClass The class that contains the discriminator mappings.
+   */
+  public static Class getClassForElement(JsonNode node, Class modelClass) {
+    ClassDiscriminatorMapping cdm = modelDiscriminators.get(modelClass);
+    if (cdm != null) {
+      return cdm.getClassForElement(node, new HashSet<Class>());
+    }
+    return null;
+  }
+
+  /**
+   * Helper class to register the discriminator mappings.
+   */
+  private static class ClassDiscriminatorMapping {
+    // The model class name.
+    Class modelClass;
+    // The name of the discriminator property.
+    String discriminatorName;
+    // The discriminator mappings for a model class.
+    Map<String, Class> discriminatorMappings;
+
+    // Constructs a new class discriminator.
+    ClassDiscriminatorMapping(Class cls, String name) {
+      modelClass = cls;
+      discriminatorName = name;
+      discriminatorMappings = new HashMap<String, Class>();
+    }
+
+    // Register a discriminator mapping for the specified model class.
+    void registerMapping(String mapping, Class cls) {
+      discriminatorMappings.put(mapping, cls);
+    }
+
+    // Return the name of the discriminator property for this model class.
+    String getDiscriminatorPropertyName() {
+      return discriminatorName;
+    }
+
+    // Return the discriminator value or null if the discriminator is not
+    // present in the payload.
+    String getDiscriminatorValue(JsonNode node) {
+      // Determine the value of the discriminator property in the input data.
+      if (discriminatorName != null) {
+        // Get the value of the discriminator property, if present in the input payload.
+        node = node.get(discriminatorName);
+        if (node != null && node.isValueNode()) {
+          String discrValue = node.asText();
+          if (discrValue != null) {
+            return discrValue;
+          }
+        }
+      }
+      return null;      
+    }
+
+    /**
+     * Returns the target model class that should be used to deserialize the input data.
+     * This function can be invoked for anyOf/oneOf composed models with discriminator mappings.
+     * The discriminator mappings are used to determine the target model class.
+     *
+     * @param node The input data.
+     * @param visitedClasses The set of classes that have already been visited.
+     */
+    Class getClassForElement(JsonNode node, Set<Class> visitedClasses) {
+      if (visitedClasses.contains(modelClass)) {
+        // Class has already been visited.
+        return null;
+      }
+      // Determine the value of the discriminator property in the input data.
+      String discrValue = getDiscriminatorValue(node);
+      if (discrValue == null) {
+        return null;
+      }
+      Class cls = discriminatorMappings.get(discrValue);
+      // It may not be sufficient to return this cls directly because that target class
+      // may itself be a composed schema, possibly with its own discriminator.
+      visitedClasses.add(modelClass);
+      for (Class childClass : discriminatorMappings.values()) {
+        ClassDiscriminatorMapping childCdm = modelDiscriminators.get(childClass);
+        if (childCdm == null) {
+          continue;
+        }
+        if (!discriminatorName.equals(childCdm.discriminatorName)) {
+          discrValue = getDiscriminatorValue(node);
+          if (discrValue == null) {
+            continue;
+          }
+        }
+        if (childCdm != null) {
+          // Recursively traverse the discriminator mappings.
+          Class childDiscr = childCdm.getClassForElement(node, visitedClasses);
+          if (childDiscr != null) {
+            return childDiscr;
+          }
+        }
+      }
+      return cls;
+    }
+  }
+
+  /**
+   * Returns true if inst is an instance of modelClass in the OpenAPI model hierarchy.
+   *
+   * The Java class hierarchy is not implemented the same way as the OpenAPI model hierarchy,
+   * so it's not possible to use the instanceof keyword.
+   *
+   * @param modelClass A OpenAPI model class.
+   * @param inst The instance object.
+   */
+  public static boolean isInstanceOf(Class modelClass, Object inst, Set<Class> visitedClasses) {
+    if (modelClass.isInstance(inst)) {
+      // This handles the 'allOf' use case with single parent inheritance.
+      return true;
+    }
+    if (visitedClasses.contains(modelClass)) {
+      // This is to prevent infinite recursion when the composed schemas have
+      // a circular dependency.
+      return false;
+    }
+    visitedClasses.add(modelClass);
+
+    // Traverse the oneOf/anyOf composed schemas.
+    Map<String, GenericType> descendants = modelDescendants.get(modelClass);
+    if (descendants != null) {
+      for (GenericType childType : descendants.values()) {
+        if (isInstanceOf(childType.getRawType(), inst, visitedClasses)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  private static Map<Class, ClassDiscriminatorMapping> modelDiscriminators = new HashMap<Class, ClassDiscriminatorMapping>();
+
+  /**
+   * Register the discriminators for all composed models.
+   */
+  private static void registerDiscriminators() {
+    {{#models}}
+    {{#model}}
+    {{#discriminator}}
+    {
+      // Initialize the discriminator mappings for '{{classname}}'.
+      ClassDiscriminatorMapping m = new ClassDiscriminatorMapping({{classname}}.class, "{{propertyBaseName}}");
+      {{#mappedModels}}
+      m.registerMapping("{{mappingName}}", {{modelName}}.class);
+      {{/mappedModels}}
+      m.registerMapping("{{name}}", {{classname}}.class);
+      modelDiscriminators.put({{classname}}.class, m);
+    }
+    {{/discriminator}}
+    {{/model}}
+    {{/models}}
+  }
+
+  private static Map<Class, Map<String, GenericType>> modelDescendants = new HashMap<Class, Map<String, GenericType>>();
+
+  /**
+   * Register the oneOf/anyOf descendants.
+   * TODO: this should not be a public method.
+   */
+  public static void registerDescendants(Class modelClass, Map<String, GenericType> descendants) {
+    modelDescendants.put(modelClass, descendants);
+  }
+
+  static {
+    registerDiscriminators();
+  }
+
 }

modules/openapi-generator/src/main/resources/Java/libraries/jersey2/additional_properties.mustache

@@ -0,0 +1,31 @@
+{{#additionalPropertiesType}}
+  /**
+   * A container for additional, undeclared properties.
+   * This is a holder for any undeclared properties as specified with
+   * the 'additionalProperties' keyword in the OAS document.
+   */
+  @JsonUnwrapped
+  private Map<String, {{{.}}}> additionalProperties;
+
+  /**
+   * Set the additional (undeclared) property with the specified name and value.
+   * If the property does not already exist, create it otherwise replace it.
+   */
+  public {{classname}} putAdditionalProperty(String key, {{{.}}} value) {
+    if (this.additionalProperties == null) {
+        this.additionalProperties = new HashMap<String, {{{.}}}>();
+    }
+    this.additionalProperties.put(key, value);
+    return this;
+  }
+
+  /**
+   * Return the additional (undeclared) property with the specified name.
+   */
+  public {{{.}}} getAdditionalProperty(String key) {
+    if (this.additionalProperties == null) {
+        return null;
+    }
+    return this.additionalProperties.get(key);
+  }
+{{/additionalPropertiesType}}