refactor(trogon-github): replace Box<dyn Error> with ServeError enum and flatten nested Result

Introduce PublishOutcome<E> to eliminate double-wrapped Result<Result<...>> in the
webhook handler, and replace Box<dyn Error> with a typed ServeError enum preserving
rich error types until the display boundary.

Signed-off-by: Yordis Prieto <yordis.prieto@gmail.com>

Author: yordis

rsworkspace/crates/trogon-github/src/lib.rs

@@ -36,4 +36,4 @@ pub mod server;
 pub mod signature;
 
 pub use config::GithubConfig;
-pub use server::{provision, router, serve};
+pub use server::{ServeError, provision, router, serve};

rsworkspace/crates/trogon-github/src/server.rs

@@ -1,7 +1,9 @@
+use std::fmt;
 use std::time::Duration;
 
 use crate::config::GithubConfig;
 use crate::signature;
+use async_nats::jetstream::context::CreateStreamError;
 use axum::{
     Router,
     body::Bytes,
@@ -16,6 +18,85 @@ use tower_http::limit::RequestBodyLimitLayer;
 use tracing::{info, instrument, warn};
 use trogon_nats::jetstream::{JetStreamContext, JetStreamPublisher, NatsJetStreamClient};
 
+#[derive(Debug)]
+pub enum ServeError {
+    Provision(CreateStreamError),
+    Io(std::io::Error),
+}
+
+impl fmt::Display for ServeError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ServeError::Provision(e) => write!(f, "stream provisioning failed: {e}"),
+            ServeError::Io(e) => write!(f, "server IO error: {e}"),
+        }
+    }
+}
+
+impl std::error::Error for ServeError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            ServeError::Provision(e) => Some(e),
+            ServeError::Io(e) => Some(e),
+        }
+    }
+}
+
+impl From<std::io::Error> for ServeError {
+    fn from(e: std::io::Error) -> Self {
+        ServeError::Io(e)
+    }
+}
+
+enum PublishOutcome<E: fmt::Display> {
+    Published,
+    PublishFailed(E),
+    AckFailed(E),
+    AckTimedOut(Duration),
+}
+
+impl<E: fmt::Display> PublishOutcome<E> {
+    fn into_status(self) -> StatusCode {
+        match self {
+            PublishOutcome::Published => {
+                info!("Published GitHub event to NATS");
+                StatusCode::OK
+            }
+            PublishOutcome::PublishFailed(e) => {
+                warn!(error = %e, "Failed to publish GitHub event to NATS");
+                StatusCode::INTERNAL_SERVER_ERROR
+            }
+            PublishOutcome::AckFailed(e) => {
+                warn!(error = %e, "NATS ack failed");
+                StatusCode::INTERNAL_SERVER_ERROR
+            }
+            PublishOutcome::AckTimedOut(timeout) => {
+                warn!(?timeout, "NATS ack timed out");
+                StatusCode::INTERNAL_SERVER_ERROR
+            }
+        }
+    }
+}
+
+async fn publish_event<P: JetStreamPublisher>(
+    js: &P,
+    subject: String,
+    headers: async_nats::HeaderMap,
+    body: Bytes,
+    ack_timeout: Duration,
+) -> PublishOutcome<P::PublishError> {
+    let ack_future = match js.publish_with_headers(subject, headers, body).await {
+        Ok(f) => f,
+        Err(e) => return PublishOutcome::PublishFailed(e),
+    };
+
+    match tokio::time::timeout(ack_timeout, ack_future).await {
+        Ok(Ok(_)) => PublishOutcome::Published,
+        Ok(Err(e)) => PublishOutcome::AckFailed(e),
+        Err(_) => PublishOutcome::AckTimedOut(ack_timeout),
+    }
+}
+
 #[derive(Clone)]
 struct AppState<P: JetStreamPublisher> {
     js: P,
@@ -61,12 +142,9 @@ pub fn router(config: &GithubConfig, nats: async_nats::Client) -> Router {
         .with_state(state)
 }
 
-pub async fn serve(
-    config: GithubConfig,
-    nats: async_nats::Client,
-) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+pub async fn serve(config: GithubConfig, nats: async_nats::Client) -> Result<(), ServeError> {
     let js = NatsJetStreamClient::new(async_nats::jetstream::new(nats.clone()));
-    provision(&js, &config).await?;
+    provision(&js, &config).await.map_err(ServeError::Provision)?;
 
     let app = router(&config, nats);
 
@@ -174,32 +252,9 @@ async fn handle_webhook<P: JetStreamPublisher>(
     nats_headers.insert("X-GitHub-Event", event.as_str());
     nats_headers.insert("X-GitHub-Delivery", delivery.as_str());
 
-    match state
-        .js
-        .publish_with_headers(subject.clone(), nats_headers, body)
+    publish_event(&state.js, subject, nats_headers, body, state.nats_ack_timeout)
         .await
-    {
-        Ok(ack_future) => {
-            match tokio::time::timeout(state.nats_ack_timeout, ack_future).await {
-                Ok(Ok(_)) => {
-                    info!("Published GitHub event to NATS");
-                    StatusCode::OK
-                }
-                Ok(Err(e)) => {
-                    warn!(error = %e, "NATS ack failed");
-                    StatusCode::INTERNAL_SERVER_ERROR
-                }
-                Err(_) => {
-                    warn!(timeout = ?state.nats_ack_timeout, "NATS ack timed out");
-                    StatusCode::INTERNAL_SERVER_ERROR
-                }
-            }
-        }
-        Err(e) => {
-            warn!(error = %e, "Failed to publish GitHub event to NATS");
-            StatusCode::INTERNAL_SERVER_ERROR
-        }
-    }
+        .into_status()
 }
 
 #[cfg(test)]