architecturekit 0.24.1

Building blocks for DDD-based applications with CQRS and event sourcing, on top of the EventSourcingDB by the native web.
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
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

use std::{error::Error as StdError, fmt};

use crate::{
    Categorized, Category, EmptyRange, Failure, Permanent, PreconditionsError, ReadOptionsError,
    Transient,
};

use super::error::{
    ExecuteError, LoadError, ReadError, RegisterSchemasError, WriteError, fmt_outcome_unknown,
    source_of_outcome_unknown,
};

/// Any failure of architecturekit, where `D` is the error of a decider, so that
/// a function that calls several operations can pass their failures on with
/// `?`.
///
/// Every error of an operation turns into it. It holds all the cases of those,
/// so a `match` on it needs a catch-all arm, and new cases may come with new
/// operations. Where the cases of a single operation matter, match on its own
/// error before it turns into this one.
#[derive(Debug)]
#[non_exhaustive]
pub enum Error<D> {
    /// See [`ExecuteError::Decider`].
    Decider(D),
    /// A failure of the category [`Category::Transient`].
    Transient(Transient),
    /// A failure of the category [`Category::Permanent`].
    Permanent(Permanent),
    /// See [`ExecuteError::OutcomeUnknown`].
    OutcomeUnknown(Failure),
    /// See [`ReadError::EmptyRange`].
    EmptyRange(EmptyRange),
}

impl<D> From<ExecuteError<D>> for Error<D> {
    fn from(failure: ExecuteError<D>) -> Self {
        match failure {
            ExecuteError::Decider(failure) => Self::Decider(failure),
            ExecuteError::Transient(failure) => Self::Transient(failure),
            ExecuteError::Permanent(failure) => Self::Permanent(failure),
            ExecuteError::OutcomeUnknown(failure) => Self::OutcomeUnknown(failure),
        }
    }
}

impl<D> From<LoadError> for Error<D> {
    fn from(failure: LoadError) -> Self {
        ExecuteError::from(failure).into()
    }
}

impl<D> From<WriteError> for Error<D> {
    fn from(failure: WriteError) -> Self {
        ExecuteError::from(failure).into()
    }
}

impl<D> From<RegisterSchemasError> for Error<D> {
    fn from(failure: RegisterSchemasError) -> Self {
        match failure {
            RegisterSchemasError::Transient(failure) => Self::Transient(failure),
            RegisterSchemasError::Permanent(failure) => Self::Permanent(failure),
        }
    }
}

impl<D> From<ReadError> for Error<D> {
    fn from(failure: ReadError) -> Self {
        match failure {
            ReadError::Transient(failure) => Self::Transient(failure),
            ReadError::Permanent(failure) => Self::Permanent(failure),
            ReadError::EmptyRange(refusal) => Self::EmptyRange(refusal),
        }
    }
}

impl<D> From<ReadOptionsError> for Error<D> {
    fn from(refusal: ReadOptionsError) -> Self {
        ReadError::from(refusal).into()
    }
}

impl<D> From<PreconditionsError> for Error<D> {
    fn from(refusal: PreconditionsError) -> Self {
        ExecuteError::from(refusal).into()
    }
}

impl<D: fmt::Display> fmt::Display for Error<D> {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Decider(failure) => failure.fmt(formatter),
            Self::Transient(failure) => failure.fmt(formatter),
            Self::Permanent(failure) => failure.fmt(formatter),
            Self::OutcomeUnknown(failure) => fmt_outcome_unknown(failure, formatter),
            Self::EmptyRange(refusal) => refusal.fmt(formatter),
        }
    }
}

impl<D: StdError + 'static> StdError for Error<D> {
    fn source(&self) -> Option<&(dyn StdError + 'static)> {
        match self {
            Self::Decider(failure) => failure.source(),
            Self::Transient(failure) => failure.source(),
            Self::Permanent(failure) => failure.source(),
            Self::OutcomeUnknown(failure) => source_of_outcome_unknown(failure),
            Self::EmptyRange(refusal) => refusal.source(),
        }
    }
}

impl<D: Categorized> Categorized for Error<D> {
    fn category(&self) -> Option<Category> {
        match self {
            Self::Decider(failure) => failure.category(),
            Self::Transient(failure) => failure.category(),
            Self::Permanent(failure) => failure.category(),
            Self::OutcomeUnknown(_) | Self::EmptyRange(_) => None,
        }
    }
}