topodb 0.0.12

Embedded, local-first memory engine for AI agents: temporal property graph + scoped recall.
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

//! `Db::edges_from` — the scoped edge-listing/supersession primitive: find
//! the open edges a changed fact should close, without a full traverse.

use topodb::*;

fn node(label: &str, scope: Scope) -> (NodeId, Op) {
    let id = NodeId::new();
    (
        id,
        Op::CreateNode {
            id,
            scope,
            label: label.into(),
            props: Props::new(),
        },
    )
}

fn edge(ty: &str, scope: Scope, from: NodeId, to: NodeId) -> (EdgeId, Op) {
    let id = EdgeId::new();
    (
        id,
        Op::CreateEdge {
            id,
            scope,
            ty: ty.into(),
            from,
            to,
            props: Props::new(),
            valid_from: None,
        },
    )
}

#[test]
fn edges_from_filters_by_target_type_and_openness() {
    let dir = tempfile::tempdir().unwrap();
    let db = Db::open(dir.path().join("t.redb")).unwrap();
    let s = ScopeId::new();
    let scope = Scope::Id(s);
    let scopes = ScopeSet::of(&[s]);

    let (a, op_a) = node("Entity", scope);
    let (b, op_b) = node("Entity", scope);
    let (c, op_c) = node("Entity", scope);
    db.submit(vec![op_a, op_b, op_c]).unwrap();

    let (e_ab_works, op1) = edge("works_at", scope, a, b);
    let (e_ac_works, op2) = edge("works_at", scope, a, c);
    let (e_ab_about, op3) = edge("about", scope, a, b);
    db.submit(vec![op1, op2, op3]).unwrap();

    // No filters: all three, oldest first (by edge id).
    let all = db.edges_from(&scopes, a, None, None, false).unwrap();
    assert_eq!(all.len(), 3);
    assert!(all.windows(2).all(|w| w[0].id <= w[1].id));

    // Type filter.
    let works: Vec<EdgeId> = db
        .edges_from(&scopes, a, None, Some("works_at"), false)
        .unwrap()
        .iter()
        .map(|e| e.id)
        .collect();
    assert_eq!(works.len(), 2);
    assert!(works.contains(&e_ab_works) && works.contains(&e_ac_works));

    // Target filter.
    let to_b: Vec<EdgeId> = db
        .edges_from(&scopes, a, Some(b), None, false)
        .unwrap()
        .iter()
        .map(|e| e.id)
        .collect();
    assert_eq!(to_b.len(), 2);
    assert!(to_b.contains(&e_ab_works) && to_b.contains(&e_ab_about));

    // Both filters.
    let narrow = db
        .edges_from(&scopes, a, Some(b), Some("works_at"), false)
        .unwrap();
    assert_eq!(narrow.len(), 1);
    assert_eq!(narrow[0].id, e_ab_works);

    // Close one edge: open_only excludes it, the unfiltered listing keeps it.
    db.submit(vec![Op::CloseEdge {
        id: e_ab_works,
        valid_to: None,
    }])
    .unwrap();
    let open_works = db
        .edges_from(&scopes, a, None, Some("works_at"), true)
        .unwrap();
    assert_eq!(open_works.len(), 1);
    assert_eq!(open_works[0].id, e_ac_works);
    assert_eq!(
        db.edges_from(&scopes, a, None, Some("works_at"), false)
            .unwrap()
            .len(),
        2,
        "closed edges stay listed when open_only is false"
    );

    // An unknown type matches nothing (not everything).
    assert!(db
        .edges_from(&scopes, a, None, Some("never_written"), false)
        .unwrap()
        .is_empty());

    // A never-created `from` node yields empty, not an error.
    assert!(db
        .edges_from(&scopes, NodeId::new(), None, None, false)
        .unwrap()
        .is_empty());
}

#[test]
fn edges_from_gates_on_edge_scope() {
    let dir = tempfile::tempdir().unwrap();
    let db = Db::open(dir.path().join("t.redb")).unwrap();
    let s = ScopeId::new();
    let scope = Scope::Id(s);

    let (a, op_a) = node("Entity", scope);
    let (b, op_b) = node("Entity", scope);
    db.submit(vec![op_a, op_b]).unwrap();
    let (e, op_e) = edge("knows", scope, a, b);
    db.submit(vec![op_e]).unwrap();

    // In scope: visible.
    let hits = db
        .edges_from(&ScopeSet::of(&[s]), a, None, None, true)
        .unwrap();
    assert_eq!(hits.len(), 1);
    assert_eq!(hits[0].id, e);

    // A reader whose scope set doesn't include the edge's scope sees nothing
    // — there is no unscoped read.
    assert!(db
        .edges_from(&ScopeSet::of(&[ScopeId::new()]), a, None, None, true)
        .unwrap()
        .is_empty());
}