hookburn-slack 0.2.0

A Rust crate for sending messages to Slack via webhooks
Documentation
// crates/hookburn-slack/src/service.rs
use crate::{
    SlackBlock, SlackClient, SlackError, SlackMessage, SlackSectionBlock, SlackText, SlackTextType,
};
use async_trait::async_trait;
use hookburn_core::{
    BoxedWebhookSender, CoreError, GenericMessage, MessageConverter, Platform, ServiceBuilder,
    ServiceConfig, ServiceInfo, WebhookSender,
};
use reqwest::Client;
use std::sync::Arc;

// ============================================================================
// Slack Service Builder
// ============================================================================

/// Defines Slack Service
pub struct SlackService {
    info: Arc<ServiceInfo>,
}

impl SlackService {
    /// Creates a new wrapper that adapts a Slack Service
    pub fn new() -> Self {
        let info = ServiceInfo {
            name: "slack".to_string(),
            version: env!("CARGO_PKG_VERSION").to_string(),
            description: "Slack webhook integration".to_string(),
            webhook_url_format: "https://hooks.slack.com/services/{T}/{B}/{X}".to_string(),
            supports_embeds: true,
            max_content_length: 4000,
            features: vec![
                "blocks".to_string(),
                "threads".to_string(),
                "attachments".to_string(),
                "markdown".to_string(),
                "buttons".to_string(),
            ],
            rate_limit_retry_after: Some(std::time::Duration::from_secs(1)),
            documentation_url: Some("https://api.slack.com/messaging/webhooks".to_string()),
            icon_url: Some("https://slack.com/favicon.ico".to_string()),
            platforms: vec![Platform::Slack],
        };
        Self { info: Arc::new(info) }
    }
}

impl ServiceBuilder for SlackService {
    fn build(
        &self,
        config: ServiceConfig,
    ) -> Result<BoxedWebhookSender, Box<dyn std::error::Error + Send + Sync>> {
        if !self.validate_url(&config.url) {
            return Err(Box::new(SlackError::InvalidUrl {
                reason: "Invalid Slack webhook URL".to_string(),
            }));
        }

        let client = Client::builder().timeout(config.timeout).build()?;
        let slack_client = SlackClient::with_client(config.url, client)?;

        // Wrap the client to work with GenericMessage
        let wrapper = SlackSenderWrapper::new(slack_client);
        let sender: BoxedWebhookSender = Box::new(wrapper);

        Ok(sender)
    }

    fn info(&self) -> Arc<ServiceInfo> {
        self.info.clone()
    }

    fn validate_url(&self, url: &str) -> bool {
        url.starts_with("https://hooks.slack.com/services/")
    }
}

// ============================================================================
// Slack Sender Wrapper
// ============================================================================

/// Wrapper that adapts SlackClient to work with GenericMessage
pub struct SlackSenderWrapper {
    inner: SlackClient,
    converter: SlackMessageConverter,
}
/// Spacl Sender Wrapper
impl SlackSenderWrapper {
    /// Creates a new wrapper that adapts a Slack client to work with GenericMessage.
    pub fn new(inner: SlackClient) -> Self {
        Self { inner, converter: SlackMessageConverter }
    }
}
#[async_trait]
impl WebhookSender for SlackSenderWrapper {
    type Message = GenericMessage;
    type Error = CoreError;

    async fn send(&self, message: &Self::Message) -> Result<(), Self::Error> {
        // Convert GenericMessage to SlackMessage
        let slack_message = self
            .converter
            .to_service(message)
            .map_err(|e| CoreError::MessageConversionFailed(e.to_string()))?;

        // Send using the inner client
        self.inner
            .send(&slack_message)
            .await
            .map_err(|e| CoreError::ServiceError(e.to_string()))
    }
}

// ============================================================================
// Slack Message Converter
// ============================================================================

/// Converter between GenericMessage and SlackMessage
pub struct SlackMessageConverter;

impl MessageConverter<SlackMessage> for SlackMessageConverter {
    fn to_service(&self, generic: &GenericMessage) -> Result<SlackMessage, CoreError> {
        let mut builder = SlackMessage::builder();

        if let Some(content) = &generic.content {
            builder = builder.text(content);
        }
        if let Some(username) = &generic.username {
            builder = builder.username(username);
        }
        if let Some(avatar_url) = &generic.avatar_url {
            builder = builder.icon_url(avatar_url);
        }

        // Convert embeds to Slack blocks
        for embed in &generic.embeds {
            let mut text = String::new();
            if let Some(title) = &embed.title {
                text.push_str(&format!("*{}*\n", title));
            }
            if let Some(description) = &embed.description {
                text.push_str(&format!("{}\n", description));
            }
            for field in &embed.fields {
                text.push_str(&format!("*{}:* {}\n", field.name, field.value));
            }

            if !text.is_empty() {
                builder = builder.block(SlackBlock::Section(SlackSectionBlock {
                    text: Some(SlackText { text_type: SlackTextType::Mrkdwn, text, emoji: None }),
                    fields: vec![],
                    accessory: None,
                }));
            }
        }

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

    fn to_generic(&self, service_msg: &SlackMessage) -> Result<GenericMessage, CoreError> {
        let mut generic = GenericMessage::default();
        generic.content = service_msg.text.clone();
        generic.username = service_msg.username.clone();
        generic.avatar_url = service_msg.icon_url.clone();
        // Convert Slack blocks to generic embeds (simplified)
        Ok(generic)
    }
}