wasm_runner_sdk/

http.rs

//! HTTP client for making outbound requests.
//!
//! This module provides a high-level API for making HTTP requests from
//! within a WASM module. It wraps the async host operations in a
//! synchronous, ergonomic interface.

use crate::abi;
use serde::de::DeserializeOwned;
use serde::Serialize;
use std::time::Duration;

/// Error type for HTTP client operations.
#[derive(Debug, Clone)]
pub enum HttpError {
    /// The request failed to start.
    RequestFailed(String),
    /// The request timed out.
    Timeout,
    /// The operation ID was invalid.
    InvalidOperation,
    /// Failed to parse the response.
    ParseError(String),
    /// Network or transport error.
    NetworkError(String),
}

impl std::fmt::Display for HttpError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            HttpError::RequestFailed(msg) => write!(f, "Request failed: {}", msg),
            HttpError::Timeout => write!(f, "Request timed out"),
            HttpError::InvalidOperation => write!(f, "Invalid operation ID"),
            HttpError::ParseError(msg) => write!(f, "Parse error: {}", msg),
            HttpError::NetworkError(msg) => write!(f, "Network error: {}", msg),
        }
    }
}

impl std::error::Error for HttpError {}

/// Response from an HTTP request.
#[derive(Debug, Clone)]
pub struct HttpResponse {
    /// HTTP status code.
    pub status: u16,
    /// Response body as bytes.
    pub body: Vec<u8>,
}

impl HttpResponse {
    /// Returns true if the status code indicates success (2xx).
    pub fn is_success(&self) -> bool {
        self.status >= 200 && self.status < 300
    }

    /// Returns the body as a UTF-8 string.
    pub fn text(&self) -> Result<String, std::string::FromUtf8Error> {
        String::from_utf8(self.body.clone())
    }

    /// Parses the body as JSON.
    pub fn json<T: DeserializeOwned>(&self) -> Result<T, serde_json::Error> {
        serde_json::from_slice(&self.body)
    }
}

/// Builder for HTTP requests.
#[derive(Debug, Clone)]
pub struct RequestBuilder {
    method: String,
    url: String,
    headers: Vec<(String, String)>,
    body: Vec<u8>,
    timeout_ms: i32,
}

impl RequestBuilder {
    /// Creates a new request builder.
    fn new(method: impl Into<String>, url: impl Into<String>) -> Self {
        Self {
            method: method.into(),
            url: url.into(),
            headers: Vec::new(),
            body: Vec::new(),
            timeout_ms: 30000, // 30 second default
        }
    }

    /// Adds a header to the request.
    pub fn header(mut self, name: impl Into<String>, value: impl Into<String>) -> Self {
        self.headers.push((name.into(), value.into()));
        self
    }

    /// Sets the Content-Type header.
    pub fn content_type(self, content_type: impl Into<String>) -> Self {
        self.header("content-type", content_type)
    }

    /// Sets the Authorization header with a Bearer token.
    pub fn bearer_auth(self, token: impl Into<String>) -> Self {
        self.header("authorization", format!("Bearer {}", token.into()))
    }

    /// Sets the request body as bytes.
    pub fn body(mut self, body: impl Into<Vec<u8>>) -> Self {
        self.body = body.into();
        self
    }

    /// Sets the request body as a string.
    pub fn text(self, text: impl Into<String>) -> Self {
        self.content_type("text/plain")
            .body(text.into().into_bytes())
    }

    /// Sets the request body as JSON.
    pub fn json<T: Serialize>(self, value: &T) -> Result<Self, serde_json::Error> {
        let body = serde_json::to_vec(value)?;
        Ok(self.content_type("application/json").body(body))
    }

    /// Sets the request timeout.
    pub fn timeout(mut self, duration: Duration) -> Self {
        self.timeout_ms = duration.as_millis().min(i32::MAX as u128) as i32;
        self
    }

    /// Sends the request and waits for the response.
    pub fn send(self) -> Result<HttpResponse, HttpError> {
        // Serialize headers
        let headers_bytes = abi::serialize_pairs(&self.headers);

        // Start the request
        let op_id = unsafe {
            abi::http_fetch_with_options(
                self.method.as_ptr(),
                self.method.len() as i32,
                self.url.as_ptr(),
                self.url.len() as i32,
                headers_bytes.as_ptr(),
                headers_bytes.len() as i32,
                self.body.as_ptr(),
                self.body.len() as i32,
            )
        };

        if op_id < 0 {
            return Err(HttpError::RequestFailed("Failed to start HTTP request".into()));
        }

        // Poll for completion
        let poll_result = unsafe { abi::operation_poll(op_id, self.timeout_ms) };

        match poll_result {
            1 => {
                // Success - get the result
                let status = unsafe { abi::operation_result_status(op_id) };

                // Get body size first
                let body_size = unsafe { abi::operation_result_body(op_id, std::ptr::null_mut(), 0) };

                let body = if body_size > 0 {
                    let mut body_buf = vec![0u8; body_size as usize];
                    unsafe {
                        abi::operation_result_body(
                            op_id,
                            body_buf.as_mut_ptr(),
                            body_buf.len() as i32,
                        );
                    }
                    body_buf
                } else {
                    Vec::new()
                };

                // Free the operation
                unsafe { abi::operation_free(op_id) };

                Ok(HttpResponse {
                    status: status as u16,
                    body,
                })
            }
            0 => {
                // Timeout
                unsafe { abi::operation_free(op_id) };
                Err(HttpError::Timeout)
            }
            -1 => {
                // Error - try to get error message from body
                let body_size = unsafe { abi::operation_result_body(op_id, std::ptr::null_mut(), 0) };
                let error_msg = if body_size > 0 {
                    let mut buf = vec![0u8; body_size as usize];
                    unsafe {
                        abi::operation_result_body(op_id, buf.as_mut_ptr(), buf.len() as i32);
                    }
                    String::from_utf8_lossy(&buf).into_owned()
                } else {
                    "Unknown error".into()
                };

                unsafe { abi::operation_free(op_id) };
                Err(HttpError::NetworkError(error_msg))
            }
            -2 => {
                Err(HttpError::InvalidOperation)
            }
            _ => {
                unsafe { abi::operation_free(op_id) };
                Err(HttpError::NetworkError(format!("Unexpected poll result: {}", poll_result)))
            }
        }
    }
}

/// HTTP client for making outbound requests.
///
/// # Example
/// ```ignore
/// use wasm_runner_sdk::http::Client;
///
/// let client = Client::new();
/// let response = client.get("https://api.example.com/data").send()?;
/// let data: MyData = response.json()?;
/// ```
#[derive(Debug, Clone, Default)]
pub struct Client {
    default_headers: Vec<(String, String)>,
}

impl Client {
    /// Creates a new HTTP client.
    pub fn new() -> Self {
        Self::default()
    }

    /// Creates a client with default headers that will be sent with every request.
    pub fn with_default_headers(headers: Vec<(String, String)>) -> Self {
        Self {
            default_headers: headers,
        }
    }

    /// Adds a default header that will be sent with every request.
    pub fn default_header(mut self, name: impl Into<String>, value: impl Into<String>) -> Self {
        self.default_headers.push((name.into(), value.into()));
        self
    }

    /// Creates a GET request.
    pub fn get(&self, url: impl Into<String>) -> RequestBuilder {
        self.request("GET", url)
    }

    /// Creates a POST request.
    pub fn post(&self, url: impl Into<String>) -> RequestBuilder {
        self.request("POST", url)
    }

    /// Creates a PUT request.
    pub fn put(&self, url: impl Into<String>) -> RequestBuilder {
        self.request("PUT", url)
    }

    /// Creates a DELETE request.
    pub fn delete(&self, url: impl Into<String>) -> RequestBuilder {
        self.request("DELETE", url)
    }

    /// Creates a PATCH request.
    pub fn patch(&self, url: impl Into<String>) -> RequestBuilder {
        self.request("PATCH", url)
    }

    /// Creates a HEAD request.
    pub fn head(&self, url: impl Into<String>) -> RequestBuilder {
        self.request("HEAD", url)
    }

    /// Creates a request with the given method.
    pub fn request(&self, method: impl Into<String>, url: impl Into<String>) -> RequestBuilder {
        let mut builder = RequestBuilder::new(method, url);
        for (name, value) in &self.default_headers {
            builder = builder.header(name.clone(), value.clone());
        }
        builder
    }
}

/// Convenience function for simple GET requests.
pub fn get(url: impl Into<String>) -> Result<HttpResponse, HttpError> {
    Client::new().get(url).send()
}

/// Convenience function for simple POST requests with JSON body.
pub fn post_json<T: Serialize>(url: impl Into<String>, body: &T) -> Result<HttpResponse, HttpError> {
    Client::new()
        .post(url)
        .json(body)
        .map_err(|e| HttpError::ParseError(e.to_string()))?
        .send()
}