app_bridge 2.0.1 → 2.1.1

data/Rakefile

@@ -3,8 +3,6 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 
-RSpec::Core::RakeTask.new(:spec)
-
 require "rubocop/rake_task"
 
 RuboCop::RakeTask.new
@@ -22,4 +20,9 @@ end
 # Load all project specific rake tasks
 Dir.glob(File.expand_path("tasks/**/*.rake", __dir__)).each { |file| load file }
 
-task default: %i[fixtures compile spec rubocop]
+# Set test mode environment variable for specs
+RSpec::Core::RakeTask.new(:spec) do |_t|
+  ENV["APP_BRIDGE_TEST_MODE"] = "1"
+end
+
+task default: %i[fixtures compile rust:test spec rubocop]

data/ext/app_bridge/Cargo.toml

@@ -1,6 +1,8 @@
 [package]
 name = "app_bridge"
-version = "1.0.0"
+# When updating the version, please also update the version in the
+# lib/app_bridge/version.rb file to keep them in sync.
+version = "2.1.1"
 edition = "2021"
 authors = ["Alexander Ross <ross@standout.se>"]
 publish = false
@@ -10,6 +12,9 @@ crate-type = ["cdylib"]
 
 [dependencies]
 magnus = { version = "0.7.1" }
-wasmtime = "29.0.1"
-wasmtime-wasi = "29.0.1"
+wasmtime = "32.0.0"
+wasmtime-wasi = "32.0.0"
 reqwest = { version = "0.12", features = ["blocking", "json", "native-tls-vendored"] }
+
+[dev-dependencies]
+httpmock = "0.7.0"

data/ext/app_bridge/src/app_state.rs

@@ -4,7 +4,7 @@ use reqwest::blocking::Client;
 use std::collections::HashMap;
 use std::sync::{Arc, Mutex};
 use wasmtime::component::ResourceTable;
-use wasmtime_wasi::{WasiCtx, WasiCtxBuilder, WasiView};
+use wasmtime_wasi::{WasiCtx, WasiCtxBuilder, WasiView, IoView};
 
 pub struct AppState {
     ctx: WasiCtx,
@@ -12,16 +12,18 @@ pub struct AppState {
     pub client: Arc<Mutex<Client>>,
     pub request_list: HashMap<u32, Request>,
     pub next_request_id: u32,
+    pub environment_variables: HashMap<String, String>,
 }
 
 impl AppState {
-    pub fn new(ctx: WasiCtx) -> Self {
+    pub fn new(ctx: WasiCtx, env_vars: Option<HashMap<String, String>>) -> Self {
         Self {
             ctx,
             table: ResourceTable::new(),
             client: Arc::new(Mutex::new(Client::new())),
             request_list: HashMap::new(),
             next_request_id: 0,
+            environment_variables: env_vars.unwrap_or_default(),
         }
     }
 }
@@ -30,17 +32,30 @@ impl standout::app::http::Host for AppState {
     // Impl http host methods here
 }
 
-impl WasiView for AppState {
-    fn ctx(&mut self) -> &mut WasiCtx {
-        &mut self.ctx
+impl standout::app::environment::Host for AppState {
+    fn env_vars(&mut self) -> Vec<(String, String)> {
+        self.environment_variables.clone().into_iter().collect()
     }
+
+    fn env_var(&mut self, name: String) -> Option<String> {
+        self.environment_variables.get(&name).cloned()
+    }
+}
+
+impl IoView for AppState {
     fn table(&mut self) -> &mut ResourceTable {
         &mut self.table
     }
 }
 
+impl WasiView for AppState {
+    fn ctx(&mut self) -> &mut WasiCtx {
+        &mut self.ctx
+    }
+}
+
 impl Default for AppState {
     fn default() -> Self {
-        Self::new(WasiCtxBuilder::new().build())
+        Self::new(WasiCtxBuilder::new().build(), None)
     }
 }

data/ext/app_bridge/src/component.rs

@@ -1,9 +1,13 @@
 use std::result::Result::Ok;
+use std::collections::HashMap;
 use wasmtime::component::{bindgen, Component, Linker};
 use wasmtime::{Engine, Result, Store};
 use wasmtime_wasi::WasiCtxBuilder;
 
-bindgen!();
+bindgen!({
+    path: "./wit",
+    world: "bridge",
+});
 
 use crate::app_state::AppState;
 
@@ -15,18 +19,27 @@ pub fn build_linker(engine: &Engine) -> Result<Linker<AppState>> {
     let mut linker = Linker::<AppState>::new(&engine);
     wasmtime_wasi::add_to_linker_sync(&mut linker)?;
     standout::app::http::add_to_linker(&mut linker, |s| s)?;
+    standout::app::environment::add_to_linker(&mut linker, |s| s)?;
 
     Ok(linker)
 }
 
-pub fn build_store(engine: &Engine) -> Store<AppState> {
-    let builder = WasiCtxBuilder::new().build();
+pub fn build_store(engine: &Engine, env_vars: Option<HashMap<String, String>>) -> Store<AppState> {
+    let mut builder = WasiCtxBuilder::new();
 
-    // ... configure `builder` more to add env vars, args, etc ...
+    // Add environment variables to WASI context if provided
+    if let Some(env_vars) = &env_vars {
+        for (key, value) in env_vars {
+            builder.env(key, value);
+        }
+    }
+
+    let ctx = builder.build();
 
-    let store = Store::new(&engine, AppState::new(builder));
+    // Create AppState with or without environment variables
+    let app_state = AppState::new(ctx, env_vars);
 
-    store
+    Store::new(&engine, app_state)
 }
 
 pub fn app(
@@ -37,16 +50,28 @@ pub fn app(
 ) -> Result<Bridge> {
     // Load the application component from the file system.
     let component = Component::from_file(&engine, file_path)?;
-    let instance = Bridge::instantiate(store, &component, &linker)?;
 
-    Ok(instance)
+    // Try to instantiate the component - if it fails due to missing interface,
+    // we'll catch that error and return a specific message
+    match Bridge::instantiate(store, &component, &linker) {
+        Ok(instance) => Ok(instance),
+        Err(e) => {
+            if e.to_string().contains("no exported instance") {
+                Err(wasmtime::Error::msg(
+                    "Incompatible WASM file version"
+                ))
+            } else {
+                Err(e)
+            }
+        }
+    }
 }
 
 impl Default for Bridge {
     fn default() -> Self {
         let file_path = "spec/fixtures/components/example_app.wasm";
         let engine = Engine::default();
-        let mut store = build_store(&engine);
+        let mut store = build_store(&engine, None);
         let linker = build_linker(&engine).unwrap();
         let instant = app(file_path.to_string(), engine, &mut store, linker);
 

data/ext/app_bridge/src/lib.rs

@@ -5,10 +5,12 @@ mod request_builder;
 mod error_mapping;
 
 mod wrappers;
-use wrappers::account::RAccount;
+use wrappers::connection::RConnection;
 use wrappers::trigger_context::RTriggerContext;
 use wrappers::trigger_event::RTriggerEvent;
 use wrappers::trigger_response::RTriggerResponse;
+use wrappers::action_context::RActionContext;
+use wrappers::action_response::RActionResponse;
 use wrappers::app::MutRApp;
 
 #[magnus::init]
@@ -27,12 +29,12 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     module.define_error("MalformedResponseError", error)?;
     module.define_error("OtherError", error)?;
 
-    // Define the Accout class
-    let account_class = module.define_class("Account", ruby.class_object())?;
-    account_class.define_singleton_method("new", function!(RAccount::new, 3))?;
-    account_class.define_method("id", method!(RAccount::id, 0))?;
-    account_class.define_method("name", method!(RAccount::name, 0))?;
-    account_class.define_method("serialized_data", method!(RAccount::serialized_data, 0))?;
+    // Define the Connection class
+    let connection_class = module.define_class("Connection", ruby.class_object())?;
+    connection_class.define_singleton_method("new", function!(RConnection::new, 3))?;
+    connection_class.define_method("id", method!(RConnection::id, 0))?;
+    connection_class.define_method("name", method!(RConnection::name, 0))?;
+    connection_class.define_method("serialized_data", method!(RConnection::serialized_data, 0))?;
 
     let trigger_event_class = module.define_class("TriggerEvent", ruby.class_object())?;
     trigger_event_class.define_singleton_method("new", function!(RTriggerEvent::new, 2))?;
@@ -48,17 +50,35 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     trigger_response_class.define_method("events", method!(RTriggerResponse::events, 0))?;
 
     let trigger_context_class = module.define_class("TriggerContext", ruby.class_object())?;
-    trigger_context_class.define_singleton_method("new", function!(RTriggerContext::new, 3))?;
+    trigger_context_class.define_singleton_method("new", function!(RTriggerContext::new, 4))?;
     trigger_context_class.define_method("trigger_id", method!(RTriggerContext::trigger_id, 0))?;
-    trigger_context_class.define_method("account", method!(RTriggerContext::account, 0))?;
+    trigger_context_class.define_method("connection", method!(RTriggerContext::connection, 0))?;
     trigger_context_class.define_method("store", method!(RTriggerContext::store, 0))?;
+    trigger_context_class.define_method("serialized_input", method!(RTriggerContext::serialized_input, 0))?;
+
+    // Define the Action classes
+    let action_context_class = module.define_class("ActionContext", ruby.class_object())?;
+    action_context_class.define_singleton_method("new", function!(RActionContext::new, 3))?;
+    action_context_class.define_method("action_id", method!(RActionContext::action_id, 0))?;
+    action_context_class.define_method("connection", method!(RActionContext::connection, 0))?;
+    action_context_class.define_method("serialized_input", method!(RActionContext::serialized_input, 0))?;
+
+    let action_response_class = module.define_class("ActionResponse", ruby.class_object())?;
+    action_response_class.define_singleton_method("new", function!(RActionResponse::new, 1))?;
+    action_response_class.define_method("serialized_output", method!(RActionResponse::serialized_output, 0))?;
 
     // Define the App class
     let app_class = module.define_class("App", ruby.class_object())?;
     app_class.define_alloc_func::<MutRApp>();
-    app_class.define_method("initialize", method!(MutRApp::initialize, 1))?;
     app_class.define_method("trigger_ids", method!(MutRApp::trigger_ids, 0))?;
+    app_class.define_method("action_ids", method!(MutRApp::action_ids, 0))?;
+    app_class.define_method("action_input_schema", method!(MutRApp::action_input_schema, 1))?;
+    app_class.define_method("action_output_schema", method!(MutRApp::action_output_schema, 1))?;
+    app_class.define_method("trigger_input_schema", method!(MutRApp::trigger_input_schema, 1))?;
+    app_class.define_method("trigger_output_schema", method!(MutRApp::trigger_output_schema, 1))?;
+    app_class.define_private_method("_rust_initialize", method!(MutRApp::initialize, 2))?;
     app_class.define_private_method("_rust_fetch_events", method!(MutRApp::rb_fetch_events, 1))?;
+    app_class.define_private_method("_rust_execute_action", method!(MutRApp::rb_execute_action, 1))?;
 
     Ok(())
 }

data/ext/app_bridge/src/request_builder.rs

@@ -162,11 +162,17 @@ impl From<Method> for ReqwestMethod {
 
 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(),
             method: Method::Get,
             body: "".to_string(),
-            headers: Vec::new(),
+            headers,
         }
     }
 }
@@ -194,3 +200,35 @@ impl std::fmt::Display for Method {
         }
     }
 }
+
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use httpmock::{MockServer, Method::GET};
+
+    #[test]
+    fn sends_request_with_default_user_agent() {
+        let version = env!("CARGO_PKG_VERSION");
+        let user_agent = format!("Standout-AppBridge/{version}");
+
+        let server = MockServer::start();
+        let mock = server.mock(|when, then| {
+            when.method(GET)
+                .path("/headers")
+                .header("User-Agent", user_agent.clone());
+            then.status(200);
+        });
+        let url = format!("{}/headers", server.base_url());
+
+        let mut app_state = AppState::default();
+        let builder = app_state.new();
+        let builder = app_state.method(builder, Method::Get);
+        let builder = app_state.url(builder, url);
+
+        let response = app_state.send(builder).expect("Request failed");
+
+        assert_eq!(response.status, 200);
+        mock.assert();
+    }
+}

data/ext/app_bridge/src/wrappers/action_context.rs

@@ -0,0 +1,79 @@
+use magnus::{prelude::*, Error, TryConvert, Value};
+use crate::component::standout::app::types::ActionContext;
+use super::connection::RConnection;
+
+#[magnus::wrap(class = "AppBridge::ActionContext")]
+pub struct RActionContext {
+    inner: ActionContext,
+    wrapped_connection: Option<RConnection>,
+}
+
+impl RActionContext {
+    pub fn new(action_id: String, connection: Value, serialized_input: String) -> Result<Self, Error> {
+        if connection.is_nil() {
+            return Err(Error::new(magnus::exception::runtime_error(), "Connection is required"));
+        }
+
+        let wrapped_connection: RConnection = match TryConvert::try_convert(connection) {
+            Ok(conn) => conn,
+            Err(_) => return Err(Error::new(magnus::exception::runtime_error(), "Connection is required")),
+        };
+
+        let inner = ActionContext {
+            action_id: action_id,
+            connection: wrapped_connection.clone().into(),
+            serialized_input,
+        };
+
+        Ok(Self {
+            inner,
+            wrapped_connection: Some(wrapped_connection),
+        })
+    }
+
+    pub fn action_id(&self) -> String {
+        self.inner.action_id.clone()
+    }
+
+    pub fn connection(&self) -> RConnection {
+        self.wrapped_connection.clone().unwrap()
+    }
+
+    pub fn serialized_input(&self) -> String {
+        self.inner.serialized_input.clone()
+    }
+}
+
+impl TryConvert for RActionContext {
+    fn try_convert(val: Value) -> Result<Self, Error> {
+        let connection_val: Value = val.funcall("connection", ())?;
+        let serialized_input: String = val.funcall("serialized_input", ())?;
+        let action_id: String = val.funcall("action_id", ())?;
+
+        if connection_val.is_nil() {
+            return Err(Error::new(magnus::exception::runtime_error(), "Connection is required"));
+        }
+
+        let wrapped_connection: RConnection = match TryConvert::try_convert(connection_val) {
+            Ok(conn) => conn,
+            Err(_) => return Err(Error::new(magnus::exception::runtime_error(), "Connection is required")),
+        };
+
+        let inner = ActionContext {
+            action_id: action_id,
+            connection: wrapped_connection.clone().inner,
+            serialized_input,
+        };
+
+        Ok(Self {
+            inner,
+            wrapped_connection: Some(wrapped_connection),
+        })
+    }
+}
+
+impl From<RActionContext> for ActionContext {
+    fn from(raction_context: RActionContext) -> Self {
+        raction_context.inner
+    }
+}

data/ext/app_bridge/src/wrappers/action_response.rs

@@ -0,0 +1,32 @@
+use crate::component::standout::app::types::ActionResponse;
+
+#[magnus::wrap(class = "AppBridge::ActionResponse")]
+pub struct RActionResponse {
+    inner: ActionResponse,
+}
+
+impl RActionResponse {
+    pub fn new(serialized_output: String) -> Self {
+        let inner = ActionResponse {
+            serialized_output: serialized_output,
+        };
+        Self { inner }
+    }
+
+    pub fn serialized_output(&self) -> String {
+        self.inner.serialized_output.clone()
+    }
+}
+
+impl From<ActionResponse> for RActionResponse {
+    fn from(value: ActionResponse) -> Self {
+        Self { inner: value }
+    }
+}
+
+impl From<RActionResponse> for ActionResponse {
+    fn from(value: RActionResponse) -> Self {
+        value.inner
+    }
+}
+