beads_rs/
error.rs

1use thiserror::Error;
2
3use crate::core::CoreError;
4use crate::daemon::{IpcError, OpError};
5use crate::git::SyncError;
6
7/// Whether retrying this operation may succeed.
8#[derive(Debug, Copy, Clone, Eq, PartialEq)]
9pub enum Transience {
10    /// Retry will never help without changing inputs/state.
11    Permanent,
12    /// Retry may help (transient contention/outage).
13    Retryable,
14    /// Unknown if retry will help.
15    Unknown,
16}
17
18impl Transience {
19    pub fn is_retryable(self) -> bool {
20        matches!(self, Transience::Retryable)
21    }
22}
23
24/// What we know about side effects when an error is returned.
25#[derive(Debug, Copy, Clone, Eq, PartialEq)]
26pub enum Effect {
27    /// Definitely no side effects occurred.
28    None,
29    /// Side effects definitely occurred (locally or remotely).
30    Some,
31    /// We don't know if side effects occurred.
32    Unknown,
33}
34
35impl Effect {
36    pub fn as_str(self) -> &'static str {
37        match self {
38            Effect::None => "none",
39            Effect::Some => "some",
40            Effect::Unknown => "unknown",
41        }
42    }
43}
44
45/// Crate-level convenience error.
46///
47/// Not a "god error": it is a thin wrapper over canonical capability errors.
48#[derive(Error, Debug)]
49#[non_exhaustive]
50pub enum Error {
51    #[error(transparent)]
52    Core(#[from] CoreError),
53
54    #[error(transparent)]
55    Op(#[from] OpError),
56
57    #[error(transparent)]
58    Sync(#[from] SyncError),
59
60    #[error(transparent)]
61    Ipc(#[from] IpcError),
62}
63
64impl Error {
65    pub fn transience(&self) -> Transience {
66        match self {
67            Error::Core(e) => e.transience(),
68            Error::Op(e) => e.transience(),
69            Error::Sync(e) => e.transience(),
70            Error::Ipc(e) => e.transience(),
71        }
72    }
73
74    pub fn effect(&self) -> Effect {
75        match self {
76            Error::Core(e) => e.effect(),
77            Error::Op(e) => e.effect(),
78            Error::Sync(e) => e.effect(),
79            Error::Ipc(e) => e.effect(),
80        }
81    }
82}