Add the matrix-sdk-search crate

A new crate with a basic API for a creating, populating and searching a
room message index.

Signed-off-by: Shrey Patel [email protected]

Author: dragonfly1033

Cargo.lock

@@ -118,6 +118,7 @@ matrix-sdk-sqlite = { path = "crates/matrix-sdk-sqlite", version = "0.13.0", def
 matrix-sdk-store-encryption = { path = "crates/matrix-sdk-store-encryption", version = "0.13.0" }
 matrix-sdk-test = { path = "testing/matrix-sdk-test", version = "0.13.0" }
 matrix-sdk-ui = { path = "crates/matrix-sdk-ui", version = "0.13.0", default-features = false }
+matrix-sdk-search = { path = "crates/matrix-sdk-search", version = "0.13.0" }
 
 [workspace.lints.rust]
 rust_2018_idioms = "warn"

Cargo.toml

@@ -160,7 +160,7 @@ pub mod sync {
         Ok(())
     }
 
-    /// Dispatch a [`RoomMemberEventContent>`] state event.
+    /// Dispatch a [`RoomMemberEventContent`] state event.
     async fn dispatch_room_member<U>(
         context: &mut Context,
         room_id: &RoomId,

crates/matrix-sdk-base/src/response_processors/state_events.rs

@@ -0,0 +1,34 @@
+[package]
+authors = ["Shrey Patel <[email protected]>"]
+description = "The search component to build a Matrix client library."
+edition = "2024"
+homepage = "https://github.com/matrix-org/matrix-rust-sdk"
+license = "Apache-2.0"
+name = "matrix-sdk-search"
+readme = "README.md"
+repository = "https://github.com/matrix-org/matrix-rust-sdk"
+rust-version.workspace = true
+version = "0.13.0"
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = ["--cfg", "docsrs", "--generate-link-to-definition"]
+
+[dependencies]
+tantivy = "0.24.2"
+ruma = { workspace = true , features = [
+    "client-api-c",
+    "events",
+    "rand",
+    "unstable-msc1767"
+] }
+tracing = { workspace = true, features = ["attributes"] }
+thiserror.workspace = true
+matrix-sdk-test = { workspace = true, optional = true }
+
+[dev-dependencies]
+matrix-sdk-test.workspace = true
+
+[lints]
+workspace = true
+

crates/matrix-sdk-search/Cargo.toml

@@ -0,0 +1 @@
+# matrix-sdk-search

crates/matrix-sdk-search/README.md

@@ -0,0 +1,164 @@
+// Copyright 2024 The Matrix.org Foundation C.I.C.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! The event cache is an abstraction layer, sitting between the Rust SDK and a
+//! final client, that acts as a global observer of all the rooms, gathering and
+//! inferring some extra useful information about each room. In particular, this
+//! doesn't require subscribing to a specific room to get access to this
+//! information.
+//!
+//! It's intended to be fast, robust and easy to maintain, having learned from
+//! previous endeavours at implementing middle to high level features elsewhere
+//! in the SDK, notably in the UI's Timeline object.
+//!
+//! See the [github issue](https://github.com/matrix-org/matrix-rust-sdk/issues/3058) for more
+//! details about the historical reasons that led us to start writing this.
+
+use tantivy::{
+    directory::error::OpenDirectoryError as TantivyOpenDirectoryError,
+    query::QueryParserError as TantivyQueryParserError,
+};
+use thiserror::Error;
+
+/// Internal representation of Search Index errors.
+#[derive(Error, Debug)]
+pub enum IndexError {
+    /// Tantivy Error
+    #[error(transparent)]
+    TantivyError(tantivy::TantivyError),
+
+    /// Open Directory Error
+    #[error(transparent)]
+    OpenDirectoryError(TantivyOpenDirectoryError),
+
+    /// Query Parse Error
+    #[error(transparent)]
+    QueryParserError(TantivyQueryParserError),
+
+    /// Schema Error
+    #[error(transparent)]
+    IndexSchemaError(IndexSchemaError),
+
+    /// Write Error
+    #[error(transparent)]
+    IndexWriteError(IndexWriteError),
+
+    /// Search Error
+    #[error(transparent)]
+    IndexSearchError(IndexSearchError),
+
+    /// Add Event Error
+    #[error("Failed to add event to index")]
+    EventNotAdded,
+
+    /// Message Type Error
+    #[error("Message type not supported")]
+    MessageTypeNotSupported,
+
+    /// Indexing Redacted Message Error
+    #[error("Cannot index redacted message")]
+    CannotIndexRedactedMessage,
+
+    /// Indexing Empty Message Error
+    #[error("Cannot index empty message")]
+    EmptyMessage,
+
+    /// IO error
+    #[error(transparent)]
+    IO(std::io::Error),
+}
+
+impl From<tantivy::TantivyError> for IndexError {
+    fn from(err: tantivy::TantivyError) -> IndexError {
+        IndexError::TantivyError(err)
+    }
+}
+
+impl From<TantivyOpenDirectoryError> for IndexError {
+    fn from(err: TantivyOpenDirectoryError) -> IndexError {
+        IndexError::OpenDirectoryError(err)
+    }
+}
+
+impl From<TantivyQueryParserError> for IndexError {
+    fn from(err: TantivyQueryParserError) -> IndexError {
+        IndexError::QueryParserError(err)
+    }
+}
+
+impl From<IndexSchemaError> for IndexError {
+    fn from(err: IndexSchemaError) -> IndexError {
+        IndexError::IndexSchemaError(err)
+    }
+}
+
+impl From<IndexWriteError> for IndexError {
+    fn from(err: IndexWriteError) -> IndexError {
+        IndexError::IndexWriteError(err)
+    }
+}
+
+impl From<IndexSearchError> for IndexError {
+    fn from(err: IndexSearchError) -> IndexError {
+        IndexError::IndexSearchError(err)
+    }
+}
+
+impl From<std::io::Error> for IndexError {
+    fn from(err: std::io::Error) -> IndexError {
+        IndexError::IO(err)
+    }
+}
+
+/// Internal representation of Schema errors.
+#[derive(Error, Debug)]
+pub enum IndexSchemaError {
+    /// Tantivy Error
+    #[error(transparent)]
+    TantivyError(tantivy::TantivyError),
+}
+
+impl From<tantivy::TantivyError> for IndexSchemaError {
+    fn from(err: tantivy::TantivyError) -> IndexSchemaError {
+        IndexSchemaError::TantivyError(err)
+    }
+}
+
+/// Internal representation of Writer errors.
+#[derive(Error, Debug)]
+pub enum IndexWriteError {
+    /// Tantivy Error
+    #[error(transparent)]
+    TantivyError(tantivy::TantivyError),
+}
+
+impl From<tantivy::TantivyError> for IndexWriteError {
+    fn from(err: tantivy::TantivyError) -> IndexWriteError {
+        IndexWriteError::TantivyError(err)
+    }
+}
+
+/// Internal representation of Search errors.
+#[derive(Error, Debug)]
+pub enum IndexSearchError {
+    /// Tantivy Error
+    #[error(transparent)]
+    TantivyError(tantivy::TantivyError),
+}
+
+impl From<tantivy::TantivyError> for IndexSearchError {
+    fn from(err: tantivy::TantivyError) -> IndexSearchError {
+        IndexSearchError::TantivyError(err)
+    }
+}