app_bridge 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 57425690652a5ffb8ee07849e313b01b14935419f6426772533d393feb69f476
-  data.tar.gz: 3c3ba85a77a936e8340c34dd485ddcf8c03c4c0caf5eef25ea680cedea35e817
+  metadata.gz: b349dc494a4c86924b7afc65d116b4d9bc43ba48ade3e7baa053440c7ce01d58
+  data.tar.gz: 8287685338c6d02170acf83a88148ad42503566163d09b1715656685512b9551
 SHA512:
-  metadata.gz: ae8b6a79d31ec201e87802161b2f3a42ac8fbff62c17b80a3025d2c1c937a5d099cc53932428cb5a52a1da8e9aee26b4212f6d13c128f830c8ad0cc6ec536e62
-  data.tar.gz: c4a55014ffe5b8e477c343a95b59a92c2a8fb170b4296efa96a6f32021b936915fc1724a88af0c8d473799960e602e6fa11dcae2f3e309b7f3a20207af3a87b1
+  metadata.gz: 2170946cd76e4752b4f1318554c722e99f36a890d1478d054c76190e9d3dd1ae00e5bc443e8e9733aa41d666e57aaf49e5349a9a6e9d0d912c756a853226ffe2
+  data.tar.gz: 4fdac8243830792bf317c8cea2c24234236189d042bf8fa9f76e278bf7977067d1ce59be8369e23f99353a41305d728a1e7723437099ddf6b6ed70fe093ee457

data/.tool-versions

@@ -0,0 +1 @@
+ruby 3.4.2

data/Cargo.lock

@@ -1752,9 +1752,9 @@ dependencies = [
 
 [[package]]
 name = "ring"
-version = "0.17.11"
+version = "0.17.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da5349ae27d3887ca812fb375b45a4fbb36d8d12d2df394968cd86e35683fe73"
+checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
 dependencies = [
  "cc",
  "cfg-if",

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

data/ext/app_bridge/wit/world.wit

@@ -1,4 +1,4 @@
-package standout:app@0.3.0;
+package standout:app@2.0.0;
 
 interface types {
   // The trigger-store is a string that is used to store data between trigger
@@ -59,24 +59,62 @@ interface types {
     // ensure that the event is only triggered once per order update.
     id: string,
 
-    // The timestamp of the event.
-    // Must be a unix timestamp in milliseconds since epoch (UTC).
-    // In JavaScript `Date.now()` can be used to get the current timestamp in
-    // milliseconds.
-    timestamp: u64,
-
     // Serialized data must be a JSON object serialized into a string
     // Note that it is important that the root is a object, not an array,
     // or another primitive type.
     serialized-data: string,
   }
+
+  /// A structured error that can be returned by for example a call to a trigger or action.
+  /// Contains a machine-readable code and a human-readable message.
+  record app-error {
+    /// The error code identifying the type of failure.
+    code: error-code,
+
+    /// A human-readable message describing the error in more detail.
+    message: string,
+  }
+
+  /// An enumeration of error codes that can be returned by a trigger implementation.
+  /// These codes help the platform and plugin developers distinguish between different types of failures.
+  variant error-code {
+    /// Authentication failed. Typically due to an invalid or expired API key or token.
+    unauthenticated,
+
+    /// Authorization failed. The account is valid but does not have the necessary permissions.
+    forbidden,
+
+    /// The trigger is misconfigured. For example, a required setting is missing or invalid.
+    misconfigured,
+
+    /// The target system does not support a required feature or endpoint.
+    unsupported,
+
+    /// The target system is rate-limiting requests. Try again later.
+    rate-limit,
+
+    /// The request timed out. The target system did not respond in time.
+    timeout,
+
+    /// The target system is currently unavailable or unreachable.
+    unavailable,
+
+    /// An unexpected internal error occurred in the plugin.
+    internal-error,
+
+    /// The response from the external system could not be parsed or was in an invalid format.
+    malformed-response,
+
+    /// A catch-all for all other types of errors. Should include a descriptive message.
+    other,
+  }
 }
 
 
 interface triggers {
-  use types.{trigger-context, trigger-event, trigger-response};
+  use types.{trigger-context, trigger-event, trigger-response, app-error};
 
-  get-triggers: func() -> list<string>;
+  trigger-ids: func() -> result<list<string>, app-error>;
 
   // Fetch events
   //
@@ -99,7 +137,7 @@ interface triggers {
   // the same events. That will ensure that the user that is building an
   // integration with your trigger will not miss any events if your system is
   // down for a short period of time.
-  fetch-events: func(context: trigger-context) -> trigger-response;
+  fetch-events: func(context: trigger-context) -> result<trigger-response, app-error>;
 }
 
 interface http {

data/lib/app_bridge/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AppBridge
-  VERSION = "1.0.0"
+  VERSION = "2.0.0"
 end

data/tasks/fixtures.rake

@@ -2,36 +2,43 @@
 
 require "English"
 
-namespace :fixtures do
+namespace :fixtures do # rubocop:disable Metrics/BlockLength
   namespace :apps do
     desc "Clean up build artifacts"
     task :clean do
-      # In context of the path spec/fixtures/components/example.
+      # In context of the path spec/fixtures/components/rust_app.
       # Execute cargo clean.
       #
-      pwd = "spec/fixtures/components/example"
+      pwd = "spec/fixtures/components/rust_app"
       pid = Process.spawn("cargo clean", chdir: pwd)
       Process.wait(pid)
       raise "Failed to clean build artifacts" unless $CHILD_STATUS.success?
 
       # Remove the built wasm artifact.
-      pid = Process.spawn("rm example.wasm", chdir: "spec/fixtures/components")
+      pid = Process.spawn("rm rust_app.wasm", chdir: "spec/fixtures/components")
       Process.wait(pid)
     end
 
     desc "Compile the fixture apps"
-    task :compile do
-      pwd = "spec/fixtures/components/example"
+    task :compile_rust do
+      pwd = "spec/fixtures/components/rust_app"
       compile_pid = Process.spawn("cargo clean && cargo build --release --target wasm32-wasip2",
                                   chdir: pwd)
       Process.wait(compile_pid)
       raise "Failed to build artifacts" unless $CHILD_STATUS.success?
 
-      move_pid = Process.spawn("mv #{pwd}/target/wasm32-wasip2/release/example.wasm #{pwd}/../example.wasm")
+      move_pid = Process.spawn("mv #{pwd}/target/wasm32-wasip2/release/rust_app.wasm #{pwd}/../rust_app.wasm")
       Process.wait(move_pid)
     end
+
+    task :compile_js do
+      pwd = "spec/fixtures/components/js_app"
+      pid = Process.spawn("npm run build", chdir: pwd)
+      Process.wait(pid)
+      raise "Failed to build artifacts" unless $CHILD_STATUS.success?
+    end
   end
 end
 
 desc "Build all fixtures"
-task fixtures: %i[fixtures:apps:clean fixtures:apps:compile]
+task fixtures: %i[fixtures:apps:clean fixtures:apps:compile_rust fixtures:apps:compile_js]

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: app_bridge
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Alexander Ross
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-04-03 00:00:00.000000000 Z
+date: 2025-04-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -36,6 +35,7 @@ extra_rdoc_files: []
 files:
 - ".rspec"
 - ".rubocop.yml"
+- ".tool-versions"
 - CHANGELOG.md
 - Cargo.lock
 - Cargo.toml
@@ -45,8 +45,15 @@ files:
 - ext/app_bridge/extconf.rb
 - ext/app_bridge/src/app_state.rs
 - ext/app_bridge/src/component.rs
+- ext/app_bridge/src/error_mapping.rs
 - ext/app_bridge/src/lib.rs
 - ext/app_bridge/src/request_builder.rs
+- ext/app_bridge/src/wrappers/account.rs
+- ext/app_bridge/src/wrappers/app.rs
+- ext/app_bridge/src/wrappers/mod.rs
+- ext/app_bridge/src/wrappers/trigger_context.rs
+- ext/app_bridge/src/wrappers/trigger_event.rs
+- ext/app_bridge/src/wrappers/trigger_response.rs
 - ext/app_bridge/wit/world.wit
 - lib/app_bridge.rb
 - lib/app_bridge/app.rb
@@ -61,7 +68,6 @@ metadata:
   source_code_uri: https://github.com/standout/app_bridge
   changelog_uri: https://github.com/standout/app_bridge/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -77,8 +83,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 3.3.11
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Communication layer for Standout integration apps
 test_files: []