chore: drop redis

src/config/mod.rs

@@ -25,8 +25,6 @@ pub struct Config {
     pub port: u16,
     /// Database connection URL
     pub database_url: String,
-    /// Redis connection URL
-    pub redis_url: String,
     /// Graceful shutdown timeout duration
     ///
     /// Accepts both numeric values (seconds) and duration strings

src/main.rs

@@ -118,8 +118,7 @@ async fn main() {
     .expect("Failed to create BannerApi");
 
     let banner_api_arc = Arc::new(banner_api);
-    let app_state = AppState::new(banner_api_arc.clone(), &config.redis_url, db_pool.clone())
-        .expect("Failed to create AppState");
+    let app_state = AppState::new(banner_api_arc.clone(), db_pool.clone());
 
     // Create BannerState for web service
     let banner_state = BannerState {

src/state.rs

@@ -3,51 +3,29 @@
 use crate::banner::BannerApi;
 use crate::banner::Course;
 use anyhow::Result;
-use redis::AsyncCommands;
-use redis::Client;
 use sqlx::PgPool;
 use std::sync::Arc;
 
 #[derive(Clone)]
 pub struct AppState {
     pub banner_api: Arc<BannerApi>,
-    pub redis: Arc<Client>,
     pub db_pool: PgPool,
 }
 
 impl AppState {
-    pub fn new(
-        banner_api: Arc<BannerApi>,
-        redis_url: &str,
-        db_pool: PgPool,
-    ) -> Result<Self, Box<dyn std::error::Error + Send + Sync>> {
-        let redis_client = Client::open(redis_url)?;
-
-        Ok(Self {
+    pub fn new(banner_api: Arc<BannerApi>, db_pool: PgPool) -> Self {
+        Self {
             banner_api,
-            redis: Arc::new(redis_client),
             db_pool,
-        })
+        }
     }
 
-    /// Get a course by CRN with Redis cache fallback to Banner API
+    /// Get a course by CRN directly from Banner API
     pub async fn get_course_or_fetch(&self, term: &str, crn: &str) -> Result<Course> {
-        let mut conn = self.redis.get_multiplexed_async_connection().await?;
-
-        let key = format!("class:{crn}");
-        if let Some(serialized) = conn.get::<_, Option<String>>(&key).await? {
-            let course: Course = serde_json::from_str(&serialized)?;
-            return Ok(course);
-        }
-
-        // Fallback: fetch from Banner API
-        if let Some(course) = self.banner_api.get_course_by_crn(term, crn).await? {
-            let serialized = serde_json::to_string(&course)?;
-            let _: () = conn.set(&key, serialized).await?;
-            return Ok(course);
-        }
-
-        Err(anyhow::anyhow!("Course not found for CRN {crn}"))
+        self.banner_api
+            .get_course_by_crn(term, crn)
+            .await?
+            .ok_or_else(|| anyhow::anyhow!("Course not found for CRN {crn}"))
     }
 
     /// Get the total number of courses in the database

src/web/routes.rs

@@ -69,18 +69,8 @@ async fn status(State(_state): State<BannerState>) -> Json<Value> {
 async fn metrics(State(_state): State<BannerState>) -> Json<Value> {
     // For now, return basic metrics structure
     Json(json!({
-        "redis": {
-            "status": "connected",
-            "connected_clients": "TODO: implement client counting",
-            "used_memory": "TODO: implement memory tracking"
-        },
-        "cache": {
-            "courses": {
-                "count": "TODO: implement course counting"
-            },
-            "subjects": {
-                "count": "TODO: implement subject counting"
-            }
+        "banner_api": {
+            "status": "connected"
         },
         "timestamp": chrono::Utc::now().to_rfc3339()
     }))