refactor: resolve handle view

Cargo.lock

···
 dependencies = [
  "android-tzdata",
  "iana-time-zone",
+ "js-sys",
  "num-traits",
+ "wasm-bindgen",
  "windows-link",
 ]
 
···
  "atproto-identity",
  "axum",
  "bincode",
+ "chrono",
  "deadpool-redis",
  "metrohash",
  "reqwest",

Cargo.toml

···
 atproto-identity = { version = "0.11.3" }
 axum = { version = "0.8" }
 bincode = { version = "2.0.1", features = ["serde"] }
+chrono = "0.4"
 deadpool-redis = { version = "0.22", features = ["connection-manager", "tokio-comp", "tokio-rustls-comp"] }
 metrohash = "1.0.7"
 reqwest = { version = "0.12", features = ["json"] }

src/http/handle_xrpc_resolve_handle.rs

···
+use chrono::{DateTime, Utc};
 use std::sync::Arc;
+use std::time::{SystemTime, UNIX_EPOCH};
 
 use crate::{
     handle_resolver::HandleResolver,
···
     message: String,
 }
 
+/// Represents the result of a handle resolution
+enum ResolutionResult {
+    Success {
+        did: String,
+        timestamp: u64,
+        etag: String,
+    },
+    Error {
+        error: String,
+        message: String,
+        timestamp: u64,
+        etag: String,
+    },
+}
+
+struct ResolutionResultView {
+    result: ResolutionResult,
+    cache_control: Option<String>,
+    if_none_match: Option<HeaderValue>,
+    if_modified_since: Option<HeaderValue>,
+}
+
+impl IntoResponse for ResolutionResultView {
+    fn into_response(self) -> Response {
+        let (last_modified, etag) = match &self.result {
+            ResolutionResult::Success {
+                timestamp, etag, ..
+            } => (*timestamp, etag),
+            ResolutionResult::Error {
+                timestamp, etag, ..
+            } => (*timestamp, etag),
+        };
+
+        let mut headers = HeaderMap::new();
+
+        // WARNING: this swallows errors
+        if let Ok(etag_value) = HeaderValue::from_str(etag) {
+            headers.insert(header::ETAG, etag_value);
+        }
+
+        // Add Last-Modified header
+        let last_modified_date = format_http_date(last_modified);
+        // WARNING: this swallows errors
+        if let Ok(last_modified_value) = HeaderValue::from_str(&last_modified_date) {
+            headers.insert(header::LAST_MODIFIED, last_modified_value);
+        }
+
+        // Add Cache-Control header if configured
+        if let Some(cache_control) = &self.cache_control {
+            // WARNING: this swallows errors
+            if let Ok(cache_control_value) = HeaderValue::from_str(cache_control) {
+                headers.insert(header::CACHE_CONTROL, cache_control_value);
+            }
+        }
+
+        headers.insert("Allow", HeaderValue::from_static("GET, HEAD, OPTIONS"));
+        headers.insert(
+            header::ACCESS_CONTROL_ALLOW_HEADERS,
+            HeaderValue::from_static("*"),
+        );
+        headers.insert(
+            header::ACCESS_CONTROL_ALLOW_METHODS,
+            HeaderValue::from_static("GET, HEAD, OPTIONS"),
+        );
+        headers.insert(
+            header::ACCESS_CONTROL_ALLOW_ORIGIN,
+            HeaderValue::from_static("*"),
+        );
+        headers.insert(
+            header::ACCESS_CONTROL_EXPOSE_HEADERS,
+            HeaderValue::from_static("*"),
+        );
+        headers.insert(
+            header::ACCESS_CONTROL_MAX_AGE,
+            HeaderValue::from_static("86400"),
+        );
+        headers.insert(
+            "Access-Control-Request-Headers",
+            HeaderValue::from_static("*"),
+        );
+        headers.insert(
+            "Access-Control-Request-Method",
+            HeaderValue::from_static("GET"),
+        );
+
+        if let ResolutionResult::Success { .. } = self.result {
+            let fresh = self
+                .if_modified_since
+                .and_then(|inner_header_value| match inner_header_value.to_str() {
+                    Ok(value) => Some(value.to_string()),
+                    Err(_) => None,
+                })
+                .and_then(|inner_str_value| parse_http_date(&inner_str_value))
+                .is_some_and(|inner_if_modified_since| last_modified <= inner_if_modified_since);
+
+            if fresh {
+                return (StatusCode::NOT_MODIFIED, headers).into_response();
+            }
+        }
+
+        let fresh = self
+            .if_none_match
+            .is_some_and(|if_none_match_value| if_none_match_value == etag);
+        if fresh {
+            return (StatusCode::NOT_MODIFIED, headers).into_response();
+        }
+
+        match &self.result {
+            ResolutionResult::Success { did, .. } => (
+                StatusCode::OK,
+                headers,
+                Json(ResolveHandleResponse { did: did.clone() }),
+            )
+                .into_response(),
+            ResolutionResult::Error { error, message, .. } => (
+                StatusCode::BAD_REQUEST,
+                headers,
+                Json(ErrorResponse {
+                    error: error.clone(),
+                    message: message.clone(),
+                }),
+            )
+                .into_response(),
+        }
+
+        // (status_code, headers).into_response()
+    }
+}
+
 /// Calculate a weak ETag for the given content using MetroHash64 with a seed
 fn calculate_etag(content: &str, seed: &str) -> String {
     let mut hasher = MetroHash64::new();
···
     format!("W/\"{:x}\"", hash)
 }
 
+/// Format a UNIX timestamp as an HTTP date string (RFC 7231)
+fn format_http_date(timestamp: u64) -> String {
+    let datetime = DateTime::from_timestamp(timestamp as i64, 0).unwrap_or_else(Utc::now);
+
+    datetime.format("%a, %d %b %Y %H:%M:%S GMT").to_string()
+}
+
+/// Parse an HTTP date string (RFC 7231) into a UNIX timestamp
+fn parse_http_date(date_str: &str) -> Option<u64> {
+    use chrono::{DateTime, Utc};
+
+    // Try parsing with the standard HTTP date format
+    DateTime::parse_from_rfc2822(date_str)
+        .ok()
+        .map(|dt| dt.with_timezone(&Utc).timestamp() as u64)
+}
+
 pub(super) async fn handle_xrpc_resolve_handle(
     headers: HeaderMap,
     Query(params): Query<ResolveHandleParams>,
     State(app_context): State<AppContext>,
     State(handle_resolver): State<Arc<dyn HandleResolver>>,
     State(queue): State<Arc<dyn QueueAdapter<HandleResolutionWork>>>,
-) -> Result<Response, Response> {
+) -> impl IntoResponse {
     let validating = params.validate.is_some();
     let queueing = params.queue.is_some();
 
···
     let handle = match params.handle {
         Some(h) => h,
         None => {
-            return Err((
+            return (
                 StatusCode::BAD_REQUEST,
                 Json(ErrorResponse {
                     error: "InvalidRequest".to_string(),
                     message: "Error: Params must have the property \"handle\"".to_string(),
                 }),
             )
-                .into_response());
+                .into_response();
         }
     };
 
···
         Ok(InputType::Handle(value)) => value,
         Ok(InputType::Plc(_)) | Ok(InputType::Web(_)) => {
             // It's a DID, not a handle
-            return Err((
+            return (
                 StatusCode::BAD_REQUEST,
                 Json(ErrorResponse {
                     error: "InvalidRequest".to_string(),
                     message: "Error: handle must be a valid handle".to_string(),
                 }),
             )
-                .into_response());
+                .into_response();
         }
         Err(_) => {
-            return Err((
+            return (
                 StatusCode::BAD_REQUEST,
                 Json(ErrorResponse {
                     error: "InvalidRequest".to_string(),
                     message: "Error: handle must be a valid handle".to_string(),
                 }),
             )
-                .into_response());
+                .into_response();
         }
     };
 
     if validating {
-        return Ok(StatusCode::NO_CONTENT.into_response());
+        return StatusCode::NO_CONTENT.into_response();
     }
 
     if queueing {
···
             }
         }
 
-        return Ok(StatusCode::NO_CONTENT.into_response());
+        return StatusCode::NO_CONTENT.into_response();
     }
 
     tracing::debug!(handle, "Resolving handle");
 
-    let if_none_match = headers.get(header::IF_NONE_MATCH);
+    // Get conditional request headers
+    let if_none_match = headers.get(header::IF_NONE_MATCH).cloned();
+    let if_modified_since = headers.get(header::IF_MODIFIED_SINCE).cloned();
 
-    let (mut response, etag) = match handle_resolver.resolve(&handle).await {
-        Ok((did, _timestamp)) => {
+    // Perform the resolution and build the response
+    let result = match handle_resolver.resolve(&handle).await {
+        Ok((did, timestamp)) => {
             tracing::debug!(handle, did, "Found cached DID for handle");
-
-            // Calculate the weak etag for the successful response
             let etag = calculate_etag(&did, app_context.etag_seed());
-
-            // Check if the client's etag matches our calculated one
-            if if_none_match.is_some_and(|value| value == &etag) {
-                (StatusCode::NOT_MODIFIED.into_response(), etag)
-            } else {
-                (Json(ResolveHandleResponse { did }).into_response(), etag)
+            ResolutionResult::Success {
+                did,
+                timestamp,
+                etag,
             }
         }
         Err(err) => {
             tracing::debug!(error = ?err, handle, "Error resolving handle");
-
-            // Calculate the weak etag for the error response
-            // Use a combination of error message and handle for consistent error etags
             let error_content = format!("error:{}:{}", handle, err);
             let etag = calculate_etag(&error_content, app_context.etag_seed());
-
-            if if_none_match.is_some_and(|value| value == &etag) {
-                (StatusCode::NOT_MODIFIED.into_response(), etag)
-            } else {
-                (
-                    (
-                        StatusCode::BAD_REQUEST,
-                        Json(ErrorResponse {
-                            error: "InvalidRequest".to_string(),
-                            message: "Unable to resolve handle".to_string(),
-                        }),
-                    )
-                        .into_response(),
-                    etag,
-                )
+            let timestamp = SystemTime::now()
+                .duration_since(UNIX_EPOCH)
+                .unwrap_or_default()
+                .as_secs();
+            ResolutionResult::Error {
+                error: "InvalidRequest".to_string(),
+                message: "Unable to resolve handle".to_string(),
+                timestamp,
+                etag,
             }
         }
     };
 
-    let headers = response.headers_mut();
-
-    // Add ETag header
-    match HeaderValue::from_str(&etag) {
-        Ok(etag_header_value) => {
-            headers.insert(header::ETAG, etag_header_value);
-        }
-        Err(err) => {
-            tracing::error!(error = ?err, "unable to create etag response value");
-        }
-    }
-
-    // Add Cache-Control header if configured
-    if let Some(cache_control) = app_context.cache_control_header()
-        && let Ok(cache_control_value) = HeaderValue::from_str(cache_control)
-    {
-        headers.insert(header::CACHE_CONTROL, cache_control_value);
+    ResolutionResultView {
+        result,
+        cache_control: app_context.cache_control_header().map(|s| s.to_string()),
+        if_none_match,
+        if_modified_since,
     }
+    .into_response()
 
-    // Add CORS and Allow headers
-    headers.insert("Allow", HeaderValue::from_static("GET, HEAD, OPTIONS"));
-    headers.insert(
-        header::ACCESS_CONTROL_ALLOW_HEADERS,
-        HeaderValue::from_static("*"),
-    );
-    headers.insert(
-        header::ACCESS_CONTROL_ALLOW_METHODS,
-        HeaderValue::from_static("GET, HEAD, OPTIONS"),
-    );
-    headers.insert(
-        header::ACCESS_CONTROL_ALLOW_ORIGIN,
-        HeaderValue::from_static("*"),
-    );
-    headers.insert(
-        header::ACCESS_CONTROL_EXPOSE_HEADERS,
-        HeaderValue::from_static("*"),
-    );
-    headers.insert(
-        header::ACCESS_CONTROL_MAX_AGE,
-        HeaderValue::from_static("86400"),
-    );
-    headers.insert(
-        "Access-Control-Request-Headers",
-        HeaderValue::from_static("*"),
-    );
-    headers.insert(
-        "Access-Control-Request-Method",
-        HeaderValue::from_static("GET"),
-    );
+    // Build the response using the builder
+    // let response = HandleResponseBuilder::new(
+    //     result,
+    //     app_context.cache_control_header().map(|s| s.to_string()),
+    //     if_none_match,
+    //     if_modified_since,
+    // )
+    // .build();
 
-    Ok(response)
+    // Ok(response)
 }
 
-pub(super) async fn handle_xrpc_resolve_handle_options() -> Response {
-    let mut response = StatusCode::NO_CONTENT.into_response();
-    let headers = response.headers_mut();
-    
+pub(super) async fn handle_xrpc_resolve_handle_options() -> impl IntoResponse {
+    let mut headers = HeaderMap::new();
+
     // Add CORS and Allow headers for OPTIONS request
     headers.insert("Allow", HeaderValue::from_static("GET, HEAD, OPTIONS"));
     headers.insert(
···
         "Access-Control-Request-Method",
         HeaderValue::from_static("GET"),
     );
-    
-    response
+
+    (StatusCode::NO_CONTENT, headers)
 }