refactor auth

crates/relay_auth/src/lib.rs

@@ -63,14 +63,11 @@ impl Global for GlobalRelayAuth {}
 // Relay authentication
 #[derive(Debug)]
 pub struct RelayAuth {
-    /// Entity for managing auth requests
+    /// Tasks for asynchronous operations
-    requests: HashSet<Arc<AuthRequest>>,
+    tasks: SmallVec<[Task<()>; 2]>,
 
     /// Event subscriptions
     _subscriptions: SmallVec<[Subscription; 1]>,
-
-    /// Tasks for asynchronous operations
-    _tasks: SmallVec<[Task<()>; 1]>,
 }
 
 impl RelayAuth {
@@ -87,50 +84,27 @@ impl RelayAuth {
     /// Create a new relay auth instance
     fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
         let nostr = NostrRegistry::global(cx);
-        let client = nostr.read(cx).client();
-
-        // Get the current entity
-        let entity = cx.entity();
-
         // Channel for communication between nostr and gpui
-        let (tx, rx) = flume::bounded::<AuthRequest>(100);
+        let (tx, rx) = flume::bounded::<Arc<AuthRequest>>(100);
 
         let mut subscriptions = smallvec![];
         let mut tasks = smallvec![];
 
         subscriptions.push(
             // Observe the current state
-            cx.observe_in(&entity, window, |this, _state, window, cx| {
+            cx.observe(&nostr, move |this, state, cx| {
-                let settings = AppSettings::global(cx);
+                if state.read(cx).connected() {
-                let mode = AppSettings::get_auth_mode(cx);
+                    this.handle_notifications(tx.clone(), cx)
-
-                for req in this.requests.iter() {
-                    let trusted_relay = settings.read(cx).trusted_relay(req.url(), cx);
-
-                    if trusted_relay && mode == AuthMode::Auto {
-                        // Automatically authenticate if the relay is authenticated before
-                        this.response(req, window, cx);
-                    } else {
-                        // Otherwise open the auth request popup
-                        this.ask_for_approval(req, window, cx);
                 }
-                }
-            }),
-        );
-
-        tasks.push(
-            // Handle nostr notifications
-            cx.background_spawn(async move {
-                Self::handle_notifications(&client, &tx).await;
             }),
         );
 
         tasks.push(
             // Update GPUI states
-            cx.spawn(async move |this, cx| {
+            cx.spawn_in(window, async move |this, cx| {
-                while let Ok(request) = rx.recv_async().await {
+                while let Ok(req) = rx.recv_async().await {
-                    this.update(cx, |this, cx| {
+                    this.update_in(cx, |this, window, cx| {
-                        this.add_request(request, cx);
+                        this.handle_auth(&req, window, cx);
                     })
                     .ok();
                 }
@@ -138,14 +112,21 @@ impl RelayAuth {
         );
 
         Self {
-            requests: HashSet::new(),
+            tasks,
             _subscriptions: subscriptions,
-            _tasks: tasks,
         }
     }
 
     // Handle nostr notifications
-    async fn handle_notifications(client: &Client, tx: &flume::Sender<AuthRequest>) {
+    fn handle_notifications(
+        &mut self,
+        tx: flume::Sender<Arc<AuthRequest>>,
+        cx: &mut Context<Self>,
+    ) {
+        let nostr = NostrRegistry::global(cx);
+        let client = nostr.read(cx).client();
+
+        let task = cx.background_spawn(async move {
             let mut notifications = client.notifications();
             let mut challenges: HashSet<Cow<'_, str>> = HashSet::default();
 
@@ -156,7 +137,7 @@ impl RelayAuth {
                             RelayMessage::Auth { challenge } => {
                                 if challenges.insert(challenge.clone()) {
                                     let request = AuthRequest::new(challenge, relay_url);
-                                tx.send_async(request).await.ok();
+                                    tx.send_async(Arc::new(request)).await.ok();
                                 }
                             }
                             RelayMessage::Ok {
@@ -181,23 +162,22 @@ impl RelayAuth {
                     _ => {}
                 }
             }
+        });
+
+        self.tasks.push(task);
     }
 
-    /// Add a new authentication request.
+    fn handle_auth(&mut self, req: &Arc<AuthRequest>, window: &mut Window, cx: &mut Context<Self>) {
-    fn add_request(&mut self, request: AuthRequest, cx: &mut Context<Self>) {
+        let settings = AppSettings::global(cx);
-        self.requests.insert(Arc::new(request));
+        let trusted_relay = settings.read(cx).trusted_relay(req.url(), cx);
-        cx.notify();
+        let mode = AppSettings::get_auth_mode(cx);
-    }
 
-    /// Get the number of pending requests.
+        if trusted_relay && mode == AuthMode::Auto {
-    pub fn pending_requests(&self, _cx: &App) -> usize {
+            // Automatically authenticate if the relay is authenticated before
-        self.requests.len()
+            self.response(req, window, cx);
-    }
+        } else {
-
+            // Otherwise open the auth request popup
-    /// Reask for approval for all pending requests.
+            self.ask_for_approval(req, window, cx);
-    pub fn re_ask(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        for request in self.requests.iter() {
-            self.ask_for_approval(request, window, cx);
         }
     }
 
@@ -268,20 +248,17 @@ impl RelayAuth {
             let result = task.await;
             let url = req.url();
 
-            this.update_in(cx, |this, window, cx| {
+            this.update_in(cx, |_this, window, cx| {
+                window.clear_notification(challenge, cx);
+
                 match result {
                     Ok(_) => {
-                        window.clear_notification(challenge, cx);
-                        window.push_notification(format!("{} has been authenticated", url), cx);
-
                         // Save the authenticated relay to automatically authenticate future requests
                         settings.update(cx, |this, cx| {
                             this.add_trusted_relay(url, cx);
                         });
 
-                        // Remove the challenge from the list of pending authentications
+                        window.push_notification(format!("{} has been authenticated", url), cx);
-                        this.requests.remove(&req);
-                        cx.notify();
                     }
                     Err(e) => {
                         window.push_notification(Notification::error(e.to_string()), cx);

crates/settings/src/lib.rs

@@ -118,10 +118,7 @@ pub struct AppSettings {
     values: Settings,
 
     /// Event subscriptions
-    _subscriptions: SmallVec<[Subscription; 1]>,
+    _subscriptions: SmallVec<[Subscription; 2]>,
-
-    /// Background tasks
-    tasks: SmallVec<[Task<Result<(), Error>>; 1]>,
 }
 
 impl AppSettings {
@@ -136,9 +133,7 @@ impl AppSettings {
     }
 
     fn new(cx: &mut Context<Self>) -> Self {
-        let load_settings = Self::get_from_database(cx);
+        let nostr = NostrRegistry::global(cx);
-
-        let mut tasks = smallvec![];
         let mut subscriptions = smallvec![];
 
         subscriptions.push(
@@ -148,24 +143,15 @@ impl AppSettings {
             }),
         );
 
-        tasks.push(
+        subscriptions.push(
-            // Load the initial settings
+            // Observe and automatically save settings on changes
-            cx.spawn(async move |this, cx| {
+            cx.observe(&nostr, |this, _state, cx| {
-                let settings = load_settings.await.unwrap_or(Settings::default());
+                this.load(cx);
-                log::info!("Settings: {settings:?}");
-
-                // Update the settings state
-                this.update(cx, |this, cx| {
-                    this.set_settings(settings, cx);
-                })?;
-
-                Ok(())
             }),
         );
 
         Self {
             values: Settings::default(),
-            tasks,
             _subscriptions: subscriptions,
         }
     }
@@ -176,50 +162,38 @@ impl AppSettings {
         cx.notify();
     }
 
-    /// Get settings from the database
+    /// Load settings
-    fn get_from_database(cx: &App) -> Task<Result<Settings, Error>> {
+    fn load(&mut self, cx: &mut Context<Self>) {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
 
-        cx.background_spawn(async move {
+        let task: Task<Result<Settings, Error>> = cx.background_spawn(async move {
-            // Construct a filter to get the latest settings
+            let signer = client.signer().context("Signer not found")?;
-            let mut filter = Filter::new()
+            let public_key = signer.get_public_key().await?;
+
+            let filter = Filter::new()
                 .kind(Kind::ApplicationSpecificData)
                 .identifier(SETTINGS_IDENTIFIER)
+                .author(public_key)
                 .limit(1);
 
-            // If the signer is available, get settings belonging to the current user
+            if let Some(event) = client.database().query(filter).await?.last_owned() {
-            if let Some(signer) = client.signer() {
-                if let Ok(public_key) = signer.get_public_key().await {
-                    // Push author to the filter
-                    filter = filter.author(public_key);
-                }
-            }
-
-            if let Some(event) = client.database().query(filter).await?.first_owned() {
                 Ok(serde_json::from_str(&event.content)?)
             } else {
                 Err(anyhow!("Not found"))
             }
-        })
+        });
-    }
 
-    /// Load settings
-    pub fn load(&mut self, cx: &mut Context<Self>) {
-        let task = Self::get_from_database(cx);
-
-        self.tasks.push(
-            // Run task in the background
         cx.spawn(async move |this, cx| {
-                let settings = task.await?;
+            let settings = task.await.unwrap_or(Settings::default());
+
             // Update settings
             this.update(cx, |this, cx| {
                 this.set_settings(settings, cx);
-                })?;
+            })
-
+            .ok();
-                Ok(())
+        })
-            }),
+        .detach();
-        );
     }
 
     /// Save settings
@@ -228,7 +202,7 @@ impl AppSettings {
         let client = nostr.read(cx).client();
         let settings = self.values.clone();
 
-        self.tasks.push(cx.background_spawn(async move {
+        let task: Task<Result<(), Error>> = cx.background_spawn(async move {
             let signer = client.signer().context("Signer not found")?;
             let public_key = signer.get_public_key().await?;
             let content = serde_json::to_string(&settings)?;
@@ -243,7 +217,9 @@ impl AppSettings {
             client.database().save_event(&event).await?;
 
             Ok(())
-        }));
+        });
+
+        task.detach();
     }
 
     /// Check if the given relay is already authenticated