Setup a simple space service and some unit tests

Author: stefanceriu

bindings/matrix-sdk-ffi/src/client.rs

@@ -48,6 +48,7 @@ use matrix_sdk_ui::{
         NotificationClient as MatrixNotificationClient,
         NotificationProcessSetup as MatrixNotificationProcessSetup,
     },
+    spaces::SpaceService as UISpaceService,
     unable_to_decrypt_hook::UtdHookManager,
 };
 use mime::Mime;
@@ -106,6 +107,7 @@ use crate::{
         MediaPreviews, MediaSource, RoomAccountDataEvent, RoomAccountDataEventType,
     },
     runtime::get_runtime_handle,
+    spaces::SpaceService,
     sync_service::{SyncService, SyncServiceBuilder},
     task_handle::TaskHandle,
     utd::{UnableToDecryptDelegate, UtdHook},
@@ -1259,6 +1261,11 @@ impl Client {
         SyncServiceBuilder::new((*self.inner).clone(), self.utd_hook_manager.get().cloned())
     }
 
+    pub fn spaces_service(&self) -> Arc<SpaceService> {
+        let inner = UISpaceService::new((*self.inner).clone());
+        Arc::new(SpaceService::new(inner))
+    }
+
     pub async fn get_notification_settings(&self) -> Arc<NotificationSettings> {
         let inner = self.inner.notification_settings().await;
 

bindings/matrix-sdk-ffi/src/lib.rs

@@ -25,6 +25,7 @@ mod room_preview;
 mod ruma;
 mod runtime;
 mod session_verification;
+mod spaces;
 mod sync_service;
 mod task_handle;
 mod timeline;

bindings/matrix-sdk-ffi/src/spaces.rs

@@ -0,0 +1,48 @@
+// Copyright 2025 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.
+
+use matrix_sdk_ui::spaces::SpaceService as UISpaceService;
+use ruma::RoomId;
+
+use crate::error::ClientError;
+
+#[derive(uniffi::Object)]
+pub struct SpaceService {
+    inner: UISpaceService,
+}
+
+impl SpaceService {
+    /// Create a new instance of `SpaceService`.
+    pub fn new(inner: UISpaceService) -> Self {
+        Self { inner }
+    }
+}
+
+#[matrix_sdk_ffi_macros::export]
+impl SpaceService {
+    /// Get the list of joined spaces.
+    pub fn joined_spaces(&self) -> Vec<String> {
+        self.inner.joined_spaces().into_iter().map(|id| id.to_string()).collect()
+    }
+
+    /// Get the top-level children for a given space.
+    pub async fn top_level_children_for(
+        &self,
+        space_id: String,
+    ) -> Result<Vec<String>, ClientError> {
+        let space_id = RoomId::parse(space_id)?;
+        let children = self.inner.top_level_children_for(space_id).await?;
+        Ok(children.into_iter().map(|id| id.to_string()).collect())
+    }
+}

crates/matrix-sdk-ui/src/lib.rs

@@ -21,6 +21,7 @@ use ruma::html::HtmlSanitizerMode;
 pub mod encryption_sync_service;
 pub mod notification_client;
 pub mod room_list_service;
+pub mod spaces;
 pub mod sync_service;
 pub mod timeline;
 pub mod unable_to_decrypt_hook;

crates/matrix-sdk-ui/src/spaces/mod.rs

@@ -0,0 +1,148 @@
+// Copyright 2025 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 that specific language governing permissions and
+// limitations under the License.
+
+//! High level interfaces for working with Spaces
+//!
+//! See [`SpaceDiscoveryService`] for details.
+
+use matrix_sdk::{Client, Error};
+use ruma::OwnedRoomId;
+use ruma::api::client::space::get_hierarchy;
+
+pub struct SpaceService {
+    client: Client,
+}
+
+impl SpaceService {
+    pub fn new(client: Client) -> Self {
+        Self { client }
+    }
+
+    pub fn joined_spaces(&self) -> Vec<OwnedRoomId> {
+        self.client
+            .joined_rooms()
+            .into_iter()
+            .filter_map(|room| if room.is_space() { Some(room.room_id().to_owned()) } else { None })
+            .collect()
+    }
+
+    pub async fn top_level_children_for(
+        &self,
+        space_id: OwnedRoomId,
+    ) -> Result<Vec<OwnedRoomId>, Error> {
+        let request = get_hierarchy::v1::Request::new(space_id.clone());
+
+        let result = self.client.send(request).await?;
+
+        println!("Top level children for space {}: {:?}", space_id, result.rooms);
+
+        Ok(vec![])
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use assert_matches2::assert_let;
+    use matrix_sdk::{room::ParentSpace, test_utils::mocks::MatrixMockServer};
+    use matrix_sdk_test::{JoinedRoomBuilder, StateTestEvent, async_test};
+    use ruma::room_id;
+    use tokio_stream::StreamExt;
+
+    #[async_test]
+    async fn test_joined_spaces() {
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
+        let space_discovery_service = SpaceService::new(client.clone());
+
+        server.mock_room_state_encryption().plain().mount().await;
+
+        let parent_space_id = room_id!("!3:example.org");
+        let child_space_id_1 = room_id!("!1:example.org");
+        let child_space_id_2 = room_id!("!2:example.org");
+
+        server
+            .sync_room(
+                &client,
+                JoinedRoomBuilder::new(child_space_id_1)
+                    .add_state_event(StateTestEvent::CreateSpace)
+                    .add_state_event(StateTestEvent::SpaceParent {
+                        parent: parent_space_id.to_owned(),
+                        child: child_space_id_1.to_owned(),
+                    }),
+            )
+            .await;
+
+        server
+            .sync_room(
+                &client,
+                JoinedRoomBuilder::new(child_space_id_2)
+                    .add_state_event(StateTestEvent::CreateSpace)
+                    .add_state_event(StateTestEvent::SpaceParent {
+                        parent: parent_space_id.to_owned(),
+                        child: child_space_id_2.to_owned(),
+                    }),
+            )
+            .await;
+        server
+            .sync_room(
+                &client,
+                JoinedRoomBuilder::new(parent_space_id)
+                    .add_state_event(StateTestEvent::CreateSpace)
+                    .add_state_event(StateTestEvent::SpaceChild {
+                        parent: parent_space_id.to_owned(),
+                        child: child_space_id_1.to_owned(),
+                    })
+                    .add_state_event(StateTestEvent::SpaceChild {
+                        parent: parent_space_id.to_owned(),
+                        child: child_space_id_2.to_owned(),
+                    }),
+            )
+            .await;
+
+        assert_eq!(
+            space_discovery_service.joined_spaces(),
+            vec![child_space_id_1, child_space_id_2, parent_space_id]
+        );
+
+        let parent_space = client.get_room(parent_space_id).unwrap();
+        assert!(parent_space.is_space());
+
+        let spaces: Vec<ParentSpace> = client
+            .get_room(child_space_id_1)
+            .unwrap()
+            .parent_spaces()
+            .await
+            .unwrap()
+            .map(Result::unwrap)
+            .collect()
+            .await;
+
+        assert_let!(ParentSpace::Reciprocal(parent) = spaces.first().unwrap());
+        assert_eq!(parent.room_id(), parent_space.room_id());
+
+        let spaces: Vec<ParentSpace> = client
+            .get_room(child_space_id_2)
+            .unwrap()
+            .parent_spaces()
+            .await
+            .unwrap()
+            .map(Result::unwrap)
+            .collect()
+            .await;
+
+        assert_let!(ParentSpace::Reciprocal(parent) = spaces.last().unwrap());
+        assert_eq!(parent.room_id(), parent_space.room_id());
+    }
+}

testing/matrix-sdk-test/src/sync_builder/test_event.rs

@@ -1,4 +1,5 @@
 use ruma::{
+    OwnedRoomId,
     api::client::sync::sync_events::StrippedState,
     events::{
         AnyGlobalAccountDataEvent, AnyRoomAccountDataEvent, AnySyncStateEvent,
@@ -15,6 +16,7 @@ pub enum StateTestEvent {
     Alias,
     Aliases,
     Create,
+    CreateSpace,
     Encryption,
     HistoryVisibility,
     JoinRules,
@@ -31,6 +33,8 @@ pub enum StateTestEvent {
     RoomName,
     RoomPinnedEvents,
     RoomTopic,
+    SpaceChild { parent: OwnedRoomId, child: OwnedRoomId },
+    SpaceParent { parent: OwnedRoomId, child: OwnedRoomId },
     Custom(JsonValue),
 }
 
@@ -40,6 +44,7 @@ impl From<StateTestEvent> for JsonValue {
             StateTestEvent::Alias => test_json::sync_events::ALIAS.to_owned(),
             StateTestEvent::Aliases => test_json::sync_events::ALIASES.to_owned(),
             StateTestEvent::Create => test_json::sync_events::CREATE.to_owned(),
+            StateTestEvent::CreateSpace => test_json::sync_events::CREATE_SPACE.to_owned(),
             StateTestEvent::Encryption => test_json::sync_events::ENCRYPTION.to_owned(),
             StateTestEvent::HistoryVisibility => {
                 test_json::sync_events::HISTORY_VISIBILITY.to_owned()
@@ -62,6 +67,18 @@ impl From<StateTestEvent> for JsonValue {
             StateTestEvent::RoomName => test_json::sync_events::NAME.to_owned(),
             StateTestEvent::RoomPinnedEvents => test_json::sync_events::PINNED_EVENTS.to_owned(),
             StateTestEvent::RoomTopic => test_json::sync_events::TOPIC.to_owned(),
+            StateTestEvent::SpaceChild { parent, child } => {
+                let mut json = test_json::sync_events::SPACE_CHILD.to_owned();
+                json["room_id"] = JsonValue::String(parent.to_string());
+                json["state_key"] = JsonValue::String(child.to_string());
+                json
+            }
+            StateTestEvent::SpaceParent { parent, child } => {
+                let mut json = test_json::sync_events::SPACE_PARENT.to_owned();
+                json["state_key"] = JsonValue::String(parent.to_string());
+                json["room_id"] = JsonValue::String(child.to_string());
+                json
+            }
             StateTestEvent::Custom(json) => json,
         }
     }

testing/matrix-sdk-test/src/test_json/sync_events.rs

@@ -57,6 +57,25 @@ pub static CREATE: Lazy<JsonValue> = Lazy::new(|| {
     })
 });
 
+pub static CREATE_SPACE: Lazy<JsonValue> = Lazy::new(|| {
+    json!({
+        "content": {
+            "creator": "@example:localhost",
+            "m.federate": true,
+            "room_version": "1",
+            "type": "m.space",
+        },
+        "event_id": "$151957878228ekrDs:localhost",
+        "origin_server_ts": 15195787,
+        "sender": "@example:localhost",
+        "state_key": "",
+        "type": "m.room.create",
+        "unsigned": {
+            "age": 139298
+        }
+    })
+});
+
 pub static DIRECT: Lazy<JsonValue> = Lazy::new(|| {
     json!({
         "content": {
@@ -726,3 +745,43 @@ pub static IGNORED_USER_LIST: Lazy<JsonValue> = Lazy::new(|| {
         "type": "m.ignored_user_list",
     })
 });
+
+pub static SPACE_CHILD: Lazy<JsonValue> = Lazy::new(|| {
+    json!({
+        "content": {
+            "via": [
+              "example.org",
+              "other.example.org"
+            ]
+          },
+          "event_id": "$space_child_event_id:example.org",
+          "room_id": "!parent_room_id:example.org",
+          "state_key": "!child_room_id:example.org",
+          "origin_server_ts": 151957879,
+          "sender": "@example:example.org",
+          "type": "m.space.child",
+          "unsigned": {
+            "age": 1234,
+          }
+    })
+});
+
+pub static SPACE_PARENT: Lazy<JsonValue> = Lazy::new(|| {
+    json!({
+        "content": {
+            "via": [
+              "example.org",
+              "other.example.org"
+            ]
+          },
+          "event_id": "$space_parent_event_id:example.org",
+          "room_id": "!child_room_id:example.org",
+          "state_key": "!parent_room_id:example.org",
+          "origin_server_ts": 151957879,
+          "sender": "@example:example.org",
+          "type": "m.space.parent",
+          "unsigned": {
+            "age": 1234,
+          }
+    })
+});