host_extensions/

registry.rs

use crate::trait_def::{HostExtension, HostPushEvent};

/// Registry of active extensions for an app instance.
///
/// Built from the app's manifest permissions and stored on the SPA tab.
/// The registry owns the extension objects and provides the glue between
/// the native WKScriptMessageHandler callbacks and each extension's handler.
pub struct ExtensionRegistry {
    extensions: Vec<Box<dyn HostExtension>>,
}

impl Default for ExtensionRegistry {
    fn default() -> Self {
        Self::new()
    }
}

impl ExtensionRegistry {
    pub fn new() -> Self {
        Self {
            extensions: Vec::new(),
        }
    }

    /// Register an extension.
    pub fn register(&mut self, ext: Box<dyn HostExtension>) {
        log::info!(
            "[host-extensions] registering extension: namespace={} channel={}",
            ext.namespace(),
            ext.channel()
        );
        self.extensions.push(ext);
    }

    /// Get all registered extensions.
    pub fn extensions(&self) -> &[Box<dyn HostExtension>] {
        &self.extensions
    }

    /// Returns the concatenated JS injection scripts for all registered extensions.
    ///
    /// Inject this string into the WebView after `HOST_API_BRIDGE_SCRIPT` so
    /// that `window.host.ext` is populated before the SPA's own scripts run.
    pub fn combined_inject_script(&self) -> String {
        // Initialise window.host.ext if the core bridge hasn't done so yet.
        let mut out = String::from(
            "(function(){\
                if(!window.host){window.host={};}\
                if(!window.host.ext){window.host.ext={};}\
            })();\n",
        );
        for ext in &self.extensions {
            out.push_str(ext.inject_script());
            out.push('\n');
        }
        out
    }

    /// Returns all channel names that need WKScriptMessageHandler registration.
    pub fn channels(&self) -> Vec<&str> {
        self.extensions.iter().map(|e| e.channel()).collect()
    }

    /// Find extensions by channel name and dispatch a message to the first
    /// one that claims the method.
    ///
    /// Returns the serialized JSON result, or `None` for fire-and-forget
    /// messages and unknown channels.
    pub fn dispatch(&self, channel: &str, method: &str, params: &str) -> Option<String> {
        log::info!("[host-extensions] dispatch channel={channel} method={method}");
        self.extensions
            .iter()
            .filter(|ext| ext.channel() == channel)
            .find_map(|ext| ext.handle_message(method, params))
    }

    /// Drain queued push events from all registered extensions.
    pub fn drain_events(&self) -> Vec<HostPushEvent> {
        self.extensions
            .iter()
            .flat_map(|ext| ext.drain_events())
            .collect()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    struct EchoExtension;

    impl HostExtension for EchoExtension {
        fn namespace(&self) -> &str {
            "echo"
        }
        fn channel(&self) -> &str {
            "hostEchoBridge"
        }
        fn inject_script(&self) -> &str {
            "// echo inject"
        }
        fn handle_message(&self, method: &str, params: &str) -> Option<String> {
            Some(format!(r#"{{"method":"{method}","params":{params}}}"#))
        }
    }

    #[test]
    fn register_and_dispatch() {
        let mut registry = ExtensionRegistry::new();
        registry.register(Box::new(EchoExtension));

        assert_eq!(registry.channels(), vec!["hostEchoBridge"]);

        let result = registry.dispatch("hostEchoBridge", "ping", r#"{"x":1}"#);
        assert_eq!(
            result,
            Some(r#"{"method":"ping","params":{"x":1}}"#.to_string())
        );
    }

    #[test]
    fn dispatch_unknown_channel_returns_none() {
        let registry = ExtensionRegistry::new();
        assert!(registry.dispatch("nope", "ping", "{}").is_none());
    }

    #[test]
    fn combined_inject_script_contains_extension_script() {
        let mut registry = ExtensionRegistry::new();
        registry.register(Box::new(EchoExtension));
        let script = registry.combined_inject_script();
        assert!(script.contains("// echo inject"));
        assert!(script.contains("window.host.ext"));
    }

    struct EmptySharedChannel;

    impl HostExtension for EmptySharedChannel {
        fn namespace(&self) -> &str {
            "empty"
        }
        fn channel(&self) -> &str {
            "hostBridge"
        }
        fn inject_script(&self) -> &str {
            "// empty"
        }
        fn handle_message(&self, _method: &str, _params: &str) -> Option<String> {
            None
        }
    }

    struct MeshLikeSharedChannel;

    impl HostExtension for MeshLikeSharedChannel {
        fn namespace(&self) -> &str {
            "mesh"
        }
        fn channel(&self) -> &str {
            "hostBridge"
        }
        fn inject_script(&self) -> &str {
            "// mesh"
        }
        fn handle_message(&self, method: &str, _params: &str) -> Option<String> {
            (method == "meshStatus").then(|| r#"{"health":"healthy"}"#.to_string())
        }
    }

    struct EventfulExtension;

    impl HostExtension for EventfulExtension {
        fn namespace(&self) -> &str {
            "events"
        }
        fn channel(&self) -> &str {
            "hostBridge"
        }
        fn inject_script(&self) -> &str {
            "// events"
        }
        fn handle_message(&self, _method: &str, _params: &str) -> Option<String> {
            None
        }
        fn drain_events(&self) -> Vec<HostPushEvent> {
            vec![HostPushEvent {
                event: "meshTopic".into(),
                payload_json: r#"{"topic":"room/1"}"#.into(),
            }]
        }
    }

    #[test]
    fn dispatch_tries_all_extensions_on_shared_channel() {
        let mut registry = ExtensionRegistry::new();
        registry.register(Box::new(EmptySharedChannel));
        registry.register(Box::new(MeshLikeSharedChannel));

        let result = registry.dispatch("hostBridge", "meshStatus", "{}");
        assert_eq!(result, Some(r#"{"health":"healthy"}"#.to_string()));
    }

    #[test]
    fn drain_events_collects_from_registered_extensions() {
        let mut registry = ExtensionRegistry::new();
        registry.register(Box::new(EventfulExtension));

        let events = registry.drain_events();
        assert_eq!(
            events,
            vec![HostPushEvent {
                event: "meshTopic".into(),
                payload_json: r#"{"topic":"room/1"}"#.into(),
            }]
        );
    }
}