.

crates/chat/src/lib.rs

@@ -146,15 +146,15 @@ impl ChatRegistry {
                             })
                             .ok();
                         }
-                        NostrEvent::Eose => {
+                        NostrEvent::Unwrapping(status) => {
                             this.update(cx, |this, cx| {
+                                this.set_loading(status, cx);
                                 this.get_rooms(cx);
                             })
                             .ok();
                         }
-                        NostrEvent::Unwrapping(status) => {
+                        NostrEvent::Eose => {
                             this.update(cx, |this, cx| {
-                                this.set_loading(status, cx);
                                 this.get_rooms(cx);
                             })
                             .ok();
@@ -310,10 +310,24 @@ impl ChatRegistry {
     /// Add a new room to the start of list.
     pub fn add_room<I>(&mut self, room: I, cx: &mut Context<Self>)
     where
-        I: Into<Room>,
+        I: Into<Room> + 'static,
     {
-        self.rooms.insert(0, cx.new(|_| room.into()));
-        cx.notify();
+        let nostr = NostrRegistry::global(cx);
+        let client = nostr.read(cx).client();
+
+        self.tasks.push(cx.spawn(async move |this, cx| {
+            if let Some(signer) = client.signer() {
+                if let Ok(public_key) = signer.get_public_key().await {
+                    this.update(cx, |this, cx| {
+                        this.rooms
+                            .insert(0, cx.new(|_| room.into().organize(&public_key)));
+                        cx.emit(ChatEvent::Ping);
+                        cx.notify();
+                    })
+                    .ok();
+                }
+            }
+        }));
     }
 
     /// Emit an open room event.
@@ -407,23 +421,20 @@ impl ChatRegistry {
     pub fn get_rooms(&mut self, cx: &mut Context<Self>) {
         let task = self.get_rooms_from_database(cx);
 
-        self.tasks.push(
-            // Run and finished in the background
-            cx.spawn(async move |this, cx| {
-                match task.await {
-                    Ok(rooms) => {
-                        this.update(cx, move |this, cx| {
-                            this.extend_rooms(rooms, cx);
-                            this.sort(cx);
-                        })
-                        .ok();
-                    }
-                    Err(e) => {
-                        log::error!("Failed to load rooms: {e}")
-                    }
-                };
-            }),
-        );
+        self.tasks.push(cx.spawn(async move |this, cx| {
+            match task.await {
+                Ok(rooms) => {
+                    this.update(cx, move |this, cx| {
+                        this.extend_rooms(rooms, cx);
+                        this.sort(cx);
+                    })
+                    .ok();
+                }
+                Err(e) => {
+                    log::error!("Failed to load rooms: {e}")
+                }
+            };
+        }));
     }
 
     /// Create a task to load rooms from the database
@@ -434,8 +445,11 @@ impl ChatRegistry {
         cx.background_spawn(async move {
             let signer = client.signer().context("Signer not found")?;
             let public_key = signer.get_public_key().await?;
+
+            // Get contacts
             let contacts = client.database().contacts_public_keys(public_key).await?;
 
+            // Construct authored filter
             let authored_filter = Filter::new()
                 .kind(Kind::ApplicationSpecificData)
                 .custom_tag(SingleLetterTag::lowercase(Alphabet::A), public_key);
@@ -443,6 +457,7 @@ impl ChatRegistry {
             // Get all authored events
             let authored = client.database().query(authored_filter).await?;
 
+            // Construct addressed filter
             let addressed_filter = Filter::new()
                 .kind(Kind::ApplicationSpecificData)
                 .custom_tag(SingleLetterTag::lowercase(Alphabet::P), public_key);
@@ -453,6 +468,7 @@ impl ChatRegistry {
             // Merge authored and addressed events
             let events = authored.merge(addressed);
 
+            // Collect results
             let mut rooms: HashSet<Room> = HashSet::new();
             let mut grouped: HashMap<u64, Vec<UnsignedEvent>> = HashMap::new();
 
@@ -468,24 +484,21 @@ impl ChatRegistry {
             for (_id, mut messages) in grouped.into_iter() {
                 messages.sort_by_key(|m| Reverse(m.created_at));
 
+                // Always use the latest message
                 let Some(latest) = messages.first() else {
                     continue;
                 };
 
-                let mut room = Room::from(latest);
-
-                if rooms.iter().any(|r| r.id == room.id) {
-                    continue;
-                }
-
-                let mut public_keys = room.members();
-                public_keys.retain(|pk| pk != &public_key);
+                // Construct the room from the latest message.
+                //
+                // Call `.organize` to ensure the current user is at the end of the list.
+                let mut room = Room::from(latest).organize(&public_key);
 
                 // Check if the user has responded to the room
                 let user_sent = messages.iter().any(|m| m.pubkey == public_key);
 
                 // Check if public keys are from the user's contacts
-                let is_contact = public_keys.iter().any(|k| contacts.contains(k));
+                let is_contact = room.members.iter().any(|k| contacts.contains(k));
 
                 // Set the room's kind based on status
                 if user_sent || is_contact {
@@ -499,6 +512,24 @@ impl ChatRegistry {
         })
     }
 
+    /// Parse a nostr event into a message and push it to the belonging room
+    ///
+    /// If the room doesn't exist, it will be created.
+    /// Updates room ordering based on the most recent messages.
+    pub fn new_message(&mut self, message: NewMessage, cx: &mut Context<Self>) {
+        match self.rooms.iter().find(|e| e.read(cx).id == message.room) {
+            Some(room) => {
+                room.update(cx, |this, cx| {
+                    this.push_message(message, cx);
+                });
+            }
+            None => {
+                // Push the new room to the front of the list
+                self.add_room(message.rumor, cx);
+            }
+        }
+    }
+
     /// Trigger a refresh of the opened chat rooms by their IDs
     pub fn refresh_rooms(&mut self, ids: Option<Vec<u64>>, cx: &mut Context<Self>) {
         if let Some(ids) = ids {
@@ -512,53 +543,6 @@ impl ChatRegistry {
         }
     }
 
-    /// Parse a nostr event into a message and push it to the belonging room
-    ///
-    /// If the room doesn't exist, it will be created.
-    /// Updates room ordering based on the most recent messages.
-    pub fn new_message(&mut self, message: NewMessage, cx: &mut Context<Self>) {
-        let nostr = NostrRegistry::global(cx);
-        // Get the unique id
-        let id = message.rumor.uniq_id();
-        // Get the author
-        let author = message.rumor.pubkey;
-
-        match self.rooms.iter().find(|room| room.read(cx).id == id) {
-            Some(room) => {
-                let new_message = message.rumor.created_at > room.read(cx).created_at;
-                let created_at = message.rumor.created_at;
-
-                // Update room
-                room.update(cx, |this, cx| {
-                    // Update the last timestamp if the new message is newer
-                    if new_message {
-                        this.set_created_at(created_at, cx);
-                    }
-
-                    // Set this room is ongoing if the new message is from current user
-                    // if author == nostr.read(cx).identity().read(cx).public_key() {
-                    //     this.set_ongoing(cx);
-                    // }
-
-                    // Emit the new message to the room
-                    this.emit_message(message, cx);
-                });
-
-                // Resort all rooms in the registry by their created at (after updated)
-                if new_message {
-                    self.sort(cx);
-                }
-            }
-            None => {
-                // Push the new room to the front of the list
-                self.add_room(&message.rumor, cx);
-
-                // Notify the UI about the new room
-                cx.emit(ChatEvent::Ping);
-            }
-        }
-    }
-
     /// Unwraps a gift-wrapped event and processes its contents.
     async fn extract_rumor(
         client: &Client,

crates/chat/src/message.rs

@@ -1,17 +1,25 @@
 use std::hash::Hash;
 
+use common::EventUtils;
 use nostr_sdk::prelude::*;
 
 /// New message.
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub struct NewMessage {
     pub gift_wrap: EventId,
+    pub room: u64,
     pub rumor: UnsignedEvent,
 }
 
 impl NewMessage {
     pub fn new(gift_wrap: EventId, rumor: UnsignedEvent) -> Self {
-        Self { gift_wrap, rumor }
+        let room = rumor.uniq_id();
+
+        Self {
+            gift_wrap,
+            room,
+            rumor,
+        }
     }
 }
 

crates/chat/src/room.rs

@@ -11,7 +11,7 @@ use nostr_sdk::prelude::*;
 use person::{Person, PersonRegistry};
 use state::{tracker, NostrRegistry};
 
-use crate::NewMessage;
+use crate::{ChatRegistry, NewMessage};
 
 const SEND_RETRY: usize = 10;
 
@@ -99,16 +99,20 @@ pub enum RoomKind {
     Ongoing,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Room {
     /// Conversation ID
     pub id: u64,
+
     /// The timestamp of the last message in the room
     pub created_at: Timestamp,
+
     /// Subject of the room
     pub subject: Option<SharedString>,
+
     /// All members of the room
-    pub members: Vec<PublicKey>,
+    pub(super) members: Vec<PublicKey>,
+
     /// Kind
     pub kind: RoomKind,
 }
@@ -145,11 +149,7 @@ impl From<&UnsignedEvent> for Room {
     fn from(val: &UnsignedEvent) -> Self {
         let id = val.uniq_id();
         let created_at = val.created_at;
-
-        // Get the members from the event's tags and event's pubkey
         let members = val.extract_public_keys();
-
-        // Get subject from tags
         let subject = val
             .tags
             .find(TagKind::Subject)
@@ -165,6 +165,12 @@ impl From<&UnsignedEvent> for Room {
     }
 }
 
+impl From<UnsignedEvent> for Room {
+    fn from(val: UnsignedEvent) -> Self {
+        Room::from(&val)
+    }
+}
+
 impl Room {
     /// Constructs a new room with the given receiver and tags.
     pub fn new<T>(author: PublicKey, receivers: T) -> Self
@@ -172,16 +178,30 @@ impl Room {
         T: IntoIterator<Item = PublicKey>,
     {
         let tags = Tags::from_list(receivers.into_iter().map(Tag::public_key).collect());
+        // Construct an unsigned event for a direct message
+        //
+        // WARNING: never sign this event
         let mut event = EventBuilder::new(Kind::PrivateDirectMessage, "")
             .tags(tags)
             .build(author);
 
-        // Generate event ID
+        // Ensure that the ID is set
         event.ensure_id();
 
         Room::from(&event)
     }
 
+    /// Organizes the members of the room by moving the target member to the end.
+    ///
+    /// Always call this function to ensure the current user is at the end of the list.
+    pub fn organize(mut self, target: &PublicKey) -> Self {
+        if let Some(index) = self.members.iter().position(|member| member == target) {
+            let member = self.members.remove(index);
+            self.members.push(member);
+        }
+        self
+    }
+
     /// Sets the kind of the room and returns the modified room
     pub fn kind(mut self, kind: RoomKind) -> Self {
         self.kind = kind;
@@ -275,9 +295,21 @@ impl Room {
         }
     }
 
-    /// Emits a new message signal to the current room
-    pub fn emit_message(&self, message: NewMessage, cx: &mut Context<Self>) {
+    /// Push a new message to the current room
+    pub fn push_message(&mut self, message: NewMessage, cx: &mut Context<Self>) {
+        let created_at = message.rumor.created_at;
+        let new_message = created_at > self.created_at;
+
+        // Emit the incoming message event
         cx.emit(RoomEvent::Incoming(message));
+
+        if new_message {
+            self.set_created_at(created_at, cx);
+            // Sort chats after emitting a new message
+            ChatRegistry::global(cx).update(cx, |this, cx| {
+                this.sort(cx);
+            });
+        }
     }
 
     /// Emits a signal to reload the current room's messages.