wae-https 0.0.1

WAE HTTPS - HTTP/HTTPS 服务核心模块，构建器模式、中间件、统一响应
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215

//! 模板渲染模块
//!
//! 提供基于 Askama 模板引擎的渲染支持。
//!
//! # 特性
//!
//! - 编译时模板检查，类型安全
//! - 自动 HTML 转义，防止 XSS 攻击
//! - 可配置模板目录和扩展名

use http::{Response, StatusCode, header};
use std::path::PathBuf;

use crate::{Body, full_body};

pub use askama;

/// 模板配置
#[derive(Debug, Clone)]
pub struct TemplateConfig {
    /// 模板根目录
    pub template_dir: PathBuf,
    /// 模板文件扩展名
    pub extension: String,
    /// 是否启用缓存（生产环境建议启用）
    pub enable_cache: bool,
}

impl Default for TemplateConfig {
    fn default() -> Self {
        Self { template_dir: PathBuf::from("templates"), extension: "html".to_string(), enable_cache: true }
    }
}

impl TemplateConfig {
    /// 创建新的模板配置
    pub fn new() -> Self {
        Self::default()
    }

    /// 设置模板目录
    pub fn with_template_dir(mut self, dir: impl Into<PathBuf>) -> Self {
        self.template_dir = dir.into();
        self
    }

    /// 设置模板扩展名
    pub fn with_extension(mut self, ext: impl Into<String>) -> Self {
        self.extension = ext.into();
        self
    }

    /// 设置是否启用缓存
    pub fn with_cache(mut self, enable: bool) -> Self {
        self.enable_cache = enable;
        self
    }
}

/// 模板渲染器
///
/// 提供模板渲染的核心功能。
///
/// # 示例
///
/// ```ignore
/// use wae_https::template::{TemplateConfig, TemplateRenderer};
///
/// let config = TemplateConfig::new()
///     .with_template_dir("views");
///
/// let renderer = TemplateRenderer::new(config);
/// ```
#[derive(Debug, Clone)]
pub struct TemplateRenderer {
    config: TemplateConfig,
}

impl TemplateRenderer {
    /// 创建新的模板渲染器
    pub fn new(config: TemplateConfig) -> Self {
        Self { config }
    }

    /// 使用默认配置创建模板渲染器
    pub fn default_renderer() -> Self {
        Self::new(TemplateConfig::default())
    }

    /// 获取配置引用
    pub fn config(&self) -> &TemplateConfig {
        &self.config
    }

    /// 获取模板目录路径
    pub fn template_dir(&self) -> &PathBuf {
        &self.config.template_dir
    }
}

impl Default for TemplateRenderer {
    fn default() -> Self {
        Self::default_renderer()
    }
}

/// 模板渲染错误
#[derive(Debug)]
pub enum TemplateError {
    /// 模板未找到
    NotFound(String),
    /// 渲染错误
    RenderError(String),
    /// IO 错误
    IoError(String),
}

impl std::fmt::Display for TemplateError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            TemplateError::NotFound(name) => write!(f, "Template not found: {}", name),
            TemplateError::RenderError(msg) => write!(f, "Template render error: {}", msg),
            TemplateError::IoError(msg) => write!(f, "Template IO error: {}", msg),
        }
    }
}

impl std::error::Error for TemplateError {}

/// HTML 模板响应包装器
///
/// 用于将 Askama 模板包装为 HTTP 响应。
/// 支持自动设置 Content-Type 头。
pub struct HtmlTemplate<T> {
    /// 内部模板
    inner: T,
}

impl<T> HtmlTemplate<T> {
    /// 创建新的 HTML 模板包装器
    pub fn new(template: T) -> Self {
        Self { inner: template }
    }

    /// 获取内部模板引用
    pub fn inner(&self) -> &T {
        &self.inner
    }

    /// 消费包装器，返回内部模板
    pub fn into_inner(self) -> T {
        self.inner
    }
}

impl<T> From<T> for HtmlTemplate<T> {
    fn from(template: T) -> Self {
        Self::new(template)
    }
}

impl<T> HtmlTemplate<T>
where
    T: askama::Template,
{
    /// 转换为 HTTP 响应
    pub fn into_response(self) -> Response<Body> {
        match self.inner.render() {
            Ok(html) => Response::builder()
                .status(StatusCode::OK)
                .header(header::CONTENT_TYPE, "text/html; charset=utf-8")
                .body(full_body(html))
                .unwrap(),
            Err(e) => {
                tracing::error!("Template render error: {}", e);
                Response::builder()
                    .status(StatusCode::INTERNAL_SERVER_ERROR)
                    .header(header::CONTENT_TYPE, "text/plain; charset=utf-8")
                    .body(full_body(format!("Template error: {}", e)))
                    .unwrap()
            }
        }
    }
}

/// 模板响应构建器
///
/// 提供便捷的模板响应构建方法。
pub struct TemplateResponse;

impl TemplateResponse {
    /// 返回 HTML 模板响应
    pub fn html<T: askama::Template>(template: T) -> Response<Body> {
        HtmlTemplate::new(template).into_response()
    }

    /// 返回带自定义状态码的 HTML 模板响应
    pub fn html_with_status<T: askama::Template>(template: T, status: StatusCode) -> Response<Body> {
        match template.render() {
            Ok(html) => Response::builder()
                .status(status)
                .header(header::CONTENT_TYPE, "text/html; charset=utf-8")
                .body(full_body(html))
                .unwrap(),
            Err(e) => {
                tracing::error!("Template render error: {}", e);
                Response::builder()
                    .status(StatusCode::INTERNAL_SERVER_ERROR)
                    .header(header::CONTENT_TYPE, "text/plain; charset=utf-8")
                    .body(full_body(format!("Template error: {}", e)))
                    .unwrap()
            }
        }
    }
}