Migrate handler layer to HTTP types (PR 12)

crates/trusted-server-adapter-fastly/src/route_tests.rs

@@ -6,6 +6,8 @@ use error_stack::Report;
 use fastly::http::StatusCode;
 use fastly::Request;
 use trusted_server_core::auction::build_orchestrator;
+use trusted_server_core::compat;
+use trusted_server_core::error::{IntoHttpResponse, TrustedServerError};
 use trusted_server_core::integrations::IntegrationRegistry;
 use trusted_server_core::platform::{
     ClientInfo, GeoInfo, PlatformBackend, PlatformBackendSpec, PlatformConfigStore, PlatformError,
@@ -16,7 +18,14 @@ use trusted_server_core::platform::{
 use trusted_server_core::request_signing::JWKS_CONFIG_STORE_NAME;
 use trusted_server_core::settings::Settings;
 
-use super::route_request;
+use super::{route_request, HandlerOutcome};
+
+fn outcome_status(result: &Result<HandlerOutcome, Report<TrustedServerError>>) -> StatusCode {
+    match result {
+        Ok(outcome) => outcome.status(),
+        Err(e) => e.current_context().status_code(),
+    }
+}
 
 struct StubJwksConfigStore;
 
@@ -185,66 +194,67 @@ fn configured_missing_consent_store_only_breaks_consent_routes() {
     let integration_registry =
         IntegrationRegistry::new(&settings).expect("should create integration registry");
 
-    let discovery_req = Request::get("https://test.com/.well-known/trusted-server.json");
-    let discovery_services = test_runtime_services(&discovery_req);
+    let discovery_fastly_req = Request::get("https://test.com/.well-known/trusted-server.json");
+    let discovery_services = test_runtime_services(&discovery_fastly_req);
     let discovery_resp = futures::executor::block_on(route_request(
         &settings,
         &orchestrator,
         &integration_registry,
         &discovery_services,
-        discovery_req,
+        compat::from_fastly_request(discovery_fastly_req),
     ))
     .expect("should route discovery request");
     assert_eq!(
-        discovery_resp.get_status(),
+        discovery_resp.status(),
         StatusCode::OK,
         "should keep discovery available when the consent store is unavailable"
     );
 
-    let admin_req = Request::post("https://test.com/admin/keys/rotate");
-    let admin_services = test_runtime_services(&admin_req);
+    let admin_fastly_req = Request::post("https://test.com/admin/keys/rotate");
+    let admin_services = test_runtime_services(&admin_fastly_req);
     let admin_resp = futures::executor::block_on(route_request(
         &settings,
         &orchestrator,
         &integration_registry,
         &admin_services,
-        admin_req,
+        compat::from_fastly_request(admin_fastly_req),
     ))
     .expect("should route admin request");
     assert_eq!(
-        admin_resp.get_status(),
+        admin_resp.status(),
         StatusCode::UNAUTHORIZED,
         "should keep admin auth behavior unchanged when the consent store is unavailable"
     );
 
-    let auction_req = Request::post("https://test.com/auction").with_body(r#"{"adUnits":[]}"#);
-    let auction_services = test_runtime_services(&auction_req);
-    let auction_resp = futures::executor::block_on(route_request(
+    let auction_fastly_req =
+        Request::post("https://test.com/auction").with_body(r#"{"adUnits":[]}"#);
+    let auction_services = test_runtime_services(&auction_fastly_req);
+    let auction_result = futures::executor::block_on(route_request(
         &settings,
         &orchestrator,
         &integration_registry,
         &auction_services,
-        auction_req,
-    ))
-    .expect("should return an error response for auction requests");
+        compat::from_fastly_request(auction_fastly_req),
+    ));
+    let auction_status = outcome_status(&auction_result);
     assert_eq!(
-        auction_resp.get_status(),
+        auction_status,
         StatusCode::SERVICE_UNAVAILABLE,
         "should fail auction requests when consent persistence is configured but unavailable"
     );
 
-    let publisher_req = Request::get("https://test.com/articles/example");
-    let publisher_services = test_runtime_services(&publisher_req);
-    let publisher_resp = futures::executor::block_on(route_request(
+    let publisher_fastly_req = Request::get("https://test.com/articles/example");
+    let publisher_services = test_runtime_services(&publisher_fastly_req);
+    let publisher_result = futures::executor::block_on(route_request(
         &settings,
         &orchestrator,
         &integration_registry,
         &publisher_services,
-        publisher_req,
-    ))
-    .expect("should return an error response for publisher fallback");
+        compat::from_fastly_request(publisher_fastly_req),
+    ));
+    let publisher_status = outcome_status(&publisher_result);
     assert_eq!(
-        publisher_resp.get_status(),
+        publisher_status,
         StatusCode::SERVICE_UNAVAILABLE,
         "should scope consent store failures to the consent-dependent routes"
     );

crates/trusted-server-core/src/auction/endpoints.rs

@@ -1,7 +1,8 @@
 //! HTTP endpoint handlers for auction requests.
 
+use edgezero_core::body::Body as EdgeBody;
 use error_stack::{Report, ResultExt};
-use fastly::{Request, Response};
+use http::{Request, Response};
 
 use crate::auction::formats::AdRequest;
 use crate::compat;
@@ -16,6 +17,8 @@ use super::formats::{convert_to_openrtb_response, convert_tsjs_to_auction_reques
 use super::types::AuctionContext;
 use super::AuctionOrchestrator;
 
+const AUCTION_MAX_BODY_BYTES: usize = 65536;
+
 /// Handle auction request from /auction endpoint.
 ///
 /// This is the main entry point for running header bidding auctions.
@@ -33,21 +36,32 @@ pub async fn handle_auction(
     settings: &Settings,
     orchestrator: &AuctionOrchestrator,
     services: &RuntimeServices,
-    mut req: Request,
-) -> Result<Response, Report<TrustedServerError>> {
+    req: Request<EdgeBody>,
+) -> Result<Response<EdgeBody>, Report<TrustedServerError>> {
+    let (parts, body) = req.into_parts();
+
     // Parse request body
-    let body: AdRequest = serde_json::from_slice(&req.take_body_bytes()).change_context(
-        TrustedServerError::Auction {
+    let body_bytes = body.into_bytes();
+    if body_bytes.len() > AUCTION_MAX_BODY_BYTES {
+        return Err(Report::new(TrustedServerError::RequestTooLarge {
+            message: format!(
+                "auction payload {} exceeds limit of {}",
+                body_bytes.len(),
+                AUCTION_MAX_BODY_BYTES,
+            ),
+        }));
+    }
+    let body: AdRequest =
+        serde_json::from_slice(&body_bytes).change_context(TrustedServerError::Auction {
             message: "Failed to parse auction request body".to_string(),
-        },
-    )?;
+        })?;
 
     log::info!(
         "Auction request received for {} ad units",
         body.ad_units.len()
     );
 
-    let http_req = compat::from_fastly_headers_ref(&req);
+    let http_req = Request::from_parts(parts, EdgeBody::empty());
 
     // Generate EC ID early so the consent pipeline can use it for
     // KV Store fallback/write operations.
@@ -60,7 +74,7 @@ pub async fn handle_auction(
     let cookie_jar = handle_request_cookies(&http_req)?;
     let geo = services
         .geo()
-        .lookup(services.client_info.client_ip)
+        .lookup(services.client_info().client_ip)
         .unwrap_or_else(|e| {
             log::warn!("geo lookup failed: {e}");
             None
@@ -83,17 +97,20 @@ pub async fn handle_auction(
         &body,
         settings,
         services,
-        &req,
+        &http_req,
         consent_context,
         &ec_id,
         geo,
     )?;
 
+    // Body already parsed above; provider context only needs request metadata.
+    let fastly_req = compat::to_fastly_request_ref(&http_req);
+
     // Create auction context
     let context = AuctionContext {
         settings,
-        request: &req,
-        client_info: &services.client_info,
+        request: &fastly_req,
+        client_info: services.client_info(),
         timeout_ms: settings.auction.timeout_ms,
         provider_responses: None,
         services,
@@ -117,3 +134,36 @@ pub async fn handle_auction(
     // Convert to OpenRTB response format with inline creative HTML
     convert_to_openrtb_response(&result, settings, &auction_request)
 }
+
+#[cfg(test)]
+mod tests {
+    use edgezero_core::body::Body as EdgeBody;
+    use http::{Method, Request as HttpRequest, StatusCode};
+
+    use crate::auction::build_orchestrator;
+    use crate::error::IntoHttpResponse;
+    use crate::platform::test_support::noop_services;
+    use crate::test_support::tests::create_test_settings;
+
+    use super::*;
+
+    #[tokio::test]
+    async fn auction_rejects_oversized_body() {
+        let settings = create_test_settings();
+        let orchestrator = build_orchestrator(&settings).expect("should build orchestrator");
+        let oversized = vec![b'x'; AUCTION_MAX_BODY_BYTES + 1];
+        let req = HttpRequest::builder()
+            .method(Method::POST)
+            .uri("https://test.com/auction")
+            .body(EdgeBody::from(oversized))
+            .expect("should build request");
+        let err = handle_auction(&settings, &orchestrator, &noop_services(), req)
+            .await
+            .expect_err("should reject oversized body");
+        assert_eq!(
+            err.current_context().status_code(),
+            StatusCode::PAYLOAD_TOO_LARGE,
+            "should return 413 for auction body over limit"
+        );
+    }
+}