armour 0.30.27

DDL and serialization for key-value storage
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

use std::io::Error as IoError;

use rapira::RapiraError;
use thiserror::Error;

use crate::types::ArmourError;

#[derive(Error, Debug)]
pub enum DbError {
    /// 400
    #[error("client error: {0}")]
    Client(&'static str),
    /// 404
    #[error("not found")]
    NotFound,
    /// 501
    #[error("not implemented")]
    NotImplemented,
    #[error("empty")]
    Empty,
    #[error("transactional error")]
    Transaction,
    #[error("storage logic error: {0}")]
    Internal(&'static str),
    #[error(transparent)]
    Io(#[from] IoError),
    #[error(transparent)]
    Rapira(#[from] RapiraError),
    #[error(transparent)]
    Armour(#[from] ArmourError),
    #[cfg(feature = "fjall")]
    #[cfg_attr(feature = "fjall", error(transparent))]
    Fjall(#[from] fjall::Error),
    // #[cfg(feature = "bytemuck")]
    // #[cfg_attr(feature = "bytemuck", error("bytemuck error: {0}"))]
    // Bytemuck(bytemuck::PodCastError),
}

impl DbError {
    pub fn status_code(&self) -> u16 {
        match self {
            DbError::Client(_) => 400,
            DbError::NotFound => 404,
            DbError::NotImplemented => 501,
            _ => 500,
        }
    }
    pub fn to_resp(&self) -> (u16, &'static str) {
        match self {
            DbError::Client(msg) => (400, msg),
            DbError::NotFound => (404, ""),
            DbError::NotImplemented => (501, ""),
            _ => {
                error!("{self}");
                (500, "")
            }
        }
    }
}

pub type DbResult<T> = Result<T, DbError>;