Skip to main content

loco_rs/controller/extractor/
validate.rs

1use crate::validation::ValidatorTrait;
2use axum::extract::{Form, FromRequest, Json, Query, Request};
3use serde::de::DeserializeOwned;
4
5use crate::Error;
6
7/// Axum middleware for validating JSON request bodies
8///
9/// This module provides extractors for validating JSON request bodies, form
10/// data, path parameters, and query parameters using the `validator` crate.
11/// Each extractor supports both detailed validation error messages
12/// (`WithMessage` variants) and simplified error responses.
13///
14/// # Example:
15///
16/// ```
17/// use axum::{routing::post, Router};
18/// use serde::{Deserialize, Serialize};
19/// use loco_rs::controller::extractor::validate::JsonValidateWithMessage;
20/// use validator::Validate;
21///
22/// #[derive(Serialize, Deserialize, Validate)]
23/// struct User {
24///     #[validate(length(min = 3, message = "username must be at least 3 characters"))]
25///     username: String,
26///     #[validate(email(message = "email must be valid"))]
27///     email: String,
28/// }
29///
30/// async fn create_user(JsonValidateWithMessage(user): JsonValidateWithMessage<User>) -> String {
31///     format!("User created: {}, {}", user.username, user.email)
32/// }
33///
34/// fn app() -> Router {
35///     Router::new()
36///         .route("/users", post(create_user))
37/// }
38/// ```
39
40#[derive(Debug, Clone, Copy, Default)]
41pub struct JsonValidateWithMessage<T>(pub T);
42
43/// Axum middleware for validating form data
44///
45/// # Example:
46///
47/// ```
48/// use axum::{routing::post, Router};
49/// use serde::{Deserialize, Serialize};
50/// use loco_rs::controller::extractor::validate::FormValidateWithMessage;
51/// use validator::Validate;
52///
53/// #[derive(Serialize, Deserialize, Validate)]
54/// struct User {
55///     #[validate(length(min = 3, message = "username must be at least 3 characters"))]
56///     username: String,
57///     #[validate(email(message = "email must be valid"))]
58///     email: String,
59/// }
60///
61/// async fn create_user(FormValidateWithMessage(user): FormValidateWithMessage<User>) -> String {
62///     format!("User created: {}, {}", user.username, user.email)
63/// }
64///
65/// fn app() -> Router {
66///     Router::new()
67///         .route("/users", post(create_user))
68/// }
69/// ```
70
71#[derive(Debug, Clone, Copy, Default)]
72pub struct FormValidateWithMessage<T>(pub T);
73
74/// Axum middleware for validating JSON request bodies with simplified error
75/// handling
76///
77/// # Example:
78///
79/// ```
80/// use axum::{routing::post, Router};
81/// use serde::{Deserialize, Serialize};
82/// use loco_rs::controller::extractor::validate::JsonValidate;
83/// use validator::Validate;
84///
85/// #[derive(Serialize, Deserialize, Validate)]
86/// struct User {
87///     #[validate(length(min = 3, message = "username must be at least 3 characters"))]
88///     username: String,
89///     #[validate(email(message = "email must be valid"))]
90///     email: String,
91/// }
92///
93/// async fn create_user(JsonValidate(user): JsonValidate<User>) -> String {
94///     format!("User created: {}, {}", user.username, user.email)
95/// }
96///
97/// fn app() -> Router {
98///     Router::new()
99///         .route("/users", post(create_user))
100/// }
101/// ```
102
103#[derive(Debug, Clone, Copy, Default)]
104pub struct JsonValidate<T>(pub T);
105
106/// Axum middleware for validating form data with simplified error handling
107///
108/// # Example:
109///
110/// ```
111/// use axum::{routing::post, Router};
112/// use serde::{Deserialize, Serialize};
113/// use loco_rs::controller::extractor::validate::FormValidate;
114/// use validator::Validate;
115///
116/// #[derive(Serialize, Deserialize, Validate)]
117/// struct User {
118///     #[validate(length(min = 3, message = "username must be at least 3 characters"))]
119///     username: String,
120///     #[validate(email(message = "email must be valid"))]
121///     email: String,
122/// }
123///
124/// async fn create_user(FormValidate(user): FormValidate<User>) -> String {
125///     format!("User created: {}, {}", user.username, user.email)
126/// }
127///
128/// fn app() -> Router {
129///     Router::new()
130///         .route("/users", post(create_user))
131/// }
132/// ```
133
134#[derive(Debug, Clone, Copy, Default)]
135pub struct FormValidate<T>(pub T);
136
137/// Axum middleware for validating query parameters
138///
139/// # Example:
140///
141/// ```
142/// use axum::{routing::get, Router};
143/// use serde::{Deserialize, Serialize};
144/// use loco_rs::controller::extractor::validate::QueryValidateWithMessage;
145/// use validator::Validate;
146///
147/// #[derive(Serialize, Deserialize, Validate)]
148/// struct UserQuery {
149///     #[validate(length(min = 3, message = "username must be at least 3 characters"))]
150///     username: String,
151///     #[validate(email(message = "email must be valid"))]
152///     email: String,
153/// }
154///
155/// async fn get_user(QueryValidateWithMessage(params): QueryValidateWithMessage<UserQuery>) -> String {
156///     format!("User: {}, Email: {}", params.username, params.email)
157/// }
158///
159/// fn app() -> Router {
160///     Router::new()
161///         .route("/users", get(get_user))
162/// }
163/// ```
164
165#[derive(Debug, Clone, Copy, Default)]
166pub struct QueryValidateWithMessage<T>(pub T);
167
168/// Axum middleware for validating query parameters with simplified error
169/// handling
170///
171/// # Example:
172///
173/// ```
174/// use axum::{routing::get, Router};
175/// use serde::{Deserialize, Serialize};
176/// use loco_rs::controller::extractor::validate::QueryValidate;
177/// use validator::Validate;
178///
179/// #[derive(Serialize, Deserialize, Validate)]
180/// struct UserQuery {
181///     #[validate(length(min = 3, message = "username must be at least 3 characters"))]
182///     username: String,
183///     #[validate(email(message = "email must be valid"))]
184///     email: String,
185/// }
186///
187/// async fn get_user(QueryValidate(params): QueryValidate<UserQuery>) -> String {
188///     format!("User: {}, Email: {}", params.username, params.email)
189/// }
190///
191/// fn app() -> Router {
192///     Router::new()
193///         .route("/users", get(get_user))
194/// }
195/// ```
196
197#[derive(Debug, Clone, Copy, Default)]
198pub struct QueryValidate<T>(pub T);
199
200// ---------------------------------------
201//
202// Shared `FromRequest` implementation
203//
204// Each extractor above is the combination of two independent axes:
205//   * how the value is decoded from the request: JSON body / form body / query string
206//   * which error tier a failed `validate()` call reports as:
207//       - "with message": field-level detail via `Error::Validation` (`{"errors": {...}}`)
208//       - opaque: `Error::BadRequest(String::new())` (`{"error": "Bad Request"}`)
209//
210// The decoding step is factored into the `extract_*` functions below, and the two error
211// tiers are factored into the `impl_validate_with_message!` / `impl_validate_opaque!` macros,
212// so each of the 6 combinations only needs to name its decoder (and, for the opaque tier,
213// its log message).
214//
215// ---------------------------------------
216
217/// Decode a JSON request body into `T`, without validating it.
218///
219/// # Errors
220/// Returns an error when the request body cannot be decoded as JSON into `T`.
221async fn extract_json_value<T, S>(req: Request, state: &S) -> Result<T, Error>
222where
223    T: DeserializeOwned,
224    S: Send + Sync,
225{
226    let Json(value) = Json::<T>::from_request(req, state).await?;
227    Ok(value)
228}
229
230/// Decode a form-urlencoded request body into `T`, without validating it.
231///
232/// # Errors
233/// Returns an error when the request body cannot be decoded as form data into `T`.
234async fn extract_form_value<T, S>(req: Request, state: &S) -> Result<T, Error>
235where
236    T: DeserializeOwned,
237    S: Send + Sync,
238{
239    let Form(value) = Form::<T>::from_request(req, state).await?;
240    Ok(value)
241}
242
243/// Decode the query string into `T`, without validating it.
244///
245/// # Errors
246/// Returns an error when the query string cannot be decoded into `T`.
247async fn extract_query_value<T, S>(req: Request, state: &S) -> Result<T, Error>
248where
249    T: DeserializeOwned,
250    S: Send + Sync,
251{
252    let Query(value) = Query::<T>::from_request(req, state)
253        .await
254        .map_err(|rejection| Error::BadRequest(format!("Invalid query string: {rejection}")))?;
255    Ok(value)
256}
257
258/// Implement `FromRequest` for a validate extractor in the "with message" error tier: a failed
259/// `validate()` call is reported with full field-level detail (`Error::Validation`, i.e.
260/// `{"errors": {...}}`).
261macro_rules! impl_validate_with_message {
262    ($name:ident, $extract:ident) => {
263        impl<T, S> FromRequest<S> for $name<T>
264        where
265            T: DeserializeOwned + ValidatorTrait,
266            S: Send + Sync,
267        {
268            type Rejection = Error;
269
270            async fn from_request(req: Request, state: &S) -> Result<Self, Self::Rejection> {
271                let value = $extract::<T, S>(req, state).await?;
272                value.validate().map_err(Error::Validation)?;
273                Ok(Self(value))
274            }
275        }
276    };
277}
278
279/// Implement `FromRequest` for a validate extractor in the opaque error tier: a failed
280/// `validate()` call is reported without detail (`Error::BadRequest(String::new())`, i.e.
281/// `{"error": "Bad Request"}`), logging `$log_msg` at debug level for diagnosis.
282macro_rules! impl_validate_opaque {
283    ($name:ident, $extract:ident, $log_msg:literal) => {
284        impl<T, S> FromRequest<S> for $name<T>
285        where
286            T: DeserializeOwned + ValidatorTrait,
287            S: Send + Sync,
288        {
289            type Rejection = Error;
290
291            async fn from_request(req: Request, state: &S) -> Result<Self, Self::Rejection> {
292                let value = $extract::<T, S>(req, state).await?;
293                value.validate().map_err(|err| {
294                    tracing::debug!(err = ?err, $log_msg);
295                    Error::BadRequest(String::new())
296                })?;
297                Ok(Self(value))
298            }
299        }
300    };
301}
302
303impl_validate_with_message!(JsonValidateWithMessage, extract_json_value);
304impl_validate_with_message!(FormValidateWithMessage, extract_form_value);
305impl_validate_with_message!(QueryValidateWithMessage, extract_query_value);
306
307impl_validate_opaque!(
308    JsonValidate,
309    extract_json_value,
310    "request validation error occurred"
311);
312impl_validate_opaque!(
313    FormValidate,
314    extract_form_value,
315    "request validation error occurred"
316);
317impl_validate_opaque!(
318    QueryValidate,
319    extract_query_value,
320    "query validation error occurred"
321);
322
323#[cfg(test)]
324mod tests {
325    use crate::validation::{ModelValidationErrors, ValidatorTrait};
326    use axum::{
327        body::{to_bytes, Body},
328        http::{self, Request as HttpRequest, StatusCode},
329        response::IntoResponse,
330    };
331    use serde::{Deserialize, Serialize};
332    use serde_json::{json, Value};
333    use validator::Validate;
334
335    use super::*;
336
337    #[derive(Debug, Serialize, Deserialize, Validate)]
338    struct TestUser {
339        #[validate(length(min = 3, message = "username must be at least 3 characters"))]
340        username: String,
341        #[validate(email(message = "email must be valid"))]
342        email: String,
343    }
344
345    #[derive(Debug, Serialize, Deserialize, Validate)]
346    struct TestQueryParams {
347        #[validate(length(min = 3, message = "username must be at least 3 characters"))]
348        username: String,
349        #[validate(email(message = "email must be valid"))]
350        email: String,
351    }
352
353    fn create_json_request(json: &str) -> HttpRequest<Body> {
354        HttpRequest::builder()
355            .method(http::Method::POST)
356            .uri("/test")
357            .header(http::header::CONTENT_TYPE, "application/json")
358            .body(Body::from(json.to_string()))
359            .unwrap()
360    }
361
362    fn create_form_request(form_data: &str) -> HttpRequest<Body> {
363        HttpRequest::builder()
364            .method(http::Method::POST)
365            .uri("/test")
366            .header(
367                http::header::CONTENT_TYPE,
368                "application/x-www-form-urlencoded",
369            )
370            .body(Body::from(form_data.to_string()))
371            .unwrap()
372    }
373
374    fn create_query_request(query: &str) -> HttpRequest<Body> {
375        HttpRequest::builder()
376            .method(http::Method::GET)
377            .uri(format!("/test?{}", query))
378            .body(Body::empty())
379            .unwrap()
380    }
381
382    async fn assert_response_status_and_body(
383        err: Error,
384        expected_status: StatusCode,
385        expected_json: Value,
386    ) {
387        let response = err.into_response();
388        assert_eq!(response.status(), expected_status);
389
390        let body = to_bytes(response.into_body(), 1024 * 1024)
391            .await
392            .expect("Failed to read response body");
393
394        let body_str = String::from_utf8(body.to_vec()).expect("Response body is not valid UTF-8");
395
396        let actual_json =
397            serde_json::from_str::<Value>(&body_str).expect("Response body is not valid JSON");
398
399        assert_eq!(actual_json, expected_json);
400    }
401
402    #[tokio::test]
403    async fn test_json_validate_with_message_valid() {
404        let valid_json = r#"{"username": "valid_user", "email": "test@example.com"}"#;
405        let request = create_json_request(valid_json);
406
407        let result = JsonValidateWithMessage::<TestUser>::from_request(request, &()).await;
408        assert!(result.is_ok());
409
410        let user = result.unwrap().0;
411        assert_eq!(user.username, "valid_user");
412        assert_eq!(user.email, "test@example.com");
413    }
414
415    #[tokio::test]
416    async fn test_json_validate_with_message_invalid() {
417        let invalid_json = r#"{"username": "ab", "email": "invalid-email"}"#;
418        let request = create_json_request(invalid_json);
419
420        let result = JsonValidateWithMessage::<TestUser>::from_request(request, &()).await;
421        assert!(result.is_err());
422
423        let expected = json!({
424            "errors": {
425                "username": [
426                    {
427                        "code": "length",
428                        "message": "username must be at least 3 characters",
429                        "params": {
430                            "min": 3,
431                            "value": "ab"
432                        }
433                    }
434                ],
435                "email": [
436                    {
437                        "code": "email",
438                        "message": "email must be valid",
439                        "params": {
440                            "value": "invalid-email"
441                        }
442                    }
443                ]
444            }
445        });
446
447        assert_response_status_and_body(result.unwrap_err(), StatusCode::BAD_REQUEST, expected)
448            .await;
449    }
450
451    #[tokio::test]
452    async fn test_form_validate_with_message_valid() {
453        let valid_form = "username=valid_user&email=test@example.com";
454        let request = create_form_request(valid_form);
455
456        let result = FormValidateWithMessage::<TestUser>::from_request(request, &()).await;
457        assert!(result.is_ok());
458
459        let user = result.unwrap().0;
460        assert_eq!(user.username, "valid_user");
461        assert_eq!(user.email, "test@example.com");
462    }
463
464    #[tokio::test]
465    async fn test_form_validate_with_message_invalid() {
466        let invalid_form = "username=ab&email=invalid-email";
467        let request = create_form_request(invalid_form);
468
469        let result = FormValidateWithMessage::<TestUser>::from_request(request, &()).await;
470        assert!(result.is_err());
471
472        let expected = json!({
473            "errors": {
474                "username": [
475                    {
476                        "code": "length",
477                        "message": "username must be at least 3 characters",
478                        "params": {
479                            "min": 3,
480                            "value": "ab"
481                        }
482                    }
483                ],
484                "email": [
485                    {
486                        "code": "email",
487                        "message": "email must be valid",
488                        "params": {
489                            "value": "invalid-email"
490                        }
491                    }
492                ]
493            }
494        });
495
496        assert_response_status_and_body(result.unwrap_err(), StatusCode::BAD_REQUEST, expected)
497            .await;
498    }
499
500    #[tokio::test]
501    async fn test_json_validate_valid() {
502        let valid_json = r#"{"username": "valid_user", "email": "test@example.com"}"#;
503        let request = create_json_request(valid_json);
504
505        let result = JsonValidate::<TestUser>::from_request(request, &()).await;
506        assert!(result.is_ok());
507
508        let user = result.unwrap().0;
509        assert_eq!(user.username, "valid_user");
510        assert_eq!(user.email, "test@example.com");
511    }
512
513    #[tokio::test]
514    async fn test_json_validate_invalid() {
515        let invalid_json = r#"{"username": "ab", "email": "invalid-email"}"#;
516        let request = create_json_request(invalid_json);
517
518        let result = JsonValidate::<TestUser>::from_request(request, &()).await;
519        assert!(result.is_err());
520
521        let err = result.unwrap_err();
522        if let Error::BadRequest(msg) = &err {
523            assert_eq!(msg, &String::new());
524        } else {
525            panic!("Expected BadRequest error");
526        }
527
528        let expected = json!({
529            "error": "Bad Request",
530            // "description": ""
531        });
532
533        assert_response_status_and_body(err, StatusCode::BAD_REQUEST, expected).await;
534    }
535
536    #[tokio::test]
537    async fn test_form_validate_valid() {
538        let valid_form = "username=valid_user&email=test@example.com";
539        let request = create_form_request(valid_form);
540
541        let result = FormValidate::<TestUser>::from_request(request, &()).await;
542        assert!(result.is_ok());
543
544        let user = result.unwrap().0;
545        assert_eq!(user.username, "valid_user");
546        assert_eq!(user.email, "test@example.com");
547    }
548
549    #[tokio::test]
550    async fn test_form_validate_invalid() {
551        let invalid_form = "username=ab&email=invalid-email";
552        let request = create_form_request(invalid_form);
553
554        let result = FormValidate::<TestUser>::from_request(request, &()).await;
555        assert!(result.is_err());
556
557        let err = result.unwrap_err();
558        if let Error::BadRequest(msg) = &err {
559            assert_eq!(msg, &String::new());
560        } else {
561            panic!("Expected BadRequest error");
562        }
563
564        let expected = json!({
565            "error": "Bad Request",
566            // "description": ""
567        });
568
569        assert_response_status_and_body(err, StatusCode::BAD_REQUEST, expected).await;
570    }
571
572    #[tokio::test]
573    async fn test_malformed_json() {
574        let invalid_json = r#"{"username": "valid_user", "email": "test@example.com"#;
575        let request = create_json_request(invalid_json);
576
577        let result = JsonValidate::<TestUser>::from_request(request, &()).await;
578        assert!(result.is_err());
579
580        let expected = json!({
581            "error": "Bad Request",
582            // "description": "invalid type: map, expected a string at line 1 column 47"
583        });
584
585        assert_response_status_and_body(result.unwrap_err(), StatusCode::BAD_REQUEST, expected)
586            .await;
587    }
588
589    #[tokio::test]
590    async fn test_malformed_form() {
591        let invalid_form = "username=valid_user&email%invalid_format";
592        let request = create_form_request(invalid_form);
593
594        let result = FormValidate::<TestUser>::from_request(request, &()).await;
595        assert!(result.is_err());
596
597        let err = result.unwrap_err();
598        assert!(
599            matches!(err, Error::AxumFormRejection(_)),
600            "expected a form rejection, got: {err:?}"
601        );
602
603        let expected = json!({
604            "error": "Bad Request",
605            // "description": "Failed to deserialize form body: ..."
606        });
607
608        assert_response_status_and_body(err, StatusCode::UNPROCESSABLE_ENTITY, expected).await;
609    }
610
611    // Custom validator that does not rely on the `validator` crate
612    #[derive(Debug, Serialize, Deserialize)]
613    struct CustomData {
614        username: String,
615        email: String,
616    }
617
618    impl ValidatorTrait for CustomData {
619        fn validate(&self) -> Result<(), ModelValidationErrors> {
620            use crate::validation::ValidationError;
621            use std::collections::{BTreeMap, HashMap};
622            if self.username.len() < 3 {
623                let mut errors: BTreeMap<String, Vec<ValidationError>> = BTreeMap::new();
624                errors.insert(
625                    "username".to_string(),
626                    vec![ValidationError {
627                        code: "length".to_string(),
628                        message: Some("username must be at least 3 characters".to_string()),
629                        params: HashMap::new(),
630                    }],
631                );
632                return Err(ModelValidationErrors { errors });
633            }
634            if !self.email.contains('@') {
635                let mut errors: BTreeMap<String, Vec<ValidationError>> = BTreeMap::new();
636                errors.insert(
637                    "email".to_string(),
638                    vec![ValidationError {
639                        code: "email".to_string(),
640                        message: Some("email must be valid".to_string()),
641                        params: HashMap::new(),
642                    }],
643                );
644                return Err(ModelValidationErrors { errors });
645            }
646            Ok(())
647        }
648    }
649
650    #[tokio::test]
651    async fn test_json_validate_with_message_custom_validator_invalid() {
652        let invalid_json = r#"{"username": "ab", "email": "invalid"}"#;
653        let request = create_json_request(invalid_json);
654
655        let result = JsonValidateWithMessage::<CustomData>::from_request(request, &()).await;
656        assert!(result.is_err());
657
658        let expected = json!({
659            "errors": {
660                "username": [
661                    { "code": "length", "message": "username must be at least 3 characters" }
662                ]
663            }
664        });
665
666        assert_response_status_and_body(result.unwrap_err(), StatusCode::BAD_REQUEST, expected)
667            .await;
668    }
669
670    #[tokio::test]
671    async fn test_json_validate_with_message_custom_validator_valid() {
672        let valid_json = r#"{"username": "valid_user", "email": "valid@example.com"}"#;
673        let request = create_json_request(valid_json);
674
675        let result = JsonValidateWithMessage::<CustomData>::from_request(request, &()).await;
676        assert!(result.is_ok());
677    }
678
679    #[tokio::test]
680    async fn test_query_validate_with_message_valid() {
681        let valid_query = "username=valid_user&email=test@example.com";
682        let request = create_query_request(valid_query);
683
684        let result = QueryValidateWithMessage::<TestQueryParams>::from_request(request, &()).await;
685        assert!(result.is_ok());
686
687        let params = result.unwrap().0;
688        assert_eq!(params.username, "valid_user");
689        assert_eq!(params.email, "test@example.com");
690    }
691
692    #[tokio::test]
693    async fn test_query_validate_with_message_invalid() {
694        let invalid_query = "username=ab&email=invalid-email";
695        let request = create_query_request(invalid_query);
696
697        let result = QueryValidateWithMessage::<TestQueryParams>::from_request(request, &()).await;
698        assert!(result.is_err());
699
700        let expected = json!({
701            "errors": {
702                "username": [
703                    {
704                        "code": "length",
705                        "message": "username must be at least 3 characters",
706                        "params": {
707                            "min": 3,
708                            "value": "ab"
709                        }
710                    }
711                ],
712                "email": [
713                    {
714                        "code": "email",
715                        "message": "email must be valid",
716                        "params": {
717                            "value": "invalid-email"
718                        }
719                    }
720                ]
721            }
722        });
723
724        assert_response_status_and_body(result.unwrap_err(), StatusCode::BAD_REQUEST, expected)
725            .await;
726    }
727
728    #[tokio::test]
729    async fn test_query_validate_valid() {
730        let valid_query = "username=valid_user&email=test@example.com";
731        let request = create_query_request(valid_query);
732
733        let result = QueryValidate::<TestQueryParams>::from_request(request, &()).await;
734        assert!(result.is_ok());
735
736        let params = result.unwrap().0;
737        assert_eq!(params.username, "valid_user");
738        assert_eq!(params.email, "test@example.com");
739    }
740
741    #[tokio::test]
742    async fn test_query_validate_invalid() {
743        let invalid_query = "username=ab&email=invalid-email";
744        let request = create_query_request(invalid_query);
745
746        let result = QueryValidate::<TestQueryParams>::from_request(request, &()).await;
747        assert!(result.is_err());
748
749        let err = result.unwrap_err();
750        if let Error::BadRequest(msg) = &err {
751            assert_eq!(msg, &String::new());
752        } else {
753            panic!("Expected BadRequest error");
754        }
755
756        let expected = json!({
757            "error": "Bad Request",
758            // "description": ""
759        });
760
761        assert_response_status_and_body(err, StatusCode::BAD_REQUEST, expected).await;
762    }
763
764    #[tokio::test]
765    async fn test_malformed_query() {
766        let invalid_query = "username=valid_user&email=invalid_format";
767        let request = create_query_request(invalid_query);
768
769        let result = QueryValidate::<TestQueryParams>::from_request(request, &()).await;
770        assert!(result.is_err());
771
772        let expected = json!({
773            "error": "Bad Request",
774            // "description": "Invalid query string: expected `=` after key"
775        });
776
777        assert_response_status_and_body(result.unwrap_err(), StatusCode::BAD_REQUEST, expected)
778            .await;
779    }
780}