The Query extractor is still missing one of those too.

Specifically I meant the one from axum but axum_extra seems to have one too that is also affected.

@taladar Check this out: #3079 although their reasoning does not apply to extractors such as Host

I see, so in case someone comes across this OptionalQuery from axum_extra looks like the correct replacement for the situation where the whole query value is optional, not just individual fields.

@taladar OptionalQuery is close to being deprecated too. I would recommend to wrap all your query fields with Option instead, since that best reflects reality of how query parameters work.

Semantically 99% of the time when I even want several query parameters stored in the same value I want to know if all of them have been specified though, not a mess of several Option values, some of them potentially None that I have to check manually again anyway.

Could you give an example? I have the exact opposite experience, I have never seen a set of query parameters that are optional as a group, rather than individually.

@dnlsndr Want to send a PR for Host?

Usually that occurs when you have related information that is useless if you only have some of it, e.g. you have a map API with x, y and z parameters or a sort by and sort direction parameter.

I'd be happy to! PR incoming.

you have a map API with x, y and z parameters

let (x, y, z) = match (x, y, z) {
  (Some(x), Some(y), Some(z)) => (x, y, z),
  _ => return Err(...),
}

I think something like this should work?

a sort by and sort direction parameter.

you can use #[serde(default = ...)] in this case without having to use Option inside the struct

That is the kind of code that I would consider "manually checking". Obviously it is not impossible but there definitely is a use-case for not having that check inside the handler.

I haven't tried it, but another alternative could be to use something like this if you always need these params to be present together:

struct QueryParams {
  #[serde(flatten)]
  xyz: Option<XYZ>
}

struct XYZ {
  x: f32,
  y: f32,
  z: f32,
}

yet another alternative: you can use query: Result<Query, QueryRejection> and then let query = query.ok(); to explicitly ignore any deserialization errors. this essentially matches the previous implementation of Option<Query>.

That last one does sound like an interesting option. In any case it would probably be useful to have something that works similar to Option mentioned in the docs somewhere.

@taladar I just stumbled across this in the source code:

This seems to be doing what you want, dunno why it's separated out into a different extractor though. It's in the axum-extrac crate under the query.rs.

Yes, that is the one I found too and that @Turbo87 said would soon be deprecated.