bodega 0.7.1

A small, relatively simple object store implementation and helpers.
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

use snafu::Snafu;

use crate::{DbBmcError, DbModelManagerError, OpError};

pub type Result<T> = core::result::Result<T, Error>;

#[derive(Debug, Snafu)]
pub enum Error {
    #[snafu(display("Attempted empty update for '{entity}' with id '{id}'"))]
    EmptyUpdate { entity: &'static str, id: String },

    #[snafu(display("Could not find '{entity}' with id '{id}'"))]
    EntityNotFound { entity: &'static str, id: String },

    #[snafu(display("Failed to create DB pool: {message}"))]
    FailedToCreateDBPool { message: String },

    #[snafu(display("DbBmc error: "))]
    DbBmc { source: DbBmcError },

    #[snafu(display("ModelManagr error: "))]
    ModelManager { source: DbModelManagerError },

    #[snafu(display("Transaction serialization error: "))]
    TransactionSerialization { source: SerializationError },

    #[snafu(display("Transaction retries exceeded: "))]
    TransactionRetriesExceeded { source: Box<Error> },

    #[snafu(transparent)]
    SqlxMigrate { source: sqlx::migrate::MigrateError },
}

impl Error {
    /// If applicable, returns the name of the constraint that triggered the error.
    ///
    /// This is a convenience proxy for the constraint on the underlying [`sqlx::Error`].
    pub fn constraint(&self) -> Option<&str> {
        match self {
            Error::DbBmc {
                source:
                    DbBmcError::Operation {
                        source:
                            OpError::Sqlx {
                                source: sqlx::Error::Database(ref e),
                            },
                        ..
                    },
            } => e.constraint(),
            Error::ModelManager { source } => match source.source() {
                sqlx::Error::Database(ref e) => e.constraint(),
                _ => None,
            },
            _ => None,
        }
    }
}

#[derive(Debug, Snafu)]
pub enum SerializationError {
    #[snafu(transparent)]
    DbBmc { source: DbBmcError },

    #[snafu(transparent)]
    ModelManager { source: DbModelManagerError },
}

// we want to explicitly distinguish serialization errors to make it easier for
// clients to retry.
impl From<DbBmcError> for Error {
    fn from(value: DbBmcError) -> Self {
        match value {
            DbBmcError::Operation {
                source:
                    OpError::Sqlx {
                        source: sqlx::Error::Database(ref e),
                    },
                ..
            } if e.code() == Some("40001".into()) => Self::TransactionSerialization {
                source: SerializationError::DbBmc { source: value },
            },
            _ => Self::DbBmc { source: value },
        }
    }
}

impl From<DbModelManagerError> for Error {
    fn from(value: DbModelManagerError) -> Self {
        match value {
            DbModelManagerError::TransactionCommit {
                source: sqlx::Error::Database(ref e),
            } if e.code() == Some("40001".into()) => Self::TransactionSerialization {
                source: SerializationError::ModelManager { source: value },
            },
            _ => Self::ModelManager { source: value },
        }
    }
}