lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README | LICENSE

error.rs (4151B)

      1 use thiserror::Error;
      2 
      3 #[derive(Debug, Error)]
      4 pub enum RadrootsNostrSignerError {
      5     #[error("store error: {0}")]
      6     Store(String),
      7 
      8     #[error("sign error: {0}")]
      9     Sign(String),
     10 
     11     #[error("missing signer identity")]
     12     MissingSignerIdentity,
     13 
     14     #[error("connection not found: {0}")]
     15     ConnectionNotFound(String),
     16 
     17     #[error(
     18         "connection already exists for client `{client_public_key}` and user `{user_identity_id}`"
     19     )]
     20     ConnectionAlreadyExists {
     21         client_public_key: String,
     22         user_identity_id: String,
     23     },
     24 
     25     #[error("connect secret already in use")]
     26     ConnectSecretAlreadyInUse,
     27 
     28     #[error("invalid auth url `{0}`")]
     29     InvalidAuthUrl(String),
     30 
     31     #[error("invalid signer state: {0}")]
     32     InvalidState(String),
     33 
     34     #[error("invalid granted permission `{0}`")]
     35     InvalidGrantedPermission(String),
     36 
     37     #[error("invalid connection id `{0}`")]
     38     InvalidConnectionId(String),
     39 
     40     #[error("invalid request id `{0}`")]
     41     InvalidRequestId(String),
     42 
     43     #[error("invalid workflow id `{0}`")]
     44     InvalidWorkflowId(String),
     45 
     46     #[error("publish workflow not found: {0}")]
     47     PublishWorkflowNotFound(String),
     48 }
     49 
     50 impl From<radroots_runtime::RuntimeJsonError> for RadrootsNostrSignerError {
     51     fn from(value: radroots_runtime::RuntimeJsonError) -> Self {
     52         Self::Store(value.to_string())
     53     }
     54 }
     55 
     56 impl From<serde_json::Error> for RadrootsNostrSignerError {
     57     fn from(value: serde_json::Error) -> Self {
     58         Self::Store(value.to_string())
     59     }
     60 }
     61 
     62 impl From<nostr::event::Error> for RadrootsNostrSignerError {
     63     fn from(value: nostr::event::Error) -> Self {
     64         Self::Sign(value.to_string())
     65     }
     66 }
     67 
     68 impl From<radroots_nostr::prelude::RadrootsNostrError> for RadrootsNostrSignerError {
     69     fn from(value: radroots_nostr::prelude::RadrootsNostrError) -> Self {
     70         Self::InvalidState(value.to_string())
     71     }
     72 }
     73 
     74 impl From<radroots_nostr_connect::prelude::RadrootsNostrConnectError> for RadrootsNostrSignerError {
     75     fn from(value: radroots_nostr_connect::prelude::RadrootsNostrConnectError) -> Self {
     76         Self::InvalidState(value.to_string())
     77     }
     78 }
     79 
     80 #[cfg(feature = "native")]
     81 impl From<radroots_sql_core::SqlError> for RadrootsNostrSignerError {
     82     fn from(value: radroots_sql_core::SqlError) -> Self {
     83         Self::Store(value.to_string())
     84     }
     85 }
     86 
     87 #[cfg(test)]
     88 mod tests {
     89     use super::*;
     90     use radroots_runtime::RuntimeJsonError;
     91     use std::path::PathBuf;
     92 
     93     #[test]
     94     fn converts_runtime_json_error() {
     95         let source = RuntimeJsonError::NotFound(PathBuf::from("signer.json"));
     96         let converted: RadrootsNostrSignerError = source.into();
     97         assert!(converted.to_string().starts_with("store error:"));
     98     }
     99 
    100     #[test]
    101     fn converts_serde_json_error() {
    102         let source = serde_json::from_str::<serde_json::Value>("{not-json")
    103             .err()
    104             .expect("serde error");
    105         let converted: RadrootsNostrSignerError = source.into();
    106         assert!(converted.to_string().starts_with("store error:"));
    107     }
    108 
    109     #[test]
    110     fn converts_nostr_event_error() {
    111         let converted: RadrootsNostrSignerError = nostr::event::Error::InvalidId.into();
    112         assert!(converted.to_string().starts_with("sign error:"));
    113     }
    114 
    115     #[test]
    116     fn converts_nostr_filter_error() {
    117         let converted: RadrootsNostrSignerError =
    118             radroots_nostr::prelude::RadrootsNostrError::FilterTagError("bad tag".to_string())
    119                 .into();
    120         assert!(converted.to_string().starts_with("invalid signer state:"));
    121     }
    122 
    123     #[test]
    124     fn converts_nostr_connect_error() {
    125         let converted: RadrootsNostrSignerError =
    126             radroots_nostr_connect::prelude::RadrootsNostrConnectError::InvalidMethod(
    127                 "bad".to_string(),
    128             )
    129             .into();
    130         assert!(converted.to_string().starts_with("invalid signer state:"));
    131     }
    132 
    133     #[cfg(feature = "native")]
    134     #[test]
    135     fn converts_sql_error() {
    136         let converted: RadrootsNostrSignerError = radroots_sql_core::SqlError::Internal.into();
    137         assert!(converted.to_string().starts_with("store error:"));
    138     }
    139 }