baijimu_cmodel_actix/
lib.rs1mod 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 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}