Merge pull request #63 from chemicalcommando/chem

Chem

Author: Tinna23

packages/core/src/api/fees.rs

@@ -2,8 +2,10 @@ use std::sync::Arc;
 
 use async_trait::async_trait;
 use axum::{
+    body::Body,
     extract::{Query, State},
-    http::StatusCode,
+    http::{HeaderMap, StatusCode, header},
+    response::Response,
     Json,
 };
 use chrono::{DateTime, Duration, Utc};
@@ -16,6 +18,7 @@ use crate::error::AppError;
 use crate::insights::{FeeDataPoint, FeeInsightsEngine, TrendIndicator, TrendStrength};
 use crate::services::horizon::HorizonClient;
 use crate::store::FeeHistoryStore;
+use super::headers::{cache_control, compute_etag, if_none_match_matches, last_modified};
 
 /// Shared state type for the fees route.
 pub type FeesState = Arc<FeesApiState>;
@@ -73,32 +76,99 @@ pub struct CurrentFeeResponse {
     pub percentiles: PercentileFees,
 }
 
+const FEES_CURRENT_MAX_AGE: u32 = 5;
+const FEES_CURRENT_SWR: u32 = 10;
+const FEES_HISTORY_MAX_AGE: u32 = 30;
+const FEES_HISTORY_SWR: u32 = 60;
+
+async fn resolve_last_modified(state: &FeesState) -> axum::http::HeaderValue {
+    let timestamp = match state.insights_engine.as_ref() {
+        Some(engine) => engine
+            .read()
+            .await
+            .get_last_update()
+            .unwrap_or_else(Utc::now),
+        None => Utc::now(),
+    };
+    last_modified(timestamp)
+}
+
+fn not_modified_response(
+    max_age: u32,
+    swr: u32,
+    etag: &str,
+    last_modified_value: axum::http::HeaderValue,
+) -> Response {
+    Response::builder()
+        .status(StatusCode::NOT_MODIFIED)
+        .header(header::CACHE_CONTROL, cache_control(max_age, swr))
+        .header(header::ETAG, etag)
+        .header(header::LAST_MODIFIED, last_modified_value)
+        .body(Body::empty())
+        .expect("304 response should be valid")
+}
+
+fn json_cache_response(
+    max_age: u32,
+    swr: u32,
+    etag: &str,
+    last_modified_value: axum::http::HeaderValue,
+    body: Vec<u8>,
+) -> Response {
+    Response::builder()
+        .status(StatusCode::OK)
+        .header(header::CONTENT_TYPE, "application/json")
+        .header(header::CACHE_CONTROL, cache_control(max_age, swr))
+        .header(header::ETAG, etag)
+        .header(header::LAST_MODIFIED, last_modified_value)
+        .body(Body::from(body))
+        .expect("cached response should be valid")
+}
+
 pub async fn current_fees(
     State(state): State<FeesState>,
-) -> Result<Json<CurrentFeeResponse>, AppError> {
-    {
+    request_headers: HeaderMap,
+) -> Result<Response, AppError> {
+    let cached = {
         let cache = state.fee_cache.lock().await;
         if cache.is_fresh() {
-            if let Some(cached) = cache.get() {
-                return Ok(Json(cached));
-            }
+            cache.get()
+        } else {
+            None
         }
-    }
-
-    let provider = state
-        .fee_stats_provider
-        .as_ref()
-        .ok_or_else(|| {
+    };
+    let payload = if let Some(cached) = cached {
+        cached
+    } else {
+        let provider = state.fee_stats_provider.as_ref().ok_or_else(|| {
             AppError::Config("Fee stats provider missing from fees state".to_string())
         })?;
-    let fresh = provider.fetch_current_fees().await?;
-
-    {
+        let fresh = provider.fetch_current_fees().await?;
         let mut cache = state.fee_cache.lock().await;
         cache.set(fresh.clone());
+        fresh
+    };
+
+    let body = serde_json::to_vec(&payload).map_err(|err| AppError::Parse(err.to_string()))?;
+    let etag = compute_etag(&body);
+    let last_modified_value = resolve_last_modified(&state).await;
+
+    if if_none_match_matches(&request_headers, &etag) {
+        return Ok(not_modified_response(
+            FEES_CURRENT_MAX_AGE,
+            FEES_CURRENT_SWR,
+            &etag,
+            last_modified_value,
+        ));
     }
 
-    Ok(Json(fresh))
+    Ok(json_cache_response(
+        FEES_CURRENT_MAX_AGE,
+        FEES_CURRENT_SWR,
+        &etag,
+        last_modified_value,
+        body,
+    ))
 }
 
 #[derive(Debug, Deserialize)]
@@ -128,7 +198,8 @@ pub struct FeeHistoryResponse {
 pub async fn fee_history(
     State(state): State<FeesState>,
     Query(params): Query<FeeHistoryQuery>,
-) -> Result<Json<FeeHistoryResponse>, (StatusCode, Json<Value>)> {
+    request_headers: HeaderMap,
+) -> Result<Response, (StatusCode, Json<Value>)> {
     let window = params.window.unwrap_or_else(|| "1h".to_string());
     let duration = parse_window(&window).ok_or_else(|| {
         (
@@ -145,14 +216,39 @@ pub async fn fee_history(
     };
     let summary = compute_summary(&fees);
 
-    Ok(Json(FeeHistoryResponse {
+    let payload = FeeHistoryResponse {
         window,
         from,
         to,
         data_points: fees.len(),
         fees,
         summary,
-    }))
+    };
+    let body = serde_json::to_vec(&payload).map_err(|err| {
+        (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            Json(json!({ "error": format!("Failed to serialize fee history: {}", err) })),
+        )
+    })?;
+    let etag = compute_etag(&body);
+    let last_modified_value = resolve_last_modified(&state).await;
+
+    if if_none_match_matches(&request_headers, &etag) {
+        return Ok(not_modified_response(
+            FEES_HISTORY_MAX_AGE,
+            FEES_HISTORY_SWR,
+            &etag,
+            last_modified_value,
+        ));
+    }
+
+    Ok(json_cache_response(
+        FEES_HISTORY_MAX_AGE,
+        FEES_HISTORY_SWR,
+        &etag,
+        last_modified_value,
+        body,
+    ))
 }
 
 fn parse_window(value: &str) -> Option<Duration> {
@@ -525,6 +621,50 @@ mod tests {
         assert_eq!(mock.calls(), 2, "expired cache should trigger refetch");
     }
 
+    #[tokio::test]
+    async fn current_fees_returns_304_when_if_none_match_matches() {
+        let mock = MockFeeStatsProvider::new(vec![make_current_fee_response("100")]);
+        let state = make_fee_state_with_provider(Arc::new(mock), StdDuration::from_secs(60));
+
+        let app = Router::new()
+            .route("/fees/current", get(current_fees))
+            .with_state(state);
+
+        let first = app
+            .clone()
+            .oneshot(
+                Request::builder()
+                    .uri("/fees/current")
+                    .body(Body::empty())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+        assert_eq!(first.status(), StatusCode::OK);
+        let etag = first
+            .headers()
+            .get("etag")
+            .expect("missing etag header")
+            .to_str()
+            .unwrap()
+            .to_string();
+
+        let second = app
+            .oneshot(
+                Request::builder()
+                    .uri("/fees/current")
+                    .header("if-none-match", etag)
+                    .body(Body::empty())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+
+        assert_eq!(second.status(), StatusCode::NOT_MODIFIED);
+        let body = to_bytes(second.into_body(), usize::MAX).await.unwrap();
+        assert!(body.is_empty(), "304 response should not include body");
+    }
+
     #[tokio::test]
     async fn fee_history_returns_data_points_and_summary_for_supported_windows() {
         for window in ["1h", "6h", "24h"] {

packages/core/src/api/headers.rs

@@ -0,0 +1,61 @@
+use std::collections::hash_map::DefaultHasher;
+use std::hash::{Hash, Hasher};
+
+use axum::http::{HeaderMap, HeaderValue, header};
+use chrono::{DateTime, Utc};
+
+/// Compute a weakly-stable quoted ETag from response bytes.
+pub fn compute_etag(body: &[u8]) -> String {
+    let mut hasher = DefaultHasher::new();
+    body.hash(&mut hasher);
+    format!("\"{:x}\"", hasher.finish())
+}
+
+/// Build a Cache-Control value using max-age and stale-while-revalidate.
+pub fn cache_control(max_age: u32, swr: u32) -> HeaderValue {
+    HeaderValue::from_str(&format!(
+        "max-age={}, stale-while-revalidate={}",
+        max_age, swr
+    ))
+    .expect("cache-control header value should be valid")
+}
+
+/// Build an RFC 7231 HTTP-date for Last-Modified.
+pub fn last_modified(timestamp: DateTime<Utc>) -> HeaderValue {
+    HeaderValue::from_str(&timestamp.format("%a, %d %b %Y %H:%M:%S GMT").to_string())
+        .expect("last-modified header value should be valid")
+}
+
+/// Returns true when `If-None-Match` contains `*` or the exact current ETag.
+pub fn if_none_match_matches(headers: &HeaderMap, current_etag: &str) -> bool {
+    headers
+        .get(header::IF_NONE_MATCH)
+        .and_then(|value| value.to_str().ok())
+        .map(|raw| {
+            raw.split(',')
+                .map(|tag| tag.trim())
+                .any(|tag| tag == "*" || tag == current_etag)
+        })
+        .unwrap_or(false)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn etag_is_quoted() {
+        let etag = compute_etag(br#"{"ok":true}"#);
+        assert!(etag.starts_with('"'));
+        assert!(etag.ends_with('"'));
+    }
+
+    #[test]
+    fn if_none_match_matches_exact_tag() {
+        let mut headers = HeaderMap::new();
+        headers.insert(header::IF_NONE_MATCH, HeaderValue::from_static("\"abc\""));
+
+        assert!(if_none_match_matches(&headers, "\"abc\""));
+        assert!(!if_none_match_matches(&headers, "\"def\""));
+    }
+}

packages/core/src/api/health.rs

@@ -1,5 +1,13 @@
-use axum::response::IntoResponse;
+use axum::{
+    body::Body,
+    http::{HeaderValue, StatusCode, header},
+    response::{IntoResponse, Response},
+};
 
 pub async fn health() -> impl IntoResponse {
-    "ok"
-}
+    Response::builder()
+        .status(StatusCode::OK)
+        .header(header::CACHE_CONTROL, HeaderValue::from_static("no-store"))
+        .body(Body::from("ok"))
+        .expect("health response should be valid")
+}

packages/core/src/api/insights.rs

@@ -1,17 +1,19 @@
 //! Insights API endpoints
 
 use axum::{
+    body::Body,
     extract::State,
-    http::StatusCode,
-    response::Json,
+    http::{HeaderMap, StatusCode, header},
+    response::{Json, Response},
     routing::get,
     Router,
 };
 use serde_json::Value;
 use std::sync::Arc;
 use tokio::sync::RwLock;
 
-use crate::insights::{FeeInsightsEngine, CurrentInsights, RollingAverages, FeeExtremes, CongestionTrends};
+use crate::insights::{CongestionTrends, FeeExtremes, FeeInsightsEngine, RollingAverages};
+use super::headers::{cache_control, compute_etag, if_none_match_matches, last_modified};
 
 /// Shared state for the insights API
 pub type InsightsState = Arc<RwLock<FeeInsightsEngine>>;
@@ -30,10 +32,37 @@ pub fn create_insights_router(insights_engine: InsightsState) -> Router {
 /// Get current insights
 async fn get_current_insights(
     State(engine): State<InsightsState>,
-) -> Result<Json<CurrentInsights>, (StatusCode, Json<Value>)> {
+    request_headers: HeaderMap,
+) -> Result<Response, (StatusCode, Json<Value>)> {
     let engine = engine.read().await;
     let insights = engine.get_current_insights();
-    Ok(Json(insights))
+    let body = serde_json::to_vec(&insights).map_err(|err| {
+        (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            Json(serde_json::json!({ "error": format!("Failed to serialize insights: {}", err) })),
+        )
+    })?;
+    let etag = compute_etag(&body);
+    let last_modified_value = last_modified(insights.last_updated);
+
+    if if_none_match_matches(&request_headers, &etag) {
+        return Ok(Response::builder()
+            .status(StatusCode::NOT_MODIFIED)
+            .header(header::CACHE_CONTROL, cache_control(10, 20))
+            .header(header::ETAG, etag.as_str())
+            .header(header::LAST_MODIFIED, last_modified_value)
+            .body(Body::empty())
+            .expect("304 insights response should be valid"));
+    }
+
+    Ok(Response::builder()
+        .status(StatusCode::OK)
+        .header(header::CONTENT_TYPE, "application/json")
+        .header(header::CACHE_CONTROL, cache_control(10, 20))
+        .header(header::ETAG, etag.as_str())
+        .header(header::LAST_MODIFIED, last_modified_value)
+        .body(Body::from(body))
+        .expect("insights response should be valid"))
 }
 
 /// Get rolling averages
@@ -80,4 +109,4 @@ async fn get_insights_health(
     });
 
     Ok(Json(health_info))
-}
+}

packages/core/src/api/mod.rs

@@ -2,5 +2,5 @@ pub mod health;
 pub mod fees;
 pub mod insights;
 pub mod alerts;
-
+pub mod headers;