vantus 0.3.0

Macro-first async Rust backend framework with explicit composition, typed extraction, and hardened HTTP defaults.
Documentation 
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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use thiserror::Error;

use crate::config::ConfigError;
use crate::core::http::Response;
use crate::di::ExtractorError;

#[derive(Debug, Error)]
pub enum FrameworkError {
    #[error(transparent)]
    Http(#[from] HttpError),
    #[error("{context}: {source}")]
    Config {
        context: &'static str,
        #[source]
        source: ConfigError,
    },
    #[error(transparent)]
    Extractor(#[from] ExtractorError),
    #[error(
        "duplicate route registration for {method} {new_path} (conflicts with {existing_path})"
    )]
    RouteConflict {
        method: String,
        existing_path: String,
        new_path: String,
    },
    #[error("{context}")]
    Startup { context: String },
    #[error("{message}")]
    Internal { message: String },
}

impl FrameworkError {
    pub fn to_response(&self) -> Response {
        match self {
            FrameworkError::Http(error) => error.to_response(),
            FrameworkError::Extractor(source) => {
                HttpError::bad_request(source.to_string()).to_response()
            }
            FrameworkError::Config { .. }
            | FrameworkError::RouteConflict { .. }
            | FrameworkError::Startup { .. }
            | FrameworkError::Internal { .. } => Response::internal_server_error(),
        }
    }

    pub fn internal(message: impl Into<String>) -> Self {
        Self::Internal {
            message: message.into(),
        }
    }

    pub fn startup(context: impl Into<String>) -> Self {
        Self::Startup {
            context: context.into(),
        }
    }

    pub fn config_context(context: &'static str, source: ConfigError) -> Self {
        Self::Config { context, source }
    }

    pub fn route_conflict(
        method: impl Into<String>,
        existing_path: impl Into<String>,
        new_path: impl Into<String>,
    ) -> Self {
        Self::RouteConflict {
            method: method.into(),
            existing_path: existing_path.into(),
            new_path: new_path.into(),
        }
    }
}

#[derive(Debug, Clone, Error)]
#[error("{status_code} {status_text}")]
pub struct HttpError {
    pub status_code: u16,
    pub status_text: String,
    pub message: String,
}

impl HttpError {
    pub fn new(
        status_code: u16,
        status_text: impl Into<String>,
        message: impl Into<String>,
    ) -> Self {
        Self {
            status_code,
            status_text: status_text.into(),
            message: message.into(),
        }
    }

    pub fn bad_request(message: impl Into<String>) -> Self {
        Self::new(400, "Bad Request", message)
    }

    pub fn not_found(message: impl Into<String>) -> Self {
        Self::new(404, "Not Found", message)
    }

    pub fn method_not_allowed(message: impl Into<String>) -> Self {
        Self::new(405, "Method Not Allowed", message)
    }

    pub fn payload_too_large(message: impl Into<String>) -> Self {
        Self::new(413, "Payload Too Large", message)
    }

    pub fn unsupported_media_type(message: impl Into<String>) -> Self {
        Self::new(415, "Unsupported Media Type", message)
    }

    pub fn too_many_requests(message: impl Into<String>) -> Self {
        Self::new(429, "Too Many Requests", message)
    }

    pub fn internal_server_error(message: impl Into<String>) -> Self {
        Self::new(500, "Internal Server Error", message)
    }

    pub fn to_response(&self) -> Response {
        Response::from_error(self.status_code, &self.status_text, self.message.clone())
    }
}