Canonical (alphabetical) key ordering in JSON output/Canonization of json

[StormLord07]

I'm currently using Glaze for JSON serialization in C++, and I'm looking to produce canonical JSON output [RFC 8785 (JSON Canonicalization Scheme)](https://cyberphone.github.io/ietf-json-canon/). This can be usefull if we need to sign the json, and changing the order might affect the signature.

What is canonised JSON form:

• Strict alphabetical ordering of object keys
• Minified, whitespace-free output
• Deterministic serialization, regardless of field declaration order or glz::meta

I’m aware that:

• glz::opts{ .prettify = false } gives me compact output so minified output is already supported
• However, the key ordering still follows the struct or glz::meta order — not alphabetical. We can change it but in case we use unordered_map, that could lead to some issues.

What I wanted

A way to achieve:

glz::opts{ .canonical = true }  // That'd imply overriding the .prettify = false so might not be a great idea, also would require knowing RFC 8785
// or
glz::opts{ .sort_keys = true }  // Cleaner meaning
glz::optis{ .normalize = true } 

Or maybe even providing custom key sorter, Unfortunately I am not too acquainted with glz::reflect to know if that's at all possible

…which would:

• Recursively sort all object keys alphabetically (RFC-compliant)
• Preserve deterministic array order
• Normalize numeric/string representations if applicable (RFC-compatible optional bonus)

Examples from other languages

Other languages have the support for this, but they do use different containers

• Java (Jackson):

  objectMapper.configure(SerializationConfig.Feature.SORT_PROPERTIES_ALPHABETICALLY, true); // older
  objectMapper.configure(MapperFeature.SORT_PROPERTIES_ALPHABETICALLY, true) // newer

• Python:

  json.dumps(obj, sort_keys=True)

• C++ (nlohmann::json)

  nlohmann::json j;
  j.dump(); // AFAIK it sorts by default due to it using std::map under the hood

Questions

• Is alphabetical key sorting (or full RFC 8785 canonicalization) currently supported in Glaze?

• If not, is it considered or it'd be useless, since there are other ways to achieve the same?

• Are there recommended patterns to achieve this today — without modifying struct layout or glz::meta definitions?

• Or is this feature more feasible in C++26 once reflection becomes standardized?

Also just wanted to thank you for answering questions, and just keeping up the great work, because of your library I know so much more about modern c++.

[stephenberry]

If you use a std::map then keys will be ordered. Likewise glz::json_t orders keys and uses a std::map underneath.

Using a glz::meta for your structs allows you to define a canonical order even if the fields aren't in that order. But, it requires writing out a glz::meta for all your structs.

It would not be too difficult to write out ordered keys for purely reflected structs. This is not currently supported and I'll look into adding a compile time option to enable this.

For now, just order the keys how you like manually in a glz::meta or use a std::map or glz::json_t

[StormLord07]

Wanted to ask two more thing.

So this will be supported, just a bit down the line right?

Do you think strong order validation could be introduced too/or needed? Might be usefull might be not.

[stephenberry]

Yes, I think canonical ordering and even custom ordering algorithms should be supported. I now have a path forward to support compile time custom ordering, which will hopefully be implemented soon. It just isn't top priority right now, but it would work similar to the new rename_key support.

Requiring a specific order is also a feature I've wanted for a while, and I think it would come soon after the compile time custom ordering. I want to integrate this well into the hashing system, because we can actually hash more efficiently if we know the order in which the keys must be found.

[StormLord07]

My god you'r the best. Thanks for clarification.