backbone-accounting 0.15.0

GL, journals, ledger, reconciliation (extracted from bersihir)
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
124
125
126
127
128
129
130
131
132
133
134
135
136

//! ReportingRepository — persistence port for financial-statement reads.
//!
//! Pure reads; no report write path exists (reports are computed on the fly, never stored —
//! the `financial_statement` entity is not the compute target). All shaping (normal-side
//! signing, A=L+E tying, tree rollups, aging buckets) is pure domain logic that stays in
//! `ReportingService`.
//!
//! Tenancy (ADR-0029): the `company_id` params are the documented legacy twin — the port keeps
//! its shapes so unstripped callers compile and run unchanged; the adapter never keys a
//! statement on them (the ambient org scope scopes every statement instead).

use async_trait::async_trait;
use chrono::NaiveDate;
use rust_decimal::Decimal;
use uuid::Uuid;

/// One detail account's debit/credit activity within a date window.
#[derive(Debug, Clone)]
pub struct AccountSumRow {
    pub account_id: Uuid,
    pub account_type: String,
    pub account_number: String,
    pub name: String,
    pub debit: Decimal,
    pub credit: Decimal,
}

/// One node of the chart of accounts (detail or header) — the tree the sums roll up through.
#[derive(Debug, Clone)]
pub struct AccountNodeRow {
    pub id: Uuid,
    pub parent_id: Option<Uuid>,
    pub account_number: String,
    pub name: String,
    pub account_type: String,
    pub level: i32,
    pub is_header: bool,
    pub is_detail: bool,
}

/// One chronological ledger line inside a GL window (the `ledgers` projection carries the
/// denormalized account/journal info and the materialized running balance).
#[derive(Debug, Clone)]
pub struct GlLineRow {
    pub account_id: Uuid,
    pub account_number: String,
    pub account_name: String,
    pub journal_number: String,
    pub transaction_date: NaiveDate,
    pub posting_date: NaiveDate,
    pub description: String,
    pub reference: Option<String>,
    pub currency: String,
    pub debit: Decimal,
    pub credit: Decimal,
    pub balance_before: Decimal,
    pub balance_after: Decimal,
    pub party_type: Option<String>,
    pub party_id: Option<Uuid>,
    pub source_type: Option<String>,
    pub source_reference: Option<String>,
    pub is_reconciled: bool,
}

/// One AR/AP line for a party (from `journal_lines`, the residual id space), with the
/// line's residual as of the report date.
#[derive(Debug, Clone)]
pub struct PartyLedgerRow {
    pub line_id: Uuid,
    pub account_id: Uuid,
    pub account_number: String,
    pub account_name: String,
    pub journal_number: String,
    pub transaction_date: NaiveDate,
    pub description: Option<String>,
    pub debit: Decimal,
    pub credit: Decimal,
    pub currency: String,
    pub residual: Decimal,
}

/// One open (residual > 0 as of the report date) AR/AP line, party-stamped — the grain the
/// aged report buckets.
#[derive(Debug, Clone)]
pub struct AgedItemRow {
    pub party_type: String,
    pub party_id: Uuid,
    pub account_id: Uuid,
    pub account_number: String,
    pub transaction_date: NaiveDate,
    pub source_reference: Option<String>,
    pub currency: String,
    pub residual: Decimal,
}

#[async_trait]
pub trait ReportingRepository: Send + Sync {
    /// Per-detail-account debit/credit sums. `lo = None` → since inception; otherwise `>= lo`.
    /// `<= hi` always.
    async fn account_sums(
        &self,
        lo: Option<NaiveDate>,
        hi: NaiveDate,
    ) -> anyhow::Result<Vec<AccountSumRow>>;

    /// The full chart of accounts (headers + details) for tree rollups.
    async fn account_directory(&self) -> anyhow::Result<Vec<AccountNodeRow>>;

    /// Chronological ledger lines within `[lo, hi]` (lo = None → since inception), optionally
    /// narrowed to one account. Ordered by account number, then posting date, then sequence.
    async fn gl_lines(
        &self,
        account_id: Option<Uuid>,
        lo: Option<NaiveDate>,
        hi: NaiveDate,
        limit: i64,
        offset: i64,
    ) -> anyhow::Result<Vec<GlLineRow>>;

    /// Every party-stamped line for one party through `as_of`, each with its residual as of
    /// that date (partials dated after `as_of` don't count yet).
    async fn party_ledger_lines(
        &self,
        party_type: &str,
        party_id: Uuid,
        as_of: NaiveDate,
    ) -> anyhow::Result<Vec<PartyLedgerRow>>;

    /// Open AR or AP items across all parties as of `as_of`, for the given account subtype
    /// (`accounts_receivable` / `accounts_payable`). Residual as of `as_of`.
    async fn aged_open_items(
        &self,
        account_subtype: &str,
        as_of: NaiveDate,
    ) -> anyhow::Result<Vec<AgedItemRow>>;
}