doubleentry 0.8.0

An immutable, tamper-evident double-entry bookkeeping engine: one pure rule core, exact integer money, identity derived from the idempotency key, and one append-only RFC 6962 Merkle log with inclusion, consistency and sealed-balance proofs and C2SP checkpoints, in memory (sync) or over SQLite and PostgreSQL (async).
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

//! Stage 4 for entries: the reversal target an entry names (the hold a
//! resolution names is checked next, by the hold rules).
//!
//! A reversal names its target by its committed id. It must find the target
//! (400), which must not act on a hold (450: a reservation ends with a void,
//! a mistaken capture with a new entry), be the only reversal of it (401),
//! be dated no earlier (402), and mirror it exactly: the same postings in
//! the same order with every side swapped (403). A reversal may itself be
//! reversed.

use super::context::EntryFacts;
use crate::error::Rejection;
use time::Date;

use crate::model::{Entry, EntryId, EntryRecord, Posting, PostingRecord, Side};

use super::structural::index;

/// The reversal rules: 400 → 450 → 401 → 402 → 403.
pub(crate) fn check<const P: u8>(
    facts: &EntryFacts<P>,
    entry: &EntryRecord<P>,
) -> Result<(), Rejection> {
    if let Some(target) = &facts.target {
        let original = target
            .entry
            .as_ref()
            .ok_or(Rejection::ReversalTargetUnknown { target: target.id })?;
        if original.record.parts().hold.is_some() {
            return Err(Rejection::HoldNotReversible { target: target.id });
        }
        if let Some(by) = target.reversed_by {
            return Err(Rejection::AlreadyReversed {
                target: target.id,
                by,
            });
        }
        let booked = original.record.parts().booking_date;
        if entry.parts().booking_date < booked {
            return Err(Rejection::ReversalBeforeTarget {
                target: target.id,
                booked,
            });
        }
        mirrors(target.id, &original.record, entry)?;
    }
    Ok(())
}

/// Whether `reversal` mirrors `original`: same postings, sides swapped.
fn mirrors<const P: u8>(
    target: EntryId,
    original: &EntryRecord<P>,
    reversal: &EntryRecord<P>,
) -> Result<(), Rejection> {
    let (original, reversal) = (&original.parts().postings, &reversal.parts().postings);
    if original.len() != reversal.len() {
        return Err(Rejection::NotAMirror {
            target,
            posting: None,
        });
    }
    match original
        .iter()
        .zip(reversal)
        .position(|(original, reversal)| mirror(original) != *reversal)
    {
        Some(posting) => Err(Rejection::NotAMirror {
            target,
            posting: Some(index(posting)),
        }),
        None => Ok(()),
    }
}

/// A posting with its side swapped.
fn mirror<const P: u8>(posting: &PostingRecord<P>) -> PostingRecord<P> {
    PostingRecord {
        side: posting.side.opposite(),
        ..posting.clone()
    }
}

/// The draft that reverses entry `target`, recorded as `original`: its
/// postings in order with every side swapped, by handle, booked on `on` under
/// `key`. Building it checks no rule; recording it checks them all.
pub(crate) fn reversal<const P: u8>(
    target: EntryId,
    original: &EntryRecord<P>,
    key: &str,
    on: Date,
) -> Entry<P> {
    original.parts().postings.iter().map(mirror).fold(
        Entry::new(key, on).reverses(target),
        |draft, posting| {
            let leg = match posting.side {
                Side::Debit => Posting::debit(posting.handle, posting.amount, posting.currency),
                Side::Credit => Posting::credit(posting.handle, posting.amount, posting.currency),
            };
            draft.posting(leg.dimensions(posting.dimensions.clone()))
        },
    )
}