app_bridge 3.0.0 → 4.0.0

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 }
     }

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

@@ -1,42 +1,43 @@
-use magnus::{Error, RArray, TryConvert};
-use crate::component::standout::app::types::TriggerResponse;
+use magnus::{Error, Ruby, TryConvert};
+use crate::types::TriggerResponse;
 use super::trigger_event::RTriggerEvent;
 
 #[magnus::wrap(class = "AppBridge::TriggerResponse")]
 pub struct RTriggerResponse {
-  inner: TriggerResponse,
+    inner: TriggerResponse,
 }
 
 impl RTriggerResponse {
-  pub fn new(store: String, events: RArray) -> Self {
-      let iter = events.into_iter();
-      let res: Vec<RTriggerEvent> = iter
-          .map(&TryConvert::try_convert)
-          .collect::<Result<Vec<RTriggerEvent>, Error>>()
-          .unwrap();
+    pub fn new(store: String, events: magnus::RArray) -> Self {
+        let iter = events.into_iter();
+        let res: Vec<RTriggerEvent> = iter
+            .map(&TryConvert::try_convert)
+            .collect::<Result<Vec<RTriggerEvent>, Error>>()
+            .unwrap();
 
-      let inner = TriggerResponse {
-          store: store,
-          events: res.iter().map(|e| e.into()).collect(),
-      };
-      Self { inner }
-  }
+        let inner = TriggerResponse {
+            store,
+            events: res.iter().map(|e| e.into()).collect(),
+        };
+        Self { inner }
+    }
 
-  pub fn store(&self) -> String {
-      self.inner.store.clone()
-  }
+    pub fn store(&self) -> String {
+        self.inner.store.clone()
+    }
 
-  pub fn events(&self) -> RArray {
-      self.inner
-          .events
-          .iter()
-          .map(|e| RTriggerEvent::from(e))
-          .collect()
-  }
+    pub fn events(&self) -> magnus::RArray {
+        let ruby = Ruby::get().unwrap();
+        let array = ruby.ary_new();
+        for e in &self.inner.events {
+            let _ = array.push(RTriggerEvent::from(e));
+        }
+        array
+    }
 }
 
 impl From<TriggerResponse> for RTriggerResponse {
-  fn from(value: TriggerResponse) -> Self {
-      Self { inner: value }
-  }
+    fn from(value: TriggerResponse) -> Self {
+        Self { inner: value }
+    }
 }

data/ext/app_bridge/wit/{world.wit → v3/world.wit}

@@ -275,9 +275,12 @@ interface http {
   }
 }
 
+// Note: v3 does NOT include the file interface
+
 world bridge {
   import http;
   import environment;
+  // Note: file interface is NOT available in v3
   export triggers;
   export actions;
 }