second_brain_sync/
export.rs1use 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_export_page(after_seq, None)?;
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_export_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 (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}