app_bridge 0.1.0

data/ext/app_bridge/src/request_builder.rs

@@ -0,0 +1,196 @@
+use crate::app_state::AppState;
+use crate::component::standout::app::http::{
+    HostRequestBuilder, Method, Request, RequestBuilder, RequestError, Response,
+};
+use reqwest::Method as ReqwestMethod;
+use std::result::Result::Ok;
+use wasmtime::component::Resource;
+
+impl HostRequestBuilder for AppState {
+    fn new(&mut self) -> Resource<RequestBuilder> {
+        let id = self.next_request_id;
+        self.next_request_id += 1;
+        self.request_list.insert(id, Request::default());
+        Resource::new_own(id)
+    }
+
+    fn method(
+        &mut self,
+        self_: Resource<RequestBuilder>,
+        method: Method,
+    ) -> Resource<RequestBuilder> {
+        let id = self_.rep();
+        let mut request = self.request_list.get(&id).cloned().unwrap();
+        request.method = method;
+        let new_id = self.next_request_id;
+        self.next_request_id += 1;
+        self.request_list.insert(new_id, request);
+        Resource::new_own(new_id)
+    }
+
+    fn url(
+        &mut self,
+        self_: Resource<RequestBuilder>,
+        url: wasmtime::component::__internal::String,
+    ) -> Resource<RequestBuilder> {
+        let id = self_.rep();
+        let mut request = self.request_list.get(&id).cloned().unwrap();
+        request.url = url;
+        let new_id = self.next_request_id;
+        self.next_request_id += 1;
+        self.request_list.insert(new_id, request);
+        Resource::new_own(new_id)
+    }
+
+    #[doc = " Add a header to the request"]
+    fn header(
+        &mut self,
+        self_: Resource<RequestBuilder>,
+        key: wasmtime::component::__internal::String,
+        value: wasmtime::component::__internal::String,
+    ) -> Resource<RequestBuilder> {
+        let id = self_.rep();
+        let mut request = self.request_list.get(&id).cloned().unwrap_or_default();
+        request.headers.push((key, value));
+        let new_id = self.next_request_id;
+        self.next_request_id += 1;
+        self.request_list.insert(new_id, request);
+        Resource::new_own(new_id)
+    }
+
+    fn headers(
+        &mut self,
+        self_: Resource<RequestBuilder>,
+        headers: wasmtime::component::__internal::Vec<(
+            wasmtime::component::__internal::String,
+            wasmtime::component::__internal::String,
+        )>,
+    ) -> Resource<RequestBuilder> {
+        let id = self_.rep();
+        let mut request = self.request_list.get(&id).cloned().unwrap_or_default();
+        for (key, value) in headers {
+            request.headers.push((key, value));
+        }
+        let new_id = self.next_request_id;
+        self.next_request_id += 1;
+        self.request_list.insert(new_id, request);
+        Resource::new_own(new_id)
+    }
+
+    #[doc = " Add a body to the request"]
+    fn body(
+        &mut self,
+        self_: Resource<RequestBuilder>,
+        body: wasmtime::component::__internal::String,
+    ) -> Resource<RequestBuilder> {
+        let id = self_.rep();
+        let mut request = self.request_list.get(&id).cloned().unwrap_or_default();
+        request.body = body;
+        let new_id = self.next_request_id;
+        self.next_request_id += 1;
+        self.request_list.insert(new_id, request);
+        Resource::new_own(new_id)
+    }
+
+    #[doc = " Send the request"]
+    fn send(&mut self, self_: Resource<RequestBuilder>) -> Result<Response, RequestError> {
+        let id = self_.rep();
+        let request = match self.request_list.get(&id).cloned() {
+            Some(request) => request,
+            None => return Err(RequestError::Other("Request not found".to_string())),
+        };
+        let client = self.client.lock().unwrap();
+        let mut request_builder = client.request(request.method.into(), &request.url);
+        for (key, value) in request.headers {
+            request_builder = request_builder.header(key, value);
+        }
+        request_builder = request_builder.body(request.body);
+
+        let response = request_builder.send();
+
+        match response {
+            Ok(resp) => {
+                let mut response = Response::default();
+                response.status = resp.status().as_u16();
+                for (key, value) in resp.headers() {
+                    response.headers.push((
+                        key.as_str().to_string(),
+                        value.to_str().unwrap_or_default().to_string(),
+                    ));
+                }
+                response.body = resp.text().unwrap_or_default();
+                Ok(response)
+            }
+            Err(error) => {
+                let error_message = format!(
+                    "Request failed to {} {}: {}",
+                    request.method,
+                    request.url,
+                    error
+                );
+                let error = RequestError::Other(error_message);
+                Err(error)
+            }
+        }
+    }
+
+    fn drop(&mut self, rep: Resource<RequestBuilder>) -> wasmtime::Result<()> {
+        let id = rep.rep();
+        self.request_list.remove(&id);
+        Ok(())
+    }
+
+    fn object(&mut self, self_: Resource<RequestBuilder>) -> Request {
+        let id = self_.rep();
+        self.request_list.get(&id).cloned().unwrap_or_default()
+    }
+}
+
+impl From<Method> for ReqwestMethod {
+    fn from(method: Method) -> Self {
+        match method {
+            Method::Get => ReqwestMethod::GET,
+            Method::Post => ReqwestMethod::POST,
+            Method::Put => ReqwestMethod::PUT,
+            Method::Delete => ReqwestMethod::DELETE,
+            Method::Patch => ReqwestMethod::PATCH,
+            Method::Head => ReqwestMethod::HEAD,
+            Method::Options => ReqwestMethod::OPTIONS,
+        }
+    }
+}
+
+impl Default for Request {
+    fn default() -> Self {
+        Self {
+            url: "".to_string(),
+            method: Method::Get,
+            body: "".to_string(),
+            headers: Vec::new(),
+        }
+    }
+}
+
+impl Default for Response {
+    fn default() -> Self {
+        Self {
+            status: 0,
+            headers: Vec::new(),
+            body: "".to_string(),
+        }
+    }
+}
+
+impl std::fmt::Display for Method {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Method::Get => write!(f, "GET"),
+            Method::Post => write!(f, "POST"),
+            Method::Put => write!(f, "PUT"),
+            Method::Delete => write!(f, "DELETE"),
+            Method::Patch => write!(f, "PATCH"),
+            Method::Head => write!(f, "HEAD"),
+            Method::Options => write!(f, "OPTIONS"),
+        }
+    }
+}

data/ext/app_bridge/wit/world.wit

@@ -0,0 +1,157 @@
+package standout:app@0.3.0;
+
+interface types {
+  // The trigger-store is a string that is used to store data between trigger
+  // invocations. It is unique per trigger instance and is persisted between
+  // invocations.
+  //
+  // You can store any string here. We suggest that you use a serialized
+  // JSON object or similar since that will give you some flexibility if you
+  // need to add more data to the store.
+  type trigger-store = string;
+
+  record account {
+    id: string,
+    name: string,
+    // The account data is a JSON object serialized into a string. The JSON root
+    // will always be an object.
+    serialized-data: string,
+  }
+
+  record trigger-context {
+    // Trigger ID is a unique identifier for the trigger that is requested to be
+    // invoked.
+    trigger-id: string,
+
+    // The account that the trigger is invoked for.
+    account: account,
+
+    // The store will contain the data that was stored in the trigger store the
+    // last time the trigger was invoked.
+    store: trigger-store,
+  }
+
+  record trigger-response {
+    // The trigger events, each event will be used to spawn a new workflow
+    // execution in Standouts integration plattform.
+    events: list<trigger-event>,
+
+    // The updated store will be stored and used the next time the trigger is
+    // invoked.
+    store: trigger-store,
+  }
+
+  record trigger-event {
+    // The ID of the trigger event
+    //
+    // If the account used for the given instance of the trigger is the same,
+    // as seen before. Then the event will be ignored.
+    //
+    // A scheduler could therefore use an timestamp as the ID, to ensure that
+    // the event is only triggered once per given time.
+    //
+    // A trigger that acts on created orders in a e-commerce system could use
+    // the order ID as the ID, to ensure that the event is only triggered once
+    // per order.
+    //
+    // A trigger that acts on updated orders in a e-commerce system could use
+    // the order ID in combination with an updated at timestamp as the ID, to
+    // 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,
+  }
+}
+
+
+interface triggers {
+  use types.{trigger-context, trigger-event, trigger-response};
+
+  get-triggers: func() -> list<string>;
+
+  // Fetch events
+  //
+  // There are some limitations to the function:
+  // - It must return within 30 seconds
+  // - It must return less than or equal to 100 events
+  //
+  // If you need to fetch more events, you can return up to 100 events and then
+  // store the data needed for you to remember where you left off in the store.
+  // The next time the trigger is invoked, you can use the store to continue
+  // where you left off.
+  //
+  // If you do not pass the limitations the return value will be ignored. We
+  // will not handle any events and we persist the store that was returned in
+  // the response.
+  //
+  // That also means that you should implement your fetch event function in a
+  // way that it can be called multiple times using the same context and return
+  // 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;
+}
+
+interface http {
+  record response {
+    status: u16,
+    headers: headers,
+    body: string,
+  }
+
+  record request {
+    method: method,
+    url: string,
+    headers: headers,
+    body: string,
+  }
+
+  variant request-error {
+    other(string)
+  }
+
+  type headers = list<tuple<string, string>>;
+
+  resource request-builder {
+    constructor();
+
+    method: func(method: method) -> request-builder;
+    url: func(url: string) -> request-builder;
+
+    // Add a header to the request
+    header: func(key: string, value: string) -> request-builder;
+    headers: func(headers: list<tuple<string, string>>) -> request-builder;
+
+    // Add a body to the request
+    body: func(body: string) -> request-builder;
+
+    object: func() -> request;
+
+    // Send the request
+    send: func() -> result<response, request-error>;
+  }
+
+  variant method {
+    get,
+    post,
+    put,
+    delete,
+    patch,
+    options,
+    head,
+  }
+}
+
+world bridge {
+  import http;
+  export triggers;
+}

data/lib/app_bridge/version.rb

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

data/lib/app_bridge.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "app_bridge/version"
+require_relative "app_bridge/app_bridge"
+
+module AppBridge
+  class Error < StandardError; end
+
+  # Represents a trigger event that is recieved from the app.
+  class TriggerEvent
+    def inspect
+      "#<AppBridge::TriggerEvent(id: #{id.inspect}, timestamp: #{timestamp.inspect}, " \
+        "serialized_data: #{serialized_data.inspect})>"
+    end
+  end
+end

data/sig/app_bridge.rbs

@@ -0,0 +1,10 @@
+module AppBridge
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+
+  class App
+    def initialize: (String) -> void
+
+    def triggers : () -> Array[String]
+  end
+end

data/tasks/fixtures.rake

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "English"
+
+namespace :fixtures do
+  namespace :apps do
+    desc "Clean up build artifacts"
+    task :clean do
+      # In context of the path spec/fixtures/components/example.
+      # Execute cargo clean.
+      #
+      pwd = "spec/fixtures/components/example"
+      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")
+      Process.wait(pid)
+    end
+
+    desc "Compile the fixture apps"
+    task :compile do
+      pwd = "spec/fixtures/components/example"
+      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")
+      Process.wait(move_pid)
+    end
+  end
+end
+
+desc "Build all fixtures"
+task fixtures: %i[fixtures:apps:clean fixtures:apps:compile]

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: app_bridge
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Alexander Ross
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-02-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rb_sys
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.91
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.91
+description: The app_bridge gem is designed to enable seamless interaction with WebAssembly
+  components that adhere to the WIT specification `standout:app`. It is developed
+  for use in Standout's products.
+email:
+- ross@standout.se
+executables: []
+extensions:
+- ext/app_bridge/extconf.rb
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- Cargo.lock
+- Cargo.toml
+- README.md
+- Rakefile
+- ext/app_bridge/Cargo.toml
+- ext/app_bridge/extconf.rb
+- ext/app_bridge/src/app_state.rs
+- ext/app_bridge/src/component.rs
+- ext/app_bridge/src/lib.rs
+- ext/app_bridge/src/request_builder.rs
+- ext/app_bridge/wit/world.wit
+- lib/app_bridge.rb
+- lib/app_bridge/version.rb
+- sig/app_bridge.rbs
+- tasks/fixtures.rake
+homepage: https://github.com/standout/app_bridge
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/standout/app_bridge
+  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
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.11
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Communication layer for Standout integration apps
+test_files: []