better error handling

Author: Handy-caT

examples/ws-echo/main.rs

@@ -7,7 +7,7 @@ use endpoint_libs::libs::handler::RequestHandler;
 use endpoint_libs::libs::log::error_aggregation::ErrorAggregationConfig;
 use endpoint_libs::libs::log::{LogLevel, LoggingConfig, OtelConfig, setup_logging};
 use endpoint_libs::libs::toolbox::{ArcToolbox, RequestContext};
-use endpoint_libs::libs::ws::toolbox::CustomError;
+use endpoint_libs::libs::ws::toolbox::{CustomError, HandlerError};
 use endpoint_libs::libs::ws::{
     AuthController, WebsocketServer, WsConnection, WsRequest, WsResponse, WsServerConfig,
 };
@@ -88,20 +88,81 @@ impl WsResponse for HoneyReceiveUserInfoResponse {
     type Request = HoneyReceiveUserInfoRequest;
 }
 
+// --- Typed error enum example ---
+//
+// This demonstrates the HandlerError trait for defining per-handler error codes.
+
+#[derive(Debug, Clone)]
+pub enum EchoTypedError {
+    MessageTooLong { max_length: u32, actual_length: u32 },
+    EmptyMessage,
+}
+
+impl std::fmt::Display for EchoTypedError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::MessageTooLong { max_length, actual_length } => {
+                write!(f, "message length {} exceeds maximum {}", actual_length, max_length)
+            }
+            Self::EmptyMessage => write!(f, "message cannot be empty"),
+        }
+    }
+}
+
+impl std::error::Error for EchoTypedError {}
+
+impl HandlerError for EchoTypedError {
+    fn error_code(&self) -> ErrorCode {
+        match self {
+            // Handler-specific codes for Echo (method 1): 1001-1099
+            Self::MessageTooLong { .. } => ErrorCode::new(1001),
+            Self::EmptyMessage => ErrorCode::new(1002),
+        }
+    }
+
+    fn params(&self) -> String {
+        match self {
+            Self::MessageTooLong { max_length, actual_length } => {
+                format!("message length {} exceeds maximum {}", actual_length, max_length)
+            }
+            Self::EmptyMessage => "empty message not allowed".to_string(),
+        }
+    }
+}
+
+impl From<EchoTypedError> for CustomError {
+    fn from(err: EchoTypedError) -> Self {
+        CustomError::new(err.error_code(), err.params())
+    }
+}
+
 // --- Handlers ---
 
 pub struct MethodEcho;
 
 #[async_trait(?Send)]
 impl RequestHandler for MethodEcho {
     type Request = EchoRequest;
+    type Error = EchoTypedError;
 
-    async fn handle(&self, ctx: RequestContext, req: EchoRequest) -> Result<EchoResponse> {
+    async fn handle(&self, ctx: RequestContext, req: EchoRequest) -> Result<EchoResponse, EchoTypedError> {
         tracing::info!(
             conn_id = %ctx.connection_id,
             message = %req.message,
             "Echo request received"
         );
+
+        if req.message.is_empty() {
+            return Err(EchoTypedError::EmptyMessage);
+        }
+
+        if req.message.len() > 1000 {
+            return Err(EchoTypedError::MessageTooLong {
+                max_length: 1000,
+                actual_length: req.message.len() as u32,
+            });
+        }
+
         let response = EchoResponse {
             message: format!("echo: {}", req.message),
         };
@@ -119,12 +180,13 @@ pub struct MethodReceiveUserInfo;
 #[async_trait(?Send)]
 impl RequestHandler for MethodReceiveUserInfo {
     type Request = HoneyReceiveUserInfoRequest;
+    type Error = CustomError;
 
     async fn handle(
         &self,
         ctx: RequestContext,
         req: HoneyReceiveUserInfoRequest,
-    ) -> Result<HoneyReceiveUserInfoResponse> {
+    ) -> Result<HoneyReceiveUserInfoResponse, CustomError> {
         tracing::info!(
             conn_id = %ctx.connection_id,
             user_pub_id = %req.user_pub_id,
@@ -147,7 +209,7 @@ impl RequestHandler for MethodReceiveUserInfo {
             user_pub_id = %req.user_pub_id,
             "Rejecting ReceiveUserInfo with BAD_REQUEST"
         );
-        Err(CustomError::new(ErrorCode::BAD_REQUEST, msg).into())
+        Err(CustomError::new(ErrorCode::BAD_REQUEST, msg))
     }
 }
 

src/libs/ws/handler.rs

@@ -7,14 +7,17 @@ use crate::libs::{
     toolbox::{ArcToolbox, RequestContext, Toolbox},
     ws::{WsRequest, request_error_to_resp},
 };
+use crate::libs::ws::toolbox::{CustomError, HandlerError};
 
 #[allow(type_alias_bounds)]
-pub type Response<T: WsRequest> = Result<T::Response>;
+pub type Response<T: WsRequest, E: HandlerError = CustomError> = Result<T::Response, E>;
+
 #[async_trait(?Send)]
 pub trait RequestHandler: Send + Sync {
     type Request: WsRequest + 'static;
+    type Error: HandlerError + Into<eyre::Error>;
 
-    async fn handle(&self, ctx: RequestContext, req: Self::Request) -> Response<Self::Request>;
+    async fn handle(&self, ctx: RequestContext, req: Self::Request) -> Response<Self::Request, Self::Error>;
 }
 
 #[doc(hidden)]
@@ -53,6 +56,15 @@ impl<T: RequestHandler> RequestHandlerErased for T {
         let fut = RequestHandler::handle(self, ctx.clone(), data);
 
         let resp = fut.await;
+        // Convert handler error to eyre::Result via CustomError
+        let resp: eyre::Result<<T::Request as WsRequest>::Response> = match resp {
+            Ok(ok) => Ok(ok),
+            Err(err) => {
+                let custom: CustomError = err.into();
+                Err(custom.into())
+            }
+        };
+
         if let Some(resp) = Toolbox::encode_ws_response(ctx.clone(), resp) {
             toolbox.send(ctx.connection_id, resp);
         }

src/libs/ws/toolbox.rs

@@ -59,6 +59,28 @@ impl Display for CustomError {
 
 impl std::error::Error for CustomError {}
 
+/// Trait for handler-specific error enums.
+///
+/// Each variant defines its own error code and params string.
+/// Implementations provide their own `From<Self> for CustomError`.
+pub trait HandlerError: std::error::Error + Send + Sync + Into<CustomError> + 'static {
+    /// Returns the error code for this variant.
+    fn error_code(&self) -> ErrorCode;
+
+    /// Returns the params string for this variant.
+    fn params(&self) -> String;
+}
+
+impl HandlerError for CustomError {
+    fn error_code(&self) -> ErrorCode {
+        self.code
+    }
+
+    fn params(&self) -> String {
+        self.params.as_str().unwrap_or("").to_string()
+    }
+}
+
 #[derive(Clone)]
 pub struct RequestContext {
     pub connection_id: ConnectionId,