1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

use std::collections::HashMap;

use axum::{http::StatusCode, response::IntoResponse, Json};

use primitives::sentry::ValidationErrorResponse;

#[derive(Debug, PartialEq, Eq)]
pub enum ResponseError {
    NotFound,
    BadRequest(String),
    FailedValidation(String),
    Unauthorized,
    Forbidden(String),
    Conflict(String),
    TooManyRequests(String),
}

impl IntoResponse for ResponseError {
    fn into_response(self) -> axum::response::Response {
        match self {
            ResponseError::NotFound => {
                (StatusCode::NOT_FOUND, "Not found".to_string()).into_response()
            }
            ResponseError::BadRequest(err) => {
                let error_response = [("message", err)].into_iter().collect::<HashMap<_, _>>();

                (StatusCode::BAD_REQUEST, Json(error_response)).into_response()
            }
            ResponseError::Unauthorized => {
                (StatusCode::UNAUTHORIZED, "invalid authorization").into_response()
            }
            ResponseError::FailedValidation(validator_err) => {
                let json = ValidationErrorResponse {
                    status_code: 400,
                    message: validator_err.clone(),
                    validation: vec![validator_err],
                };

                (StatusCode::BAD_REQUEST, Json(json)).into_response()
            }
            ResponseError::Forbidden(e) => (StatusCode::FORBIDDEN, e).into_response(),
            ResponseError::Conflict(e) => (StatusCode::CONFLICT, e).into_response(),
            ResponseError::TooManyRequests(e) => (StatusCode::TOO_MANY_REQUESTS, e).into_response(),
        }
    }
}

impl<T> From<T> for ResponseError
where
    T: std::error::Error + 'static,
{
    fn from(error: T) -> Self {
        ResponseError::BadRequest(error.to_string())
    }
}