Form field / query parameter that either exists and is valid or does not exist, but not exists and invalid

[campbellcole]

I am trying to find a type or technique that would allow me to have a form field or query parameter that either exists AND is valid, or does not exist at all. Currently, wrapping a field/param in Option swallows all errors and makes it impossible to distinguish between actually missing and being invalid.

Is there a Rocket type that satisfies this behavior? I managed to create something with this behavior but I don't know if it handles all cases correctly:

use rocket::{
    async_trait,
    form::{error::ErrorKind, DataField, Error, FromFormField, Result, ValueField},
};

#[derive(Debug, Clone, Copy)]
pub struct Maybe<T>(Option<T>);

impl<T> Maybe<T> {
    pub fn into_inner(self) -> Option<T> {
        self.0
    }
}

fn match_inner<T>(result: Result<'_, T>) -> Result<'_, Maybe<T>> {
    match result {
        Ok(value) => Ok(Maybe(Some(value))),
        Err(errs) => match errs.as_slice() {
            &[Error {
                kind: ErrorKind::Missing,
                ..
            }] => Ok(Maybe(None)),
            _ => Err(errs),
        },
    }
}

#[async_trait]
impl<'r, T: FromFormField<'r>> FromFormField<'r> for Maybe<T> {
    fn from_value(field: ValueField<'r>) -> Result<'r, Self> {
        match_inner(T::from_value(field))
    }

    async fn from_data(field: DataField<'r, '_>) -> Result<'r, Self> {
        match_inner(T::from_data(field).await)
    }

    fn default() -> Option<Self> {
        Some(Self(None))
    }
}

My assumption is that there's some combination of Option, Strict, and Lenient that could achieve this behavior, but I don't know. Thank you

[the10thWiz]

My assumption is that there's some combination of Option, Strict, and Lenient that could achieve this behavior

After looking at the implementation of FromForm for Option and Result, I don't think this behavior is currently possible. Both simply ignore errors, and always succeed. (Also, Option always parses the inner type as strict, and Result parses it with the same strictness as it was given, but neither does anything differently based on the strictness).

It's also important to point out that they implement FromForm, not FromFormField, but this might be desirable behavior for Option - any error other than missing is considered a failure. This could also help catch potential issues earlier, since we actually catch invalid values, rather than simply ignoring errors and processing the form as if the field wasn't specified.

We would also likely need to keep track of how many fields we were passed, so that we can ensure every field inside the Option is missing, and not just some of them. We may also wish to inspect the value of error fields, and consider empty fields to be missing, even if present.