use super::config;
use crate::{ApiError, AppState};
use axum::extract::{Path, Query, State};
use axum::http::{HeaderMap, StatusCode};
use axum::routing::{get, post};
use axum::{Json, Router};
use sqlx::Row as _;
use crate::database::{DatabaseExecutor, Sql};
use serde::{Deserialize, Serialize};
pub(super) fn router() -> Router<AppState> {
Router::new()
.route("/api/admin/webhooks", get(list_deliveries))
.route("/api/admin/webhooks/{id}/retry", post(retry_delivery))
.route("/api/admin/webhooks/{id}/replay", post(replay_delivery))
}
#[derive(Deserialize)]
struct DeliveryQuery {
status: Option<String>,
page: Option<u64>,
page_size: Option<u64>,
}
#[derive(Serialize)]
struct AdminWebhookDelivery {
id: uuid::Uuid,
endpoint: String,
event: String,
status: String,
tenant_id: Option<uuid::Uuid>,
attempts: i32,
max_attempts: i32,
next_attempt_at: chrono::DateTime<chrono::Utc>,
response_status: Option<i32>,
last_error: Option<String>,
created_at: chrono::DateTime<chrono::Utc>,
completed_at: Option<chrono::DateTime<chrono::Utc>>,
}
#[derive(Serialize)]
struct DeliveryList { data: Vec<AdminWebhookDelivery>, meta: DeliveryListMeta }
#[derive(Serialize)]
struct DeliveryListMeta { page: u64, page_size: u64, total: u64 }
async fn list_deliveries(
State(state): State<AppState>, headers: HeaderMap, Query(input): Query<DeliveryQuery>,
) -> Result<Json<DeliveryList>, ApiError> {
require_admin(&state, &headers).await?;
ensure_enabled()?;
if input.status.as_deref().is_some_and(|status| {
!matches!(status, "pending" | "delivering" | "succeeded" | "dead")
}) {
return Err(ApiError::InvalidQuery(
"status must be pending, delivering, succeeded, or dead".to_owned(),
));
}
let page = input.page.unwrap_or(1);
let page_size = input.page_size.unwrap_or(25);
if !(1..=10_000).contains(&page) || !(1..=100).contains(&page_size) {
return Err(ApiError::InvalidQuery(
"page must be between 1 and 10000 and page_size between 1 and 100".to_owned(),
));
}
let offset = (page - 1).checked_mul(page_size).ok_or_else(|| {
ApiError::InvalidQuery("pagination is too large".to_owned())
})?;
let count = state.database.fetch_optional(Sql::bind("SELECT COUNT(*) AS total FROM \"_appstruct_webhook_deliveries\" WHERE ($1::text IS NULL OR status::text = $1)",
[input.status.clone().into()],
)).await?.ok_or(ApiError::Internal)?;
let total: i64 = count.try_get("total")?;
let rows = state.database.fetch_all(Sql::bind("SELECT id, endpoint, event, status::text AS status, tenant_id, attempts, max_attempts, next_attempt_at, response_status, last_error, created_at, completed_at FROM \"_appstruct_webhook_deliveries\" WHERE ($1::text IS NULL OR status::text = $1) ORDER BY created_at DESC, id DESC LIMIT $2 OFFSET $3",
[input.status.into(), i64::try_from(page_size).unwrap_or(100).into(), i64::try_from(offset).unwrap_or(i64::MAX).into()],
)).await?;
let data = rows.into_iter().map(delivery_from_row).collect::<Result<Vec<_>, _>>()?;
Ok(Json(DeliveryList { data, meta: DeliveryListMeta { page, page_size, total: u64::try_from(total).unwrap_or(0) } }))
}
async fn retry_delivery(
State(state): State<AppState>, headers: HeaderMap, Path(id): Path<String>,
) -> Result<Json<AdminWebhookDelivery>, ApiError> {
require_admin_mutation(&state, &headers).await?;
ensure_enabled()?;
let id = uuid::Uuid::parse_str(&id).map_err(|_| ApiError::InvalidId)?;
let transaction = state.database.begin().await?;
if lock_status(&transaction, id).await? != "dead" {
return Err(ApiError::Conflict("Only dead webhook deliveries can be retried".to_owned()));
}
let row = transaction.fetch_optional(Sql::bind("UPDATE \"_appstruct_webhook_deliveries\" SET status = 'pending', attempts = 0, next_attempt_at = CURRENT_TIMESTAMP, locked_by = NULL, locked_until = NULL, response_status = NULL, last_error = NULL, completed_at = NULL WHERE id = $1 RETURNING id, endpoint, event, status::text AS status, tenant_id, attempts, max_attempts, next_attempt_at, response_status, last_error, created_at, completed_at",
[id.into()],
)).await?.ok_or(ApiError::NotFound)?;
let delivery = delivery_from_row(row)?;
transaction.commit().await?;
Ok(Json(delivery))
}
async fn replay_delivery(
State(state): State<AppState>, headers: HeaderMap, Path(id): Path<String>,
) -> Result<(StatusCode, Json<AdminWebhookDelivery>), ApiError> {
require_admin_mutation(&state, &headers).await?;
ensure_enabled()?;
let source_id = uuid::Uuid::parse_str(&id).map_err(|_| ApiError::InvalidId)?;
let transaction = state.database.begin().await?;
let status = lock_status(&transaction, source_id).await?;
if !matches!(status.as_str(), "succeeded" | "dead") {
return Err(ApiError::Conflict(
"Only succeeded or dead webhook deliveries can be replayed".to_owned(),
));
}
let id = uuid::Uuid::now_v7();
let row = transaction.fetch_optional(Sql::bind("INSERT INTO \"_appstruct_webhook_deliveries\" (id, endpoint, event, payload, idempotency_key, tenant_id, status, attempts, max_attempts, backoff_seconds, next_attempt_at, created_at) SELECT $1, endpoint, event, payload, NULL, tenant_id, 'pending', 0, max_attempts, backoff_seconds, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP FROM \"_appstruct_webhook_deliveries\" WHERE id = $2 RETURNING id, endpoint, event, status::text AS status, tenant_id, attempts, max_attempts, next_attempt_at, response_status, last_error, created_at, completed_at",
[id.into(), source_id.into()],
)).await?.ok_or(ApiError::NotFound)?;
let delivery = delivery_from_row(row)?;
transaction.commit().await?;
Ok((StatusCode::CREATED, Json(delivery)))
}
async fn require_admin(state: &AppState, headers: &HeaderMap) -> Result<(), ApiError> {
let actor = state.auth.actor(&state.database, headers).await?.ok_or(ApiError::Unauthorized)?;
if actor.has_role("admin") { Ok(()) } else { Err(ApiError::Forbidden) }
}
async fn require_admin_mutation(state: &AppState, headers: &HeaderMap) -> Result<(), ApiError> {
let actor = state.auth.actor_for_mutation(&state.database, headers).await?
.ok_or(ApiError::Unauthorized)?;
if actor.has_role("admin") { Ok(()) } else { Err(ApiError::Forbidden) }
}
fn ensure_enabled() -> Result<(), ApiError> {
if config::WEBHOOKS_ENABLED { Ok(()) } else { Err(ApiError::NotFound) }
}
async fn lock_status<C: DatabaseExecutor>(database: &C, id: uuid::Uuid) -> Result<String, ApiError> {
let row = database.fetch_optional(Sql::bind("SELECT status::text AS status FROM \"_appstruct_webhook_deliveries\" WHERE id = $1 FOR UPDATE",
[id.into()],
)).await?.ok_or(ApiError::NotFound)?;
Ok(row.try_get("status")?)
}
fn delivery_from_row(row: crate::database::PgRow) -> Result<AdminWebhookDelivery, sqlx::Error> {
Ok(AdminWebhookDelivery {
id: row.try_get("id")?, endpoint: row.try_get("endpoint")?,
event: row.try_get("event")?, status: row.try_get("status")?,
tenant_id: row.try_get("tenant_id")?, attempts: row.try_get("attempts")?,
max_attempts: row.try_get("max_attempts")?,
next_attempt_at: row.try_get("next_attempt_at")?,
response_status: row.try_get("response_status")?,
last_error: row.try_get("last_error")?, created_at: row.try_get("created_at")?,
completed_at: row.try_get("completed_at")?,
})
}