second-brain-core 0.13.4

Core library for second-brain: SQLite storage with vector and lexical indexes, BGE embeddings, and hybrid retrieval
Documentation
use anyhow::{Context, Result};
use rusqlite::params;
use serde::{Deserialize, Serialize};

use super::identity::{Epoch, IdentityTag};
use crate::sqlite_store::SqliteStore;

const PEER_VIEW_PREFIX: &str = "peer_view:";

/// What a peer's newest accepted hello showed about this device.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct PeerView {
    #[serde(skip)]
    pub peer: String,
    pub heard_at_micros: i64,
    /// The hello listed this device's row under its current signing key.
    pub holds_own_row: bool,
    /// Epochs the peer declared that this device still could not open
    /// after taking the hello.
    pub lacking: Vec<Epoch>,
}

impl SqliteStore {
    pub fn record_peer_view(&self, tag: &IdentityTag, view: &PeerView) -> Result<()> {
        let value = serde_json::to_string(view)?;
        self.with_txn(|tx| {
            tx.execute(
                "INSERT OR REPLACE INTO index_meta (key, value) VALUES (?1, ?2)",
                params![view_key(tag, &view.peer), value],
            )?;
            Ok(())
        })
    }

    /// Every view recorded under `tag`, ordered by peer id.
    pub fn peer_views(&self, tag: &IdentityTag) -> Result<Vec<PeerView>> {
        let prefix = view_key(tag, "");
        let conn = self.reader();
        let mut stmt = conn.prepare(
            "SELECT key, value FROM index_meta WHERE substr(key, 1, length(?1)) = ?1 ORDER BY key",
        )?;
        let rows = stmt.query_map(params![prefix], |r| {
            Ok((r.get::<_, String>(0)?, r.get::<_, String>(1)?))
        })?;
        let mut views = Vec::new();
        for row in rows {
            let (key, value) = row?;
            let mut view: PeerView = serde_json::from_str(&value)
                .with_context(|| format!("stored {key} is {value:?}"))?;
            view.peer = key[prefix.len()..].to_string();
            views.push(view);
        }
        Ok(views)
    }
}

fn view_key(tag: &IdentityTag, peer: &str) -> String {
    format!("{PEER_VIEW_PREFIX}{}:{peer}", tag.as_str())
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::keys::KeyId;

    fn view(peer: &str, holds_own_row: bool) -> PeerView {
        PeerView {
            peer: peer.to_string(),
            heard_at_micros: 7,
            holds_own_row,
            lacking: vec![Epoch {
                number: 2,
                key_id: KeyId([1; 8]),
            }],
        }
    }

    #[test]
    fn views_are_kept_per_identity_and_peer_with_the_newest_winning() {
        let store = SqliteStore::in_memory("m".to_string()).unwrap();
        let ours = IdentityTag::from("t-1".to_string());
        let other = IdentityTag::from("t-10".to_string());
        store.record_peer_view(&ours, &view("b", false)).unwrap();
        store.record_peer_view(&ours, &view("a", true)).unwrap();
        store.record_peer_view(&ours, &view("b", true)).unwrap();
        store.record_peer_view(&other, &view("c", true)).unwrap();

        assert_eq!(
            store.peer_views(&ours).unwrap(),
            vec![view("a", true), view("b", true)]
        );
        assert_eq!(store.peer_views(&other).unwrap(), vec![view("c", true)]);
    }
}