How can I sort fields in alphabetic order when serializing with serde?

Question

I've an API that requires the object's fields to be sorted alphabetically because the struct has to be hashed.

In Java/Jackson, you can set a flag in the serializer: MapperFeature.SORT_PROPERTIES_ALPHABETICALLY. I can't find anything similar in Serde.

I'm using rmp-serde (MessagePack). It follows the annotations and serialization process used for JSON, so I thought that it would be fully compatible, but the sorting provided by @jonasbb doesn't work for it.

The struct has (a lot of) nested enums and structs which have to be flattened for the final representation. I'm using Serialize::serialize for that, but calling state.serialize_field at the right place (such that everything is alphabetical) is a pain because the enums need a match clause, so it has to be called multiple times for the same field in different places and the code is very difficult to follow.

As possible solutions, two ideas:

1. Create a new struct with the flat representation and sort the fields alphabetically manually.

   This is a bit error prone, so a programmatic sorting solution for this flattened struct would be great.

2. Buffer the key values in Serialize::serialize (e.g. in a BTreeMap, which is sorted), and call state.serialize_field in a loop at the end.

   The problem is that the values seem to have to be of type Serialize, which isn't object safe, so I wasn't able to figure out how to store them in the map.

How to sort HashMap keys when serializing with serde? is similar but not related because my question is about the sorting of the struct's fields/properties.

Answer 1

You are not writing which data format you are targetting. This makes it hard to find a solution, since some might not work in all cases.

This code works if you are using JSON (unless the preserve_order feature flag is used). The same would for for TOML by serializing into toml::Value as intermediate step. The solution will also work for other data formats, but it might result in a different serialization, for example, emitting the data as a map instead of struct-like.

fn sort_alphabetically<T: Serialize, S: serde::Serializer>(value: &T, serializer: S) -> Result<S::Ok, S::Error> {
    let value = serde_json::to_value(value).map_err(serde::ser::Error::custom)?;
    value.serialize(serializer)
}

#[derive(Serialize)]
struct SortAlphabetically<T: Serialize>(
    #[serde(serialize_with = "sort_alphabetically")]
    T
);

#[derive(Serialize, Deserialize, Default, Debug)]
struct Foo {
    z: (),
    bar: (),
    ZZZ: (),
    aAa: (),
    AaA: (),
}

println!("{}", serde_json::to_string_pretty(&SortAlphabetically(&Foo::default()))?);

because the struct has to be hashed

While field order is one source of indeterminism there are other factors too. Many formats allow different amounts of whitespace or different representations like Unicode escapes \u0066.