enable unreachable_pub lint

This causes some other lints to start firing too (which is good), but
I'm going to fix them in follow-up commits to keep things organized.

src/service/rooms/alias.rs

@@ -1,32 +1,32 @@
 mod data;
 
-pub use data::Data;
+pub(crate) use data::Data;
 
 use crate::Result;
 use ruma::{OwnedRoomAliasId, OwnedRoomId, RoomAliasId, RoomId};
 
-pub struct Service {
-    pub db: &'static dyn Data,
+pub(crate) struct Service {
+    pub(crate) db: &'static dyn Data,
 }
 
 impl Service {
     #[tracing::instrument(skip(self))]
-    pub fn set_alias(&self, alias: &RoomAliasId, room_id: &RoomId) -> Result<()> {
+    pub(crate) fn set_alias(&self, alias: &RoomAliasId, room_id: &RoomId) -> Result<()> {
         self.db.set_alias(alias, room_id)
     }
 
     #[tracing::instrument(skip(self))]
-    pub fn remove_alias(&self, alias: &RoomAliasId) -> Result<()> {
+    pub(crate) fn remove_alias(&self, alias: &RoomAliasId) -> Result<()> {
         self.db.remove_alias(alias)
     }
 
     #[tracing::instrument(skip(self))]
-    pub fn resolve_local_alias(&self, alias: &RoomAliasId) -> Result<Option<OwnedRoomId>> {
+    pub(crate) fn resolve_local_alias(&self, alias: &RoomAliasId) -> Result<Option<OwnedRoomId>> {
         self.db.resolve_local_alias(alias)
     }
 
     #[tracing::instrument(skip(self))]
-    pub fn local_aliases_for_room<'a>(
+    pub(crate) fn local_aliases_for_room<'a>(
         &'a self,
         room_id: &RoomId,
     ) -> Box<dyn Iterator<Item = Result<OwnedRoomAliasId>> + 'a> {

src/service/rooms/alias/data.rs

@@ -1,7 +1,7 @@
 use crate::Result;
 use ruma::{OwnedRoomAliasId, OwnedRoomId, RoomAliasId, RoomId};
 
-pub trait Data: Send + Sync {
+pub(crate) trait Data: Send + Sync {
     /// Creates or updates the alias to the given room id.
     fn set_alias(&self, alias: &RoomAliasId, room_id: &RoomId) -> Result<()>;
 

src/service/rooms/auth_chain.rs

@@ -4,28 +4,35 @@ use std::{
     sync::Arc,
 };
 
-pub use data::Data;
+pub(crate) use data::Data;
 use ruma::{api::client::error::ErrorKind, EventId, RoomId};
 use tracing::{debug, error, warn};
 
 use crate::{services, Error, Result};
 
-pub struct Service {
-    pub db: &'static dyn Data,
+pub(crate) struct Service {
+    pub(crate) db: &'static dyn Data,
 }
 
 impl Service {
-    pub fn get_cached_eventid_authchain(&self, key: &[u64]) -> Result<Option<Arc<HashSet<u64>>>> {
+    pub(crate) fn get_cached_eventid_authchain(
+        &self,
+        key: &[u64],
+    ) -> Result<Option<Arc<HashSet<u64>>>> {
         self.db.get_cached_eventid_authchain(key)
     }
 
     #[tracing::instrument(skip(self))]
-    pub fn cache_auth_chain(&self, key: Vec<u64>, auth_chain: Arc<HashSet<u64>>) -> Result<()> {
+    pub(crate) fn cache_auth_chain(
+        &self,
+        key: Vec<u64>,
+        auth_chain: Arc<HashSet<u64>>,
+    ) -> Result<()> {
         self.db.cache_auth_chain(key, auth_chain)
     }
 
     #[tracing::instrument(skip(self, starting_events))]
-    pub async fn get_auth_chain<'a>(
+    pub(crate) async fn get_auth_chain<'a>(
         &self,
         room_id: &RoomId,
         starting_events: Vec<Arc<EventId>>,

src/service/rooms/auth_chain/data.rs

@@ -1,7 +1,7 @@
 use crate::Result;
 use std::{collections::HashSet, sync::Arc};
 
-pub trait Data: Send + Sync {
+pub(crate) trait Data: Send + Sync {
     fn get_cached_eventid_authchain(
         &self,
         shorteventid: &[u64],

src/service/rooms/directory.rs

@@ -1,32 +1,32 @@
 mod data;
 
-pub use data::Data;
+pub(crate) use data::Data;
 use ruma::{OwnedRoomId, RoomId};
 
 use crate::Result;
 
-pub struct Service {
-    pub db: &'static dyn Data,
+pub(crate) struct Service {
+    pub(crate) db: &'static dyn Data,
 }
 
 impl Service {
     #[tracing::instrument(skip(self))]
-    pub fn set_public(&self, room_id: &RoomId) -> Result<()> {
+    pub(crate) fn set_public(&self, room_id: &RoomId) -> Result<()> {
         self.db.set_public(room_id)
     }
 
     #[tracing::instrument(skip(self))]
-    pub fn set_not_public(&self, room_id: &RoomId) -> Result<()> {
+    pub(crate) fn set_not_public(&self, room_id: &RoomId) -> Result<()> {
         self.db.set_not_public(room_id)
     }
 
     #[tracing::instrument(skip(self))]
-    pub fn is_public_room(&self, room_id: &RoomId) -> Result<bool> {
+    pub(crate) fn is_public_room(&self, room_id: &RoomId) -> Result<bool> {
         self.db.is_public_room(room_id)
     }
 
     #[tracing::instrument(skip(self))]
-    pub fn public_rooms(&self) -> impl Iterator<Item = Result<OwnedRoomId>> + '_ {
+    pub(crate) fn public_rooms(&self) -> impl Iterator<Item = Result<OwnedRoomId>> + '_ {
         self.db.public_rooms()
     }
 }

src/service/rooms/directory/data.rs

@@ -1,7 +1,7 @@
 use crate::Result;
 use ruma::{OwnedRoomId, RoomId};
 
-pub trait Data: Send + Sync {
+pub(crate) trait Data: Send + Sync {
     /// Adds the room to the public room directory
     fn set_public(&self, room_id: &RoomId) -> Result<()>;
 

src/service/rooms/edus.rs

@@ -1,9 +1,9 @@
-pub mod read_receipt;
-pub mod typing;
+pub(crate) mod read_receipt;
+pub(crate) mod typing;
 
-pub trait Data: read_receipt::Data + 'static {}
+pub(crate) trait Data: read_receipt::Data + 'static {}
 
-pub struct Service {
-    pub read_receipt: read_receipt::Service,
-    pub typing: typing::Service,
+pub(crate) struct Service {
+    pub(crate) read_receipt: read_receipt::Service,
+    pub(crate) typing: typing::Service,
 }

src/service/rooms/edus/read_receipt.rs

@@ -1,17 +1,17 @@
 mod data;
 
-pub use data::Data;
+pub(crate) use data::Data;
 
 use crate::Result;
 use ruma::{events::receipt::ReceiptEvent, serde::Raw, OwnedUserId, RoomId, UserId};
 
-pub struct Service {
-    pub db: &'static dyn Data,
+pub(crate) struct Service {
+    pub(crate) db: &'static dyn Data,
 }
 
 impl Service {
     /// Replaces the previous read receipt.
-    pub fn readreceipt_update(
+    pub(crate) fn readreceipt_update(
         &self,
         user_id: &UserId,
         room_id: &RoomId,
@@ -22,7 +22,7 @@ impl Service {
 
     /// Returns an iterator over the most recent read_receipts in a room that happened after the event with id `since`.
     #[tracing::instrument(skip(self))]
-    pub fn readreceipts_since<'a>(
+    pub(crate) fn readreceipts_since<'a>(
         &'a self,
         room_id: &RoomId,
         since: u64,
@@ -38,18 +38,31 @@ impl Service {
 
     /// Sets a private read marker at `count`.
     #[tracing::instrument(skip(self))]
-    pub fn private_read_set(&self, room_id: &RoomId, user_id: &UserId, count: u64) -> Result<()> {
+    pub(crate) fn private_read_set(
+        &self,
+        room_id: &RoomId,
+        user_id: &UserId,
+        count: u64,
+    ) -> Result<()> {
         self.db.private_read_set(room_id, user_id, count)
     }
 
     /// Returns the private read marker.
     #[tracing::instrument(skip(self))]
-    pub fn private_read_get(&self, room_id: &RoomId, user_id: &UserId) -> Result<Option<u64>> {
+    pub(crate) fn private_read_get(
+        &self,
+        room_id: &RoomId,
+        user_id: &UserId,
+    ) -> Result<Option<u64>> {
         self.db.private_read_get(room_id, user_id)
     }
 
     /// Returns the count of the last typing update in this room.
-    pub fn last_privateread_update(&self, user_id: &UserId, room_id: &RoomId) -> Result<u64> {
+    pub(crate) fn last_privateread_update(
+        &self,
+        user_id: &UserId,
+        room_id: &RoomId,
+    ) -> Result<u64> {
         self.db.last_privateread_update(user_id, room_id)
     }
 }

src/service/rooms/edus/read_receipt/data.rs

@@ -1,7 +1,7 @@
 use crate::Result;
 use ruma::{events::receipt::ReceiptEvent, serde::Raw, OwnedUserId, RoomId, UserId};
 
-pub trait Data: Send + Sync {
+pub(crate) trait Data: Send + Sync {
     /// Replaces the previous read receipt.
     fn readreceipt_update(
         &self,

src/service/rooms/edus/typing.rs

@@ -4,16 +4,21 @@ use tokio::sync::{broadcast, RwLock};
 
 use crate::{services, utils, Result};
 
-pub struct Service {
-    pub typing: RwLock<BTreeMap<OwnedRoomId, BTreeMap<OwnedUserId, u64>>>, // u64 is unix timestamp of timeout
-    pub last_typing_update: RwLock<BTreeMap<OwnedRoomId, u64>>, // timestamp of the last change to typing users
-    pub typing_update_sender: broadcast::Sender<OwnedRoomId>,
+pub(crate) struct Service {
+    pub(crate) typing: RwLock<BTreeMap<OwnedRoomId, BTreeMap<OwnedUserId, u64>>>, // u64 is unix timestamp of timeout
+    pub(crate) last_typing_update: RwLock<BTreeMap<OwnedRoomId, u64>>, // timestamp of the last change to typing users
+    pub(crate) typing_update_sender: broadcast::Sender<OwnedRoomId>,
 }
 
 impl Service {
     /// Sets a user as typing until the timeout timestamp is reached or roomtyping_remove is
     /// called.
-    pub async fn typing_add(&self, user_id: &UserId, room_id: &RoomId, timeout: u64) -> Result<()> {
+    pub(crate) async fn typing_add(
+        &self,
+        user_id: &UserId,
+        room_id: &RoomId,
+        timeout: u64,
+    ) -> Result<()> {
         self.typing
             .write()
             .await
@@ -29,7 +34,7 @@ impl Service {
     }
 
     /// Removes a user from typing before the timeout is reached.
-    pub async fn typing_remove(&self, user_id: &UserId, room_id: &RoomId) -> Result<()> {
+    pub(crate) async fn typing_remove(&self, user_id: &UserId, room_id: &RoomId) -> Result<()> {
         self.typing
             .write()
             .await
@@ -44,7 +49,7 @@ impl Service {
         Ok(())
     }
 
-    pub async fn wait_for_update(&self, room_id: &RoomId) -> Result<()> {
+    pub(crate) async fn wait_for_update(&self, room_id: &RoomId) -> Result<()> {
         let mut receiver = self.typing_update_sender.subscribe();
         while let Ok(next) = receiver.recv().await {
             if next == room_id {
@@ -87,7 +92,7 @@ impl Service {
     }
 
     /// Returns the count of the last typing update in this room.
-    pub async fn last_typing_update(&self, room_id: &RoomId) -> Result<u64> {
+    pub(crate) async fn last_typing_update(&self, room_id: &RoomId) -> Result<u64> {
         self.typings_maintain(room_id).await?;
         Ok(self
             .last_typing_update
@@ -99,7 +104,7 @@ impl Service {
     }
 
     /// Returns a new typing EDU.
-    pub async fn typings_all(
+    pub(crate) async fn typings_all(
         &self,
         room_id: &RoomId,
     ) -> Result<SyncEphemeralRoomEvent<ruma::events::typing::TypingEventContent>> {

src/service/rooms/event_handler.rs

@@ -43,7 +43,7 @@ use crate::{service::*, services, Error, PduEvent, Result};
 
 use super::state_compressor::CompressedStateEvent;
 
-pub struct Service;
+pub(crate) struct Service;
 
 impl Service {
     /// When receiving an event one needs to:
@@ -480,7 +480,7 @@ impl Service {
     }
 
     #[tracing::instrument(skip(self, incoming_pdu, val, create_event, pub_key_map))]
-    pub async fn upgrade_outlier_to_timeline_pdu(
+    pub(crate) async fn upgrade_outlier_to_timeline_pdu(
         &self,
         incoming_pdu: Arc<PduEvent>,
         val: BTreeMap<String, CanonicalJsonValue>,
@@ -1636,7 +1636,7 @@ impl Service {
     }
 
     /// Returns Ok if the acl allows the server
-    pub fn acl_check(&self, server_name: &ServerName, room_id: &RoomId) -> Result<()> {
+    pub(crate) fn acl_check(&self, server_name: &ServerName, room_id: &RoomId) -> Result<()> {
         let acl_event = match services().rooms.state_accessor.room_state_get(
             room_id,
             &StateEventType::RoomServerAcl,
@@ -1677,7 +1677,7 @@ impl Service {
     /// Search the DB for the signing keys of the given server, if we don't have them
     /// fetch them from the server and save to our DB.
     #[tracing::instrument(skip_all)]
-    pub async fn fetch_signing_keys(
+    pub(crate) async fn fetch_signing_keys(
         &self,
         origin: &ServerName,
         signature_ids: Vec<String>,

src/service/rooms/lazy_loading.rs

@@ -1,7 +1,7 @@
 mod data;
 use std::collections::{HashMap, HashSet};
 
-pub use data::Data;
+pub(crate) use data::Data;
 use ruma::{DeviceId, OwnedDeviceId, OwnedRoomId, OwnedUserId, RoomId, UserId};
 use tokio::sync::Mutex;
 
@@ -9,17 +9,17 @@ use crate::Result;
 
 use super::timeline::PduCount;
 
-pub struct Service {
-    pub db: &'static dyn Data,
+pub(crate) struct Service {
+    pub(crate) db: &'static dyn Data,
 
     #[allow(clippy::type_complexity)]
-    pub lazy_load_waiting:
+    pub(crate) lazy_load_waiting:
         Mutex<HashMap<(OwnedUserId, OwnedDeviceId, OwnedRoomId, PduCount), HashSet<OwnedUserId>>>,
 }
 
 impl Service {
     #[tracing::instrument(skip(self))]
-    pub fn lazy_load_was_sent_before(
+    pub(crate) fn lazy_load_was_sent_before(
         &self,
         user_id: &UserId,
         device_id: &DeviceId,
@@ -31,7 +31,7 @@ impl Service {
     }
 
     #[tracing::instrument(skip(self))]
-    pub async fn lazy_load_mark_sent(
+    pub(crate) async fn lazy_load_mark_sent(
         &self,
         user_id: &UserId,
         device_id: &DeviceId,
@@ -51,7 +51,7 @@ impl Service {
     }
 
     #[tracing::instrument(skip(self))]
-    pub async fn lazy_load_confirm_delivery(
+    pub(crate) async fn lazy_load_confirm_delivery(
         &self,
         user_id: &UserId,
         device_id: &DeviceId,
@@ -78,7 +78,7 @@ impl Service {
     }
 
     #[tracing::instrument(skip(self))]
-    pub fn lazy_load_reset(
+    pub(crate) fn lazy_load_reset(
         &self,
         user_id: &UserId,
         device_id: &DeviceId,

src/service/rooms/lazy_loading/data.rs

@@ -1,7 +1,7 @@
 use crate::Result;
 use ruma::{DeviceId, RoomId, UserId};
 
-pub trait Data: Send + Sync {
+pub(crate) trait Data: Send + Sync {
     fn lazy_load_was_sent_before(
         &self,
         user_id: &UserId,

src/service/rooms/metadata.rs

@@ -1,30 +1,30 @@
 mod data;
 
-pub use data::Data;
+pub(crate) use data::Data;
 use ruma::{OwnedRoomId, RoomId};
 
 use crate::Result;
 
-pub struct Service {
-    pub db: &'static dyn Data,
+pub(crate) struct Service {
+    pub(crate) db: &'static dyn Data,
 }
 
 impl Service {
     /// Checks if a room exists.
     #[tracing::instrument(skip(self))]
-    pub fn exists(&self, room_id: &RoomId) -> Result<bool> {
+    pub(crate) fn exists(&self, room_id: &RoomId) -> Result<bool> {
         self.db.exists(room_id)
     }
 
-    pub fn iter_ids<'a>(&'a self) -> Box<dyn Iterator<Item = Result<OwnedRoomId>> + 'a> {
+    pub(crate) fn iter_ids<'a>(&'a self) -> Box<dyn Iterator<Item = Result<OwnedRoomId>> + 'a> {
         self.db.iter_ids()
     }
 
-    pub fn is_disabled(&self, room_id: &RoomId) -> Result<bool> {
+    pub(crate) fn is_disabled(&self, room_id: &RoomId) -> Result<bool> {
         self.db.is_disabled(room_id)
     }
 
-    pub fn disable_room(&self, room_id: &RoomId, disabled: bool) -> Result<()> {
+    pub(crate) fn disable_room(&self, room_id: &RoomId, disabled: bool) -> Result<()> {
         self.db.disable_room(room_id, disabled)
     }
 }

src/service/rooms/metadata/data.rs

@@ -1,7 +1,7 @@
 use crate::Result;
 use ruma::{OwnedRoomId, RoomId};
 
-pub trait Data: Send + Sync {
+pub(crate) trait Data: Send + Sync {
     fn exists(&self, room_id: &RoomId) -> Result<bool>;
     fn iter_ids<'a>(&'a self) -> Box<dyn Iterator<Item = Result<OwnedRoomId>> + 'a>;
     fn is_disabled(&self, room_id: &RoomId) -> Result<bool>;

src/service/rooms/outlier.rs

@@ -1,28 +1,35 @@
 mod data;
 
-pub use data::Data;
+pub(crate) use data::Data;
 use ruma::{CanonicalJsonObject, EventId};
 
 use crate::{PduEvent, Result};
 
-pub struct Service {
-    pub db: &'static dyn Data,
+pub(crate) struct Service {
+    pub(crate) db: &'static dyn Data,
 }
 
 impl Service {
     /// Returns the pdu from the outlier tree.
-    pub fn get_outlier_pdu_json(&self, event_id: &EventId) -> Result<Option<CanonicalJsonObject>> {
+    pub(crate) fn get_outlier_pdu_json(
+        &self,
+        event_id: &EventId,
+    ) -> Result<Option<CanonicalJsonObject>> {
         self.db.get_outlier_pdu_json(event_id)
     }
 
     /// Returns the pdu from the outlier tree.
-    pub fn get_pdu_outlier(&self, event_id: &EventId) -> Result<Option<PduEvent>> {
+    pub(crate) fn get_pdu_outlier(&self, event_id: &EventId) -> Result<Option<PduEvent>> {
         self.db.get_outlier_pdu(event_id)
     }
 
     /// Append the PDU as an outlier.
     #[tracing::instrument(skip(self, pdu))]
-    pub fn add_pdu_outlier(&self, event_id: &EventId, pdu: &CanonicalJsonObject) -> Result<()> {
+    pub(crate) fn add_pdu_outlier(
+        &self,
+        event_id: &EventId,
+        pdu: &CanonicalJsonObject,
+    ) -> Result<()> {
         self.db.add_pdu_outlier(event_id, pdu)
     }
 }

src/service/rooms/outlier/data.rs

@@ -2,7 +2,7 @@ use ruma::{CanonicalJsonObject, EventId};
 
 use crate::{PduEvent, Result};
 
-pub trait Data: Send + Sync {
+pub(crate) trait Data: Send + Sync {
     fn get_outlier_pdu_json(&self, event_id: &EventId) -> Result<Option<CanonicalJsonObject>>;
     fn get_outlier_pdu(&self, event_id: &EventId) -> Result<Option<PduEvent>>;
     fn add_pdu_outlier(&self, event_id: &EventId, pdu: &CanonicalJsonObject) -> Result<()>;

src/service/rooms/pdu_metadata.rs

@@ -1,7 +1,7 @@
 mod data;
 use std::sync::Arc;
 
-pub use data::Data;
+pub(crate) use data::Data;
 use ruma::{
     api::client::relations::get_relating_events,
     events::{relation::RelationType, TimelineEventType},
@@ -13,8 +13,8 @@ use crate::{services, PduEvent, Result};
 
 use super::timeline::PduCount;
 
-pub struct Service {
-    pub db: &'static dyn Data,
+pub(crate) struct Service {
+    pub(crate) db: &'static dyn Data,
 }
 
 #[derive(Clone, Debug, Deserialize)]
@@ -29,7 +29,7 @@ struct ExtractRelatesToEventId {
 
 impl Service {
     #[tracing::instrument(skip(self, from, to))]
-    pub fn add_relation(&self, from: PduCount, to: PduCount) -> Result<()> {
+    pub(crate) fn add_relation(&self, from: PduCount, to: PduCount) -> Result<()> {
         match (from, to) {
             (PduCount::Normal(f), PduCount::Normal(t)) => self.db.add_relation(f, t),
             _ => {
@@ -41,7 +41,7 @@ impl Service {
     }
 
     #[allow(clippy::too_many_arguments)]
-    pub fn paginate_relations_with_filter(
+    pub(crate) fn paginate_relations_with_filter(
         &self,
         sender_user: &UserId,
         room_id: &RoomId,
@@ -152,7 +152,7 @@ impl Service {
         }
     }
 
-    pub fn relations_until<'a>(
+    pub(crate) fn relations_until<'a>(
         &'a self,
         user_id: &'a UserId,
         room_id: &'a RoomId,
@@ -169,22 +169,26 @@ impl Service {
     }
 
     #[tracing::instrument(skip(self, room_id, event_ids))]
-    pub fn mark_as_referenced(&self, room_id: &RoomId, event_ids: &[Arc<EventId>]) -> Result<()> {
+    pub(crate) fn mark_as_referenced(
+        &self,
+        room_id: &RoomId,
+        event_ids: &[Arc<EventId>],
+    ) -> Result<()> {
         self.db.mark_as_referenced(room_id, event_ids)
     }
 
     #[tracing::instrument(skip(self))]
-    pub fn is_event_referenced(&self, room_id: &RoomId, event_id: &EventId) -> Result<bool> {
+    pub(crate) fn is_event_referenced(&self, room_id: &RoomId, event_id: &EventId) -> Result<bool> {
         self.db.is_event_referenced(room_id, event_id)
     }
 
     #[tracing::instrument(skip(self))]
-    pub fn mark_event_soft_failed(&self, event_id: &EventId) -> Result<()> {
+    pub(crate) fn mark_event_soft_failed(&self, event_id: &EventId) -> Result<()> {
         self.db.mark_event_soft_failed(event_id)
     }
 
     #[tracing::instrument(skip(self))]
-    pub fn is_event_soft_failed(&self, event_id: &EventId) -> Result<bool> {
+    pub(crate) fn is_event_soft_failed(&self, event_id: &EventId) -> Result<bool> {
         self.db.is_event_soft_failed(event_id)
     }
 }

src/service/rooms/pdu_metadata/data.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use crate::{service::rooms::timeline::PduCount, PduEvent, Result};
 use ruma::{EventId, RoomId, UserId};
 
-pub trait Data: Send + Sync {
+pub(crate) trait Data: Send + Sync {
     fn add_relation(&self, from: u64, to: u64) -> Result<()>;
     #[allow(clippy::type_complexity)]
     fn relations_until<'a>(

src/service/rooms/search.rs

@@ -1,22 +1,27 @@
 mod data;
 
-pub use data::Data;
+pub(crate) use data::Data;
 
 use crate::Result;
 use ruma::RoomId;
 
-pub struct Service {
-    pub db: &'static dyn Data,
+pub(crate) struct Service {
+    pub(crate) db: &'static dyn Data,
 }
 
 impl Service {
     #[tracing::instrument(skip(self))]
-    pub fn index_pdu<'a>(&self, shortroomid: u64, pdu_id: &[u8], message_body: &str) -> Result<()> {
+    pub(crate) fn index_pdu<'a>(
+        &self,
+        shortroomid: u64,
+        pdu_id: &[u8],
+        message_body: &str,
+    ) -> Result<()> {
         self.db.index_pdu(shortroomid, pdu_id, message_body)
     }
 
     #[tracing::instrument(skip(self))]
-    pub fn search_pdus<'a>(
+    pub(crate) fn search_pdus<'a>(
         &'a self,
         room_id: &RoomId,
         search_string: &str,

src/service/rooms/search/data.rs

@@ -1,7 +1,7 @@
 use crate::Result;
 use ruma::RoomId;
 
-pub trait Data: Send + Sync {
+pub(crate) trait Data: Send + Sync {
     fn index_pdu(&self, shortroomid: u64, pdu_id: &[u8], message_body: &str) -> Result<()>;
 
     #[allow(clippy::type_complexity)]

src/service/rooms/short.rs

@@ -1,21 +1,21 @@
 mod data;
 use std::sync::Arc;
 
-pub use data::Data;
+pub(crate) use data::Data;
 use ruma::{events::StateEventType, EventId, RoomId};
 
 use crate::Result;
 
-pub struct Service {
-    pub db: &'static dyn Data,
+pub(crate) struct Service {
+    pub(crate) db: &'static dyn Data,
 }
 
 impl Service {
-    pub fn get_or_create_shorteventid(&self, event_id: &EventId) -> Result<u64> {
+    pub(crate) fn get_or_create_shorteventid(&self, event_id: &EventId) -> Result<u64> {
         self.db.get_or_create_shorteventid(event_id)
     }
 
-    pub fn get_shortstatekey(
+    pub(crate) fn get_shortstatekey(
         &self,
         event_type: &StateEventType,
         state_key: &str,
@@ -23,7 +23,7 @@ impl Service {
         self.db.get_shortstatekey(event_type, state_key)
     }
 
-    pub fn get_or_create_shortstatekey(
+    pub(crate) fn get_or_create_shortstatekey(
         &self,
         event_type: &StateEventType,
         state_key: &str,
@@ -31,24 +31,27 @@ impl Service {
         self.db.get_or_create_shortstatekey(event_type, state_key)
     }
 
-    pub fn get_eventid_from_short(&self, shorteventid: u64) -> Result<Arc<EventId>> {
+    pub(crate) fn get_eventid_from_short(&self, shorteventid: u64) -> Result<Arc<EventId>> {
         self.db.get_eventid_from_short(shorteventid)
     }
 
-    pub fn get_statekey_from_short(&self, shortstatekey: u64) -> Result<(StateEventType, String)> {
+    pub(crate) fn get_statekey_from_short(
+        &self,
+        shortstatekey: u64,
+    ) -> Result<(StateEventType, String)> {
         self.db.get_statekey_from_short(shortstatekey)
     }
 
     /// Returns (shortstatehash, already_existed)
-    pub fn get_or_create_shortstatehash(&self, state_hash: &[u8]) -> Result<(u64, bool)> {
+    pub(crate) fn get_or_create_shortstatehash(&self, state_hash: &[u8]) -> Result<(u64, bool)> {
         self.db.get_or_create_shortstatehash(state_hash)
     }
 
-    pub fn get_shortroomid(&self, room_id: &RoomId) -> Result<Option<u64>> {
+    pub(crate) fn get_shortroomid(&self, room_id: &RoomId) -> Result<Option<u64>> {
         self.db.get_shortroomid(room_id)
     }
 
-    pub fn get_or_create_shortroomid(&self, room_id: &RoomId) -> Result<u64> {
+    pub(crate) fn get_or_create_shortroomid(&self, room_id: &RoomId) -> Result<u64> {
         self.db.get_or_create_shortroomid(room_id)
     }
 }

src/service/rooms/short/data.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use crate::Result;
 use ruma::{events::StateEventType, EventId, RoomId};
 
-pub trait Data: Send + Sync {
+pub(crate) trait Data: Send + Sync {
     fn get_or_create_shorteventid(&self, event_id: &EventId) -> Result<u64>;
 
     fn get_shortstatekey(

src/service/rooms/spaces.rs

@@ -31,23 +31,23 @@ use tracing::{debug, error, warn};
 
 use crate::{services, Error, PduEvent, Result};
 
-pub enum CachedJoinRule {
+pub(crate) enum CachedJoinRule {
     //Simplified(SpaceRoomJoinRule),
     Full(JoinRule),
 }
 
-pub struct CachedSpaceChunk {
+pub(crate) struct CachedSpaceChunk {
     chunk: SpaceHierarchyRoomsChunk,
     children: Vec<OwnedRoomId>,
     join_rule: CachedJoinRule,
 }
 
-pub struct Service {
-    pub roomid_spacechunk_cache: Mutex<LruCache<OwnedRoomId, Option<CachedSpaceChunk>>>,
+pub(crate) struct Service {
+    pub(crate) roomid_spacechunk_cache: Mutex<LruCache<OwnedRoomId, Option<CachedSpaceChunk>>>,
 }
 
 impl Service {
-    pub async fn get_hierarchy(
+    pub(crate) async fn get_hierarchy(
         &self,
         sender_user: &UserId,
         room_id: &RoomId,

src/service/rooms/state.rs

@@ -4,7 +4,7 @@ use std::{
     sync::Arc,
 };
 
-pub use data::Data;
+pub(crate) use data::Data;
 use ruma::{
     api::client::error::ErrorKind,
     events::{
@@ -23,13 +23,13 @@ use crate::{services, utils::calculate_hash, Error, PduEvent, Result};
 
 use super::state_compressor::CompressedStateEvent;
 
-pub struct Service {
-    pub db: &'static dyn Data,
+pub(crate) struct Service {
+    pub(crate) db: &'static dyn Data,
 }
 
 impl Service {
     /// Set the room to the given statehash and update caches.
-    pub async fn force_state(
+    pub(crate) async fn force_state(
         &self,
         room_id: &RoomId,
         shortstatehash: u64,
@@ -115,7 +115,7 @@ impl Service {
     /// This adds all current state events (not including the incoming event)
     /// to `stateid_pduid` and adds the incoming event to `eventid_statehash`.
     #[tracing::instrument(skip(self, state_ids_compressed))]
-    pub fn set_event_state(
+    pub(crate) fn set_event_state(
         &self,
         event_id: &EventId,
         room_id: &RoomId,
@@ -187,7 +187,7 @@ impl Service {
     /// This adds all current state events (not including the incoming event)
     /// to `stateid_pduid` and adds the incoming event to `eventid_statehash`.
     #[tracing::instrument(skip(self, new_pdu))]
-    pub fn append_to_state(&self, new_pdu: &PduEvent) -> Result<u64> {
+    pub(crate) fn append_to_state(&self, new_pdu: &PduEvent) -> Result<u64> {
         let shorteventid = services()
             .rooms
             .short
@@ -259,7 +259,7 @@ impl Service {
     }
 
     #[tracing::instrument(skip(self, invite_event))]
-    pub fn calculate_invite_state(
+    pub(crate) fn calculate_invite_state(
         &self,
         invite_event: &PduEvent,
     ) -> Result<Vec<Raw<AnyStrippedStateEvent>>> {
@@ -314,7 +314,7 @@ impl Service {
 
     /// Set the state hash to a new version, but does not update state_cache.
     #[tracing::instrument(skip(self))]
-    pub fn set_room_state(
+    pub(crate) fn set_room_state(
         &self,
         room_id: &RoomId,
         shortstatehash: u64,
@@ -325,7 +325,7 @@ impl Service {
 
     /// Returns the room's version.
     #[tracing::instrument(skip(self))]
-    pub fn get_room_version(&self, room_id: &RoomId) -> Result<RoomVersionId> {
+    pub(crate) fn get_room_version(&self, room_id: &RoomId) -> Result<RoomVersionId> {
         let create_event = services().rooms.state_accessor.room_state_get(
             room_id,
             &StateEventType::RoomCreate,
@@ -346,15 +346,18 @@ impl Service {
         Ok(create_event_content.room_version)
     }
 
-    pub fn get_room_shortstatehash(&self, room_id: &RoomId) -> Result<Option<u64>> {
+    pub(crate) fn get_room_shortstatehash(&self, room_id: &RoomId) -> Result<Option<u64>> {
         self.db.get_room_shortstatehash(room_id)
     }
 
-    pub fn get_forward_extremities(&self, room_id: &RoomId) -> Result<HashSet<Arc<EventId>>> {
+    pub(crate) fn get_forward_extremities(
+        &self,
+        room_id: &RoomId,
+    ) -> Result<HashSet<Arc<EventId>>> {
         self.db.get_forward_extremities(room_id)
     }
 
-    pub fn set_forward_extremities(
+    pub(crate) fn set_forward_extremities(
         &self,
         room_id: &RoomId,
         event_ids: Vec<OwnedEventId>,
@@ -366,7 +369,7 @@ impl Service {
 
     /// This fetches auth events from the current state.
     #[tracing::instrument(skip(self))]
-    pub fn get_auth_events(
+    pub(crate) fn get_auth_events(
         &self,
         room_id: &RoomId,
         kind: &TimelineEventType,

src/service/rooms/state/data.rs

@@ -3,7 +3,7 @@ use ruma::{EventId, OwnedEventId, RoomId};
 use std::{collections::HashSet, sync::Arc};
 use tokio::sync::MutexGuard;
 
-pub trait Data: Send + Sync {
+pub(crate) trait Data: Send + Sync {
     /// Returns the last state hash key added to the db for the given room.
     fn get_room_shortstatehash(&self, room_id: &RoomId) -> Result<Option<u64>>;
 

src/service/rooms/state_accessor.rs

@@ -4,7 +4,7 @@ use std::{
     sync::{Arc, Mutex},
 };
 
-pub use data::Data;
+pub(crate) use data::Data;
 use lru_cache::LruCache;
 use ruma::{
     events::{
@@ -26,21 +26,24 @@ use tracing::{error, warn};
 
 use crate::{service::pdu::PduBuilder, services, Error, PduEvent, Result};
 
-pub struct Service {
-    pub db: &'static dyn Data,
-    pub server_visibility_cache: Mutex<LruCache<(OwnedServerName, u64), bool>>,
-    pub user_visibility_cache: Mutex<LruCache<(OwnedUserId, u64), bool>>,
+pub(crate) struct Service {
+    pub(crate) db: &'static dyn Data,
+    pub(crate) server_visibility_cache: Mutex<LruCache<(OwnedServerName, u64), bool>>,
+    pub(crate) user_visibility_cache: Mutex<LruCache<(OwnedUserId, u64), bool>>,
 }
 
 impl Service {
     /// Builds a StateMap by iterating over all keys that start
     /// with state_hash, this gives the full state for the given state_hash.
     #[tracing::instrument(skip(self))]
-    pub async fn state_full_ids(&self, shortstatehash: u64) -> Result<HashMap<u64, Arc<EventId>>> {
+    pub(crate) async fn state_full_ids(
+        &self,
+        shortstatehash: u64,
+    ) -> Result<HashMap<u64, Arc<EventId>>> {
         self.db.state_full_ids(shortstatehash).await
     }
 
-    pub async fn state_full(
+    pub(crate) async fn state_full(
         &self,
         shortstatehash: u64,
     ) -> Result<HashMap<(StateEventType, String), Arc<PduEvent>>> {
@@ -49,7 +52,7 @@ impl Service {
 
     /// Returns a single PDU from `room_id` with key (`event_type`, `state_key`).
     #[tracing::instrument(skip(self))]
-    pub fn state_get_id(
+    pub(crate) fn state_get_id(
         &self,
         shortstatehash: u64,
         event_type: &StateEventType,
@@ -59,7 +62,7 @@ impl Service {
     }
 
     /// Returns a single PDU from `room_id` with key (`event_type`, `state_key`).
-    pub fn state_get(
+    pub(crate) fn state_get(
         &self,
         shortstatehash: u64,
         event_type: &StateEventType,
@@ -100,7 +103,7 @@ impl Service {
     /// Whether a server is allowed to see an event through federation, based on
     /// the room's history_visibility at that event's state.
     #[tracing::instrument(skip(self, origin, room_id, event_id))]
-    pub fn server_can_see_event(
+    pub(crate) fn server_can_see_event(
         &self,
         origin: &ServerName,
         room_id: &RoomId,
@@ -164,7 +167,7 @@ impl Service {
     /// Whether a user is allowed to see an event, based on
     /// the room's history_visibility at that event's state.
     #[tracing::instrument(skip(self, user_id, room_id, event_id))]
-    pub fn user_can_see_event(
+    pub(crate) fn user_can_see_event(
         &self,
         user_id: &UserId,
         room_id: &RoomId,
@@ -224,7 +227,11 @@ impl Service {
     /// Whether a user is allowed to see an event, based on
     /// the room's history_visibility at that event's state.
     #[tracing::instrument(skip(self, user_id, room_id))]
-    pub fn user_can_see_state_events(&self, user_id: &UserId, room_id: &RoomId) -> Result<bool> {
+    pub(crate) fn user_can_see_state_events(
+        &self,
+        user_id: &UserId,
+        room_id: &RoomId,
+    ) -> Result<bool> {
         let currently_member = services().rooms.state_cache.is_joined(user_id, room_id)?;
 
         let history_visibility = self
@@ -241,13 +248,13 @@ impl Service {
     }
 
     /// Returns the state hash for this pdu.
-    pub fn pdu_shortstatehash(&self, event_id: &EventId) -> Result<Option<u64>> {
+    pub(crate) fn pdu_shortstatehash(&self, event_id: &EventId) -> Result<Option<u64>> {
         self.db.pdu_shortstatehash(event_id)
     }
 
     /// Returns the full room state.
     #[tracing::instrument(skip(self))]
-    pub async fn room_state_full(
+    pub(crate) async fn room_state_full(
         &self,
         room_id: &RoomId,
     ) -> Result<HashMap<(StateEventType, String), Arc<PduEvent>>> {
@@ -256,7 +263,7 @@ impl Service {
 
     /// Returns a single PDU from `room_id` with key (`event_type`, `state_key`).
     #[tracing::instrument(skip(self))]
-    pub fn room_state_get_id(
+    pub(crate) fn room_state_get_id(
         &self,
         room_id: &RoomId,
         event_type: &StateEventType,
@@ -267,7 +274,7 @@ impl Service {
 
     /// Returns a single PDU from `room_id` with key (`event_type`, `state_key`).
     #[tracing::instrument(skip(self))]
-    pub fn room_state_get(
+    pub(crate) fn room_state_get(
         &self,
         room_id: &RoomId,
         event_type: &StateEventType,
@@ -276,7 +283,7 @@ impl Service {
         self.db.room_state_get(room_id, event_type, state_key)
     }
 
-    pub fn get_name(&self, room_id: &RoomId) -> Result<Option<String>> {
+    pub(crate) fn get_name(&self, room_id: &RoomId) -> Result<Option<String>> {
         services()
             .rooms
             .state_accessor
@@ -294,7 +301,7 @@ impl Service {
             })
     }
 
-    pub fn get_avatar(&self, room_id: &RoomId) -> Result<JsOption<RoomAvatarEventContent>> {
+    pub(crate) fn get_avatar(&self, room_id: &RoomId) -> Result<JsOption<RoomAvatarEventContent>> {
         services()
             .rooms
             .state_accessor
@@ -305,7 +312,7 @@ impl Service {
             })
     }
 
-    pub async fn user_can_invite(
+    pub(crate) async fn user_can_invite(
         &self,
         room_id: &RoomId,
         sender: &UserId,
@@ -330,7 +337,7 @@ impl Service {
             .is_ok())
     }
 
-    pub fn get_member(
+    pub(crate) fn get_member(
         &self,
         room_id: &RoomId,
         user_id: &UserId,
@@ -350,7 +357,7 @@ impl Service {
     /// If `federation` is `true`, it allows redaction events from any user of the same server
     /// as the original event sender, [as required by room versions >=
     /// v3](https://spec.matrix.org/v1.10/rooms/v11/#handling-redactions)
-    pub fn user_can_redact(
+    pub(crate) fn user_can_redact(
         &self,
         redacts: &EventId,
         sender: &UserId,

src/service/rooms/state_accessor/data.rs

@@ -6,7 +6,7 @@ use ruma::{events::StateEventType, EventId, RoomId};
 use crate::{PduEvent, Result};
 
 #[async_trait]
-pub trait Data: Send + Sync {
+pub(crate) trait Data: Send + Sync {
     /// Builds a StateMap by iterating over all keys that start
     /// with state_hash, this gives the full state for the given state_hash.
     async fn state_full_ids(&self, shortstatehash: u64) -> Result<HashMap<u64, Arc<EventId>>>;

src/service/rooms/state_cache.rs

@@ -1,7 +1,7 @@
 mod data;
 use std::{collections::HashSet, sync::Arc};
 
-pub use data::Data;
+pub(crate) use data::Data;
 
 use ruma::{
     events::{
@@ -18,14 +18,14 @@ use tracing::warn;
 
 use crate::{service::appservice::RegistrationInfo, services, Error, Result};
 
-pub struct Service {
-    pub db: &'static dyn Data,
+pub(crate) struct Service {
+    pub(crate) db: &'static dyn Data,
 }
 
 impl Service {
     /// Update current membership data.
     #[tracing::instrument(skip(self, last_state))]
-    pub fn update_membership(
+    pub(crate) fn update_membership(
         &self,
         room_id: &RoomId,
         user_id: &UserId,
@@ -192,17 +192,17 @@ impl Service {
     }
 
     #[tracing::instrument(skip(self, room_id))]
-    pub fn update_joined_count(&self, room_id: &RoomId) -> Result<()> {
+    pub(crate) fn update_joined_count(&self, room_id: &RoomId) -> Result<()> {
         self.db.update_joined_count(room_id)
     }
 
     #[tracing::instrument(skip(self, room_id))]
-    pub fn get_our_real_users(&self, room_id: &RoomId) -> Result<Arc<HashSet<OwnedUserId>>> {
+    pub(crate) fn get_our_real_users(&self, room_id: &RoomId) -> Result<Arc<HashSet<OwnedUserId>>> {
         self.db.get_our_real_users(room_id)
     }
 
     #[tracing::instrument(skip(self, room_id, appservice))]
-    pub fn appservice_in_room(
+    pub(crate) fn appservice_in_room(
         &self,
         room_id: &RoomId,
         appservice: &RegistrationInfo,
@@ -212,13 +212,13 @@ impl Service {
 
     /// Makes a user forget a room.
     #[tracing::instrument(skip(self))]
-    pub fn forget(&self, room_id: &RoomId, user_id: &UserId) -> Result<()> {
+    pub(crate) fn forget(&self, room_id: &RoomId, user_id: &UserId) -> Result<()> {
         self.db.forget(room_id, user_id)
     }
 
     /// Returns an iterator of all servers participating in this room.
     #[tracing::instrument(skip(self))]
-    pub fn room_servers<'a>(
+    pub(crate) fn room_servers<'a>(
         &'a self,
         room_id: &RoomId,
     ) -> impl Iterator<Item = Result<OwnedServerName>> + 'a {
@@ -226,13 +226,17 @@ impl Service {
     }
 
     #[tracing::instrument(skip(self))]
-    pub fn server_in_room<'a>(&'a self, server: &ServerName, room_id: &RoomId) -> Result<bool> {
+    pub(crate) fn server_in_room<'a>(
+        &'a self,
+        server: &ServerName,
+        room_id: &RoomId,
+    ) -> Result<bool> {
         self.db.server_in_room(server, room_id)
     }
 
     /// Returns an iterator of all rooms a server participates in (as far as we know).
     #[tracing::instrument(skip(self))]
-    pub fn server_rooms<'a>(
+    pub(crate) fn server_rooms<'a>(
         &'a self,
         server: &ServerName,
     ) -> impl Iterator<Item = Result<OwnedRoomId>> + 'a {
@@ -241,7 +245,7 @@ impl Service {
 
     /// Returns an iterator over all joined members of a room.
     #[tracing::instrument(skip(self))]
-    pub fn room_members<'a>(
+    pub(crate) fn room_members<'a>(
         &'a self,
         room_id: &RoomId,
     ) -> impl Iterator<Item = Result<OwnedUserId>> + 'a {
@@ -249,18 +253,18 @@ impl Service {
     }
 
     #[tracing::instrument(skip(self))]
-    pub fn room_joined_count(&self, room_id: &RoomId) -> Result<Option<u64>> {
+    pub(crate) fn room_joined_count(&self, room_id: &RoomId) -> Result<Option<u64>> {
         self.db.room_joined_count(room_id)
     }
 
     #[tracing::instrument(skip(self))]
-    pub fn room_invited_count(&self, room_id: &RoomId) -> Result<Option<u64>> {
+    pub(crate) fn room_invited_count(&self, room_id: &RoomId) -> Result<Option<u64>> {
         self.db.room_invited_count(room_id)
     }
 
     /// Returns an iterator over all User IDs who ever joined a room.
     #[tracing::instrument(skip(self))]
-    pub fn room_useroncejoined<'a>(
+    pub(crate) fn room_useroncejoined<'a>(
         &'a self,
         room_id: &RoomId,
     ) -> impl Iterator<Item = Result<OwnedUserId>> + 'a {
@@ -269,7 +273,7 @@ impl Service {
 
     /// Returns an iterator over all invited members of a room.
     #[tracing::instrument(skip(self))]
-    pub fn room_members_invited<'a>(
+    pub(crate) fn room_members_invited<'a>(
         &'a self,
         room_id: &RoomId,
     ) -> impl Iterator<Item = Result<OwnedUserId>> + 'a {
@@ -277,18 +281,22 @@ impl Service {
     }
 
     #[tracing::instrument(skip(self))]
-    pub fn get_invite_count(&self, room_id: &RoomId, user_id: &UserId) -> Result<Option<u64>> {
+    pub(crate) fn get_invite_count(
+        &self,
+        room_id: &RoomId,
+        user_id: &UserId,
+    ) -> Result<Option<u64>> {
         self.db.get_invite_count(room_id, user_id)
     }
 
     #[tracing::instrument(skip(self))]
-    pub fn get_left_count(&self, room_id: &RoomId, user_id: &UserId) -> Result<Option<u64>> {
+    pub(crate) fn get_left_count(&self, room_id: &RoomId, user_id: &UserId) -> Result<Option<u64>> {
         self.db.get_left_count(room_id, user_id)
     }
 
     /// Returns an iterator over all rooms this user joined.
     #[tracing::instrument(skip(self))]
-    pub fn rooms_joined<'a>(
+    pub(crate) fn rooms_joined<'a>(
         &'a self,
         user_id: &UserId,
     ) -> impl Iterator<Item = Result<OwnedRoomId>> + 'a {
@@ -297,7 +305,7 @@ impl Service {
 
     /// Returns an iterator over all rooms a user was invited to.
     #[tracing::instrument(skip(self))]
-    pub fn rooms_invited<'a>(
+    pub(crate) fn rooms_invited<'a>(
         &'a self,
         user_id: &UserId,
     ) -> impl Iterator<Item = Result<(OwnedRoomId, Vec<Raw<AnyStrippedStateEvent>>)>> + 'a {
@@ -305,7 +313,7 @@ impl Service {
     }
 
     #[tracing::instrument(skip(self))]
-    pub fn invite_state(
+    pub(crate) fn invite_state(
         &self,
         user_id: &UserId,
         room_id: &RoomId,
@@ -314,7 +322,7 @@ impl Service {
     }
 
     #[tracing::instrument(skip(self))]
-    pub fn left_state(
+    pub(crate) fn left_state(
         &self,
         user_id: &UserId,
         room_id: &RoomId,
@@ -324,7 +332,7 @@ impl Service {
 
     /// Returns an iterator over all rooms a user left.
     #[tracing::instrument(skip(self))]
-    pub fn rooms_left<'a>(
+    pub(crate) fn rooms_left<'a>(
         &'a self,
         user_id: &UserId,
     ) -> impl Iterator<Item = Result<(OwnedRoomId, Vec<Raw<AnySyncStateEvent>>)>> + 'a {
@@ -332,22 +340,22 @@ impl Service {
     }
 
     #[tracing::instrument(skip(self))]
-    pub fn once_joined(&self, user_id: &UserId, room_id: &RoomId) -> Result<bool> {
+    pub(crate) fn once_joined(&self, user_id: &UserId, room_id: &RoomId) -> Result<bool> {
         self.db.once_joined(user_id, room_id)
     }
 
     #[tracing::instrument(skip(self))]
-    pub fn is_joined(&self, user_id: &UserId, room_id: &RoomId) -> Result<bool> {
+    pub(crate) fn is_joined(&self, user_id: &UserId, room_id: &RoomId) -> Result<bool> {
         self.db.is_joined(user_id, room_id)
     }
 
     #[tracing::instrument(skip(self))]
-    pub fn is_invited(&self, user_id: &UserId, room_id: &RoomId) -> Result<bool> {
+    pub(crate) fn is_invited(&self, user_id: &UserId, room_id: &RoomId) -> Result<bool> {
         self.db.is_invited(user_id, room_id)
     }
 
     #[tracing::instrument(skip(self))]
-    pub fn is_left(&self, user_id: &UserId, room_id: &RoomId) -> Result<bool> {
+    pub(crate) fn is_left(&self, user_id: &UserId, room_id: &RoomId) -> Result<bool> {
         self.db.is_left(user_id, room_id)
     }
 }

src/service/rooms/state_cache/data.rs

@@ -7,7 +7,7 @@ use ruma::{
     OwnedRoomId, OwnedServerName, OwnedUserId, RoomId, ServerName, UserId,
 };
 
-pub trait Data: Send + Sync {
+pub(crate) trait Data: Send + Sync {
     fn mark_as_once_joined(&self, user_id: &UserId, room_id: &RoomId) -> Result<()>;
     fn mark_as_joined(&self, user_id: &UserId, room_id: &RoomId) -> Result<()>;
     fn mark_as_invited(

src/service/rooms/state_compressor.rs

@@ -1,11 +1,11 @@
-pub mod data;
+pub(crate) mod data;
 use std::{
     collections::HashSet,
     mem::size_of,
     sync::{Arc, Mutex},
 };
 
-pub use data::Data;
+pub(crate) use data::Data;
 use lru_cache::LruCache;
 use ruma::{EventId, RoomId};
 
@@ -13,11 +13,11 @@ use crate::{services, utils, Result};
 
 use self::data::StateDiff;
 
-pub struct Service {
-    pub db: &'static dyn Data,
+pub(crate) struct Service {
+    pub(crate) db: &'static dyn Data,
 
     #[allow(clippy::type_complexity)]
-    pub stateinfo_cache: Mutex<
+    pub(crate) stateinfo_cache: Mutex<
         LruCache<
             u64,
             Vec<(
@@ -30,13 +30,13 @@ pub struct Service {
     >,
 }
 
-pub type CompressedStateEvent = [u8; 2 * size_of::<u64>()];
+pub(crate) type CompressedStateEvent = [u8; 2 * size_of::<u64>()];
 
 impl Service {
     /// Returns a stack with info on shortstatehash, full state, added diff and removed diff for the selected shortstatehash and each parent layer.
     #[allow(clippy::type_complexity)]
     #[tracing::instrument(skip(self))]
-    pub fn load_shortstatehash_info(
+    pub(crate) fn load_shortstatehash_info(
         &self,
         shortstatehash: u64,
     ) -> Result<
@@ -89,7 +89,7 @@ impl Service {
         }
     }
 
-    pub fn compress_state_event(
+    pub(crate) fn compress_state_event(
         &self,
         shortstatekey: u64,
         event_id: &EventId,
@@ -106,7 +106,7 @@ impl Service {
     }
 
     /// Returns shortstatekey, event id
-    pub fn parse_compressed_state_event(
+    pub(crate) fn parse_compressed_state_event(
         &self,
         compressed_event: &CompressedStateEvent,
     ) -> Result<(u64, Arc<EventId>)> {
@@ -141,7 +141,7 @@ impl Service {
         diff_to_sibling,
         parent_states
     ))]
-    pub fn save_state_from_diff(
+    pub(crate) fn save_state_from_diff(
         &self,
         shortstatehash: u64,
         statediffnew: Arc<HashSet<CompressedStateEvent>>,
@@ -257,7 +257,7 @@ impl Service {
 
     /// Returns the new shortstatehash, and the state diff from the previous room state
     #[allow(clippy::type_complexity)]
-    pub fn save_state(
+    pub(crate) fn save_state(
         &self,
         room_id: &RoomId,
         new_state_ids_compressed: Arc<HashSet<CompressedStateEvent>>,

src/service/rooms/state_compressor/data.rs

@@ -3,13 +3,13 @@ use std::{collections::HashSet, sync::Arc};
 use super::CompressedStateEvent;
 use crate::Result;
 
-pub struct StateDiff {
-    pub parent: Option<u64>,
-    pub added: Arc<HashSet<CompressedStateEvent>>,
-    pub removed: Arc<HashSet<CompressedStateEvent>>,
+pub(crate) struct StateDiff {
+    pub(crate) parent: Option<u64>,
+    pub(crate) added: Arc<HashSet<CompressedStateEvent>>,
+    pub(crate) removed: Arc<HashSet<CompressedStateEvent>>,
 }
 
-pub trait Data: Send + Sync {
+pub(crate) trait Data: Send + Sync {
     fn get_statediff(&self, shortstatehash: u64) -> Result<StateDiff>;
     fn save_statediff(&self, shortstatehash: u64, diff: StateDiff) -> Result<()>;
 }

src/service/rooms/threads.rs

@@ -1,6 +1,6 @@
 mod data;
 
-pub use data::Data;
+pub(crate) use data::Data;
 use ruma::{
     api::client::{error::ErrorKind, threads::get_threads::v1::IncludeThreads},
     events::relation::BundledThread,
@@ -11,12 +11,12 @@ use serde_json::json;
 
 use crate::{services, Error, PduEvent, Result};
 
-pub struct Service {
-    pub db: &'static dyn Data,
+pub(crate) struct Service {
+    pub(crate) db: &'static dyn Data,
 }
 
 impl Service {
-    pub fn threads_until<'a>(
+    pub(crate) fn threads_until<'a>(
         &'a self,
         user_id: &'a UserId,
         room_id: &'a RoomId,
@@ -26,7 +26,7 @@ impl Service {
         self.db.threads_until(user_id, room_id, until, include)
     }
 
-    pub fn add_to_thread(&self, root_event_id: &EventId, pdu: &PduEvent) -> Result<()> {
+    pub(crate) fn add_to_thread(&self, root_event_id: &EventId, pdu: &PduEvent) -> Result<()> {
         let root_id = &services()
             .rooms
             .timeline

src/service/rooms/threads/data.rs

@@ -1,7 +1,7 @@
 use crate::{PduEvent, Result};
 use ruma::{api::client::threads::get_threads::v1::IncludeThreads, OwnedUserId, RoomId, UserId};
 
-pub trait Data: Send + Sync {
+pub(crate) trait Data: Send + Sync {
     #[allow(clippy::type_complexity)]
     fn threads_until<'a>(
         &'a self,

src/service/rooms/timeline.rs

@@ -6,7 +6,7 @@ use std::{
     sync::Arc,
 };
 
-pub use data::Data;
+pub(crate) use data::Data;
 
 use ruma::{
     api::{client::error::ErrorKind, federation},
@@ -42,20 +42,20 @@ use crate::{
 use super::state_compressor::CompressedStateEvent;
 
 #[derive(Hash, PartialEq, Eq, Clone, Copy, Debug)]
-pub enum PduCount {
+pub(crate) enum PduCount {
     Backfilled(u64),
     Normal(u64),
 }
 
 impl PduCount {
-    pub fn min() -> Self {
+    pub(crate) fn min() -> Self {
         Self::Backfilled(u64::MAX)
     }
-    pub fn max() -> Self {
+    pub(crate) fn max() -> Self {
         Self::Normal(u64::MAX)
     }
 
-    pub fn try_from_string(token: &str) -> Result<Self> {
+    pub(crate) fn try_from_string(token: &str) -> Result<Self> {
         if let Some(stripped) = token.strip_prefix('-') {
             stripped.parse().map(PduCount::Backfilled)
         } else {
@@ -64,7 +64,7 @@ impl PduCount {
         .map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Invalid pagination token."))
     }
 
-    pub fn stringify(&self) -> String {
+    pub(crate) fn stringify(&self) -> String {
         match self {
             PduCount::Backfilled(x) => format!("-{x}"),
             PduCount::Normal(x) => x.to_string(),
@@ -89,15 +89,15 @@ impl Ord for PduCount {
     }
 }
 
-pub struct Service {
-    pub db: &'static dyn Data,
+pub(crate) struct Service {
+    pub(crate) db: &'static dyn Data,
 
-    pub lasttimelinecount_cache: Mutex<HashMap<OwnedRoomId, PduCount>>,
+    pub(crate) lasttimelinecount_cache: Mutex<HashMap<OwnedRoomId, PduCount>>,
 }
 
 impl Service {
     #[tracing::instrument(skip(self))]
-    pub fn first_pdu_in_room(&self, room_id: &RoomId) -> Result<Option<Arc<PduEvent>>> {
+    pub(crate) fn first_pdu_in_room(&self, room_id: &RoomId) -> Result<Option<Arc<PduEvent>>> {
         self.all_pdus(user_id!("@doesntmatter:grapevine"), room_id)?
             .next()
             .map(|o| o.map(|(_, p)| Arc::new(p)))
@@ -105,19 +105,23 @@ impl Service {
     }
 
     #[tracing::instrument(skip(self))]
-    pub fn last_timeline_count(&self, sender_user: &UserId, room_id: &RoomId) -> Result<PduCount> {
+    pub(crate) fn last_timeline_count(
+        &self,
+        sender_user: &UserId,
+        room_id: &RoomId,
+    ) -> Result<PduCount> {
         self.db.last_timeline_count(sender_user, room_id)
     }
 
     /// Returns the `count` of this pdu's id.
-    pub fn get_pdu_count(&self, event_id: &EventId) -> Result<Option<PduCount>> {
+    pub(crate) fn get_pdu_count(&self, event_id: &EventId) -> Result<Option<PduCount>> {
         self.db.get_pdu_count(event_id)
     }
 
     // TODO Is this the same as the function above?
     /*
     #[tracing::instrument(skip(self))]
-    pub fn latest_pdu_count(&self, room_id: &RoomId) -> Result<u64> {
+    pub(crate) fn latest_pdu_count(&self, room_id: &RoomId) -> Result<u64> {
         let prefix = self
             .get_shortroomid(room_id)?
             .expect("room exists")
@@ -138,12 +142,12 @@ impl Service {
     */
 
     /// Returns the json of a pdu.
-    pub fn get_pdu_json(&self, event_id: &EventId) -> Result<Option<CanonicalJsonObject>> {
+    pub(crate) fn get_pdu_json(&self, event_id: &EventId) -> Result<Option<CanonicalJsonObject>> {
         self.db.get_pdu_json(event_id)
     }
 
     /// Returns the json of a pdu.
-    pub fn get_non_outlier_pdu_json(
+    pub(crate) fn get_non_outlier_pdu_json(
         &self,
         event_id: &EventId,
     ) -> Result<Option<CanonicalJsonObject>> {
@@ -151,39 +155,42 @@ impl Service {
     }
 
     /// Returns the pdu's id.
-    pub fn get_pdu_id(&self, event_id: &EventId) -> Result<Option<Vec<u8>>> {
+    pub(crate) fn get_pdu_id(&self, event_id: &EventId) -> Result<Option<Vec<u8>>> {
         self.db.get_pdu_id(event_id)
     }
 
     /// Returns the pdu.
     ///
     /// Checks the `eventid_outlierpdu` Tree if not found in the timeline.
-    pub fn get_non_outlier_pdu(&self, event_id: &EventId) -> Result<Option<PduEvent>> {
+    pub(crate) fn get_non_outlier_pdu(&self, event_id: &EventId) -> Result<Option<PduEvent>> {
         self.db.get_non_outlier_pdu(event_id)
     }
 
     /// Returns the pdu.
     ///
     /// Checks the `eventid_outlierpdu` Tree if not found in the timeline.
-    pub fn get_pdu(&self, event_id: &EventId) -> Result<Option<Arc<PduEvent>>> {
+    pub(crate) fn get_pdu(&self, event_id: &EventId) -> Result<Option<Arc<PduEvent>>> {
         self.db.get_pdu(event_id)
     }
 
     /// Returns the pdu.
     ///
     /// This does __NOT__ check the outliers `Tree`.
-    pub fn get_pdu_from_id(&self, pdu_id: &[u8]) -> Result<Option<PduEvent>> {
+    pub(crate) fn get_pdu_from_id(&self, pdu_id: &[u8]) -> Result<Option<PduEvent>> {
         self.db.get_pdu_from_id(pdu_id)
     }
 
     /// Returns the pdu as a `BTreeMap<String, CanonicalJsonValue>`.
-    pub fn get_pdu_json_from_id(&self, pdu_id: &[u8]) -> Result<Option<CanonicalJsonObject>> {
+    pub(crate) fn get_pdu_json_from_id(
+        &self,
+        pdu_id: &[u8],
+    ) -> Result<Option<CanonicalJsonObject>> {
         self.db.get_pdu_json_from_id(pdu_id)
     }
 
     /// Removes a pdu and creates a new one with the same id.
     #[tracing::instrument(skip(self))]
-    pub fn replace_pdu(
+    pub(crate) fn replace_pdu(
         &self,
         pdu_id: &[u8],
         pdu_json: &CanonicalJsonObject,
@@ -199,7 +206,7 @@ impl Service {
     ///
     /// Returns pdu id
     #[tracing::instrument(skip(self, pdu, pdu_json, leaves))]
-    pub async fn append_pdu<'a>(
+    pub(crate) async fn append_pdu<'a>(
         &self,
         pdu: &PduEvent,
         mut pdu_json: CanonicalJsonObject,
@@ -624,7 +631,7 @@ impl Service {
         Ok(pdu_id)
     }
 
-    pub fn create_hash_and_sign_event(
+    pub(crate) fn create_hash_and_sign_event(
         &self,
         pdu_builder: PduBuilder,
         sender: &UserId,
@@ -807,7 +814,7 @@ impl Service {
     /// Creates a new persisted data unit and adds it to a room. This function takes a
     /// roomid_mutex_state, meaning that only this function is able to mutate the room state.
     #[tracing::instrument(skip(self, state_lock))]
-    pub async fn build_and_append_pdu(
+    pub(crate) async fn build_and_append_pdu(
         &self,
         pdu_builder: PduBuilder,
         sender: &UserId,
@@ -1007,7 +1014,7 @@ impl Service {
     /// Append the incoming event setting the state snapshot to the state from the
     /// server that sent the event.
     #[tracing::instrument(skip_all)]
-    pub async fn append_incoming_pdu<'a>(
+    pub(crate) async fn append_incoming_pdu<'a>(
         &self,
         pdu: &PduEvent,
         pdu_json: CanonicalJsonObject,
@@ -1047,7 +1054,7 @@ impl Service {
     }
 
     /// Returns an iterator over all PDUs in a room.
-    pub fn all_pdus<'a>(
+    pub(crate) fn all_pdus<'a>(
         &'a self,
         user_id: &UserId,
         room_id: &RoomId,
@@ -1058,7 +1065,7 @@ impl Service {
     /// Returns an iterator over all events and their tokens in a room that happened before the
     /// event with id `until` in reverse-chronological order.
     #[tracing::instrument(skip(self))]
-    pub fn pdus_until<'a>(
+    pub(crate) fn pdus_until<'a>(
         &'a self,
         user_id: &UserId,
         room_id: &RoomId,
@@ -1070,7 +1077,7 @@ impl Service {
     /// Returns an iterator over all events and their token in a room that happened after the event
     /// with id `from` in chronological order.
     #[tracing::instrument(skip(self))]
-    pub fn pdus_after<'a>(
+    pub(crate) fn pdus_after<'a>(
         &'a self,
         user_id: &UserId,
         room_id: &RoomId,
@@ -1081,7 +1088,7 @@ impl Service {
 
     /// Replace a PDU with the redacted form.
     #[tracing::instrument(skip(self, reason))]
-    pub fn redact_pdu(&self, event_id: &EventId, reason: &PduEvent) -> Result<()> {
+    pub(crate) fn redact_pdu(&self, event_id: &EventId, reason: &PduEvent) -> Result<()> {
         // TODO: Don't reserialize, keep original json
         if let Some(pdu_id) = self.get_pdu_id(event_id)? {
             let mut pdu = self
@@ -1100,7 +1107,11 @@ impl Service {
     }
 
     #[tracing::instrument(skip(self, room_id))]
-    pub async fn backfill_if_required(&self, room_id: &RoomId, from: PduCount) -> Result<()> {
+    pub(crate) async fn backfill_if_required(
+        &self,
+        room_id: &RoomId,
+        from: PduCount,
+    ) -> Result<()> {
         let first_pdu = self
             .all_pdus(user_id!("@doesntmatter:grapevine"), room_id)?
             .next()
@@ -1165,7 +1176,7 @@ impl Service {
     }
 
     #[tracing::instrument(skip(self, pdu))]
-    pub async fn backfill_pdu(
+    pub(crate) async fn backfill_pdu(
         &self,
         origin: &ServerName,
         pdu: Box<RawJsonValue>,

src/service/rooms/timeline/data.rs

@@ -6,7 +6,7 @@ use crate::{PduEvent, Result};
 
 use super::PduCount;
 
-pub trait Data: Send + Sync {
+pub(crate) trait Data: Send + Sync {
     fn last_timeline_count(&self, sender_user: &UserId, room_id: &RoomId) -> Result<PduCount>;
 
     /// Returns the `count` of this pdu's id.

src/service/rooms/user.rs

@@ -1,32 +1,36 @@
 mod data;
 
-pub use data::Data;
+pub(crate) use data::Data;
 use ruma::{OwnedRoomId, OwnedUserId, RoomId, UserId};
 
 use crate::Result;
 
-pub struct Service {
-    pub db: &'static dyn Data,
+pub(crate) struct Service {
+    pub(crate) db: &'static dyn Data,
 }
 
 impl Service {
-    pub fn reset_notification_counts(&self, user_id: &UserId, room_id: &RoomId) -> Result<()> {
+    pub(crate) fn reset_notification_counts(
+        &self,
+        user_id: &UserId,
+        room_id: &RoomId,
+    ) -> Result<()> {
         self.db.reset_notification_counts(user_id, room_id)
     }
 
-    pub fn notification_count(&self, user_id: &UserId, room_id: &RoomId) -> Result<u64> {
+    pub(crate) fn notification_count(&self, user_id: &UserId, room_id: &RoomId) -> Result<u64> {
         self.db.notification_count(user_id, room_id)
     }
 
-    pub fn highlight_count(&self, user_id: &UserId, room_id: &RoomId) -> Result<u64> {
+    pub(crate) fn highlight_count(&self, user_id: &UserId, room_id: &RoomId) -> Result<u64> {
         self.db.highlight_count(user_id, room_id)
     }
 
-    pub fn last_notification_read(&self, user_id: &UserId, room_id: &RoomId) -> Result<u64> {
+    pub(crate) fn last_notification_read(&self, user_id: &UserId, room_id: &RoomId) -> Result<u64> {
         self.db.last_notification_read(user_id, room_id)
     }
 
-    pub fn associate_token_shortstatehash(
+    pub(crate) fn associate_token_shortstatehash(
         &self,
         room_id: &RoomId,
         token: u64,
@@ -36,11 +40,15 @@ impl Service {
             .associate_token_shortstatehash(room_id, token, shortstatehash)
     }
 
-    pub fn get_token_shortstatehash(&self, room_id: &RoomId, token: u64) -> Result<Option<u64>> {
+    pub(crate) fn get_token_shortstatehash(
+        &self,
+        room_id: &RoomId,
+        token: u64,
+    ) -> Result<Option<u64>> {
         self.db.get_token_shortstatehash(room_id, token)
     }
 
-    pub fn get_shared_rooms(
+    pub(crate) fn get_shared_rooms(
         &self,
         users: Vec<OwnedUserId>,
     ) -> Result<impl Iterator<Item = Result<OwnedRoomId>>> {

src/service/rooms/user/data.rs

@@ -1,7 +1,7 @@
 use crate::Result;
 use ruma::{OwnedRoomId, OwnedUserId, RoomId, UserId};
 
-pub trait Data: Send + Sync {
+pub(crate) trait Data: Send + Sync {
     fn reset_notification_counts(&self, user_id: &UserId, room_id: &RoomId) -> Result<()>;
 
     fn notification_count(&self, user_id: &UserId, room_id: &RoomId) -> Result<u64>;