base: Remove deprecated StateStore APIs

Signed-off-by: Kévin Commaille <[email protected]>

Author: zecakeh

crates/matrix-sdk-base/src/store/integration_tests.rs

@@ -71,8 +71,6 @@ pub trait StateStoreIntegrationTests {
     async fn test_receipts_saving(&self);
     /// Test custom storage.
     async fn test_custom_storage(&self) -> Result<()>;
-    /// Test invited room saving.
-    async fn test_persist_invited_room(&self) -> Result<()>;
     /// Test stripped and non-stripped room member saving.
     async fn test_stripped_non_stripped(&self) -> Result<()>;
     /// Test room removal.
@@ -259,9 +257,6 @@ impl StateStoreIntegrationTests for DynStateStore {
         assert!(self.get_kv_data(StateStoreDataKey::SyncToken).await?.is_some());
         assert!(self.get_presence_event(user_id).await?.is_some());
         assert_eq!(self.get_room_infos().await?.len(), 2, "Expected to find 2 room infos");
-        #[allow(deprecated)]
-        let stripped_rooms = self.get_stripped_room_infos().await?;
-        assert_eq!(stripped_rooms.len(), 1, "Expected to find 1 stripped room info");
         assert!(self
             .get_account_data_event(GlobalAccountDataEventType::PushRules)
             .await?
@@ -918,25 +913,12 @@ impl StateStoreIntegrationTests for DynStateStore {
         Ok(())
     }
 
-    async fn test_persist_invited_room(&self) -> Result<()> {
-        self.populate().await?;
-
-        #[allow(deprecated)]
-        let stripped_rooms = self.get_stripped_room_infos().await?;
-        assert_eq!(stripped_rooms.len(), 1);
-
-        Ok(())
-    }
-
     async fn test_stripped_non_stripped(&self) -> Result<()> {
         let room_id = room_id!("!test_stripped_non_stripped:localhost");
         let user_id = user_id();
 
         assert!(self.get_member_event(room_id, user_id).await.unwrap().is_none());
         assert_eq!(self.get_room_infos().await.unwrap().len(), 0);
-        #[allow(deprecated)]
-        let stripped_rooms = self.get_stripped_room_infos().await?;
-        assert_eq!(stripped_rooms.len(), 0);
 
         let mut changes = StateChanges::default();
         changes
@@ -953,9 +935,6 @@ impl StateStoreIntegrationTests for DynStateStore {
             self.get_member_event(room_id, user_id).await.unwrap().unwrap().deserialize().unwrap();
         assert!(matches!(member_event, MemberEvent::Sync(_)));
         assert_eq!(self.get_room_infos().await.unwrap().len(), 1);
-        #[allow(deprecated)]
-        let stripped_rooms = self.get_stripped_room_infos().await?;
-        assert_eq!(stripped_rooms.len(), 0);
 
         let members = self.get_user_ids(room_id, RoomMemberships::empty()).await.unwrap();
         assert_eq!(members, vec![user_id.to_owned()]);
@@ -969,9 +948,6 @@ impl StateStoreIntegrationTests for DynStateStore {
             self.get_member_event(room_id, user_id).await.unwrap().unwrap().deserialize().unwrap();
         assert!(matches!(member_event, MemberEvent::Stripped(_)));
         assert_eq!(self.get_room_infos().await.unwrap().len(), 1);
-        #[allow(deprecated)]
-        let stripped_rooms = self.get_stripped_room_infos().await?;
-        assert_eq!(stripped_rooms.len(), 1);
 
         let members = self.get_user_ids(room_id, RoomMemberships::empty()).await.unwrap();
         assert_eq!(members, vec![user_id.to_owned()]);
@@ -989,9 +965,6 @@ impl StateStoreIntegrationTests for DynStateStore {
         self.remove_room(room_id).await?;
 
         assert_eq!(self.get_room_infos().await?.len(), 1, "room is still there");
-        #[allow(deprecated)]
-        let stripped_rooms = self.get_stripped_room_infos().await?;
-        assert_eq!(stripped_rooms.len(), 1);
 
         assert!(self.get_state_event(room_id, StateEventType::RoomName, "").await?.is_none());
         assert!(
@@ -1044,9 +1017,6 @@ impl StateStoreIntegrationTests for DynStateStore {
         self.remove_room(stripped_room_id).await?;
 
         assert!(self.get_room_infos().await?.is_empty(), "still room info found");
-        #[allow(deprecated)]
-        let stripped_rooms = self.get_stripped_room_infos().await?;
-        assert!(stripped_rooms.is_empty(), "still stripped room info found");
         Ok(())
     }
 
@@ -1584,12 +1554,6 @@ macro_rules! statestore_integration_tests {
                 store.test_custom_storage().await
             }
 
-            #[async_test]
-            async fn test_persist_invited_room() -> StoreResult<()> {
-                let store = get_store().await?.into_state_store();
-                store.test_persist_invited_room().await
-            }
-
             #[async_test]
             async fn test_stripped_non_stripped() -> StoreResult<()> {
                 let store = get_store().await.unwrap().into_state_store();

crates/matrix-sdk-base/src/store/memory_store.rs

@@ -45,7 +45,7 @@ use super::{
 };
 use crate::{
     deserialized_responses::RawAnySyncOrStrippedState, MinimalRoomMemberEvent, RoomMemberships,
-    RoomState, StateStoreDataKey, StateStoreDataValue,
+    StateStoreDataKey, StateStoreDataValue,
 };
 
 /// In-memory, non-persistent implementation of the `StateStore`.
@@ -696,29 +696,10 @@ impl StateStore for MemoryStore {
         Ok(get_user_ids_inner(&self.members.read().unwrap(), room_id, memberships))
     }
 
-    async fn get_invited_user_ids(&self, room_id: &RoomId) -> Result<Vec<OwnedUserId>> {
-        StateStore::get_user_ids(self, room_id, RoomMemberships::INVITE).await
-    }
-
-    async fn get_joined_user_ids(&self, room_id: &RoomId) -> Result<Vec<OwnedUserId>> {
-        StateStore::get_user_ids(self, room_id, RoomMemberships::JOIN).await
-    }
-
     async fn get_room_infos(&self) -> Result<Vec<RoomInfo>> {
         Ok(self.room_info.read().unwrap().values().cloned().collect())
     }
 
-    async fn get_stripped_room_infos(&self) -> Result<Vec<RoomInfo>> {
-        Ok(self
-            .room_info
-            .read()
-            .unwrap()
-            .values()
-            .filter(|r| matches!(r.state(), RoomState::Invited))
-            .cloned()
-            .collect())
-    }
-
     async fn get_users_with_display_name(
         &self,
         room_id: &RoomId,

crates/matrix-sdk-base/src/store/traits.rs

@@ -190,24 +190,9 @@ pub trait StateStore: AsyncTraitDeps {
         memberships: RoomMemberships,
     ) -> Result<Vec<OwnedUserId>, Self::Error>;
 
-    /// Get all the user ids of members that are in the invited state for a
-    /// given room, for stripped and regular rooms alike.
-    #[deprecated = "Use get_user_ids with RoomMemberships::INVITE instead."]
-    async fn get_invited_user_ids(&self, room_id: &RoomId)
-        -> Result<Vec<OwnedUserId>, Self::Error>;
-
-    /// Get all the user ids of members that are in the joined state for a
-    /// given room, for stripped and regular rooms alike.
-    #[deprecated = "Use get_user_ids with RoomMemberships::JOIN instead."]
-    async fn get_joined_user_ids(&self, room_id: &RoomId) -> Result<Vec<OwnedUserId>, Self::Error>;
-
     /// Get all the pure `RoomInfo`s the store knows about.
     async fn get_room_infos(&self) -> Result<Vec<RoomInfo>, Self::Error>;
 
-    /// Get all the pure `RoomInfo`s the store knows about.
-    #[deprecated = "Use get_room_infos instead and filter by RoomState"]
-    async fn get_stripped_room_infos(&self) -> Result<Vec<RoomInfo>, Self::Error>;
-
     /// Get all the users that use the given display name in the given room.
     ///
     /// # Arguments
@@ -559,26 +544,10 @@ impl<T: StateStore> StateStore for EraseStateStoreError<T> {
         self.0.get_user_ids(room_id, memberships).await.map_err(Into::into)
     }
 
-    async fn get_invited_user_ids(
-        &self,
-        room_id: &RoomId,
-    ) -> Result<Vec<OwnedUserId>, Self::Error> {
-        self.0.get_user_ids(room_id, RoomMemberships::INVITE).await.map_err(Into::into)
-    }
-
-    async fn get_joined_user_ids(&self, room_id: &RoomId) -> Result<Vec<OwnedUserId>, Self::Error> {
-        self.0.get_user_ids(room_id, RoomMemberships::JOIN).await.map_err(Into::into)
-    }
-
     async fn get_room_infos(&self) -> Result<Vec<RoomInfo>, Self::Error> {
         self.0.get_room_infos().await.map_err(Into::into)
     }
 
-    #[allow(deprecated)]
-    async fn get_stripped_room_infos(&self) -> Result<Vec<RoomInfo>, Self::Error> {
-        self.0.get_stripped_room_infos().await.map_err(Into::into)
-    }
-
     async fn get_users_with_display_name(
         &self,
         room_id: &RoomId,

crates/matrix-sdk-indexeddb/src/state_store/mod.rs

@@ -29,8 +29,7 @@ use matrix_sdk_base::{
         QueuedEvent, SerializableEventContent, ServerCapabilities, StateChanges, StateStore,
         StoreError,
     },
-    MinimalRoomMemberEvent, RoomInfo, RoomMemberships, RoomState, StateStoreDataKey,
-    StateStoreDataValue,
+    MinimalRoomMemberEvent, RoomInfo, RoomMemberships, StateStoreDataKey, StateStoreDataValue,
 };
 use matrix_sdk_store_encryption::{Error as EncryptionError, StoreCipher};
 use ruma::{
@@ -1087,33 +1086,6 @@ impl_state_store!({
         Ok(entries)
     }
 
-    async fn get_stripped_room_infos(&self) -> Result<Vec<RoomInfo>> {
-        let txn = self
-            .inner
-            .transaction_on_one_with_mode(keys::ROOM_INFOS, IdbTransactionMode::Readonly)?;
-        let store = txn.object_store(keys::ROOM_INFOS)?;
-
-        let mut infos = Vec::new();
-        let cursor = store.open_cursor()?.await?;
-
-        if let Some(cursor) = cursor {
-            loop {
-                let value = cursor.value();
-                let info = self.deserialize_value::<RoomInfo>(&value)?;
-
-                if info.state() == RoomState::Invited {
-                    infos.push(info);
-                }
-
-                if !cursor.continue_cursor()?.await? {
-                    break;
-                }
-            }
-        }
-
-        Ok(infos)
-    }
-
     async fn get_users_with_display_name(
         &self,
         room_id: &RoomId,
@@ -1324,14 +1296,6 @@ impl_state_store!({
         self.get_user_ids_inner(room_id, memberships, false).await
     }
 
-    async fn get_invited_user_ids(&self, room_id: &RoomId) -> Result<Vec<OwnedUserId>> {
-        self.get_user_ids(room_id, RoomMemberships::INVITE).await
-    }
-
-    async fn get_joined_user_ids(&self, room_id: &RoomId) -> Result<Vec<OwnedUserId>> {
-        self.get_user_ids(room_id, RoomMemberships::JOIN).await
-    }
-
     async fn save_send_queue_event(
         &self,
         room_id: &RoomId,

crates/matrix-sdk-sqlite/src/state_store.rs

@@ -699,26 +699,12 @@ trait SqliteObjectStateStoreExt: SqliteAsyncConnExt {
         Ok(())
     }
 
-    async fn get_room_infos(&self, states: Vec<Key>) -> Result<Vec<Vec<u8>>> {
-        if states.is_empty() {
-            Ok(self
-                .prepare("SELECT data FROM room_info", move |mut stmt| {
-                    stmt.query_map((), |row| row.get(0))?.collect()
-                })
-                .await?)
-        } else {
-            self.chunk_large_query_over(states, None, |txn, states| {
-                let sql_params = repeat_vars(states.len());
-                let sql = format!("SELECT data FROM room_info WHERE state IN ({sql_params})");
-
-                Ok(txn
-                    .prepare(&sql)?
-                    .query(rusqlite::params_from_iter(states))?
-                    .mapped(|row| row.get(0))
-                    .collect::<Result<_, _>>()?)
+    async fn get_room_infos(&self) -> Result<Vec<Vec<u8>>> {
+        Ok(self
+            .prepare("SELECT data FROM room_info", move |mut stmt| {
+                stmt.query_map((), |row| row.get(0))?.collect()
             })
-            .await
-        }
+            .await?)
     }
 
     async fn get_maybe_stripped_state_events_for_keys(
@@ -1444,30 +1430,10 @@ impl StateStore for SqliteStateStore {
             .collect()
     }
 
-    async fn get_invited_user_ids(&self, room_id: &RoomId) -> Result<Vec<OwnedUserId>> {
-        self.get_user_ids(room_id, RoomMemberships::INVITE).await
-    }
-
-    async fn get_joined_user_ids(&self, room_id: &RoomId) -> Result<Vec<OwnedUserId>> {
-        self.get_user_ids(room_id, RoomMemberships::JOIN).await
-    }
-
     async fn get_room_infos(&self) -> Result<Vec<RoomInfo>> {
         self.acquire()
             .await?
-            .get_room_infos(Vec::new())
-            .await?
-            .into_iter()
-            .map(|data| self.deserialize_json(&data))
-            .collect()
-    }
-
-    async fn get_stripped_room_infos(&self) -> Result<Vec<RoomInfo>> {
-        let states =
-            vec![self.encode_key(keys::ROOM_INFO, serde_json::to_string(&RoomState::Invited)?)];
-        self.acquire()
-            .await?
-            .get_room_infos(states)
+            .get_room_infos()
             .await?
             .into_iter()
             .map(|data| self.deserialize_json(&data))
@@ -2115,9 +2081,6 @@ mod migration_tests {
 
         // Check all room infos are there.
         assert_eq!(store.get_room_infos().await.unwrap().len(), 5);
-        #[allow(deprecated)]
-        let stripped_rooms = store.get_stripped_room_infos().await.unwrap();
-        assert_eq!(stripped_rooms.len(), 2);
     }
 
     // Add a room in version 2 format of the state store.