Struct SocialGraphStore 

pub struct SocialGraphStore { /* private fields */ }

Implementations

impl SocialGraphStore

pub fn force_sync(&self) -> Result<()>

Forces graph-owned LMDB state to durable storage.

The public event/profile blobs are owned by the caller’s HashtreeStore and must be synced by that store separately.

pub fn set_profile_index_overmute_threshold(&self, threshold: f64)

pub fn profile_search_root(&self) -> Result<Option<Cid>>

pub fn profiles_by_pubkey_root(&self) -> Result<Option<Cid>>

pub fn public_events_root(&self) -> Result<Option<Cid>>

pub fn latest_profile_event(&self, pubkey_hex: &str) -> Result<Option<Event>>

pub fn profile_search_entries_for_prefix( &self, prefix: &str, ) -> Result<Vec<(String, StoredProfileSearchEntry)>>

pub fn validate_profile_indexes_for_event( &self, event: &Event, ) -> Result<StoredProfileSearchEntry>

Validate profile-by-pubkey and profile-search semantics against one real metadata event.

This reads both persisted roots through the shared storage router, proves that the pubkey points at the expected event blob, derives a normal search term from that event, and proves the exact search entry points at the same mirrored blob.

pub fn sync_profile_index_for_events(&self, events: &[Event]) -> Result<()>

pub fn sync_profile_index_for_events_with_frozen_distances( &self, events: &[Event], decisions: &BTreeMap<String, Option<u32>>, ) -> Result<()>

Apply profile updates using an immutable, independently derived rank decision for every profile author. Some(distance) retains the profile with that exact search rank; None removes an excluded profile.

pub fn build_unpublished_profile_index_repair_with_frozen_distances( &self, events: &[Event], decisions: &BTreeMap<String, Option<u32>>, ) -> Result<PreparedProfileIndexRepair>

Build a complete replacement profile-index pair without publishing either root file. Every input must be the retained kind-0 winner for a distinct author and must have an independently pinned eligible rank.

The returned blocks are force-synced before this function returns. Callers can therefore exhaustively validate both unpublished roots and durably record their own provenance intent before committing the pair.

pub fn commit_prepared_profile_index_repair( &self, prepared: &PreparedProfileIndexRepair, authority: ProfileIndexRepairAuthority, ) -> Result<ProfileIndexRepairCommitOutcome>

Atomically publish an exhaustively validated repair pair iff the currently published pair is still the exact pair observed during preparation. Interrupted low-level commits roll forward on open; an already-installed exact replacement is therefore an idempotent success.

pub fn authorize_prepared_profile_index_repair( &self, prepared: &PreparedProfileIndexRepair, validated_intent_bytes: &[u8], ) -> Result<ProfileIndexRepairAuthority>

Mint an opaque commit capability only when the durable high-level intent exists, is bound to this store, and names this exact root pair.

pub fn authorize_completed_profile_index_repair( &self, prepared: &PreparedProfileIndexRepair, validated_intent_bytes: &[u8], validated_receipt_bytes: &[u8], ) -> Result<ProfileIndexRepairAuthority>

Mint an opaque completion-recovery capability only when an exact intent-bound receipt exists but its completion witness does not.

pub fn commit_prepared_profile_index_repair_held( &self, prepared: &PreparedProfileIndexRepair, authority: ProfileIndexRepairAuthority, ) -> Result<ProfileIndexRepairPublicationGuard>

Publish an exact prepared pair and retain the exclusive root-pair lock until the returned guard is dropped. Recovery callers use this form to audit the installed roots and persist their receipt without a post-commit writer race.

pub fn commit_prepared_profile_index_repair_held_with<F>( &self, prepared: &PreparedProfileIndexRepair, before_commit: F, ) -> Result<ProfileIndexRepairPublicationGuard>

where F: FnOnce() -> Result<ProfileIndexRepairAuthority>,

As Self::commit_prepared_profile_index_repair_held, but run one durable high-level intent callback while the exclusive pair lock is held. The callback must return the opaque capability minted from that exact durable intent before privileged recovery or publication begins.

pub fn hold_completed_profile_index_repair( &self, prepared: &PreparedProfileIndexRepair, authority: ProfileIndexRepairAuthority, ) -> Result<ProfileIndexRepairPublicationGuard>

Hold the profile-root transaction after proving a previously completed repair still has its exact installed pair. Crash recovery uses this boundary to publish a missing completion witness without racing an ordinary writer after the final verification.

pub fn rebuild_profile_index_from_stored_events(&self) -> Result<usize>

pub async fn rebuild_profile_index_from_stored_events_async( &self, ) -> Result<usize>

pub fn rebuild_event_indexes_from_stored_events(&self) -> Result<(usize, usize)>

pub async fn rebuild_event_indexes_from_stored_events_async( &self, ) -> Result<(usize, usize)>

Trait Implementations

impl SocialGraphBackend for SocialGraphStore

fn stats(&self) -> Result<SocialGraphStats>

fn users_by_follow_distance(&self, distance: u32) -> Result<Vec<[u8; 32]>>

fn follow_distance(&self, pk_bytes: &[u8; 32]) -> Result<Option<u32>>

fn follow_list_created_at(&self, owner: &[u8; 32]) -> Result<Option<u64>>

fn followed_targets(&self, owner: &[u8; 32]) -> Result<UserSet>

fn is_overmuted_user(&self, user_pk: &[u8; 32], threshold: f64) -> Result<bool>

fn profile_search_root(&self) -> Result<Option<Cid>>

fn snapshot_chunks( &self, root: &[u8; 32], options: &BinaryBudget, ) -> Result<Vec<Bytes>>

fn ingest_event(&self, event: &Event) -> Result<()>

fn ingest_event_with_storage_class( &self, event: &Event, storage_class: EventStorageClass, ) -> Result<()>

fn ingest_events(&self, events: &[Event]) -> Result<()>

fn ingest_events_with_storage_class( &self, events: &[Event], storage_class: EventStorageClass, ) -> Result<()>

fn ingest_graph_events(&self, events: &[Event]) -> Result<()>

fn query_events(&self, filter: &Filter, limit: usize) -> Result<Vec<Event>>

impl SocialGraphBackend for SocialGraphStore

type Error = UpstreamGraphBackendError

fn get_root(&self) -> Result<String, Self::Error>

fn set_root(&mut self, root: &str) -> Result<(), Self::Error>

fn handle_event( &mut self, event: &GraphEvent, allow_unknown_authors: bool, overmute_threshold: f64, ) -> Result<(), Self::Error>

fn get_follow_distance(&self, user: &str) -> Result<u32, Self::Error>

fn is_following( &self, follower: &str, followed_user: &str, ) -> Result<bool, Self::Error>

fn get_followed_by_user(&self, user: &str) -> Result<Vec<String>, Self::Error>

fn get_followers_by_user(&self, user: &str) -> Result<Vec<String>, Self::Error>

fn get_muted_by_user(&self, user: &str) -> Result<Vec<String>, Self::Error>

fn get_user_muted_by(&self, user: &str) -> Result<Vec<String>, Self::Error>

fn get_follow_list_created_at( &self, user: &str, ) -> Result<Option<u64>, Self::Error>

fn get_mute_list_created_at( &self, user: &str, ) -> Result<Option<u64>, Self::Error>

fn is_overmuted(&self, user: &str, threshold: f64) -> Result<bool, Self::Error>

fn flush(&mut self) -> Result<(), Self::Error>

fn has_unflushed_changes(&self) -> bool