app_bridge 3.0.0 → 4.1.0

data/ext/app_bridge/src/request_builder.rs

@@ -1,178 +1,338 @@
 use crate::app_state::AppState;
-use crate::component::standout::app::http::{
-    HostRequestBuilder, Method, Request, RequestBuilder, RequestError, Response,
-};
+use crate::component::{v3, v4, v4_1};
+use crate::component::v4::standout::app::http::{Method, Request, RequestError, Response};
 use reqwest::Method as ReqwestMethod;
 use std::result::Result::Ok;
 use wasmtime::component::Resource;
 
-impl HostRequestBuilder for AppState {
-    fn new(&mut self) -> Resource<RequestBuilder> {
-        let id = self.next_request_id;
-        self.next_request_id += 1;
-        self.request_list.insert(id, Request::default());
-        Resource::new_own(id)
-    }
+// ============================================================================
+// Macro to implement HostRequestBuilder for any version
+//
+// When adding a new version, just add:
+//   impl_host_request_builder!(v5);
+//   impl_http_type_conversions!(v5);
+// ============================================================================
 
-    fn method(
-        &mut self,
-        self_: Resource<RequestBuilder>,
-        method: Method,
-    ) -> Resource<RequestBuilder> {
-        let id = self_.rep();
-        let mut request = self.request_list.get(&id).cloned().unwrap();
-        request.method = method;
-        let new_id = self.next_request_id;
-        self.next_request_id += 1;
-        self.request_list.insert(new_id, request);
-        Resource::new_own(new_id)
-    }
+macro_rules! impl_host_request_builder {
+    ($v:ident, $has_body_bytes:ident) => {
+        impl $v::standout::app::http::HostRequestBuilder for AppState {
+            fn new(&mut self) -> Resource<$v::standout::app::http::RequestBuilder> {
+                let id = self.next_request_id;
+                self.next_request_id += 1;
+                self.request_list.insert(id, Request::default());
+                Resource::new_own(id)
+            }
 
-    fn url(
-        &mut self,
-        self_: Resource<RequestBuilder>,
-        url: wasmtime::component::__internal::String,
-    ) -> Resource<RequestBuilder> {
-        let id = self_.rep();
-        let mut request = self.request_list.get(&id).cloned().unwrap();
-        request.url = url;
-        let new_id = self.next_request_id;
-        self.next_request_id += 1;
-        self.request_list.insert(new_id, request);
-        Resource::new_own(new_id)
-    }
+            fn method(
+                &mut self,
+                self_: Resource<$v::standout::app::http::RequestBuilder>,
+                method: $v::standout::app::http::Method,
+            ) -> Resource<$v::standout::app::http::RequestBuilder> {
+                let id = self_.rep();
+                if let Some(mut request) = self.request_list.get(&id).cloned() {
+                    request.method = method.into();
+                    let new_id = self.next_request_id;
+                    self.next_request_id += 1;
+                    self.request_list.insert(new_id, request);
+                    if let Some(bytes) = self.request_body_bytes.get(&id).cloned() {
+                        self.request_body_bytes.insert(new_id, bytes);
+                    }
+                    Resource::new_own(new_id)
+                } else {
+                    Resource::new_own(id)
+                }
+            }
 
-    #[doc = " Add a header to the request"]
-    fn header(
-        &mut self,
-        self_: Resource<RequestBuilder>,
-        key: wasmtime::component::__internal::String,
-        value: wasmtime::component::__internal::String,
-    ) -> Resource<RequestBuilder> {
-        let id = self_.rep();
-        let mut request = self.request_list.get(&id).cloned().unwrap_or_default();
-        request.headers.push((key, value));
-        let new_id = self.next_request_id;
-        self.next_request_id += 1;
-        self.request_list.insert(new_id, request);
-        Resource::new_own(new_id)
-    }
+            fn url(
+                &mut self,
+                self_: Resource<$v::standout::app::http::RequestBuilder>,
+                url: String,
+            ) -> Resource<$v::standout::app::http::RequestBuilder> {
+                let id = self_.rep();
+                if let Some(mut request) = self.request_list.get(&id).cloned() {
+                    request.url = url;
+                    let new_id = self.next_request_id;
+                    self.next_request_id += 1;
+                    self.request_list.insert(new_id, request);
+                    if let Some(bytes) = self.request_body_bytes.get(&id).cloned() {
+                        self.request_body_bytes.insert(new_id, bytes);
+                    }
+                    Resource::new_own(new_id)
+                } else {
+                    Resource::new_own(id)
+                }
+            }
+
+            fn header(
+                &mut self,
+                self_: Resource<$v::standout::app::http::RequestBuilder>,
+                key: String,
+                value: String,
+            ) -> Resource<$v::standout::app::http::RequestBuilder> {
+                let id = self_.rep();
+                let mut request = self.request_list.get(&id).cloned().unwrap_or_default();
+                request.headers.push((key, value));
+                let new_id = self.next_request_id;
+                self.next_request_id += 1;
+                self.request_list.insert(new_id, request);
+                if let Some(bytes) = self.request_body_bytes.get(&id).cloned() {
+                    self.request_body_bytes.insert(new_id, bytes);
+                }
+                Resource::new_own(new_id)
+            }
+
+            fn headers(
+                &mut self,
+                self_: Resource<$v::standout::app::http::RequestBuilder>,
+                headers: Vec<(String, String)>,
+            ) -> Resource<$v::standout::app::http::RequestBuilder> {
+                let id = self_.rep();
+                let mut request = self.request_list.get(&id).cloned().unwrap_or_default();
+                request.headers.extend(headers);
+                let new_id = self.next_request_id;
+                self.next_request_id += 1;
+                self.request_list.insert(new_id, request);
+                if let Some(bytes) = self.request_body_bytes.get(&id).cloned() {
+                    self.request_body_bytes.insert(new_id, bytes);
+                }
+                Resource::new_own(new_id)
+            }
+
+            fn body(
+                &mut self,
+                self_: Resource<$v::standout::app::http::RequestBuilder>,
+                body: String,
+            ) -> Resource<$v::standout::app::http::RequestBuilder> {
+                let id = self_.rep();
+                let mut request = self.request_list.get(&id).cloned().unwrap_or_default();
+                request.body = body;
+                let new_id = self.next_request_id;
+                self.next_request_id += 1;
+                self.request_list.insert(new_id, request);
+                self.request_body_bytes.remove(&new_id);
+                Resource::new_own(new_id)
+            }
+
+            fn send(
+                &mut self,
+                self_: Resource<$v::standout::app::http::RequestBuilder>,
+            ) -> Result<$v::standout::app::http::Response, $v::standout::app::http::RequestError> {
+                let id = self_.rep();
+                match self.request_list.get(&id).cloned() {
+                    Some(request) => {
+                        let body_bytes = self.request_body_bytes.get(&id).map(|b| b.as_slice());
+                        send_request(&self.client, &request, body_bytes)
+                            .map(Into::into)
+                            .map_err(Into::into)
+                    }
+                    None => Err($v::standout::app::http::RequestError::Other(
+                        "Request not found".to_string(),
+                    )),
+                }
+            }
 
-    fn headers(
-        &mut self,
-        self_: Resource<RequestBuilder>,
-        headers: wasmtime::component::__internal::Vec<(
-            wasmtime::component::__internal::String,
-            wasmtime::component::__internal::String,
-        )>,
-    ) -> Resource<RequestBuilder> {
-        let id = self_.rep();
-        let mut request = self.request_list.get(&id).cloned().unwrap_or_default();
-        for (key, value) in headers {
-            request.headers.push((key, value));
+            fn drop(
+                &mut self,
+                rep: Resource<$v::standout::app::http::RequestBuilder>,
+            ) -> wasmtime::Result<()> {
+                self.request_list.remove(&rep.rep());
+                self.request_body_bytes.remove(&rep.rep());
+                Ok(())
+            }
+
+            fn object(
+                &mut self,
+                self_: Resource<$v::standout::app::http::RequestBuilder>,
+            ) -> $v::standout::app::http::Request {
+                self.request_list
+                    .get(&self_.rep())
+                    .cloned()
+                    .unwrap_or_default()
+                    .into()
+            }
+
+            impl_host_request_builder_body_bytes!($v, $has_body_bytes);
         }
-        let new_id = self.next_request_id;
-        self.next_request_id += 1;
-        self.request_list.insert(new_id, request);
-        Resource::new_own(new_id)
-    }
+    };
+}
+
+macro_rules! impl_host_request_builder_body_bytes {
+    ($v:ident, yes) => {
+        fn body_bytes(
+            &mut self,
+            self_: Resource<$v::standout::app::http::RequestBuilder>,
+            body: Vec<u8>,
+        ) -> Resource<$v::standout::app::http::RequestBuilder> {
+            let id = self_.rep();
+            let mut request = self.request_list.get(&id).cloned().unwrap_or_default();
+            request.body.clear();
+            let new_id = self.next_request_id;
+            self.next_request_id += 1;
+            self.request_list.insert(new_id, request);
+            self.request_body_bytes.insert(new_id, body);
+            Resource::new_own(new_id)
+        }
+    };
+    ($v:ident, no) => {};
+}
 
-    #[doc = " Add a body to the request"]
-    fn body(
-        &mut self,
-        self_: Resource<RequestBuilder>,
-        body: wasmtime::component::__internal::String,
-    ) -> Resource<RequestBuilder> {
-        let id = self_.rep();
-        let mut request = self.request_list.get(&id).cloned().unwrap_or_default();
-        request.body = body;
-        let new_id = self.next_request_id;
-        self.next_request_id += 1;
-        self.request_list.insert(new_id, request);
-        Resource::new_own(new_id)
-    }
 
-    #[doc = " Send the request"]
-    fn send(&mut self, self_: Resource<RequestBuilder>) -> Result<Response, RequestError> {
-        let id = self_.rep();
-        let request = match self.request_list.get(&id).cloned() {
-            Some(request) => request,
-            None => return Err(RequestError::Other("Request not found".to_string())),
-        };
-        let client = self.client.lock().unwrap();
-        let mut request_builder = client.request(request.method.into(), &request.url);
-        for (key, value) in request.headers {
-            request_builder = request_builder.header(key, value);
+// ============================================================================
+// Macro to implement HTTP type conversions for a version
+// ============================================================================
+
+macro_rules! impl_http_type_conversions {
+    ($v:ident) => {
+        impl From<$v::standout::app::http::Method> for Method {
+            fn from(m: $v::standout::app::http::Method) -> Self {
+                use $v::standout::app::http::Method as V;
+                match m {
+                    V::Get => Self::Get,
+                    V::Post => Self::Post,
+                    V::Put => Self::Put,
+                    V::Delete => Self::Delete,
+                    V::Patch => Self::Patch,
+                    V::Options => Self::Options,
+                    V::Head => Self::Head,
+                }
+            }
         }
-        request_builder = request_builder.body(request.body);
-
-        let response = request_builder.send();
-
-        match response {
-            Ok(resp) => {
-                let mut response = Response::default();
-                response.status = resp.status().as_u16();
-                for (key, value) in resp.headers() {
-                    response.headers.push((
-                        key.as_str().to_string(),
-                        value.to_str().unwrap_or_default().to_string(),
-                    ));
+
+        impl From<Method> for $v::standout::app::http::Method {
+            fn from(m: Method) -> Self {
+                match m {
+                    Method::Get => Self::Get,
+                    Method::Post => Self::Post,
+                    Method::Put => Self::Put,
+                    Method::Delete => Self::Delete,
+                    Method::Patch => Self::Patch,
+                    Method::Options => Self::Options,
+                    Method::Head => Self::Head,
                 }
-                response.body = resp.text().unwrap_or_default();
-                Ok(response)
             }
-            Err(error) => {
-                let error_message = format!(
-                    "Request failed to {} {}: {}",
-                    request.method,
-                    request.url,
-                    error
-                );
-                let error = RequestError::Other(error_message);
-                Err(error)
+        }
+
+        impl From<Response> for $v::standout::app::http::Response {
+            fn from(r: Response) -> Self {
+                Self {
+                    status: r.status,
+                    headers: r.headers,
+                    body: r.body,
+                }
             }
         }
-    }
 
-    fn drop(&mut self, rep: Resource<RequestBuilder>) -> wasmtime::Result<()> {
-        let id = rep.rep();
-        self.request_list.remove(&id);
-        Ok(())
+        impl From<Request> for $v::standout::app::http::Request {
+            fn from(r: Request) -> Self {
+                Self {
+                    method: r.method.into(),
+                    url: r.url,
+                    headers: r.headers,
+                    body: r.body,
+                }
+            }
+        }
+
+        impl From<RequestError> for $v::standout::app::http::RequestError {
+            fn from(e: RequestError) -> Self {
+                match e {
+                    RequestError::Other(msg) => Self::Other(msg),
+                }
+            }
+        }
+    };
+}
+
+// ============================================================================
+// Generate implementations for all supported versions
+// When adding v5, just add:
+//   impl_host_request_builder!(v5);
+//   impl_http_type_conversions!(v5);
+// ============================================================================
+
+impl_host_request_builder!(v3, no);
+impl_host_request_builder!(v4, no);
+impl_host_request_builder!(v4_1, yes);
+
+impl_http_type_conversions!(v3);
+// Note: v4 doesn't need conversions since we use v4 types as the canonical internal types
+impl_http_type_conversions!(v4_1);
+
+// ============================================================================
+// Shared request sending logic
+// ============================================================================
+
+fn send_request(
+    client: &std::sync::Arc<std::sync::Mutex<reqwest::blocking::Client>>,
+    request: &Request,
+    body_bytes: Option<&[u8]>,
+) -> Result<Response, RequestError> {
+    let client = client.lock().unwrap();
+    let mut builder = client.request(request.method.clone().into(), &request.url);
+
+    for (key, value) in &request.headers {
+        builder = builder.header(key, value);
     }
+    builder = if let Some(bytes) = body_bytes {
+        builder.body(bytes.to_vec())
+    } else {
+        builder.body(request.body.clone())
+    };
 
-    fn object(&mut self, self_: Resource<RequestBuilder>) -> Request {
-        let id = self_.rep();
-        self.request_list.get(&id).cloned().unwrap_or_default()
+    match builder.send() {
+        Ok(resp) => {
+            let headers = resp
+                .headers()
+                .iter()
+                .map(|(k, v)| {
+                    (
+                        k.as_str().to_string(),
+                        v.to_str().unwrap_or_default().to_string(),
+                    )
+                })
+                .collect();
+
+            Ok(Response {
+                status: resp.status().as_u16(),
+                headers,
+                body: resp.text().unwrap_or_default(),
+            })
+        }
+        Err(error) => Err(RequestError::Other(format!(
+            "Request failed to {} {}: {}",
+            request.method, request.url, error
+        ))),
     }
 }
 
+// ============================================================================
+// Standard type implementations (used by all versions)
+// ============================================================================
+
 impl From<Method> for ReqwestMethod {
     fn from(method: Method) -> Self {
         match method {
-            Method::Get => ReqwestMethod::GET,
-            Method::Post => ReqwestMethod::POST,
-            Method::Put => ReqwestMethod::PUT,
-            Method::Delete => ReqwestMethod::DELETE,
-            Method::Patch => ReqwestMethod::PATCH,
-            Method::Head => ReqwestMethod::HEAD,
-            Method::Options => ReqwestMethod::OPTIONS,
+            Method::Get => Self::GET,
+            Method::Post => Self::POST,
+            Method::Put => Self::PUT,
+            Method::Delete => Self::DELETE,
+            Method::Patch => Self::PATCH,
+            Method::Head => Self::HEAD,
+            Method::Options => Self::OPTIONS,
         }
     }
 }
 
 impl Default for Request {
     fn default() -> Self {
-        let version = env!("CARGO_PKG_VERSION");
-        let user_agent = format!("Standout-AppBridge/{version}");
-        let headers = vec![
-            ("User-Agent".to_string(), user_agent.into()),
-        ];
-
         Self {
-            url: "".to_string(),
+            url: String::new(),
             method: Method::Get,
-            body: "".to_string(),
-            headers,
+            body: String::new(),
+            headers: vec![(
+                "User-Agent".to_string(),
+                format!("Standout-AppBridge/{}", env!("CARGO_PKG_VERSION")),
+            )],
         }
     }
 }
@@ -182,33 +342,38 @@ impl Default for Response {
         Self {
             status: 0,
             headers: Vec::new(),
-            body: "".to_string(),
+            body: String::new(),
         }
     }
 }
 
 impl std::fmt::Display for Method {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Method::Get => write!(f, "GET"),
-            Method::Post => write!(f, "POST"),
-            Method::Put => write!(f, "PUT"),
-            Method::Delete => write!(f, "DELETE"),
-            Method::Patch => write!(f, "PATCH"),
-            Method::Head => write!(f, "HEAD"),
-            Method::Options => write!(f, "OPTIONS"),
-        }
+        f.write_str(match self {
+            Self::Get => "GET",
+            Self::Post => "POST",
+            Self::Put => "PUT",
+            Self::Delete => "DELETE",
+            Self::Patch => "PATCH",
+            Self::Head => "HEAD",
+            Self::Options => "OPTIONS",
+        })
     }
 }
 
+// ============================================================================
+// Tests
+// ============================================================================
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use httpmock::{MockServer, Method::GET};
+    use httpmock::{Method::GET, Method::POST, MockServer};
 
     #[test]
     fn sends_request_with_default_user_agent() {
+        use v4::standout::app::http::HostRequestBuilder;
+
         let version = env!("CARGO_PKG_VERSION");
         let user_agent = format!("Standout-AppBridge/{version}");
 
@@ -231,4 +396,30 @@ mod tests {
         assert_eq!(response.status, 200);
         mock.assert();
     }
+
+    #[test]
+    fn sends_binary_body_when_bytes_present() {
+        use v4_1::standout::app::http::HostRequestBuilder;
+
+        let server = MockServer::start();
+        let mock = server.mock(|when, then| {
+            when.method(POST)
+                .path("/upload")
+                .body("raw-bytes");
+            then.status(200);
+        });
+        let url = format!("{}/upload", server.base_url());
+
+        let mut app_state = AppState::default();
+        let builder = app_state.new();
+        let builder = app_state.method(builder, v4_1::standout::app::http::Method::Post);
+        let builder = app_state.url(builder, url);
+        let builder = app_state.body(builder, "string-body".to_string());
+        let builder = app_state.body_bytes(builder, b"raw-bytes".to_vec());
+
+        let response = app_state.send(builder).expect("Request failed");
+
+        assert_eq!(response.status, 200);
+        mock.assert();
+    }
 }

data/ext/app_bridge/src/types.rs

@@ -0,0 +1,95 @@
+//! Canonical types used internally by the bridge.
+//!
+//! These are version-agnostic and converted to/from versioned WIT types at the boundary.
+
+use std::fmt;
+
+// ============================================================================
+// Canonical Types - used throughout the codebase, not tied to any version
+// ============================================================================
+
+#[derive(Debug, Clone)]
+pub struct AppError {
+    pub code: ErrorCode,
+    pub message: String,
+}
+
+impl AppError {
+    pub fn new(code: ErrorCode, message: impl Into<String>) -> Self {
+        Self {
+            code,
+            message: message.into(),
+        }
+    }
+}
+
+impl fmt::Display for AppError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}: {}", self.code, self.message)
+    }
+}
+
+impl std::error::Error for AppError {}
+
+#[derive(Debug, Clone)]
+pub enum ErrorCode {
+    Unauthenticated,
+    Forbidden,
+    Misconfigured,
+    Unsupported,
+    RateLimit,
+    Timeout,
+    Unavailable,
+    InternalError,
+    MalformedResponse,
+    Other,
+    RetryWithReference(ReferenceObject),
+    CompleteWorkflow,
+    CompleteParent,
+}
+
+#[derive(Debug, Clone)]
+pub struct ReferenceObject {
+    pub reference: String,
+    pub status: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct Connection {
+    pub id: String,
+    pub name: String,
+    pub serialized_data: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct TriggerContext {
+    pub trigger_id: String,
+    pub connection: Connection,
+    pub store: String,
+    pub serialized_input: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct ActionContext {
+    pub action_id: String,
+    pub connection: Connection,
+    pub serialized_input: String,
+    pub reference_object: Option<ReferenceObject>,
+}
+
+#[derive(Debug, Clone)]
+pub struct TriggerEvent {
+    pub id: String,
+    pub serialized_data: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct TriggerResponse {
+    pub store: String,
+    pub events: Vec<TriggerEvent>,
+}
+
+#[derive(Debug, Clone)]
+pub struct ActionResponse {
+    pub serialized_output: String,
+}