app_bridge 0.1.0

data/Cargo.toml

@@ -0,0 +1,8 @@
+# This Cargo.toml is here to let externals tools (IDEs, etc.) know that this is
+# a Rust project. Your extensions dependencies should be added to the Cargo.toml
+# in the ext/ directory.
+
+[workspace]
+members = ["./ext/app_bridge"]
+resolver = "2"
+exclude = ["./spec/fixtures/components/example"]

data/README.md

@@ -0,0 +1,73 @@
+# Standout App Bridge
+
+`app_bridge` is a Ruby gem designed to facilitate communication with WebAssembly components that implement the WIT specification `standout:app`. This gem is developed for use in Standout's products.
+
+## Installation
+
+Add the following line to your `Gemfile`:
+
+```ruby
+gem 'app_bridge', github: 'standout/app_bridge'
+```
+
+Then, install the gem by running:
+
+```bash
+bundle install
+```
+
+## Usage
+
+To use this gem, you need a WebAssembly component that adheres to the specification defined in `ext/app_bridge/wit/world.wit`.
+
+You can check out the example components in `spec/fixtures/components` to see how such a component should be structured.
+
+Once you have a WebAssembly component, you can use the gem as follows:
+
+```ruby
+require 'app_bridge'
+
+app = AppBridge::App.new('path/to/your/component.wasm')
+app.triggers # => ['trigger1', 'trigger2']
+```
+
+More documentation and features will be added as the gem evolves.
+
+## Development
+
+To contribute or modify this gem, ensure you have the following dependencies installed:
+
+- **Ruby 3.3.0** (or later)
+- **Rust 1.84.0** (or later)
+
+### Setting Up the Development Environment
+
+Run the following command to setup and install additional dependencies:
+
+```bash
+bin/setup
+```
+
+Then, to compile example applications, run tests, and perform syntax checks, execute:
+
+```bash
+rake
+```
+
+### Useful Commands
+
+- **Interactive Console:** Run `bin/console` to interactively test the code.
+- **Full Test Suite & Linting:** Run `rake` to compile, execute tests, and perform syntax checks.
+- **Run Tests Only:** Execute `rake spec` to run only the test suite.
+- **Linting:** Run `rake rubocop` to check code style and formatting.
+- **Compile Example Applications:** Use `rake fixtures` to build the example apps.
+
+To install this gem locally for testing purposes, run:
+
+```bash
+bundle exec rake install
+```
+
+## Release & Distribution
+
+This gem is **not** published to RubyGems. It is intended for internal use within Standout's products only.

data/Rakefile

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+require "rb_sys/extensiontask"
+
+task build: :compile
+
+GEMSPEC = Gem::Specification.load("app_bridge.gemspec")
+
+RbSys::ExtensionTask.new("app_bridge", GEMSPEC) do |ext|
+  ext.lib_dir = "lib/app_bridge"
+end
+
+# Load all project specific rake tasks
+Dir.glob(File.expand_path("tasks/**/*.rake", __dir__)).each { |file| load file }
+
+task default: %i[fixtures compile spec rubocop]

data/ext/app_bridge/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "app_bridge"
+version = "0.1.0"
+edition = "2021"
+authors = ["Alexander Ross <ross@standout.se>"]
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+magnus = { version = "0.7.1" }
+anyhow = "1.0.95"
+wasmtime = "29.0.1"
+wasmtime-wasi = "29.0.1"
+wasmtime-cli = "29.0.1"
+wasmtime-component-util = "29.0.1"
+reqwest = { version = "0.12", features = ["blocking", "json"] }
+tokio = { version = "1", features = ["full"] }

data/ext/app_bridge/extconf.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "mkmf"
+require "rb_sys/mkmf"
+
+create_rust_makefile("app_bridge/app_bridge")

data/ext/app_bridge/src/app_state.rs

@@ -0,0 +1,46 @@
+use crate::component::standout;
+use crate::component::standout::app::http::Request;
+use reqwest::blocking::Client;
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex};
+use wasmtime::component::ResourceTable;
+use wasmtime_wasi::{WasiCtx, WasiCtxBuilder, WasiView};
+
+pub struct AppState {
+    ctx: WasiCtx,
+    table: ResourceTable,
+    pub client: Arc<Mutex<Client>>,
+    pub request_list: HashMap<u32, Request>,
+    pub next_request_id: u32,
+}
+
+impl AppState {
+    pub fn new(ctx: WasiCtx) -> Self {
+        Self {
+            ctx,
+            table: ResourceTable::new(),
+            client: Arc::new(Mutex::new(Client::new())),
+            request_list: HashMap::new(),
+            next_request_id: 0,
+        }
+    }
+}
+
+impl standout::app::http::Host for AppState {
+    // Impl http host methods here
+}
+
+impl WasiView for AppState {
+    fn ctx(&mut self) -> &mut WasiCtx {
+        &mut self.ctx
+    }
+    fn table(&mut self) -> &mut ResourceTable {
+        &mut self.table
+    }
+}
+
+impl Default for AppState {
+    fn default() -> Self {
+        Self::new(WasiCtxBuilder::new().build())
+    }
+}

data/ext/app_bridge/src/component.rs

@@ -0,0 +1,55 @@
+use std::result::Result::Ok;
+use wasmtime::component::{bindgen, Component, Linker};
+use wasmtime::{Engine, Result, Store};
+use wasmtime_wasi::WasiCtxBuilder;
+
+bindgen!();
+
+use crate::app_state::AppState;
+
+pub fn build_engine() -> Engine {
+    Engine::default()
+}
+
+pub fn build_linker(engine: &Engine) -> Result<Linker<AppState>> {
+    let mut linker = Linker::<AppState>::new(&engine);
+    wasmtime_wasi::add_to_linker_sync(&mut linker)?;
+    standout::app::http::add_to_linker(&mut linker, |s| s)?;
+
+    Ok(linker)
+}
+
+pub fn build_store(engine: &Engine) -> Store<AppState> {
+    let builder = WasiCtxBuilder::new().build();
+
+    // ... configure `builder` more to add env vars, args, etc ...
+
+    let store = Store::new(&engine, AppState::new(builder));
+
+    store
+}
+
+pub fn app(
+    file_path: String,
+    engine: Engine,
+    store: &mut Store<AppState>,
+    linker: Linker<AppState>,
+) -> Result<Bridge> {
+    // Load the application component from the file system.
+    let component = Component::from_file(&engine, file_path)?;
+    let instance = Bridge::instantiate(store, &component, &linker)?;
+
+    Ok(instance)
+}
+
+impl Default for Bridge {
+    fn default() -> Self {
+        let file_path = "spec/fixtures/components/example_app.wasm";
+        let engine = Engine::default();
+        let mut store = build_store(&engine);
+        let linker = build_linker(&engine).unwrap();
+        let instant = app(file_path.to_string(), engine, &mut store, linker);
+
+        instant.unwrap()
+    }
+}

data/ext/app_bridge/src/lib.rs

@@ -0,0 +1,307 @@
+use magnus::{function, method, prelude::*, Error, RArray, Ruby, TryConvert, Value};
+use std::cell::RefCell;
+use wasmtime::Store;
+mod app_state;
+mod component;
+mod request_builder;
+
+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 })
+    }
+}
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let module = ruby.define_module("AppBridge")?;
+
+    // Define the Accout class
+    let account_class = module.define_class("Account", ruby.class_object())?;
+    account_class.define_singleton_method("new", function!(RAccount::new, 3))?;
+    account_class.define_method("id", method!(RAccount::id, 0))?;
+    account_class.define_method("name", method!(RAccount::name, 0))?;
+    account_class.define_method("serialized_data", method!(RAccount::serialized_data, 0))?;
+
+    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_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),
+    )?;
+
+    let trigger_response_class = module.define_class("TriggerResponse", ruby.class_object())?;
+    trigger_response_class.define_singleton_method("new", function!(RTriggerResponse::new, 2))?;
+    trigger_response_class.define_method("store", method!(RTriggerResponse::store, 0))?;
+    trigger_response_class.define_method("events", method!(RTriggerResponse::events, 0))?;
+
+    let trigger_context_class = module.define_class("TriggerContext", ruby.class_object())?;
+    trigger_context_class.define_singleton_method("new", function!(RTriggerContext::new, 3))?;
+    trigger_context_class.define_method("trigger_id", method!(RTriggerContext::trigger_id, 0))?;
+    trigger_context_class.define_method("account", method!(RTriggerContext::account, 0))?;
+    trigger_context_class.define_method("store", method!(RTriggerContext::store, 0))?;
+
+    // Define the App class
+    let app_class = module.define_class("App", ruby.class_object())?;
+    app_class.define_alloc_func::<MutRApp>();
+    app_class.define_method("initialize", method!(MutRApp::initialize, 1))?;
+    app_class.define_method("triggers", method!(MutRApp::triggers, 0))?;
+    app_class.define_method("fetch_events", method!(MutRApp::rb_fetch_events, 1))?;
+
+    Ok(())
+}