eventfold 0.2.0

Lightweight, append-only event log with derived views — your application state is a fold over an event log
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
137
138
139
140
141
142
143
144
145

mod common;

use eventfold::{Event, EventLog};
use serde::{Deserialize, Serialize};
use serde_json::json;
use tempfile::tempdir;

#[test]
fn test_append_and_read_with_metadata() {
    let dir = tempdir().unwrap();
    let mut log = EventLog::open(dir.path()).unwrap();

    let event = Event::new("user_action", json!({"action": "click"}))
        .with_id("evt-001")
        .with_actor("user_42");
    log.append(&event).unwrap();

    let events: Vec<_> = log
        .read_from(0)
        .unwrap()
        .collect::<Result<Vec<_>, _>>()
        .unwrap();

    assert_eq!(events.len(), 1);
    let read_event = &events[0].0;
    assert_eq!(read_event.event_type, "user_action");
    assert_eq!(read_event.id, Some("evt-001".to_string()));
    assert_eq!(read_event.actor, Some("user_42".to_string()));
    assert_eq!(read_event.data["action"], "click");
}

#[derive(Default, Clone, Debug, PartialEq, Serialize, Deserialize)]
struct PerActorCount {
    user_a: u64,
    user_b: u64,
    unknown: u64,
}

fn per_actor_reducer(mut state: PerActorCount, event: &Event) -> PerActorCount {
    match event.actor.as_deref() {
        Some("user_a") => state.user_a += 1,
        Some("user_b") => state.user_b += 1,
        _ => state.unknown += 1,
    }
    state
}

#[test]
fn test_reducer_reads_actor() {
    let dir = tempdir().unwrap();
    let mut log = EventLog::builder(dir.path())
        .view::<PerActorCount>("per_actor", per_actor_reducer)
        .open()
        .unwrap();

    log.append(&Event::new("click", json!({})).with_actor("user_a"))
        .unwrap();
    log.append(&Event::new("click", json!({})).with_actor("user_b"))
        .unwrap();
    log.append(&Event::new("click", json!({})).with_actor("user_a"))
        .unwrap();
    log.append(&Event::new("click", json!({})))
        .unwrap(); // no actor

    log.refresh_all().unwrap();
    let state: &PerActorCount = log.view("per_actor").unwrap();

    assert_eq!(state.user_a, 2);
    assert_eq!(state.user_b, 1);
    assert_eq!(state.unknown, 1);
}

#[test]
fn test_view_with_mixed_events() {
    let dir = tempdir().unwrap();
    let mut log = EventLog::builder(dir.path())
        .view::<PerActorCount>("per_actor", per_actor_reducer)
        .open()
        .unwrap();

    // Old-style event (no metadata)
    log.append(&Event::new("click", json!({}))).unwrap();

    // New-style events (with metadata)
    log.append(&Event::new("click", json!({})).with_actor("user_a"))
        .unwrap();
    log.append(
        &Event::new("click", json!({}))
            .with_id("e3")
            .with_actor("user_b")
            .with_meta(json!({"session": "s1"})),
    )
    .unwrap();

    log.refresh_all().unwrap();
    let state: &PerActorCount = log.view("per_actor").unwrap();

    assert_eq!(state.user_a, 1);
    assert_eq!(state.user_b, 1);
    assert_eq!(state.unknown, 1);
}

#[test]
fn test_rotation_preserves_metadata() {
    let dir = tempdir().unwrap();
    let mut log = EventLog::builder(dir.path())
        .view::<PerActorCount>("per_actor", per_actor_reducer)
        .open()
        .unwrap();

    // Append with metadata
    log.append(&Event::new("click", json!({})).with_id("e1").with_actor("user_a"))
        .unwrap();
    log.append(&Event::new("click", json!({})).with_id("e2").with_actor("user_b"))
        .unwrap();

    // Rotate — events move to archive
    log.rotate().unwrap();

    // Append more after rotation
    log.append(&Event::new("click", json!({})).with_id("e3").with_actor("user_a"))
        .unwrap();

    // Read full (archive + active) — metadata should survive
    let events: Vec<_> = log
        .read_full()
        .unwrap()
        .collect::<Result<Vec<_>, _>>()
        .unwrap();

    assert_eq!(events.len(), 3);
    assert_eq!(events[0].0.id, Some("e1".to_string()));
    assert_eq!(events[0].0.actor, Some("user_a".to_string()));
    assert_eq!(events[1].0.id, Some("e2".to_string()));
    assert_eq!(events[1].0.actor, Some("user_b".to_string()));
    assert_eq!(events[2].0.id, Some("e3".to_string()));
    assert_eq!(events[2].0.actor, Some("user_a".to_string()));

    // Rebuild view from archive — should get correct state
    log.refresh_all().unwrap();
    let state: &PerActorCount = log.view("per_actor").unwrap();
    assert_eq!(state.user_a, 2);
    assert_eq!(state.user_b, 1);
    assert_eq!(state.unknown, 0);
}