ledgr 0.1.0

A TUI personal finance app: import bank/pension statements, build a local database, and analyze your finances.
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
124
125
126

use serde::{Deserialize, Serialize};

pub type Id = i64;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum AccountType {
    Checking,
    Savings,
    CreditCard,
    Pension,
    Investment,
    Other,
}

impl AccountType {
    pub fn as_str(&self) -> &'static str {
        match self {
            AccountType::Checking => "checking",
            AccountType::Savings => "savings",
            AccountType::CreditCard => "credit_card",
            AccountType::Pension => "pension",
            AccountType::Investment => "investment",
            AccountType::Other => "other",
        }
    }

    pub fn parse(s: &str) -> Option<Self> {
        Some(match s {
            "checking" => AccountType::Checking,
            "savings" => AccountType::Savings,
            "credit_card" => AccountType::CreditCard,
            "pension" => AccountType::Pension,
            "investment" => AccountType::Investment,
            "other" => AccountType::Other,
            _ => return None,
        })
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Account {
    pub id: Id,
    pub name: String,
    pub institution: Option<String>,
    pub account_type: AccountType,
    pub currency: String,
}

/// Fields needed to create a new account; `id` is assigned by the database.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NewAccount {
    pub name: String,
    pub institution: Option<String>,
    pub account_type: AccountType,
    pub currency: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Category {
    pub id: Id,
    pub name: String,
    pub parent_id: Option<Id>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Transaction {
    pub id: Id,
    pub account_id: Id,
    pub statement_id: Option<Id>,
    /// ISO 8601 date, e.g. `2026-07-11`.
    pub posted_at: String,
    /// Signed amount in minor currency units (e.g. pence), to avoid float drift.
    pub amount_minor: i64,
    pub currency: String,
    pub description: String,
    pub raw_description: Option<String>,
    pub category_id: Option<Id>,
    pub external_id: Option<String>,
}

/// Fields needed to create a new transaction; `id` is assigned by the database.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NewTransaction {
    pub account_id: Id,
    pub statement_id: Option<Id>,
    pub posted_at: String,
    pub amount_minor: i64,
    pub currency: String,
    pub description: String,
    pub raw_description: Option<String>,
    pub category_id: Option<Id>,
    pub external_id: Option<String>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum LinkRelation {
    Transfer,
    Refund,
    DuplicateOf,
    Related,
}

impl LinkRelation {
    pub fn as_str(&self) -> &'static str {
        match self {
            LinkRelation::Transfer => "transfer",
            LinkRelation::Refund => "refund",
            LinkRelation::DuplicateOf => "duplicate_of",
            LinkRelation::Related => "related",
        }
    }
}

/// An edge between two transactions, e.g. the two legs of a transfer between
/// accounts, or a refund pointing back at its original charge.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TransactionLink {
    pub id: Id,
    pub from_transaction_id: Id,
    pub to_transaction_id: Id,
    pub relation: LinkRelation,
    /// Set when the link was inferred rather than user-confirmed.
    pub confidence: Option<f64>,
}