main
use actix_web::body::BoxBody;
use actix_web::http::StatusCode;
use actix_web::{HttpRequest, HttpResponse, Responder};
use serde::ser::SerializeStruct;
use serde::{Deserialize, Serialize, Serializer};
use utoipa::ToSchema;
use crate::context;
pub const OK_CODE: i32 = 200;
pub const OK_MESSAGE: &str = "success";
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Deserialize, Serialize, ToSchema)]
pub struct NoData;
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, ToSchema)]
pub struct Envelope<T> {
pub code: i32,
pub message: String,
pub data: Option<T>,
pub error: Option<String>,
pub error_code: Option<String>,
#[serde(default)]
pub request_id: String,
#[serde(skip)]
#[schema(ignore)]
retry_after_secs: Option<u64>,
}
impl<T: Serialize> Serialize for Envelope<T> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let request_id = resolve(&self.request_id, context::request_id().as_deref());
let mut state = serializer.serialize_struct("Envelope", 6)?;
state.serialize_field("code", &self.code)?;
state.serialize_field("message", &self.message)?;
state.serialize_field("data", &self.data)?;
state.serialize_field("error", &self.error)?;
state.serialize_field("error_code", &self.error_code)?;
state.serialize_field("request_id", &request_id)?;
state.end()
}
}
fn resolve(explicit: &str, injected: Option<&str>) -> String {
if explicit.is_empty() {
injected.unwrap_or_default().to_owned()
} else {
explicit.to_owned()
}
}
impl<T: Serialize> Envelope<T> {
pub fn ok(data: T) -> Self {
Self {
code: OK_CODE,
message: OK_MESSAGE.to_owned(),
data: Some(data),
error: None,
error_code: None,
request_id: String::new(),
retry_after_secs: None,
}
}
pub fn err(code: i32, message: impl Into<String>) -> Self {
Self {
code,
message: message.into(),
data: None,
error: None,
error_code: None,
request_id: String::new(),
retry_after_secs: None,
}
}
pub fn with_error(mut self, error: impl Into<String>) -> Self {
self.error = Some(error.into());
self
}
pub fn with_error_code(mut self, error_code: impl Into<String>) -> Self {
self.error_code = Some(error_code.into());
self
}
pub fn with_request_id(mut self, request_id: impl Into<String>) -> Self {
self.request_id = request_id.into();
self
}
pub fn with_retry_after(mut self, seconds: u64) -> Self {
self.retry_after_secs = Some(seconds);
self
}
pub fn status(&self) -> StatusCode {
status_of(self.code)
}
pub fn into_body(&self) -> BoxBody {
body_of(self)
}
}
impl Envelope<NoData> {
pub fn empty() -> Self {
Self {
code: OK_CODE,
message: OK_MESSAGE.to_owned(),
data: None,
error: None,
error_code: None,
request_id: String::new(),
retry_after_secs: None,
}
}
}
pub fn status_of(code: i32) -> StatusCode {
u16::try_from(code)
.ok()
.and_then(|code| StatusCode::from_u16(code).ok())
.unwrap_or(StatusCode::INTERNAL_SERVER_ERROR)
}
fn body_of<T: Serialize>(envelope: &Envelope<T>) -> BoxBody {
let bytes = serde_json::to_vec(envelope).unwrap_or_else(|error| {
tracing::error!(%error, "failed to serialize the response envelope");
Vec::from(SERIALIZE_FALLBACK)
});
BoxBody::new(bytes)
}
const SERIALIZE_FALLBACK: &[u8] =
br#"{"code":500,"message":"internal server error","data":null,"error":null,"error_code":null,"request_id":""}"#;
impl<T: Serialize> Envelope<T> {
pub fn into_http_response(self) -> HttpResponse<BoxBody> {
let status = status_of(self.code);
let mut response = HttpResponse::build(status);
if let Some(seconds) = self.retry_after_secs {
response.insert_header((actix_web::http::header::RETRY_AFTER, seconds.to_string()));
}
response
.content_type("application/json")
.body(body_of(&self))
}
}
impl std::fmt::Display for Envelope<()> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "API error: code={}, message={}", self.code, self.message)
}
}
impl<T: Serialize> Responder for Envelope<T> {
type Body = BoxBody;
fn respond_to(self, _request: &HttpRequest) -> HttpResponse<Self::Body> {
self.into_http_response()
}
}