app_bridge 3.0.0 → 4.1.0

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

@@ -1,5 +1,5 @@
-use magnus::{prelude::*, Error, TryConvert, Value};
-use crate::component::standout::app::types::ActionContext;
+use magnus::{prelude::*, scan_args::scan_args, Error, RHash, Ruby, Symbol, TryConvert, Value};
+use crate::types::{ActionContext, ReferenceObject};
 use super::connection::RConnection;
 
 #[magnus::wrap(class = "AppBridge::ActionContext")]
@@ -9,7 +9,29 @@ pub struct RActionContext {
 }
 
 impl RActionContext {
-    pub fn new(action_id: String, connection: Value, serialized_input: String) -> Result<Self, Error> {
+    fn parse_reference_object(value: Value) -> Result<ReferenceObject, Error> {
+        let reference: String = fetch_hash_string(value, "reference")?;
+        let status: String = fetch_hash_string(value, "status")?;
+        Ok(ReferenceObject {
+            reference,
+            status,
+        })
+    }
+
+    pub fn new(args: &[Value]) -> Result<Self, Error> {
+        let args = scan_args::<(String, Value, String), (Option<Value>,), (), (), (), ()>(args)?;
+        let (action_id, connection, serialized_input) = args.required;
+        let (retry,) = args.optional;
+
+        Self::build(action_id, connection, serialized_input, retry)
+    }
+
+    fn build(
+        action_id: String,
+        connection: Value,
+        serialized_input: String,
+        retry: Option<Value>,
+    ) -> Result<Self, Error> {
         if connection.is_nil() {
             return Err(Error::new(magnus::exception::runtime_error(), "Connection is required"));
         }
@@ -19,14 +41,18 @@ impl RActionContext {
             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,
+        let reference_object = match retry {
+            Some(value) if !value.is_nil() => Some(Self::parse_reference_object(value)?),
+            _ => None,
         };
 
         Ok(Self {
-            inner,
+            inner: ActionContext {
+                action_id,
+                connection: wrapped_connection.clone().into(),
+                serialized_input,
+                reference_object,
+            },
             wrapped_connection: Some(wrapped_connection),
         })
     }
@@ -42,6 +68,18 @@ impl RActionContext {
     pub fn serialized_input(&self) -> String {
         self.inner.serialized_input.clone()
     }
+
+    pub fn reference_object(&self) -> Result<Value, Error> {
+        let ruby = Ruby::get().unwrap();
+        if let Some(reference_object) = &self.inner.reference_object {
+            let hash: RHash = ruby.hash_new();
+            hash.aset("reference", reference_object.reference.clone())?;
+            hash.aset("status", reference_object.status.clone())?;
+            Ok(hash.as_value())
+        } else {
+            Ok(ruby.qnil().as_value())
+        }
+    }
 }
 
 impl TryConvert for RActionContext {
@@ -49,6 +87,16 @@ impl TryConvert for RActionContext {
         let connection_val: Value = val.funcall("connection", ())?;
         let serialized_input: String = val.funcall("serialized_input", ())?;
         let action_id: String = val.funcall("action_id", ())?;
+        let reference_object = if val.funcall("respond_to?", ("reference_object",))? {
+            let reference_object_val: Value = val.funcall("reference_object", ())?;
+            if reference_object_val.is_nil() {
+                None
+            } else {
+                Some(Self::parse_reference_object(reference_object_val)?)
+            }
+        } else {
+            None
+        };
 
         if connection_val.is_nil() {
             return Err(Error::new(magnus::exception::runtime_error(), "Connection is required"));
@@ -60,9 +108,10 @@ impl TryConvert for RActionContext {
         };
 
         let inner = ActionContext {
-            action_id: action_id,
+            action_id,
             connection: wrapped_connection.clone().inner,
             serialized_input,
+            reference_object,
         };
 
         Ok(Self {
@@ -72,6 +121,18 @@ impl TryConvert for RActionContext {
     }
 }
 
+fn fetch_hash_string(hash: Value, key: &str) -> Result<String, Error> {
+    let value: Value = hash.funcall("[]", (key,))?;
+    let value = if value.is_nil() {
+        let symbol = Symbol::new(key);
+        hash.funcall("[]", (symbol,))?
+    } else {
+        value
+    };
+    TryConvert::try_convert(value)
+}
+
+
 impl From<RActionContext> for ActionContext {
     fn from(raction_context: RActionContext) -> Self {
         raction_context.inner

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

@@ -1,4 +1,4 @@
-use crate::component::standout::app::types::ActionResponse;
+use crate::types::ActionResponse;
 
 #[magnus::wrap(class = "AppBridge::ActionResponse")]
 pub struct RActionResponse {
@@ -8,7 +8,7 @@ pub struct RActionResponse {
 impl RActionResponse {
     pub fn new(serialized_output: String) -> Self {
         let inner = ActionResponse {
-            serialized_output: serialized_output,
+            serialized_output,
         };
         Self { inner }
     }
@@ -16,6 +16,11 @@ impl RActionResponse {
     pub fn serialized_output(&self) -> String {
         self.inner.serialized_output.clone()
     }
+
+    /// Returns a new ActionResponse with the given output
+    pub fn with_output(&self, value: String) -> Self {
+        Self::new(value)
+    }
 }
 
 impl From<ActionResponse> for RActionResponse {
@@ -29,4 +34,3 @@ impl From<RActionResponse> for ActionResponse {
         value.inner
     }
 }
-

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

@@ -4,21 +4,19 @@ use std::collections::HashMap;
 use wasmtime::Store;
 
 use crate::app_state::AppState;
-use crate::component::standout::app::types::{
-    AppError, ErrorCode, TriggerContext, TriggerResponse, ActionContext, ActionResponse
-};
-use crate::component::{app, build_engine, build_linker, build_store, Bridge};
+use crate::component::{app, build_engine, build_linker, build_store, BridgeWrapper};
+use crate::types::{ActionContext, ActionResponse, AppError, ErrorCode, TriggerContext, TriggerResponse};
 use super::{
-    trigger_context::RTriggerContext,
-    trigger_response::RTriggerResponse,
     action_context::RActionContext,
     action_response::RActionResponse,
+    trigger_context::RTriggerContext,
+    trigger_response::RTriggerResponse,
 };
 
 #[derive(Default)]
 pub struct RApp {
     component_path: String,
-    instance: RefCell<Option<Bridge>>,
+    instance: RefCell<Option<BridgeWrapper>>,
     store: RefCell<Option<Store<AppState>>>,
 }
 
@@ -27,13 +25,28 @@ pub struct RApp {
 pub struct MutRApp(RefCell<RApp>);
 
 impl MutRApp {
+    /// Returns the WIT version this component was built against (e.g., "3.0.0", "4.0.0")
+    pub fn wit_version(&self) -> Result<String, Error> {
+        let binding = self.0.borrow();
+        let instance = binding.instance.borrow();
+
+        if let Some(instance) = &*instance {
+            Ok(instance.wit_version().to_string())
+        } else {
+            Err(Error::new(
+                magnus::exception::runtime_error(),
+                "App not initialized",
+            ))
+        }
+    }
+
     pub fn initialize(&self, component_path: String, env_vars: HashMap<String, String>) -> Result<(), Error> {
         let mut this = self.0.borrow_mut();
         let engine = build_engine();
         let linker = build_linker(&engine).map_err(|e| {
             Error::new(
                 magnus::exception::runtime_error(),
-                format!("Failed to build linker: {}", e)
+                format!("Failed to build linker: {}", e),
             )
         })?;
         let mut store = if env_vars.is_empty() {
@@ -44,19 +57,16 @@ impl MutRApp {
 
         let app = app(component_path.clone(), engine, &mut store, linker).map_err(|e| {
             if e.to_string().contains("Incompatible WASM file version") {
-                Error::new(
-                    magnus::exception::runtime_error(),
-                    e.to_string()
-                )
+                Error::new(magnus::exception::runtime_error(), e.to_string())
             } else {
                 Error::new(
                     magnus::exception::runtime_error(),
-                    format!("Failed to initialize app: {}", e)
+                    format!("Failed to initialize app: {}", e),
                 )
             }
         })?;
 
-        this.component_path = component_path.to_string();
+        this.component_path = component_path;
         *this.instance.borrow_mut() = Some(app);
         *this.store.borrow_mut() = Some(store);
 
@@ -65,102 +75,87 @@ impl MutRApp {
 
     pub fn trigger_ids(&self) -> Result<Vec<String>, Error> {
         let binding = self.0.borrow();
-
         let mut instance = binding.instance.borrow_mut();
         let mut store = binding.store.borrow_mut();
 
         if let (Some(instance), Some(store)) = (&mut *instance, &mut *store) {
-            match instance.standout_app_triggers().call_trigger_ids(store) {
-                Ok(result) => {
-                    match result {
-                        Ok(ids) => Ok(ids),
-                        Err(err) => Err(err.into())
-                    }
-                },
+            match instance.call_trigger_ids(store) {
+                Ok(result) => result.map_err(Into::into),
                 Err(err) => {
-                  if let Some(wit_err) = err.downcast_ref::<AppError>() {
-                      Err(wit_err.clone().into())
-                  } else {
-                      Err(Error::new(
-                          magnus::exception::runtime_error(),
-                          format!("Unexpected error: {:?}", err)
-                      ))
-                  }
-                },
+                    if let Some(wit_err) = err.downcast_ref::<AppError>() {
+                        Err(wit_err.clone().into())
+                    } else {
+                        Err(Error::new(
+                            magnus::exception::runtime_error(),
+                            format!("Unexpected error: {:?}", err),
+                        ))
+                    }
+                }
             }
         } else {
             Err(AppError {
                 code: ErrorCode::InternalError,
                 message: "App instance couldn't be initialized".to_string(),
-            }.into())
+            }
+            .into())
         }
     }
 
     pub fn trigger_input_schema(&self, context: RTriggerContext) -> Result<String, Error> {
         let binding = self.0.borrow();
-
         let mut instance = binding.instance.borrow_mut();
         let mut store = binding.store.borrow_mut();
 
         if let (Some(instance), Some(store)) = (&mut *instance, &mut *store) {
             let context_ctx = context.into();
-            match instance.standout_app_triggers().call_input_schema(store, &context_ctx) {
-                Ok(result) => {
-                    match result {
-                        Ok(schema) => Ok(schema),
-                        Err(err) => Err(err.into())
-                    }
-                },
+            match instance.call_trigger_input_schema(store, &context_ctx) {
+                Ok(result) => result.map_err(Into::into),
                 Err(err) => {
-                  if let Some(wit_err) = err.downcast_ref::<AppError>() {
-                      Err(wit_err.clone().into())
-                  } else {
-                      Err(Error::new(
-                          magnus::exception::runtime_error(),
-                          format!("Unexpected error: {:?}", err)
-                      ))
-                  }
-                },
+                    if let Some(wit_err) = err.downcast_ref::<AppError>() {
+                        Err(wit_err.clone().into())
+                    } else {
+                        Err(Error::new(
+                            magnus::exception::runtime_error(),
+                            format!("Unexpected error: {:?}", err),
+                        ))
+                    }
+                }
             }
         } else {
             Err(AppError {
                 code: ErrorCode::InternalError,
                 message: "App instance couldn't be initialized".to_string(),
-            }.into())
+            }
+            .into())
         }
     }
 
     pub fn trigger_output_schema(&self, context: RTriggerContext) -> Result<String, Error> {
         let binding = self.0.borrow();
-
         let mut instance = binding.instance.borrow_mut();
         let mut store = binding.store.borrow_mut();
 
         if let (Some(instance), Some(store)) = (&mut *instance, &mut *store) {
             let context_ctx = context.into();
-            match instance.standout_app_triggers().call_output_schema(store, &context_ctx) {
-                Ok(result) => {
-                    match result {
-                        Ok(schema) => Ok(schema),
-                        Err(err) => Err(err.into())
-                    }
-                },
+            match instance.call_trigger_output_schema(store, &context_ctx) {
+                Ok(result) => result.map_err(Into::into),
                 Err(err) => {
-                  if let Some(wit_err) = err.downcast_ref::<AppError>() {
-                      Err(wit_err.clone().into())
-                  } else {
-                      Err(Error::new(
-                          magnus::exception::runtime_error(),
-                          format!("Unexpected error: {:?}", err)
-                      ))
-                  }
-                },
+                    if let Some(wit_err) = err.downcast_ref::<AppError>() {
+                        Err(wit_err.clone().into())
+                    } else {
+                        Err(Error::new(
+                            magnus::exception::runtime_error(),
+                            format!("Unexpected error: {:?}", err),
+                        ))
+                    }
+                }
             }
         } else {
             Err(AppError {
                 code: ErrorCode::InternalError,
                 message: "App instance couldn't be initialized".to_string(),
-            }.into())
+            }
+            .into())
         }
     }
 
@@ -169,30 +164,22 @@ impl MutRApp {
         let response = self.fetch_events(context.into());
 
         match response {
-            Ok(response) =>  Ok(response.into()),
-            Err(err) => Err(err.into())
+            Ok(response) => Ok(response.into()),
+            Err(err) => Err(err.into()),
         }
     }
 
     fn fetch_events(&self, context: TriggerContext) -> Result<TriggerResponse, AppError> {
         let binding = self.0.borrow();
-
         let mut instance = binding.instance.borrow_mut();
         let mut store = binding.store.borrow_mut();
 
         if let (Some(instance), Some(store)) = (&mut *instance, &mut *store) {
-            match instance
-                .standout_app_triggers()
-                .call_fetch_events(store, &context) {
-                Ok(response) => {
-                    match response {
-                        Ok(res) => Ok(res),
-                        Err(err) => Err(err),
-                    }
-                },
+            match instance.call_fetch_events(store, &context) {
+                Ok(response) => response,
                 Err(err) => {
                     if let Some(wit_err) = err.downcast_ref::<AppError>() {
-                        Err(AppError::from(wit_err.clone()))
+                        Err(wit_err.clone())
                     } else {
                         Err(AppError {
                             code: ErrorCode::InternalError,
@@ -211,102 +198,87 @@ impl MutRApp {
 
     pub fn action_ids(&self) -> Result<Vec<String>, Error> {
         let binding = self.0.borrow();
-
         let mut instance = binding.instance.borrow_mut();
         let mut store = binding.store.borrow_mut();
 
         if let (Some(instance), Some(store)) = (&mut *instance, &mut *store) {
-            match instance.standout_app_actions().call_action_ids(store) {
-                Ok(result) => {
-                    match result {
-                        Ok(ids) => Ok(ids),
-                        Err(err) => Err(err.into())
-                    }
-                },
+            match instance.call_action_ids(store) {
+                Ok(result) => result.map_err(Into::into),
                 Err(err) => {
-                  if let Some(wit_err) = err.downcast_ref::<AppError>() {
-                      Err(wit_err.clone().into())
-                  } else {
-                      Err(Error::new(
-                          magnus::exception::runtime_error(),
-                          format!("Unexpected error: {:?}", err)
-                      ))
-                  }
-                },
+                    if let Some(wit_err) = err.downcast_ref::<AppError>() {
+                        Err(wit_err.clone().into())
+                    } else {
+                        Err(Error::new(
+                            magnus::exception::runtime_error(),
+                            format!("Unexpected error: {:?}", err),
+                        ))
+                    }
+                }
             }
         } else {
             Err(AppError {
                 code: ErrorCode::InternalError,
                 message: "App instance couldn't be initialized".to_string(),
-            }.into())
+            }
+            .into())
         }
     }
 
     pub fn action_input_schema(&self, context: RActionContext) -> Result<String, Error> {
         let binding = self.0.borrow();
-
         let mut instance = binding.instance.borrow_mut();
         let mut store = binding.store.borrow_mut();
 
         if let (Some(instance), Some(store)) = (&mut *instance, &mut *store) {
             let context_ctx = context.into();
-            match instance.standout_app_actions().call_input_schema(store, &context_ctx) {
-                Ok(result) => {
-                    match result {
-                        Ok(schema) => Ok(schema),
-                        Err(err) => Err(err.into())
-                    }
-                },
+            match instance.call_action_input_schema(store, &context_ctx) {
+                Ok(result) => result.map_err(Into::into),
                 Err(err) => {
-                  if let Some(wit_err) = err.downcast_ref::<AppError>() {
-                      Err(wit_err.clone().into())
-                  } else {
-                      Err(Error::new(
-                          magnus::exception::runtime_error(),
-                          format!("Unexpected error: {:?}", err)
-                      ))
-                  }
-                },
+                    if let Some(wit_err) = err.downcast_ref::<AppError>() {
+                        Err(wit_err.clone().into())
+                    } else {
+                        Err(Error::new(
+                            magnus::exception::runtime_error(),
+                            format!("Unexpected error: {:?}", err),
+                        ))
+                    }
+                }
             }
         } else {
             Err(AppError {
                 code: ErrorCode::InternalError,
                 message: "App instance couldn't be initialized".to_string(),
-            }.into())
+            }
+            .into())
         }
     }
 
     pub fn action_output_schema(&self, context: RActionContext) -> Result<String, Error> {
         let binding = self.0.borrow();
-
         let mut instance = binding.instance.borrow_mut();
         let mut store = binding.store.borrow_mut();
 
         if let (Some(instance), Some(store)) = (&mut *instance, &mut *store) {
             let context_ctx = context.into();
-            match instance.standout_app_actions().call_output_schema(store, &context_ctx) {
-                Ok(result) => {
-                    match result {
-                        Ok(schema) => Ok(schema),
-                        Err(err) => Err(err.into())
-                    }
-                },
+            match instance.call_action_output_schema(store, &context_ctx) {
+                Ok(result) => result.map_err(Into::into),
                 Err(err) => {
-                  if let Some(wit_err) = err.downcast_ref::<AppError>() {
-                      Err(wit_err.clone().into())
-                  } else {
-                      Err(Error::new(
-                          magnus::exception::runtime_error(),
-                          format!("Unexpected error: {:?}", err)
-                      ))
-                  }
-                },
+                    if let Some(wit_err) = err.downcast_ref::<AppError>() {
+                        Err(wit_err.clone().into())
+                    } else {
+                        Err(Error::new(
+                            magnus::exception::runtime_error(),
+                            format!("Unexpected error: {:?}", err),
+                        ))
+                    }
+                }
             }
         } else {
             Err(AppError {
                 code: ErrorCode::InternalError,
                 message: "App instance couldn't be initialized".to_string(),
-            }.into())
+            }
+            .into())
         }
     }
 
@@ -315,30 +287,22 @@ impl MutRApp {
         let response = self.execute_action(context.into());
 
         match response {
-            Ok(response) =>  Ok(response.into()),
-            Err(err) => Err(err.into())
+            Ok(response) => Ok(response.into()),
+            Err(err) => Err(err.into()),
         }
     }
 
     fn execute_action(&self, context: ActionContext) -> Result<ActionResponse, AppError> {
         let binding = self.0.borrow();
-
         let mut instance = binding.instance.borrow_mut();
         let mut store = binding.store.borrow_mut();
 
         if let (Some(instance), Some(store)) = (&mut *instance, &mut *store) {
-            match instance
-                .standout_app_actions()
-                .call_execute(store, &context) {
-                Ok(response) => {
-                    match response {
-                        Ok(res) => Ok(res),
-                        Err(err) => Err(err),
-                    }
-                },
+            match instance.call_execute(store, &context) {
+                Ok(response) => response,
                 Err(err) => {
                     if let Some(wit_err) = err.downcast_ref::<AppError>() {
-                        Err(AppError::from(wit_err.clone()))
+                        Err(wit_err.clone())
                     } else {
                         Err(AppError {
                             code: ErrorCode::InternalError,

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

@@ -1,5 +1,5 @@
 use magnus::{prelude::*, Error, TryConvert, Value};
-use crate::component::standout::app::types::Connection;
+use crate::types::Connection;
 
 #[magnus::wrap(class = "AppBridge::Connection")]
 pub struct RConnection {
@@ -9,9 +9,9 @@ pub struct RConnection {
 impl RConnection {
     pub fn new(id: String, name: String, serialized_data: String) -> Self {
         let inner = Connection {
-            id: id,
-            name: name,
-            serialized_data: serialized_data,
+            id,
+            name,
+            serialized_data,
         };
         Self { inner }
     }

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

@@ -1,5 +1,5 @@
 use magnus::{prelude::*, Error, TryConvert, Value};
-use crate::component::standout::app::types::TriggerContext;
+use crate::types::TriggerContext;
 use super::connection::RConnection;
 
 #[magnus::wrap(class = "AppBridge::TriggerContext")]
@@ -20,10 +20,10 @@ impl RTriggerContext {
         };
 
         let inner = TriggerContext {
-            trigger_id: trigger_id,
+            trigger_id,
             connection: wrapped_connection.clone().into(),
-            store: store,
-            serialized_input: serialized_input,
+            store,
+            serialized_input,
         };
         Ok(Self {
             inner,
@@ -65,10 +65,10 @@ impl TryConvert for RTriggerContext {
         };
 
         let inner = TriggerContext {
-            trigger_id: trigger_id,
+            trigger_id,
             connection: wrapped_connection.clone().inner,
-            store: store,
-            serialized_input: serialized_input,
+            store,
+            serialized_input,
         };
 
         Ok(Self {

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

@@ -1,5 +1,5 @@
 use magnus::{prelude::*, Error, TryConvert, Value};
-use crate::component::standout::app::types::TriggerEvent;
+use crate::types::TriggerEvent;
 
 #[magnus::wrap(class = "AppBridge::TriggerEvent")]
 pub struct RTriggerEvent {
@@ -8,9 +8,9 @@ pub struct RTriggerEvent {
 
 impl RTriggerEvent {
     pub fn new(id: String, serialized_data: String) -> Self {
-        let inner: TriggerEvent = TriggerEvent {
-            id: id,
-            serialized_data: serialized_data,
+        let inner = TriggerEvent {
+            id,
+            serialized_data,
         };
         Self { inner }
     }