[BUG] XML name incorrect when referenced or when item of an array

[Sevenarth]

Description

The endpoints described in the spec file are supposed to all read (and produce if the model is set in the response body):

<Entries>
  <Entry value="1234" />
  <Entry value="1234" />
</Entries>

In this case I generated the models with the Java generator, which seems to be the best implementation fir POJOs, and I plugged them into a Spring Boot server stub. (It was just easier to get responses to this mock spec this way for the purpose of this issue)
Normally I work with the JaxRS Resteasy and Spring Boot generator customised with the Java generator POJO templates (since the other two are lacking templates for XML support)

For each case these are what the system is expecting (or generating as a response) instead:

arrayInObject: (EntriesObject response)

<EntriesObject>
    <entries>
        <entries>
            <value>1234</value>
        </entries>
    </entries>
</EntriesObject>

wholeObject: (WholeObject response)

<WholeObject>
    <entries>
        <entries>
            <value>1234</value>
        </entries>
    </entries>
</WholeObject>

rootArray: (List response)

<List>
    <item>
        <value>1234</value>
    </item>
</List>

I am using JAXB for the serialisation process.

In writing a demonstration for this issue, lots of other issues came up, but my original issue was only regarding the XML name of array items: the generator generates the following: (for WholeObject and EntriesObject)

  // Is a container wrapped=false
  // items.name=entries items.baseName=entries items.xmlName= items.xmlNamespace=
  // items.example= items.type=Entry
  @XmlElement(name = "entries")
  private List<Entry> entries = new ArrayList<>();

Even if I try to change names to the YAML properties or xmlName, the name assigned to the XmlElement is always the variable name, instead of xmlName or the YAML property name as a fallback. (In this case it should be @XmlElement(name = "Entry"))

I take the opportunity to also report that when an object (that has a xmlName) is referenced to a property (of another object), it takes the property name instead of the xmlName:

MyObject:
  type: object
  xml:
    name: PrimaryObject
  properties:
    otherObject:
      $ref: '#/components/schemas/OtherObject'
OtherObject:
  type: object
  xml:
    name: SecondaryObject
  properties:
    value:
      ...

generates:

<PrimaryObject>
  <otherObject>
    <value>...</value>
  </otherObject>
</PrimaryObject>

instead of:

<PrimaryObject>
  <SecondaryObject>
    <value>...</value>
  </SecondaryObject>
</PrimaryObject>

openapi-generator version

4.0.2

OpenAPI declaration url

https://gist.github.com/Sevenarth/595ce008748a0fa1e43bcfcdcaffe229

Command line used for generation

To retrieve the generated models:

java -jar openapi-generator-cli.jar generate \
  -i xmlname_bug.yaml \
  -o OAPIxmlNameBug \
  -g java \
  --additional-properties withXml=true \
  --additional-properties java8=true

(As said before, these models have been tested in the Spring Boot server stub)

Steps to reproduce

1. Generate models using the Java generator
2. Generate server stub using the Spring Boot generator
3. Adapt the Java generator models to the Spring Boot server stub
4. Run Spring Boot server in debug or Create example response models and run server
5. Analyse request bodies or response bodies

Related issues/PRs

Unknown

Suggest a fix

The fix to my original issue is to assign XmlElement(name = "...") to entries.items.xml.name (xmlName in container items), and @XmlElementWrapper(name="...") to entries.xml.name when entries.xml.wrapped=true.

[auto-labeler]

👍 Thanks for opening this issue!
🏷 I have applied any labels matching special text in your issue.

The team will review the labels and make any necessary changes.

[Sevenarth]

NOTE: Technically this issue should be related to the default generator or openapi parser and not any language-specific generator considering that the variable xmlName in the templates is always empty.

[f-zampieri]

@Sevenarth refers to two issues - one in the case of using $ref, the other in the case of items in an array. I am running into this issue when attempting to use $ref. Duplicating the example below:

MyObject:
  type: object
  xml:
    name: PrimaryObject
  properties:
    otherObject:
      $ref: '#/components/schemas/OtherObject'
OtherObject:
  type: object
  xml:
    name: SecondaryObject
  properties:
    value:
      ...

As indicated, the generated name is the base name, and not the XML name.
Any possible work-arounds for now?
Thanks for any replies.

[Sevenarth]

Hi @f-zampieri,
Since nobody has looked into this issue, I developed my own patch, since I used this library for a project at work, and we needed the patch asap. I do not work there anymore, so I don't have my patch anymore. I can instruct you on my quick patch, so you could apply it on your own:

The patch was reflected in the class org.openapitools.codegen.InlineModelResolver, found under modules/openapi-generator folder in the repo. In all the occasions where an array is detected, if it gets flattened, get the xml property from the object node and apply it to the array children node, if it is already referencing an object, then get the referenced object node (there is already a method to do this somewhere, once you find it it's quite straightforward), and then do the previous part to apply the xml property. You have to do the latter also for all the cases where a model is just referenced. This is somewhat the process.

Essentially the codegen generator gets the parsed openapi spec and automatically passes it to the templates, without fetching the values underlying a reference.

If you are using the code generator as a standalone then you would need to recompile the whole project, otherwise if you are using it from another java project, you need to put the patched class in the classpath before the openapi codegen library, so it overrides the original one.

Hope I have been helpful enough!

NOTE: make sure that the templates you are using are also taking the xml properties correctly! (Sadly, any templates do not even take XML properties into account) Otherwise you would need to use custom templates to suit them to your needs!

[f-zampieri]

Hello @Sevenarth,
Thanks very much for your response. I have spent some time trying to understand your guidelines, and it seems to me there is a mismatch between my issue and the fix you are suggesting. The class InlineModelResolver does not appear to be responsible for unaliasing $refs. If we refer to our example:

  type: object
  xml:
    name: PrimaryObject
  properties:
    otherObject:
      $ref: '#/components/schemas/OtherObject'
OtherObject:
  type: object
  xml:
    name: SecondaryObject
  properties:
    value:
      ...

The issue at hand is that MyObject needs the XML data contained in OtherObject, but this cannot happen without unaliasing the $ref. I am digging through DefaultCodegen and some other classes, but any other leads you have would be awesome.
Thanks again for volunteering your help, I greatly appreciate it.

[Sevenarth]

Hi @f-zampieri,

No, InlineModelResolver only deals with flattening the schema. What I explained is that you can edit it, because it already contains the loops that you need. Since it loops through the models recursively, it checks if a model above first level is referenced or needs to be moved (flattened). In this situation, when it encounters a referenced model you can just add the code that takes the xml property from the reference models and adds it to the reference node.

[f-zampieri]

Hello @Sevenarth,
With your help I was able to get a fix in place. Thanks very much!
Note this only addresses the bug concerning XML not being applied to $ref fields, but not the bug concerning arrays.
The algorithm (if I may call it that) might not be quite what you envisioned. What I'm doing is as follows.

1. While flattening the properties of schema X, for a given property we'll call schema Y, I check if $ref is present. If so, I add schema X and schema Y to a Map such that schema Y maps to schema X. For example:

ObjectA:
  type: object
  properties:
    myField:
      $ref: '#/components/schemas/InnerObject'
ObjectB:
  type: object
  properties:
    theField:
      $ref: '#/components/schemas/InnerObject'
InnerObject:
  type: object
  xml:
    name: InnerObject
  properties:
    value:
      ...

This object structure will produce the mapping: "InnerObject" -> [ "ObjectA", "ObjectB" ]. Let's call that map 'referredToBy'.
2. Once flattening components is complete, I pass the XML properties along:

models := OpenAPI schemas
for refereeName in referredToBy.keys():
  refereeSchema := models.get(refereeName)
  if refereeSchema XML present:
    listOfSchemasReferringToReferee = referredToBy.get(refereeName)
    for refererName in listOfSchemasReferringToReferee:
      referrerSchema := models.get(refererName)
      for referrerProperty in referrerSchema.getProperties()
        if referrerProperty $ref present AND refereeName equals property $ref:
          property.setXML(refereeSchema.getXML())

This approach seems a little.. unrefined. I am curious to hear your thoughts on it.
I hope you've found this to be useful. Again, thank you.