Polish community UI copy and cleanup

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

@@ -1,18 +1,16 @@
 mod client;
 mod error;
 mod model;
-mod sse;
 
 use async_trait::async_trait;
 use crank_core::{
     AdapterResponse, ExecutionMode, PreparedRequest, Protocol, ProtocolAdapter,
-    ProtocolAdapterError, RestTarget, RuntimeRequestContext, Target, WindowExecutionResult,
+    ProtocolAdapterError, RestTarget, RuntimeRequestContext, Target,
 };
-use serde_json::{Map, Value};
 
 pub use client::RestAdapter;
 pub use error::RestAdapterError;
-pub use model::{RestRequest, RestResponse, RestWindowRequest, RestWindowResponse};
+pub use model::{RestRequest, RestResponse};
 
 #[async_trait]
 impl ProtocolAdapter for RestAdapter {
@@ -21,7 +19,7 @@ impl ProtocolAdapter for RestAdapter {
     }
 
     fn supports_mode(&self, mode: ExecutionMode) -> bool {
-        matches!(mode, ExecutionMode::Unary | ExecutionMode::Window)
+        matches!(mode, ExecutionMode::Unary)
     }
 
     async fn invoke_unary(
@@ -47,72 +45,11 @@ impl ProtocolAdapter for RestAdapter {
             body: response.body,
         })
     }
-
-    async fn invoke_window(
-        &self,
-        target: &Target,
-        prepared: &PreparedRequest,
-        window_duration_ms: u64,
-        max_items: Option<u32>,
-        _context: &RuntimeRequestContext,
-    ) -> Result<WindowExecutionResult, ProtocolAdapterError> {
-        let target = rest_target(target)?;
-        let request = RestWindowRequest {
-            request: RestRequest {
-                path_params: prepared.path_params.clone(),
-                query_params: prepared.query_params.clone(),
-                headers: prepared.headers.clone(),
-                body: prepared.body.clone(),
-                timeout_ms: prepared.timeout_ms,
-            },
-            window_duration_ms,
-            max_items: max_items.map(|value| value.saturating_add(1)),
-        };
-        let response = self.execute_window(target, &request).await?;
-        Ok(window_result_from_response(response.body, max_items))
-    }
 }
 
 fn rest_target(target: &Target) -> Result<&RestTarget, ProtocolAdapterError> {
     match target {
         Target::Rest(target) => Ok(target),
-        other => Err(ProtocolAdapterError::Message(format!(
-            "rest adapter cannot handle target {other:?}"
-        ))),
-    }
-}
-
-fn window_result_from_response(body: Value, max_items: Option<u32>) -> WindowExecutionResult {
-    let done = body.get("done").and_then(Value::as_bool).unwrap_or(true);
-    let mut items = body
-        .get("items")
-        .and_then(Value::as_array)
-        .cloned()
-        .unwrap_or_default();
-    let mut truncated = false;
-    let mut has_more = !done;
-
-    if let Some(max_items) = max_items.map(|value| value as usize) {
-        if items.len() > max_items {
-            items.truncate(max_items);
-            truncated = true;
-            has_more = true;
-        }
-    }
-
-    let summary = body
-        .get("summary")
-        .cloned()
-        .unwrap_or_else(|| Value::Object(Map::new()));
-    let cursor = body.get("cursor").cloned();
-
-    WindowExecutionResult {
-        summary,
-        items,
-        cursor,
-        window_complete: !has_more,
-        truncated,
-        has_more,
     }
 }