Add PlatformHttpClient and PlatformBackend traits (EdgeZero PR6)

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

@@ -161,16 +161,20 @@ async fn route_request(
         }
 
         // tsjs endpoints
-        (Method::GET, "/first-party/proxy") => handle_first_party_proxy(settings, req).await,
-        (Method::GET, "/first-party/click") => handle_first_party_click(settings, req).await,
+        (Method::GET, "/first-party/proxy") => {
+            handle_first_party_proxy(settings, runtime_services, req).await
+        }
+        (Method::GET, "/first-party/click") => {
+            handle_first_party_click(settings, runtime_services, req).await
+        }
         (Method::GET, "/first-party/sign") | (Method::POST, "/first-party/sign") => {
-            handle_first_party_proxy_sign(settings, req).await
+            handle_first_party_proxy_sign(settings, runtime_services, req).await
         }
         (Method::POST, "/first-party/proxy-rebuild") => {
-            handle_first_party_proxy_rebuild(settings, req).await
+            handle_first_party_proxy_rebuild(settings, runtime_services, req).await
         }
         (m, path) if integration_registry.has_route(&m, path) => integration_registry
-            .handle_proxy(&m, path, settings, req)
+            .handle_proxy(&m, path, settings, runtime_services, req)
             .await
             .unwrap_or_else(|| {
                 Err(Report::new(TrustedServerError::BadRequest {

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

@@ -187,45 +187,175 @@ impl PlatformBackend for FastlyPlatformBackend {
 }
 
 // ---------------------------------------------------------------------------
-// FastlyPlatformHttpClient
+// FastlyPlatformHttpClient — helpers
 // ---------------------------------------------------------------------------
 
-/// Placeholder Fastly implementation of [`PlatformHttpClient`].
+/// Convert a platform-neutral [`EdgeRequest`] to a [`fastly::Request`].
 ///
-/// The Fastly-backed `send` / `send_async` / `select` behavior lands in a
-/// follow-up PR once the orchestrator migration is complete. Until then all
-/// methods return [`PlatformError::Unsupported`].
+/// Only `Body::Once` bodies are forwarded; `Body::Stream` bodies are not
+/// used on this path (proxy.rs builds bodies from byte slices).
+fn edge_request_to_fastly(request: edgezero_core::http::Request) -> fastly::Request {
+    let (parts, body) = request.into_parts();
+    let mut fastly_req = fastly::Request::new(parts.method, parts.uri.to_string());
+    for (name, value) in parts.headers.iter() {
+        fastly_req.set_header(name.as_str(), value.as_bytes());
+    }
+    // Only Body::Once is supported. Body::Stream is intentionally not forwarded
+    // because all outbound proxy bodies are built from Vec<u8> via EdgeBody::from()
+    // and are therefore always Once. When this conversion moves to edgezero-adapter-fastly
+    // it can use send_async_streaming() to handle Stream bodies properly.
+    debug_assert!(
+        matches!(&body, edgezero_core::body::Body::Once(_)),
+        "unexpected Body::Stream in edge_request_to_fastly: body will be empty"
+    );
+    if let edgezero_core::body::Body::Once(bytes) = body {
+        if !bytes.is_empty() {
+            fastly_req.set_body(bytes.to_vec());
+        }
+    } else {
+        log::warn!("edge_request_to_fastly: Body::Stream not supported; body will be empty");
+    }
+    fastly_req
+}
+
+/// Convert a [`fastly::Response`] to a [`PlatformResponse`] with the given backend name.
+fn fastly_response_to_platform(
+    mut resp: fastly::Response,
+    backend_name: impl Into<String>,
+) -> Result<PlatformResponse, Report<PlatformError>> {
+    let status = resp.get_status();
+    let mut builder = edgezero_core::http::response_builder().status(status);
+    for (name, value) in resp.get_headers() {
+        builder = builder.header(name.as_str(), value.as_bytes());
+    }
+    let body_bytes = resp.take_body_bytes();
+    let edge_response = builder
+        .body(edgezero_core::body::Body::from(body_bytes))
+        .change_context(PlatformError::HttpClient)?;
+    Ok(PlatformResponse::new(edge_response).with_backend_name(backend_name))
+}
+
+// ---------------------------------------------------------------------------
+// FastlyPlatformHttpClient
+// ---------------------------------------------------------------------------
+
+/// Fastly implementation of [`PlatformHttpClient`].
 ///
-/// Implementation lands in #487 (PR 6: Backend + HTTP client traits).
+/// - [`send`](PlatformHttpClient::send) — converts the platform request to a
+///   `fastly::Request`, calls `.send()`, and wraps the response.
+/// - [`send_async`](PlatformHttpClient::send_async) — same conversion but
+///   calls `.send_async()` and wraps the `fastly::PendingRequest`.
+/// - [`select`](PlatformHttpClient::select) — downcasts each
+///   [`PlatformPendingRequest`] back to `fastly::PendingRequest` and calls
+///   `fastly::http::request::select()`.
 pub struct FastlyPlatformHttpClient;
 
 #[async_trait::async_trait(?Send)]
 impl PlatformHttpClient for FastlyPlatformHttpClient {
     async fn send(
         &self,
-        _request: PlatformHttpRequest,
+        request: PlatformHttpRequest,
     ) -> Result<PlatformResponse, Report<PlatformError>> {
-        log::warn!("FastlyPlatformHttpClient::send called before #487 lands");
-        Err(Report::new(PlatformError::Unsupported)
-            .attach("FastlyPlatformHttpClient::send is not yet implemented"))
+        let backend_name = request.backend_name.clone();
+        let fastly_req = edge_request_to_fastly(request.request);
+        let fastly_resp = fastly_req
+            .send(&backend_name)
+            .change_context(PlatformError::HttpClient)?;
+        fastly_response_to_platform(fastly_resp, backend_name)
     }
 
     async fn send_async(
         &self,
-        _request: PlatformHttpRequest,
+        request: PlatformHttpRequest,
     ) -> Result<PlatformPendingRequest, Report<PlatformError>> {
-        log::warn!("FastlyPlatformHttpClient::send_async called before #487 lands");
-        Err(Report::new(PlatformError::Unsupported)
-            .attach("FastlyPlatformHttpClient::send_async is not yet implemented"))
+        let backend_name = request.backend_name.clone();
+        let fastly_req = edge_request_to_fastly(request.request);
+        let pending = fastly_req
+            .send_async(&backend_name)
+            .change_context(PlatformError::HttpClient)?;
+        Ok(PlatformPendingRequest::new(pending).with_backend_name(backend_name))
     }
 
     async fn select(
         &self,
-        _pending_requests: Vec<PlatformPendingRequest>,
+        pending_requests: Vec<PlatformPendingRequest>,
     ) -> Result<PlatformSelectResult, Report<PlatformError>> {
-        log::warn!("FastlyPlatformHttpClient::select called before #487 lands");
-        Err(Report::new(PlatformError::Unsupported)
-            .attach("FastlyPlatformHttpClient::select is not yet implemented"))
+        use fastly::http::request::{select, PendingRequest};
+
+        if pending_requests.is_empty() {
+            return Err(Report::new(PlatformError::HttpClient)
+                .attach("select called with an empty pending_requests list"));
+        }
+
+        let mut fastly_pending: Vec<PendingRequest> = Vec::with_capacity(pending_requests.len());
+        let mut saved_names: Vec<String> = Vec::with_capacity(pending_requests.len());
+
+        for platform_req in pending_requests {
+            let name = platform_req.backend_name().unwrap_or("").to_string();
+            let inner = platform_req.downcast::<PendingRequest>().map_err(|_| {
+                Report::new(PlatformError::HttpClient)
+                    .attach("PlatformPendingRequest inner type is not fastly::PendingRequest")
+            })?;
+            fastly_pending.push(inner);
+            saved_names.push(name);
+        }
+
+        let (result, remaining_fastly) = select(fastly_pending);
+
+        // Re-attach saved backend names to the remaining pending requests.
+        // Identify which request completed by matching the response backend name
+        // to the saved names, then skip that index when rebuilding remaining.
+        let completed_name = match &result {
+            Ok(resp) => resp.get_backend_name().map(str::to_string),
+            Err(_) => None,
+        };
+        let completed_idx = completed_name
+            .as_deref()
+            .and_then(|name| saved_names.iter().position(|n| n == name));
+        if completed_name.is_some() && completed_idx.is_none() {
+            log::warn!(
+                "select: completed backend name not found in saved names; \
+                 remaining requests will lose backend correlation"
+            );
+        }
+
+        let remaining: Vec<PlatformPendingRequest> = if let Some(idx) = completed_idx {
+            remaining_fastly
+                .into_iter()
+                .zip(
+                    saved_names
+                        .into_iter()
+                        .enumerate()
+                        .filter(|(i, _)| *i != idx)
+                        .map(|(_, name)| name),
+                )
+                .map(|(req, name)| PlatformPendingRequest::new(req).with_backend_name(name))
+                .collect()
+        } else {
+            remaining_fastly
+                .into_iter()
+                .map(PlatformPendingRequest::new)
+                .collect()
+        };
+
+        let ready = match result {
+            Ok(fastly_resp) => {
+                let backend_name = fastly_resp
+                    .get_backend_name()
+                    .unwrap_or_else(|| {
+                        log::warn!("select: response has no backend name, correlation will fail");
+                        ""
+                    })
+                    .to_string();
+                fastly_response_to_platform(fastly_resp, backend_name)
+            }
+            Err(e) => {
+                Err(Report::new(PlatformError::HttpClient)
+                    .attach(format!("fastly select error: {e}")))
+            }
+        };
+
+        Ok(PlatformSelectResult { ready, remaining })
     }
 }
 
@@ -299,6 +429,8 @@ mod tests {
     use std::sync::Arc;
     use std::time::Duration;
 
+    use edgezero_core::body::Body;
+    use edgezero_core::http::request_builder;
     use edgezero_core::key_value_store::NoopKvStore;
 
     use super::*;
@@ -417,4 +549,74 @@ mod tests {
             "should preserve client_ip through clone"
         );
     }
+
+    // --- FastlyPlatformHttpClient -------------------------------------------
+
+    #[test]
+    fn fastly_platform_http_client_send_returns_error_for_unregistered_backend() {
+        let client = FastlyPlatformHttpClient;
+        let request = request_builder()
+            .method("GET")
+            .uri("https://example.com/")
+            .body(Body::empty())
+            .expect("should build test request");
+        let err = futures::executor::block_on(
+            client.send(PlatformHttpRequest::new(request, "nonexistent-backend")),
+        )
+        .expect_err("should return error for unregistered backend");
+
+        assert!(
+            matches!(err.current_context(), &PlatformError::HttpClient),
+            "should be HttpClient error, got: {:?}",
+            err.current_context()
+        );
+    }
+
+    #[test]
+    fn fastly_platform_http_client_send_async_returns_error_for_unregistered_backend() {
+        let client = FastlyPlatformHttpClient;
+        let request = request_builder()
+            .method("GET")
+            .uri("https://example.com/")
+            .body(Body::empty())
+            .expect("should build test request");
+        let err = futures::executor::block_on(
+            client.send_async(PlatformHttpRequest::new(request, "nonexistent-backend")),
+        )
+        .expect_err("should return error for unregistered backend");
+
+        assert!(
+            matches!(err.current_context(), &PlatformError::HttpClient),
+            "should be HttpClient error, got: {:?}",
+            err.current_context()
+        );
+    }
+
+    #[test]
+    fn fastly_platform_http_client_select_returns_error_for_empty_list() {
+        let client = FastlyPlatformHttpClient;
+        let err = futures::executor::block_on(client.select(vec![]))
+            .expect_err("should return error for empty pending list");
+
+        assert!(
+            matches!(err.current_context(), &PlatformError::HttpClient),
+            "should be HttpClient error, got: {:?}",
+            err.current_context()
+        );
+    }
+
+    #[test]
+    fn fastly_platform_http_client_select_returns_error_for_wrong_inner_type() {
+        let client = FastlyPlatformHttpClient;
+        // Wrap a non-PendingRequest type to trigger the downcast failure.
+        let wrong = PlatformPendingRequest::new(42u32);
+        let err = futures::executor::block_on(client.select(vec![wrong]))
+            .expect_err("should return error for wrong inner type");
+
+        assert!(
+            matches!(err.current_context(), &PlatformError::HttpClient),
+            "should be HttpClient error, got: {:?}",
+            err.current_context()
+        );
+    }
 }

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

@@ -85,7 +85,7 @@ pub async fn handle_auction(
 
     // Run the auction
     let result = orchestrator
-        .run_auction(&auction_request, &context)
+        .run_auction(&auction_request, &context, runtime_services)
         .await
         .change_context(TrustedServerError::Auction {
             message: "Auction orchestration failed".to_string(),