1use crate::validation::ValidatorTrait;
2use axum::extract::{Form, FromRequest, Json, Query, Request};
3use serde::de::DeserializeOwned;
4
5use crate::Error;
6
7#[derive(Debug, Clone, Copy, Default)]
41pub struct JsonValidateWithMessage<T>(pub T);
42
43#[derive(Debug, Clone, Copy, Default)]
72pub struct FormValidateWithMessage<T>(pub T);
73
74#[derive(Debug, Clone, Copy, Default)]
104pub struct JsonValidate<T>(pub T);
105
106#[derive(Debug, Clone, Copy, Default)]
135pub struct FormValidate<T>(pub T);
136
137#[derive(Debug, Clone, Copy, Default)]
166pub struct QueryValidateWithMessage<T>(pub T);
167
168#[derive(Debug, Clone, Copy, Default)]
198pub struct QueryValidate<T>(pub T);
199
200async 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
230async 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
243async 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
258macro_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
279macro_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 });
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 });
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 });
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 });
607
608 assert_response_status_and_body(err, StatusCode::UNPROCESSABLE_ENTITY, expected).await;
609 }
610
611 #[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 });
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 });
776
777 assert_response_status_and_body(result.unwrap_err(), StatusCode::BAD_REQUEST, expected)
778 .await;
779 }
780}