Support serializing maps and nested structs about serde_urlencoded

[nox]

The solution is to just use serde_json yourself for whichever keys you want

[rnag]

Update: It looks like currently serde_url_encoded might not support nested struct or also HashMap (and other map-like) types. If anyone is curious, my current workaround is to implement a custom Serializer for the main struct, defined as follows:

use serde::ser::SerializeStruct;
use serde::{Deserialize, Serialize, Serializer};

impl<'a> Serialize for AuditLogParams<'a> {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut s = if let Some(ref filters) = self.filters {
            let mut s = serializer.serialize_struct("AuditLogParams", 3)?;
            s.serialize_field("filters", &serde_json::to_string(filters).unwrap())?;
            s
        } else {
            serializer.serialize_struct("AuditLogParams", 2)?
        };
        s.serialize_field("page", &self.page)?;
        s.serialize_field("per_page", &self.per_page)?;

        s.end()
    }
}

For a more generic approach, one could also use serialize_with along with a helper function defined as follows:

/// Helper function to serialize a `struct` as a JSON string, to be used with
/// the [`serialize_with`] attribute.
///
/// # Example
/// ```rust
/// #[derive(Debug, Serialize, Deserialize)]
/// struct MyStruct {
///     #[serde(serialize_with = "to_json_string")]
///     #[serde(skip_serializing_if = "Option::is_none")]
///     my_field: Option<Inner>,
/// }
///
/// struct Inner;
/// ```
///
/// [`serialize_with`]: https://serde.rs/field-attrs.html#serialize_with
fn to_json_string<S, T>(t: &T, s: S) -> std::result::Result<S::Ok, S::Error>
where
    S: Serializer,
    T: Serialize,
{
    s.serialize_str(&serde_json::to_string(t).unwrap())
}

Then my tests in the crate now look like this:

#[cfg(test)]
mod tests {
    use super::*;
    use serde_urlencoded::to_string;

    #[test]
    fn test_serialize_filters_as_url_encoded_params() -> Result<()> {
        sensible_env_logger::safe_init!();

        let filters = FilterParams {
            start_time: "2020-08-24T17:03:00Z",
            end_time: "",
        };

        let params = AuditLogParams::from(filters);

        let result = to_string(params)?;
        trace!(result); // "filters=%7B%22start_time%22%3A%222020-08-24T17%3A03%3A00Z%22%7D&page=1&per_page=1000"

        // result contains `start_time` but *not* the `end_time`
        assert!(result.contains("start_time"));
        assert!(!result.contains("end_time"));

        Ok(())
    }
}

[rnag]

Hi @nox , curious if any update was implemented as part of this issue? I did put together a workaround which appears to work for now, however I think it would be great if serde_urlencoded supported such a use case (nested structs and maps) out of the box. I think it would be pretty unambiguous to implement as well - essentially just using serde_json library to serialize the nested values.