Skip to main content

second_brain_sync/
export.rs

1use std::io::Write;
2
3use anyhow::Result;
4
5use second_brain_core::schema::{SyncNodeType, SyncOp};
6use second_brain_core::store::StoreAdmin;
7
8pub use second_brain_core::schema::SyncRecord;
9
10pub fn export_changes<W: Write>(
11    store: &dyn StoreAdmin,
12    after_seq: u64,
13    writer: &mut W,
14) -> Result<u64> {
15    let entries = store.sync_log_since(after_seq)?;
16    let mut max_seq = after_seq;
17
18    let mut records: Vec<SyncRecord> = entries
19        .into_iter()
20        .map(|e| {
21            let data = e.data.as_ref().and_then(|d| serde_json::from_str(d).ok());
22            SyncRecord {
23                local_seq: e.local_seq as u64,
24                origin_machine_id: e.origin_machine_id,
25                origin_seq: e.origin_seq as u64,
26                op: e.op,
27                node_type: e.node_type,
28                node_id: e.node_id,
29                timestamp: e.timestamp,
30                data,
31            }
32        })
33        .collect();
34
35    sort_for_import(&mut records);
36
37    for record in &records {
38        serde_json::to_writer(&mut *writer, record)?;
39        writer.write_all(b"\n")?;
40        if record.local_seq > max_seq {
41            max_seq = record.local_seq;
42        }
43    }
44
45    Ok(max_seq)
46}
47
48pub fn export_page(
49    store: &dyn StoreAdmin,
50    after_seq: u64,
51    limit: usize,
52) -> Result<(Vec<serde_json::Value>, u64)> {
53    let capped = store.sync_log_page(after_seq, Some(limit))?;
54    let mut sync_records: Vec<SyncRecord> = capped
55        .iter()
56        .map(|e| {
57            let data = e.data.as_ref().and_then(|d| serde_json::from_str(d).ok());
58            SyncRecord {
59                local_seq: e.local_seq as u64,
60                origin_machine_id: e.origin_machine_id.clone(),
61                origin_seq: e.origin_seq as u64,
62                op: e.op,
63                node_type: e.node_type,
64                node_id: e.node_id.clone(),
65                timestamp: e.timestamp,
66                data,
67            }
68        })
69        .collect();
70    sort_for_import(&mut sync_records);
71    let max_seq = sync_records
72        .iter()
73        .map(|r| r.local_seq)
74        .max()
75        .unwrap_or(after_seq);
76    let records: Vec<serde_json::Value> = sync_records
77        .iter()
78        .map(|r| {
79            serde_json::json!({
80                "local_seq": r.local_seq,
81                "origin_machine_id": r.origin_machine_id,
82                "origin_seq": r.origin_seq,
83                "op": r.op,
84                "node_type": r.node_type,
85                "node_id": r.node_id,
86                "timestamp": r.timestamp,
87                "data": r.data,
88            })
89        })
90        .collect();
91    Ok((records, max_seq))
92}
93
94pub fn export_to_stdout(store: &dyn StoreAdmin, after_seq: u64) -> Result<u64> {
95    let stdout = std::io::stdout();
96    let mut handle = stdout.lock();
97    export_changes(store, after_seq, &mut handle)
98}
99
100pub fn sort_for_import(records: &mut [SyncRecord]) {
101    records.sort_by(|a, b| {
102        let type_order = |r: &SyncRecord| -> u8 {
103            match (&r.op, &r.node_type) {
104                // Distillation is a leaf referencing a memory, so it is dropped
105                // before its target and created after it, same as a relation.
106                (SyncOp::Delete, SyncNodeType::Distillation) => 0,
107                (SyncOp::Delete, SyncNodeType::Relation) => 1,
108                (SyncOp::Delete, SyncNodeType::Memory) => 2,
109                (SyncOp::Delete, SyncNodeType::Entity) => 3,
110                (SyncOp::Delete, SyncNodeType::Conversation) => 4,
111                (SyncOp::Create, SyncNodeType::Conversation) => 5,
112                (SyncOp::Create, SyncNodeType::Entity) => 6,
113                (SyncOp::Create, SyncNodeType::Memory) => 7,
114                (SyncOp::Create, SyncNodeType::Relation) => 8,
115                (SyncOp::Create, SyncNodeType::Distillation) => 9,
116                (SyncOp::Update, SyncNodeType::Conversation) => 10,
117                (SyncOp::Update, SyncNodeType::Entity) => 11,
118                (SyncOp::Update, SyncNodeType::Memory) => 12,
119                (SyncOp::Update, SyncNodeType::Relation) => 13,
120                (SyncOp::Update, SyncNodeType::Distillation) => 14,
121            }
122        };
123        type_order(a)
124            .cmp(&type_order(b))
125            .then(a.local_seq.cmp(&b.local_seq))
126    });
127}