cala-ledger 0.15.5

An embeddable double sided accounting ledger built on PG/SQLx
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

use rust_decimal::Decimal;
use thiserror::Error;

use cel_interpreter::CelError;

use crate::primitives::*;

use super::control::{
    VelocityControlColumn, VelocityControlCreateError, VelocityControlFindError,
    VelocityControlModifyError, VelocityControlQueryError,
};
use super::limit::{
    VelocityLimitColumn, VelocityLimitCreateError, VelocityLimitFindError,
    VelocityLimitModifyError, VelocityLimitQueryError,
};

#[derive(Error, Debug)]
pub enum VelocityError {
    #[error("VelocityError - Sqlx: {0}")]
    Sqlx(sqlx::Error),
    #[error("VelocityError - CelError: {0}")]
    CelError(#[from] CelError),
    #[error("{0}")]
    ParamError(#[from] crate::param::error::ParamError),
    #[error("VelocityError - Could not find control by id: {0}")]
    CouldNotFindControlById(VelocityControlId),
    #[error("VelocityError - Enforcement: {0}")]
    Enforcement(#[from] LimitExceededError),
    #[error("VelocityError - HydrationError: {0}")]
    HydrationError(#[from] es_entity::EntityHydrationError),
    #[error("VelocityError - VelocityControlCreate: {0}")]
    VelocityControlCreate(VelocityControlCreateError),
    #[error("VelocityError - VelocityControlModify: {0}")]
    VelocityControlModify(#[from] VelocityControlModifyError),
    #[error("VelocityError - VelocityControlFind: {0}")]
    VelocityControlFind(VelocityControlFindError),
    #[error("VelocityError - VelocityControlQuery: {0}")]
    VelocityControlQuery(#[from] VelocityControlQueryError),
    #[error("VelocityError - VelocityLimitCreate: {0}")]
    VelocityLimitCreate(VelocityLimitCreateError),
    #[error("VelocityError - VelocityLimitModify: {0}")]
    VelocityLimitModify(#[from] VelocityLimitModifyError),
    #[error("VelocityError - VelocityLimitFind: {0}")]
    VelocityLimitFind(#[from] VelocityLimitFindError),
    #[error("VelocityError - VelocityLimitQuery: {0}")]
    VelocityLimitQuery(#[from] VelocityLimitQueryError),
    #[error("VelocityError - control_id '{0}' already exists")]
    ControlIdAlreadyExists(String),
    #[error("VelocityError - limit_id '{0}' already exists")]
    LimitIdAlreadyExists(String),
    #[error("VelocityError - Limit already added to Control")]
    LimitAlreadyAddedToControl,
}

impl From<VelocityControlFindError> for VelocityError {
    fn from(error: VelocityControlFindError) -> Self {
        match error {
            VelocityControlFindError::NotFound {
                column: Some(VelocityControlColumn::Id),
                value,
                ..
            } => Self::CouldNotFindControlById(value.parse().expect("invalid uuid")),
            other => Self::VelocityControlFind(other),
        }
    }
}

impl From<sqlx::Error> for VelocityError {
    fn from(error: sqlx::Error) -> Self {
        if let Some(err) = error.as_database_error() {
            if let Some(constraint) = err.constraint() {
                if constraint
                    .contains("cala_velocity_control_limits_velocity_control_id_velocity_l_key")
                {
                    return Self::LimitAlreadyAddedToControl;
                }
            }
        }
        Self::Sqlx(error)
    }
}

impl From<VelocityControlCreateError> for VelocityError {
    fn from(error: VelocityControlCreateError) -> Self {
        match error {
            VelocityControlCreateError::ConstraintViolation {
                column: Some(VelocityControlColumn::Id),
                value,
                ..
            } => Self::ControlIdAlreadyExists(value.unwrap_or_default()),
            other => Self::VelocityControlCreate(other),
        }
    }
}

impl From<VelocityLimitCreateError> for VelocityError {
    fn from(error: VelocityLimitCreateError) -> Self {
        match error {
            VelocityLimitCreateError::ConstraintViolation {
                column: Some(VelocityLimitColumn::Id),
                value,
                ..
            } => Self::LimitIdAlreadyExists(value.unwrap_or_default()),
            other => Self::VelocityLimitCreate(other),
        }
    }
}

#[derive(Error, Debug)]
#[error("Velocity limit exceeded")]
pub struct LimitExceededError {
    pub account_id: AccountId,
    pub currency: Currency,
    pub limit_id: VelocityLimitId,
    pub layer: Layer,
    pub direction: DebitOrCredit,
    pub limit: Decimal,
    pub requested: Decimal,
}