How to return validation error in optional form fields

[dorianim]

I have this scenario:

pub struct DateParam(pub NaiveDate);

#[rocket::async_trait]
impl<'r> FromFormField<'r> for DateParam {
    fn from_value(field: ValueField<'r>) -> form::Result<'r, Self> {
        let d = NaiveDate::parse_from_str(field.value, "%Y-%m-%d").map_err(|e| form::Error::custom(e))?;
        Ok(DateParam(
            d
        ))
    }
}

struct QueryForm {
    date: Option<DateParam>,
}

#[get("/?<query..>")]
async fn get_competition(query: QueryForm>) {
 // ...
}

And I'd like the following to happen:

• When no date is provided, continue with None [works]
• When some date is provided, continue with Some(date) [works]
• When an invalid date is provided, return 401 [does NOT work] -> in this case, rocket just continues with None

Is there a way to accomplish the third requirement?

[Mike-Neto]

I'm not sure if this is the best way of doing this, but my approach for this kind of issue is like so:

use rocket::http::Status;
use rocket::request::{FromRequest, Outcome, Request};
use rocket::{get, launch, routes};

#[derive(Debug)]
pub struct NaiveDate {
    year: u64,
}

#[derive(Debug)]
pub struct NaiveDateGuard {
    inner: Option<NaiveDate>,
}

#[derive(Debug)]
pub enum NaiveDateError {
    Missing,
    Invalid,
}

// In this trait we can pick and chose the outcome and reject/continue the request accordingly
// however this trait can't be implemented for Option<NaiveDate> so instead we wrap the optionality
// into it's params
#[rocket::async_trait]
impl<'r> FromRequest<'r> for NaiveDateGuard {
    type Error = NaiveDateError;

    async fn from_request(req: &'r Request<'_>) -> Outcome<Self, Self::Error> {
        let query_params = req.uri().query().map(|qp| {
            qp.split("&")
                .map(|r| r.as_str())
                .filter(|param| param.contains("date"))
                .next()
                .map(|date| {
                    date.split_terminator('=').skip(1).next().map(|segment| {
                        segment
                            .split_terminator('-')
                            .next()
                            .map(|segment| segment.parse::<u64>())
                    })
                })
        });

        match query_params {
            Some(Some(Some(Some(Ok(year))))) => Outcome::Success(NaiveDateGuard {
                inner: Some(NaiveDate { year }),
            }),
            None | Some(None) => Outcome::Success(NaiveDateGuard { inner: None }),
            _ => Outcome::Failure((Status::Unauthorized, NaiveDateError::Missing)),
        }
    }
}

#[get("/")]
async fn get_competition(date: NaiveDateGuard) -> String {
    format!("{date:?}")
}

#[launch]
fn rocket_mount() -> _ {
    rocket::build().mount("/", routes![get_competition])
}

#[cfg(test)]
mod test {
    use super::rocket_mount;
    use rocket::http::Status;
    use rocket::local::blocking::Client;

    #[test]
    fn when_no_date_is_provided_continue_with_none() {
        let client = Client::tracked(rocket_mount()).expect("valid rocket instance");
        let response = client.get("/").dispatch();
        assert_eq!(response.status(), Status::Ok);
        assert_eq!(
            response.into_string().unwrap(),
            "NaiveDateGuard { inner: None }"
        );
    }

    #[test]
    fn when_some_date_is_provided_continue_with_some_date() {
        let client = Client::tracked(rocket_mount()).expect("valid rocket instance");
        let response = client.get("/?date=2023-01-23").dispatch();
        assert_eq!(response.status(), Status::Ok);
        assert_eq!(
            response.into_string().unwrap(),
            "NaiveDateGuard { inner: Some(NaiveDate { year: 2023 }) }"
        );
    }

    #[test]
    fn when_invalid_date_is_provided_return_401() {
        let client = Client::tracked(rocket_mount()).expect("valid rocket instance");
        let response = client.get("/?date=not_a_year-01-23").dispatch();
        assert_eq!(response.status(), Status::Unauthorized);
    }
}

By using the FromRequest trait you have full control over the outcome of the request.

[MuhannadAlrusayni]

I have the same issue, any idea how to solve this ?

I use Form<Contextual<'r, T>> to have all errors goes into Contextual, if I will need to use form::Result<T>, this defeat the purpose of using Contextual in the first place.