Skip to main content

yaiko_core/
compression.rs

1use crate::{Handler, Middleware, Request, Response};
2use async_compression::tokio::write::{BrotliEncoder, GzipEncoder};
3use async_trait::async_trait;
4use std::sync::Arc;
5use tokio::io::AsyncWriteExt;
6
7pub struct CompressionMiddleware {
8    min_size: usize,
9}
10
11impl Default for CompressionMiddleware {
12    fn default() -> Self {
13        Self::new()
14    }
15}
16
17impl CompressionMiddleware {
18    pub fn new() -> Self {
19        CompressionMiddleware {
20            min_size: 1024, // Only compress responses larger than 1KB
21        }
22    }
23
24    pub fn min_size(mut self, size: usize) -> Self {
25        self.min_size = size;
26        self
27    }
28
29    async fn compress_response(
30        &self,
31        response: Response,
32        encoding: &str,
33    ) -> Result<Response, Box<dyn std::error::Error + Send + Sync>> {
34        let body_bytes = hyper::body::to_bytes(response.body).await?;
35
36        if body_bytes.len() < self.min_size {
37            return Ok(Response {
38                status: response.status,
39                headers: response.headers,
40                body: hyper::Body::from(body_bytes),
41            });
42        }
43
44        let compressed = match encoding {
45            "gzip" => {
46                let mut encoder = GzipEncoder::new(Vec::new());
47                encoder.write_all(&body_bytes).await?;
48                encoder.shutdown().await?;
49                encoder.into_inner()
50            }
51            "br" => {
52                let mut encoder = BrotliEncoder::new(Vec::new());
53                encoder.write_all(&body_bytes).await?;
54                encoder.shutdown().await?;
55                encoder.into_inner()
56            }
57            _ => {
58                return Ok(Response {
59                    status: response.status,
60                    headers: response.headers,
61                    body: hyper::Body::from(body_bytes),
62                })
63            }
64        };
65
66        let mut headers = response.headers;
67        headers.insert("Content-Encoding".to_string(), encoding.to_string());
68        headers.insert("Content-Length".to_string(), compressed.len().to_string());
69
70        Ok(Response {
71            status: response.status,
72            headers,
73            body: hyper::Body::from(compressed),
74        })
75    }
76}
77
78#[async_trait]
79impl Middleware for CompressionMiddleware {
80    async fn handle(
81        &self,
82        req: Request,
83        next: Arc<dyn Handler>,
84    ) -> Result<Response, Box<dyn std::error::Error + Send + Sync>> {
85        let accept_encoding = req
86            .headers
87            .get("accept-encoding")
88            .and_then(|v| v.to_str().ok())
89            .unwrap_or("")
90            .to_string();
91
92        let response = next.handle(req).await?;
93
94        // Choose compression method based on client support
95        if accept_encoding.contains("br") {
96            self.compress_response(response, "br").await
97        } else if accept_encoding.contains("gzip") {
98            self.compress_response(response, "gzip").await
99        } else {
100            Ok(response)
101        }
102    }
103}