distributed 4.4.2

CQRS/ES framework for Rust using Plain Old Rust Structs — append-only events, replay, snapshots, outbox, service bus, and pluggable infrastructure
Documentation 
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

use std::fmt;

/// Errors raised while compiling portable application contracts.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum ApplicationError {
    InvalidIdentity {
        kind: &'static str,
        value: String,
        reason: &'static str,
    },
    Duplicate {
        kind: &'static str,
        identity: String,
    },
    Collision {
        kind: &'static str,
        identity: String,
        reason: String,
    },
    Missing {
        kind: &'static str,
        identity: String,
    },
    InvalidSpec(String),
    UnsupportedVersion {
        expected: u32,
        actual: u32,
    },
    NonCanonical(&'static str),
    Canonical(String),
}

pub type ApplicationResult<T> = Result<T, ApplicationError>;

impl fmt::Display for ApplicationError {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::InvalidIdentity {
                kind,
                value,
                reason,
            } => write!(formatter, "invalid {kind} identity `{value}`: {reason}"),
            Self::Duplicate { kind, identity } => {
                write!(formatter, "duplicate {kind} identity `{identity}`")
            }
            Self::Collision {
                kind,
                identity,
                reason,
            } => write!(
                formatter,
                "colliding {kind} identity `{identity}`: {reason}"
            ),
            Self::Missing { kind, identity } => {
                write!(formatter, "missing {kind} identity `{identity}`")
            }
            Self::InvalidSpec(reason) => {
                write!(formatter, "invalid application specification: {reason}")
            }
            Self::UnsupportedVersion { expected, actual } => write!(
                formatter,
                "unsupported application manifest schema version {actual}; expected {expected}"
            ),
            Self::NonCanonical(kind) => write!(formatter, "non-canonical {kind} bytes"),
            Self::Canonical(reason) => {
                write!(formatter, "canonical application artifact error: {reason}")
            }
        }
    }
}

impl std::error::Error for ApplicationError {}

impl From<serde_json::Error> for ApplicationError {
    fn from(error: serde_json::Error) -> Self {
        Self::Canonical(error.to_string())
    }
}