1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

//!
//! Client [`enum@Error`] enum declaration
//!

use crate::error::ServerError;
use crate::messages::serde_json::SerdeJsonServerError;
use serde::*;
use std::fmt::Display;
use thiserror::Error;
use wasm_bindgen::JsValue;
use workflow_core::channel::{RecvError, SendError, TrySendError};
use workflow_websocket::client::error::Error as WebSocketError;

#[derive(Error, Debug)]
pub enum Error {
    #[error("Invalid URL {0}")]
    InvalidUrl(String),

    #[error(transparent)]
    RpcError(#[from] crate::error::Error),

    #[error("response handler for id {0} not found")]
    ResponseHandler(String),

    #[error("WebSocket disconnected")]
    Disconnect,
    #[error("Missing method in notification message")]
    NotificationMethod,

    #[error("invalid WebSocket message type for protocol")]
    WebSocketMessageType,

    #[error("RPC client is missing notification handler")]
    MissingNotificationHandler,

    /// Underlying WebSocket error
    #[error("WebSocket error: {0}")]
    WebSocketError(#[from] WebSocketError),
    /// RPC call timeout
    #[error("RPC request timeout")]
    Timeout,
    /// Unable to send shutdown message to receiver
    #[error("Receiver ctl failure")]
    ReceiverCtl,
    /// RPC call succeeded but no data was received in success response
    #[error("RPC: no data in success response")]
    NoDataInSuccessResponse,
    #[error("RPC: no data in notification")]
    NoDataInNotificationMessage,
    /// RPC call failed but no data was received in error response
    #[error("RPC: no data in error response")]
    NoDataInErrorResponse,
    /// Unable to deserialize response data
    #[error("RPC: error deserializing server message data")]
    ErrorDeserializingServerMessageData(crate::error::Error),
    /// Unable to deserialize response data
    #[error("RPC: error deserializing response data")]
    ErrorDeserializingResponseData,
    /// Response produced an unknown status code
    #[error("RPC: status code {0}")]
    StatusCode(u32),
    /// RPC call executed successfully but produced an error response
    #[error("RPC: response error {0:?}")]
    RpcCall(ServerError),
    /// Unable to serialize borsh data    
    #[error("RPC: borsh serialization error")]
    BorshSerialize,
    /// Unable to deserialize borsh data
    #[error("RPC borsh deserialization error: {0}")]
    BorshDeserialize(String),
    /// Unable to serialize serde data    
    #[error("RPC serde serialization error: {0}")]
    SerdeSerialize(String), //#[from] dyn serde::de::Error),
    /// Unable to deserialize serde data
    #[error("RPC serde deserialization error: {0}")]
    SerdeDeserialize(String),
    /// RPC call succeeded, but error occurred deserializing borsh response
    #[error("RPC: borsh error deserializing response: {0}")]
    BorshResponseDeserialize(String),

    #[error("RPC: channel receive error")]
    ChannelRecvError,

    #[error("RPC: channel send error")]
    ChannelSendError,

    #[error("Utf8 error: {0}")]
    Utf8Error(#[from] std::str::Utf8Error),

    #[error("SerdeJSON error: {0}")]
    SerdeJSON(#[from] serde_json::Error),

    #[error(transparent)]
    Task(#[from] workflow_task::TaskError),

    #[error("{0}")]
    ServerError(ServerError),

    #[error("{0}")]
    SerdeJsonServerError(SerdeJsonServerError),

    #[error("{0}")]
    RegexError(#[from] regex::Error),
}

impl From<ServerError> for Error {
    fn from(err: ServerError) -> Self {
        Error::ServerError(err)
    }
}

/// Transform Error into JsValue containing the error message
impl From<Error> for JsValue {
    fn from(err: Error) -> JsValue {
        JsValue::from(err.to_string())
    }
}

impl From<RecvError> for Error {
    fn from(_: RecvError) -> Self {
        Error::ChannelRecvError
    }
}

impl<T> From<SendError<T>> for Error {
    fn from(_: SendError<T>) -> Self {
        Error::ChannelSendError
    }
}

impl<T> From<TrySendError<T>> for Error {
    fn from(_: TrySendError<T>) -> Self {
        Error::ChannelSendError
    }
}

impl de::Error for Error {
    fn custom<T: Display>(msg: T) -> Error {
        Error::SerdeDeserialize(msg.to_string())
    }
}

impl ser::Error for Error {
    fn custom<T: Display>(msg: T) -> Error {
        Error::SerdeSerialize(msg.to_string())
    }
}

impl From<SerdeJsonServerError> for Error {
    fn from(err: SerdeJsonServerError) -> Self {
        Error::SerdeJsonServerError(err)
    }
}