JSON to XML Converter

import { XMLBuilder } from 'fast-xml-parser';

const builder = new XMLBuilder({
  ignoreAttributes: false,        // default is true: @_ keys would be dropped
  attributeNamePrefix: '@_',
  textNodeName: '#text',
  format: true,
  indentBy: '  ',
  suppressEmptyNode: true,        // write <note/> rather than <note></note>
  processEntities: true,          // escape &, < and " in values
});

const xml = '<?xml version="1.0" encoding="UTF-8"?>\n' + builder.build(data);

// XMLBuilder does not sanitise keys. A key of "2024 total" is written
// verbatim and produces XML that will not parse, so check before building:
const illegal = Object.keys(flatten(data))
  .filter((k) => !/^[A-Za-z_][\w.\-]*(:[A-Za-z_][\w.\-]*)?$/.test(k));
if (illegal.length) throw new Error('Illegal XML names: ' + illegal.join(', '));

import json
import re
import xmltodict


def legal_name(key):
    """Replace illegal characters rather than stripping them, so that
    distinct keys stay distinct. Prefix a leading digit."""
    name = re.sub(r'[^\w.\-:]', '_', key, flags=re.UNICODE)
    return name if re.match(r'^[A-Za-z_:]', name) else '_' + name


def sanitise(node):
    if isinstance(node, dict):
        return {legal_name(k): sanitise(v) for k, v in node.items()}
    if isinstance(node, list):
        return [sanitise(v) for v in node]
    return node


data = json.loads(json_source)
if not isinstance(data, dict) or len(data) != 1:
    data = {'root': data}          # xmltodict.unparse requires a single root

print(xmltodict.unparse(
    sanitise(data),
    pretty=True, indent='  ',
    attr_prefix='@_', cdata_key='#text',
    full_document=True,            # emit the <?xml ...?> declaration
))

# xmltodict raises ValueError("Document must have exactly one root.") rather
# than guessing, which is correct behaviour and the reason for the wrap.

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.dataformat.xml.XmlMapper;

JsonNode tree = new ObjectMapper().readTree(jsonSource);

XmlMapper xml = new XmlMapper();
xml.enable(SerializationFeature.INDENT_OUTPUT);

// JSON has no root name and Jackson will not invent one, so supply it.
String out = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
    + xml.writer().withRootName("root").writeValueAsString(tree);

// Two things Jackson will not do for you:
//  1. It does not sanitise names. A key with a space throws
//     IllegalArgumentException at write time, which is at least loud.
//  2. It writes every value as a child element. There is no attribute
//     convention on a JsonNode, so @_ keys become elements unless you bind
//     to a class annotated with @JacksonXmlProperty(isAttribute = true).

using System.Xml;
using Newtonsoft.Json;

// The second argument is the root element name, used when the JSON does not
// already have exactly one top-level property. Without it, multi-key JSON
// throws JsonSerializationException rather than producing invalid XML.
XmlDocument? document = JsonConvert.DeserializeXmlNode(jsonSource, "root");

if (document is null) throw new InvalidOperationException("Empty JSON.");

var settings = new XmlWriterSettings { Indent = true, IndentChars = "  " };
using var writer = XmlWriter.Create(Console.Out, settings);
document.Save(writer);

// Json.NET uses "@" for attributes and "#text" for text, so retarget the
// keys if your JSON came from a converter using "@_". It does not sanitise
// names either: a property called "2024 total" throws XmlException("The ''
// character, hexadecimal value 0x20, cannot be included in a name").

<?php
$data = json_decode($source, true, 512, JSON_THROW_ON_ERROR);

function legal_name(string $key): string {
    $name = preg_replace('/[^\w.\-:]/u', '_', $key);
    return preg_match('/^[A-Za-z_:]/', $name) ? $name : '_' . $name;
}

function write_node(XMLWriter $w, string $name, mixed $value): void {
    if (is_array($value) && array_is_list($value)) {
        foreach ($value as $v) write_node($w, $name, $v);   // repeat, no wrapper
        return;
    }
    $w->startElement(legal_name($name));
    if (is_array($value)) {
        foreach ($value as $k => $v) {
            if (str_starts_with((string) $k, '@_')) {
                $w->writeAttribute(legal_name(substr((string) $k, 2)), (string) $v);
            } elseif ($k === '#text') {
                $w->text((string) $v);
            } else {
                write_node($w, (string) $k, $v);
            }
        }
    } elseif ($value !== null) {
        $w->text(is_bool($value) ? ($value ? 'true' : 'false') : (string) $value);
    }
    $w->endElement();
}

$single = count($data) === 1;
$w = new XMLWriter();
$w->openMemory();
$w->setIndent(true);
$w->setIndentString('  ');
$w->startDocument('1.0', 'UTF-8');
write_node($w, $single ? (string) array_key_first($data) : 'root',
               $single ? reset($data) : $data);
$w->endDocument();
echo $w->outputMemory();

# yq v4 (Mike Farah). JSON is a subset of YAML, so -p=json works directly.
yq -p=json -o=xml '.' payload.json

# Set the root and the key conventions to match this page:
yq -p=json -o=xml \
   --xml-attribute-prefix='@_' \
   --xml-content-name='#text' \
   '{"root": .}' payload.json

# yq writes no XML declaration, so prepend one if a consumer expects it, and
# check the result: yq does not sanitise element names.
{ echo '<?xml version="1.0" encoding="UTF-8"?>'
  yq -p=json -o=xml '{"root": .}' payload.json; } | xmllint --noout --nonet -