feat: implement messenger search

brenodt · brenodt · commit d63c6c54f915 · 2026-03-31T19:43:59.000-03:00
diff --git a/protobuf/generated/rust/qaul.rpc.chat.rs b/protobuf/generated/rust/qaul.rpc.chat.rs
@@ -3,7 +3,7 @@
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Chat {
     /// message type
-    #[prost(oneof = "chat::Message", tags = "3, 4, 5")]
+    #[prost(oneof = "chat::Message", tags = "3, 4, 5, 6, 7")]
     pub message: ::core::option::Option<chat::Message>,
 }
 /// Nested message and enum types in `Chat`.
@@ -20,6 +20,12 @@ pub mod chat {
         /// send a new chat message
         #[prost(message, tag = "5")]
         Send(super::ChatMessageSend),
+        /// search chat messages
+        #[prost(message, tag = "6")]
+        SearchRequest(super::ChatSearchRequest),
+        /// search results
+        #[prost(message, tag = "7")]
+        SearchResult(super::ChatSearchResult),
     }
 }
 /// request messages of a specific chat conversation
@@ -148,6 +154,42 @@ pub struct GroupEvent {
     #[prost(bytes = "vec", tag = "2")]
     pub user_id: ::prost::alloc::vec::Vec<u8>,
 }
+/// search chat messages request
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct ChatSearchRequest {
+    /// search query string
+    #[prost(string, tag = "1")]
+    pub query: ::prost::alloc::string::String,
+}
+/// search results
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ChatSearchResult {
+    /// the query that produced these results
+    #[prost(string, tag = "1")]
+    pub query: ::prost::alloc::string::String,
+    /// matching messages
+    #[prost(message, repeated, tag = "2")]
+    pub items: ::prost::alloc::vec::Vec<ChatSearchResultItem>,
+}
+/// a single search result item
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct ChatSearchResultItem {
+    /// message id
+    #[prost(bytes = "vec", tag = "1")]
+    pub message_id: ::prost::alloc::vec::Vec<u8>,
+    /// group id of the conversation
+    #[prost(bytes = "vec", tag = "2")]
+    pub group_id: ::prost::alloc::vec::Vec<u8>,
+    /// sender id
+    #[prost(bytes = "vec", tag = "3")]
+    pub sender_id: ::prost::alloc::vec::Vec<u8>,
+    /// message text content
+    #[prost(string, tag = "4")]
+    pub content: ::prost::alloc::string::String,
+    /// time when the message was sent
+    #[prost(uint64, tag = "5")]
+    pub sent_at: u64,
+}
 /// send chat message
 #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
 pub struct ChatMessageSend {
diff --git a/protobuf/proto_definitions/services/chat/chat.proto b/protobuf/proto_definitions/services/chat/chat.proto
@@ -12,6 +12,11 @@ message Chat {
 
         // send a new chat message
         ChatMessageSend send = 5;
+
+        // search chat messages
+        ChatSearchRequest search_request = 6;
+        // search results
+        ChatSearchResult search_result = 7;
     }
 }
 
@@ -155,6 +160,34 @@ enum GroupEventType {
     INVITE_ACCEPTED = 7;
 }
 
+// search chat messages request
+message ChatSearchRequest {
+    // search query string
+    string query = 1;
+}
+
+// search results
+message ChatSearchResult {
+    // the query that produced these results
+    string query = 1;
+    // matching messages
+    repeated ChatSearchResultItem items = 2;
+}
+
+// a single search result item
+message ChatSearchResultItem {
+    // message id
+    bytes message_id = 1;
+    // group id of the conversation
+    bytes group_id = 2;
+    // sender id
+    bytes sender_id = 3;
+    // message text content
+    string content = 4;
+    // time when the message was sent
+    uint64 sent_at = 5;
+}
+
 // send chat message
 message ChatMessageSend {
     // group id to which this message is sent
diff --git a/rust/clients/cli/README.md b/rust/clients/cli/README.md
@@ -72,6 +72,7 @@ The following commands are available:
 * chat
   * `chat send {Group ID} {Chat Message}` - sends the {Chat Message} to the user with the ID {Group ID}
   * `chat conversation {Group ID}` - displays all messages of the conversation with the ID {Group ID}
+  * `chat search {query}` - searches chat messages matching {query} across all conversations
 * chat files
   * `file send {Group ID} {File Path} {File Description}` - sends a file to the user with the ID {Group ID} and a {File Description} text.
   * `file history [{offset} {limit}]` - displays a paginated file history
diff --git a/rust/clients/cli/src/chat.rs b/rust/clients/cli/src/chat.rs
@@ -107,6 +107,15 @@ impl Chat {
                     }
                 }
             }
+            // search chat messages
+            cmd if cmd.starts_with("search ") => {
+                let query = cmd.strip_prefix("search ").unwrap().trim();
+                if query.is_empty() {
+                    log::error!("usage: chat search <query>");
+                    return;
+                }
+                Self::send_search_request(query.to_string());
+            }
             // unknown command
             _ => log::error!("unknown chat command"),
         }
@@ -182,6 +191,22 @@ impl Chat {
         Rpc::send_message(buf, super::rpc::proto::Modules::Chat.into(), "".to_string());
     }
 
+    /// Send a search request via rpc
+    fn send_search_request(query: String) {
+        let proto_message = proto::Chat {
+            message: Some(proto::chat::Message::SearchRequest(
+                proto::ChatSearchRequest { query },
+            )),
+        };
+
+        let mut buf = Vec::with_capacity(proto_message.encoded_len());
+        proto_message
+            .encode(&mut buf)
+            .expect("Vec<u8> provides capacity as needed");
+
+        Rpc::send_message(buf, super::rpc::proto::Modules::Chat.into(), "".to_string());
+    }
+
     fn analyze_content(content: &Vec<u8>) -> Result<Vec<String>, String> {
         let mut res: Vec<String> = vec![];
 
@@ -294,6 +319,31 @@ impl Chat {
                         }
                     }
 
+                    Some(proto::chat::Message::SearchResult(results)) => {
+                        println!("");
+                        println!("Search results for \"{}\":", results.query);
+                        println!("");
+                        if results.items.is_empty() {
+                            println!("  (no results)");
+                        } else {
+                            for item in results.items {
+                                let group_id_str = match uuid::Uuid::from_slice(&item.group_id) {
+                                    Ok(id) => id.to_string(),
+                                    Err(_) => bs58::encode(&item.group_id).into_string(),
+                                };
+                                println!(
+                                    "  [{}] group:{} from:{} at:{}",
+                                    bs58::encode(&item.message_id).into_string(),
+                                    group_id_str,
+                                    bs58::encode(&item.sender_id).into_string(),
+                                    item.sent_at,
+                                );
+                                println!("    {}", item.content);
+                                println!("");
+                            }
+                        }
+                    }
+
                     _ => {
                         log::error!("unprocessable RPC chat message");
                     }
diff --git a/rust/libqaul/src/search/mod.rs b/rust/libqaul/src/search/mod.rs
@@ -71,6 +71,10 @@ pub struct Search {
     // avoiding repeated string-based lookups into the schema.
     id_field: Field,
     content_field: Field,
+
+    // True if this index was freshly created (not opened from an existing directory).
+    // Callers use this to decide whether a batch backfill of existing data is needed.
+    is_fresh: bool,
 }
 
 impl Search {
@@ -94,9 +98,11 @@ impl Search {
         std::fs::create_dir_all(index_path)?;
 
         // create (or open, if existing) the Index for the corresponding Schema in the provided path
-        let index = match Index::create_in_dir(index_path, schema.clone()) {
-            Ok(index) => index,
-            Err(tantivy::TantivyError::IndexAlreadyExists) => Index::open_in_dir(index_path)?,
+        let (index, is_fresh) = match Index::create_in_dir(index_path, schema.clone()) {
+            Ok(index) => (index, true),
+            Err(tantivy::TantivyError::IndexAlreadyExists) => {
+                (Index::open_in_dir(index_path)?, false)
+            }
             Err(e) => return Err(e.into()),
         };
 
@@ -114,17 +120,25 @@ impl Search {
         //   "There must be only one writer at a time. This single IndexWriter is already multithreaded."
         //
         // That is why we keep it persistent per instance of Search, initializing it
-        // with a 50Mb memory_arena budget (also suggested by the docs).
-        let writer: IndexWriter = index.writer(50_000_000)?;
+        // with a 15Mb memory_arena budget (suitable for mobile).
+        let writer: IndexWriter = index.writer(15_000_000)?;
 
         Ok(Self {
             writer,
             reader,
             id_field,
             content_field,
+            is_fresh,
         })
     }
 
+    /// Returns `true` if this index was freshly created (not opened from an existing directory).
+    ///
+    /// Callers use this to decide whether a batch backfill of existing data is needed.
+    pub fn is_fresh(&self) -> bool {
+        self.is_fresh
+    }
+
     /// Stages a single document for indexing, deduplicating by ID.
     ///
     /// Note: this does NOT commit. Call `commit()` when you're ready
@@ -176,6 +190,7 @@ impl Search {
     ///
     /// Note: Unlike `index` and `index_many`, this commits on its own.
     /// It's NOT designed to be called inside a batch operation.
+    #[allow(dead_code)]
     pub fn remove(&mut self, id: &str) -> Result<(), SearchError> {
         self.delete_id(id);
         self.commit()?;
diff --git a/rust/libqaul/src/services/chat/mod.rs b/rust/libqaul/src/services/chat/mod.rs
@@ -10,13 +10,15 @@ use prost::Message;
 
 pub mod file;
 pub mod message;
+pub mod search;
 pub mod storage;
 
 use crate::connections::{internet::Internet, lan::Lan};
 use crate::node::user_accounts::UserAccounts;
 use crate::rpc::Rpc;
 pub use file::ChatFile;
 pub use message::ChatMessage;
+pub use search::ChatSearch;
 pub use storage::ChatStorage;
 
 /// Import protobuf message definition
@@ -33,6 +35,9 @@ impl Chat {
 
         // initialize the chat file management
         ChatFile::init();
+
+        // initialize the chat search indexes
+        ChatSearch::init();
     }
 
     /// Generate a Chat Message ID
@@ -127,6 +132,40 @@ impl Chat {
                             log::error!("Outgoing chat message error: {}", error)
                         }
                     }
+                    Some(rpc_proto::chat::Message::SearchRequest(search_request)) => {
+                        let results = ChatSearch::search(&account_id, &search_request.query);
+
+                        let items: Vec<rpc_proto::ChatSearchResultItem> = results
+                            .into_iter()
+                            .map(|r| rpc_proto::ChatSearchResultItem {
+                                message_id: r.message_id,
+                                group_id: r.group_id,
+                                sender_id: r.sender_id,
+                                content: r.content,
+                                sent_at: r.sent_at,
+                            })
+                            .collect();
+
+                        let proto_message = rpc_proto::Chat {
+                            message: Some(rpc_proto::chat::Message::SearchResult(
+                                rpc_proto::ChatSearchResult {
+                                    query: search_request.query,
+                                    items,
+                                },
+                            )),
+                        };
+
+                        let mut buf = Vec::with_capacity(proto_message.encoded_len());
+                        proto_message
+                            .encode(&mut buf)
+                            .expect("Vec<u8> provides capacity as needed");
+                        Rpc::send_message(
+                            buf,
+                            crate::rpc::proto::Modules::Chat.into(),
+                            request_id,
+                            Vec::new(),
+                        );
+                    }
                     _ => {
                         log::error!("Unhandled Protobuf Chat Message");
                     }
diff --git a/rust/libqaul/src/services/chat/search.rs b/rust/libqaul/src/services/chat/search.rs
diff --git a/rust/libqaul/src/services/chat/storage.rs b/rust/libqaul/src/services/chat/storage.rs
