Custom extractor for Queries with fields that have enums with enum values

[Gautham-kj]

Summary

The given below is the query parameter that I want to write a custom extractor for

#[derive(Deserialize, PartialEq, ToSchema)]
pub enum Order {
    Inc,
    Dec,
}
#[derive(Deserialize, PartialEq, ToSchema)]
pub enum Filters {
    Rating(Order),
    DateOfCreation(Order),
    Alphabetical(Order),
    Price(Order),
}

The entire Query struct is below

#[derive(Deserialize, ToSchema, IntoParams)]
pub struct ItemsQuery {
    take: Option<u32>,
    page_no: Option<u32>,
    filter: Option<Filters>,
    search_string: Option<String>,
}

This is my first project in rust and I wanted help to understand how to create a custom extractor with FromRequest or using the FromRequestParts while reusing features of the Query extractor

axum version

0.7.4

[jplatte]

Sorry, what is it that you want to customize?

[Gautham-kj]

passing ?filter=Price as the query gets me an error saying

Failed to deserialize query string: expected unit variant

and passing ?filter=Price(Inc) as the query gives me an error

Failed to deserialize query string: unknown variant `Price(Inc)`, expected one of `Rating`, `DateOfCreation`, `Alphabetical`, `Price`

I am not sure how to fix the error. I'm assuming a custom extractor with some way of handling this can be made. Or am I passing the query parameters incorrectly. (I am using the axum::extract::Query struct currently)

[jplatte]

You don't need a custom extractor in that case. You just need to change your data structures or how Deserialize is implemented for them.

If changing your data types and the serialized format is an option, the easiest fix would probably be to move the order to a separate parameter, i.e.

// Order defined as before

#[derive(Deserialize, PartialEq, ToSchema)]
pub enum Filter {
    Rating,
    DateOfCreation,
    Alphabetical,
    Price,
}

#[derive(Deserialize, ToSchema, IntoParams)]
pub struct ItemsQuery {
    take: Option<u32>,
    page_no: Option<u32>,
    filter: Option<Filter>,
    order: Option<Order>,
    search_string: Option<String>,
}

If you want to keep the types defined as-is, you could do something like this instead of deriving Deserialize:

impl<'de> Deserialize<'de> for Filter {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let input = String::deserialize(deserializer)?;
        // Parse input into a Filter, for example using `str::split` to
        // find the `(` and `strip_suffix` to remove the final `)`.
        // In case the input is invalid, `Err(serde::de::Error::custom("..."))`
        // can be returned.
    }
}

[Gautham-kj]

Thanks, That helped a lot :)