Referential Arrays

[ksafranski]

Consider the following JSON Data:

{
  arr: [ { foo: 'bar', fizz: 'buzz' } ]
}

Currently the lib supports this format:

root: example
elements:
  - arr:
      arrItem:
        arrItemPropFoo: ${foo}
        arrItemPropFizz: ${buzz}

The output being:

<example>
  <arr>
    <arrItem>
      <arrItemPropFoo>bar</arr1ItemPropFoo>
      <arrItemPropFizz>buzz</arr1ItemPropFizz>
    </arrItem>
  </arr1>
</example>

This works but in the elements you have to have arr as the key, and subsequently this is the tag that gets generated and the item property, meaning there is no ability to use a different element, for example:

root: example
elements:
  - SomeCustomArrTag:
      SomeCustomArrItem:
        SomeCustomArrItemPropFoo: ${foo}
        SomeCustomArrItemPropFizz: ${fizz}

Ideally it would be better to allow the config above, then change the ${foo} to be a path reference to the array, something like ${arr[].foo} and ${arr[].fizz}

root: example
elements:
  - SomeCustomArrTag:
      SomeCustomArrItem:
        SomeCustomArrItemPropFoo: ${arr[].foo}
        SomeCustomArrItemPropFizz: ${arr[].fizz}

This would allow for creating referential mappings instead of explicit ones and supporting custom tags for array elements.

Open to better suggestions on the formatting of the template if the current setup is too muddy or confusing.

[TomFrost]

Oh that's interesting -- I ran into the exact same thing when I was writing Jexl. In that case, I put the child element inside the square brackets, so that I could go on to use it for other operations like filtering the array based on that element: https://github.com/TomFrost/Jexl?tab=readme-ov-file#collections

Which makes me think: does it make sense to use Jexl or an expression language like Jexl for this? Not just for this case specifically, but I can imagine there are cases where a publisher might give us a value in all lowercase and we need it to be in all caps, or we need to create one field by concatenating two other fields together, or transform a "YYYYMMDD" date into "YYYY-MM-DD", or any number of things that we can't achieve through a 1:1 map and don't want to fully reimplement functionality that an expression language could handle.

[ksafranski]

Hence why I sent it to you :)

Figure there are a number of things we could pull over from Jexl but you have the domain knowledge here.