feat(backend): add Redis caching for improved performance

Cargo.toml

@@ -26,6 +26,7 @@ thiserror          = "1"
 dotenvy            = "0.15"
 tower              = "0.4"
 tower-http         = { version = "0.5", features = ["cors", "trace"] }
+futures            = "0.3"
 
 [profile.release]
 opt-level         = "z"

backend/.env.example

@@ -1,5 +1,6 @@
 APP_ENV=development
 DATABASE_URL=postgres://lance:lance@localhost:5432/lance
+REDIS_URL=redis://localhost:6379
 OPENCLAW_API_KEY=TODO_fill_in
 OPENCLAW_BASE_URL=https://api.openclaw.ai/v1
 STELLAR_RPC_URL=https://soroban-testnet.stellar.org

backend/Cargo.toml

@@ -31,6 +31,8 @@ bytes        = { workspace = true }
 base64       = "0.22"
 sha2         = "0.10"
 ed25519-dalek = { version = "2", features = ["rand_core"] }
+fred = { version = "9", features = ["enable-rustls", "i-all"] }
+futures      = { workspace = true }
 hex          = "0.4"
 governor     = { version = "0.6", features = ["std"] }
 futures-util = "0.3"

backend/src/db.rs

@@ -1,3 +1,4 @@
+use crate::services::cache::CacheService;
 use crate::services::judge::JudgeService;
 use crate::services::stellar::StellarService;
 use sqlx::PgPool;
@@ -7,14 +8,30 @@ pub struct AppState {
     pub pool: PgPool,
     pub judge: std::sync::Arc<JudgeService>,
     pub stellar: std::sync::Arc<StellarService>,
+    pub cache: Option<CacheService>,
 }
 
 impl AppState {
-    pub fn new(pool: PgPool) -> Self {
+    pub async fn new(pool: PgPool) -> Self {
+        let cache = match CacheService::from_env().await {
+            Ok(c) => {
+                tracing::info!("Redis cache initialized successfully");
+                Some(c)
+            }
+            Err(e) => {
+                tracing::warn!(
+                    "Failed to initialize Redis cache: {}. Running without cache.",
+                    e
+                );
+                None
+            }
+        };
+
         Self {
             pool,
             judge: std::sync::Arc::new(JudgeService::from_env()),
             stellar: std::sync::Arc::new(StellarService::from_env()),
+            cache,
         }
     }
 }

backend/src/main.rs

@@ -44,10 +44,9 @@ async fn main() -> anyhow::Result<()> {
 
     sqlx::migrate!("./migrations").run(&pool).await?;
 
-    let state = AppState::new(pool.clone());
+    let state = AppState::new(pool.clone()).await;
     tokio::spawn(worker::run_judge_worker(pool.clone()));
     tokio::spawn(indexer::run_indexer_worker(pool));
-
     let app = build_router(state);
 
     let port: u16 = std::env::var("PORT")

backend/src/routes/health.rs

@@ -52,21 +52,50 @@ pub async fn readiness(State(state): State<AppState>) -> (StatusCode, Json<Value
 }
 
 pub async fn health(State(state): State<AppState>) -> (StatusCode, Json<Value>) {
-    match sqlx::query("SELECT 1").execute(&state.pool).await {
+    let mut cache_status = "not configured".to_string();
+    let mut overall_status = "ok".to_string();
+
+    // Check database connection
+    let db_res = sqlx::query("SELECT 1").execute(&state.pool).await;
+
+    // Check Redis cache connection (if configured)
+    if let Some(ref cache) = state.cache {
+        match cache.ping().await {
+            Ok(pong) => {
+                cache_status = pong;
+            }
+            Err(e) => {
+                cache_status = format!("error: {}", e);
+                overall_status = "degraded".to_string();
+            }
+        }
+    }
+
+    match db_res {
         Ok(_) => {
             let (code, Json(sync_status_payload)) = sync_status(State(state.clone())).await;
+            let final_status = if overall_status == "degraded" {
+                "degraded"
+            } else {
+                sync_status_payload["status"].as_str().unwrap_or("ok")
+            };
             (
                 code,
                 Json(json!({
-                    "status": sync_status_payload["status"].clone(),
+                    "status": final_status,
                     "db": "connected",
+                    "cache": cache_status,
                     "indexer_sync_status": sync_status_payload
                 })),
             )
         }
         Err(e) => (
             StatusCode::SERVICE_UNAVAILABLE,
-            Json(json!({ "status": "degraded", "db": e.to_string() })),
+            Json(json!({
+                "status": "degraded",
+                "db": e.to_string(),
+                "cache": cache_status
+            })),
         ),
     }
 }

backend/src/routes/jobs.rs

@@ -55,9 +55,9 @@ async fn list_jobs(
 
     if let Some(q) = params.query {
         query_builder.push(" AND (title ILIKE ");
-        query_builder.push_bind(format!("%{}%", q));
+        query_builder.push_bind(format!("%{q}%"));
         query_builder.push(" OR description ILIKE ");
-        query_builder.push_bind(format!("%{}%", q));
+        query_builder.push_bind(format!("%{q}%"));
         query_builder.push(")");
     }
 
@@ -71,21 +71,25 @@ async fn list_jobs(
     if let Some(tag) = params.tag {
         if tag != "all" {
             query_builder.push(" AND (title ILIKE ");
-            query_builder.push_bind(format!("%{}%", tag));
+            query_builder.push_bind(format!("%{tag}%"));
             query_builder.push(" OR description ILIKE ");
-            query_builder.push_bind(format!("%{}%", tag));
+            query_builder.push_bind(format!("%{tag}%"));
             query_builder.push(")");
         }
     }
 
     match params.sort.as_deref() {
-        Some("budget") => query_builder.push(" ORDER BY budget_usdc DESC"),
+        Some("budget") => {
+            query_builder.push(" ORDER BY budget_usdc DESC");
+        }
         Some("reputation") => {
             // Reputation sort requires joining with a reputation table or calculating score.
             // For now, we'll just sort by created_at as a fallback.
             query_builder.push(" ORDER BY created_at DESC");
         }
-        _ => query_builder.push(" ORDER BY created_at DESC"),
+        _ => {
+            query_builder.push(" ORDER BY created_at DESC");
+        }
     }
 
     let jobs = query_builder