Skip to main content

vertigo_cli/serve/
vertigo_handler.rs

1use actix_web::{
2    HttpRequest,
3    http::{StatusCode, header},
4    web,
5};
6use std::time::Instant;
7
8use crate::serve::{
9    MountConfig, RequestHeaders, html::SSR_FETCH_HEADER, response_state::ResponseState,
10};
11
12use super::server_state::ServerState;
13
14/// Directly attach SSR mechanism to the actix web server (no static files mounting)
15///
16/// To root path:
17///
18/// ```no_run
19/// # use actix_web::web;
20/// # use vertigo_cli::serve::{MountConfigBuilder, vertigo_handler};
21/// # let mount_config = MountConfigBuilder::new("/", "/").build().unwrap();
22/// # let app = web::scope("/");
23/// app.default_service(vertigo_handler(&mount_config));
24/// ```
25///
26/// To custom mount point:
27///
28/// ```no_run
29/// # use actix_web::web;
30/// # use vertigo_cli::serve::{MountConfigBuilder, vertigo_handler};
31/// # let mount_config = MountConfigBuilder::new("/", "/").build().unwrap();
32/// # let app = web::scope("/");
33/// app.service(
34///     web::scope(mount_config.mount_point())
35///         .default_service(vertigo_handler(&mount_config)),
36/// );
37/// ```
38pub fn vertigo_handler(mount_config: &MountConfig) -> actix_web::Route {
39    let mount_point = mount_config.mount_point().to_string();
40
41    web::route().to(move |req: HttpRequest| {
42        let mount_point = mount_point.clone();
43        async move {
44            if is_ssr_fetch(&req) {
45                log::error!(
46                    "SSR fetched {}, which only the SSR handler serves",
47                    req.uri()
48                );
49                return actix_web::HttpResponse::NotFound().finish();
50            }
51
52            let state = ServerState::global(&mount_point);
53            let now = Instant::now();
54            let url = req.uri();
55
56            let uri = {
57                let path = url.path();
58                // Strip mount point to get local url
59                let local_url = if state.mount_config.mount_point() != "/" {
60                    path.trim_start_matches(state.mount_config.mount_point())
61                } else {
62                    path
63                };
64
65                match url.query() {
66                    Some(query) => format!("{local_url}?{query}"),
67                    None => local_url.to_string(),
68                }
69            };
70
71            log::debug!("Incoming request: {uri}");
72            let cookie = request_cookie(&req);
73            let accept_language = request_accept_language(&req);
74            let headers = RequestHeaders {
75                cookie: cookie.as_deref(),
76                accept_language: accept_language.as_deref(),
77            };
78            let mut response_state = state.request_with_headers(&uri, headers).await;
79
80            let time = now.elapsed().as_millis();
81            let log_level = if time > 1000 {
82                log::Level::Warn
83            } else {
84                log::Level::Info
85            };
86            log::log!(
87                log_level,
88                "Response for request: {} {time}ms {uri}",
89                response_state.status,
90            );
91
92            if let Some(port_watch) = state.port_watch
93                && response_state.headers.get("content-type")
94                    == Some(&ResponseState::HTML.to_string())
95            {
96                response_state.add_watch_script(port_watch);
97            }
98
99            // Checking for error status to log
100            if StatusCode::from_u16(response_state.status)
101                .unwrap_or(StatusCode::INTERNAL_SERVER_ERROR)
102                .is_server_error()
103            {
104                log::error!("WASM status: {}", response_state.status);
105
106                match String::from_utf8(response_state.body.clone()) {
107                    Ok(messagee) => {
108                        log::error!("WASM response: text={}", messagee);
109                    }
110                    Err(_) => {
111                        log::error!("WASM response: bytes={:#?}", response_state.body);
112                    }
113                }
114            }
115
116            actix_web::HttpResponse::from(response_state)
117        }
118    })
119}
120
121/// Whether the request is a fetch the app made while the server rendered a page, sent back to the
122/// server's own origin ([`MountConfigBuilder::ssr_fetch_base`]).
123///
124/// A handler of your own that renders pages with [`ServerState`] should refuse such a request, as
125/// [`vertigo_handler`] does: rendering a page for it could fetch the same URL again, endlessly.
126/// It comes when the app fetches a URL that only the page handler answers.
127///
128/// ```
129/// use actix_web::{HttpRequest, HttpResponse};
130/// use vertigo_cli::serve::{RequestHeaders, ServerState, is_ssr_fetch, request_cookie};
131///
132/// async fn page(req: HttpRequest) -> HttpResponse {
133///     if is_ssr_fetch(&req) {
134///         return HttpResponse::NotFound().finish();
135///     }
136///     let cookie = request_cookie(&req);
137///     let headers = RequestHeaders {
138///         cookie: cookie.as_deref(),
139///         ..RequestHeaders::default()
140///     };
141///     ServerState::global("/")
142///         .request_with_headers(&req.uri().to_string(), headers)
143///         .await
144///         .into()
145/// }
146/// ```
147///
148/// [`MountConfigBuilder::ssr_fetch_base`]: super::MountConfigBuilder::ssr_fetch_base
149pub fn is_ssr_fetch(req: &HttpRequest) -> bool {
150    req.headers().contains_key(SSR_FETCH_HEADER)
151}
152
153/// `Cookie` header of the request, for [`ServerState::request_with_cookie`].
154///
155/// HTTP/2 may send the cookies as several header fields; they are joined with `; `
156/// (RFC 9113, section 8.2.3).
157pub fn request_cookie(req: &HttpRequest) -> Option<String> {
158    let parts: Vec<&str> = req
159        .headers()
160        .get_all(header::COOKIE)
161        .filter_map(|value| value.to_str().ok())
162        .collect();
163
164    (!parts.is_empty()).then(|| parts.join("; "))
165}
166
167/// `Accept-Language` header of the request, for [`ServerState::request_with_headers`].
168///
169/// Several header fields make one list, joined with `, ` (RFC 9110, section 5.3).
170pub fn request_accept_language(req: &HttpRequest) -> Option<String> {
171    let parts: Vec<&str> = req
172        .headers()
173        .get_all(header::ACCEPT_LANGUAGE)
174        .filter_map(|value| value.to_str().ok())
175        .collect();
176
177    (!parts.is_empty()).then(|| parts.join(", "))
178}
179
180#[cfg(test)]
181mod tests {
182    use actix_web::{http::header, test::TestRequest};
183
184    use super::{is_ssr_fetch, request_accept_language, request_cookie};
185    use crate::serve::html::SSR_FETCH_HEADER;
186
187    #[test]
188    fn ssr_fetch_is_told_by_its_header() {
189        let ssr_fetch = TestRequest::get()
190            .append_header((SSR_FETCH_HEADER, "1"))
191            .to_http_request();
192
193        assert!(is_ssr_fetch(&ssr_fetch));
194        assert!(!is_ssr_fetch(&TestRequest::get().to_http_request()));
195    }
196
197    #[test]
198    fn no_cookie_header() {
199        assert_eq!(request_cookie(&TestRequest::get().to_http_request()), None);
200    }
201
202    #[test]
203    fn split_cookie_headers_are_joined() {
204        let req = TestRequest::get()
205            .append_header((header::COOKIE, "session=abc"))
206            .append_header((header::COOKIE, "theme=dark"))
207            .to_http_request();
208
209        assert_eq!(
210            request_cookie(&req).as_deref(),
211            Some("session=abc; theme=dark")
212        );
213    }
214
215    #[test]
216    fn split_accept_language_headers_are_one_list() {
217        let req = TestRequest::get()
218            .append_header((header::ACCEPT_LANGUAGE, "pl-PL,pl;q=0.9"))
219            .append_header((header::ACCEPT_LANGUAGE, "en;q=0.5"))
220            .to_http_request();
221
222        assert_eq!(
223            request_accept_language(&req).as_deref(),
224            Some("pl-PL,pl;q=0.9, en;q=0.5")
225        );
226        assert_eq!(
227            request_accept_language(&TestRequest::get().to_http_request()),
228            None
229        );
230    }
231}