second-brain-sync 0.12.0

Bidirectional sync for second-brain: SSH transport, JSONL change log, conflict resolution
Documentation
use std::io::Write;

use anyhow::Result;

use second_brain_core::schema::{SyncNodeType, SyncOp};
use second_brain_core::store::StoreAdmin;

pub use second_brain_core::schema::SyncRecord;

pub fn export_changes<W: Write>(
    store: &dyn StoreAdmin,
    after_seq: u64,
    writer: &mut W,
) -> Result<u64> {
    let entries = store.sync_log_since(after_seq)?;
    let mut max_seq = after_seq;

    let mut records: Vec<SyncRecord> = entries
        .into_iter()
        .map(|e| {
            let data = e.data.as_ref().and_then(|d| serde_json::from_str(d).ok());
            SyncRecord {
                local_seq: e.local_seq as u64,
                origin_machine_id: e.origin_machine_id,
                origin_seq: e.origin_seq as u64,
                op: e.op,
                node_type: e.node_type,
                node_id: e.node_id,
                timestamp: e.timestamp,
                data,
            }
        })
        .collect();

    sort_for_import(&mut records);

    for record in &records {
        serde_json::to_writer(&mut *writer, record)?;
        writer.write_all(b"\n")?;
        if record.local_seq > max_seq {
            max_seq = record.local_seq;
        }
    }

    Ok(max_seq)
}

pub fn export_page(
    store: &dyn StoreAdmin,
    after_seq: u64,
    limit: usize,
) -> Result<(Vec<serde_json::Value>, u64)> {
    let capped = store.sync_log_page(after_seq, Some(limit))?;
    let mut sync_records: Vec<SyncRecord> = capped
        .iter()
        .map(|e| {
            let data = e.data.as_ref().and_then(|d| serde_json::from_str(d).ok());
            SyncRecord {
                local_seq: e.local_seq as u64,
                origin_machine_id: e.origin_machine_id.clone(),
                origin_seq: e.origin_seq as u64,
                op: e.op,
                node_type: e.node_type,
                node_id: e.node_id.clone(),
                timestamp: e.timestamp,
                data,
            }
        })
        .collect();
    sort_for_import(&mut sync_records);
    let max_seq = sync_records
        .iter()
        .map(|r| r.local_seq)
        .max()
        .unwrap_or(after_seq);
    let records: Vec<serde_json::Value> = sync_records
        .iter()
        .map(|r| {
            serde_json::json!({
                "local_seq": r.local_seq,
                "origin_machine_id": r.origin_machine_id,
                "origin_seq": r.origin_seq,
                "op": r.op,
                "node_type": r.node_type,
                "node_id": r.node_id,
                "timestamp": r.timestamp,
                "data": r.data,
            })
        })
        .collect();
    Ok((records, max_seq))
}

pub fn export_to_stdout(store: &dyn StoreAdmin, after_seq: u64) -> Result<u64> {
    let stdout = std::io::stdout();
    let mut handle = stdout.lock();
    export_changes(store, after_seq, &mut handle)
}

pub fn sort_for_import(records: &mut [SyncRecord]) {
    records.sort_by(|a, b| {
        let type_order = |r: &SyncRecord| -> u8 {
            match (&r.op, &r.node_type) {
                // Distillation is a leaf referencing a memory, so it is dropped
                // before its target and created after it, same as a relation.
                (SyncOp::Delete, SyncNodeType::Distillation) => 0,
                (SyncOp::Delete, SyncNodeType::Relation) => 1,
                (SyncOp::Delete, SyncNodeType::Memory) => 2,
                (SyncOp::Delete, SyncNodeType::Entity) => 3,
                (SyncOp::Delete, SyncNodeType::Conversation) => 4,
                (SyncOp::Create, SyncNodeType::Conversation) => 5,
                (SyncOp::Create, SyncNodeType::Entity) => 6,
                (SyncOp::Create, SyncNodeType::Memory) => 7,
                (SyncOp::Create, SyncNodeType::Relation) => 8,
                (SyncOp::Create, SyncNodeType::Distillation) => 9,
                (SyncOp::Update, SyncNodeType::Conversation) => 10,
                (SyncOp::Update, SyncNodeType::Entity) => 11,
                (SyncOp::Update, SyncNodeType::Memory) => 12,
                (SyncOp::Update, SyncNodeType::Relation) => 13,
                (SyncOp::Update, SyncNodeType::Distillation) => 14,
            }
        };
        type_order(a)
            .cmp(&type_order(b))
            .then(a.local_seq.cmp(&b.local_seq))
    });
}