Merge pull request #26 from yeoleobun/patch1

improve:  improve error with this error

Author: shenjinti

Cargo.toml

@@ -23,6 +23,7 @@ async-trait = "0.1.89"
 futures = "0.3.31"
 log = "0.4.27"
 rsip = { version = "0.4.0" }
+thiserror = "2.0.16"
 tracing = "0.1.41"
 wasm-bindgen = "0.2.84"
 # The `console_error_panic_hook` crate provides better debugging of panics by

src/error.rs

@@ -1,95 +1,64 @@
 use crate::{dialog::DialogId, transaction::key::TransactionKey, transport::SipAddr};
 use std::env::VarError;
+use thiserror::Error as ThisError;
 use wasm_bindgen::prelude::*;
 
-#[derive(Debug, Eq, PartialEq, Clone)]
+#[derive(Debug, ThisError)]
 pub enum Error {
-    SipMessageError(String),
+    #[error("SIP message error: {0}")]
+    SipMessageError(#[from] rsip::Error),
+
+    #[error("DNS resolution error: {0}")]
     DnsResolutionError(String),
+
+    #[error("Transport layer error: {0}: {1}")]
     TransportLayerError(String, SipAddr),
+
+    #[error("Transaction error: {0}: {1}")]
     TransactionError(String, TransactionKey),
+
+    #[error("Endpoint error: {0}")]
     EndpointError(String),
+
+    #[error("Dialog error: {0}: {1}")]
     DialogError(String, DialogId),
-    Error(String),
-}
 
-impl std::fmt::Display for Error {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Error::SipMessageError(e) => write!(f, "SIP message error: {}", e),
-            Error::DnsResolutionError(e) => write!(f, "DNS resolution error: {}", e),
-            Error::TransportLayerError(e, addr) => {
-                write!(f, "Transport layer error: {}: {}", e, addr)
-            }
-            Error::TransactionError(e, key) => write!(f, "Transaction error: {}: {}", e, key),
-            Error::EndpointError(e) => write!(f, "Endpoint error: {}", e),
-            Error::DialogError(e, id) => write!(f, "Dialog error: {}: {}", e, id),
-            Error::Error(e) => write!(f, "Error: {}", e),
-        }
-    }
-}
+    #[error("I/O error: {0}")]
+    IoError(#[from] std::io::Error),
 
-impl Into<JsValue> for Error {
-    fn into(self) -> JsValue {
-        match self {
-            Error::DnsResolutionError(e) => e.into(),
-            Error::SipMessageError(e) => e.into(),
-            Error::TransportLayerError(e, _) => e.into(),
-            Error::TransactionError(e, key) => format!("{}: {}", e, key.to_string()).into(),
-            Error::EndpointError(e) => e.into(),
-            Error::DialogError(e, id) => format!("{}: {}", e, id.to_string()).into(),
-            Error::Error(e) => e.into(),
-        }
-    }
-}
-impl From<rsip::Error> for Error {
-    fn from(e: rsip::Error) -> Self {
-        Error::SipMessageError(e.to_string())
-    }
-}
+    #[error("Format error: {0}")]
+    FormatError(#[from] std::fmt::Error),
 
-impl<T> From<tokio::sync::mpsc::error::SendError<T>> for Error {
-    fn from(e: tokio::sync::mpsc::error::SendError<T>) -> Self {
-        Error::Error(e.to_string())
-    }
-}
+    #[error("Environment variable error: {0}")]
+    VarError(#[from] VarError),
 
-impl From<tokio::sync::broadcast::error::RecvError> for Error {
-    fn from(e: tokio::sync::broadcast::error::RecvError) -> Self {
-        Error::Error(e.to_string())
-    }
-}
-impl From<std::io::Error> for Error {
-    fn from(e: std::io::Error) -> Self {
-        Error::Error(e.to_string())
-    }
-}
+    #[error("Address parse error: {0}")]
+    AddrParseError(#[from] std::net::AddrParseError),
 
-impl From<std::fmt::Error> for Error {
-    fn from(e: std::fmt::Error) -> Self {
-        Error::Error(e.to_string())
-    }
-}
-impl From<VarError> for Error {
-    fn from(e: VarError) -> Self {
-        Error::Error(e.to_string())
-    }
-}
+    #[error("TLS error: {0}")]
+    TlsError(#[from] tokio_rustls::rustls::Error),
 
-impl From<std::net::AddrParseError> for Error {
-    fn from(e: std::net::AddrParseError) -> Self {
-        Error::Error(e.to_string())
-    }
+    #[error("WebSocket error: {0}")]
+    WebSocketError(#[from] tokio_tungstenite::tungstenite::Error),
+
+    #[error("Channel send error: {0}")]
+    ChannelSendError(String),
+
+    #[error("Broadcast receive error: {0}")]
+    BroadcastRecvError(#[from] tokio::sync::broadcast::error::RecvError),
+
+    #[error("Error: {0}")]
+    Error(String),
 }
 
-impl From<tokio_rustls::rustls::Error> for Error {
-    fn from(e: tokio_rustls::rustls::Error) -> Self {
-        Error::Error(e.to_string())
+impl From<Error> for JsValue {
+    fn from(e: Error) -> Self {
+        e.to_string().into()
     }
 }
 
-impl From<tokio_tungstenite::tungstenite::Error> for Error {
-    fn from(e: tokio_tungstenite::tungstenite::Error) -> Self {
-        Error::Error(e.to_string())
+impl<T> From<tokio::sync::mpsc::error::SendError<T>> for Error {
+    fn from(e: tokio::sync::mpsc::error::SendError<T>) -> Self {
+        Error::ChannelSendError(e.to_string())
     }
 }