feat(anda_engine_server): add CompressionMiddleware

Author: zensh

Cargo.toml

@@ -101,6 +101,7 @@ isolang = { version = "2.4", features = [
   "local_names",
   "list_languages",
 ] }
+tower-http = { version = "0.6", features = ["compression-gzip"] }
 
 # [patch.crates-io]
 # candid = { git = "https://github.com/ldclabs/candid.git", rev = "4cf7d02bad9530172cb4cafe733cb1e80689b793" } # remove check_recursion on stack for TEE

anda_engine_server/Cargo.toml

@@ -3,7 +3,7 @@ name = "anda_engine_server"
 description = "A http server to serve multiple Anda engines."
 repository = "https://github.com/ldclabs/anda/tree/main/anda_engine_server"
 publish = true
-version = "0.9.9"
+version = "0.9.10"
 edition.workspace = true
 keywords.workspace = true
 categories.workspace = true
@@ -26,5 +26,6 @@ tokio = { workspace = true }
 log = { workspace = true }
 ic_auth_types = { workspace = true }
 ic_auth_verifier = { workspace = true, features = ["full"] }
+tower-http = { workspace = true }
 
 [dev-dependencies]

anda_engine_server/src/lib.rs

@@ -8,11 +8,11 @@ use tokio::signal;
 use tokio_util::sync::CancellationToken;
 
 mod handler;
-mod middleware;
+pub mod middleware;
 mod types;
 
 use handler::*;
-pub use middleware::{ApiKeyMiddleware, HttpMiddleware};
+use middleware::*;
 
 const APP_NAME: &str = env!("CARGO_PKG_NAME");
 const APP_VERSION: &str = env!("CARGO_PKG_VERSION");

anda_engine_server/src/middleware.rs

@@ -6,22 +6,25 @@ use axum::{
     response::{IntoResponse, Response},
 };
 use std::{future::Future, sync::Arc};
+use tower_http::compression::CompressionLayer;
 
-use crate::handler::AppState;
+pub use crate::handler::AppState;
+
+pub type AppRouter = Router<AppState>;
 
 /// Object-safe middleware trait for applying HTTP middleware to the server `Router`.
 ///
 /// This is intentionally type-erased so callers can register arbitrary axum/tower
 /// middleware without turning `ServerBuilder` into a giant generic type.
 pub trait HttpMiddleware: Send + Sync + 'static {
-    fn apply(&self, router: Router<AppState>) -> Router<AppState>;
+    fn apply(&self, router: AppRouter) -> AppRouter;
 }
 
 impl<F> HttpMiddleware for F
 where
-    F: Fn(Router<AppState>) -> Router<AppState> + Send + Sync + 'static,
+    F: Fn(AppRouter) -> AppRouter + Send + Sync + 'static,
 {
-    fn apply(&self, router: Router<AppState>) -> Router<AppState> {
+    fn apply(&self, router: AppRouter) -> AppRouter {
         (self)(router)
     }
 }
@@ -42,11 +45,36 @@ where
     F: Fn(Request, Next) -> Fut + Clone + Send + Sync + 'static,
     Fut: Future<Output = Response> + Send + 'static,
 {
-    fn apply(&self, router: Router<AppState>) -> Router<AppState> {
+    fn apply(&self, router: AppRouter) -> AppRouter {
         router.layer(axum::middleware::from_fn(self.f.clone()))
     }
 }
 
+/// Middleware that applies response compression using `tower-http`'s `CompressionLayer`.
+pub struct CompressionMiddleware {
+    layer: CompressionLayer,
+}
+
+impl CompressionMiddleware {
+    pub fn new(layer: CompressionLayer) -> Self {
+        Self { layer }
+    }
+}
+
+impl Default for CompressionMiddleware {
+    fn default() -> Self {
+        Self {
+            layer: CompressionLayer::new(),
+        }
+    }
+}
+
+impl HttpMiddleware for CompressionMiddleware {
+    fn apply(&self, router: AppRouter) -> AppRouter {
+        router.layer(self.layer.clone())
+    }
+}
+
 /// A simple API key middleware that validates `x-api-key` on every request.
 ///
 /// Use `exempt_path` to allow unauthenticated endpoints (e.g. health/info routes).
@@ -72,7 +100,7 @@ impl ApiKeyMiddleware {
 }
 
 impl HttpMiddleware for ApiKeyMiddleware {
-    fn apply(&self, router: Router<AppState>) -> Router<AppState> {
+    fn apply(&self, router: AppRouter) -> AppRouter {
         let expected_key = self.expected_key.clone();
         let exempt_paths = self.exempt_paths.clone();