app_bridge 3.0.0 → 4.1.0

data/ext/app_bridge/src/component.rs

@@ -1,25 +1,338 @@
-use std::result::Result::Ok;
 use std::collections::HashMap;
-use wasmtime::component::{bindgen, Component, Linker};
+use std::result::Result::Ok;
+use wasmtime::component::{Component, Linker};
 use wasmtime::{Engine, Result, Store};
-use wasmtime_wasi::WasiCtxBuilder;
-
-bindgen!({
-    path: "./wit",
-    world: "bridge",
-});
+use wasmtime_wasi::p2::WasiCtxBuilder;
 
 use crate::app_state::AppState;
+use crate::types::{
+    ActionContext, ActionResponse, AppError, Connection, ErrorCode, TriggerContext,
+    ReferenceObject, TriggerEvent, TriggerResponse,
+};
+
+// ============================================================================
+// WIT version modules
+//
+// To add a new version:
+// 1. Add a new pub mod vN { bindgen!(...) }
+// 2. Add impl_conversions!(vN) below
+// 3. Add variant to BridgeWrapper enum
+// 4. Add to build_linker() and app() functions
+// 5. Add arm to each bridge_method! in BridgeWrapper impl
+// ============================================================================
+
+pub mod v3 {
+    wasmtime::component::bindgen!({
+        path: "./wit/v3",
+        world: "bridge",
+    });
+}
+
+pub mod v4 {
+    wasmtime::component::bindgen!({
+        path: "./wit/v4",
+        world: "bridge",
+    });
+}
+
+pub mod v4_1 {
+    wasmtime::component::bindgen!({
+        path: "./wit/v4_1",
+        world: "bridge",
+    });
+}
+
+// ============================================================================
+// Version conversion macro - generates From impls for a version module
+// ============================================================================
+
+macro_rules! impl_error_code_conversion {
+    ($v:ident, $($extra_arms:tt)*) => {
+        impl From<$v::standout::app::types::ErrorCode> for ErrorCode {
+            fn from(c: $v::standout::app::types::ErrorCode) -> Self {
+                use $v::standout::app::types::ErrorCode as V;
+                match c {
+                    V::Unauthenticated => Self::Unauthenticated,
+                    V::Forbidden => Self::Forbidden,
+                    V::Misconfigured => Self::Misconfigured,
+                    V::Unsupported => Self::Unsupported,
+                    V::RateLimit => Self::RateLimit,
+                    V::Timeout => Self::Timeout,
+                    V::Unavailable => Self::Unavailable,
+                    V::InternalError => Self::InternalError,
+                    V::MalformedResponse => Self::MalformedResponse,
+                    V::Other => Self::Other,
+                    $($extra_arms)*
+                    V::CompleteWorkflow => Self::CompleteWorkflow,
+                    V::CompleteParent => Self::CompleteParent,
+                }
+            }
+        }
+    };
+}
+
+macro_rules! impl_conversions {
+    ($v:ident) => {
+        // TriggerEvent: version → canonical
+        impl From<$v::standout::app::types::TriggerEvent> for TriggerEvent {
+            fn from(e: $v::standout::app::types::TriggerEvent) -> Self {
+                Self { id: e.id, serialized_data: e.serialized_data }
+            }
+        }
+
+        // TriggerResponse: version → canonical
+        impl From<$v::standout::app::types::TriggerResponse> for TriggerResponse {
+            fn from(r: $v::standout::app::types::TriggerResponse) -> Self {
+                Self {
+                    store: r.store,
+                    events: r.events.into_iter().map(Into::into).collect(),
+                }
+            }
+        }
+
+        // ActionResponse: version → canonical
+        impl From<$v::standout::app::types::ActionResponse> for ActionResponse {
+            fn from(r: $v::standout::app::types::ActionResponse) -> Self {
+                Self { serialized_output: r.serialized_output }
+            }
+        }
+
+        // Connection: canonical → version (for passing to components)
+        impl From<&Connection> for $v::standout::app::types::Connection {
+            fn from(c: &Connection) -> Self {
+                Self {
+                    id: c.id.clone(),
+                    name: c.name.clone(),
+                    serialized_data: c.serialized_data.clone(),
+                }
+            }
+        }
+
+        // TriggerContext: canonical → version
+        impl From<&TriggerContext> for $v::standout::app::types::TriggerContext {
+            fn from(c: &TriggerContext) -> Self {
+                Self {
+                    trigger_id: c.trigger_id.clone(),
+                    connection: (&c.connection).into(),
+                    store: c.store.clone(),
+                    serialized_input: c.serialized_input.clone(),
+                }
+            }
+        }
+
+    };
+}
+
+macro_rules! impl_app_error_conversion {
+    ($v:ident) => {
+        impl From<$v::standout::app::types::AppError> for AppError {
+            fn from(e: $v::standout::app::types::AppError) -> Self {
+                Self {
+                    code: e.code.into(),
+                    message: e.message,
+                }
+            }
+        }
+    };
+}
+
+macro_rules! impl_action_context_conversion_basic {
+    ($v:ident) => {
+        impl From<&ActionContext> for $v::standout::app::types::ActionContext {
+            fn from(c: &ActionContext) -> Self {
+                Self {
+                    action_id: c.action_id.clone(),
+                    connection: (&c.connection).into(),
+                    serialized_input: c.serialized_input.clone(),
+                }
+            }
+        }
+    };
+}
+
+macro_rules! impl_action_context_conversion_retry {
+    ($v:ident) => {
+        impl From<&ActionContext> for $v::standout::app::types::ActionContext {
+            fn from(c: &ActionContext) -> Self {
+                Self {
+                    action_id: c.action_id.clone(),
+                    connection: (&c.connection).into(),
+                    serialized_input: c.serialized_input.clone(),
+                    reference_object: c.reference_object.as_ref().map(Into::into),
+                }
+            }
+        }
+    };
+}
+
+impl From<v4_1::standout::app::types::ReferenceObject> for ReferenceObject {
+    fn from(r: v4_1::standout::app::types::ReferenceObject) -> Self {
+        Self {
+            reference: r.reference,
+            status: r.status,
+        }
+    }
+}
+
+impl From<&ReferenceObject> for v4_1::standout::app::types::ReferenceObject {
+    fn from(r: &ReferenceObject) -> Self {
+        Self {
+            reference: r.reference.clone(),
+            status: r.status.clone(),
+        }
+    }
+}
+
+// Generate conversions for all supported versions
+impl_error_code_conversion!(v3,);
+impl_conversions!(v3);
+impl_app_error_conversion!(v3);
+impl_action_context_conversion_basic!(v3);
+impl_error_code_conversion!(v4,);
+impl_conversions!(v4);
+impl_app_error_conversion!(v4);
+impl_action_context_conversion_basic!(v4);
+impl_error_code_conversion!(
+    v4_1,
+    V::RetryWithReference(r) => Self::RetryWithReference(r.into()),
+);
+impl_conversions!(v4_1);
+impl_app_error_conversion!(v4_1);
+impl_action_context_conversion_retry!(v4_1);
+
+// ============================================================================
+// BridgeWrapper - unified interface for all component versions
+//
+// To add vN: add variant BridgeWrapper::VN(vN::Bridge)
+// ============================================================================
+
+pub enum BridgeWrapper {
+    V3(v3::Bridge),
+    V4(v4::Bridge),
+    V4_1(v4_1::Bridge),
+}
+
+impl BridgeWrapper {
+    /// Returns the WIT version this component was built against
+    pub fn wit_version(&self) -> &'static str {
+        match self {
+            BridgeWrapper::V3(_) => "3.0.0",
+            BridgeWrapper::V4(_) => "4.0.0",
+            BridgeWrapper::V4_1(_) => "4.1.0",
+        }
+    }
+}
+
+/// Macro to implement a bridge method that works across all versions.
+/// Each version's result is converted to canonical types.
+macro_rules! bridge_method {
+    // Simple no-arg method (e.g., trigger_ids, action_ids)
+    (fn $name:ident() -> Result<$ok_type:ty> via $interface:ident . $method:ident) => {
+        pub fn $name(&self, store: &mut Store<AppState>) -> Result<std::result::Result<$ok_type, AppError>> {
+            match self {
+                BridgeWrapper::V3(b) => {
+                    let r = b.$interface().$method(store)?;
+                    Ok(r.map_err(Into::into))
+                }
+                BridgeWrapper::V4(b) => {
+                    let r = b.$interface().$method(store)?;
+                    Ok(r.map_err(Into::into))
+                }
+                BridgeWrapper::V4_1(b) => {
+                    let r = b.$interface().$method(store)?;
+                    Ok(r.map_err(Into::into))
+                }
+            }
+        }
+    };
+    // Method with TriggerContext
+    (fn $name:ident(&TriggerContext) -> Result<$ok_type:ty> via $interface:ident . $method:ident) => {
+        pub fn $name(&self, store: &mut Store<AppState>, ctx: &TriggerContext) -> Result<std::result::Result<$ok_type, AppError>> {
+            match self {
+                BridgeWrapper::V3(b) => {
+                    let r = b.$interface().$method(store, &ctx.into())?;
+                    Ok(r.map(Into::into).map_err(Into::into))
+                }
+                BridgeWrapper::V4(b) => {
+                    let r = b.$interface().$method(store, &ctx.into())?;
+                    Ok(r.map(Into::into).map_err(Into::into))
+                }
+                BridgeWrapper::V4_1(b) => {
+                    let r = b.$interface().$method(store, &ctx.into())?;
+                    Ok(r.map(Into::into).map_err(Into::into))
+                }
+            }
+        }
+    };
+    // Method with ActionContext
+    (fn $name:ident(&ActionContext) -> Result<$ok_type:ty> via $interface:ident . $method:ident) => {
+        pub fn $name(&self, store: &mut Store<AppState>, ctx: &ActionContext) -> Result<std::result::Result<$ok_type, AppError>> {
+            match self {
+                BridgeWrapper::V3(b) => {
+                    let r = b.$interface().$method(store, &ctx.into())?;
+                    Ok(r.map(Into::into).map_err(Into::into))
+                }
+                BridgeWrapper::V4(b) => {
+                    let r = b.$interface().$method(store, &ctx.into())?;
+                    Ok(r.map(Into::into).map_err(Into::into))
+                }
+                BridgeWrapper::V4_1(b) => {
+                    let r = b.$interface().$method(store, &ctx.into())?;
+                    Ok(r.map(Into::into).map_err(Into::into))
+                }
+            }
+        }
+    };
+}
+
+impl BridgeWrapper {
+    // Trigger methods
+    bridge_method!(fn call_trigger_ids() -> Result<Vec<String>> via standout_app_triggers . call_trigger_ids);
+    bridge_method!(fn call_trigger_input_schema(&TriggerContext) -> Result<String> via standout_app_triggers . call_input_schema);
+    bridge_method!(fn call_trigger_output_schema(&TriggerContext) -> Result<String> via standout_app_triggers . call_output_schema);
+    bridge_method!(fn call_fetch_events(&TriggerContext) -> Result<TriggerResponse> via standout_app_triggers . call_fetch_events);
+
+    // Action methods
+    bridge_method!(fn call_action_ids() -> Result<Vec<String>> via standout_app_actions . call_action_ids);
+    bridge_method!(fn call_action_input_schema(&ActionContext) -> Result<String> via standout_app_actions . call_input_schema);
+    bridge_method!(fn call_action_output_schema(&ActionContext) -> Result<String> via standout_app_actions . call_output_schema);
+    bridge_method!(fn call_execute(&ActionContext) -> Result<ActionResponse> via standout_app_actions . call_execute);
+}
+
+// ============================================================================
+// Builder functions
+// ============================================================================
 
 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)?;
-    standout::app::environment::add_to_linker(&mut linker, |s| s)?;
+    let mut linker = Linker::<AppState>::new(engine);
+
+    // WASI support (shared by all versions)
+    wasmtime_wasi::p2::add_to_linker_sync(&mut linker)?;
+
+    // ---- Version-specific interfaces ----
+    // v3: http + environment
+    v3::standout::app::http::add_to_linker(&mut linker, |s| s)?;
+    v3::standout::app::environment::add_to_linker(&mut linker, |s| s)?;
+
+    // v4: http + environment + file
+    v4::standout::app::http::add_to_linker(&mut linker, |s| s)?;
+    v4::standout::app::environment::add_to_linker(&mut linker, |s| s)?;
+    v4::standout::app::file::add_to_linker(&mut linker, |s| s)?;
+
+    // v4.1: http + environment + file
+    v4_1::standout::app::http::add_to_linker(&mut linker, |s| s)?;
+    v4_1::standout::app::environment::add_to_linker(&mut linker, |s| s)?;
+    v4_1::standout::app::file::add_to_linker(&mut linker, |s| s)?;
+
+    // Add new versions here:
+    // v5::standout::app::http::add_to_linker(&mut linker, |s| s)?;
+    // v5::standout::app::environment::add_to_linker(&mut linker, |s| s)?;
+    // v5::standout::app::file::add_to_linker(&mut linker, |s| s)?;
+    // v5::standout::app::new_feature::add_to_linker(&mut linker, |s| s)?;
 
     Ok(linker)
 }
@@ -27,54 +340,42 @@ pub fn build_linker(engine: &Engine) -> Result<Linker<AppState>> {
 pub fn build_store(engine: &Engine, env_vars: Option<HashMap<String, String>>) -> Store<AppState> {
     let mut builder = WasiCtxBuilder::new();
 
-    // Add environment variables to WASI context if provided
     if let Some(env_vars) = &env_vars {
         for (key, value) in env_vars {
             builder.env(key, value);
         }
     }
 
-    let ctx = builder.build();
-
-    // Create AppState with or without environment variables
-    let app_state = AppState::new(ctx, env_vars);
-
-    Store::new(&engine, app_state)
+    Store::new(engine, AppState::new(builder.build(), env_vars))
 }
 
+/// Try to instantiate a WASM component.
+/// Attempts versions from newest to oldest until one succeeds.
 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)?;
-
-    // Try to instantiate the component - if it fails due to missing interface,
-    // we'll catch that error and return a specific message
-    match Bridge::instantiate(store, &component, &linker) {
-        Ok(instance) => Ok(instance),
-        Err(e) => {
-            if e.to_string().contains("no exported instance") {
-                Err(wasmtime::Error::msg(
-                    "Incompatible WASM file version"
-                ))
-            } else {
-                Err(e)
-            }
-        }
+) -> Result<BridgeWrapper> {
+    let component = Component::from_file(&engine, &file_path)?;
+
+    // Try versions newest-first. When adding vN, insert at the top.
+    // v4.1 (current - has file interface)
+    if let Ok(instance) = v4_1::Bridge::instantiate(&mut *store, &component, &linker) {
+        return Ok(BridgeWrapper::V4_1(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, None);
-        let linker = build_linker(&engine).unwrap();
-        let instant = app(file_path.to_string(), engine, &mut store, linker);
+    // v4
+    if let Ok(instance) = v4::Bridge::instantiate(&mut *store, &component, &linker) {
+        return Ok(BridgeWrapper::V4(instance));
+    }
 
-        instant.unwrap()
+    // v3 (legacy - no file interface)
+    if let Ok(instance) = v3::Bridge::instantiate(&mut *store, &component, &linker) {
+        return Ok(BridgeWrapper::V3(instance));
     }
+
+    Err(wasmtime::Error::msg(
+        "Failed to instantiate component: no compatible WIT version found (tried v4.1, v4, v3)",
+    ))
 }

data/ext/app_bridge/src/error_mapping.rs

@@ -1,32 +1,48 @@
-use crate::component::standout::app::types::{AppError, ErrorCode};
-use magnus::{self, Error, Ruby, ExceptionClass};
+use crate::types::{AppError, ErrorCode};
+use magnus::prelude::*;
+use magnus::{Error, ExceptionClass, RObject, Ruby};
 
 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()
-    }
+    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"),
-        ErrorCode::CompleteWorkflow => get_class("AppBridge::CompleteWorkflowException"),
-        ErrorCode::CompleteParent => get_class("AppBridge::CompleteParentException"),
+        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"),
+            ErrorCode::RetryWithReference(_) => get_class("AppBridge::RetryWithReferenceError"),
+            ErrorCode::CompleteWorkflow => get_class("AppBridge::CompleteWorkflowException"),
+            ErrorCode::CompleteParent => get_class("AppBridge::CompleteParentException"),
+        }
     }
-  }
 }
 
 impl From<AppError> for Error {
-  fn from(value: AppError) -> Self {
-      Error::new(value.code.into(), value.message)
-  }
+    fn from(value: AppError) -> Self {
+        if let ErrorCode::RetryWithReference(retry) = value.code.clone() {
+            let class: ExceptionClass = value.code.into();
+            let message = value.message;
+            if let Ok(exception) = class.new_instance((message.as_str(),)) {
+                if let Ok(exception_value) = RObject::try_convert(exception.as_value()) {
+                    let _ = exception_value.ivar_set("@reference", retry.reference);
+                    let _ = exception_value.ivar_set("@status", retry.status);
+                }
+                return Error::from(exception);
+            }
+
+            return Error::new(class, message);
+        }
+
+        Error::new(value.code.into(), value.message)
+    }
 }