use crate::domain::models::{Webhook, WebhookEvent, WebhookEventType};
use crate::domain::repositories::webhook_event_repository::WebhookEventRepository;
use crate::domain::repositories::webhook_repository::WebhookRepository;
use crate::domain::services::webhook_event_builder::WebhookEventBuilder;
use crate::domain::services::webhook_service::{WebhookManagementService, WebhookService};
use anyhow::{anyhow, Result};
use async_trait::async_trait;
use log::{error, info};
use std::sync::Arc;
#[cfg(feature = "webhook")]
pub struct WebhookManagementServiceImpl {
webhook_repository: Arc<dyn WebhookRepository>,
event_repository: Arc<dyn WebhookEventRepository>,
webhook_service: Arc<dyn WebhookService>,
}
#[cfg(feature = "webhook")]
impl WebhookManagementServiceImpl {
pub fn new(
webhook_repository: Arc<dyn WebhookRepository>,
event_repository: Arc<dyn WebhookEventRepository>,
webhook_service: Arc<dyn WebhookService>,
) -> Self {
Self {
webhook_repository,
event_repository,
webhook_service,
}
}
async fn find_webhook_or_err(&self, webhook_id: crate::domain::id::Id) -> Result<Webhook> {
self.webhook_repository
.find_by_id(webhook_id)
.await
.map_err(|e| anyhow!("Failed to find webhook {}: {}", webhook_id, e))?
.ok_or_else(|| anyhow!("Webhook not found: {}", webhook_id))
}
async fn create_processing_event(&self, event: &WebhookEvent) -> Result<()> {
self.event_repository
.create(event)
.await
.map_err(|e| anyhow!("Failed to create webhook event: {}", e))?;
Ok(())
}
async fn send_event_inline(&self, event: &mut WebhookEvent) -> Result<()> {
if let Err(e) = self.webhook_service.send_webhook(event).await {
error!("Failed to send webhook event {}: {}", event.id, e);
event.status = crate::domain::models::WebhookStatus::Failed;
event.next_retry_at = Some(chrono::Utc::now() + chrono::Duration::seconds(5));
if let Err(update_err) = self.event_repository.update(event).await {
error!(
"Failed to schedule retry for webhook event {}: {}",
event.id, update_err
);
}
return Err(e);
}
event.status = crate::domain::models::WebhookStatus::Delivered;
event.delivered_at = Some(chrono::Utc::now());
if let Err(update_err) = self.event_repository.update(event).await {
error!(
"Failed to mark webhook event {} delivered (attempt 1/2), retrying: {}",
event.id, update_err
);
if let Err(retry_err) = self.event_repository.update(event).await {
error!(
"CRITICAL: webhook event {} was delivered externally but status \
write-back failed after retry: {}; returning Err \
(sent-but-status-unknown, dedup relies on event msg_id idempotency)",
event.id, retry_err
);
return Err(anyhow!(
"webhook event {} delivered but status write-back failed: {}",
event.id,
retry_err
));
}
}
Ok(())
}
}
#[cfg(feature = "webhook")]
#[async_trait]
impl WebhookManagementService for WebhookManagementServiceImpl {
async fn register_webhook(
&self,
team_id: crate::domain::id::Id,
url: String,
) -> Result<Webhook> {
let webhook = Webhook::new(crate::domain::id::Id::generate(), team_id, url);
webhook
.validate_url()
.map_err(|e| anyhow!("Invalid webhook URL: {}", e))?;
let created = self
.webhook_repository
.create(&webhook)
.await
.map_err(|e| anyhow!("Failed to create webhook: {}", e))?;
info!(
"Registered webhook {} for team {}",
created.id, created.team_id
);
Ok(created)
}
async fn trigger_webhook(
&self,
webhook_id: crate::domain::id::Id,
event_type: WebhookEventType,
payload: serde_json::Value,
) -> Result<()> {
let webhook = self.find_webhook_or_err(webhook_id).await?;
let mut event = WebhookEventBuilder::build_triggered_event(
webhook.team_id,
webhook.id,
event_type,
payload,
webhook.url.clone(),
);
event.status = crate::domain::models::WebhookStatus::Processing;
self.create_processing_event(&event).await?;
self.send_event_inline(&mut event).await?;
info!("Triggered webhook {} for event {}", webhook_id, event.id);
Ok(())
}
async fn retry_failed(&self, limit: u64) -> Result<u64> {
let pending = self
.event_repository
.claim_pending(limit)
.await
.map_err(|e| anyhow!("Failed to claim pending webhook events: {}", e))?;
let mut success_count: u64 = 0;
for mut event in pending {
if !event.can_retry() {
continue;
}
match self.webhook_service.send_webhook(&event).await {
Ok(status) => {
event.record_attempt(true, Some(status as i32), None);
success_count += 1;
}
Err(e) => {
event.record_attempt(false, None, Some(e.to_string()));
}
}
if let Err(e) = self.event_repository.update(&event).await {
error!("Failed to update webhook event {}: {}", event.id, e);
}
}
info!(
"Retried pending webhook events (limit {}), {} succeeded",
limit, success_count
);
Ok(success_count)
}
async fn list_webhooks(&self, team_id: crate::domain::id::Id) -> Result<Vec<Webhook>> {
let webhooks = self
.webhook_repository
.find_by_team_id(team_id)
.await
.map_err(|e| anyhow!("Failed to list webhooks for team {}: {}", team_id, e))?;
Ok(webhooks)
}
}