Skip to main content

baijimu_cmodel_actix/
lib.rs

1mod extractors;
2mod request_context;
3
4pub use extractors::{configure_cmodel_extractors, json_config, path_config, query_config};
5pub use request_context::cmodel_request_context;
6
7use actix_web::{HttpRequest, HttpResponse, Responder, body::BoxBody, http::StatusCode};
8use baijimu_cmodel_core::{
9    CModelError, CModelFailureData, CModelResponse, ContractViolation, ErrorCode,
10};
11use baijimu_cmodel_http::{PreservedErrorResponse, validate_http_status};
12use serde::Serialize;
13
14#[derive(Debug)]
15pub struct ActixCModelResponse<T> {
16    status: StatusCode,
17    body: CModelResponse<T>,
18}
19
20impl<T> ActixCModelResponse<T> {
21    pub fn try_new(status: StatusCode, body: CModelResponse<T>) -> Result<Self, ContractViolation> {
22        let _requested_status = status;
23        validate_http_status(baijimu_cmodel_http::StatusCode::OK, &body)?;
24        Ok(Self {
25            status: StatusCode::OK,
26            body,
27        })
28    }
29
30    pub fn success(status: StatusCode, data: Option<T>) -> Result<Self, ContractViolation> {
31        Self::try_new(status, CModelResponse::success(data)?)
32    }
33
34    pub fn failure(
35        status: StatusCode,
36        error: impl Into<ErrorCode>,
37    ) -> Result<Self, ContractViolation> {
38        Self::try_new(status, CModelResponse::failure(error)?)
39    }
40
41    pub fn failure_with_data(
42        status: StatusCode,
43        error: impl Into<ErrorCode>,
44        data: CModelFailureData,
45    ) -> Result<Self, ContractViolation> {
46        Self::try_new(status, CModelResponse::failure_with_data(error, data)?)
47    }
48
49    pub fn failure_from_error(
50        status: StatusCode,
51        error: CModelError,
52    ) -> Result<Self, ContractViolation> {
53        Self::try_new(status, CModelResponse::failure_from_error(error)?)
54    }
55
56    pub fn status(&self) -> StatusCode {
57        self.status
58    }
59
60    pub fn body(&self) -> &CModelResponse<T> {
61        &self.body
62    }
63}
64
65impl<T: Serialize> ActixCModelResponse<T> {
66    /// Build a response for Actix `ResponseError` implementations.
67    pub fn into_http_response(self) -> HttpResponse {
68        let mut body = self.body;
69        if let Some(identity) = baijimu_cmodel_http::current_service_identity() {
70            body.prepend_error_path(identity);
71        }
72        HttpResponse::build(self.status).json(body)
73    }
74}
75
76impl<T> Responder for ActixCModelResponse<T>
77where
78    T: Serialize,
79{
80    type Body = BoxBody;
81
82    fn respond_to(self, _request: &HttpRequest) -> HttpResponse<Self::Body> {
83        self.into_http_response()
84    }
85}
86
87#[derive(Debug)]
88pub struct ActixPreservedError(PreservedErrorResponse);
89
90impl From<PreservedErrorResponse> for ActixPreservedError {
91    fn from(error: PreservedErrorResponse) -> Self {
92        Self(error)
93    }
94}
95
96impl ActixPreservedError {
97    pub fn into_http_response(self) -> HttpResponse {
98        let (status, body) = self.0.into_service_response_parts();
99        HttpResponse::build(
100            StatusCode::from_u16(status.as_u16()).expect("CModel HTTP status must be valid"),
101        )
102        .content_type(baijimu_cmodel_http::CMODEL_CONTENT_TYPE)
103        .body(body)
104    }
105}
106
107impl Responder for ActixPreservedError {
108    type Body = BoxBody;
109
110    fn respond_to(self, _request: &HttpRequest) -> HttpResponse<Self::Body> {
111        self.into_http_response()
112    }
113}
114
115#[cfg(test)]
116mod tests {
117    use super::*;
118    use baijimu_cmodel_core::ErrorCode;
119
120    #[test]
121    fn normalizes_business_failure_to_http_200() {
122        let result = ActixCModelResponse::<()>::failure(
123            StatusCode::NOT_FOUND,
124            ErrorCode::parse("BAIJIMU_INVALID_REQUEST").unwrap(),
125        )
126        .unwrap();
127
128        assert_eq!(result.status(), StatusCode::OK);
129    }
130}