Mapping response based on query parameter

[sagacity]

I am working on implementing a server for an API that returns JSON if there is an f=json query parameter and has to return XML otherwise. I deal with the responses by having a set of response structs for the JSON responses, with a ToXml trait that can be implemented by a struct to convert itself to a struct that is suitable for XML serialization (with different Serde annotations etc).

What would be the best way to implement this in a way that has no impact on route handler implementations? Currently my route handlers return a tuple containing both the f query parameter and the response struct (which, again, is bounded to an ToXml trait) so I can optionally convert it to XML from an IntoResponse handler. But this is a bit annoying since my route handlers are not returning 'pure' responses now. Since IntoResponse has no access to request query parameters I need to forward the f parameter via this tuple.

I looked at the new map_response functionality but that seems to only deal with response bytes and is not able to get the original strongly typed response object (with optional bounds, like ToXml in my case) in order to map it.

It's not a huge deal, but I was just curious to how something like this might be implemented.

[davidpdrsn]

You can do something like this

use axum::{
    async_trait,
    extract::{FromRequestParts, Query},
    http::request::Parts,
    response::Response,
};
use serde::{Deserialize, Serialize};

async fn handler(format: Format) -> Response {
    #[derive(Serialize)]
    struct Data {
        value: String,
    }

    format.render(Data {
        value: "foo".to_owned(),
    })
}

enum Format {
    Json,
    Xml,
}

impl Format {
    fn render<T>(self, data: T) -> Response
    where
        T: Serialize,
    {
        match self {
            Format::Json => {
                todo!("render json...")
            }
            Format::Xml => {
                todo!("render xml...")
            }
        }
    }
}

#[async_trait]
impl<S> FromRequestParts<S> for Format
where
    S: Send + Sync,
{
    type Rejection = std::convert::Infallible;

    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
        #[derive(Deserialize)]
        struct FormatQuery {
            f: String,
        }

        let Query(query) = match Query::<FormatQuery>::from_request_parts(parts, state).await {
            Ok(query) => query,
            Err(_) => return Ok(Self::Xml),
        };

        if query.f == "json" {
            Ok(Self::Json)
        } else {
            Ok(Self::Xml)
        }
    }
}

[sagacity]

Thanks for the prompt reply! Would there be a way to avoid needing to inject format in every handler, though?

[davidpdrsn]

There is. You can insert a response extension (via IntoResponseParts), access that in a middleware, and build your response as you want. However I would recommend doing it in the handler.

[sagacity]

Ok, will do! I guess doing it in handler is a lot less complicated.