Polish community UI copy and cleanup

crates/crank-adapter-rest/src/client.rs

@@ -7,7 +7,7 @@ use reqwest::{
 };
 use serde_json::Value;
 
-use crate::{RestAdapterError, RestRequest, RestResponse, RestWindowRequest, RestWindowResponse};
+use crate::{RestAdapterError, RestRequest, RestResponse};
 
 #[derive(Clone, Debug)]
 pub struct RestAdapter {
@@ -62,61 +62,6 @@ impl RestAdapter {
             body,
         })
     }
-
-    pub async fn execute_window(
-        &self,
-        target: &RestTarget,
-        request: &RestWindowRequest,
-    ) -> Result<RestWindowResponse, RestAdapterError> {
-        let url = build_url(target, &request.request)?;
-        let mut headers = build_headers(target, &request.request)?;
-        headers.insert(
-            reqwest::header::ACCEPT,
-            HeaderValue::from_static("text/event-stream"),
-        );
-
-        let mut builder = self
-            .client
-            .request(to_reqwest_method(target.method), url)
-            .headers(headers)
-            .timeout(Duration::from_millis(request.request.timeout_ms));
-
-        if let Some(body) = &request.request.body {
-            builder = builder.json(body);
-        }
-
-        let response = builder.send().await?;
-        let status = response.status();
-
-        if !status.is_success() {
-            let headers = normalize_headers(response.headers());
-            let body = decode_body(response).await?;
-            return Err(RestAdapterError::UnexpectedStatus {
-                status: status.as_u16(),
-                body: Value::Object(
-                    [
-                        (
-                            "headers".to_owned(),
-                            serde_json::to_value(headers).unwrap_or(Value::Null),
-                        ),
-                        ("body".to_owned(), body),
-                    ]
-                    .into_iter()
-                    .collect(),
-                ),
-            });
-        }
-
-        let (status_code, headers, body) =
-            crate::sse::collect_sse_window(response, request.window_duration_ms, request.max_items)
-                .await?;
-
-        Ok(RestWindowResponse {
-            status_code,
-            headers,
-            body,
-        })
-    }
 }
 
 fn build_url(target: &RestTarget, request: &RestRequest) -> Result<reqwest::Url, RestAdapterError> {
@@ -227,15 +172,13 @@ mod tests {
         Json, Router,
         extract::{Path, Query},
         http::HeaderMap,
-        response::sse::{Event, KeepAlive, Sse},
         routing::{get, post},
     };
     use crank_core::{HttpMethod, RestTarget};
-    use futures_util::stream;
     use serde_json::{Value, json};
     use tokio::net::TcpListener;
 
-    use crate::{RestAdapter, RestAdapterError, RestRequest, RestWindowRequest};
+    use crate::{RestAdapter, RestAdapterError, RestRequest};
 
     #[tokio::test]
     async fn executes_rest_request_and_normalizes_json_response() {
@@ -299,104 +242,10 @@ mod tests {
         ));
     }
 
-    #[tokio::test]
-    async fn collects_sse_events_with_window_bounds() {
-        let base_url = spawn_test_server().await;
-        let adapter = RestAdapter::new();
-        let target = RestTarget {
-            base_url,
-            method: HttpMethod::Get,
-            path_template: "/events".to_owned(),
-            static_headers: BTreeMap::new(),
-        };
-        let request = RestWindowRequest {
-            request: RestRequest {
-                path_params: BTreeMap::new(),
-                query_params: BTreeMap::new(),
-                headers: BTreeMap::new(),
-                body: None,
-                timeout_ms: 1_000,
-            },
-            window_duration_ms: 1_000,
-            max_items: Some(2),
-        };
-
-        let response = adapter.execute_window(&target, &request).await.unwrap();
-
-        assert_eq!(response.status_code, 200);
-        assert_eq!(
-            response.body,
-            json!({
-                "items": [
-                    { "message": "one" },
-                    { "message": "two" }
-                ],
-                "done": false
-            })
-        );
-    }
-
-    #[tokio::test]
-    async fn returns_timeout_window_when_no_events_arrive_before_deadline() {
-        let base_url = spawn_test_server().await;
-        let adapter = RestAdapter::new();
-        let target = RestTarget {
-            base_url,
-            method: HttpMethod::Get,
-            path_template: "/events-idle".to_owned(),
-            static_headers: BTreeMap::new(),
-        };
-        let request = RestWindowRequest {
-            request: RestRequest {
-                path_params: BTreeMap::new(),
-                query_params: BTreeMap::new(),
-                headers: BTreeMap::new(),
-                body: None,
-                timeout_ms: 1_000,
-            },
-            window_duration_ms: 50,
-            max_items: Some(10),
-        };
-
-        let response = adapter.execute_window(&target, &request).await.unwrap();
-
-        assert_eq!(response.body, json!({ "items": [], "done": true }));
-    }
-
-    #[tokio::test]
-    async fn rejects_malformed_sse_payloads() {
-        let base_url = spawn_test_server().await;
-        let adapter = RestAdapter::new();
-        let target = RestTarget {
-            base_url,
-            method: HttpMethod::Get,
-            path_template: "/events-broken".to_owned(),
-            static_headers: BTreeMap::new(),
-        };
-        let request = RestWindowRequest {
-            request: RestRequest {
-                path_params: BTreeMap::new(),
-                query_params: BTreeMap::new(),
-                headers: BTreeMap::new(),
-                body: None,
-                timeout_ms: 1_000,
-            },
-            window_duration_ms: 1_000,
-            max_items: Some(10),
-        };
-
-        let error = adapter.execute_window(&target, &request).await.unwrap_err();
-
-        assert!(matches!(error, RestAdapterError::InvalidSseEvent));
-    }
-
     async fn spawn_test_server() -> String {
         let app = Router::new()
             .route("/users/{user_id}", post(create_user))
-            .route("/fail", get(fail))
-            .route("/events", get(sse_events))
-            .route("/events-idle", get(sse_idle))
-            .route("/events-broken", get(sse_broken));
+            .route("/fail", get(fail));
         let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
         let address = listener.local_addr().unwrap();
 
@@ -437,27 +286,4 @@ mod tests {
             Json(json!({ "error": "upstream failed" })),
         )
     }
-
-    async fn sse_events()
-    -> Sse<impl futures_util::Stream<Item = Result<Event, std::convert::Infallible>>> {
-        let events = vec![
-            Ok(Event::default().data("{\"message\":\"one\"}")),
-            Ok(Event::default().data("{\"message\":\"two\"}")),
-            Ok(Event::default().data("{\"message\":\"three\"}")),
-        ];
-
-        Sse::new(stream::iter(events)).keep_alive(KeepAlive::default())
-    }
-
-    async fn sse_idle()
-    -> Sse<impl futures_util::Stream<Item = Result<Event, std::convert::Infallible>>> {
-        Sse::new(stream::pending()).keep_alive(KeepAlive::default())
-    }
-
-    async fn sse_broken()
-    -> Sse<impl futures_util::Stream<Item = Result<Event, std::convert::Infallible>>> {
-        let events = vec![Ok(Event::default().data("{broken-json}"))];
-
-        Sse::new(stream::iter(events)).keep_alive(KeepAlive::default())
-    }
 }