hookburn-core 0.2.2

Shared HTTP client and WebhookSender trait for the Hookburn crates
Documentation
// crates/hookburn-core/src/registry.rs
use crate::error::CoreError;
use crate::service::{ServiceBuilder, ServiceConfig, ServiceInfo};
use crate::webhook_service::BoxedWebhookSender;
use rustc_hash::FxHashMap;
use std::sync::Arc;

/// Registry for discovering and creating webhook services
#[derive(Default, Clone)]
pub struct WebhookRegistry {
    services: Arc<FxHashMap<String, Arc<ServiceInfo>>>,
    // Remove the associated type from here
    builders: Arc<FxHashMap<String, Arc<dyn ServiceBuilder + Send + Sync>>>,
}

impl WebhookRegistry {
    /// Create a new empty registry
    pub fn new() -> Self {
        Self::default()
    }

    /// Register a service builder
    pub fn register<S>(&mut self, builder: S)
    where
        S: ServiceBuilder + Send + Sync + 'static,
    {
        let info = builder.info();
        let name = info.name.clone();

        // Get mutable access to the maps
        let mut services = match Arc::try_unwrap(std::mem::take(&mut self.services)) {
            Ok(map) => map,
            Err(arc) => (*arc).clone(),
        };
        let mut builders = match Arc::try_unwrap(std::mem::take(&mut self.builders)) {
            Ok(map) => map,
            Err(arc) => (*arc).clone(),
        };

        services.insert(name.clone(), info);
        builders.insert(name, Arc::new(builder));

        self.services = Arc::new(services);
        self.builders = Arc::new(builders);
    }

    /// Get information about a specific service
    pub fn get_service_info(&self, name: &str) -> Option<Arc<ServiceInfo>> {
        self.services.get(name).cloned()
    }

    /// List all registered services
    pub fn list_services(&self) -> Vec<Arc<ServiceInfo>> {
        self.services.values().cloned().collect()
    }

    /// Create a sender for a specific service
    pub fn create_sender(
        &self,
        service_name: &str,
        config: ServiceConfig,
    ) -> Result<BoxedWebhookSender, CoreError> {
        let builder = self
            .builders
            .get(service_name)
            .ok_or_else(|| CoreError::ServiceNotFound(service_name.to_string()))?;

        builder
            .build(config)
            .map_err(|e| CoreError::ServiceCreationFailed(e.to_string()))
    }

    /// Check if a service is registered
    pub fn has_service(&self, name: &str) -> bool {
        self.services.contains_key(name)
    }
}