chore: bind user metadata to per-view directories (#31)

Reviewed-on: #31

crates/signed_state/src/bootstrap.rs

@@ -46,7 +46,7 @@ pub(crate) async fn subscribe_bootstrap_only(
     Ok(())
 }
 
-pub(crate) async fn sync_bootstrap_only(
+pub async fn sync_bootstrap_only(
     client: &Client,
     filter: Filter,
     opts: SyncOptions,

crates/signed_state/src/lib.rs

@@ -5,7 +5,6 @@ mod git_store;
 mod inbox;
 mod local_repos;
 mod patch_series;
-mod profile;
 mod push;
 mod refresh;
 mod repo;
@@ -16,14 +15,13 @@ mod sync_status;
 use std::path::{Path, PathBuf};
 
 pub use backend::{Backend, BackendEvent};
-pub use bootstrap::user_grasp_list_servers;
+pub use bootstrap::{sync_bootstrap_only, user_grasp_list_servers};
 pub use checkouts::{CheckoutStatus, CheckoutsStore};
 pub use git_store::Mirrors;
 use gpui::{App, AppContext};
 pub use inbox::Inbox;
 pub use local_repos::{LocalReposStore, ResolvedLocalRepo};
 pub use nostr_sdk::prelude::Timestamp;
-pub use profile::{Profile, ProfileStore};
 pub use push::{GraspServer, PushOutcome};
 pub use refresh::{RefreshGate, RefreshRequest};
 pub use repo::RepoStore;
@@ -51,7 +49,6 @@ pub fn init(
     Mirrors::install(repos_root);
 
     Backend::set_global(cx.new(|cx| Backend::new(client, signer, cx)), cx);
-    ProfileStore::set_global(cx.new(ProfileStore::new), cx);
     RepoListStore::set_global(cx.new(RepoListStore::new), cx);
     LocalReposStore::set_global(cx.new(|cx| LocalReposStore::new(scan_paths, cx)), cx);
     CheckoutsStore::set_global(cx.new(CheckoutsStore::new), cx);

crates/signed_state/src/profile.rs

@@ -1,287 +0,0 @@
-use std::cell::RefCell;
-use std::collections::{HashMap, HashSet};
-use std::time::{Duration, Instant};
-
-use anyhow::Error;
-use flume::{Receiver, Sender};
-use gpui::{
-    App, AppContext, AsyncApp, Context, Entity, Global, SharedString, Subscription, WeakEntity,
-};
-use nostr_sdk::prelude::*;
-use utils::shorten_pubkey;
-
-use crate::backend::{Backend, BackendEvent};
-use crate::bootstrap::sync_bootstrap_only;
-
-const BATCH_TIMEOUT: Duration = Duration::from_millis(500);
-const REQUEST_CHUNK: usize = 100;
-const WARM_LIMIT: usize = 500;
-
-#[derive(Debug, Clone)]
-pub struct Profile {
-    public_key: PublicKey,
-    metadata: Metadata,
-}
-
-impl Profile {
-    pub fn new(public_key: PublicKey, metadata: Metadata) -> Self {
-        Self {
-            public_key,
-            metadata,
-        }
-    }
-
-    pub fn public_key(&self) -> PublicKey {
-        self.public_key
-    }
-
-    pub fn metadata(&self) -> &Metadata {
-        &self.metadata
-    }
-
-    // Falls back to `name`, then a shortened npub.
-    pub fn name(&self) -> SharedString {
-        if let Some(display_name) = self.metadata.display_name.as_ref()
-            && !display_name.is_empty()
-        {
-            return SharedString::from(display_name.trim().to_owned());
-        }
-
-        if let Some(name) = self.metadata.name.as_ref()
-            && !name.is_empty()
-        {
-            return SharedString::from(name.trim().to_owned());
-        }
-
-        SharedString::from(shorten_pubkey(self.public_key))
-    }
-
-    pub fn picture(&self) -> Option<SharedString> {
-        self.metadata
-            .picture
-            .as_ref()
-            .filter(|p| !p.is_empty())
-            .map(|p| SharedString::from(p.clone()))
-    }
-}
-
-pub struct ProfileStore {
-    profiles: HashMap<PublicKey, Profile>,
-    seen: RefCell<HashSet<PublicKey>>,
-    sender: Sender<PublicKey>,
-    _subscription: Subscription,
-}
-
-struct GlobalProfileStore(Entity<ProfileStore>);
-
-impl Global for GlobalProfileStore {}
-
-impl ProfileStore {
-    pub fn global(cx: &App) -> Entity<Self> {
-        cx.global::<GlobalProfileStore>().0.clone()
-    }
-
-    pub(crate) fn set_global(entity: Entity<Self>, cx: &mut App) {
-        cx.set_global(GlobalProfileStore(entity));
-    }
-
-    pub(crate) fn new(cx: &mut Context<Self>) -> Self {
-        let backend = Backend::global(cx);
-        let entity = cx.entity().downgrade();
-        let client = backend.read(cx).client();
-
-        let (sender, receiver) = flume::unbounded::<PublicKey>();
-
-        let subscription = cx.subscribe(&backend, |this, _backend, event, cx| {
-            if let BackendEvent::ProfileUpdates(authors) = event {
-                this.apply_authors(authors.clone(), cx);
-            }
-        });
-
-        cx.spawn(async move |this, cx| {
-            if let Err(e) = Self::handle_requests(this, &client, &receiver, cx).await {
-                log::error!("Failed to handle requests: {e}");
-            }
-        })
-        .detach();
-
-        cx.defer(move |cx| {
-            entity.update(cx, |this, cx| this.load(cx)).ok();
-        });
-
-        Self {
-            profiles: HashMap::new(),
-            seen: RefCell::new(HashSet::new()),
-            sender,
-            _subscription: subscription,
-        }
-    }
-
-    // Returns a placeholder until fetched; queues a fetch when uncached.
-    pub fn get(&self, public_key: &PublicKey) -> Profile {
-        if let Some(profile) = self.profiles.get(public_key) {
-            return profile.clone();
-        }
-
-        let public_key = *public_key;
-
-        if self.seen.borrow_mut().insert(public_key)
-            && let Err(e) = self.sender.send(public_key)
-        {
-            log::warn!("failed to queue profile fetch: {e}");
-        }
-
-        Profile::new(public_key, Metadata::default())
-    }
-
-    fn load(&mut self, cx: &mut Context<Self>) {
-        let backend = Backend::global(cx);
-        let client = backend.read(cx).client();
-
-        let work = cx.background_spawn(async move {
-            let filter = Filter::new().kind(Kind::Metadata).limit(WARM_LIMIT);
-            let events = client.database().query(filter).await?;
-
-            let profiles: Vec<Profile> = events
-                .into_iter()
-                .map(|event| {
-                    let metadata = Metadata::from_json(&event.content).unwrap_or_default();
-                    Profile::new(event.pubkey, metadata)
-                })
-                .collect();
-
-            Ok::<_, Error>(profiles)
-        });
-
-        cx.spawn(async move |this, cx| {
-            let profiles = work.await?;
-
-            this.update(cx, |this, cx| {
-                for profile in profiles {
-                    this.profiles.insert(profile.public_key(), profile);
-                }
-                cx.notify();
-            })?;
-
-            Ok::<_, Error>(())
-        })
-        .detach();
-    }
-
-    fn apply_authors(&mut self, authors: Vec<PublicKey>, cx: &mut Context<Self>) {
-        if authors.is_empty() {
-            return;
-        }
-
-        let backend = Backend::global(cx);
-        let client = backend.read(cx).client();
-
-        let work = cx.background_spawn(async move {
-            let filter = Filter::new().kind(Kind::Metadata).authors(authors);
-            let events = client.database().query(filter).await?;
-            // Pick the latest metadata per author off the main thread.
-            let mut latest: HashMap<PublicKey, (Timestamp, Metadata)> = HashMap::new();
-
-            for event in events {
-                match latest.get(&event.pubkey) {
-                    Some((ts, _)) if *ts >= event.created_at => {}
-                    _ => {
-                        latest.insert(
-                            event.pubkey,
-                            (
-                                event.created_at,
-                                Metadata::from_json(&event.content).unwrap_or_default(),
-                            ),
-                        );
-                    }
-                }
-            }
-
-            let profiles: Vec<Profile> = latest
-                .into_iter()
-                .map(|(public_key, (_, metadata))| Profile::new(public_key, metadata))
-                .collect();
-
-            Ok::<_, Error>(profiles)
-        });
-
-        cx.spawn(async move |this, cx| {
-            let profiles = work.await?;
-
-            this.update(cx, |this, cx| {
-                for profile in profiles {
-                    this.profiles.insert(profile.public_key(), profile);
-                }
-                cx.notify();
-            })?;
-
-            Ok::<_, Error>(())
-        })
-        .detach();
-    }
-
-    fn apply_seen(&mut self, cx: &mut Context<Self>) {
-        let authors: Vec<PublicKey> = self.seen.borrow().iter().copied().collect();
-        self.apply_authors(authors, cx);
-    }
-
-    async fn handle_requests(
-        this: WeakEntity<ProfileStore>,
-        client: &Client,
-        receiver: &Receiver<PublicKey>,
-        cx: &mut AsyncApp,
-    ) -> Result<(), Error> {
-        let mut batch: HashSet<PublicKey> = HashSet::new();
-
-        loop {
-            match receiver.recv_async().await {
-                Ok(public_key) => {
-                    batch.insert(public_key);
-                }
-                Err(_) => return Ok(()),
-            }
-
-            // The channel has no async timeout, race the receive against a timer.
-            let deadline = Instant::now() + BATCH_TIMEOUT;
-
-            loop {
-                let now = Instant::now();
-
-                if now >= deadline {
-                    break;
-                }
-
-                let timer = cx.background_executor().timer(deadline - now);
-                futures::pin_mut!(timer);
-
-                let recv = receiver.recv_async();
-                futures::pin_mut!(recv);
-
-                match futures::future::select(recv, timer).await {
-                    futures::future::Either::Left((Ok(public_key), _)) => {
-                        batch.insert(public_key);
-                    }
-                    futures::future::Either::Left((Err(_), _)) => return Ok(()),
-                    futures::future::Either::Right(_) => break,
-                }
-            }
-
-            let authors: Vec<PublicKey> = batch.drain().collect();
-
-            for chunk in authors.chunks(REQUEST_CHUNK) {
-                let opts = SyncOptions::default();
-                let filter = Filter::new()
-                    .kind(Kind::Metadata)
-                    .authors(chunk.iter().copied());
-
-                if let Err(e) = sync_bootstrap_only(client, filter, opts).await {
-                    log::warn!("profile fetch failed: {e}");
-                }
-            }
-
-            if this.update(cx, |this, cx| this.apply_seen(cx)).is_err() {
-                return Ok(());
-            }
-        }
-    }
-}