viam_bridge_sdk/

bridge.rs

use async_trait::async_trait;
use tokio::runtime::Runtime;
use std::{any::{Any, TypeId}, sync::Arc};
use serde_json::Value;
use anyhow::Result;
use std::collections::HashMap;

#[derive(Clone, Debug, Default)]
pub struct Context {
    pub component_id: Option<String>,
    pub tracing: HashMap<String, String>,
    // You could add more fields as needed:
    // pub request_id: Option<String>,
    // pub timestamp: Option<u64>,
}

pub struct BridgeContext {
    runtime: Arc<Runtime>,
    // Add other context fields as needed
}

impl BridgeContext {
    pub fn new(runtime: Arc<Runtime>) -> Self {
        Self { runtime }
    }
    
    pub fn runtime(&self) -> Arc<Runtime> {
        self.runtime.clone()
    }
}

/// Interface for bridge instances that can be used at runtime
#[async_trait]
pub trait BridgeInstance: Send + Sync {  
    /// Get instance as Any for downcasting
    fn as_any(&self) -> &dyn Any;

    fn is_async(&self) -> bool {
        false // Default to sync
    }
    
    /// Get all interfaces exposed by this bridge instance
    fn get_interfaces(&self) -> Vec<BridgeInterface>;
    
    /// Dispatch a function call to this bridge instance
    fn dispatch_call(
        &self,
        context: &Context,
        interface_name: &str,
        function_name: &str,
        args: &[wasmtime::component::Val],
        //store: &mut wasmtime::StoreContextMut<'_, ComApiWasmHost>,
    ) -> Result<Vec<wasmtime::component::Val>, Box<dyn std::error::Error>>;

    async fn dispatch_call_async(
        &self,
        context: &Context,
        interface_name: &str,
        function_name: &str,
        args: &[wasmtime::component::Val],
        //store: &mut wasmtime::StoreContextMut<'_, ComApiWasmHost>,
        //host_state: &mut ComApiWasmHost,
    ) -> Result<Vec<wasmtime::component::Val>, Box<dyn std::error::Error + Send + Sync>>;

    //fn register_with_host(&self, linker: &mut wasmtime::component::Linker<ComApiWasmHost>, host: &mut ComApiWasmHost) ->  Result<()>; //anyhow::Result<Vec<(String, Box<dyn Fn<(wasmtime::StoreContextMut<'_, ComApiWasmHost>,), Output=anyhow::Result<(String,)>> + Send + 'static>)>>;
}

/// Represents a function parameter or result
pub struct BridgeType {
    /// The type of the parameter or result
    pub ty: wasmtime::component::Type,
    /// Optional name of the parameter (for documentation)
    pub name: Option<String>,
}

/// Represents a function exposed by a bridge
pub struct BridgeFunc {
    /// Name of the function
    pub name: String,
    /// Parameters of the function
    pub params: Vec<BridgeType>,
    /// Results of the function
    pub results: Vec<BridgeType>,
    /// Optional documentation
    pub docs: Option<String>,
}

/// Represents an interface exposed by a bridge
pub struct BridgeInterface {
    /// Full name of the interface (e.g., "postgres-bridge:db/db@0.1.0")
    pub full_name: String,
    /// Base namespace of the interface (e.g., "postgres-bridge:db")
    pub namespace: String,
    /// Functions exposed by this interface
    pub functions: Vec<BridgeFunc>,
}

/// Core trait for extension bridges - these methods are all dyn-compatible
pub trait ExtensionBridge: Send + Sync {
    /// Get the bridge's name
    fn name(&self) -> &str;
    
    /// Get the list of interfaces that this bridge provides
    fn interfaces(&self) -> Vec<&str>;
    
    /// Initialize the bridge with configuration
    fn initialize(&mut self, config: Value) -> Result<()>;
    
    /// Create bridge instances
    fn create_instances(&self) -> Result<Vec<Arc<dyn BridgeInstance>>>;
    
    /// Get the bridge as Any for downcasting
    fn as_any(&self) -> &dyn Any;
    
    /// Get the bridge as mutable Any for downcasting
    fn as_any_mut(&mut self) -> &mut dyn Any;
    
    /// Get an object ID to uniquely identify this bridge
    fn object_id(&self) -> TypeId;
}

/// Type-erased registry callback
pub struct TypedRegistryCallback {
    /// The type ID of the host type this callback works with
    pub host_type_id: TypeId,
    
    /// The callback function, erased to an Any type
    callback: Box<dyn Any + Send + Sync>,
}

impl TypedRegistryCallback {
    // Create a new typed registry callback for a specific host type
    // pub fn new<T: Send + 'static>(
    //     callback: Box<dyn Fn(&mut Linker<T>, Box<dyn Fn(&T) -> &HostData + Send + Sync>) -> Result<()> + Send + Sync>
    // ) -> Self {
    //     Self {
    //         host_type_id: TypeId::of::<T>(),
    //         callback: Box::new(callback) as Box<dyn Any + Send + Sync>,
    //     }
    // }
    
    // /// Try to use this callback with a specific host type
    // pub fn call<T: Send + 'static>(
    //     &self,
    //     linker: &mut Linker<T>,
    //     host_accessor: Box<dyn Fn(&T) -> &HostData + Send + Sync>
    // ) -> Result<()> {
    //     if self.host_type_id != TypeId::of::<T>() {
    //         return Err(anyhow::anyhow!("Type mismatch in registry callback"));
    //     }
        
    //     let callback = self.callback
    //         .downcast_ref::<Box<dyn Fn(&mut Linker<T>, Box<dyn Fn(&T) -> &HostData + Send + Sync>) -> Result<()> + Send + Sync>>()
    //         .ok_or_else(|| anyhow::anyhow!("Failed to downcast registry callback"))?;
            
    //     callback(linker, host_accessor)
    // }
}

/// Bridge type registry trait - handles registration for specific host types
/// This is intentionally separate from ExtensionBridge to maintain dyn-compatibility
pub trait BridgeTypeRegistry: Send + Sync {
    /// Register a callback for a specific host type
    fn register_callback(&mut self, callback: TypedRegistryCallback);
    
    /// Get callbacks that match a specific host type ID
    fn get_callbacks_for(&self, host_type_id: TypeId) -> Vec<&TypedRegistryCallback>;
}

/// Combined trait for extension bridges that also support type registry
pub trait ExtensionBridgeWithRegistry: ExtensionBridge + BridgeTypeRegistry {}

// Auto-implement the combined trait for any type that implements both traits
impl<T> ExtensionBridgeWithRegistry for T 
where 
    T: ExtensionBridge + BridgeTypeRegistry
{}