app_bridge 1.0.0 → 2.0.1

data/Cargo.toml

@@ -5,4 +5,4 @@
 [workspace]
 members = ["./ext/app_bridge"]
 resolver = "2"
-exclude = ["./spec/fixtures/components/example"]
+exclude = ["./spec/fixtures/components/rust_app"]

data/ext/app_bridge/src/error_mapping.rs

@@ -0,0 +1,30 @@
+use crate::component::standout::app::types::{AppError, ErrorCode};
+use magnus::{self, Error, Ruby, ExceptionClass};
+
+impl From<ErrorCode> for ExceptionClass {
+  fn from(value: ErrorCode) -> Self {
+    fn get_class(name: &str) -> ExceptionClass {
+        let ruby = Ruby::get().unwrap();
+        ruby.eval::<ExceptionClass>(name).unwrap()
+    }
+
+    match value {
+        ErrorCode::Unauthenticated => get_class("AppBridge::UnauthenticatedError"),
+        ErrorCode::Forbidden => get_class("AppBridge::ForbiddenError"),
+        ErrorCode::Misconfigured => get_class("AppBridge::MisconfiguredError"),
+        ErrorCode::Unsupported => get_class("AppBridge::UnsupportedError"),
+        ErrorCode::RateLimit => get_class("AppBridge::RateLimitError"),
+        ErrorCode::Timeout => get_class("AppBridge::TimeoutError"),
+        ErrorCode::Unavailable => get_class("AppBridge::UnavailableError"),
+        ErrorCode::InternalError => get_class("AppBridge::InternalError"),
+        ErrorCode::MalformedResponse => get_class("AppBridge::MalformedResponseError"),
+        ErrorCode::Other => get_class("AppBridge::OtherError"),
+    }
+  }
+}
+
+impl From<AppError> for Error {
+  fn from(value: AppError) -> Self {
+      Error::new(value.code.into(), value.message)
+  }
+}

data/ext/app_bridge/src/lib.rs

@@ -1,274 +1,32 @@
-use magnus::{function, method, prelude::*, Error, RArray, Ruby, TryConvert, Value};
-use std::cell::RefCell;
-use wasmtime::Store;
+use magnus::{function, method, prelude::*, Error, Ruby};
 mod app_state;
 mod component;
 mod request_builder;
+mod error_mapping;
 
-use app_state::AppState;
-use component::standout::app::types::{Account, TriggerContext, TriggerEvent, TriggerResponse};
-use component::{app, build_engine, build_linker, build_store, Bridge};
-
-#[derive(Default)]
-pub struct RApp {
-    component_path: String,
-    instance: RefCell<Option<Bridge>>,
-    store: RefCell<Option<Store<AppState>>>,
-}
-
-#[derive(Default)]
-#[magnus::wrap(class = "AppBridge::App")]
-struct MutRApp(RefCell<RApp>);
-
-impl MutRApp {
-    fn initialize(&self, component_path: String) {
-        let mut this = self.0.borrow_mut();
-        let engine = build_engine();
-        let linker = build_linker(&engine).unwrap();
-        let mut store = build_store(&engine);
-
-        let app = app(component_path.clone(), engine, &mut store, linker).unwrap();
-
-        this.component_path = component_path.to_string();
-        *this.instance.borrow_mut() = Some(app);
-        *this.store.borrow_mut() = Some(store);
-    }
-
-    fn triggers(&self) -> Vec<String> {
-        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) {
-            instance
-                .standout_app_triggers()
-                .call_get_triggers(store)
-                .unwrap()
-        } else {
-            vec![]
-        }
-    }
-
-    fn rb_fetch_events(&self, context: Value) -> RTriggerResponse {
-        let context: RTriggerContext = TryConvert::try_convert(context).unwrap();
-        let response = self.fetch_events(context.inner);
-
-        RTriggerResponse::from_trigger_response(response)
-    }
-
-    fn fetch_events(&self, context: TriggerContext) -> TriggerResponse {
-        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) {
-            instance
-                .standout_app_triggers()
-                .call_fetch_events(store, &context)
-                .unwrap()
-        } else {
-            TriggerResponse {
-                store: context.store,
-                events: vec![],
-            }
-        }
-    }
-}
-
-#[magnus::wrap(class = "AppBridge::Account")]
-struct RAccount {
-    inner: Account,
-}
-
-impl RAccount {
-    fn new(id: String, name: String, serialized_data: String) -> Self {
-        let inner = Account {
-            id: id,
-            name: name,
-            serialized_data: serialized_data,
-        };
-        Self { inner }
-    }
-
-    fn id(&self) -> String {
-        self.inner.id.clone()
-    }
-
-    fn name(&self) -> String {
-        self.inner.name.clone()
-    }
-
-    fn serialized_data(&self) -> String {
-        self.inner.serialized_data.clone()
-    }
-}
-
-impl Clone for RAccount {
-    fn clone(&self) -> Self {
-        Self {
-            inner: self.inner.clone(),
-        }
-    }
-}
-
-impl TryConvert for RAccount {
-    fn try_convert(val: Value) -> Result<Self, Error> {
-        let id: String = val.funcall("id", ())?;
-        let name: String = val.funcall("name", ())?;
-        let serialized_data: String = val.funcall("serialized_data", ())?;
-
-        let inner = Account {
-            id,
-            name,
-            serialized_data,
-        };
-
-        Ok(Self { inner })
-    }
-}
-
-#[magnus::wrap(class = "AppBridge::TriggerContext")]
-struct RTriggerContext {
-    inner: TriggerContext,
-    wrapped_account: RAccount,
-}
-
-impl RTriggerContext {
-    fn new(trigger_id: String, account: Value, store: String) -> Self {
-        let account: RAccount = TryConvert::try_convert(account).unwrap();
-
-        let inner = TriggerContext {
-            trigger_id: trigger_id,
-            account: account.clone().inner,
-            store: store,
-        };
-        Self {
-            inner,
-            wrapped_account: account.clone(),
-        }
-    }
-
-    fn trigger_id(&self) -> String {
-        self.inner.trigger_id.clone()
-    }
-
-    fn account(&self) -> RAccount {
-        self.wrapped_account.clone()
-    }
-
-    fn store(&self) -> String {
-        self.inner.store.clone()
-    }
-}
-
-impl TryConvert for RTriggerContext {
-    fn try_convert(val: Value) -> Result<Self, Error> {
-        let account_val: Value = val.funcall("account", ())?;
-        let store: String = val.funcall("store", ())?;
-        let trigger_id: String = val.funcall("trigger_id", ())?;
-
-        let account: RAccount = TryConvert::try_convert(account_val).unwrap();
-
-        let inner = TriggerContext {
-            trigger_id: trigger_id,
-            account: account.clone().inner,
-            store: store,
-        };
-
-        Ok(Self {
-            inner,
-            wrapped_account: account.clone(),
-        })
-    }
-}
-
-#[magnus::wrap(class = "AppBridge::TriggerResponse")]
-struct RTriggerResponse {
-    inner: TriggerResponse,
-}
-
-impl RTriggerResponse {
-    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();
-
-        let inner = TriggerResponse {
-            store: store,
-            events: res.iter().map(|e| e.inner.clone()).collect(),
-        };
-        Self { inner }
-    }
-
-    fn from_trigger_response(inner: TriggerResponse) -> Self {
-        Self { inner }
-    }
-
-    fn store(&self) -> String {
-        self.inner.store.clone()
-    }
-
-    fn events(&self) -> RArray {
-        self.inner
-            .events
-            .iter()
-            .map(|e| RTriggerEvent::new(e.id.clone(), e.timestamp, e.serialized_data.clone()))
-            .collect()
-    }
-}
-
-#[magnus::wrap(class = "AppBridge::TriggerEvent")]
-struct RTriggerEvent {
-    inner: TriggerEvent,
-}
-
-impl RTriggerEvent {
-    fn new(id: String, timestamp: u64, serialized_data: String) -> Self {
-        let inner = TriggerEvent {
-            id: id,
-            timestamp: timestamp,
-            serialized_data: serialized_data,
-        };
-        Self { inner }
-    }
-
-    fn id(&self) -> String {
-        self.inner.id.clone()
-    }
-
-    fn timestamp(&self) -> u64 {
-        self.inner.timestamp
-    }
-
-    fn serialized_data(&self) -> String {
-        self.inner.serialized_data.clone()
-    }
-}
-
-impl TryConvert for RTriggerEvent {
-    fn try_convert(val: Value) -> Result<Self, Error> {
-        let id: String = val.funcall("id", ())?;
-        let timestamp: u64 = val.funcall("timestamp", ())?;
-        let serialized_data: String = val.funcall("serialized_data", ())?;
-
-        let inner = TriggerEvent {
-            id,
-            timestamp,
-            serialized_data,
-        };
-
-        Ok(Self { inner })
-    }
-}
+mod wrappers;
+use wrappers::account::RAccount;
+use wrappers::trigger_context::RTriggerContext;
+use wrappers::trigger_event::RTriggerEvent;
+use wrappers::trigger_response::RTriggerResponse;
+use wrappers::app::MutRApp;
 
 #[magnus::init]
 fn init(ruby: &Ruby) -> Result<(), Error> {
     let module = ruby.define_module("AppBridge")?;
 
+    let error = module.define_error("Error", ruby.exception_standard_error())?;
+    module.define_error("UnauthenticatedError", error)?;
+    module.define_error("ForbiddenError", error)?;
+    module.define_error("MisconfiguredError", error)?;
+    module.define_error("UnsupportedError", error)?;
+    module.define_error("RateLimitError", error)?;
+    module.define_error("TimeoutError", error)?;
+    module.define_error("UnavailableError", error)?;
+    module.define_error("InternalError", 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))?;
@@ -277,9 +35,8 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     account_class.define_method("serialized_data", method!(RAccount::serialized_data, 0))?;
 
     let trigger_event_class = module.define_class("TriggerEvent", ruby.class_object())?;
-    trigger_event_class.define_singleton_method("new", function!(RTriggerEvent::new, 3))?;
+    trigger_event_class.define_singleton_method("new", function!(RTriggerEvent::new, 2))?;
     trigger_event_class.define_method("id", method!(RTriggerEvent::id, 0))?;
-    trigger_event_class.define_method("timestamp", method!(RTriggerEvent::timestamp, 0))?;
     trigger_event_class.define_method(
         "serialized_data",
         method!(RTriggerEvent::serialized_data, 0),
@@ -300,9 +57,8 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     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("triggers", method!(MutRApp::triggers, 0))?;
+    app_class.define_method("trigger_ids", method!(MutRApp::trigger_ids, 0))?;
     app_class.define_private_method("_rust_fetch_events", method!(MutRApp::rb_fetch_events, 1))?;
 
-
     Ok(())
 }

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

@@ -0,0 +1,60 @@
+use magnus::{prelude::*, Error, TryConvert, Value};
+use crate::component::standout::app::types::Account;
+
+#[magnus::wrap(class = "AppBridge::Account")]
+pub struct RAccount {
+    pub inner: Account,
+}
+
+impl RAccount {
+    pub fn new(id: String, name: String, serialized_data: String) -> Self {
+        let inner = Account {
+            id: id,
+            name: name,
+            serialized_data: serialized_data,
+        };
+        Self { inner }
+    }
+
+    pub fn id(&self) -> String {
+        self.inner.id.clone()
+    }
+
+    pub fn name(&self) -> String {
+        self.inner.name.clone()
+    }
+
+    pub fn serialized_data(&self) -> String {
+        self.inner.serialized_data.clone()
+    }
+}
+
+impl Clone for RAccount {
+    fn clone(&self) -> Self {
+        Self {
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+impl TryConvert for RAccount {
+    fn try_convert(val: Value) -> Result<Self, Error> {
+        let id: String = val.funcall("id", ())?;
+        let name: String = val.funcall("name", ())?;
+        let serialized_data: String = val.funcall("serialized_data", ())?;
+
+        let inner = Account {
+            id,
+            name,
+            serialized_data,
+        };
+
+        Ok(Self { inner })
+    }
+}
+
+impl From<RAccount> for Account {
+    fn from(raccount: RAccount) -> Self {
+        raccount.inner
+    }
+}

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

@@ -0,0 +1,114 @@
+use magnus::{Error, TryConvert, Value};
+use std::cell::RefCell;
+use wasmtime::Store;
+
+use crate::app_state::AppState;
+use crate::component::standout::app::types::{TriggerContext, TriggerResponse, AppError, ErrorCode};
+use crate::component::{app, build_engine, build_linker, build_store, Bridge};
+use super::trigger_context::RTriggerContext;
+
+use super::trigger_response::RTriggerResponse;
+
+#[derive(Default)]
+pub struct RApp {
+    component_path: String,
+    instance: RefCell<Option<Bridge>>,
+    store: RefCell<Option<Store<AppState>>>,
+}
+
+#[derive(Default)]
+#[magnus::wrap(class = "AppBridge::App")]
+pub struct MutRApp(RefCell<RApp>);
+
+impl MutRApp {
+    pub fn initialize(&self, component_path: String) {
+        let mut this = self.0.borrow_mut();
+        let engine = build_engine();
+        let linker = build_linker(&engine).unwrap();
+        let mut store = build_store(&engine);
+
+        let app = app(component_path.clone(), engine, &mut store, linker).unwrap();
+
+        this.component_path = component_path.to_string();
+        *this.instance.borrow_mut() = Some(app);
+        *this.store.borrow_mut() = Some(store);
+    }
+
+    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())
+                    }
+                },
+                Err(err) => {
+                  if let Some(wit_err) = err.downcast_ref::<AppError>() {
+                      Err(wit_err.clone().into())
+                  } else {
+                      Err(AppError {
+                          code: ErrorCode::InternalError,
+                          message: format!("Unexpected error: {:?}", err),
+                      }.into())
+                  }
+                },
+            }
+        } else {
+            Err(AppError {
+                code: ErrorCode::InternalError,
+                message: "App instance couln't be initialized".to_string(),
+            }.into())
+        }
+    }
+
+    pub fn rb_fetch_events(&self, context: Value) -> Result<RTriggerResponse, magnus::Error> {
+        let context: RTriggerContext = TryConvert::try_convert(context).unwrap();
+        let response = self.fetch_events(context.into());
+
+        match response {
+            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),
+                    }
+                },
+                Err(err) => {
+                    if let Some(wit_err) = err.downcast_ref::<AppError>() {
+                        Err(AppError::from(wit_err.clone()))
+                    } else {
+                        Err(AppError {
+                            code: ErrorCode::InternalError,
+                            message: format!("Unexpected error: {:?}", err),
+                        })
+                    }
+                }
+            }
+        } else {
+            Err(AppError {
+                code: ErrorCode::InternalError,
+                message: "App instance couln't be initialized".to_string(),
+            })
+        }
+    }
+}

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

@@ -0,0 +1,5 @@
+pub mod account;
+pub mod trigger_context;
+pub mod trigger_response;
+pub mod trigger_event;
+pub mod app;

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

@@ -0,0 +1,64 @@
+use magnus::{prelude::*, Error, TryConvert, Value};
+use crate::component::standout::app::types::TriggerContext;
+use super::account::RAccount;
+
+#[magnus::wrap(class = "AppBridge::TriggerContext")]
+pub struct RTriggerContext {
+    inner: TriggerContext,
+    wrapped_account: RAccount,
+}
+
+impl RTriggerContext {
+    pub fn new(trigger_id: String, account: Value, store: String) -> Self {
+        let account: RAccount = TryConvert::try_convert(account).unwrap();
+
+        let inner = TriggerContext {
+            trigger_id: trigger_id,
+            account: account.clone().into(),
+            store: store,
+        };
+        Self {
+            inner,
+            wrapped_account: account.clone(),
+        }
+    }
+
+    pub fn trigger_id(&self) -> String {
+        self.inner.trigger_id.clone()
+    }
+
+    pub fn account(&self) -> RAccount {
+        self.wrapped_account.clone()
+    }
+
+    pub fn store(&self) -> String {
+        self.inner.store.clone()
+    }
+}
+
+impl TryConvert for RTriggerContext {
+    fn try_convert(val: Value) -> Result<Self, Error> {
+        let account_val: Value = val.funcall("account", ())?;
+        let store: String = val.funcall("store", ())?;
+        let trigger_id: String = val.funcall("trigger_id", ())?;
+
+        let account: RAccount = TryConvert::try_convert(account_val).unwrap();
+
+        let inner = TriggerContext {
+            trigger_id: trigger_id,
+            account: account.clone().inner,
+            store: store,
+        };
+
+        Ok(Self {
+            inner,
+            wrapped_account: account.clone(),
+        })
+    }
+}
+
+impl From<RTriggerContext> for TriggerContext {
+    fn from(rtrigger_context: RTriggerContext) -> Self {
+        rtrigger_context.inner
+    }
+}

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

@@ -0,0 +1,63 @@
+use magnus::{prelude::*, Error, TryConvert, Value};
+use crate::component::standout::app::types::TriggerEvent;
+
+#[magnus::wrap(class = "AppBridge::TriggerEvent")]
+pub struct RTriggerEvent {
+    inner: TriggerEvent,
+}
+
+impl RTriggerEvent {
+    pub fn new(id: String, serialized_data: String) -> Self {
+        let inner: TriggerEvent = TriggerEvent {
+            id: id,
+            serialized_data: serialized_data,
+        };
+        Self { inner }
+    }
+
+    pub fn id(&self) -> String {
+        self.inner.id.clone()
+    }
+
+    pub fn serialized_data(&self) -> String {
+        self.inner.serialized_data.clone()
+    }
+}
+
+impl TryConvert for RTriggerEvent {
+    fn try_convert(val: Value) -> Result<Self, Error> {
+        let id: String = val.funcall("id", ())?;
+        let serialized_data: String = val.funcall("serialized_data", ())?;
+
+        let inner = TriggerEvent {
+            id,
+            serialized_data,
+        };
+
+        Ok(Self { inner })
+    }
+}
+
+impl From<RTriggerEvent> for TriggerEvent {
+    fn from(rtrigger_event: RTriggerEvent) -> Self {
+        rtrigger_event.inner
+    }
+}
+
+impl From<TriggerEvent> for RTriggerEvent {
+    fn from(trigger_event: TriggerEvent) -> Self {
+        Self { inner: trigger_event }
+    }
+}
+
+impl From<&RTriggerEvent> for TriggerEvent {
+    fn from(rtrigger_event: &RTriggerEvent) -> Self {
+        rtrigger_event.inner.clone()
+    }
+}
+
+impl From<&TriggerEvent> for RTriggerEvent {
+    fn from(trigger_event: &TriggerEvent) -> Self {
+        Self { inner: trigger_event.clone() }
+    }
+}

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

@@ -0,0 +1,42 @@
+use magnus::{Error, RArray, TryConvert};
+use crate::component::standout::app::types::TriggerResponse;
+use super::trigger_event::RTriggerEvent;
+
+#[magnus::wrap(class = "AppBridge::TriggerResponse")]
+pub struct RTriggerResponse {
+  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();
+
+      let inner = TriggerResponse {
+          store: store,
+          events: res.iter().map(|e| e.into()).collect(),
+      };
+      Self { inner }
+  }
+
+  pub fn store(&self) -> String {
+      self.inner.store.clone()
+  }
+
+  pub fn events(&self) -> RArray {
+      self.inner
+          .events
+          .iter()
+          .map(|e| RTriggerEvent::from(e))
+          .collect()
+  }
+}
+
+impl From<TriggerResponse> for RTriggerResponse {
+  fn from(value: TriggerResponse) -> Self {
+      Self { inner: value }
+  }
+}