Struct Repo 

pub struct Repo<'a> { /* private fields */ }

A dispatcher bound to one request’s state.

Implementations

impl Repo<'_>

pub async fn has_session(&self, did: &str) -> Result<bool>

Whether did has a session this backend could actually use.

A precondition check, not a repo operation — deliberately NOT wrapped in timed(). The background flusher calls this every round for every DID holding dirty read-state; counting it would re-inflate the very flush_read_states error count this exists to stop polluting (#117).

Existence only: no decrypt, no staleness check, no refresh. A session that is present but expired still counts as usable here, because the refresh path is exactly what session() will do about it. The question being answered is narrower — is there anything at all to work with, or is this DID parked until the user signs in again?

The sidecar arm answers true unconditionally, preserving today’s behaviour on that backend rather than guessing. The sidecar owns its own session store and answering honestly would mean a loopback round trip per DID per minute; prod runs rust, and that arm is deleted by #18.

impl Repo<'_>

pub async fn list_subscriptions_sorted( &self, did: &str, ) -> Result<Vec<(String, Subscription)>>

The reader’s feed list, in display order.

pub async fn add_subscription( &self, did: &str, sub: &Subscription, ) -> Result<String>

Subscribe. Returns the new record’s rkey.

Vets the record first — see [vet].

pub async fn remove_subscription(&self, did: &str, rkey: &str) -> Result<()>

Unsubscribe by rkey.

pub async fn update_subscription( &self, did: &str, rkey: &str, sub: &Subscription, ) -> Result<WriteResult>

Rename or re-folder a subscription.

Vets the record first — see [vet].

pub async fn add_subscriptions_bulk( &self, did: &str, subs: &[Subscription], ) -> Result<Vec<String>>

OPML import — one applyWrites for the whole batch.

Vets every record first — see [vet]. An import is the path where the URLs are least trustworthy: the file is arbitrary, and 200 of them arrive at once with nobody reading each line.

pub async fn list_folders_sorted( &self, did: &str, ) -> Result<Vec<(String, Folder)>>

Folders in display order.

pub async fn add_folder(&self, did: &str, folder: &Folder) -> Result<String>

Create a folder. Returns its rkey.

pub async fn rename_folder( &self, did: &str, rkey: &str, folder: &Folder, ) -> Result<WriteResult>

Rename a folder in place.

pub async fn remove_folder(&self, did: &str, rkey: &str) -> Result<()>

Delete a folder.

pub async fn list_saved_sorted(&self, did: &str) -> Result<Vec<(String, Saved)>>

Saved items, newest first.

pub async fn add_saved(&self, did: &str, saved: &Saved) -> Result<String>

Save an entry. Returns its rkey.

Refuses rather than publishing a URL we would not render. url is required on this record, so unlike a subscription’s siteUrl there is no honest resting place for a rejected value — see crate::vetted::VettedSaved. The only caller already treats a failed PDS write as recoverable: it logs and keeps the entry starred locally, so the reader loses nothing but the hostile record.

pub async fn list_saved(&self, did: &str) -> Result<Vec<(String, Saved)>>

Saved items in PDS order — the un-star path, which matches by URL and does not care about display order.

pub async fn remove_saved(&self, did: &str, rkey: &str) -> Result<()>

Unsave by rkey.

pub async fn list_read_states( &self, did: &str, ) -> Result<Vec<(String, ReadState)>>

Every read cursor.

pub async fn flush_read_states( &self, did: &str, cursors: &[(String, ReadState, bool)], ) -> Result<()>

Flush dirty cursors in one applyWrites — the hottest write path.