haven 0.1.4

Actix + React + Vite integration for server-rendered applications
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

use std::fmt::{Display, Formatter};

use actix_web::HttpResponse;
use http::{HeaderMap, StatusCode};
use serde_json::json;
use thiserror::Error;

use crate::http_protocol::wants_page_protocol;

#[derive(Debug, Error)]
pub enum RendererError {
    #[error("runtime init failed: {0}")]
    RuntimeInit(String),
    #[error("render failed: {0}")]
    RenderFailed(String),
    #[error("render failed: {message}")]
    RenderFailedHtml { message: String, html: String },
    #[error("renderer worker channel closed")]
    ChannelClosed,
    #[error("serialization failed: {0}")]
    Serialization(String),
    #[error("javascript exception: {0}")]
    JavaScriptException(String),
    #[error("reload failed: {0}")]
    ReloadFailed(String),
    #[error("io failed: {0}")]
    Io(String),
    #[error("bundle build failed: {0}")]
    BundleBuildFailed(String),
    #[error("prerender failed: {0}")]
    PrerenderFailed(String),
}

impl RendererError {
    pub fn status_code(&self) -> StatusCode {
        StatusCode::INTERNAL_SERVER_ERROR
    }

    pub fn into_response_for_visit(self, is_page_protocol: bool) -> HttpResponse {
        if let Self::RenderFailedHtml { html, .. } = &self {
            if !is_page_protocol {
                return HttpResponse::build(
                    actix_web::http::StatusCode::from_u16(self.status_code().as_u16())
                        .unwrap_or(actix_web::http::StatusCode::INTERNAL_SERVER_ERROR),
                )
                .content_type("text/html; charset=utf-8")
                .body(html.clone());
            }
        }

        HttpResponse::build(
            actix_web::http::StatusCode::from_u16(self.status_code().as_u16())
                .unwrap_or(actix_web::http::StatusCode::INTERNAL_SERVER_ERROR),
        )
        .json(json!({
            "error": self.to_string(),
        }))
    }

    pub fn into_response_for_headers(self, headers: Option<&HeaderMap>) -> HttpResponse {
        self.into_response_for_visit(headers.is_some_and(wants_page_protocol))
    }
}

impl RendererError {
    pub fn into_actix_response_for_visit(self, is_page_protocol: bool) -> HttpResponse {
        self.into_response_for_visit(is_page_protocol)
    }

    pub fn into_actix_response_for_headers(self, headers: Option<&HeaderMap>) -> HttpResponse {
        self.into_response_for_headers(headers)
    }
}

impl From<std::io::Error> for RendererError {
    fn from(value: std::io::Error) -> Self {
        Self::Io(value.to_string())
    }
}

impl From<serde_json::Error> for RendererError {
    fn from(value: serde_json::Error) -> Self {
        Self::Serialization(value.to_string())
    }
}

impl Display for crate::renderer::RendererMode {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            crate::renderer::RendererMode::Development => f.write_str("development"),
            crate::renderer::RendererMode::Production => f.write_str("production"),
        }
    }
}