110 lines
3.3 KiB
Rust
110 lines
3.3 KiB
Rust
use crate::context::RequestContext;
|
|
use axum::http::StatusCode;
|
|
use axum::http::{HeaderName, HeaderValue};
|
|
use axum::response::{IntoResponse, Response};
|
|
use axum::Json;
|
|
use serde::Serialize;
|
|
|
|
#[derive(Debug, Clone, Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct ErrorBody {
|
|
pub ok: bool,
|
|
pub code: &'static str,
|
|
pub message: String,
|
|
pub request_id: Option<String>,
|
|
pub trace_id: Option<String>,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct WebError {
|
|
status: StatusCode,
|
|
code: &'static str,
|
|
message: String,
|
|
request_context: Option<RequestContext>,
|
|
headers: Vec<(&'static str, String)>,
|
|
}
|
|
|
|
impl WebError {
|
|
pub fn new(status: StatusCode, code: &'static str, message: impl Into<String>) -> Self {
|
|
Self {
|
|
status,
|
|
code,
|
|
message: message.into(),
|
|
request_context: None,
|
|
headers: Vec::new(),
|
|
}
|
|
}
|
|
|
|
pub fn bad_request(message: impl Into<String>) -> Self {
|
|
Self::new(StatusCode::BAD_REQUEST, "bad_request", message)
|
|
}
|
|
|
|
pub fn bad_request_code(code: &'static str, message: impl Into<String>) -> Self {
|
|
Self::new(StatusCode::BAD_REQUEST, code, message)
|
|
}
|
|
|
|
pub fn internal(message: impl Into<String>) -> Self {
|
|
Self::new(StatusCode::INTERNAL_SERVER_ERROR, "internal_error", message)
|
|
}
|
|
|
|
pub fn bad_gateway_code(code: &'static str, message: impl Into<String>) -> Self {
|
|
Self::new(StatusCode::BAD_GATEWAY, code, message)
|
|
}
|
|
|
|
pub fn service_unavailable_code(code: &'static str, message: impl Into<String>) -> Self {
|
|
Self::new(StatusCode::SERVICE_UNAVAILABLE, code, message)
|
|
}
|
|
|
|
pub fn gateway_timeout_code(code: &'static str, message: impl Into<String>) -> Self {
|
|
Self::new(StatusCode::GATEWAY_TIMEOUT, code, message)
|
|
}
|
|
|
|
pub fn with_context(mut self, request_context: &RequestContext) -> Self {
|
|
self.request_context = Some(request_context.clone());
|
|
self
|
|
}
|
|
|
|
pub fn with_header(mut self, name: &'static str, value: impl Into<String>) -> Self {
|
|
self.headers.push((name, value.into()));
|
|
self
|
|
}
|
|
|
|
pub fn message(&self) -> &str {
|
|
&self.message
|
|
}
|
|
}
|
|
|
|
impl IntoResponse for WebError {
|
|
fn into_response(self) -> Response {
|
|
let body = ErrorBody {
|
|
ok: false,
|
|
code: self.code,
|
|
message: self.message,
|
|
request_id: self
|
|
.request_context
|
|
.as_ref()
|
|
.map(|context| context.trace.request_id.clone()),
|
|
trace_id: self
|
|
.request_context
|
|
.as_ref()
|
|
.map(|context| context.trace.trace_id.clone()),
|
|
};
|
|
let mut response = (self.status, Json(body)).into_response();
|
|
if let Ok(name) = HeaderName::from_lowercase(b"x-error-code") {
|
|
if let Ok(value) = HeaderValue::from_str(self.code) {
|
|
response.headers_mut().insert(name, value);
|
|
}
|
|
}
|
|
for (name, value) in self.headers {
|
|
let Ok(header_name) = HeaderName::from_lowercase(name.as_bytes()) else {
|
|
continue;
|
|
};
|
|
let Ok(header_value) = HeaderValue::from_str(&value) else {
|
|
continue;
|
|
};
|
|
response.headers_mut().insert(header_name, header_value);
|
|
}
|
|
response
|
|
}
|
|
}
|