make everything pub(crate) instead of pub

conduwuit is not a library

Signed-off-by: strawberry <strawberry@puppygock.gay>

src/service/rooms/alias/data.rs

@@ -2,7 +2,7 @@ use ruma::{OwnedRoomAliasId, OwnedRoomId, RoomAliasId, RoomId};
 
 use crate::Result;
 
-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/alias/mod.rs

@@ -1,35 +1,37 @@
 mod data;
 
-pub use data::Data;
+pub(crate) use data::Data;
 use ruma::{OwnedRoomAliasId, OwnedRoomId, RoomAliasId, 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_alias(&self, alias: &RoomAliasId, room_id: &RoomId) -> Result<()> { self.db.set_alias(alias, room_id) }
+	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<()> { self.db.remove_alias(alias) }
+	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> {
 		self.db.local_aliases_for_room(room_id)
 	}
 
 	#[tracing::instrument(skip(self))]
-	pub fn all_local_aliases<'a>(&'a self) -> Box<dyn Iterator<Item = Result<(OwnedRoomId, String)>> + 'a> {
+	pub(crate) fn all_local_aliases<'a>(&'a self) -> Box<dyn Iterator<Item = Result<(OwnedRoomId, String)>> + 'a> {
 		self.db.all_local_aliases()
 	}
 }

src/service/rooms/auth_chain/data.rs

@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use crate::Result;
 
-pub trait Data: Send + Sync {
+pub(crate) trait Data: Send + Sync {
 	fn get_cached_eventid_authchain(&self, shorteventid: &[u64]) -> Result<Option<Arc<[u64]>>>;
 	fn cache_auth_chain(&self, shorteventid: Vec<u64>, auth_chain: Arc<[u64]>) -> Result<()>;
 }

src/service/rooms/auth_chain/mod.rs

@@ -4,18 +4,18 @@ 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 async fn event_ids_iter<'a>(
+	pub(crate) async fn event_ids_iter<'a>(
 		&self, room_id: &RoomId, starting_events_: Vec<Arc<EventId>>,
 	) -> Result<impl Iterator<Item = Arc<EventId>> + 'a> {
 		let mut starting_events: Vec<&EventId> = Vec::with_capacity(starting_events_.len());
@@ -30,7 +30,7 @@ impl Service {
 			.filter_map(move |sid| services().rooms.short.get_eventid_from_short(sid).ok()))
 	}
 
-	pub async fn get_auth_chain(&self, room_id: &RoomId, starting_events: &[&EventId]) -> Result<Vec<u64>> {
+	pub(crate) async fn get_auth_chain(&self, room_id: &RoomId, starting_events: &[&EventId]) -> Result<Vec<u64>> {
 		const NUM_BUCKETS: usize = 50; //TODO: change possible w/o disrupting db?
 		const BUCKET: BTreeSet<(u64, &EventId)> = BTreeSet::new();
 
@@ -165,18 +165,18 @@ impl Service {
 		Ok(found)
 	}
 
-	pub fn get_cached_eventid_authchain(&self, key: &[u64]) -> Result<Option<Arc<[u64]>>> {
+	pub(crate) fn get_cached_eventid_authchain(&self, key: &[u64]) -> Result<Option<Arc<[u64]>>> {
 		self.db.get_cached_eventid_authchain(key)
 	}
 
 	#[tracing::instrument(skip(self))]
-	pub fn cache_auth_chain(&self, key: Vec<u64>, auth_chain: &HashSet<u64>) -> Result<()> {
+	pub(crate) fn cache_auth_chain(&self, key: Vec<u64>, auth_chain: &HashSet<u64>) -> Result<()> {
 		self.db
 			.cache_auth_chain(key, auth_chain.iter().copied().collect::<Arc<[u64]>>())
 	}
 
 	#[tracing::instrument(skip(self))]
-	pub fn cache_auth_chain_vec(&self, key: Vec<u64>, auth_chain: &Vec<u64>) -> Result<()> {
+	pub(crate) fn cache_auth_chain_vec(&self, key: Vec<u64>, auth_chain: &Vec<u64>) -> Result<()> {
 		self.db
 			.cache_auth_chain(key, auth_chain.iter().copied().collect::<Arc<[u64]>>())
 	}

src/service/rooms/directory/data.rs

@@ -2,7 +2,7 @@ use ruma::{OwnedRoomId, RoomId};
 
 use crate::Result;
 
-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/directory/mod.rs

@@ -1,24 +1,24 @@
 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<()> { self.db.set_public(room_id) }
+	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<()> { self.db.set_not_public(room_id) }
+	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> { self.db.is_public_room(room_id) }
+	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>> + '_ { self.db.public_rooms() }
+	pub(crate) fn public_rooms(&self) -> impl Iterator<Item = Result<OwnedRoomId>> + '_ { self.db.public_rooms() }
 }

src/service/rooms/event_handler/mod.rs

@@ -29,8 +29,8 @@ use crate::{
 	services, Error, PduEvent,
 };
 
-pub mod signing_keys;
-pub struct Service;
+mod signing_keys;
+pub(crate) struct Service;
 
 // We use some AsyncRecursiveType hacks here so we can call async funtion
 // recursively.
@@ -425,7 +425,7 @@ impl Service {
 		})
 	}
 
-	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>, create_event: &PduEvent,
 		origin: &ServerName, room_id: &RoomId, pub_key_map: &RwLock<BTreeMap<String, BTreeMap<String, Base64>>>,
 	) -> Result<Option<Vec<u8>>> {
@@ -746,7 +746,7 @@ impl Service {
 	// TODO: if we know the prev_events of the incoming event we can avoid the
 	// request and build the state from a known point and resolve if > 1 prev_event
 	#[tracing::instrument(skip_all, name = "state")]
-	pub async fn state_at_incoming_degree_one(
+	pub(crate) async fn state_at_incoming_degree_one(
 		&self, incoming_pdu: &Arc<PduEvent>,
 	) -> Result<Option<HashMap<u64, Arc<EventId>>>> {
 		let prev_event = &*incoming_pdu.prev_events[0];
@@ -794,7 +794,7 @@ impl Service {
 	}
 
 	#[tracing::instrument(skip_all, name = "state")]
-	pub async fn state_at_incoming_resolved(
+	pub(crate) async fn state_at_incoming_resolved(
 		&self, incoming_pdu: &Arc<PduEvent>, room_id: &RoomId, room_version_id: &RoomVersionId,
 	) -> Result<Option<HashMap<u64, Arc<EventId>>>> {
 		debug!("Calculating state at event using state res");
@@ -1275,7 +1275,7 @@ impl Service {
 
 	/// Returns Ok if the acl allows the server
 	#[tracing::instrument(skip_all)]
-	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 = if let Some(acl) =
 			services()
 				.rooms

src/service/rooms/event_handler/signing_keys.rs

@@ -367,7 +367,7 @@ impl super::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_for_server(
+	pub(crate) async fn fetch_signing_keys_for_server(
 		&self, origin: &ServerName, signature_ids: Vec<String>,
 	) -> Result<BTreeMap<String, Base64>> {
 		let contains_all_ids = |keys: &BTreeMap<String, Base64>| signature_ids.iter().all(|id| keys.contains_key(id));

src/service/rooms/lazy_loading/data.rs

@@ -2,7 +2,7 @@ use ruma::{DeviceId, RoomId, UserId};
 
 use crate::Result;
 
-pub trait Data: Send + Sync {
+pub(crate) trait Data: Send + Sync {
 	fn lazy_load_was_sent_before(
 		&self, user_id: &UserId, device_id: &DeviceId, room_id: &RoomId, ll_user: &UserId,
 	) -> Result<bool>;

src/service/rooms/lazy_loading/mod.rs

@@ -1,23 +1,24 @@
 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;
 
 use super::timeline::PduCount;
 use crate::Result;
 
-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: Mutex<HashMap<(OwnedUserId, OwnedDeviceId, OwnedRoomId, PduCount), HashSet<OwnedUserId>>>,
+	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, room_id: &RoomId, ll_user: &UserId,
 	) -> Result<bool> {
 		self.db
@@ -25,7 +26,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, room_id: &RoomId, lazy_load: HashSet<OwnedUserId>,
 		count: PduCount,
 	) {
@@ -36,7 +37,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, room_id: &RoomId, since: PduCount,
 	) -> Result<()> {
 		if let Some(user_ids) = self.lazy_load_waiting.lock().await.remove(&(
@@ -55,7 +56,7 @@ impl Service {
 	}
 
 	#[tracing::instrument(skip(self))]
-	pub fn lazy_load_reset(&self, user_id: &UserId, device_id: &DeviceId, room_id: &RoomId) -> Result<()> {
+	pub(crate) fn lazy_load_reset(&self, user_id: &UserId, device_id: &DeviceId, room_id: &RoomId) -> Result<()> {
 		self.db.lazy_load_reset(user_id, device_id, room_id)
 	}
 }

src/service/rooms/metadata/data.rs

@@ -2,7 +2,7 @@ use ruma::{OwnedRoomId, RoomId};
 
 use crate::Result;
 
-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/metadata/mod.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 {
 	/// Checks if a room exists.
 	#[tracing::instrument(skip(self))]
-	pub fn exists(&self, room_id: &RoomId) -> Result<bool> { self.db.exists(room_id) }
+	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> { self.db.iter_ids() }
+	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> { self.db.is_disabled(room_id) }
+	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)
 	}
 
-	pub fn is_banned(&self, room_id: &RoomId) -> Result<bool> { self.db.is_banned(room_id) }
+	pub(crate) fn is_banned(&self, room_id: &RoomId) -> Result<bool> { self.db.is_banned(room_id) }
 
-	pub fn ban_room(&self, room_id: &RoomId, banned: bool) -> Result<()> { self.db.ban_room(room_id, banned) }
+	pub(crate) fn ban_room(&self, room_id: &RoomId, banned: bool) -> Result<()> { self.db.ban_room(room_id, banned) }
 
-	pub fn list_banned_rooms<'a>(&'a self) -> Box<dyn Iterator<Item = Result<OwnedRoomId>> + 'a> {
+	pub(crate) fn list_banned_rooms<'a>(&'a self) -> Box<dyn Iterator<Item = Result<OwnedRoomId>> + 'a> {
 		self.db.list_banned_rooms()
 	}
 }

src/service/rooms/mod.rs

@@ -1,25 +1,25 @@
-pub mod alias;
-pub mod auth_chain;
-pub mod directory;
-pub mod event_handler;
-pub mod lazy_loading;
-pub mod metadata;
-pub mod outlier;
-pub mod pdu_metadata;
-pub mod read_receipt;
-pub mod search;
-pub mod short;
-pub mod spaces;
-pub mod state;
-pub mod state_accessor;
-pub mod state_cache;
-pub mod state_compressor;
-pub mod threads;
-pub mod timeline;
-pub mod typing;
-pub mod user;
+pub(crate) mod alias;
+pub(crate) mod auth_chain;
+pub(crate) mod directory;
+pub(crate) mod event_handler;
+pub(crate) mod lazy_loading;
+pub(crate) mod metadata;
+pub(crate) mod outlier;
+pub(crate) mod pdu_metadata;
+pub(crate) mod read_receipt;
+pub(crate) mod search;
+pub(crate) mod short;
+pub(crate) mod spaces;
+pub(crate) mod state;
+pub(crate) mod state_accessor;
+pub(crate) mod state_cache;
+pub(crate) mod state_compressor;
+pub(crate) mod threads;
+pub(crate) mod timeline;
+pub(crate) mod typing;
+pub(crate) mod user;
 
-pub trait Data:
+pub(crate) trait Data:
 	alias::Data
 	+ auth_chain::Data
 	+ directory::Data
@@ -40,25 +40,25 @@ pub trait Data:
 {
 }
 
-pub struct Service {
-	pub alias: alias::Service,
-	pub auth_chain: auth_chain::Service,
-	pub directory: directory::Service,
-	pub event_handler: event_handler::Service,
-	pub lazy_loading: lazy_loading::Service,
-	pub metadata: metadata::Service,
-	pub outlier: outlier::Service,
-	pub pdu_metadata: pdu_metadata::Service,
-	pub read_receipt: read_receipt::Service,
-	pub search: search::Service,
-	pub short: short::Service,
-	pub state: state::Service,
-	pub state_accessor: state_accessor::Service,
-	pub state_cache: state_cache::Service,
-	pub state_compressor: state_compressor::Service,
-	pub timeline: timeline::Service,
-	pub threads: threads::Service,
-	pub typing: typing::Service,
-	pub spaces: spaces::Service,
-	pub user: user::Service,
+pub(crate) struct Service {
+	pub(crate) alias: alias::Service,
+	pub(crate) auth_chain: auth_chain::Service,
+	pub(crate) directory: directory::Service,
+	pub(crate) event_handler: event_handler::Service,
+	pub(crate) lazy_loading: lazy_loading::Service,
+	pub(crate) metadata: metadata::Service,
+	pub(crate) outlier: outlier::Service,
+	pub(crate) pdu_metadata: pdu_metadata::Service,
+	pub(crate) read_receipt: read_receipt::Service,
+	pub(crate) search: search::Service,
+	pub(crate) short: short::Service,
+	pub(crate) state: state::Service,
+	pub(crate) state_accessor: state_accessor::Service,
+	pub(crate) state_cache: state_cache::Service,
+	pub(crate) state_compressor: state_compressor::Service,
+	pub(crate) timeline: timeline::Service,
+	pub(crate) threads: threads::Service,
+	pub(crate) typing: typing::Service,
+	pub(crate) spaces: spaces::Service,
+	pub(crate) user: user::Service,
 }

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/outlier/mod.rs

@@ -1,26 +1,28 @@
 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>> { self.db.get_outlier_pdu(event_id) }
+	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/pdu_metadata/data.rs

@@ -4,7 +4,7 @@ use ruma::{EventId, RoomId, UserId};
 
 use crate::{service::rooms::timeline::PduCount, PduEvent, Result};
 
-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/pdu_metadata/mod.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, Direction},
 	events::{relation::RelationType, TimelineEventType},
@@ -12,8 +12,8 @@ use serde::Deserialize;
 use super::timeline::PduCount;
 use crate::{services, PduEvent, Result};
 
-pub struct Service {
-	pub db: &'static dyn Data,
+pub(crate) struct Service {
+	pub(crate) db: &'static dyn Data,
 }
 
 #[derive(Clone, Debug, Deserialize)]
@@ -28,7 +28,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),
 			_ => {
@@ -40,7 +40,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, target: &EventId, filter_event_type: &Option<TimelineEventType>,
 		filter_rel_type: &Option<RelationType>, from: &Option<String>, to: &Option<String>, limit: &Option<UInt>,
 		recurse: bool, dir: Direction,
@@ -173,7 +173,7 @@ impl Service {
 		}
 	}
 
-	pub fn relations_until<'a>(
+	pub(crate) fn relations_until<'a>(
 		&'a self, user_id: &'a UserId, room_id: &'a RoomId, target: &'a EventId, until: PduCount, max_depth: u8,
 	) -> Result<Vec<(PduCount, PduEvent)>> {
 		let room_id = services().rooms.short.get_or_create_shortroomid(room_id)?;
@@ -215,18 +215,22 @@ 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<()> { self.db.mark_event_soft_failed(event_id) }
+	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> { self.db.is_event_soft_failed(event_id) }
+	pub(crate) fn is_event_soft_failed(&self, event_id: &EventId) -> Result<bool> {
+		self.db.is_event_soft_failed(event_id)
+	}
 }

src/service/rooms/read_receipt/data.rs

@@ -9,7 +9,7 @@ use crate::Result;
 type AnySyncEphemeralRoomEventIter<'a> =
 	Box<dyn Iterator<Item = Result<(OwnedUserId, u64, Raw<AnySyncEphemeralRoomEvent>)>> + 'a>;
 
-pub trait Data: Send + Sync {
+pub(crate) trait Data: Send + Sync {
 	/// Replaces the previous read receipt.
 	fn readreceipt_update(&self, user_id: &UserId, room_id: &RoomId, event: ReceiptEvent) -> Result<()>;
 

src/service/rooms/read_receipt/mod.rs

@@ -1,17 +1,17 @@
 mod data;
 
-pub use data::Data;
+pub(crate) use data::Data;
 use ruma::{events::receipt::ReceiptEvent, serde::Raw, OwnedUserId, RoomId, UserId};
 
 use crate::{services, Result};
 
-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(&self, user_id: &UserId, room_id: &RoomId, event: ReceiptEvent) -> Result<()> {
+	pub(crate) fn readreceipt_update(&self, user_id: &UserId, room_id: &RoomId, event: ReceiptEvent) -> Result<()> {
 		self.db.readreceipt_update(user_id, room_id, event)?;
 		services().sending.flush_room(room_id)?;
 
@@ -21,7 +21,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,
 	) -> impl Iterator<Item = Result<(OwnedUserId, u64, Raw<ruma::events::AnySyncEphemeralRoomEvent>)>> + 'a {
 		self.db.readreceipts_since(room_id, since)
@@ -29,18 +29,18 @@ 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/search/data.rs

@@ -4,7 +4,7 @@ use crate::Result;
 
 type SearchPdusResult<'a> = Result<Option<(Box<dyn Iterator<Item = Vec<u8>> + 'a>, Vec<String>)>>;
 
-pub trait Data: Send + Sync {
+pub(crate) trait Data: Send + Sync {
 	fn index_pdu(&self, shortroomid: u64, pdu_id: &[u8], message_body: &str) -> Result<()>;
 
 	fn search_pdus<'a>(&'a self, room_id: &RoomId, search_string: &str) -> SearchPdusResult<'a>;

src/service/rooms/search/mod.rs

@@ -1,22 +1,22 @@
 mod data;
 
-pub use data::Data;
+pub(crate) use data::Data;
 use ruma::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 index_pdu(&self, shortroomid: u64, pdu_id: &[u8], message_body: &str) -> Result<()> {
+	pub(crate) fn index_pdu(&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,
 	) -> Result<Option<(impl Iterator<Item = Vec<u8>> + 'a, Vec<String>)>> {
 		self.db.search_pdus(room_id, search_string)

src/service/rooms/short/data.rs

@@ -4,7 +4,7 @@ use ruma::{events::StateEventType, EventId, RoomId};
 
 use crate::Result;
 
-pub trait Data: Send + Sync {
+pub(crate) trait Data: Send + Sync {
 	fn get_or_create_shorteventid(&self, event_id: &EventId) -> Result<u64>;
 
 	fn multi_get_or_create_shorteventid(&self, event_id: &[&EventId]) -> Result<Vec<u64>>;

src/service/rooms/short/mod.rs

@@ -1,48 +1,48 @@
 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 multi_get_or_create_shorteventid(&self, event_ids: &[&EventId]) -> Result<Vec<u64>> {
+	pub(crate) fn multi_get_or_create_shorteventid(&self, event_ids: &[&EventId]) -> Result<Vec<u64>> {
 		self.db.multi_get_or_create_shorteventid(event_ids)
 	}
 
-	pub fn get_shortstatekey(&self, event_type: &StateEventType, state_key: &str) -> Result<Option<u64>> {
+	pub(crate) fn get_shortstatekey(&self, event_type: &StateEventType, state_key: &str) -> Result<Option<u64>> {
 		self.db.get_shortstatekey(event_type, state_key)
 	}
 
-	pub fn get_or_create_shortstatekey(&self, event_type: &StateEventType, state_key: &str) -> Result<u64> {
+	pub(crate) fn get_or_create_shortstatekey(&self, event_type: &StateEventType, state_key: &str) -> Result<u64> {
 		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>> { self.db.get_shortroomid(room_id) }
+	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/spaces/mod.rs

@@ -34,22 +34,22 @@ use tracing::{debug, error, warn};
 
 use crate::{debug_info, services, Error, Result};
 
-pub struct CachedSpaceHierarchySummary {
+pub(crate) struct CachedSpaceHierarchySummary {
 	summary: SpaceHierarchyParentSummary,
 }
 
-pub enum SummaryAccessibility {
+enum SummaryAccessibility {
 	Accessible(Box<SpaceHierarchyParentSummary>),
 	Inaccessible,
 }
 
-pub struct Arena {
+struct Arena {
 	nodes: Vec<Node>,
 	max_depth: usize,
 	first_untraversed: Option<NodeId>,
 }
 
-pub struct Node {
+struct Node {
 	parent: Option<NodeId>,
 	// Next meaning:
 	//   -->
@@ -60,13 +60,13 @@ pub struct Node {
 	// v
 	// o o o o
 	first_child: Option<NodeId>,
-	pub room_id: OwnedRoomId,
-	pub via: Vec<OwnedServerName>,
+	room_id: OwnedRoomId,
+	via: Vec<OwnedServerName>,
 	traversed: bool,
 }
 
 #[derive(Clone, Copy, PartialEq, Debug, PartialOrd)]
-pub struct NodeId {
+struct NodeId {
 	index: usize,
 }
 
@@ -288,14 +288,14 @@ impl Display for PagnationToken {
 /// Identifier used to check if rooms are accessible
 ///
 /// None is used if you want to return the room, no matter if accessible or not
-pub enum Identifier<'a> {
+enum Identifier<'a> {
 	UserId(&'a UserId),
 	ServerName(&'a ServerName),
 	None,
 }
 
-pub struct Service {
-	pub roomid_spacehierarchy_cache: Mutex<LruCache<OwnedRoomId, Option<CachedSpaceHierarchySummary>>>,
+pub(crate) struct Service {
+	pub(crate) roomid_spacehierarchy_cache: Mutex<LruCache<OwnedRoomId, Option<CachedSpaceHierarchySummary>>>,
 }
 
 // Here because cannot implement `From` across ruma-federation-api and
@@ -338,7 +338,7 @@ impl Service {
 	///
 	///Panics if the room does not exist, so a check if the room exists should
 	/// be done
-	pub async fn get_federation_hierarchy(
+	pub(crate) async fn get_federation_hierarchy(
 		&self, room_id: &RoomId, server_name: &ServerName, suggested_only: bool,
 	) -> Result<federation::space::get_hierarchy::v1::Response> {
 		match self
@@ -649,7 +649,7 @@ impl Service {
 		})
 	}
 
-	pub async fn get_client_hierarchy(
+	pub(crate) async fn get_client_hierarchy(
 		&self, sender_user: &UserId, room_id: &RoomId, limit: usize, skip: usize, max_depth: usize,
 		suggested_only: bool,
 	) -> Result<client::space::get_hierarchy::v1::Response> {

src/service/rooms/state/data.rs

@@ -5,7 +5,7 @@ use tokio::sync::MutexGuard;
 
 use crate::Result;
 
-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/mod.rs

@@ -21,13 +21,13 @@ use tracing::warn;
 use super::state_compressor::CompressedStateEvent;
 use crate::{services, utils::calculate_hash, Error, PduEvent, Result};
 
-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,
@@ -104,7 +104,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, state_ids_compressed: Arc<HashSet<CompressedStateEvent>>,
 	) -> Result<u64> {
 		let shorteventid = services()
@@ -172,7 +172,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
@@ -244,7 +244,7 @@ impl Service {
 	}
 
 	#[tracing::instrument(skip(self, invite_event))]
-	pub fn calculate_invite_state(&self, invite_event: &PduEvent) -> Result<Vec<Raw<AnyStrippedStateEvent>>> {
+	pub(crate) fn calculate_invite_state(&self, invite_event: &PduEvent) -> Result<Vec<Raw<AnyStrippedStateEvent>>> {
 		let mut state = Vec::new();
 		// Add recommended events
 		if let Some(e) =
@@ -300,7 +300,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,
@@ -311,7 +311,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
@@ -331,15 +331,15 @@ 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>,
@@ -351,7 +351,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, sender: &UserId, state_key: Option<&str>,
 		content: &serde_json::value::RawValue,
 	) -> Result<StateMap<Arc<PduEvent>>> {

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.
 	#[allow(unused_qualifications)] // async traits

src/service/rooms/state_accessor/mod.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::{
@@ -24,28 +24,30 @@ 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(&self, shortstatehash: u64) -> Result<HashMap<(StateEventType, String), Arc<PduEvent>>> {
+	pub(crate) async fn state_full(
+		&self, shortstatehash: u64,
+	) -> Result<HashMap<(StateEventType, String), Arc<PduEvent>>> {
 		self.db.state_full(shortstatehash).await
 	}
 
 	/// 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, state_key: &str,
 	) -> Result<Option<Arc<EventId>>> {
 		self.db.state_get_id(shortstatehash, event_type, state_key)
@@ -53,7 +55,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, state_key: &str,
 	) -> Result<Option<Arc<PduEvent>>> {
 		self.db.state_get(shortstatehash, event_type, state_key)
@@ -88,7 +90,9 @@ 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(&self, origin: &ServerName, room_id: &RoomId, event_id: &EventId) -> Result<bool> {
+	pub(crate) fn server_can_see_event(
+		&self, origin: &ServerName, room_id: &RoomId, event_id: &EventId,
+	) -> Result<bool> {
 		let Some(shortstatehash) = self.pdu_shortstatehash(event_id)? else {
 			return Ok(true);
 		};
@@ -151,7 +155,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(&self, user_id: &UserId, room_id: &RoomId, event_id: &EventId) -> Result<bool> {
+	pub(crate) fn user_can_see_event(&self, user_id: &UserId, room_id: &RoomId, event_id: &EventId) -> Result<bool> {
 		let Some(shortstatehash) = self.pdu_shortstatehash(event_id)? else {
 			return Ok(true);
 		};
@@ -210,7 +214,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))]
-	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
@@ -232,18 +236,22 @@ impl Service {
 	}
 
 	/// Returns the state hash for this pdu.
-	pub fn pdu_shortstatehash(&self, event_id: &EventId) -> Result<Option<u64>> { self.db.pdu_shortstatehash(event_id) }
+	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(&self, room_id: &RoomId) -> Result<HashMap<(StateEventType, String), Arc<PduEvent>>> {
+	pub(crate) async fn room_state_full(
+		&self, room_id: &RoomId,
+	) -> Result<HashMap<(StateEventType, String), Arc<PduEvent>>> {
 		self.db.room_state_full(room_id).await
 	}
 
 	/// 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, state_key: &str,
 	) -> Result<Option<Arc<EventId>>> {
 		self.db.room_state_get_id(room_id, event_type, state_key)
@@ -252,13 +260,13 @@ 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, state_key: &str,
 	) -> Result<Option<Arc<PduEvent>>> {
 		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
@@ -268,7 +276,7 @@ impl Service {
 			})
 	}
 
-	pub fn get_avatar(&self, room_id: &RoomId) -> Result<ruma::JsOption<RoomAvatarEventContent>> {
+	pub(crate) fn get_avatar(&self, room_id: &RoomId) -> Result<ruma::JsOption<RoomAvatarEventContent>> {
 		services()
 			.rooms
 			.state_accessor
@@ -279,7 +287,7 @@ impl Service {
 			})
 	}
 
-	pub fn get_member(&self, room_id: &RoomId, user_id: &UserId) -> Result<Option<RoomMemberEventContent>> {
+	pub(crate) fn get_member(&self, room_id: &RoomId, user_id: &UserId) -> Result<Option<RoomMemberEventContent>> {
 		services()
 			.rooms
 			.state_accessor
@@ -290,7 +298,7 @@ impl Service {
 			})
 	}
 
-	pub async fn user_can_invite(
+	pub(crate) async fn user_can_invite(
 		&self, room_id: &RoomId, sender: &UserId, target_user: &UserId, state_lock: &MutexGuard<'_, ()>,
 	) -> Result<bool> {
 		let content = to_raw_value(&RoomMemberEventContent::new(MembershipState::Invite))

src/service/rooms/state_cache/data.rs

@@ -12,7 +12,7 @@ type StrippedStateEventIter<'a> = Box<dyn Iterator<Item = Result<(OwnedRoomId, V
 
 type AnySyncStateEventIter<'a> = Box<dyn Iterator<Item = Result<(OwnedRoomId, Vec<Raw<AnySyncStateEvent>>)>> + 'a>;
 
-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_cache/mod.rs

@@ -1,6 +1,6 @@
 use std::{collections::HashSet, sync::Arc};
 
-pub use data::Data;
+pub(crate) use data::Data;
 use itertools::Itertools;
 use ruma::{
 	events::{
@@ -23,15 +23,15 @@ use crate::{service::appservice::RegistrationInfo, services, Error, Result};
 
 mod data;
 
-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))]
 	#[allow(clippy::too_many_arguments)]
-	pub fn update_membership(
+	pub(crate) fn update_membership(
 		&self, room_id: &RoomId, user_id: &UserId, membership_event: RoomMemberEventContent, sender: &UserId,
 		last_state: Option<Vec<Raw<AnyStrippedStateEvent>>>, invite_via: Option<Vec<OwnedServerName>>,
 		update_joined_count: bool,
@@ -210,43 +210,43 @@ impl Service {
 	}
 
 	#[tracing::instrument(skip(self, room_id))]
-	pub fn update_joined_count(&self, room_id: &RoomId) -> Result<()> { self.db.update_joined_count(room_id) }
+	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(&self, room_id: &RoomId, appservice: &RegistrationInfo) -> Result<bool> {
+	pub(crate) fn appservice_in_room(&self, room_id: &RoomId, appservice: &RegistrationInfo) -> Result<bool> {
 		self.db.appservice_in_room(room_id, appservice)
 	}
 
 	/// Makes a user forget a room.
 	#[tracing::instrument(skip(self))]
-	pub fn forget(&self, room_id: &RoomId, user_id: &UserId) -> Result<()> { self.db.forget(room_id, user_id) }
+	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>(&'a self, room_id: &RoomId) -> impl Iterator<Item = Result<OwnedServerName>> + 'a {
+	pub(crate) fn room_servers<'a>(&'a self, room_id: &RoomId) -> impl Iterator<Item = Result<OwnedServerName>> + 'a {
 		self.db.room_servers(room_id)
 	}
 
 	#[tracing::instrument(skip(self))]
-	pub fn server_in_room(&self, server: &ServerName, room_id: &RoomId) -> Result<bool> {
+	pub(crate) fn server_in_room(&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>(&'a self, server: &ServerName) -> impl Iterator<Item = Result<OwnedRoomId>> + 'a {
+	pub(crate) fn server_rooms<'a>(&'a self, server: &ServerName) -> impl Iterator<Item = Result<OwnedRoomId>> + 'a {
 		self.db.server_rooms(server)
 	}
 
 	/// Returns true if server can see user by sharing at least one room.
 	#[tracing::instrument(skip(self))]
-	pub fn server_sees_user(&self, server: &ServerName, user_id: &UserId) -> Result<bool> {
+	pub(crate) fn server_sees_user(&self, server: &ServerName, user_id: &UserId) -> Result<bool> {
 		Ok(self
 			.server_rooms(server)
 			.filter_map(Result::ok)
@@ -255,7 +255,7 @@ impl Service {
 
 	/// Returns true if user_a and user_b share at least one room.
 	#[tracing::instrument(skip(self))]
-	pub fn user_sees_user(&self, user_a: &UserId, user_b: &UserId) -> Result<bool> {
+	pub(crate) fn user_sees_user(&self, user_a: &UserId, user_b: &UserId) -> Result<bool> {
 		// Minimize number of point-queries by iterating user with least nr rooms
 		let (a, b) = if self.rooms_joined(user_a).count() < self.rooms_joined(user_b).count() {
 			(user_a, user_b)
@@ -271,88 +271,104 @@ impl Service {
 
 	/// Returns an iterator over all joined members of a room.
 	#[tracing::instrument(skip(self))]
-	pub fn room_members<'a>(&'a self, room_id: &RoomId) -> impl Iterator<Item = Result<OwnedUserId>> + 'a {
+	pub(crate) fn room_members<'a>(&'a self, room_id: &RoomId) -> impl Iterator<Item = Result<OwnedUserId>> + 'a {
 		self.db.room_members(room_id)
 	}
 
 	#[tracing::instrument(skip(self))]
-	pub fn room_joined_count(&self, room_id: &RoomId) -> Result<Option<u64>> { self.db.room_joined_count(room_id) }
+	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>> { self.db.room_invited_count(room_id) }
+	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>(&'a self, room_id: &RoomId) -> impl Iterator<Item = Result<OwnedUserId>> + 'a {
+	pub(crate) fn room_useroncejoined<'a>(
+		&'a self, room_id: &RoomId,
+	) -> impl Iterator<Item = Result<OwnedUserId>> + 'a {
 		self.db.room_useroncejoined(room_id)
 	}
 
 	/// Returns an iterator over all invited members of a room.
 	#[tracing::instrument(skip(self))]
-	pub fn room_members_invited<'a>(&'a self, room_id: &RoomId) -> impl Iterator<Item = Result<OwnedUserId>> + 'a {
+	pub(crate) fn room_members_invited<'a>(
+		&'a self, room_id: &RoomId,
+	) -> impl Iterator<Item = Result<OwnedUserId>> + 'a {
 		self.db.room_members_invited(room_id)
 	}
 
 	#[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>(&'a self, user_id: &UserId) -> impl Iterator<Item = Result<OwnedRoomId>> + 'a {
+	pub(crate) fn rooms_joined<'a>(&'a self, user_id: &UserId) -> impl Iterator<Item = Result<OwnedRoomId>> + 'a {
 		self.db.rooms_joined(user_id)
 	}
 
 	/// 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 {
 		self.db.rooms_invited(user_id)
 	}
 
 	#[tracing::instrument(skip(self))]
-	pub fn invite_state(&self, user_id: &UserId, room_id: &RoomId) -> Result<Option<Vec<Raw<AnyStrippedStateEvent>>>> {
+	pub(crate) fn invite_state(
+		&self, user_id: &UserId, room_id: &RoomId,
+	) -> Result<Option<Vec<Raw<AnyStrippedStateEvent>>>> {
 		self.db.invite_state(user_id, room_id)
 	}
 
 	#[tracing::instrument(skip(self))]
-	pub fn left_state(&self, user_id: &UserId, room_id: &RoomId) -> Result<Option<Vec<Raw<AnyStrippedStateEvent>>>> {
+	pub(crate) fn left_state(
+		&self, user_id: &UserId, room_id: &RoomId,
+	) -> Result<Option<Vec<Raw<AnyStrippedStateEvent>>>> {
 		self.db.left_state(user_id, room_id)
 	}
 
 	/// 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 {
 		self.db.rooms_left(user_id)
 	}
 
 	#[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> { self.db.is_joined(user_id, room_id) }
+	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> { self.db.is_left(user_id, room_id) }
+	pub(crate) fn is_left(&self, user_id: &UserId, room_id: &RoomId) -> Result<bool> {
+		self.db.is_left(user_id, room_id)
+	}
 
 	#[tracing::instrument(skip(self))]
-	pub fn servers_invite_via(&self, room_id: &RoomId) -> Result<Option<Vec<OwnedServerName>>> {
+	pub(crate) fn servers_invite_via(&self, room_id: &RoomId) -> Result<Option<Vec<OwnedServerName>>> {
 		self.db.servers_invite_via(room_id)
 	}
 
@@ -361,7 +377,7 @@ impl Service {
 	///
 	/// See <https://spec.matrix.org/v1.10/appendices/#routing>
 	#[tracing::instrument(skip(self))]
-	pub fn servers_route_via(&self, room_id: &RoomId) -> Result<Vec<OwnedServerName>> {
+	pub(crate) fn servers_route_via(&self, room_id: &RoomId) -> Result<Vec<OwnedServerName>> {
 		let most_powerful_user_server = services()
 			.rooms
 			.state_accessor

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/state_compressor/mod.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};
 
@@ -42,19 +42,19 @@ type ParentStatesVec = Vec<(
 
 type HashSetCompressStateEvent = Result<(u64, Arc<HashSet<CompressedStateEvent>>, Arc<HashSet<CompressedStateEvent>>)>;
 
-pub struct Service {
-	pub db: &'static dyn Data,
+pub(crate) struct Service {
+	pub(crate) db: &'static dyn Data,
 
-	pub stateinfo_cache: StateInfoLruCache,
+	pub(crate) stateinfo_cache: StateInfoLruCache,
 }
 
-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.
 	#[tracing::instrument(skip(self))]
-	pub fn load_shortstatehash_info(&self, shortstatehash: u64) -> ShortStateInfoResult {
+	pub(crate) fn load_shortstatehash_info(&self, shortstatehash: u64) -> ShortStateInfoResult {
 		if let Some(r) = self
 			.stateinfo_cache
 			.lock()
@@ -97,7 +97,7 @@ impl Service {
 		}
 	}
 
-	pub fn compress_state_event(&self, shortstatekey: u64, event_id: &EventId) -> Result<CompressedStateEvent> {
+	pub(crate) fn compress_state_event(&self, shortstatekey: u64, event_id: &EventId) -> Result<CompressedStateEvent> {
 		let mut v = shortstatekey.to_be_bytes().to_vec();
 		v.extend_from_slice(
 			&services()
@@ -110,7 +110,9 @@ impl Service {
 	}
 
 	/// Returns shortstatekey, event id
-	pub fn parse_compressed_state_event(&self, compressed_event: &CompressedStateEvent) -> Result<(u64, Arc<EventId>)> {
+	pub(crate) fn parse_compressed_state_event(
+		&self, compressed_event: &CompressedStateEvent,
+	) -> Result<(u64, Arc<EventId>)> {
 		Ok((
 			utils::u64_from_bytes(&compressed_event[0..size_of::<u64>()]).expect("bytes have right length"),
 			services().rooms.short.get_eventid_from_short(
@@ -138,7 +140,7 @@ impl Service {
 	/// * `parent_states` - A stack with info on shortstatehash, full state,
 	///   added diff and removed diff for each parent layer
 	#[tracing::instrument(skip(self, statediffnew, statediffremoved, 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>>,
 		statediffremoved: Arc<HashSet<CompressedStateEvent>>, diff_to_sibling: usize,
 		mut parent_states: ParentStatesVec,
@@ -250,7 +252,7 @@ impl Service {
 
 	/// Returns the new shortstatehash, and the state diff from the previous
 	/// room state
-	pub fn save_state(
+	pub(crate) fn save_state(
 		&self, room_id: &RoomId, new_state_ids_compressed: Arc<HashSet<CompressedStateEvent>>,
 	) -> HashSetCompressStateEvent {
 		let previous_shortstatehash = services().rooms.state.get_room_shortstatehash(room_id)?;

src/service/rooms/threads/data.rs

@@ -4,7 +4,7 @@ use crate::{PduEvent, Result};
 
 type PduEventIterResult<'a> = Result<Box<dyn Iterator<Item = Result<(u64, PduEvent)>> + 'a>>;
 
-pub trait Data: Send + Sync {
+pub(crate) trait Data: Send + Sync {
 	fn threads_until<'a>(
 		&'a self, user_id: &'a UserId, room_id: &'a RoomId, until: u64, include: &'a IncludeThreads,
 	) -> PduEventIterResult<'a>;

src/service/rooms/threads/mod.rs

@@ -2,7 +2,7 @@ mod data;
 
 use std::collections::BTreeMap;
 
-pub use data::Data;
+pub(crate) use data::Data;
 use ruma::{
 	api::client::{error::ErrorKind, threads::get_threads::v1::IncludeThreads},
 	events::relation::BundledThread,
@@ -12,18 +12,18 @@ 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, until: u64, include: &'a IncludeThreads,
 	) -> Result<impl Iterator<Item = Result<(u64, PduEvent)>> + 'a> {
 		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/timeline/data.rs

@@ -5,7 +5,7 @@ use ruma::{CanonicalJsonObject, EventId, OwnedUserId, RoomId, UserId};
 use super::PduCount;
 use crate::{PduEvent, Result};
 
-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/timeline/mod.rs

@@ -6,7 +6,7 @@ use std::{
 	sync::Arc,
 };
 
-pub use data::Data;
+pub(crate) use data::Data;
 use rand::prelude::SliceRandom;
 use ruma::{
 	api::{client::error::ErrorKind, federation},
@@ -45,17 +45,17 @@ use crate::{
 };
 
 #[derive(Hash, PartialEq, Eq, Clone, Copy, Debug)]
-pub enum PduCount {
+pub(crate) enum PduCount {
 	Backfilled(u64),
 	Normal(u64),
 }
 
 impl PduCount {
-	pub fn min() -> Self { Self::Backfilled(u64::MAX) }
+	pub(crate) fn min() -> Self { Self::Backfilled(u64::MAX) }
 
-	pub fn max() -> Self { Self::Normal(u64::MAX) }
+	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) = token.strip_prefix('-') {
 			stripped_token.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(),
@@ -104,15 +104,15 @@ struct ExtractRelatesToEventId {
 	relates_to: ExtractEventId,
 }
 
-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:conduit.rs"), room_id)?
 			.next()
 			.map(|o| o.map(|(_, p)| Arc::new(p)))
@@ -120,17 +120,19 @@ 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>> { self.db.get_pdu_count(event_id) }
+	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")
@@ -151,7 +153,7 @@ impl Service {
 	*/
 
 	/// Returns the version of a room, if known
-	pub fn get_room_version(&self, room_id: &RoomId) -> Result<Option<RoomVersionId>> {
+	pub(crate) fn get_room_version(&self, room_id: &RoomId) -> Result<Option<RoomVersionId>> {
 		let create_event = services()
 			.rooms
 			.state_accessor
@@ -171,43 +173,43 @@ 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(&self, event_id: &EventId) -> Result<Option<CanonicalJsonObject>> {
+	pub(crate) fn get_non_outlier_pdu_json(&self, event_id: &EventId) -> Result<Option<CanonicalJsonObject>> {
 		self.db.get_non_outlier_pdu_json(event_id)
 	}
 
 	/// Returns the pdu's id.
-	pub fn get_pdu_id(&self, event_id: &EventId) -> Result<Option<Vec<u8>>> { self.db.get_pdu_id(event_id) }
+	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>>> { self.db.get_pdu(event_id) }
+	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>> { self.db.get_pdu_from_id(pdu_id) }
+	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(&self, pdu_id: &[u8], pdu_json: &CanonicalJsonObject, pdu: &PduEvent) -> Result<()> {
+	pub(crate) fn replace_pdu(&self, pdu_id: &[u8], pdu_json: &CanonicalJsonObject, pdu: &PduEvent) -> Result<()> {
 		self.db.replace_pdu(pdu_id, pdu_json, pdu)
 	}
 
@@ -218,7 +220,7 @@ impl Service {
 	///
 	/// Returns pdu id
 	#[tracing::instrument(skip(self, pdu, pdu_json, leaves))]
-	pub async fn append_pdu(
+	pub(crate) async fn append_pdu(
 		&self,
 		pdu: &PduEvent,
 		mut pdu_json: CanonicalJsonObject,
@@ -615,7 +617,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,
@@ -798,7 +800,7 @@ impl Service {
 	/// 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,
@@ -940,7 +942,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(
+	pub(crate) async fn append_incoming_pdu(
 		&self,
 		pdu: &PduEvent,
 		pdu_json: CanonicalJsonObject,
@@ -979,7 +981,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,
 	) -> Result<impl Iterator<Item = Result<(PduCount, PduEvent)>> + 'a> {
 		self.pdus_after(user_id, room_id, PduCount::min())
@@ -989,7 +991,7 @@ impl Service {
 	/// 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, until: PduCount,
 	) -> Result<impl Iterator<Item = Result<(PduCount, PduEvent)>> + 'a> {
 		self.db.pdus_until(user_id, room_id, until)
@@ -998,7 +1000,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, from: PduCount,
 	) -> Result<impl Iterator<Item = Result<(PduCount, PduEvent)>> + 'a> {
 		self.db.pdus_after(user_id, room_id, from)
@@ -1006,7 +1008,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
@@ -1028,7 +1030,7 @@ 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:conduit.rs"), room_id)?
 			.next()
@@ -1142,7 +1144,7 @@ impl Service {
 	}
 
 	#[tracing::instrument(skip(self, pdu, pub_key_map))]
-	pub async fn backfill_pdu(
+	pub(crate) async fn backfill_pdu(
 		&self, origin: &ServerName, pdu: Box<RawJsonValue>,
 		pub_key_map: &RwLock<BTreeMap<String, BTreeMap<String, Base64>>>,
 	) -> Result<()> {

src/service/rooms/typing/mod.rs

@@ -10,17 +10,18 @@ use tracing::debug;
 
 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<()> {
 		debug!("typing add {:?} in {:?} timeout:{:?}", user_id, room_id, timeout);
 		// update clients
 		self.typing
@@ -44,7 +45,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<()> {
 		debug!("typing remove {:?} in {:?}", user_id, room_id);
 		// update clients
 		self.typing
@@ -67,7 +68,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 {
@@ -124,7 +125,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
@@ -136,7 +137,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>> {
 		Ok(SyncEphemeralRoomEvent {

src/service/rooms/user/data.rs

@@ -2,7 +2,7 @@ use ruma::{OwnedRoomId, OwnedUserId, RoomId, UserId};
 
 use crate::Result;
 
-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>;

src/service/rooms/user/mod.rs

@@ -1,41 +1,45 @@
 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(&self, room_id: &RoomId, token: u64, shortstatehash: u64) -> Result<()> {
+	pub(crate) fn associate_token_shortstatehash(
+		&self, room_id: &RoomId, token: u64, shortstatehash: u64,
+	) -> Result<()> {
 		self.db
 			.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(&self, users: Vec<OwnedUserId>) -> Result<impl Iterator<Item = Result<OwnedRoomId>>> {
+	pub(crate) fn get_shared_rooms(
+		&self, users: Vec<OwnedUserId>,
+	) -> Result<impl Iterator<Item = Result<OwnedRoomId>>> {
 		self.db.get_shared_rooms(users)
 	}
 }