Skip to main content

conduit_cli/core/
error.rs

1use std::fmt;
2
3#[derive(Debug)]
4pub enum CoreError {
5    Io(std::io::Error),
6    Json(serde_json::Error),
7    TomlDe(toml::de::Error),
8    TomlSer(toml::ser::Error),
9    Reqwest(reqwest::Error),
10    MissingConfig,
11    MissingLocalDataDir,
12    NoCompatibleVersion { slug: String },
13    NoFilesForVersion { version: String },
14    ProjectNotFound { slug: String },
15    UnsupportedLoader(String),
16    ServerOnlyFeature,
17    ClientOnlyFeature,
18    RuntimeError(String),
19    Zip(zip::result::ZipError),
20}
21
22impl fmt::Display for CoreError {
23    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
24        match self {
25            CoreError::Io(e) => write!(f, "IO error: {e}"),
26            CoreError::Json(e) => write!(f, "JSON error: {e}"),
27            CoreError::TomlDe(e) => write!(f, "TOML decode error: {e}"),
28            CoreError::TomlSer(e) => write!(f, "TOML encode error: {e}"),
29            CoreError::Reqwest(e) => write!(f, "HTTP error: {e}"),
30            CoreError::MissingConfig => write!(f, "No conduit.json found"),
31            CoreError::MissingLocalDataDir => write!(f, "Could not find local data directory"),
32            CoreError::NoCompatibleVersion { slug } => {
33                write!(f, "No compatible version for {slug}")
34            }
35            CoreError::NoFilesForVersion { version } => {
36                write!(f, "No files available for version {version}")
37            }
38            CoreError::ProjectNotFound { slug } => write!(f, "Project not found: {slug}"),
39            CoreError::UnsupportedLoader(loader) => {
40                write!(f, "Unsupported loader: {loader}")
41            }
42            CoreError::ServerOnlyFeature => write!(f, "This feature is only available for server instances"),
43            CoreError::ClientOnlyFeature => write!(f, "This feature is only available for client instances"),
44            CoreError::RuntimeError(e) => write!(f, "Runtime error: {e}"),
45            CoreError::Zip(e) => write!(f, "Zip error: {e}"),
46        }
47    }
48}
49
50impl std::error::Error for CoreError {}
51
52impl From<std::io::Error> for CoreError {
53    fn from(value: std::io::Error) -> Self {
54        Self::Io(value)
55    }
56}
57
58impl From<serde_json::Error> for CoreError {
59    fn from(value: serde_json::Error) -> Self {
60        Self::Json(value)
61    }
62}
63
64impl From<toml::de::Error> for CoreError {
65    fn from(value: toml::de::Error) -> Self {
66        Self::TomlDe(value)
67    }
68}
69
70impl From<toml::ser::Error> for CoreError {
71    fn from(value: toml::ser::Error) -> Self {
72        Self::TomlSer(value)
73    }
74}
75
76impl From<reqwest::Error> for CoreError {
77    fn from(value: reqwest::Error) -> Self {
78        Self::Reqwest(value)
79    }
80}
81
82pub type CoreResult<T> = Result<T, CoreError>;
83
84impl From<Box<dyn std::error::Error>> for CoreError {
85    fn from(value: Box<dyn std::error::Error>) -> Self {
86        Self::RuntimeError(value.to_string())
87    }
88}
89
90impl From<zip::result::ZipError> for CoreError {
91    fn from(value: zip::result::ZipError) -> Self {
92        Self::Zip(value)
93    }
94}