make everything pub(crate) instead of pub

conduwuit is not a library

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

Cargo.toml

@@ -487,6 +487,7 @@ elided_lifetimes_in_paths = "warn"
 macro_use_extern_crate = "warn"
 single_use_lifetimes = "warn"
 unsafe_op_in_unsafe_fn = "warn"
+unreachable_pub = "warn"
 
 # not in rust 1.75.0 (doesn't break CI but won't check for it)
 unit_bindings = "warn"
@@ -495,7 +496,6 @@ unit_bindings = "warn"
 unused_braces = "allow"
 
 # some sadness
-unreachable_pub = "allow"
 missing_docs = "allow"
 
 

src/api/client_server/account.rs

@@ -34,7 +34,7 @@ const RANDOM_USER_ID_LENGTH: usize = 10;
 ///
 /// Note: This will not reserve the username, so the username might become
 /// invalid when trying to register
-pub async fn get_register_available_route(
+pub(crate) async fn get_register_available_route(
 	body: Ruma<get_username_availability::v3::Request>,
 ) -> Result<get_username_availability::v3::Response> {
 	// Validate user id
@@ -82,7 +82,7 @@ pub async fn get_register_available_route(
 /// - If `inhibit_login` is false: Creates a device and returns device id and
 ///   access_token
 #[allow(clippy::doc_markdown)]
-pub async fn register_route(body: Ruma<register::v3::Request>) -> Result<register::v3::Response> {
+pub(crate) async fn register_route(body: Ruma<register::v3::Request>) -> Result<register::v3::Response> {
 	if !services().globals.allow_registration() && body.appservice_info.is_none() {
 		info!(
 			"Registration disabled and request not from known appservice, rejecting registration attempt for username \
@@ -406,7 +406,9 @@ pub async fn register_route(body: Ruma<register::v3::Request>) -> Result<registe
 ///   last seen ts)
 /// - Forgets to-device events
 /// - Triggers device list updates
-pub async fn change_password_route(body: Ruma<change_password::v3::Request>) -> Result<change_password::v3::Response> {
+pub(crate) async fn change_password_route(
+	body: Ruma<change_password::v3::Request>,
+) -> Result<change_password::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 	let sender_device = body.sender_device.as_ref().expect("user is authenticated");
 
@@ -469,7 +471,7 @@ pub async fn change_password_route(body: Ruma<change_password::v3::Request>) ->
 /// Get `user_id` of the sender user.
 ///
 /// Note: Also works for Application Services
-pub async fn whoami_route(body: Ruma<whoami::v3::Request>) -> Result<whoami::v3::Response> {
+pub(crate) async fn whoami_route(body: Ruma<whoami::v3::Request>) -> Result<whoami::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 	let device_id = body.sender_device.clone();
 
@@ -491,7 +493,7 @@ pub async fn whoami_route(body: Ruma<whoami::v3::Request>) -> Result<whoami::v3:
 /// - Forgets all to-device events
 /// - Triggers device list updates
 /// - Removes ability to log in again
-pub async fn deactivate_route(body: Ruma<deactivate::v3::Request>) -> Result<deactivate::v3::Response> {
+pub(crate) async fn deactivate_route(body: Ruma<deactivate::v3::Request>) -> Result<deactivate::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 	let sender_device = body.sender_device.as_ref().expect("user is authenticated");
 
@@ -546,7 +548,7 @@ pub async fn deactivate_route(body: Ruma<deactivate::v3::Request>) -> Result<dea
 /// Get a list of third party identifiers associated with this account.
 ///
 /// - Currently always returns empty list
-pub async fn third_party_route(body: Ruma<get_3pids::v3::Request>) -> Result<get_3pids::v3::Response> {
+pub(crate) async fn third_party_route(body: Ruma<get_3pids::v3::Request>) -> Result<get_3pids::v3::Response> {
 	let _sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	Ok(get_3pids::v3::Response::new(Vec::new()))
@@ -559,7 +561,7 @@ pub async fn third_party_route(body: Ruma<get_3pids::v3::Request>) -> Result<get
 ///
 /// - 403 signals that The homeserver does not allow the third party identifier
 ///   as a contact option.
-pub async fn request_3pid_management_token_via_email_route(
+pub(crate) async fn request_3pid_management_token_via_email_route(
 	_body: Ruma<request_3pid_management_token_via_email::v3::Request>,
 ) -> Result<request_3pid_management_token_via_email::v3::Response> {
 	Err(Error::BadRequest(
@@ -575,7 +577,7 @@ pub async fn request_3pid_management_token_via_email_route(
 ///
 /// - 403 signals that The homeserver does not allow the third party identifier
 ///   as a contact option.
-pub async fn request_3pid_management_token_via_msisdn_route(
+pub(crate) async fn request_3pid_management_token_via_msisdn_route(
 	_body: Ruma<request_3pid_management_token_via_msisdn::v3::Request>,
 ) -> Result<request_3pid_management_token_via_msisdn::v3::Response> {
 	Err(Error::BadRequest(

src/api/client_server/alias.rs

@@ -17,7 +17,7 @@ use crate::{debug_info, debug_warn, services, Error, Result, Ruma};
 /// # `PUT /_matrix/client/v3/directory/room/{roomAlias}`
 ///
 /// Creates a new room alias on this server.
-pub async fn create_alias_route(body: Ruma<create_alias::v3::Request>) -> Result<create_alias::v3::Response> {
+pub(crate) async fn create_alias_route(body: Ruma<create_alias::v3::Request>) -> Result<create_alias::v3::Response> {
 	if body.room_alias.server_name() != services().globals.server_name() {
 		return Err(Error::BadRequest(ErrorKind::InvalidParam, "Alias is from another server."));
 	}
@@ -72,7 +72,7 @@ pub async fn create_alias_route(body: Ruma<create_alias::v3::Request>) -> Result
 ///
 /// - TODO: additional access control checks
 /// - TODO: Update canonical alias event
-pub async fn delete_alias_route(body: Ruma<delete_alias::v3::Request>) -> Result<delete_alias::v3::Response> {
+pub(crate) async fn delete_alias_route(body: Ruma<delete_alias::v3::Request>) -> Result<delete_alias::v3::Response> {
 	if body.room_alias.server_name() != services().globals.server_name() {
 		return Err(Error::BadRequest(ErrorKind::InvalidParam, "Alias is from another server."));
 	}
@@ -118,7 +118,7 @@ pub async fn delete_alias_route(body: Ruma<delete_alias::v3::Request>) -> Result
 /// # `GET /_matrix/client/v3/directory/room/{roomAlias}`
 ///
 /// Resolve an alias locally or over federation.
-pub async fn get_alias_route(body: Ruma<get_alias::v3::Request>) -> Result<get_alias::v3::Response> {
+pub(crate) async fn get_alias_route(body: Ruma<get_alias::v3::Request>) -> Result<get_alias::v3::Response> {
 	get_alias_helper(body.body.room_alias, None).await
 }
 

src/api/client_server/backup.rs

@@ -13,7 +13,7 @@ use crate::{services, Error, Result, Ruma};
 /// # `POST /_matrix/client/r0/room_keys/version`
 ///
 /// Creates a new backup.
-pub async fn create_backup_version_route(
+pub(crate) async fn create_backup_version_route(
 	body: Ruma<create_backup_version::v3::Request>,
 ) -> Result<create_backup_version::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -30,7 +30,7 @@ pub async fn create_backup_version_route(
 ///
 /// Update information about an existing backup. Only `auth_data` can be
 /// modified.
-pub async fn update_backup_version_route(
+pub(crate) async fn update_backup_version_route(
 	body: Ruma<update_backup_version::v3::Request>,
 ) -> Result<update_backup_version::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -44,7 +44,7 @@ pub async fn update_backup_version_route(
 /// # `GET /_matrix/client/r0/room_keys/version`
 ///
 /// Get information about the latest backup version.
-pub async fn get_latest_backup_info_route(
+pub(crate) async fn get_latest_backup_info_route(
 	body: Ruma<get_latest_backup_info::v3::Request>,
 ) -> Result<get_latest_backup_info::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -65,7 +65,9 @@ pub async fn get_latest_backup_info_route(
 /// # `GET /_matrix/client/r0/room_keys/version`
 ///
 /// Get information about an existing backup.
-pub async fn get_backup_info_route(body: Ruma<get_backup_info::v3::Request>) -> Result<get_backup_info::v3::Response> {
+pub(crate) async fn get_backup_info_route(
+	body: Ruma<get_backup_info::v3::Request>,
+) -> Result<get_backup_info::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 	let algorithm = services()
 		.key_backups
@@ -91,7 +93,7 @@ pub async fn get_backup_info_route(body: Ruma<get_backup_info::v3::Request>) ->
 ///
 /// - Deletes both information about the backup, as well as all key data related
 ///   to the backup
-pub async fn delete_backup_version_route(
+pub(crate) async fn delete_backup_version_route(
 	body: Ruma<delete_backup_version::v3::Request>,
 ) -> Result<delete_backup_version::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -111,7 +113,9 @@ pub async fn delete_backup_version_route(
 ///   allowed
 /// - Adds the keys to the backup
 /// - Returns the new number of keys in this backup and the etag
-pub async fn add_backup_keys_route(body: Ruma<add_backup_keys::v3::Request>) -> Result<add_backup_keys::v3::Response> {
+pub(crate) async fn add_backup_keys_route(
+	body: Ruma<add_backup_keys::v3::Request>,
+) -> Result<add_backup_keys::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	if Some(&body.version)
@@ -153,7 +157,7 @@ pub async fn add_backup_keys_route(body: Ruma<add_backup_keys::v3::Request>) ->
 ///   allowed
 /// - Adds the keys to the backup
 /// - Returns the new number of keys in this backup and the etag
-pub async fn add_backup_keys_for_room_route(
+pub(crate) async fn add_backup_keys_for_room_route(
 	body: Ruma<add_backup_keys_for_room::v3::Request>,
 ) -> Result<add_backup_keys_for_room::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -195,7 +199,7 @@ pub async fn add_backup_keys_for_room_route(
 ///   allowed
 /// - Adds the keys to the backup
 /// - Returns the new number of keys in this backup and the etag
-pub async fn add_backup_keys_for_session_route(
+pub(crate) async fn add_backup_keys_for_session_route(
 	body: Ruma<add_backup_keys_for_session::v3::Request>,
 ) -> Result<add_backup_keys_for_session::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -230,7 +234,9 @@ pub async fn add_backup_keys_for_session_route(
 /// # `GET /_matrix/client/r0/room_keys/keys`
 ///
 /// Retrieves all keys from the backup.
-pub async fn get_backup_keys_route(body: Ruma<get_backup_keys::v3::Request>) -> Result<get_backup_keys::v3::Response> {
+pub(crate) async fn get_backup_keys_route(
+	body: Ruma<get_backup_keys::v3::Request>,
+) -> Result<get_backup_keys::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	let rooms = services().key_backups.get_all(sender_user, &body.version)?;
@@ -243,7 +249,7 @@ pub async fn get_backup_keys_route(body: Ruma<get_backup_keys::v3::Request>) ->
 /// # `GET /_matrix/client/r0/room_keys/keys/{roomId}`
 ///
 /// Retrieves all keys from the backup for a given room.
-pub async fn get_backup_keys_for_room_route(
+pub(crate) async fn get_backup_keys_for_room_route(
 	body: Ruma<get_backup_keys_for_room::v3::Request>,
 ) -> Result<get_backup_keys_for_room::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -260,7 +266,7 @@ pub async fn get_backup_keys_for_room_route(
 /// # `GET /_matrix/client/r0/room_keys/keys/{roomId}/{sessionId}`
 ///
 /// Retrieves a key from the backup.
-pub async fn get_backup_keys_for_session_route(
+pub(crate) async fn get_backup_keys_for_session_route(
 	body: Ruma<get_backup_keys_for_session::v3::Request>,
 ) -> Result<get_backup_keys_for_session::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -281,7 +287,7 @@ pub async fn get_backup_keys_for_session_route(
 /// # `DELETE /_matrix/client/r0/room_keys/keys`
 ///
 /// Delete the keys from the backup.
-pub async fn delete_backup_keys_route(
+pub(crate) async fn delete_backup_keys_route(
 	body: Ruma<delete_backup_keys::v3::Request>,
 ) -> Result<delete_backup_keys::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -304,7 +310,7 @@ pub async fn delete_backup_keys_route(
 /// # `DELETE /_matrix/client/r0/room_keys/keys/{roomId}`
 ///
 /// Delete the keys from the backup for a given room.
-pub async fn delete_backup_keys_for_room_route(
+pub(crate) async fn delete_backup_keys_for_room_route(
 	body: Ruma<delete_backup_keys_for_room::v3::Request>,
 ) -> Result<delete_backup_keys_for_room::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -327,7 +333,7 @@ pub async fn delete_backup_keys_for_room_route(
 /// # `DELETE /_matrix/client/r0/room_keys/keys/{roomId}/{sessionId}`
 ///
 /// Delete a key from the backup.
-pub async fn delete_backup_keys_for_session_route(
+pub(crate) async fn delete_backup_keys_for_session_route(
 	body: Ruma<delete_backup_keys_for_session::v3::Request>,
 ) -> Result<delete_backup_keys_for_session::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");

src/api/client_server/capabilities.rs

@@ -11,7 +11,7 @@ use crate::{services, Result, Ruma};
 ///
 /// Get information on the supported feature set and other relevent capabilities
 /// of this server.
-pub async fn get_capabilities_route(
+pub(crate) async fn get_capabilities_route(
 	_body: Ruma<get_capabilities::v3::Request>,
 ) -> Result<get_capabilities::v3::Response> {
 	let mut available = BTreeMap::new();

src/api/client_server/config.rs

@@ -14,7 +14,7 @@ use crate::{services, Error, Result, Ruma};
 /// # `PUT /_matrix/client/r0/user/{userId}/account_data/{type}`
 ///
 /// Sets some account data for the sender user.
-pub async fn set_global_account_data_route(
+pub(crate) async fn set_global_account_data_route(
 	body: Ruma<set_global_account_data::v3::Request>,
 ) -> Result<set_global_account_data::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -40,7 +40,7 @@ pub async fn set_global_account_data_route(
 /// # `PUT /_matrix/client/r0/user/{userId}/rooms/{roomId}/account_data/{type}`
 ///
 /// Sets some room account data for the sender user.
-pub async fn set_room_account_data_route(
+pub(crate) async fn set_room_account_data_route(
 	body: Ruma<set_room_account_data::v3::Request>,
 ) -> Result<set_room_account_data::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -66,7 +66,7 @@ pub async fn set_room_account_data_route(
 /// # `GET /_matrix/client/r0/user/{userId}/account_data/{type}`
 ///
 /// Gets some account data for the sender user.
-pub async fn get_global_account_data_route(
+pub(crate) async fn get_global_account_data_route(
 	body: Ruma<get_global_account_data::v3::Request>,
 ) -> Result<get_global_account_data::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -88,7 +88,7 @@ pub async fn get_global_account_data_route(
 /// # `GET /_matrix/client/r0/user/{userId}/rooms/{roomId}/account_data/{type}`
 ///
 /// Gets some room account data for the sender user.
-pub async fn get_room_account_data_route(
+pub(crate) async fn get_room_account_data_route(
 	body: Ruma<get_room_account_data::v3::Request>,
 ) -> Result<get_room_account_data::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");

src/api/client_server/context.rs

@@ -15,7 +15,7 @@ use crate::{services, Error, Result, Ruma};
 /// - Only works if the user is joined (TODO: always allow, but only show events
 ///   if the user was
 /// joined, depending on history_visibility)
-pub async fn get_context_route(body: Ruma<get_context::v3::Request>) -> Result<get_context::v3::Response> {
+pub(crate) async fn get_context_route(body: Ruma<get_context::v3::Request>) -> Result<get_context::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 	let sender_device = body.sender_device.as_ref().expect("user is authenticated");
 

src/api/client_server/device.rs

@@ -10,7 +10,7 @@ use crate::{services, utils, Error, Result, Ruma};
 /// # `GET /_matrix/client/r0/devices`
 ///
 /// Get metadata on all devices of the sender user.
-pub async fn get_devices_route(body: Ruma<get_devices::v3::Request>) -> Result<get_devices::v3::Response> {
+pub(crate) async fn get_devices_route(body: Ruma<get_devices::v3::Request>) -> Result<get_devices::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	let devices: Vec<device::Device> = services()
@@ -27,7 +27,7 @@ pub async fn get_devices_route(body: Ruma<get_devices::v3::Request>) -> Result<g
 /// # `GET /_matrix/client/r0/devices/{deviceId}`
 ///
 /// Get metadata on a single device of the sender user.
-pub async fn get_device_route(body: Ruma<get_device::v3::Request>) -> Result<get_device::v3::Response> {
+pub(crate) async fn get_device_route(body: Ruma<get_device::v3::Request>) -> Result<get_device::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	let device = services()
@@ -43,7 +43,7 @@ pub async fn get_device_route(body: Ruma<get_device::v3::Request>) -> Result<get
 /// # `PUT /_matrix/client/r0/devices/{deviceId}`
 ///
 /// Updates the metadata on a given device of the sender user.
-pub async fn update_device_route(body: Ruma<update_device::v3::Request>) -> Result<update_device::v3::Response> {
+pub(crate) async fn update_device_route(body: Ruma<update_device::v3::Request>) -> Result<update_device::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	let mut device = services()
@@ -70,7 +70,7 @@ pub async fn update_device_route(body: Ruma<update_device::v3::Request>) -> Resu
 ///   last seen ts)
 /// - Forgets to-device events
 /// - Triggers device list updates
-pub async fn delete_device_route(body: Ruma<delete_device::v3::Request>) -> Result<delete_device::v3::Response> {
+pub(crate) async fn delete_device_route(body: Ruma<delete_device::v3::Request>) -> Result<delete_device::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 	let sender_device = body.sender_device.as_ref().expect("user is authenticated");
 
@@ -122,7 +122,9 @@ pub async fn delete_device_route(body: Ruma<delete_device::v3::Request>) -> Resu
 ///   last seen ts)
 /// - Forgets to-device events
 /// - Triggers device list updates
-pub async fn delete_devices_route(body: Ruma<delete_devices::v3::Request>) -> Result<delete_devices::v3::Response> {
+pub(crate) async fn delete_devices_route(
+	body: Ruma<delete_devices::v3::Request>,
+) -> Result<delete_devices::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 	let sender_device = body.sender_device.as_ref().expect("user is authenticated");
 

src/api/client_server/directory.rs

@@ -31,7 +31,7 @@ use crate::{services, Error, Result, Ruma};
 /// Lists the public rooms on this server.
 ///
 /// - Rooms are ordered by the number of joined members
-pub async fn get_public_rooms_filtered_route(
+pub(crate) async fn get_public_rooms_filtered_route(
 	body: Ruma<get_public_rooms_filtered::v3::Request>,
 ) -> Result<get_public_rooms_filtered::v3::Response> {
 	if let Some(server) = &body.server {
@@ -68,7 +68,7 @@ pub async fn get_public_rooms_filtered_route(
 /// Lists the public rooms on this server.
 ///
 /// - Rooms are ordered by the number of joined members
-pub async fn get_public_rooms_route(
+pub(crate) async fn get_public_rooms_route(
 	body: Ruma<get_public_rooms::v3::Request>,
 ) -> Result<get_public_rooms::v3::Response> {
 	if let Some(server) = &body.server {
@@ -110,7 +110,7 @@ pub async fn get_public_rooms_route(
 /// Sets the visibility of a given room in the room directory.
 ///
 /// - TODO: Access control checks
-pub async fn set_room_visibility_route(
+pub(crate) async fn set_room_visibility_route(
 	body: Ruma<set_room_visibility::v3::Request>,
 ) -> Result<set_room_visibility::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -153,7 +153,7 @@ pub async fn set_room_visibility_route(
 /// # `GET /_matrix/client/r0/directory/list/room/{roomId}`
 ///
 /// Gets the visibility of a given room in the room directory.
-pub async fn get_room_visibility_route(
+pub(crate) async fn get_room_visibility_route(
 	body: Ruma<get_room_visibility::v3::Request>,
 ) -> Result<get_room_visibility::v3::Response> {
 	if !services().rooms.metadata.exists(&body.room_id)? {

src/api/client_server/filter.rs

@@ -10,7 +10,7 @@ use crate::{services, Error, Result, Ruma};
 /// Loads a filter that was previously created.
 ///
 /// - A user can only access their own filters
-pub async fn get_filter_route(body: Ruma<get_filter::v3::Request>) -> Result<get_filter::v3::Response> {
+pub(crate) async fn get_filter_route(body: Ruma<get_filter::v3::Request>) -> Result<get_filter::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 	let Some(filter) = services().users.get_filter(sender_user, &body.filter_id)? else {
 		return Err(Error::BadRequest(ErrorKind::NotFound, "Filter not found."));
@@ -22,7 +22,7 @@ pub async fn get_filter_route(body: Ruma<get_filter::v3::Request>) -> Result<get
 /// # `PUT /_matrix/client/r0/user/{userId}/filter`
 ///
 /// Creates a new filter to be used by other endpoints.
-pub async fn create_filter_route(body: Ruma<create_filter::v3::Request>) -> Result<create_filter::v3::Response> {
+pub(crate) async fn create_filter_route(body: Ruma<create_filter::v3::Request>) -> Result<create_filter::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 	Ok(create_filter::v3::Response::new(
 		services().users.create_filter(sender_user, &body.filter)?,

src/api/client_server/keys.rs

@@ -29,7 +29,7 @@ use crate::{services, utils, Error, Result, Ruma};
 /// - Adds one time keys
 /// - If there are no device keys yet: Adds device keys (TODO: merge with
 ///   existing keys?)
-pub async fn upload_keys_route(body: Ruma<upload_keys::v3::Request>) -> Result<upload_keys::v3::Response> {
+pub(crate) async fn upload_keys_route(body: Ruma<upload_keys::v3::Request>) -> Result<upload_keys::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 	let sender_device = body.sender_device.as_ref().expect("user is authenticated");
 
@@ -68,7 +68,7 @@ pub async fn upload_keys_route(body: Ruma<upload_keys::v3::Request>) -> Result<u
 /// - Gets master keys, self-signing keys, user signing keys and device keys.
 /// - The master and self-signing keys contain signatures that the user is
 ///   allowed to see
-pub async fn get_keys_route(body: Ruma<get_keys::v3::Request>) -> Result<get_keys::v3::Response> {
+pub(crate) async fn get_keys_route(body: Ruma<get_keys::v3::Request>) -> Result<get_keys::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	let response = get_keys_helper(
@@ -85,7 +85,7 @@ pub async fn get_keys_route(body: Ruma<get_keys::v3::Request>) -> Result<get_key
 /// # `POST /_matrix/client/r0/keys/claim`
 ///
 /// Claims one-time keys
-pub async fn claim_keys_route(body: Ruma<claim_keys::v3::Request>) -> Result<claim_keys::v3::Response> {
+pub(crate) async fn claim_keys_route(body: Ruma<claim_keys::v3::Request>) -> Result<claim_keys::v3::Response> {
 	let response = claim_keys_helper(&body.one_time_keys).await?;
 
 	Ok(response)
@@ -96,7 +96,7 @@ pub async fn claim_keys_route(body: Ruma<claim_keys::v3::Request>) -> Result<cla
 /// Uploads end-to-end key information for the sender user.
 ///
 /// - Requires UIAA to verify password
-pub async fn upload_signing_keys_route(
+pub(crate) async fn upload_signing_keys_route(
 	body: Ruma<upload_signing_keys::v3::Request>,
 ) -> Result<upload_signing_keys::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -147,7 +147,7 @@ pub async fn upload_signing_keys_route(
 /// # `POST /_matrix/client/r0/keys/signatures/upload`
 ///
 /// Uploads end-to-end key signatures from the sender user.
-pub async fn upload_signatures_route(
+pub(crate) async fn upload_signatures_route(
 	body: Ruma<upload_signatures::v3::Request>,
 ) -> Result<upload_signatures::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -193,7 +193,9 @@ pub async fn upload_signatures_route(
 /// previous sync token.
 ///
 /// - TODO: left users
-pub async fn get_key_changes_route(body: Ruma<get_key_changes::v3::Request>) -> Result<get_key_changes::v3::Response> {
+pub(crate) async fn get_key_changes_route(
+	body: Ruma<get_key_changes::v3::Request>,
+) -> Result<get_key_changes::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	let mut device_list_updates = HashSet::new();

src/api/client_server/media.rs

@@ -24,7 +24,7 @@ const MXC_LENGTH: usize = 32;
 /// # `GET /_matrix/media/v3/config`
 ///
 /// Returns max upload size.
-pub async fn get_media_config_route(
+pub(crate) async fn get_media_config_route(
 	_body: Ruma<get_media_config::v3::Request>,
 ) -> Result<get_media_config::v3::Response> {
 	Ok(get_media_config::v3::Response {
@@ -39,7 +39,7 @@ pub async fn get_media_config_route(
 /// See <https://spec.matrix.org/legacy/legacy/#id27>
 ///
 /// Returns max upload size.
-pub async fn get_media_config_v1_route(
+pub(crate) async fn get_media_config_v1_route(
 	_body: Ruma<get_media_config::v3::Request>,
 ) -> Result<RumaResponse<get_media_config::v3::Response>> {
 	Ok(get_media_config::v3::Response {
@@ -51,7 +51,7 @@ pub async fn get_media_config_v1_route(
 /// # `GET /_matrix/media/v3/preview_url`
 ///
 /// Returns URL preview.
-pub async fn get_media_preview_route(
+pub(crate) async fn get_media_preview_route(
 	body: Ruma<get_media_preview::v3::Request>,
 ) -> Result<get_media_preview::v3::Response> {
 	let url = &body.url;
@@ -95,7 +95,7 @@ pub async fn get_media_preview_route(
 /// See <https://spec.matrix.org/legacy/legacy/#id27>
 ///
 /// Returns URL preview.
-pub async fn get_media_preview_v1_route(
+pub(crate) async fn get_media_preview_v1_route(
 	body: Ruma<get_media_preview::v3::Request>,
 ) -> Result<RumaResponse<get_media_preview::v3::Response>> {
 	let url = &body.url;
@@ -138,7 +138,9 @@ pub async fn get_media_preview_v1_route(
 ///
 /// - Some metadata will be saved in the database
 /// - Media will be saved in the media/ directory
-pub async fn create_content_route(body: Ruma<create_content::v3::Request>) -> Result<create_content::v3::Response> {
+pub(crate) async fn create_content_route(
+	body: Ruma<create_content::v3::Request>,
+) -> Result<create_content::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	let mxc = format!(
@@ -179,7 +181,7 @@ pub async fn create_content_route(body: Ruma<create_content::v3::Request>) -> Re
 ///
 /// - Some metadata will be saved in the database
 /// - Media will be saved in the media/ directory
-pub async fn create_content_v1_route(
+pub(crate) async fn create_content_v1_route(
 	body: Ruma<create_content::v3::Request>,
 ) -> Result<RumaResponse<create_content::v3::Response>> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -214,7 +216,7 @@ pub async fn create_content_v1_route(
 }
 
 /// helper method to fetch remote media from other servers over federation
-pub async fn get_remote_content(
+pub(crate) async fn get_remote_content(
 	mxc: &str, server_name: &ruma::ServerName, media_id: String, allow_redirect: bool, timeout_ms: Duration,
 ) -> Result<get_content::v3::Response, Error> {
 	// we'll lie to the client and say the blocked server's media was not found and
@@ -267,7 +269,7 @@ pub async fn get_remote_content(
 /// - Only redirects if `allow_redirect` is true
 /// - Uses client-provided `timeout_ms` if available, else defaults to 20
 ///   seconds
-pub async fn get_content_route(body: Ruma<get_content::v3::Request>) -> Result<get_content::v3::Response> {
+pub(crate) async fn get_content_route(body: Ruma<get_content::v3::Request>) -> Result<get_content::v3::Response> {
 	let mxc = format!("mxc://{}/{}", body.server_name, body.media_id);
 
 	if let Some(FileMeta {
@@ -310,7 +312,7 @@ pub async fn get_content_route(body: Ruma<get_content::v3::Request>) -> Result<g
 /// - Only redirects if `allow_redirect` is true
 /// - Uses client-provided `timeout_ms` if available, else defaults to 20
 ///   seconds
-pub async fn get_content_v1_route(
+pub(crate) async fn get_content_v1_route(
 	body: Ruma<get_content::v3::Request>,
 ) -> Result<RumaResponse<get_content::v3::Response>> {
 	let mxc = format!("mxc://{}/{}", body.server_name, body.media_id);
@@ -352,7 +354,7 @@ pub async fn get_content_v1_route(
 /// - Only redirects if `allow_redirect` is true
 /// - Uses client-provided `timeout_ms` if available, else defaults to 20
 ///   seconds
-pub async fn get_content_as_filename_route(
+pub(crate) async fn get_content_as_filename_route(
 	body: Ruma<get_content_as_filename::v3::Request>,
 ) -> Result<get_content_as_filename::v3::Response> {
 	let mxc = format!("mxc://{}/{}", body.server_name, body.media_id);
@@ -404,7 +406,7 @@ pub async fn get_content_as_filename_route(
 /// - Only redirects if `allow_redirect` is true
 /// - Uses client-provided `timeout_ms` if available, else defaults to 20
 ///   seconds
-pub async fn get_content_as_filename_v1_route(
+pub(crate) async fn get_content_as_filename_v1_route(
 	body: Ruma<get_content_as_filename::v3::Request>,
 ) -> Result<RumaResponse<get_content_as_filename::v3::Response>> {
 	let mxc = format!("mxc://{}/{}", body.server_name, body.media_id);
@@ -454,7 +456,7 @@ pub async fn get_content_as_filename_v1_route(
 /// - Only redirects if `allow_redirect` is true
 /// - Uses client-provided `timeout_ms` if available, else defaults to 20
 ///   seconds
-pub async fn get_content_thumbnail_route(
+pub(crate) async fn get_content_thumbnail_route(
 	body: Ruma<get_content_thumbnail::v3::Request>,
 ) -> Result<get_content_thumbnail::v3::Response> {
 	let mxc = format!("mxc://{}/{}", body.server_name, body.media_id);
@@ -545,7 +547,7 @@ pub async fn get_content_thumbnail_route(
 /// - Only redirects if `allow_redirect` is true
 /// - Uses client-provided `timeout_ms` if available, else defaults to 20
 ///   seconds
-pub async fn get_content_thumbnail_v1_route(
+pub(crate) async fn get_content_thumbnail_v1_route(
 	body: Ruma<get_content_thumbnail::v3::Request>,
 ) -> Result<RumaResponse<get_content_thumbnail::v3::Response>> {
 	let mxc = format!("mxc://{}/{}", body.server_name, body.media_id);

src/api/client_server/membership.rs

@@ -45,7 +45,9 @@ use crate::{
 ///   rules locally
 /// - If the server does not know about the room: asks other servers over
 ///   federation
-pub async fn join_room_by_id_route(body: Ruma<join_room_by_id::v3::Request>) -> Result<join_room_by_id::v3::Response> {
+pub(crate) async fn join_room_by_id_route(
+	body: Ruma<join_room_by_id::v3::Request>,
+) -> Result<join_room_by_id::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	if services().rooms.metadata.is_banned(&body.room_id)? && !services().users.is_admin(sender_user)? {
@@ -118,7 +120,7 @@ pub async fn join_room_by_id_route(body: Ruma<join_room_by_id::v3::Request>) ->
 /// - If the server does not know about the room: use the server name query
 ///   param if specified. if not specified, asks other servers over federation
 ///   via room alias server name and room ID server name
-pub async fn join_room_by_id_or_alias_route(
+pub(crate) async fn join_room_by_id_or_alias_route(
 	body: Ruma<join_room_by_id_or_alias::v3::Request>,
 ) -> Result<join_room_by_id_or_alias::v3::Response> {
 	let sender_user = body.sender_user.as_deref().expect("user is authenticated");
@@ -291,7 +293,7 @@ pub async fn join_room_by_id_or_alias_route(
 /// Tries to leave the sender user from a room.
 ///
 /// - This should always work if the user is currently joined.
-pub async fn leave_room_route(body: Ruma<leave_room::v3::Request>) -> Result<leave_room::v3::Response> {
+pub(crate) async fn leave_room_route(body: Ruma<leave_room::v3::Request>) -> Result<leave_room::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	leave_room(sender_user, &body.room_id, body.reason.clone()).await?;
@@ -302,7 +304,7 @@ pub async fn leave_room_route(body: Ruma<leave_room::v3::Request>) -> Result<lea
 /// # `POST /_matrix/client/r0/rooms/{roomId}/invite`
 ///
 /// Tries to send an invite event into the room.
-pub async fn invite_user_route(body: Ruma<invite_user::v3::Request>) -> Result<invite_user::v3::Response> {
+pub(crate) async fn invite_user_route(body: Ruma<invite_user::v3::Request>) -> Result<invite_user::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	if !services().users.is_admin(sender_user)? && services().globals.block_non_admin_invites() {
@@ -355,7 +357,7 @@ pub async fn invite_user_route(body: Ruma<invite_user::v3::Request>) -> Result<i
 /// # `POST /_matrix/client/r0/rooms/{roomId}/kick`
 ///
 /// Tries to send a kick event into the room.
-pub async fn kick_user_route(body: Ruma<kick_user::v3::Request>) -> Result<kick_user::v3::Response> {
+pub(crate) async fn kick_user_route(body: Ruma<kick_user::v3::Request>) -> Result<kick_user::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	if let Ok(true) = services()
@@ -420,7 +422,7 @@ pub async fn kick_user_route(body: Ruma<kick_user::v3::Request>) -> Result<kick_
 /// # `POST /_matrix/client/r0/rooms/{roomId}/ban`
 ///
 /// Tries to send a ban event into the room.
-pub async fn ban_user_route(body: Ruma<ban_user::v3::Request>) -> Result<ban_user::v3::Response> {
+pub(crate) async fn ban_user_route(body: Ruma<ban_user::v3::Request>) -> Result<ban_user::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	if let Ok(Some(membership_event)) = services()
@@ -506,7 +508,7 @@ pub async fn ban_user_route(body: Ruma<ban_user::v3::Request>) -> Result<ban_use
 /// # `POST /_matrix/client/r0/rooms/{roomId}/unban`
 ///
 /// Tries to send an unban event into the room.
-pub async fn unban_user_route(body: Ruma<unban_user::v3::Request>) -> Result<unban_user::v3::Response> {
+pub(crate) async fn unban_user_route(body: Ruma<unban_user::v3::Request>) -> Result<unban_user::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	if let Ok(Some(membership_event)) = services()
@@ -577,7 +579,7 @@ pub async fn unban_user_route(body: Ruma<unban_user::v3::Request>) -> Result<unb
 ///
 /// Note: Other devices of the user have no way of knowing the room was
 /// forgotten, so this has to be called from every device
-pub async fn forget_room_route(body: Ruma<forget_room::v3::Request>) -> Result<forget_room::v3::Response> {
+pub(crate) async fn forget_room_route(body: Ruma<forget_room::v3::Request>) -> Result<forget_room::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	services()
@@ -591,7 +593,7 @@ pub async fn forget_room_route(body: Ruma<forget_room::v3::Request>) -> Result<f
 /// # `POST /_matrix/client/r0/joined_rooms`
 ///
 /// Lists all rooms the user has joined.
-pub async fn joined_rooms_route(body: Ruma<joined_rooms::v3::Request>) -> Result<joined_rooms::v3::Response> {
+pub(crate) async fn joined_rooms_route(body: Ruma<joined_rooms::v3::Request>) -> Result<joined_rooms::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	Ok(joined_rooms::v3::Response {
@@ -610,7 +612,7 @@ pub async fn joined_rooms_route(body: Ruma<joined_rooms::v3::Request>) -> Result
 /// specific membership).
 ///
 /// - Only works if the user is currently joined
-pub async fn get_member_events_route(
+pub(crate) async fn get_member_events_route(
 	body: Ruma<get_member_events::v3::Request>,
 ) -> Result<get_member_events::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -645,7 +647,9 @@ pub async fn get_member_events_route(
 ///
 /// - The sender user must be in the room
 /// - TODO: An appservice just needs a puppet joined
-pub async fn joined_members_route(body: Ruma<joined_members::v3::Request>) -> Result<joined_members::v3::Response> {
+pub(crate) async fn joined_members_route(
+	body: Ruma<joined_members::v3::Request>,
+) -> Result<joined_members::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	if !services()
@@ -1600,7 +1604,7 @@ pub(crate) async fn invite_helper(
 }
 
 // Make a user leave all their joined rooms
-pub async fn leave_all_rooms(user_id: &UserId) -> Result<()> {
+pub(crate) async fn leave_all_rooms(user_id: &UserId) -> Result<()> {
 	let all_rooms = services()
 		.rooms
 		.state_cache
@@ -1626,7 +1630,7 @@ pub async fn leave_all_rooms(user_id: &UserId) -> Result<()> {
 	Ok(())
 }
 
-pub async fn leave_room(user_id: &UserId, room_id: &RoomId, reason: Option<String>) -> Result<()> {
+pub(crate) async fn leave_room(user_id: &UserId, room_id: &RoomId, reason: Option<String>) -> Result<()> {
 	// Ask a remote server if we don't have this room
 	if !services()
 		.rooms

src/api/client_server/message.rs

@@ -28,7 +28,7 @@ use crate::{
 /// - The only requirement for the content is that it has to be valid json
 /// - Tries to send the event into the room, auth rules will determine if it is
 ///   allowed
-pub async fn send_message_event_route(
+pub(crate) async fn send_message_event_route(
 	body: Ruma<send_message_event::v3::Request>,
 ) -> Result<send_message_event::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -119,7 +119,7 @@ pub async fn send_message_event_route(
 /// - Only works if the user is joined (TODO: always allow, but only show events
 ///   where the user was
 /// joined, depending on `history_visibility`)
-pub async fn get_message_events_route(
+pub(crate) async fn get_message_events_route(
 	body: Ruma<get_message_events::v3::Request>,
 ) -> Result<get_message_events::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");

src/api/client_server/mod.rs

@@ -34,50 +34,50 @@ mod unversioned;
 mod user_directory;
 mod voip;
 
-pub use account::*;
+pub(crate) use account::*;
-pub use alias::*;
+pub(crate) use alias::*;
-pub use backup::*;
+pub(crate) use backup::*;
-pub use capabilities::*;
+pub(crate) use capabilities::*;
-pub use config::*;
+pub(crate) use config::*;
-pub use context::*;
+pub(crate) use context::*;
-pub use device::*;
+pub(crate) use device::*;
-pub use directory::*;
+pub(crate) use directory::*;
-pub use filter::*;
+pub(crate) use filter::*;
-pub use keys::*;
+pub(crate) use keys::*;
-pub use media::*;
+pub(crate) use media::*;
-pub use membership::*;
+pub(crate) use membership::*;
-pub use message::*;
+pub(crate) use message::*;
-pub use presence::*;
+pub(crate) use presence::*;
-pub use profile::*;
+pub(crate) use profile::*;
-pub use push::*;
+pub(crate) use push::*;
-pub use read_marker::*;
+pub(crate) use read_marker::*;
-pub use redact::*;
+pub(crate) use redact::*;
-pub use relations::*;
+pub(crate) use relations::*;
-pub use report::*;
+pub(crate) use report::*;
-pub use room::*;
+pub(crate) use room::*;
-pub use search::*;
+pub(crate) use search::*;
-pub use session::*;
+pub(crate) use session::*;
-pub use space::*;
+pub(crate) use space::*;
-pub use state::*;
+pub(crate) use state::*;
-pub use sync::*;
+pub(crate) use sync::*;
-pub use tag::*;
+pub(crate) use tag::*;
-pub use thirdparty::*;
+pub(crate) use thirdparty::*;
-pub use threads::*;
+pub(crate) use threads::*;
-pub use to_device::*;
+pub(crate) use to_device::*;
-pub use typing::*;
+pub(crate) use typing::*;
-pub use unstable::*;
+pub(crate) use unstable::*;
-pub use unversioned::*;
+pub(crate) use unversioned::*;
-pub use user_directory::*;
+pub(crate) use user_directory::*;
-pub use voip::*;
+pub(crate) use voip::*;
 
 /// generated device ID length
-pub const DEVICE_ID_LENGTH: usize = 10;
+const DEVICE_ID_LENGTH: usize = 10;
 
 /// generated user access token length
-pub const TOKEN_LENGTH: usize = 32;
+const TOKEN_LENGTH: usize = 32;
 
 /// generated user session ID length
-pub const SESSION_ID_LENGTH: usize = 32;
+pub(crate) const SESSION_ID_LENGTH: usize = 32;
 
 /// auto-generated password length
-pub const AUTO_GEN_PASSWORD_LENGTH: usize = 25;
+pub(crate) const AUTO_GEN_PASSWORD_LENGTH: usize = 25;

src/api/client_server/presence.rs

@@ -10,7 +10,7 @@ use crate::{services, Error, Result, Ruma};
 /// # `PUT /_matrix/client/r0/presence/{userId}/status`
 ///
 /// Sets the presence state of the sender user.
-pub async fn set_presence_route(body: Ruma<set_presence::v3::Request>) -> Result<set_presence::v3::Response> {
+pub(crate) async fn set_presence_route(body: Ruma<set_presence::v3::Request>) -> Result<set_presence::v3::Response> {
 	if !services().globals.allow_local_presence() {
 		return Err(Error::BadRequest(ErrorKind::forbidden(), "Presence is disabled on this server"));
 	}
@@ -28,7 +28,7 @@ pub async fn set_presence_route(body: Ruma<set_presence::v3::Request>) -> Result
 /// Gets the presence state of the given user.
 ///
 /// - Only works if you share a room with the user
-pub async fn get_presence_route(body: Ruma<get_presence::v3::Request>) -> Result<get_presence::v3::Response> {
+pub(crate) async fn get_presence_route(body: Ruma<get_presence::v3::Request>) -> Result<get_presence::v3::Response> {
 	if !services().globals.allow_local_presence() {
 		return Err(Error::BadRequest(ErrorKind::forbidden(), "Presence is disabled on this server"));
 	}

src/api/client_server/profile.rs

@@ -20,7 +20,7 @@ use crate::{service::pdu::PduBuilder, services, Error, Result, Ruma};
 /// Updates the displayname.
 ///
 /// - Also makes sure other users receive the update using presence EDUs
-pub async fn set_displayname_route(
+pub(crate) async fn set_displayname_route(
 	body: Ruma<set_display_name::v3::Request>,
 ) -> Result<set_display_name::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -102,7 +102,7 @@ pub async fn set_displayname_route(
 ///
 /// - If user is on another server and we do not have a local copy already
 /// fetch displayname over federation
-pub async fn get_displayname_route(
+pub(crate) async fn get_displayname_route(
 	body: Ruma<get_display_name::v3::Request>,
 ) -> Result<get_display_name::v3::Response> {
 	if body.user_id.server_name() != services().globals.server_name() {
@@ -157,7 +157,9 @@ pub async fn get_displayname_route(
 /// Updates the `avatar_url` and `blurhash`.
 ///
 /// - Also makes sure other users receive the update using presence EDUs
-pub async fn set_avatar_url_route(body: Ruma<set_avatar_url::v3::Request>) -> Result<set_avatar_url::v3::Response> {
+pub(crate) async fn set_avatar_url_route(
+	body: Ruma<set_avatar_url::v3::Request>,
+) -> Result<set_avatar_url::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	services()
@@ -242,7 +244,9 @@ pub async fn set_avatar_url_route(body: Ruma<set_avatar_url::v3::Request>) -> Re
 ///
 /// - If user is on another server and we do not have a local copy already
 /// fetch `avatar_url` and blurhash over federation
-pub async fn get_avatar_url_route(body: Ruma<get_avatar_url::v3::Request>) -> Result<get_avatar_url::v3::Response> {
+pub(crate) async fn get_avatar_url_route(
+	body: Ruma<get_avatar_url::v3::Request>,
+) -> Result<get_avatar_url::v3::Response> {
 	if body.user_id.server_name() != services().globals.server_name() {
 		// Create and update our local copy of the user
 		if let Ok(response) = services()
@@ -298,7 +302,7 @@ pub async fn get_avatar_url_route(body: Ruma<get_avatar_url::v3::Request>) -> Re
 ///
 /// - If user is on another server and we do not have a local copy already,
 /// fetch profile over federation.
-pub async fn get_profile_route(body: Ruma<get_profile::v3::Request>) -> Result<get_profile::v3::Response> {
+pub(crate) async fn get_profile_route(body: Ruma<get_profile::v3::Request>) -> Result<get_profile::v3::Response> {
 	if body.user_id.server_name() != services().globals.server_name() {
 		// Create and update our local copy of the user
 		if let Ok(response) = services()

src/api/client_server/push.rs

@@ -15,7 +15,7 @@ use crate::{services, Error, Result, Ruma};
 /// # `GET /_matrix/client/r0/pushrules/`
 ///
 /// Retrieves the push rules event for this user.
-pub async fn get_pushrules_all_route(
+pub(crate) async fn get_pushrules_all_route(
 	body: Ruma<get_pushrules_all::v3::Request>,
 ) -> Result<get_pushrules_all::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -55,7 +55,7 @@ pub async fn get_pushrules_all_route(
 /// # `GET /_matrix/client/r0/pushrules/{scope}/{kind}/{ruleId}`
 ///
 /// Retrieves a single specified push rule for this user.
-pub async fn get_pushrule_route(body: Ruma<get_pushrule::v3::Request>) -> Result<get_pushrule::v3::Response> {
+pub(crate) async fn get_pushrule_route(body: Ruma<get_pushrule::v3::Request>) -> Result<get_pushrule::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	let event = services()
@@ -84,7 +84,7 @@ pub async fn get_pushrule_route(body: Ruma<get_pushrule::v3::Request>) -> Result
 /// # `PUT /_matrix/client/r0/pushrules/{scope}/{kind}/{ruleId}`
 ///
 /// Creates a single specified push rule for this user.
-pub async fn set_pushrule_route(body: Ruma<set_pushrule::v3::Request>) -> Result<set_pushrule::v3::Response> {
+pub(crate) async fn set_pushrule_route(body: Ruma<set_pushrule::v3::Request>) -> Result<set_pushrule::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 	let body = body.body;
 
@@ -147,7 +147,7 @@ pub async fn set_pushrule_route(body: Ruma<set_pushrule::v3::Request>) -> Result
 /// # `GET /_matrix/client/r0/pushrules/{scope}/{kind}/{ruleId}/actions`
 ///
 /// Gets the actions of a single specified push rule for this user.
-pub async fn get_pushrule_actions_route(
+pub(crate) async fn get_pushrule_actions_route(
 	body: Ruma<get_pushrule_actions::v3::Request>,
 ) -> Result<get_pushrule_actions::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -182,7 +182,7 @@ pub async fn get_pushrule_actions_route(
 /// # `PUT /_matrix/client/r0/pushrules/{scope}/{kind}/{ruleId}/actions`
 ///
 /// Sets the actions of a single specified push rule for this user.
-pub async fn set_pushrule_actions_route(
+pub(crate) async fn set_pushrule_actions_route(
 	body: Ruma<set_pushrule_actions::v3::Request>,
 ) -> Result<set_pushrule_actions::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -224,7 +224,7 @@ pub async fn set_pushrule_actions_route(
 /// # `GET /_matrix/client/r0/pushrules/{scope}/{kind}/{ruleId}/enabled`
 ///
 /// Gets the enabled status of a single specified push rule for this user.
-pub async fn get_pushrule_enabled_route(
+pub(crate) async fn get_pushrule_enabled_route(
 	body: Ruma<get_pushrule_enabled::v3::Request>,
 ) -> Result<get_pushrule_enabled::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -258,7 +258,7 @@ pub async fn get_pushrule_enabled_route(
 /// # `PUT /_matrix/client/r0/pushrules/{scope}/{kind}/{ruleId}/enabled`
 ///
 /// Sets the enabled status of a single specified push rule for this user.
-pub async fn set_pushrule_enabled_route(
+pub(crate) async fn set_pushrule_enabled_route(
 	body: Ruma<set_pushrule_enabled::v3::Request>,
 ) -> Result<set_pushrule_enabled::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -300,7 +300,9 @@ pub async fn set_pushrule_enabled_route(
 /// # `DELETE /_matrix/client/r0/pushrules/{scope}/{kind}/{ruleId}`
 ///
 /// Deletes a single specified push rule for this user.
-pub async fn delete_pushrule_route(body: Ruma<delete_pushrule::v3::Request>) -> Result<delete_pushrule::v3::Response> {
+pub(crate) async fn delete_pushrule_route(
+	body: Ruma<delete_pushrule::v3::Request>,
+) -> Result<delete_pushrule::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	if body.scope != RuleScope::Global {
@@ -347,7 +349,7 @@ pub async fn delete_pushrule_route(body: Ruma<delete_pushrule::v3::Request>) ->
 /// # `GET /_matrix/client/r0/pushers`
 ///
 /// Gets all currently active pushers for the sender user.
-pub async fn get_pushers_route(body: Ruma<get_pushers::v3::Request>) -> Result<get_pushers::v3::Response> {
+pub(crate) async fn get_pushers_route(body: Ruma<get_pushers::v3::Request>) -> Result<get_pushers::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	Ok(get_pushers::v3::Response {
@@ -360,7 +362,7 @@ pub async fn get_pushers_route(body: Ruma<get_pushers::v3::Request>) -> Result<g
 /// Adds a pusher for the sender user.
 ///
 /// - TODO: Handle `append`
-pub async fn set_pushers_route(body: Ruma<set_pusher::v3::Request>) -> Result<set_pusher::v3::Response> {
+pub(crate) async fn set_pushers_route(body: Ruma<set_pusher::v3::Request>) -> Result<set_pusher::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	services()

src/api/client_server/read_marker.rs

@@ -18,7 +18,9 @@ use crate::{service::rooms::timeline::PduCount, services, Error, Result, Ruma};
 /// - Updates fully-read account data event to `fully_read`
 /// - If `read_receipt` is set: Update private marker and public read receipt
 ///   EDU
-pub async fn set_read_marker_route(body: Ruma<set_read_marker::v3::Request>) -> Result<set_read_marker::v3::Response> {
+pub(crate) async fn set_read_marker_route(
+	body: Ruma<set_read_marker::v3::Request>,
+) -> Result<set_read_marker::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	if let Some(fully_read) = &body.fully_read {
@@ -95,7 +97,9 @@ pub async fn set_read_marker_route(body: Ruma<set_read_marker::v3::Request>) ->
 /// # `POST /_matrix/client/r0/rooms/{roomId}/receipt/{receiptType}/{eventId}`
 ///
 /// Sets private read marker and public read receipt EDU.
-pub async fn create_receipt_route(body: Ruma<create_receipt::v3::Request>) -> Result<create_receipt::v3::Response> {
+pub(crate) async fn create_receipt_route(
+	body: Ruma<create_receipt::v3::Request>,
+) -> Result<create_receipt::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	if matches!(

src/api/client_server/redact.rs

@@ -13,7 +13,7 @@ use crate::{service::pdu::PduBuilder, services, Result, Ruma};
 /// Tries to send a redaction event into the room.
 ///
 /// - TODO: Handle txn id
-pub async fn redact_event_route(body: Ruma<redact_event::v3::Request>) -> Result<redact_event::v3::Response> {
+pub(crate) async fn redact_event_route(body: Ruma<redact_event::v3::Request>) -> Result<redact_event::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 	let body = body.body;
 

src/api/client_server/relations.rs

@@ -5,7 +5,7 @@ use ruma::api::client::relations::{
 use crate::{services, Result, Ruma};
 
 /// # `GET /_matrix/client/r0/rooms/{roomId}/relations/{eventId}/{relType}/{eventType}`
-pub async fn get_relating_events_with_rel_type_and_event_type_route(
+pub(crate) async fn get_relating_events_with_rel_type_and_event_type_route(
 	body: Ruma<get_relating_events_with_rel_type_and_event_type::v1::Request>,
 ) -> Result<get_relating_events_with_rel_type_and_event_type::v1::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -35,7 +35,7 @@ pub async fn get_relating_events_with_rel_type_and_event_type_route(
 }
 
 /// # `GET /_matrix/client/r0/rooms/{roomId}/relations/{eventId}/{relType}`
-pub async fn get_relating_events_with_rel_type_route(
+pub(crate) async fn get_relating_events_with_rel_type_route(
 	body: Ruma<get_relating_events_with_rel_type::v1::Request>,
 ) -> Result<get_relating_events_with_rel_type::v1::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -65,7 +65,7 @@ pub async fn get_relating_events_with_rel_type_route(
 }
 
 /// # `GET /_matrix/client/r0/rooms/{roomId}/relations/{eventId}`
-pub async fn get_relating_events_route(
+pub(crate) async fn get_relating_events_route(
 	body: Ruma<get_relating_events::v1::Request>,
 ) -> Result<get_relating_events::v1::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");

src/api/client_server/report.rs

@@ -14,7 +14,9 @@ use crate::{services, utils::HtmlEscape, Error, Result, Ruma};
 /// # `POST /_matrix/client/v3/rooms/{roomId}/report/{eventId}`
 ///
 /// Reports an inappropriate event to homeserver admins
-pub async fn report_event_route(body: Ruma<report_content::v3::Request>) -> Result<report_content::v3::Response> {
+pub(crate) async fn report_event_route(
+	body: Ruma<report_content::v3::Request>,
+) -> Result<report_content::v3::Response> {
 	// user authentication
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 

src/api/client_server/room.rs

@@ -45,7 +45,7 @@ use crate::{api::client_server::invite_helper, service::pdu::PduBuilder, service
 /// - Send events listed in initial state
 /// - Send events implied by `name` and `topic`
 /// - Send invite events
-pub async fn create_room_route(body: Ruma<create_room::v3::Request>) -> Result<create_room::v3::Response> {
+pub(crate) async fn create_room_route(body: Ruma<create_room::v3::Request>) -> Result<create_room::v3::Response> {
 	use create_room::v3::RoomPreset;
 
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -603,7 +603,9 @@ pub async fn create_room_route(body: Ruma<create_room::v3::Request>) -> Result<c
 ///
 /// - You have to currently be joined to the room (TODO: Respect history
 ///   visibility)
-pub async fn get_room_event_route(body: Ruma<get_room_event::v3::Request>) -> Result<get_room_event::v3::Response> {
+pub(crate) async fn get_room_event_route(
+	body: Ruma<get_room_event::v3::Request>,
+) -> Result<get_room_event::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	let event = services()
@@ -640,7 +642,7 @@ pub async fn get_room_event_route(body: Ruma<get_room_event::v3::Request>) -> Re
 ///
 /// - Only users joined to the room are allowed to call this, or if
 ///   `history_visibility` is world readable in the room
-pub async fn get_room_aliases_route(body: Ruma<aliases::v3::Request>) -> Result<aliases::v3::Response> {
+pub(crate) async fn get_room_aliases_route(body: Ruma<aliases::v3::Request>) -> Result<aliases::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	if !services()
@@ -674,7 +676,7 @@ pub async fn get_room_aliases_route(body: Ruma<aliases::v3::Request>) -> Result<
 /// - Transfers some state events
 /// - Moves local aliases
 /// - Modifies old room power levels to prevent users from speaking
-pub async fn upgrade_room_route(body: Ruma<upgrade_room::v3::Request>) -> Result<upgrade_room::v3::Response> {
+pub(crate) async fn upgrade_room_route(body: Ruma<upgrade_room::v3::Request>) -> Result<upgrade_room::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	if !services()

src/api/client_server/search.rs

@@ -22,7 +22,7 @@ use crate::{services, Error, Result, Ruma};
 ///
 /// - Only works if the user is currently joined to the room (TODO: Respect
 ///   history visibility)
-pub async fn search_events_route(body: Ruma<search_events::v3::Request>) -> Result<search_events::v3::Response> {
+pub(crate) async fn search_events_route(body: Ruma<search_events::v3::Request>) -> Result<search_events::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	let search_criteria = body.search_categories.room_events.as_ref().unwrap();

src/api/client_server/session.rs

@@ -33,7 +33,9 @@ struct Claims {
 ///
 /// Get the supported login types of this server. One of these should be used as
 /// the `type` field when logging in.
-pub async fn get_login_types_route(_body: Ruma<get_login_types::v3::Request>) -> Result<get_login_types::v3::Response> {
+pub(crate) async fn get_login_types_route(
+	_body: Ruma<get_login_types::v3::Request>,
+) -> Result<get_login_types::v3::Response> {
 	Ok(get_login_types::v3::Response::new(vec![
 		get_login_types::v3::LoginType::Password(PasswordLoginType::default()),
 		get_login_types::v3::LoginType::ApplicationService(ApplicationServiceLoginType::default()),
@@ -54,7 +56,7 @@ pub async fn get_login_types_route(_body: Ruma<get_login_types::v3::Request>) ->
 /// Note: You can use [`GET
 /// /_matrix/client/r0/login`](fn.get_supported_versions_route.html) to see
 /// supported login types.
-pub async fn login_route(body: Ruma<login::v3::Request>) -> Result<login::v3::Response> {
+pub(crate) async fn login_route(body: Ruma<login::v3::Request>) -> Result<login::v3::Response> {
 	// Validate login method
 	// TODO: Other login methods
 	let user_id = match &body.login_info {
@@ -235,7 +237,7 @@ pub async fn login_route(body: Ruma<login::v3::Request>) -> Result<login::v3::Re
 ///   last seen ts)
 /// - Forgets to-device events
 /// - Triggers device list updates
-pub async fn logout_route(body: Ruma<logout::v3::Request>) -> Result<logout::v3::Response> {
+pub(crate) async fn logout_route(body: Ruma<logout::v3::Request>) -> Result<logout::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 	let sender_device = body.sender_device.as_ref().expect("user is authenticated");
 
@@ -260,7 +262,7 @@ pub async fn logout_route(body: Ruma<logout::v3::Request>) -> Result<logout::v3:
 /// Note: This is equivalent to calling [`GET
 /// /_matrix/client/r0/logout`](fn.logout_route.html) from each device of this
 /// user.
-pub async fn logout_all_route(body: Ruma<logout_all::v3::Request>) -> Result<logout_all::v3::Response> {
+pub(crate) async fn logout_all_route(body: Ruma<logout_all::v3::Request>) -> Result<logout_all::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	for device_id in services().users.all_device_ids(sender_user).flatten() {

src/api/client_server/space.rs

@@ -11,7 +11,7 @@ use crate::{service::rooms::spaces::PagnationToken, services, Error, Result, Rum
 ///
 /// Paginates over the space tree in a depth-first manner to locate child rooms
 /// of a given space.
-pub async fn get_hierarchy_route(body: Ruma<get_hierarchy::v1::Request>) -> Result<get_hierarchy::v1::Response> {
+pub(crate) async fn get_hierarchy_route(body: Ruma<get_hierarchy::v1::Request>) -> Result<get_hierarchy::v1::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	let limit = body

src/api/client_server/state.rs

@@ -31,7 +31,7 @@ use crate::{
 /// - Tries to send the event into the room, auth rules will determine if it is
 ///   allowed
 /// - If event is new `canonical_alias`: Rejects if alias is incorrect
-pub async fn send_state_event_for_key_route(
+pub(crate) async fn send_state_event_for_key_route(
 	body: Ruma<send_state_event::v3::Request>,
 ) -> Result<send_state_event::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -59,7 +59,7 @@ pub async fn send_state_event_for_key_route(
 /// - Tries to send the event into the room, auth rules will determine if it is
 ///   allowed
 /// - If event is new `canonical_alias`: Rejects if alias is incorrect
-pub async fn send_state_event_for_empty_key_route(
+pub(crate) async fn send_state_event_for_empty_key_route(
 	body: Ruma<send_state_event::v3::Request>,
 ) -> Result<RumaResponse<send_state_event::v3::Response>> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -86,7 +86,7 @@ pub async fn send_state_event_for_empty_key_route(
 ///
 /// - If not joined: Only works if current room history visibility is world
 ///   readable
-pub async fn get_state_events_route(
+pub(crate) async fn get_state_events_route(
 	body: Ruma<get_state_events::v3::Request>,
 ) -> Result<get_state_events::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -122,7 +122,7 @@ pub async fn get_state_events_route(
 ///
 /// - If not joined: Only works if current room history visibility is world
 ///   readable
-pub async fn get_state_events_for_key_route(
+pub(crate) async fn get_state_events_for_key_route(
 	body: Ruma<get_state_events_for_key::v3::Request>,
 ) -> Result<get_state_events_for_key::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -177,7 +177,7 @@ pub async fn get_state_events_for_key_route(
 ///
 /// - If not joined: Only works if current room history visibility is world
 ///   readable
-pub async fn get_state_events_for_empty_key_route(
+pub(crate) async fn get_state_events_for_empty_key_route(
 	body: Ruma<get_state_events_for_key::v3::Request>,
 ) -> Result<RumaResponse<get_state_events_for_key::v3::Response>> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");

src/api/client_server/sync.rs

@@ -77,7 +77,7 @@ use crate::{
 /// - Sync is handled in an async task, multiple requests from the same device
 ///   with the same
 /// `since` will be cached
-pub async fn sync_events_route(
+pub(crate) async fn sync_events_route(
 	body: Ruma<sync_events::v3::Request>,
 ) -> Result<sync_events::v3::Response, RumaResponse<UiaaResponse>> {
 	let sender_user = body.sender_user.expect("user is authenticated");
@@ -1172,7 +1172,7 @@ fn share_encrypted_room(sender_user: &UserId, user_id: &UserId, ignore_room: &Ro
 /// POST `/_matrix/client/unstable/org.matrix.msc3575/sync`
 ///
 /// Sliding Sync endpoint (future endpoint: `/_matrix/client/v4/sync`)
-pub async fn sync_events_v4_route(
+pub(crate) async fn sync_events_v4_route(
 	body: Ruma<sync_events::v4::Request>,
 ) -> Result<sync_events::v4::Response, RumaResponse<UiaaResponse>> {
 	let sender_user = body.sender_user.expect("user is authenticated");

src/api/client_server/tag.rs

@@ -15,7 +15,7 @@ use crate::{services, Error, Result, Ruma};
 /// Adds a tag to the room.
 ///
 /// - Inserts the tag into the tag event of the room account data.
-pub async fn update_tag_route(body: Ruma<create_tag::v3::Request>) -> Result<create_tag::v3::Response> {
+pub(crate) async fn update_tag_route(body: Ruma<create_tag::v3::Request>) -> Result<create_tag::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	let event = services()
@@ -53,7 +53,7 @@ pub async fn update_tag_route(body: Ruma<create_tag::v3::Request>) -> Result<cre
 /// Deletes a tag from the room.
 ///
 /// - Removes the tag from the tag event of the room account data.
-pub async fn delete_tag_route(body: Ruma<delete_tag::v3::Request>) -> Result<delete_tag::v3::Response> {
+pub(crate) async fn delete_tag_route(body: Ruma<delete_tag::v3::Request>) -> Result<delete_tag::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	let event = services()
@@ -88,7 +88,7 @@ pub async fn delete_tag_route(body: Ruma<delete_tag::v3::Request>) -> Result<del
 /// Returns tags on the room.
 ///
 /// - Gets the tag event of the room account data.
-pub async fn get_tags_route(body: Ruma<get_tags::v3::Request>) -> Result<get_tags::v3::Response> {
+pub(crate) async fn get_tags_route(body: Ruma<get_tags::v3::Request>) -> Result<get_tags::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	let event = services()

src/api/client_server/thirdparty.rs

@@ -7,7 +7,9 @@ use crate::{Result, Ruma};
 /// # `GET /_matrix/client/r0/thirdparty/protocols`
 ///
 /// TODO: Fetches all metadata about protocols supported by the homeserver.
-pub async fn get_protocols_route(_body: Ruma<get_protocols::v3::Request>) -> Result<get_protocols::v3::Response> {
+pub(crate) async fn get_protocols_route(
+	_body: Ruma<get_protocols::v3::Request>,
+) -> Result<get_protocols::v3::Response> {
 	// TODO
 	Ok(get_protocols::v3::Response {
 		protocols: BTreeMap::new(),

src/api/client_server/threads.rs

@@ -3,7 +3,7 @@ use ruma::api::client::{error::ErrorKind, threads::get_threads};
 use crate::{services, Error, Result, Ruma};
 
 /// # `GET /_matrix/client/r0/rooms/{roomId}/threads`
-pub async fn get_threads_route(body: Ruma<get_threads::v1::Request>) -> Result<get_threads::v1::Response> {
+pub(crate) async fn get_threads_route(body: Ruma<get_threads::v1::Request>) -> Result<get_threads::v1::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	// Use limit or else 10, with maximum 100

src/api/client_server/to_device.rs

@@ -13,7 +13,7 @@ use crate::{services, Error, Result, Ruma};
 /// # `PUT /_matrix/client/r0/sendToDevice/{eventType}/{txnId}`
 ///
 /// Send a to-device event to a set of client devices.
-pub async fn send_event_to_device_route(
+pub(crate) async fn send_event_to_device_route(
 	body: Ruma<send_event_to_device::v3::Request>,
 ) -> Result<send_event_to_device::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");

src/api/client_server/typing.rs

@@ -5,7 +5,7 @@ use crate::{services, utils, Error, Result, Ruma};
 /// # `PUT /_matrix/client/r0/rooms/{roomId}/typing/{userId}`
 ///
 /// Sets the typing state of the sender user.
-pub async fn create_typing_event_route(
+pub(crate) async fn create_typing_event_route(
 	body: Ruma<create_typing_event::v3::Request>,
 ) -> Result<create_typing_event::v3::Response> {
 	use create_typing_event::v3::Typing;

src/api/client_server/unstable.rs

@@ -12,7 +12,7 @@ use crate::{services, Error, Result, Ruma};
 /// TODO: Implement pagination, currently this just returns everything
 ///
 /// An implementation of [MSC2666](https://github.com/matrix-org/matrix-spec-proposals/pull/2666)
-pub async fn get_mutual_rooms_route(
+pub(crate) async fn get_mutual_rooms_route(
 	body: Ruma<mutual_rooms::unstable::Request>,
 ) -> Result<mutual_rooms::unstable::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");

src/api/client_server/unversioned.rs

@@ -24,7 +24,7 @@ use crate::{services, Error, Result, Ruma};
 ///
 /// Note: Unstable features are used while developing new features. Clients
 /// should avoid using unstable features in their stable releases
-pub async fn get_supported_versions_route(
+pub(crate) async fn get_supported_versions_route(
 	_body: Ruma<get_supported_versions::Request>,
 ) -> Result<get_supported_versions::Response> {
 	let resp = get_supported_versions::Response {
@@ -60,7 +60,9 @@ pub async fn get_supported_versions_route(
 /// # `GET /.well-known/matrix/client`
 ///
 /// Returns the .well-known URL if it is configured, otherwise returns 404.
-pub async fn well_known_client(_body: Ruma<discover_homeserver::Request>) -> Result<discover_homeserver::Response> {
+pub(crate) async fn well_known_client(
+	_body: Ruma<discover_homeserver::Request>,
+) -> Result<discover_homeserver::Response> {
 	let client_url = match services().globals.well_known_client() {
 		Some(url) => url.to_string(),
 		None => return Err(Error::BadRequest(ErrorKind::NotFound, "Not found.")),
@@ -81,7 +83,7 @@ pub async fn well_known_client(_body: Ruma<discover_homeserver::Request>) -> Res
 /// # `GET /.well-known/matrix/support`
 ///
 /// Server support contact and support page of a homeserver's domain.
-pub async fn well_known_support(_body: Ruma<discover_support::Request>) -> Result<discover_support::Response> {
+pub(crate) async fn well_known_support(_body: Ruma<discover_support::Request>) -> Result<discover_support::Response> {
 	let support_page = services()
 		.globals
 		.well_known_support_page()
@@ -131,7 +133,7 @@ pub async fn well_known_support(_body: Ruma<discover_support::Request>) -> Resul
 ///
 /// Endpoint provided by sliding sync proxy used by some clients such as Element
 /// Web as a non-standard health check.
-pub async fn syncv3_client_server_json() -> Result<impl IntoResponse> {
+pub(crate) async fn syncv3_client_server_json() -> Result<impl IntoResponse> {
 	let server_url = match services().globals.well_known_client() {
 		Some(url) => url.to_string(),
 		None => match services().globals.well_known_server() {
@@ -155,7 +157,7 @@ pub async fn syncv3_client_server_json() -> Result<impl IntoResponse> {
 ///
 /// Conduwuit-specific API to get the server version, results akin to
 /// `/_matrix/federation/v1/version`
-pub async fn conduwuit_server_version() -> Result<impl IntoResponse> {
+pub(crate) async fn conduwuit_server_version() -> Result<impl IntoResponse> {
 	let version = match option_env!("CONDUIT_VERSION_EXTRA") {
 		Some(extra) => format!("{} ({})", env!("CARGO_PKG_VERSION"), extra),
 		None => env!("CARGO_PKG_VERSION").to_owned(),

src/api/client_server/user_directory.rs

@@ -15,7 +15,7 @@ use crate::{services, Result, Ruma};
 /// - Hides any local users that aren't in any public rooms (i.e. those that
 ///   have the join rule set to public)
 /// and don't share a room with the sender
-pub async fn search_users_route(body: Ruma<search_users::v3::Request>) -> Result<search_users::v3::Response> {
+pub(crate) async fn search_users_route(body: Ruma<search_users::v3::Request>) -> Result<search_users::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 	let limit = u64::from(body.limit) as usize;
 

src/api/client_server/voip.rs

@@ -12,7 +12,7 @@ type HmacSha1 = Hmac<Sha1>;
 /// # `GET /_matrix/client/r0/voip/turnServer`
 ///
 /// TODO: Returns information about the recommended turn server.
-pub async fn turn_server_route(
+pub(crate) async fn turn_server_route(
 	body: Ruma<get_turn_server_info::v3::Request>,
 ) -> Result<get_turn_server_info::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");

src/api/mod.rs

@@ -1,3 +1,3 @@
-pub mod client_server;
+pub(crate) mod client_server;
-pub mod ruma_wrapper;
+pub(crate) mod ruma_wrapper;
-pub mod server_server;
+pub(crate) mod server_server;

src/api/ruma_wrapper/mod.rs

@@ -7,14 +7,13 @@ use crate::{service::appservice::RegistrationInfo, Error};
 mod axum;
 
 /// Extractor for Ruma request structs
-pub struct Ruma<T> {
+pub(crate) struct Ruma<T> {
-	pub body: T,
+	pub(crate) body: T,
-	pub sender_user: Option<OwnedUserId>,
+	pub(crate) sender_user: Option<OwnedUserId>,
-	pub sender_device: Option<OwnedDeviceId>,
+	pub(crate) sender_device: Option<OwnedDeviceId>,
-	pub sender_servername: Option<OwnedServerName>,
+	pub(crate) sender_servername: Option<OwnedServerName>,
-	// This is None when body is not a valid string
+	pub(crate) json_body: Option<CanonicalJsonValue>, // This is None when body is not a valid string
-	pub json_body: Option<CanonicalJsonValue>,
+	pub(crate) appservice_info: Option<RegistrationInfo>,
-	pub appservice_info: Option<RegistrationInfo>,
 }
 
 impl<T> Deref for Ruma<T> {
@@ -24,7 +23,7 @@ impl<T> Deref for Ruma<T> {
 }
 
 #[derive(Clone)]
-pub struct RumaResponse<T>(pub T);
+pub(crate) struct RumaResponse<T>(pub(crate) T);
 
 impl<T> From<T> for RumaResponse<T> {
 	fn from(t: T) -> Self { Self(t) }

src/api/server_server.rs

@@ -60,7 +60,7 @@ use crate::{
 /// # `GET /_matrix/federation/v1/version`
 ///
 /// Get version information on this server.
-pub async fn get_server_version_route(
+pub(crate) async fn get_server_version_route(
 	_body: Ruma<get_server_version::v1::Request>,
 ) -> Result<get_server_version::v1::Response> {
 	let version = match option_env!("CONDUIT_VERSION_EXTRA") {
@@ -85,7 +85,7 @@ pub async fn get_server_version_route(
 /// forever.
 // Response type for this endpoint is Json because we need to calculate a
 // signature for the response
-pub async fn get_server_keys_route() -> Result<impl IntoResponse> {
+pub(crate) async fn get_server_keys_route() -> Result<impl IntoResponse> {
 	let mut verify_keys: BTreeMap<OwnedServerSigningKeyId, VerifyKey> = BTreeMap::new();
 	verify_keys.insert(
 		format!("ed25519:{}", services().globals.keypair().version())
@@ -132,12 +132,12 @@ pub async fn get_server_keys_route() -> Result<impl IntoResponse> {
 /// - Matrix does not support invalidating public keys, so the key returned by
 ///   this will be valid
 /// forever.
-pub async fn get_server_keys_deprecated_route() -> impl IntoResponse { get_server_keys_route().await }
+pub(crate) async fn get_server_keys_deprecated_route() -> impl IntoResponse { get_server_keys_route().await }
 
 /// # `POST /_matrix/federation/v1/publicRooms`
 ///
 /// Lists the public rooms on this server.
-pub async fn get_public_rooms_filtered_route(
+pub(crate) async fn get_public_rooms_filtered_route(
 	body: Ruma<get_public_rooms_filtered::v1::Request>,
 ) -> Result<get_public_rooms_filtered::v1::Response> {
 	if !services()
@@ -171,7 +171,7 @@ pub async fn get_public_rooms_filtered_route(
 /// # `GET /_matrix/federation/v1/publicRooms`
 ///
 /// Lists the public rooms on this server.
-pub async fn get_public_rooms_route(
+pub(crate) async fn get_public_rooms_route(
 	body: Ruma<get_public_rooms::v1::Request>,
 ) -> Result<get_public_rooms::v1::Response> {
 	if !services()
@@ -202,7 +202,7 @@ pub async fn get_public_rooms_route(
 	})
 }
 
-pub fn parse_incoming_pdu(pdu: &RawJsonValue) -> Result<(OwnedEventId, CanonicalJsonObject, OwnedRoomId)> {
+pub(crate) fn parse_incoming_pdu(pdu: &RawJsonValue) -> Result<(OwnedEventId, CanonicalJsonObject, OwnedRoomId)> {
 	let value: CanonicalJsonObject = serde_json::from_str(pdu.get()).map_err(|e| {
 		warn!("Error parsing incoming event {:?}: {:?}", pdu, e);
 		Error::BadServerResponse("Invalid PDU in server response")
@@ -231,7 +231,7 @@ pub fn parse_incoming_pdu(pdu: &RawJsonValue) -> Result<(OwnedEventId, Canonical
 /// # `PUT /_matrix/federation/v1/send/{txnId}`
 ///
 /// Push EDUs and PDUs to this server.
-pub async fn send_transaction_message_route(
+pub(crate) async fn send_transaction_message_route(
 	body: Ruma<send_transaction_message::v1::Request>,
 ) -> Result<send_transaction_message::v1::Response> {
 	let sender_servername = body
@@ -522,7 +522,7 @@ pub async fn send_transaction_message_route(
 ///
 /// - Only works if a user of this server is currently invited or joined the
 ///   room
-pub async fn get_event_route(body: Ruma<get_event::v1::Request>) -> Result<get_event::v1::Response> {
+pub(crate) async fn get_event_route(body: Ruma<get_event::v1::Request>) -> Result<get_event::v1::Response> {
 	let sender_servername = body
 		.sender_servername
 		.as_ref()
@@ -572,7 +572,7 @@ pub async fn get_event_route(body: Ruma<get_event::v1::Request>) -> Result<get_e
 ///
 /// Retrieves events from before the sender joined the room, if the room's
 /// history visibility allows.
-pub async fn get_backfill_route(body: Ruma<get_backfill::v1::Request>) -> Result<get_backfill::v1::Response> {
+pub(crate) async fn get_backfill_route(body: Ruma<get_backfill::v1::Request>) -> Result<get_backfill::v1::Response> {
 	let sender_servername = body
 		.sender_servername
 		.as_ref()
@@ -635,7 +635,7 @@ pub async fn get_backfill_route(body: Ruma<get_backfill::v1::Request>) -> Result
 /// # `POST /_matrix/federation/v1/get_missing_events/{roomId}`
 ///
 /// Retrieves events that the sender is missing.
-pub async fn get_missing_events_route(
+pub(crate) async fn get_missing_events_route(
 	body: Ruma<get_missing_events::v1::Request>,
 ) -> Result<get_missing_events::v1::Response> {
 	let sender_servername = body
@@ -718,7 +718,7 @@ pub async fn get_missing_events_route(
 /// Retrieves the auth chain for a given event.
 ///
 /// - This does not include the event itself
-pub async fn get_event_authorization_route(
+pub(crate) async fn get_event_authorization_route(
 	body: Ruma<get_event_authorization::v1::Request>,
 ) -> Result<get_event_authorization::v1::Response> {
 	let sender_servername = body
@@ -773,7 +773,9 @@ pub async fn get_event_authorization_route(
 /// # `GET /_matrix/federation/v1/state/{roomId}`
 ///
 /// Retrieves the current state of the room.
-pub async fn get_room_state_route(body: Ruma<get_room_state::v1::Request>) -> Result<get_room_state::v1::Response> {
+pub(crate) async fn get_room_state_route(
+	body: Ruma<get_room_state::v1::Request>,
+) -> Result<get_room_state::v1::Response> {
 	let sender_servername = body
 		.sender_servername
 		.as_ref()
@@ -840,7 +842,7 @@ pub async fn get_room_state_route(body: Ruma<get_room_state::v1::Request>) -> Re
 /// # `GET /_matrix/federation/v1/state_ids/{roomId}`
 ///
 /// Retrieves the current state of the room.
-pub async fn get_room_state_ids_route(
+pub(crate) async fn get_room_state_ids_route(
 	body: Ruma<get_room_state_ids::v1::Request>,
 ) -> Result<get_room_state_ids::v1::Response> {
 	let sender_servername = body
@@ -891,7 +893,7 @@ pub async fn get_room_state_ids_route(
 /// # `GET /_matrix/federation/v1/make_join/{roomId}/{userId}`
 ///
 /// Creates a join template.
-pub async fn create_join_event_template_route(
+pub(crate) async fn create_join_event_template_route(
 	body: Ruma<prepare_join_event::v1::Request>,
 ) -> Result<prepare_join_event::v1::Response> {
 	if !services().rooms.metadata.exists(&body.room_id)? {
@@ -1224,7 +1226,7 @@ async fn create_join_event(
 /// # `PUT /_matrix/federation/v1/send_join/{roomId}/{eventId}`
 ///
 /// Submits a signed join event.
-pub async fn create_join_event_v1_route(
+pub(crate) async fn create_join_event_v1_route(
 	body: Ruma<create_join_event::v1::Request>,
 ) -> Result<create_join_event::v1::Response> {
 	let sender_servername = body
@@ -1278,7 +1280,7 @@ pub async fn create_join_event_v1_route(
 /// # `PUT /_matrix/federation/v2/send_join/{roomId}/{eventId}`
 ///
 /// Submits a signed join event.
-pub async fn create_join_event_v2_route(
+pub(crate) async fn create_join_event_v2_route(
 	body: Ruma<create_join_event::v2::Request>,
 ) -> Result<create_join_event::v2::Response> {
 	let sender_servername = body
@@ -1338,7 +1340,7 @@ pub async fn create_join_event_v2_route(
 /// # `PUT /_matrix/federation/v1/make_leave/{roomId}/{eventId}`
 ///
 /// Creates a leave template.
-pub async fn create_leave_event_template_route(
+pub(crate) async fn create_leave_event_template_route(
 	body: Ruma<prepare_leave_event::v1::Request>,
 ) -> Result<prepare_leave_event::v1::Response> {
 	let sender_servername = body
@@ -1490,7 +1492,7 @@ async fn create_leave_event(sender_servername: &ServerName, room_id: &RoomId, pd
 /// # `PUT /_matrix/federation/v1/send_leave/{roomId}/{eventId}`
 ///
 /// Submits a signed leave event.
-pub async fn create_leave_event_v1_route(
+pub(crate) async fn create_leave_event_v1_route(
 	body: Ruma<create_leave_event::v1::Request>,
 ) -> Result<create_leave_event::v1::Response> {
 	let sender_servername = body
@@ -1506,7 +1508,7 @@ pub async fn create_leave_event_v1_route(
 /// # `PUT /_matrix/federation/v2/send_leave/{roomId}/{eventId}`
 ///
 /// Submits a signed leave event.
-pub async fn create_leave_event_v2_route(
+pub(crate) async fn create_leave_event_v2_route(
 	body: Ruma<create_leave_event::v2::Request>,
 ) -> Result<create_leave_event::v2::Response> {
 	let sender_servername = body
@@ -1522,7 +1524,7 @@ pub async fn create_leave_event_v2_route(
 /// # `PUT /_matrix/federation/v2/invite/{roomId}/{eventId}`
 ///
 /// Invites a remote user to a room.
-pub async fn create_invite_route(body: Ruma<create_invite::v2::Request>) -> Result<create_invite::v2::Response> {
+pub(crate) async fn create_invite_route(body: Ruma<create_invite::v2::Request>) -> Result<create_invite::v2::Response> {
 	let sender_servername = body
 		.sender_servername
 		.as_ref()
@@ -1692,7 +1694,7 @@ pub async fn create_invite_route(body: Ruma<create_invite::v2::Request>) -> Resu
 /// # `GET /_matrix/federation/v1/user/devices/{userId}`
 ///
 /// Gets information on all devices of the user.
-pub async fn get_devices_route(body: Ruma<get_devices::v1::Request>) -> Result<get_devices::v1::Response> {
+pub(crate) async fn get_devices_route(body: Ruma<get_devices::v1::Request>) -> Result<get_devices::v1::Response> {
 	if body.user_id.server_name() != services().globals.server_name() {
 		return Err(Error::BadRequest(
 			ErrorKind::InvalidParam,
@@ -1746,7 +1748,7 @@ pub async fn get_devices_route(body: Ruma<get_devices::v1::Request>) -> Result<g
 /// # `GET /_matrix/federation/v1/query/directory`
 ///
 /// Resolve a room alias to a room id.
-pub async fn get_room_information_route(
+pub(crate) async fn get_room_information_route(
 	body: Ruma<get_room_information::v1::Request>,
 ) -> Result<get_room_information::v1::Response> {
 	let room_id = services()
@@ -1786,7 +1788,7 @@ pub async fn get_room_information_route(
 ///
 ///
 /// Gets information on a profile.
-pub async fn get_profile_information_route(
+pub(crate) async fn get_profile_information_route(
 	body: Ruma<get_profile_information::v1::Request>,
 ) -> Result<get_profile_information::v1::Response> {
 	if !services()
@@ -1837,7 +1839,7 @@ pub async fn get_profile_information_route(
 /// # `POST /_matrix/federation/v1/user/keys/query`
 ///
 /// Gets devices and identity keys for the given users.
-pub async fn get_keys_route(body: Ruma<get_keys::v1::Request>) -> Result<get_keys::v1::Response> {
+pub(crate) async fn get_keys_route(body: Ruma<get_keys::v1::Request>) -> Result<get_keys::v1::Response> {
 	if body
 		.device_keys
 		.iter()
@@ -1867,7 +1869,7 @@ pub async fn get_keys_route(body: Ruma<get_keys::v1::Request>) -> Result<get_key
 /// # `POST /_matrix/federation/v1/user/keys/claim`
 ///
 /// Claims one-time keys.
-pub async fn claim_keys_route(body: Ruma<claim_keys::v1::Request>) -> Result<claim_keys::v1::Response> {
+pub(crate) async fn claim_keys_route(body: Ruma<claim_keys::v1::Request>) -> Result<claim_keys::v1::Response> {
 	if body
 		.one_time_keys
 		.iter()
@@ -1889,7 +1891,9 @@ pub async fn claim_keys_route(body: Ruma<claim_keys::v1::Request>) -> Result<cla
 /// # `GET /.well-known/matrix/server`
 ///
 /// Returns the .well-known URL if it is configured, otherwise returns 404.
-pub async fn well_known_server(_body: Ruma<discover_homeserver::Request>) -> Result<discover_homeserver::Response> {
+pub(crate) async fn well_known_server(
+	_body: Ruma<discover_homeserver::Request>,
+) -> Result<discover_homeserver::Response> {
 	Ok(discover_homeserver::Response {
 		server: match services().globals.well_known_server() {
 			Some(server_name) => server_name.to_owned(),
@@ -1902,7 +1906,7 @@ pub async fn well_known_server(_body: Ruma<discover_homeserver::Request>) -> Res
 ///
 /// Gets the space tree in a depth-first manner to locate child rooms of a given
 /// space.
-pub async fn get_hierarchy_route(body: Ruma<get_hierarchy::v1::Request>) -> Result<get_hierarchy::v1::Response> {
+pub(crate) async fn get_hierarchy_route(body: Ruma<get_hierarchy::v1::Request>) -> Result<get_hierarchy::v1::Response> {
 	let sender_servername = body
 		.sender_servername
 		.as_ref()

src/clap.rs

@@ -22,12 +22,12 @@ fn version() -> String {
 /// Commandline arguments
 #[derive(Parser, Debug)]
 #[clap(version = version(), about, long_about = None)]
-pub struct Args {
+pub(crate) struct Args {
 	#[arg(short, long)]
 	/// Optional argument to the path of a conduwuit config TOML file
-	pub config: Option<PathBuf>,
+	pub(crate) config: Option<PathBuf>,
 }
 
 /// Parse commandline arguments into structured data
 #[must_use]
-pub fn parse() -> Args { Args::parse() }
+pub(crate) fn parse() -> Args { Args::parse() }

src/config/check.rs

@@ -5,7 +5,7 @@ use tracing::{debug, error, info, warn};
 
 use crate::{utils::error::Error, Config};
 
-pub(super) fn check(config: &Config) -> Result<(), Error> {
+pub(crate) fn check(config: &Config) -> Result<(), Error> {
 	config.warn_deprecated();
 	config.warn_unknown_key();
 

src/config/mod.rs

@@ -30,323 +30,323 @@ mod proxy;
 
 #[derive(Deserialize, Clone, Debug)]
 #[serde(transparent)]
-pub struct ListeningPort {
+struct ListeningPort {
 	#[serde(with = "either::serde_untagged")]
-	pub ports: Either<u16, Vec<u16>>,
+	ports: Either<u16, Vec<u16>>,
 }
 
 /// all the config options for conduwuit
 #[derive(Clone, Debug, Deserialize)]
 #[allow(clippy::struct_excessive_bools)]
-pub struct Config {
+pub(crate) struct Config {
 	/// [`IpAddr`] conduwuit will listen on (can be IPv4 or IPv6)
 	#[serde(default = "default_address")]
-	pub address: IpAddr,
+	pub(crate) address: IpAddr,
 	/// default TCP port(s) conduwuit will listen on
 	#[serde(default = "default_port")]
-	pub port: ListeningPort,
+	port: ListeningPort,
-	pub tls: Option<TlsConfig>,
+	pub(crate) tls: Option<TlsConfig>,
-	pub unix_socket_path: Option<PathBuf>,
+	pub(crate) unix_socket_path: Option<PathBuf>,
 	#[serde(default = "default_unix_socket_perms")]
-	pub unix_socket_perms: u32,
+	pub(crate) unix_socket_perms: u32,
-	pub server_name: OwnedServerName,
+	pub(crate) server_name: OwnedServerName,
 	#[serde(default = "default_database_backend")]
-	pub database_backend: String,
+	pub(crate) database_backend: String,
-	pub database_path: PathBuf,
+	pub(crate) database_path: PathBuf,
-	pub database_backup_path: Option<PathBuf>,
+	pub(crate) database_backup_path: Option<PathBuf>,
 	#[serde(default = "default_database_backups_to_keep")]
-	pub database_backups_to_keep: i16,
+	pub(crate) database_backups_to_keep: i16,
 	#[serde(default = "default_db_cache_capacity_mb")]
-	pub db_cache_capacity_mb: f64,
+	pub(crate) db_cache_capacity_mb: f64,
 	#[serde(default = "default_new_user_displayname_suffix")]
-	pub new_user_displayname_suffix: String,
+	pub(crate) new_user_displayname_suffix: String,
 	#[serde(default)]
-	pub allow_check_for_updates: bool,
+	pub(crate) allow_check_for_updates: bool,
 
 	#[serde(default = "default_pdu_cache_capacity")]
-	pub pdu_cache_capacity: u32,
+	pub(crate) pdu_cache_capacity: u32,
 	#[serde(default = "default_conduit_cache_capacity_modifier")]
-	pub conduit_cache_capacity_modifier: f64,
+	pub(crate) conduit_cache_capacity_modifier: f64,
 	#[serde(default = "default_auth_chain_cache_capacity")]
-	pub auth_chain_cache_capacity: u32,
+	pub(crate) auth_chain_cache_capacity: u32,
 	#[serde(default = "default_shorteventid_cache_capacity")]
-	pub shorteventid_cache_capacity: u32,
+	pub(crate) shorteventid_cache_capacity: u32,
 	#[serde(default = "default_eventidshort_cache_capacity")]
-	pub eventidshort_cache_capacity: u32,
+	pub(crate) eventidshort_cache_capacity: u32,
 	#[serde(default = "default_shortstatekey_cache_capacity")]
-	pub shortstatekey_cache_capacity: u32,
+	pub(crate) shortstatekey_cache_capacity: u32,
 	#[serde(default = "default_statekeyshort_cache_capacity")]
-	pub statekeyshort_cache_capacity: u32,
+	pub(crate) statekeyshort_cache_capacity: u32,
 	#[serde(default = "default_server_visibility_cache_capacity")]
-	pub server_visibility_cache_capacity: u32,
+	pub(crate) server_visibility_cache_capacity: u32,
 	#[serde(default = "default_user_visibility_cache_capacity")]
-	pub user_visibility_cache_capacity: u32,
+	pub(crate) user_visibility_cache_capacity: u32,
 	#[serde(default = "default_stateinfo_cache_capacity")]
-	pub stateinfo_cache_capacity: u32,
+	pub(crate) stateinfo_cache_capacity: u32,
 	#[serde(default = "default_roomid_spacehierarchy_cache_capacity")]
-	pub roomid_spacehierarchy_cache_capacity: u32,
+	pub(crate) roomid_spacehierarchy_cache_capacity: u32,
 
 	#[serde(default = "default_cleanup_second_interval")]
-	pub cleanup_second_interval: u32,
+	pub(crate) cleanup_second_interval: u32,
 
 	#[serde(default = "default_dns_cache_entries")]
-	pub dns_cache_entries: u32,
+	pub(crate) dns_cache_entries: u32,
 	#[serde(default = "default_dns_min_ttl")]
-	pub dns_min_ttl: u64,
+	pub(crate) dns_min_ttl: u64,
 	#[serde(default = "default_dns_min_ttl_nxdomain")]
-	pub dns_min_ttl_nxdomain: u64,
+	pub(crate) dns_min_ttl_nxdomain: u64,
 	#[serde(default = "default_dns_attempts")]
-	pub dns_attempts: u16,
+	pub(crate) dns_attempts: u16,
 	#[serde(default = "default_dns_timeout")]
-	pub dns_timeout: u64,
+	pub(crate) dns_timeout: u64,
 	#[serde(default = "true_fn")]
-	pub dns_tcp_fallback: bool,
+	pub(crate) dns_tcp_fallback: bool,
 	#[serde(default = "true_fn")]
-	pub query_all_nameservers: bool,
+	pub(crate) query_all_nameservers: bool,
 
 	#[serde(default = "default_max_request_size")]
-	pub max_request_size: u32,
+	pub(crate) max_request_size: u32,
 	#[serde(default = "default_max_concurrent_requests")]
-	pub max_concurrent_requests: u16,
+	pub(crate) max_concurrent_requests: u16,
 	#[serde(default = "default_max_fetch_prev_events")]
-	pub max_fetch_prev_events: u16,
+	pub(crate) max_fetch_prev_events: u16,
 
 	#[serde(default = "default_request_conn_timeout")]
-	pub request_conn_timeout: u64,
+	pub(crate) request_conn_timeout: u64,
 	#[serde(default = "default_request_timeout")]
-	pub request_timeout: u64,
+	pub(crate) request_timeout: u64,
 	#[serde(default = "default_request_total_timeout")]
-	pub request_total_timeout: u64,
+	pub(crate) request_total_timeout: u64,
 	#[serde(default = "default_request_idle_timeout")]
-	pub request_idle_timeout: u64,
+	pub(crate) request_idle_timeout: u64,
 	#[serde(default = "default_request_idle_per_host")]
-	pub request_idle_per_host: u16,
+	pub(crate) request_idle_per_host: u16,
 	#[serde(default = "default_well_known_conn_timeout")]
-	pub well_known_conn_timeout: u64,
+	pub(crate) well_known_conn_timeout: u64,
 	#[serde(default = "default_well_known_timeout")]
-	pub well_known_timeout: u64,
+	pub(crate) well_known_timeout: u64,
 	#[serde(default = "default_federation_timeout")]
-	pub federation_timeout: u64,
+	pub(crate) federation_timeout: u64,
 	#[serde(default = "default_federation_idle_timeout")]
-	pub federation_idle_timeout: u64,
+	pub(crate) federation_idle_timeout: u64,
 	#[serde(default = "default_federation_idle_per_host")]
-	pub federation_idle_per_host: u16,
+	pub(crate) federation_idle_per_host: u16,
 	#[serde(default = "default_sender_timeout")]
-	pub sender_timeout: u64,
+	pub(crate) sender_timeout: u64,
 	#[serde(default = "default_sender_idle_timeout")]
-	pub sender_idle_timeout: u64,
+	pub(crate) sender_idle_timeout: u64,
 	#[serde(default = "default_sender_retry_backoff_limit")]
-	pub sender_retry_backoff_limit: u64,
+	pub(crate) sender_retry_backoff_limit: u64,
 	#[serde(default = "default_appservice_timeout")]
-	pub appservice_timeout: u64,
+	pub(crate) appservice_timeout: u64,
 	#[serde(default = "default_appservice_idle_timeout")]
-	pub appservice_idle_timeout: u64,
+	pub(crate) appservice_idle_timeout: u64,
 	#[serde(default = "default_pusher_idle_timeout")]
-	pub pusher_idle_timeout: u64,
+	pub(crate) pusher_idle_timeout: u64,
 
 	#[serde(default)]
-	pub allow_registration: bool,
+	pub(crate) allow_registration: bool,
 	#[serde(default)]
-	pub yes_i_am_very_very_sure_i_want_an_open_registration_server_prone_to_abuse: bool,
+	pub(crate) yes_i_am_very_very_sure_i_want_an_open_registration_server_prone_to_abuse: bool,
-	pub registration_token: Option<String>,
+	pub(crate) registration_token: Option<String>,
 	#[serde(default = "true_fn")]
-	pub allow_encryption: bool,
+	pub(crate) allow_encryption: bool,
 	#[serde(default = "true_fn")]
-	pub allow_federation: bool,
+	pub(crate) allow_federation: bool,
 	#[serde(default)]
-	pub allow_public_room_directory_over_federation: bool,
+	pub(crate) allow_public_room_directory_over_federation: bool,
 	#[serde(default)]
-	pub allow_public_room_directory_without_auth: bool,
+	pub(crate) allow_public_room_directory_without_auth: bool,
 	#[serde(default)]
-	pub lockdown_public_room_directory: bool,
+	pub(crate) lockdown_public_room_directory: bool,
 	#[serde(default)]
-	pub allow_device_name_federation: bool,
+	pub(crate) allow_device_name_federation: bool,
 	#[serde(default = "true_fn")]
-	pub allow_profile_lookup_federation_requests: bool,
+	pub(crate) allow_profile_lookup_federation_requests: bool,
 	#[serde(default = "true_fn")]
-	pub allow_room_creation: bool,
+	pub(crate) allow_room_creation: bool,
 	#[serde(default = "true_fn")]
-	pub allow_unstable_room_versions: bool,
+	pub(crate) allow_unstable_room_versions: bool,
 	#[serde(default = "default_default_room_version")]
-	pub default_room_version: RoomVersionId,
+	pub(crate) default_room_version: RoomVersionId,
 	#[serde(default)]
-	pub well_known: WellKnownConfig,
+	pub(crate) well_known: WellKnownConfig,
 	#[serde(default)]
-	pub allow_jaeger: bool,
+	pub(crate) allow_jaeger: bool,
 	#[serde(default)]
-	pub tracing_flame: bool,
+	pub(crate) tracing_flame: bool,
 	#[serde(default)]
-	pub proxy: ProxyConfig,
+	pub(crate) proxy: ProxyConfig,
-	pub jwt_secret: Option<String>,
+	pub(crate) jwt_secret: Option<String>,
 	#[serde(default = "default_trusted_servers")]
-	pub trusted_servers: Vec<OwnedServerName>,
+	pub(crate) trusted_servers: Vec<OwnedServerName>,
 	#[serde(default = "true_fn")]
-	pub query_trusted_key_servers_first: bool,
+	pub(crate) query_trusted_key_servers_first: bool,
 	#[serde(default = "default_log")]
-	pub log: String,
+	pub(crate) log: String,
 	#[serde(default)]
-	pub turn_username: String,
+	pub(crate) turn_username: String,
 	#[serde(default)]
-	pub turn_password: String,
+	pub(crate) turn_password: String,
 	#[serde(default = "Vec::new")]
-	pub turn_uris: Vec<String>,
+	pub(crate) turn_uris: Vec<String>,
 	#[serde(default)]
-	pub turn_secret: String,
+	pub(crate) turn_secret: String,
 	#[serde(default = "default_turn_ttl")]
-	pub turn_ttl: u64,
+	pub(crate) turn_ttl: u64,
 
 	#[serde(default = "Vec::new")]
-	pub auto_join_rooms: Vec<OwnedRoomId>,
+	pub(crate) auto_join_rooms: Vec<OwnedRoomId>,
 
 	#[serde(default = "default_rocksdb_log_level")]
-	pub rocksdb_log_level: String,
+	pub(crate) rocksdb_log_level: String,
 	#[serde(default)]
-	pub rocksdb_log_stderr: bool,
+	pub(crate) rocksdb_log_stderr: bool,
 	#[serde(default = "default_rocksdb_max_log_file_size")]
-	pub rocksdb_max_log_file_size: usize,
+	pub(crate) rocksdb_max_log_file_size: usize,
 	#[serde(default = "default_rocksdb_log_time_to_roll")]
-	pub rocksdb_log_time_to_roll: usize,
+	pub(crate) rocksdb_log_time_to_roll: usize,
 	#[serde(default)]
-	pub rocksdb_optimize_for_spinning_disks: bool,
+	pub(crate) rocksdb_optimize_for_spinning_disks: bool,
 	#[serde(default = "default_rocksdb_parallelism_threads")]
-	pub rocksdb_parallelism_threads: usize,
+	pub(crate) rocksdb_parallelism_threads: usize,
 	#[serde(default = "default_rocksdb_max_log_files")]
-	pub rocksdb_max_log_files: usize,
+	pub(crate) rocksdb_max_log_files: usize,
 	#[serde(default = "default_rocksdb_compression_algo")]
-	pub rocksdb_compression_algo: String,
+	pub(crate) rocksdb_compression_algo: String,
 	#[serde(default = "default_rocksdb_compression_level")]
-	pub rocksdb_compression_level: i32,
+	pub(crate) rocksdb_compression_level: i32,
 	#[serde(default = "default_rocksdb_bottommost_compression_level")]
-	pub rocksdb_bottommost_compression_level: i32,
+	pub(crate) rocksdb_bottommost_compression_level: i32,
 	#[serde(default)]
-	pub rocksdb_bottommost_compression: bool,
+	pub(crate) rocksdb_bottommost_compression: bool,
 	#[serde(default = "default_rocksdb_recovery_mode")]
-	pub rocksdb_recovery_mode: u8,
+	pub(crate) rocksdb_recovery_mode: u8,
 	#[serde(default)]
-	pub rocksdb_repair: bool,
+	pub(crate) rocksdb_repair: bool,
 	#[serde(default)]
-	pub rocksdb_read_only: bool,
+	pub(crate) rocksdb_read_only: bool,
 	#[serde(default)]
-	pub rocksdb_periodic_cleanup: bool,
+	pub(crate) rocksdb_periodic_cleanup: bool,
 
-	pub emergency_password: Option<String>,
+	pub(crate) emergency_password: Option<String>,
 
 	#[serde(default = "default_notification_push_path")]
-	pub notification_push_path: String,
+	pub(crate) notification_push_path: String,
 
 	#[serde(default = "true_fn")]
-	pub allow_local_presence: bool,
+	pub(crate) allow_local_presence: bool,
 	#[serde(default = "true_fn")]
-	pub allow_incoming_presence: bool,
+	pub(crate) allow_incoming_presence: bool,
 	#[serde(default = "true_fn")]
-	pub allow_outgoing_presence: bool,
+	pub(crate) allow_outgoing_presence: bool,
 	#[serde(default = "default_presence_idle_timeout_s")]
-	pub presence_idle_timeout_s: u64,
+	pub(crate) presence_idle_timeout_s: u64,
 	#[serde(default = "default_presence_offline_timeout_s")]
-	pub presence_offline_timeout_s: u64,
+	pub(crate) presence_offline_timeout_s: u64,
 	#[serde(default = "true_fn")]
-	pub presence_timeout_remote_users: bool,
+	pub(crate) presence_timeout_remote_users: bool,
 
 	#[serde(default = "true_fn")]
-	pub allow_incoming_read_receipts: bool,
+	pub(crate) allow_incoming_read_receipts: bool,
 	#[serde(default = "true_fn")]
-	pub allow_outgoing_read_receipts: bool,
+	pub(crate) allow_outgoing_read_receipts: bool,
 
 	#[serde(default = "true_fn")]
-	pub allow_outgoing_typing: bool,
+	pub(crate) allow_outgoing_typing: bool,
 	#[serde(default = "true_fn")]
-	pub allow_incoming_typing: bool,
+	pub(crate) allow_incoming_typing: bool,
 	#[serde(default = "default_typing_federation_timeout_s")]
-	pub typing_federation_timeout_s: u64,
+	pub(crate) typing_federation_timeout_s: u64,
 	#[serde(default = "default_typing_client_timeout_min_s")]
-	pub typing_client_timeout_min_s: u64,
+	pub(crate) typing_client_timeout_min_s: u64,
 	#[serde(default = "default_typing_client_timeout_max_s")]
-	pub typing_client_timeout_max_s: u64,
+	pub(crate) typing_client_timeout_max_s: u64,
 
 	#[serde(default)]
-	pub zstd_compression: bool,
+	pub(crate) zstd_compression: bool,
 	#[serde(default)]
-	pub gzip_compression: bool,
+	pub(crate) gzip_compression: bool,
 	#[serde(default)]
-	pub brotli_compression: bool,
+	pub(crate) brotli_compression: bool,
 
 	#[serde(default)]
-	pub allow_guest_registration: bool,
+	pub(crate) allow_guest_registration: bool,
 	#[serde(default)]
-	pub log_guest_registrations: bool,
+	pub(crate) log_guest_registrations: bool,
 	#[serde(default)]
-	pub allow_guests_auto_join_rooms: bool,
+	pub(crate) allow_guests_auto_join_rooms: bool,
 
 	#[serde(default = "Vec::new")]
-	pub prevent_media_downloads_from: Vec<OwnedServerName>,
+	pub(crate) prevent_media_downloads_from: Vec<OwnedServerName>,
 	#[serde(default = "Vec::new")]
-	pub forbidden_remote_server_names: Vec<OwnedServerName>,
+	pub(crate) forbidden_remote_server_names: Vec<OwnedServerName>,
 	#[serde(default = "Vec::new")]
-	pub forbidden_remote_room_directory_server_names: Vec<OwnedServerName>,
+	pub(crate) forbidden_remote_room_directory_server_names: Vec<OwnedServerName>,
 
 	#[serde(default = "default_ip_range_denylist")]
-	pub ip_range_denylist: Vec<String>,
+	pub(crate) ip_range_denylist: Vec<String>,
 
 	#[serde(default = "Vec::new")]
-	pub url_preview_domain_contains_allowlist: Vec<String>,
+	pub(crate) url_preview_domain_contains_allowlist: Vec<String>,
 	#[serde(default = "Vec::new")]
-	pub url_preview_domain_explicit_allowlist: Vec<String>,
+	pub(crate) url_preview_domain_explicit_allowlist: Vec<String>,
 	#[serde(default = "Vec::new")]
-	pub url_preview_domain_explicit_denylist: Vec<String>,
+	pub(crate) url_preview_domain_explicit_denylist: Vec<String>,
 	#[serde(default = "Vec::new")]
-	pub url_preview_url_contains_allowlist: Vec<String>,
+	pub(crate) url_preview_url_contains_allowlist: Vec<String>,
 	#[serde(default = "default_url_preview_max_spider_size")]
-	pub url_preview_max_spider_size: usize,
+	pub(crate) url_preview_max_spider_size: usize,
 	#[serde(default)]
-	pub url_preview_check_root_domain: bool,
+	pub(crate) url_preview_check_root_domain: bool,
 
 	#[serde(default = "RegexSet::empty")]
 	#[serde(with = "serde_regex")]
-	pub forbidden_alias_names: RegexSet,
+	pub(crate) forbidden_alias_names: RegexSet,
 
 	#[serde(default = "RegexSet::empty")]
 	#[serde(with = "serde_regex")]
-	pub forbidden_usernames: RegexSet,
+	pub(crate) forbidden_usernames: RegexSet,
 
 	#[serde(default = "true_fn")]
-	pub startup_netburst: bool,
+	pub(crate) startup_netburst: bool,
 	#[serde(default = "default_startup_netburst_keep")]
-	pub startup_netburst_keep: i64,
+	pub(crate) startup_netburst_keep: i64,
 
 	#[serde(default)]
-	pub block_non_admin_invites: bool,
+	pub(crate) block_non_admin_invites: bool,
 
 	#[serde(default)]
-	pub sentry: bool,
+	pub(crate) sentry: bool,
 	#[serde(default)]
-	pub sentry_send_server_name: bool,
+	pub(crate) sentry_send_server_name: bool,
 	#[serde(default = "default_sentry_traces_sample_rate")]
-	pub sentry_traces_sample_rate: f32,
+	pub(crate) sentry_traces_sample_rate: f32,
 
 	#[serde(flatten)]
 	#[allow(clippy::zero_sized_map_values)] // this is a catchall, the map shouldn't be zero at runtime
-	pub catchall: BTreeMap<String, IgnoredAny>,
+	catchall: BTreeMap<String, IgnoredAny>,
 }
 
 #[derive(Clone, Debug, Deserialize)]
-pub struct TlsConfig {
+pub(crate) struct TlsConfig {
-	pub certs: String,
+	pub(crate) certs: String,
-	pub key: String,
+	pub(crate) key: String,
 	#[serde(default)]
 	/// Whether to listen and allow for HTTP and HTTPS connections (insecure!)
 	/// Only works / does something if the `axum_dual_protocol` feature flag was
 	/// built
-	pub dual_protocol: bool,
+	pub(crate) dual_protocol: bool,
 }
 
 #[derive(Clone, Debug, Deserialize, Default)]
-pub struct WellKnownConfig {
+pub(crate) struct WellKnownConfig {
-	pub client: Option<Url>,
+	pub(crate) client: Option<Url>,
-	pub server: Option<OwnedServerName>,
+	pub(crate) server: Option<OwnedServerName>,
-	pub support_page: Option<Url>,
+	pub(crate) support_page: Option<Url>,
-	pub support_role: Option<ContactRole>,
+	pub(crate) support_role: Option<ContactRole>,
-	pub support_email: Option<String>,
+	pub(crate) support_email: Option<String>,
-	pub support_mxid: Option<OwnedUserId>,
+	pub(crate) support_mxid: Option<OwnedUserId>,
 }
 
 const DEPRECATED_KEYS: &[&str] = &[
@@ -361,7 +361,7 @@ const DEPRECATED_KEYS: &[&str] = &[
 
 impl Config {
 	/// Initialize config
-	pub fn new(path: Option<PathBuf>) -> Result<Self, Error> {
+	pub(crate) fn new(path: Option<PathBuf>) -> Result<Self, Error> {
 		let raw_config = if let Some(config_file_env) = Env::var("CONDUIT_CONFIG") {
 			Figment::new()
 				.merge(Toml::file(config_file_env).nested())
@@ -389,7 +389,7 @@ impl Config {
 
 	/// Iterates over all the keys in the config file and warns if there is a
 	/// deprecated key specified
-	pub fn warn_deprecated(&self) {
+	pub(crate) fn warn_deprecated(&self) {
 		debug!("Checking for deprecated config keys");
 		let mut was_deprecated = false;
 		for key in self
@@ -411,7 +411,7 @@ impl Config {
 
 	/// iterates over all the catchall keys (unknown config options) and warns
 	/// if there are any.
-	pub fn warn_unknown_key(&self) {
+	pub(crate) fn warn_unknown_key(&self) {
 		debug!("Checking for unknown config keys");
 		for key in self
 			.catchall
@@ -439,7 +439,7 @@ impl Config {
 	}
 
 	#[must_use]
-	pub fn get_bind_addrs(&self) -> Vec<SocketAddr> {
+	pub(crate) fn get_bind_addrs(&self) -> Vec<SocketAddr> {
 		match &self.port.ports {
 			Left(port) => {
 				// Left is only 1 value, so make a vec with 1 value only
@@ -459,7 +459,7 @@ impl Config {
 		}
 	}
 
-	pub fn check(&self) -> Result<(), Error> { check(self) }
+	pub(crate) fn check(&self) -> Result<(), Error> { check(self) }
 }
 
 impl fmt::Display for Config {

src/config/proxy.rs

@@ -30,7 +30,7 @@ use crate::Result;
 /// `ordinary.onion`, `matrix.myspecial.onion`, but not `hello.myspecial.onion`.
 #[derive(Clone, Default, Debug, Deserialize)]
 #[serde(rename_all = "snake_case")]
-pub enum ProxyConfig {
+pub(crate) enum ProxyConfig {
 	#[default]
 	None,
 	Global {
@@ -40,7 +40,7 @@ pub enum ProxyConfig {
 	ByDomain(Vec<PartialProxyConfig>),
 }
 impl ProxyConfig {
-	pub fn to_proxy(&self) -> Result<Option<Proxy>> {
+	pub(crate) fn to_proxy(&self) -> Result<Option<Proxy>> {
 		Ok(match self.clone() {
 			ProxyConfig::None => None,
 			ProxyConfig::Global {
@@ -55,7 +55,7 @@ impl ProxyConfig {
 }
 
 #[derive(Clone, Debug, Deserialize)]
-pub struct PartialProxyConfig {
+pub(crate) struct PartialProxyConfig {
 	#[serde(deserialize_with = "crate::utils::deserialize_from_str")]
 	url: Url,
 	#[serde(default)]
@@ -64,7 +64,7 @@ pub struct PartialProxyConfig {
 	exclude: Vec<WildCardedDomain>,
 }
 impl PartialProxyConfig {
-	pub fn for_url(&self, url: &Url) -> Option<&Url> {
+	pub(crate) fn for_url(&self, url: &Url) -> Option<&Url> {
 		let domain = url.domain()?;
 		let mut included_because = None; // most specific reason it was included
 		let mut excluded_because = None; // most specific reason it was excluded

src/database/cork.rs

@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use super::KeyValueDatabaseEngine;
 
-pub struct Cork {
+pub(crate) struct Cork {
 	db: Arc<dyn KeyValueDatabaseEngine>,
 	flush: bool,
 	sync: bool,

src/database/mod.rs

@@ -1,14 +1,14 @@
-pub(crate) mod cork;
+mod cork;
-pub(crate) mod key_value;
+mod key_value;
-pub(crate) mod kvengine;
+mod kvengine;
-pub(crate) mod kvtree;
+mod kvtree;
 mod migrations;
 
 #[cfg(feature = "rocksdb")]
-pub(crate) mod rocksdb;
+mod rocksdb;
 
 #[cfg(feature = "sqlite")]
-pub mod sqlite;
+mod sqlite;
 
 #[cfg(any(feature = "sqlite", feature = "rocksdb"))]
 pub(crate) mod watchers;
@@ -44,149 +44,149 @@ use crate::{
 	SERVICES,
 };
 
-pub struct KeyValueDatabase {
+pub(crate) struct KeyValueDatabase {
 	db: Arc<dyn KeyValueDatabaseEngine>,
 
-	//pub globals: globals::Globals,
+	//pub(crate) globals: globals::Globals,
-	pub(super) global: Arc<dyn KvTree>,
+	pub(crate) global: Arc<dyn KvTree>,
-	pub(super) server_signingkeys: Arc<dyn KvTree>,
+	pub(crate) server_signingkeys: Arc<dyn KvTree>,
 
-	pub(super) roomid_inviteviaservers: Arc<dyn KvTree>,
+	pub(crate) roomid_inviteviaservers: Arc<dyn KvTree>,
 
-	//pub users: users::Users,
+	//pub(crate) users: users::Users,
-	pub(super) userid_password: Arc<dyn KvTree>,
+	pub(crate) userid_password: Arc<dyn KvTree>,
-	pub(super) userid_displayname: Arc<dyn KvTree>,
+	pub(crate) userid_displayname: Arc<dyn KvTree>,
-	pub(super) userid_avatarurl: Arc<dyn KvTree>,
+	pub(crate) userid_avatarurl: Arc<dyn KvTree>,
-	pub(super) userid_blurhash: Arc<dyn KvTree>,
+	pub(crate) userid_blurhash: Arc<dyn KvTree>,
-	pub(super) userdeviceid_token: Arc<dyn KvTree>,
+	pub(crate) userdeviceid_token: Arc<dyn KvTree>,
-	pub(super) userdeviceid_metadata: Arc<dyn KvTree>, // This is also used to check if a device exists
+	pub(crate) userdeviceid_metadata: Arc<dyn KvTree>, // This is also used to check if a device exists
-	pub(super) userid_devicelistversion: Arc<dyn KvTree>, // DevicelistVersion = u64
+	pub(crate) userid_devicelistversion: Arc<dyn KvTree>, // DevicelistVersion = u64
-	pub(super) token_userdeviceid: Arc<dyn KvTree>,
+	pub(crate) token_userdeviceid: Arc<dyn KvTree>,
 
-	pub(super) onetimekeyid_onetimekeys: Arc<dyn KvTree>, // OneTimeKeyId = UserId + DeviceKeyId
+	pub(crate) onetimekeyid_onetimekeys: Arc<dyn KvTree>, // OneTimeKeyId = UserId + DeviceKeyId
-	pub(super) userid_lastonetimekeyupdate: Arc<dyn KvTree>, // LastOneTimeKeyUpdate = Count
+	pub(crate) userid_lastonetimekeyupdate: Arc<dyn KvTree>, // LastOneTimeKeyUpdate = Count
-	pub(super) keychangeid_userid: Arc<dyn KvTree>,       // KeyChangeId = UserId/RoomId + Count
+	pub(crate) keychangeid_userid: Arc<dyn KvTree>,       // KeyChangeId = UserId/RoomId + Count
-	pub(super) keyid_key: Arc<dyn KvTree>,                // KeyId = UserId + KeyId (depends on key type)
+	pub(crate) keyid_key: Arc<dyn KvTree>,                // KeyId = UserId + KeyId (depends on key type)
-	pub(super) userid_masterkeyid: Arc<dyn KvTree>,
+	pub(crate) userid_masterkeyid: Arc<dyn KvTree>,
-	pub(super) userid_selfsigningkeyid: Arc<dyn KvTree>,
+	pub(crate) userid_selfsigningkeyid: Arc<dyn KvTree>,
-	pub(super) userid_usersigningkeyid: Arc<dyn KvTree>,
+	pub(crate) userid_usersigningkeyid: Arc<dyn KvTree>,
 
-	pub(super) userfilterid_filter: Arc<dyn KvTree>, // UserFilterId = UserId + FilterId
+	pub(crate) userfilterid_filter: Arc<dyn KvTree>, // UserFilterId = UserId + FilterId
-	pub(super) todeviceid_events: Arc<dyn KvTree>,   // ToDeviceId = UserId + DeviceId + Count
+	pub(crate) todeviceid_events: Arc<dyn KvTree>,   // ToDeviceId = UserId + DeviceId + Count
-	pub(super) userid_presenceid: Arc<dyn KvTree>,   // UserId => Count
+	pub(crate) userid_presenceid: Arc<dyn KvTree>,   // UserId => Count
-	pub(super) presenceid_presence: Arc<dyn KvTree>, // Count + UserId => Presence
+	pub(crate) presenceid_presence: Arc<dyn KvTree>, // Count + UserId => Presence
 
-	//pub uiaa: uiaa::Uiaa,
+	//pub(crate) uiaa: uiaa::Uiaa,
-	pub(super) userdevicesessionid_uiaainfo: Arc<dyn KvTree>, // User-interactive authentication
+	pub(crate) userdevicesessionid_uiaainfo: Arc<dyn KvTree>, // User-interactive authentication
-	pub(super) userdevicesessionid_uiaarequest:
+	pub(crate) userdevicesessionid_uiaarequest:
 		RwLock<BTreeMap<(OwnedUserId, OwnedDeviceId, String), CanonicalJsonValue>>,
 
-	//pub edus: RoomEdus,
+	//pub(crate) edus: RoomEdus,
-	pub(super) readreceiptid_readreceipt: Arc<dyn KvTree>, // ReadReceiptId = RoomId + Count + UserId
+	pub(crate) readreceiptid_readreceipt: Arc<dyn KvTree>, // ReadReceiptId = RoomId + Count + UserId
-	pub(super) roomuserid_privateread: Arc<dyn KvTree>,    // RoomUserId = Room + User, PrivateRead = Count
+	pub(crate) roomuserid_privateread: Arc<dyn KvTree>,    // RoomUserId = Room + User, PrivateRead = Count
-	pub(super) roomuserid_lastprivatereadupdate: Arc<dyn KvTree>, // LastPrivateReadUpdate = Count
+	pub(crate) roomuserid_lastprivatereadupdate: Arc<dyn KvTree>, // LastPrivateReadUpdate = Count
 
-	//pub rooms: rooms::Rooms,
+	//pub(crate) rooms: rooms::Rooms,
-	pub(super) pduid_pdu: Arc<dyn KvTree>, // PduId = ShortRoomId + Count
+	pub(crate) pduid_pdu: Arc<dyn KvTree>, // PduId = ShortRoomId + Count
-	pub(super) eventid_pduid: Arc<dyn KvTree>,
+	pub(crate) eventid_pduid: Arc<dyn KvTree>,
-	pub(super) roomid_pduleaves: Arc<dyn KvTree>,
+	pub(crate) roomid_pduleaves: Arc<dyn KvTree>,
-	pub(super) alias_roomid: Arc<dyn KvTree>,
+	pub(crate) alias_roomid: Arc<dyn KvTree>,
-	pub(super) aliasid_alias: Arc<dyn KvTree>, // AliasId = RoomId + Count
+	pub(crate) aliasid_alias: Arc<dyn KvTree>, // AliasId = RoomId + Count
-	pub(super) publicroomids: Arc<dyn KvTree>,
+	pub(crate) publicroomids: Arc<dyn KvTree>,
 
-	pub(super) threadid_userids: Arc<dyn KvTree>, // ThreadId = RoomId + Count
+	pub(crate) threadid_userids: Arc<dyn KvTree>, // ThreadId = RoomId + Count
 
-	pub(super) tokenids: Arc<dyn KvTree>, // TokenId = ShortRoomId + Token + PduIdCount
+	pub(crate) tokenids: Arc<dyn KvTree>, // TokenId = ShortRoomId + Token + PduIdCount
 
 	/// Participating servers in a room.
-	pub(super) roomserverids: Arc<dyn KvTree>, // RoomServerId = RoomId + ServerName
+	pub(crate) roomserverids: Arc<dyn KvTree>, // RoomServerId = RoomId + ServerName
-	pub(super) serverroomids: Arc<dyn KvTree>, // ServerRoomId = ServerName + RoomId
+	pub(crate) serverroomids: Arc<dyn KvTree>, // ServerRoomId = ServerName + RoomId
 
-	pub(super) userroomid_joined: Arc<dyn KvTree>,
+	pub(crate) userroomid_joined: Arc<dyn KvTree>,
-	pub(super) roomuserid_joined: Arc<dyn KvTree>,
+	pub(crate) roomuserid_joined: Arc<dyn KvTree>,
-	pub(super) roomid_joinedcount: Arc<dyn KvTree>,
+	pub(crate) roomid_joinedcount: Arc<dyn KvTree>,
-	pub(super) roomid_invitedcount: Arc<dyn KvTree>,
+	pub(crate) roomid_invitedcount: Arc<dyn KvTree>,
-	pub(super) roomuseroncejoinedids: Arc<dyn KvTree>,
+	pub(crate) roomuseroncejoinedids: Arc<dyn KvTree>,
-	pub(super) userroomid_invitestate: Arc<dyn KvTree>, // InviteState = Vec<Raw<Pdu>>
+	pub(crate) userroomid_invitestate: Arc<dyn KvTree>, // InviteState = Vec<Raw<Pdu>>
-	pub(super) roomuserid_invitecount: Arc<dyn KvTree>, // InviteCount = Count
+	pub(crate) roomuserid_invitecount: Arc<dyn KvTree>, // InviteCount = Count
-	pub(super) userroomid_leftstate: Arc<dyn KvTree>,
+	pub(crate) userroomid_leftstate: Arc<dyn KvTree>,
-	pub(super) roomuserid_leftcount: Arc<dyn KvTree>,
+	pub(crate) roomuserid_leftcount: Arc<dyn KvTree>,
 
-	pub(super) disabledroomids: Arc<dyn KvTree>, // Rooms where incoming federation handling is disabled
+	pub(crate) disabledroomids: Arc<dyn KvTree>, // Rooms where incoming federation handling is disabled
 
-	pub(super) bannedroomids: Arc<dyn KvTree>, // Rooms where local users are not allowed to join
+	pub(crate) bannedroomids: Arc<dyn KvTree>, // Rooms where local users are not allowed to join
 
-	pub(super) lazyloadedids: Arc<dyn KvTree>, // LazyLoadedIds = UserId + DeviceId + RoomId + LazyLoadedUserId
+	pub(crate) lazyloadedids: Arc<dyn KvTree>, // LazyLoadedIds = UserId + DeviceId + RoomId + LazyLoadedUserId
 
-	pub(super) userroomid_notificationcount: Arc<dyn KvTree>, // NotifyCount = u64
+	pub(crate) userroomid_notificationcount: Arc<dyn KvTree>, // NotifyCount = u64
-	pub(super) userroomid_highlightcount: Arc<dyn KvTree>,    // HightlightCount = u64
+	pub(crate) userroomid_highlightcount: Arc<dyn KvTree>,    // HightlightCount = u64
-	pub(super) roomuserid_lastnotificationread: Arc<dyn KvTree>, // LastNotificationRead = u64
+	pub(crate) roomuserid_lastnotificationread: Arc<dyn KvTree>, // LastNotificationRead = u64
 
 	/// Remember the current state hash of a room.
-	pub(super) roomid_shortstatehash: Arc<dyn KvTree>,
+	pub(crate) roomid_shortstatehash: Arc<dyn KvTree>,
-	pub(super) roomsynctoken_shortstatehash: Arc<dyn KvTree>,
+	pub(crate) roomsynctoken_shortstatehash: Arc<dyn KvTree>,
 	/// Remember the state hash at events in the past.
-	pub(super) shorteventid_shortstatehash: Arc<dyn KvTree>,
+	pub(crate) shorteventid_shortstatehash: Arc<dyn KvTree>,
-	pub(super) statekey_shortstatekey: Arc<dyn KvTree>, /* StateKey = EventType + StateKey, ShortStateKey =
+	pub(crate) statekey_shortstatekey: Arc<dyn KvTree>, /* StateKey = EventType + StateKey, ShortStateKey =
 	                                                     * Count */
-	pub(super) shortstatekey_statekey: Arc<dyn KvTree>,
+	pub(crate) shortstatekey_statekey: Arc<dyn KvTree>,
 
-	pub(super) roomid_shortroomid: Arc<dyn KvTree>,
+	pub(crate) roomid_shortroomid: Arc<dyn KvTree>,
 
-	pub(super) shorteventid_eventid: Arc<dyn KvTree>,
+	pub(crate) shorteventid_eventid: Arc<dyn KvTree>,
-	pub(super) eventid_shorteventid: Arc<dyn KvTree>,
+	pub(crate) eventid_shorteventid: Arc<dyn KvTree>,
 
-	pub(super) statehash_shortstatehash: Arc<dyn KvTree>,
+	pub(crate) statehash_shortstatehash: Arc<dyn KvTree>,
-	pub(super) shortstatehash_statediff: Arc<dyn KvTree>, /* StateDiff = parent (or 0) +
+	pub(crate) shortstatehash_statediff: Arc<dyn KvTree>, /* StateDiff = parent (or 0) +
 	                                                       * (shortstatekey+shorteventid++) + 0_u64 +
 	                                                       * (shortstatekey+shorteventid--) */
 
-	pub(super) shorteventid_authchain: Arc<dyn KvTree>,
+	pub(crate) shorteventid_authchain: Arc<dyn KvTree>,
 
 	/// RoomId + EventId -> outlier PDU.
 	/// Any pdu that has passed the steps 1-8 in the incoming event
 	/// /federation/send/txn.
-	pub(super) eventid_outlierpdu: Arc<dyn KvTree>,
+	pub(crate) eventid_outlierpdu: Arc<dyn KvTree>,
-	pub(super) softfailedeventids: Arc<dyn KvTree>,
+	pub(crate) softfailedeventids: Arc<dyn KvTree>,
 
 	/// ShortEventId + ShortEventId -> ().
-	pub(super) tofrom_relation: Arc<dyn KvTree>,
+	pub(crate) tofrom_relation: Arc<dyn KvTree>,
 	/// RoomId + EventId -> Parent PDU EventId.
-	pub(super) referencedevents: Arc<dyn KvTree>,
+	pub(crate) referencedevents: Arc<dyn KvTree>,
 
-	//pub account_data: account_data::AccountData,
+	//pub(crate) account_data: account_data::AccountData,
-	pub(super) roomuserdataid_accountdata: Arc<dyn KvTree>, // RoomUserDataId = Room + User + Count + Type
+	pub(crate) roomuserdataid_accountdata: Arc<dyn KvTree>, // RoomUserDataId = Room + User + Count + Type
-	pub(super) roomusertype_roomuserdataid: Arc<dyn KvTree>, // RoomUserType = Room + User + Type
+	pub(crate) roomusertype_roomuserdataid: Arc<dyn KvTree>, // RoomUserType = Room + User + Type
 
-	//pub media: media::Media,
+	//pub(crate) media: media::Media,
-	pub(super) mediaid_file: Arc<dyn KvTree>, // MediaId = MXC + WidthHeight + ContentDisposition + ContentType
+	pub(crate) mediaid_file: Arc<dyn KvTree>, // MediaId = MXC + WidthHeight + ContentDisposition + ContentType
-	pub(super) url_previews: Arc<dyn KvTree>,
+	pub(crate) url_previews: Arc<dyn KvTree>,
-	pub(super) mediaid_user: Arc<dyn KvTree>,
+	pub(crate) mediaid_user: Arc<dyn KvTree>,
-	//pub key_backups: key_backups::KeyBackups,
+	//pub(crate) key_backups: key_backups::KeyBackups,
-	pub(super) backupid_algorithm: Arc<dyn KvTree>, // BackupId = UserId + Version(Count)
+	pub(crate) backupid_algorithm: Arc<dyn KvTree>, // BackupId = UserId + Version(Count)
-	pub(super) backupid_etag: Arc<dyn KvTree>,      // BackupId = UserId + Version(Count)
+	pub(crate) backupid_etag: Arc<dyn KvTree>,      // BackupId = UserId + Version(Count)
-	pub(super) backupkeyid_backup: Arc<dyn KvTree>, // BackupKeyId = UserId + Version + RoomId + SessionId
+	pub(crate) backupkeyid_backup: Arc<dyn KvTree>, // BackupKeyId = UserId + Version + RoomId + SessionId
 
-	//pub transaction_ids: transaction_ids::TransactionIds,
+	//pub(crate) transaction_ids: transaction_ids::TransactionIds,
-	pub(super) userdevicetxnid_response: Arc<dyn KvTree>, /* Response can be empty (/sendToDevice) or the event id
+	pub(crate) userdevicetxnid_response: Arc<dyn KvTree>, /* Response can be empty (/sendToDevice) or the event id
 	                                                       * (/send) */
-	//pub sending: sending::Sending,
+	//pub(crate) sending: sending::Sending,
-	pub(super) servername_educount: Arc<dyn KvTree>, // EduCount: Count of last EDU sync
+	pub(crate) servername_educount: Arc<dyn KvTree>, // EduCount: Count of last EDU sync
-	pub(super) servernameevent_data: Arc<dyn KvTree>, /* ServernameEvent = (+ / $)SenderKey / ServerName / UserId +
+	pub(crate) servernameevent_data: Arc<dyn KvTree>, /* ServernameEvent = (+ / $)SenderKey / ServerName / UserId +
 	                                                  * PduId / Id (for edus), Data = EDU content */
-	pub(super) servercurrentevent_data: Arc<dyn KvTree>, /* ServerCurrentEvents = (+ / $)ServerName / UserId + PduId
+	pub(crate) servercurrentevent_data: Arc<dyn KvTree>, /* ServerCurrentEvents = (+ / $)ServerName / UserId + PduId
 	                                                      * / Id (for edus), Data = EDU content */
 
-	//pub appservice: appservice::Appservice,
+	//pub(crate) appservice: appservice::Appservice,
-	pub(super) id_appserviceregistrations: Arc<dyn KvTree>,
+	pub(crate) id_appserviceregistrations: Arc<dyn KvTree>,
 
-	//pub pusher: pusher::PushData,
+	//pub(crate) pusher: pusher::PushData,
-	pub(super) senderkey_pusher: Arc<dyn KvTree>,
+	pub(crate) senderkey_pusher: Arc<dyn KvTree>,
 
-	pub(super) auth_chain_cache: Mutex<LruCache<Vec<u64>, Arc<[u64]>>>,
+	pub(crate) auth_chain_cache: Mutex<LruCache<Vec<u64>, Arc<[u64]>>>,
-	pub(super) our_real_users_cache: RwLock<HashMap<OwnedRoomId, Arc<HashSet<OwnedUserId>>>>,
+	pub(crate) our_real_users_cache: RwLock<HashMap<OwnedRoomId, Arc<HashSet<OwnedUserId>>>>,
-	pub(super) appservice_in_room_cache: RwLock<HashMap<OwnedRoomId, HashMap<String, bool>>>,
+	pub(crate) appservice_in_room_cache: RwLock<HashMap<OwnedRoomId, HashMap<String, bool>>>,
-	pub(super) lasttimelinecount_cache: Mutex<HashMap<OwnedRoomId, PduCount>>,
+	pub(crate) lasttimelinecount_cache: Mutex<HashMap<OwnedRoomId, PduCount>>,
 }
 
 #[derive(Deserialize)]
@@ -203,7 +203,7 @@ struct CheckForUpdatesResponse {
 impl KeyValueDatabase {
 	/// Load an existing database or create a new one.
 	#[allow(clippy::too_many_lines)]
-	pub async fn load_or_create(
+	pub(crate) async fn load_or_create(
 		config: Config,
 		tracing_reload_handler: tracing_subscriber::reload::Handle<
 			tracing_subscriber::EnvFilter,
@@ -545,7 +545,7 @@ impl KeyValueDatabase {
 	}
 
 	#[allow(dead_code)]
-	pub fn flush(&self) -> Result<()> {
+	fn flush(&self) -> Result<()> {
 		let start = std::time::Instant::now();
 
 		let res = self.db.flush();

src/database/rocksdb/kvtree.rs

@@ -5,10 +5,10 @@ use rust_rocksdb::WriteBatchWithTransaction;
 use super::{watchers::Watchers, Engine, KeyValueDatabaseEngine, KvTree};
 use crate::{utils, Result};
 
-pub(super) struct RocksDbEngineTree<'a> {
+pub(crate) struct RocksDbEngineTree<'a> {
-	pub db: Arc<Engine>,
+	pub(crate) db: Arc<Engine>,
-	pub name: &'a str,
+	pub(crate) name: &'a str,
-	pub watchers: Watchers,
+	pub(crate) watchers: Watchers,
 }
 
 impl RocksDbEngineTree<'_> {

src/database/sqlite/mod.rs

@@ -20,8 +20,8 @@ thread_local! {
 }
 
 struct PreparedStatementIterator<'a> {
-	pub iterator: Box<dyn Iterator<Item = TupleOfBytes> + 'a>,
+	iterator: Box<dyn Iterator<Item = TupleOfBytes> + 'a>,
-	pub _statement_ref: NonAliasingBox<rusqlite::Statement<'a>>,
+	_statement_ref: NonAliasingBox<rusqlite::Statement<'a>>,
 }
 
 impl Iterator for PreparedStatementIterator<'_> {
@@ -77,7 +77,7 @@ impl Engine {
 			.get_or(|| Self::prepare_conn(&self.path, self.cache_size_per_thread).unwrap())
 	}
 
-	pub fn flush_wal(self: &Arc<Self>) -> Result<()> {
+	fn flush_wal(self: &Arc<Self>) -> Result<()> {
 		self.write_lock()
 			.pragma_update(Some(Main), "wal_checkpoint", "RESTART")?;
 		Ok(())
@@ -130,7 +130,7 @@ impl KeyValueDatabaseEngine for Arc<Engine> {
 	fn cleanup(&self) -> Result<()> { self.flush_wal() }
 }
 
-pub struct SqliteTable {
+struct SqliteTable {
 	engine: Arc<Engine>,
 	name: String,
 	watchers: Watchers,
@@ -154,7 +154,7 @@ impl SqliteTable {
 		Ok(())
 	}
 
-	pub fn iter_with_guard<'a>(&'a self, guard: &'a Connection) -> Box<dyn Iterator<Item = TupleOfBytes> + 'a> {
+	fn iter_with_guard<'a>(&'a self, guard: &'a Connection) -> Box<dyn Iterator<Item = TupleOfBytes> + 'a> {
 		let statement = Box::leak(Box::new(
 			guard
 				.prepare(&format!("SELECT key, value FROM {} ORDER BY key ASC", &self.name))

src/database/watchers.rs

@@ -10,12 +10,12 @@ use tokio::sync::watch;
 type Watcher = RwLock<HashMap<Vec<u8>, (watch::Sender<()>, watch::Receiver<()>)>>;
 
 #[derive(Default)]
-pub(super) struct Watchers {
+pub(crate) struct Watchers {
 	watchers: Watcher,
 }
 
 impl Watchers {
-	pub(super) fn watch<'a>(&'a self, prefix: &[u8]) -> Pin<Box<dyn Future<Output = ()> + Send + 'a>> {
+	pub(crate) fn watch<'a>(&'a self, prefix: &[u8]) -> Pin<Box<dyn Future<Output = ()> + Send + 'a>> {
 		let mut rx = match self.watchers.write().unwrap().entry(prefix.to_vec()) {
 			hash_map::Entry::Occupied(o) => o.get().1.clone(),
 			hash_map::Entry::Vacant(v) => {
@@ -31,7 +31,7 @@ impl Watchers {
 		})
 	}
 
-	pub(super) fn wake(&self, key: &[u8]) {
+	pub(crate) fn wake(&self, key: &[u8]) {
 		let watchers = self.watchers.read().unwrap();
 		let mut triggered = Vec::new();
 

src/main.rs

@@ -54,10 +54,10 @@ mod routes;
 mod service;
 mod utils;
 
-pub static SERVICES: RwLock<Option<&'static Services<'static>>> = RwLock::new(None);
+pub(crate) static SERVICES: RwLock<Option<&'static Services<'static>>> = RwLock::new(None);
 
 #[must_use]
-pub fn services() -> &'static Services<'static> {
+pub(crate) fn services() -> &'static Services<'static> {
 	SERVICES
 		.read()
 		.unwrap()

src/routes.rs

@@ -15,7 +15,7 @@ use crate::{
 	Config, Error, Result, Ruma, RumaResponse,
 };
 
-pub fn routes(config: &Config) -> Router {
+pub(crate) fn routes(config: &Config) -> Router {
 	let router = Router::new()
 		.ruma_route(client_server::get_supported_versions_route)
 		.ruma_route(client_server::get_register_available_route)
@@ -266,7 +266,7 @@ impl RouterExt for Router {
 	}
 }
 
-pub trait RumaHandler<T> {
+pub(crate) trait RumaHandler<T> {
 	// Can't transform to a handler without boxing or relying on the nightly-only
 	// impl-trait-in-traits feature. Moving a small amount of extra logic into the
 	// trait allows bypassing both.

src/service/account_data/data.rs

@@ -8,7 +8,7 @@ use ruma::{
 
 use crate::Result;
 
-pub trait Data: Send + Sync {
+pub(crate) trait Data: Send + Sync {
 	/// Places one event in the account data of the user and removes the
 	/// previous entry.
 	fn update(

src/service/account_data/mod.rs

@@ -11,15 +11,15 @@ use ruma::{
 
 use crate::Result;
 
-pub struct Service {
+pub(crate) struct Service {
-	pub db: &'static dyn Data,
+	pub(crate) db: &'static dyn Data,
 }
 
 impl Service {
 	/// Places one event in the account data of the user and removes the
 	/// previous entry.
 	#[tracing::instrument(skip(self, room_id, user_id, event_type, data))]
-	pub fn update(
+	pub(crate) fn update(
 		&self, room_id: Option<&RoomId>, user_id: &UserId, event_type: RoomAccountDataEventType,
 		data: &serde_json::Value,
 	) -> Result<()> {
@@ -28,7 +28,7 @@ impl Service {
 
 	/// Searches the account data for a specific kind.
 	#[tracing::instrument(skip(self, room_id, user_id, event_type))]
-	pub fn get(
+	pub(crate) fn get(
 		&self, room_id: Option<&RoomId>, user_id: &UserId, event_type: RoomAccountDataEventType,
 	) -> Result<Option<Box<serde_json::value::RawValue>>> {
 		self.db.get(room_id, user_id, event_type)
@@ -36,7 +36,7 @@ impl Service {
 
 	/// Returns all changes to the account data that happened after `since`.
 	#[tracing::instrument(skip(self, room_id, user_id, since))]
-	pub fn changes_since(
+	pub(crate) fn changes_since(
 		&self, room_id: Option<&RoomId>, user_id: &UserId, since: u64,
 	) -> Result<HashMap<RoomAccountDataEventType, Raw<AnyEphemeralRoomEvent>>> {
 		self.db.changes_since(room_id, user_id, since)

src/service/admin/appservice/appservice_command.rs

@@ -2,7 +2,7 @@ use ruma::{api::appservice::Registration, events::room::message::RoomMessageEven
 
 use crate::{service::admin::escape_html, services, Result};
 
-pub(super) async fn register(body: Vec<&str>) -> Result<RoomMessageEventContent> {
+pub(crate) async fn register(body: Vec<&str>) -> Result<RoomMessageEventContent> {
 	if body.len() > 2 && body[0].trim().starts_with("```") && body.last().unwrap().trim() == "```" {
 		let appservice_config = body[1..body.len() - 1].join("\n");
 		let parsed_config = serde_yaml::from_str::<Registration>(&appservice_config);
@@ -26,7 +26,7 @@ pub(super) async fn register(body: Vec<&str>) -> Result<RoomMessageEventContent>
 	}
 }
 
-pub(super) async fn unregister(_body: Vec<&str>, appservice_identifier: String) -> Result<RoomMessageEventContent> {
+pub(crate) async fn unregister(_body: Vec<&str>, appservice_identifier: String) -> Result<RoomMessageEventContent> {
 	match services()
 		.appservice
 		.unregister_appservice(&appservice_identifier)
@@ -39,7 +39,7 @@ pub(super) async fn unregister(_body: Vec<&str>, appservice_identifier: String)
 	}
 }
 
-pub(super) async fn show(_body: Vec<&str>, appservice_identifier: String) -> Result<RoomMessageEventContent> {
+pub(crate) async fn show(_body: Vec<&str>, appservice_identifier: String) -> Result<RoomMessageEventContent> {
 	match services()
 		.appservice
 		.get_registration(&appservice_identifier)
@@ -59,7 +59,7 @@ pub(super) async fn show(_body: Vec<&str>, appservice_identifier: String) -> Res
 	}
 }
 
-pub(super) async fn list(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
+pub(crate) async fn list(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
 	let appservices = services().appservice.iter_ids().await;
 	let output = format!("Appservices ({}): {}", appservices.len(), appservices.join(", "));
 	Ok(RoomMessageEventContent::text_plain(output))

src/service/admin/debug/debug_commands.rs

@@ -10,7 +10,7 @@ use tracing_subscriber::EnvFilter;
 
 use crate::{api::server_server::parse_incoming_pdu, services, utils::HtmlEscape, Error, PduEvent, Result};
 
-pub(super) async fn get_auth_chain(_body: Vec<&str>, event_id: Box<EventId>) -> Result<RoomMessageEventContent> {
+pub(crate) async fn get_auth_chain(_body: Vec<&str>, event_id: Box<EventId>) -> Result<RoomMessageEventContent> {
 	let event_id = Arc::<EventId>::from(event_id);
 	if let Some(event) = services().rooms.timeline.get_pdu_json(&event_id)? {
 		let room_id_str = event
@@ -36,7 +36,7 @@ pub(super) async fn get_auth_chain(_body: Vec<&str>, event_id: Box<EventId>) ->
 	}
 }
 
-pub(super) async fn parse_pdu(body: Vec<&str>) -> Result<RoomMessageEventContent> {
+pub(crate) async fn parse_pdu(body: Vec<&str>) -> Result<RoomMessageEventContent> {
 	if body.len() > 2 && body[0].trim().starts_with("```") && body.last().unwrap().trim() == "```" {
 		let string = body[1..body.len() - 1].join("\n");
 		match serde_json::from_str(&string) {
@@ -62,7 +62,7 @@ pub(super) async fn parse_pdu(body: Vec<&str>) -> Result<RoomMessageEventContent
 	}
 }
 
-pub(super) async fn get_pdu(_body: Vec<&str>, event_id: Box<EventId>) -> Result<RoomMessageEventContent> {
+pub(crate) async fn get_pdu(_body: Vec<&str>, event_id: Box<EventId>) -> Result<RoomMessageEventContent> {
 	let mut outlier = false;
 	let mut pdu_json = services()
 		.rooms
@@ -100,7 +100,7 @@ pub(super) async fn get_pdu(_body: Vec<&str>, event_id: Box<EventId>) -> Result<
 	}
 }
 
-pub(super) async fn get_remote_pdu_list(
+pub(crate) async fn get_remote_pdu_list(
 	body: Vec<&str>, server: Box<ServerName>, force: bool,
 ) -> Result<RoomMessageEventContent> {
 	if !services().globals.config.allow_federation {
@@ -138,7 +138,7 @@ pub(super) async fn get_remote_pdu_list(
 	))
 }
 
-pub(super) async fn get_remote_pdu(
+pub(crate) async fn get_remote_pdu(
 	_body: Vec<&str>, event_id: Box<EventId>, server: Box<ServerName>,
 ) -> Result<RoomMessageEventContent> {
 	if !services().globals.config.allow_federation {
@@ -228,7 +228,7 @@ pub(super) async fn get_remote_pdu(
 	}
 }
 
-pub(super) async fn get_room_state(_body: Vec<&str>, room_id: Box<RoomId>) -> Result<RoomMessageEventContent> {
+pub(crate) async fn get_room_state(_body: Vec<&str>, room_id: Box<RoomId>) -> Result<RoomMessageEventContent> {
 	let room_state = services()
 		.rooms
 		.state_accessor
@@ -261,7 +261,7 @@ pub(super) async fn get_room_state(_body: Vec<&str>, room_id: Box<RoomId>) -> Re
 	))
 }
 
-pub(super) async fn ping(_body: Vec<&str>, server: Box<ServerName>) -> Result<RoomMessageEventContent> {
+pub(crate) async fn ping(_body: Vec<&str>, server: Box<ServerName>) -> Result<RoomMessageEventContent> {
 	if server == services().globals.server_name() {
 		return Ok(RoomMessageEventContent::text_plain(
 			"Not allowed to send federation requests to ourselves.",
@@ -305,7 +305,7 @@ pub(super) async fn ping(_body: Vec<&str>, server: Box<ServerName>) -> Result<Ro
 	}
 }
 
-pub(super) async fn force_device_list_updates(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
+pub(crate) async fn force_device_list_updates(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
 	// Force E2EE device list updates for all users
 	for user_id in services().users.iter().filter_map(Result::ok) {
 		services().users.mark_device_key_update(&user_id)?;
@@ -315,7 +315,7 @@ pub(super) async fn force_device_list_updates(_body: Vec<&str>) -> Result<RoomMe
 	))
 }
 
-pub(super) async fn change_log_level(
+pub(crate) async fn change_log_level(
 	_body: Vec<&str>, filter: Option<String>, reset: bool,
 ) -> Result<RoomMessageEventContent> {
 	if reset {
@@ -376,7 +376,7 @@ pub(super) async fn change_log_level(
 	Ok(RoomMessageEventContent::text_plain("No log level was specified."))
 }
 
-pub(super) async fn sign_json(body: Vec<&str>) -> Result<RoomMessageEventContent> {
+pub(crate) async fn sign_json(body: Vec<&str>) -> Result<RoomMessageEventContent> {
 	if body.len() > 2 && body[0].trim().starts_with("```") && body.last().unwrap().trim() == "```" {
 		let string = body[1..body.len() - 1].join("\n");
 		match serde_json::from_str(&string) {
@@ -399,7 +399,7 @@ pub(super) async fn sign_json(body: Vec<&str>) -> Result<RoomMessageEventContent
 	}
 }
 
-pub(super) async fn verify_json(body: Vec<&str>) -> Result<RoomMessageEventContent> {
+pub(crate) async fn verify_json(body: Vec<&str>) -> Result<RoomMessageEventContent> {
 	if body.len() > 2 && body[0].trim().starts_with("```") && body.last().unwrap().trim() == "```" {
 		let string = body[1..body.len() - 1].join("\n");
 		match serde_json::from_str(&string) {

src/service/admin/federation/federation_commands.rs

@@ -4,17 +4,17 @@ use ruma::{events::room::message::RoomMessageEventContent, RoomId, ServerName};
 
 use crate::{services, utils::HtmlEscape, Result};
 
-pub(super) async fn disable_room(_body: Vec<&str>, room_id: Box<RoomId>) -> Result<RoomMessageEventContent> {
+pub(crate) async fn disable_room(_body: Vec<&str>, room_id: Box<RoomId>) -> Result<RoomMessageEventContent> {
 	services().rooms.metadata.disable_room(&room_id, true)?;
 	Ok(RoomMessageEventContent::text_plain("Room disabled."))
 }
 
-pub(super) async fn enable_room(_body: Vec<&str>, room_id: Box<RoomId>) -> Result<RoomMessageEventContent> {
+pub(crate) async fn enable_room(_body: Vec<&str>, room_id: Box<RoomId>) -> Result<RoomMessageEventContent> {
 	services().rooms.metadata.disable_room(&room_id, false)?;
 	Ok(RoomMessageEventContent::text_plain("Room enabled."))
 }
 
-pub(super) async fn incoming_federeation(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
+pub(crate) async fn incoming_federeation(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
 	let map = services().globals.roomid_federationhandletime.read().await;
 	let mut msg = format!("Handling {} incoming pdus:\n", map.len());
 
@@ -25,7 +25,7 @@ pub(super) async fn incoming_federeation(_body: Vec<&str>) -> Result<RoomMessage
 	Ok(RoomMessageEventContent::text_plain(&msg))
 }
 
-pub(super) async fn fetch_support_well_known(
+pub(crate) async fn fetch_support_well_known(
 	_body: Vec<&str>, server_name: Box<ServerName>,
 ) -> Result<RoomMessageEventContent> {
 	let response = services()

src/service/admin/fsck/fsck_commands.rs

@@ -5,7 +5,7 @@ use crate::{services, Result};
 /// Uses the iterator in `src/database/key_value/users.rs` to iterator over
 /// every user in our database (remote and local). Reports total count, any
 /// errors if there were any, etc
-pub(super) async fn check_all_users(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
+pub(crate) async fn check_all_users(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
 	let timer = tokio::time::Instant::now();
 	let results = services().users.db.iter();
 	let query_time = timer.elapsed();

src/service/admin/media/media_commands.rs

@@ -3,7 +3,7 @@ use tracing::{debug, info};
 
 use crate::{service::admin::MxcUri, services, Result};
 
-pub(super) async fn delete(
+pub(crate) async fn delete(
 	_body: Vec<&str>, mxc: Option<Box<MxcUri>>, event_id: Option<Box<EventId>>,
 ) -> Result<RoomMessageEventContent> {
 	if event_id.is_some() && mxc.is_some() {
@@ -137,7 +137,7 @@ pub(super) async fn delete(
 	))
 }
 
-pub(super) async fn delete_list(body: Vec<&str>) -> Result<RoomMessageEventContent> {
+pub(crate) async fn delete_list(body: Vec<&str>) -> Result<RoomMessageEventContent> {
 	if body.len() > 2 && body[0].trim().starts_with("```") && body.last().unwrap().trim() == "```" {
 		let mxc_list = body.clone().drain(1..body.len() - 1).collect::<Vec<_>>();
 
@@ -159,7 +159,7 @@ pub(super) async fn delete_list(body: Vec<&str>) -> Result<RoomMessageEventConte
 	))
 }
 
-pub(super) async fn delete_past_remote_media(_body: Vec<&str>, duration: String) -> Result<RoomMessageEventContent> {
+pub(crate) async fn delete_past_remote_media(_body: Vec<&str>, duration: String) -> Result<RoomMessageEventContent> {
 	let deleted_count = services()
 		.media
 		.delete_all_remote_media_at_after_time(duration)

src/service/admin/mod.rs

@@ -90,18 +90,18 @@ enum AdminCommand {
 }
 
 #[derive(Debug)]
-pub enum AdminRoomEvent {
+pub(crate) enum AdminRoomEvent {
 	ProcessMessage(String, Arc<EventId>),
 	SendMessage(RoomMessageEventContent),
 }
 
-pub struct Service {
+pub(crate) struct Service {
-	pub sender: loole::Sender<AdminRoomEvent>,
+	pub(crate) sender: loole::Sender<AdminRoomEvent>,
 	receiver: Mutex<loole::Receiver<AdminRoomEvent>>,
 }
 
 impl Service {
-	pub fn build() -> Arc<Self> {
+	pub(crate) fn build() -> Arc<Self> {
 		let (sender, receiver) = loole::unbounded();
 		Arc::new(Self {
 			sender,
@@ -109,7 +109,7 @@ impl Service {
 		})
 	}
 
-	pub fn start_handler(self: &Arc<Self>) {
+	pub(crate) fn start_handler(self: &Arc<Self>) {
 		let self2 = Arc::clone(self);
 		tokio::spawn(async move {
 			self2
@@ -201,13 +201,13 @@ impl Service {
 		Ok(())
 	}
 
-	pub fn process_message(&self, room_message: String, event_id: Arc<EventId>) {
+	pub(crate) fn process_message(&self, room_message: String, event_id: Arc<EventId>) {
 		self.sender
 			.send(AdminRoomEvent::ProcessMessage(room_message, event_id))
 			.unwrap();
 	}
 
-	pub fn send_message(&self, message_content: RoomMessageEventContent) {
+	pub(crate) fn send_message(&self, message_content: RoomMessageEventContent) {
 		self.sender
 			.send(AdminRoomEvent::SendMessage(message_content))
 			.unwrap();

src/service/admin/query/account_data.rs

@@ -4,7 +4,7 @@ use super::AccountData;
 use crate::{services, Result};
 
 /// All the getters and iterators from src/database/key_value/account_data.rs
-pub(super) async fn account_data(subcommand: AccountData) -> Result<RoomMessageEventContent> {
+pub(crate) async fn account_data(subcommand: AccountData) -> Result<RoomMessageEventContent> {
 	match subcommand {
 		AccountData::ChangesSince {
 			user_id,

src/service/admin/query/appservice.rs

@@ -4,7 +4,7 @@ use super::Appservice;
 use crate::{services, Result};
 
 /// All the getters and iterators from src/database/key_value/appservice.rs
-pub(super) async fn appservice(subcommand: Appservice) -> Result<RoomMessageEventContent> {
+pub(crate) async fn appservice(subcommand: Appservice) -> Result<RoomMessageEventContent> {
 	match subcommand {
 		Appservice::GetRegistration {
 			appservice_id,

src/service/admin/query/globals.rs

@@ -4,7 +4,7 @@ use super::Globals;
 use crate::{services, Result};
 
 /// All the getters and iterators from src/database/key_value/globals.rs
-pub(super) async fn globals(subcommand: Globals) -> Result<RoomMessageEventContent> {
+pub(crate) async fn globals(subcommand: Globals) -> Result<RoomMessageEventContent> {
 	match subcommand {
 		Globals::DatabaseVersion => {
 			let timer = tokio::time::Instant::now();

src/service/admin/query/presence.rs

@@ -4,7 +4,7 @@ use super::Presence;
 use crate::{services, Result};
 
 /// All the getters and iterators in key_value/presence.rs
-pub(super) async fn presence(subcommand: Presence) -> Result<RoomMessageEventContent> {
+pub(crate) async fn presence(subcommand: Presence) -> Result<RoomMessageEventContent> {
 	match subcommand {
 		Presence::GetPresence {
 			user_id,

src/service/admin/query/room_alias.rs

@@ -4,7 +4,7 @@ use super::RoomAlias;
 use crate::{services, Result};
 
 /// All the getters and iterators in src/database/key_value/rooms/alias.rs
-pub(super) async fn room_alias(subcommand: RoomAlias) -> Result<RoomMessageEventContent> {
+pub(crate) async fn room_alias(subcommand: RoomAlias) -> Result<RoomMessageEventContent> {
 	match subcommand {
 		RoomAlias::ResolveLocalAlias {
 			alias,

src/service/admin/query/sending.rs

@@ -4,7 +4,7 @@ use super::Sending;
 use crate::{service::sending::Destination, services, Result};
 
 /// All the getters and iterators in key_value/sending.rs
-pub(super) async fn sending(subcommand: Sending) -> Result<RoomMessageEventContent> {
+pub(crate) async fn sending(subcommand: Sending) -> Result<RoomMessageEventContent> {
 	match subcommand {
 		Sending::ActiveRequests => {
 			let timer = tokio::time::Instant::now();

src/service/admin/query/users.rs

@@ -4,7 +4,7 @@ use super::Users;
 use crate::{services, Result};
 
 /// All the getters and iterators in key_value/users.rs
-pub(super) async fn users(subcommand: Users) -> Result<RoomMessageEventContent> {
+pub(crate) async fn users(subcommand: Users) -> Result<RoomMessageEventContent> {
 	match subcommand {
 		Users::Iter => {
 			let timer = tokio::time::Instant::now();

src/service/admin/room/room_commands.rs

@@ -7,7 +7,7 @@ use crate::{
 	services, Result,
 };
 
-pub(super) async fn list(_body: Vec<&str>, page: Option<usize>) -> Result<RoomMessageEventContent> {
+pub(crate) async fn list(_body: Vec<&str>, page: Option<usize>) -> Result<RoomMessageEventContent> {
 	// TODO: i know there's a way to do this with clap, but i can't seem to find it
 	let page = page.unwrap_or(1);
 	let mut rooms = services()

src/service/admin/server/server_commands.rs

@@ -2,12 +2,12 @@ use ruma::events::room::message::RoomMessageEventContent;
 
 use crate::{services, Result};
 
-pub(super) async fn show_config(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
+pub(crate) async fn show_config(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
 	// Construct and send the response
 	Ok(RoomMessageEventContent::text_plain(format!("{}", services().globals.config)))
 }
 
-pub(super) async fn memory_usage(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
+pub(crate) async fn memory_usage(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
 	let response1 = services().memory_usage().await;
 	let response2 = services().globals.db.memory_usage();
 
@@ -16,19 +16,19 @@ pub(super) async fn memory_usage(_body: Vec<&str>) -> Result<RoomMessageEventCon
 	)))
 }
 
-pub(super) async fn clear_database_caches(_body: Vec<&str>, amount: u32) -> Result<RoomMessageEventContent> {
+pub(crate) async fn clear_database_caches(_body: Vec<&str>, amount: u32) -> Result<RoomMessageEventContent> {
 	services().globals.db.clear_caches(amount);
 
 	Ok(RoomMessageEventContent::text_plain("Done."))
 }
 
-pub(super) async fn clear_service_caches(_body: Vec<&str>, amount: u32) -> Result<RoomMessageEventContent> {
+pub(crate) async fn clear_service_caches(_body: Vec<&str>, amount: u32) -> Result<RoomMessageEventContent> {
 	services().clear_caches(amount).await;
 
 	Ok(RoomMessageEventContent::text_plain("Done."))
 }
 
-pub(super) async fn list_backups(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
+pub(crate) async fn list_backups(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
 	let result = services().globals.db.backup_list()?;
 
 	if result.is_empty() {
@@ -38,7 +38,7 @@ pub(super) async fn list_backups(_body: Vec<&str>) -> Result<RoomMessageEventCon
 	}
 }
 
-pub(super) async fn backup_database(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
+pub(crate) async fn backup_database(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
 	if !cfg!(feature = "rocksdb") {
 		return Ok(RoomMessageEventContent::text_plain(
 			"Only RocksDB supports online backups in conduwuit.",
@@ -59,7 +59,7 @@ pub(super) async fn backup_database(_body: Vec<&str>) -> Result<RoomMessageEvent
 	Ok(RoomMessageEventContent::text_plain(&result))
 }
 
-pub(super) async fn list_database_files(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
+pub(crate) async fn list_database_files(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
 	if !cfg!(feature = "rocksdb") {
 		return Ok(RoomMessageEventContent::text_plain(
 			"Only RocksDB supports listing files in conduwuit.",

src/service/admin/user/user_commands.rs

@@ -10,7 +10,7 @@ use crate::{
 	services, utils, Result,
 };
 
-pub(super) async fn list(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
+pub(crate) async fn list(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
 	match services().users.list_local_users() {
 		Ok(users) => {
 			let mut msg = format!("Found {} local user account(s):\n", users.len());
@@ -21,7 +21,7 @@ pub(super) async fn list(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
 	}
 }
 
-pub(super) async fn create(
+pub(crate) async fn create(
 	_body: Vec<&str>, username: String, password: Option<String>,
 ) -> Result<RoomMessageEventContent> {
 	let password = password.unwrap_or_else(|| utils::random_string(AUTO_GEN_PASSWORD_LENGTH));
@@ -119,7 +119,7 @@ pub(super) async fn create(
 	)))
 }
 
-pub(super) async fn deactivate(
+pub(crate) async fn deactivate(
 	_body: Vec<&str>, leave_rooms: bool, user_id: String,
 ) -> Result<RoomMessageEventContent> {
 	// Validate user id
@@ -168,7 +168,7 @@ pub(super) async fn deactivate(
 	}
 }
 
-pub(super) async fn reset_password(_body: Vec<&str>, username: String) -> Result<RoomMessageEventContent> {
+pub(crate) async fn reset_password(_body: Vec<&str>, username: String) -> Result<RoomMessageEventContent> {
 	// Validate user id
 	let user_id =
 		match UserId::parse_with_server_name(username.as_str().to_lowercase(), services().globals.server_name()) {
@@ -210,7 +210,7 @@ pub(super) async fn reset_password(_body: Vec<&str>, username: String) -> Result
 	}
 }
 
-pub(super) async fn deactivate_all(body: Vec<&str>, leave_rooms: bool, force: bool) -> Result<RoomMessageEventContent> {
+pub(crate) async fn deactivate_all(body: Vec<&str>, leave_rooms: bool, force: bool) -> Result<RoomMessageEventContent> {
 	if body.len() > 2 && body[0].trim().starts_with("```") && body.last().unwrap().trim() == "```" {
 		let usernames = body.clone().drain(1..body.len() - 1).collect::<Vec<_>>();
 
@@ -292,7 +292,7 @@ pub(super) async fn deactivate_all(body: Vec<&str>, leave_rooms: bool, force: bo
 	}
 }
 
-pub(super) async fn list_joined_rooms(_body: Vec<&str>, user_id: String) -> Result<RoomMessageEventContent> {
+pub(crate) async fn list_joined_rooms(_body: Vec<&str>, user_id: String) -> Result<RoomMessageEventContent> {
 	// Validate user id
 	let user_id =
 		match UserId::parse_with_server_name(user_id.as_str().to_lowercase(), services().globals.server_name()) {

src/service/appservice/data.rs

@@ -2,7 +2,7 @@ use ruma::api::appservice::Registration;
 
 use crate::Result;
 
-pub trait Data: Send + Sync {
+pub(crate) trait Data: Send + Sync {
 	/// Registers an appservice and returns the ID to the caller
 	fn register_appservice(&self, yaml: Registration) -> Result<String>;
 

src/service/appservice/mod.rs

@@ -15,14 +15,14 @@ use crate::{services, Result};
 
 /// Compiled regular expressions for a namespace
 #[derive(Clone, Debug)]
-pub struct NamespaceRegex {
+pub(crate) struct NamespaceRegex {
-	pub exclusive: Option<RegexSet>,
+	pub(crate) exclusive: Option<RegexSet>,
-	pub non_exclusive: Option<RegexSet>,
+	pub(crate) non_exclusive: Option<RegexSet>,
 }
 
 impl NamespaceRegex {
 	/// Checks if this namespace has rights to a namespace
-	pub fn is_match(&self, heystack: &str) -> bool {
+	pub(crate) fn is_match(&self, heystack: &str) -> bool {
 		if self.is_exclusive_match(heystack) {
 			return true;
 		}
@@ -36,7 +36,7 @@ impl NamespaceRegex {
 	}
 
 	/// Checks if this namespace has exlusive rights to a namespace
-	pub fn is_exclusive_match(&self, heystack: &str) -> bool {
+	pub(crate) fn is_exclusive_match(&self, heystack: &str) -> bool {
 		if let Some(exclusive) = &self.exclusive {
 			if exclusive.is_match(heystack) {
 				return true;
@@ -47,11 +47,11 @@ impl NamespaceRegex {
 }
 
 impl RegistrationInfo {
-	pub fn is_user_match(&self, user_id: &UserId) -> bool {
+	pub(crate) fn is_user_match(&self, user_id: &UserId) -> bool {
 		self.users.is_match(user_id.as_str()) || self.registration.sender_localpart == user_id.localpart()
 	}
 
-	pub fn is_exclusive_user_match(&self, user_id: &UserId) -> bool {
+	pub(crate) fn is_exclusive_user_match(&self, user_id: &UserId) -> bool {
 		self.users.is_exclusive_match(user_id.as_str()) || self.registration.sender_localpart == user_id.localpart()
 	}
 }
@@ -88,11 +88,11 @@ impl TryFrom<Vec<Namespace>> for NamespaceRegex {
 
 /// Appservice registration combined with its compiled regular expressions.
 #[derive(Clone, Debug)]
-pub struct RegistrationInfo {
+pub(crate) struct RegistrationInfo {
-	pub registration: Registration,
+	pub(crate) registration: Registration,
-	pub users: NamespaceRegex,
+	pub(crate) users: NamespaceRegex,
-	pub aliases: NamespaceRegex,
+	pub(crate) aliases: NamespaceRegex,
-	pub rooms: NamespaceRegex,
+	pub(crate) rooms: NamespaceRegex,
 }
 
 impl TryFrom<Registration> for RegistrationInfo {
@@ -108,13 +108,13 @@ impl TryFrom<Registration> for RegistrationInfo {
 	}
 }
 
-pub struct Service {
+pub(crate) struct Service {
-	pub db: &'static dyn Data,
+	pub(crate) db: &'static dyn Data,
 	registration_info: RwLock<BTreeMap<String, RegistrationInfo>>,
 }
 
 impl Service {
-	pub fn build(db: &'static dyn Data) -> Result<Self> {
+	pub(crate) fn build(db: &'static dyn Data) -> Result<Self> {
 		let mut registration_info = BTreeMap::new();
 		// Inserting registrations into cache
 		for appservice in db.all()? {
@@ -134,7 +134,7 @@ impl Service {
 	}
 
 	/// Registers an appservice and returns the ID to the caller
-	pub async fn register_appservice(&self, yaml: Registration) -> Result<String> {
+	pub(crate) async fn register_appservice(&self, yaml: Registration) -> Result<String> {
 		//TODO: Check for collisions between exclusive appservice namespaces
 		services()
 			.appservice
@@ -151,7 +151,7 @@ impl Service {
 	/// # Arguments
 	///
 	/// * `service_name` - the name you send to register the service previously
-	pub async fn unregister_appservice(&self, service_name: &str) -> Result<()> {
+	pub(crate) async fn unregister_appservice(&self, service_name: &str) -> Result<()> {
 		services()
 			.appservice
 			.registration_info
@@ -163,7 +163,7 @@ impl Service {
 		self.db.unregister_appservice(service_name)
 	}
 
-	pub async fn get_registration(&self, id: &str) -> Option<Registration> {
+	pub(crate) async fn get_registration(&self, id: &str) -> Option<Registration> {
 		self.registration_info
 			.read()
 			.await
@@ -172,7 +172,7 @@ impl Service {
 			.map(|info| info.registration)
 	}
 
-	pub async fn iter_ids(&self) -> Vec<String> {
+	pub(crate) async fn iter_ids(&self) -> Vec<String> {
 		self.registration_info
 			.read()
 			.await
@@ -181,7 +181,7 @@ impl Service {
 			.collect()
 	}
 
-	pub async fn find_from_token(&self, token: &str) -> Option<RegistrationInfo> {
+	pub(crate) async fn find_from_token(&self, token: &str) -> Option<RegistrationInfo> {
 		self.read()
 			.await
 			.values()
@@ -190,7 +190,7 @@ impl Service {
 	}
 
 	/// Checks if a given user id matches any exclusive appservice regex
-	pub async fn is_exclusive_user_id(&self, user_id: &UserId) -> bool {
+	pub(crate) async fn is_exclusive_user_id(&self, user_id: &UserId) -> bool {
 		self.read()
 			.await
 			.values()
@@ -198,7 +198,7 @@ impl Service {
 	}
 
 	/// Checks if a given room alias matches any exclusive appservice regex
-	pub async fn is_exclusive_alias(&self, alias: &RoomAliasId) -> bool {
+	pub(crate) async fn is_exclusive_alias(&self, alias: &RoomAliasId) -> bool {
 		self.read()
 			.await
 			.values()
@@ -206,14 +206,16 @@ impl Service {
 	}
 
 	/// Checks if a given room id matches any exclusive appservice regex
-	pub async fn is_exclusive_room_id(&self, room_id: &RoomId) -> bool {
+	pub(crate) async fn is_exclusive_room_id(&self, room_id: &RoomId) -> bool {
 		self.read()
 			.await
 			.values()
 			.any(|info| info.rooms.is_exclusive_match(room_id.as_str()))
 	}
 
-	pub fn read(&self) -> impl Future<Output = tokio::sync::RwLockReadGuard<'_, BTreeMap<String, RegistrationInfo>>> {
+	pub(crate) fn read(
+		&self,
+	) -> impl Future<Output = tokio::sync::RwLockReadGuard<'_, BTreeMap<String, RegistrationInfo>>> {
 		self.registration_info.read()
 	}
 }

src/service/globals/client.rs

@@ -4,18 +4,18 @@ use reqwest::redirect;
 
 use crate::{service::globals::resolver, Config, Result};
 
-pub struct Client {
+pub(crate) struct Client {
-	pub default: reqwest::Client,
+	pub(crate) default: reqwest::Client,
-	pub url_preview: reqwest::Client,
+	pub(crate) url_preview: reqwest::Client,
-	pub well_known: reqwest::Client,
+	pub(crate) well_known: reqwest::Client,
-	pub federation: reqwest::Client,
+	pub(crate) federation: reqwest::Client,
-	pub sender: reqwest::Client,
+	pub(crate) sender: reqwest::Client,
-	pub appservice: reqwest::Client,
+	pub(crate) appservice: reqwest::Client,
-	pub pusher: reqwest::Client,
+	pub(crate) pusher: reqwest::Client,
 }
 
 impl Client {
-	pub fn new(config: &Config, resolver: &Arc<resolver::Resolver>) -> Client {
+	pub(crate) fn new(config: &Config, resolver: &Arc<resolver::Resolver>) -> Client {
 		Client {
 			default: Self::base(config)
 				.unwrap()

src/service/globals/data.rs

@@ -10,7 +10,7 @@ use ruma::{
 use crate::{database::Cork, Result};
 
 #[async_trait]
-pub trait Data: Send + Sync {
+pub(crate) trait Data: Send + Sync {
 	fn next_count(&self) -> Result<u64>;
 	fn current_count(&self) -> Result<u64>;
 	fn last_check_for_updates_id(&self) -> Result<u64>;

src/service/globals/mod.rs

@@ -12,7 +12,7 @@ use std::{
 
 use argon2::Argon2;
 use base64::{engine::general_purpose, Engine as _};
-pub use data::Data;
+pub(crate) use data::Data;
 use hickory_resolver::TokioAsyncResolver;
 use ipaddress::IPAddress;
 use regex::RegexSet;
@@ -32,9 +32,9 @@ use url::Url;
 
 use crate::{services, Config, Result};
 
-pub mod client;
+mod client;
 mod data;
-pub mod resolver;
+mod resolver;
 
 type RateLimitState = (Instant, u32); // Time if last failed try, number of failed tries
 type SyncHandle = (
@@ -42,32 +42,32 @@ type SyncHandle = (
 	Receiver<Option<Result<sync_events::v3::Response>>>, // rx
 );
 
-pub struct Service<'a> {
+pub(crate) struct Service<'a> {
-	pub db: &'static dyn Data,
+	pub(crate) db: &'static dyn Data,
 
-	pub tracing_reload_handle: tracing_subscriber::reload::Handle<EnvFilter, Registry>,
+	pub(crate) tracing_reload_handle: tracing_subscriber::reload::Handle<EnvFilter, Registry>,
-	pub config: Config,
+	pub(crate) config: Config,
-	pub cidr_range_denylist: Vec<IPAddress>,
+	pub(crate) cidr_range_denylist: Vec<IPAddress>,
 	keypair: Arc<ruma::signatures::Ed25519KeyPair>,
 	jwt_decoding_key: Option<jsonwebtoken::DecodingKey>,
-	pub resolver: Arc<resolver::Resolver>,
+	pub(crate) resolver: Arc<resolver::Resolver>,
-	pub client: client::Client,
+	pub(crate) client: client::Client,
-	pub stable_room_versions: Vec<RoomVersionId>,
+	pub(crate) stable_room_versions: Vec<RoomVersionId>,
-	pub unstable_room_versions: Vec<RoomVersionId>,
+	pub(crate) unstable_room_versions: Vec<RoomVersionId>,
-	pub bad_event_ratelimiter: Arc<RwLock<HashMap<OwnedEventId, RateLimitState>>>,
+	pub(crate) bad_event_ratelimiter: Arc<RwLock<HashMap<OwnedEventId, RateLimitState>>>,
-	pub bad_signature_ratelimiter: Arc<RwLock<HashMap<Vec<String>, RateLimitState>>>,
+	pub(crate) bad_signature_ratelimiter: Arc<RwLock<HashMap<Vec<String>, RateLimitState>>>,
-	pub bad_query_ratelimiter: Arc<RwLock<HashMap<OwnedServerName, RateLimitState>>>,
+	pub(crate) bad_query_ratelimiter: Arc<RwLock<HashMap<OwnedServerName, RateLimitState>>>,
-	pub servername_ratelimiter: Arc<RwLock<HashMap<OwnedServerName, Arc<Semaphore>>>>,
+	pub(crate) servername_ratelimiter: Arc<RwLock<HashMap<OwnedServerName, Arc<Semaphore>>>>,
-	pub sync_receivers: RwLock<HashMap<(OwnedUserId, OwnedDeviceId), SyncHandle>>,
+	pub(crate) sync_receivers: RwLock<HashMap<(OwnedUserId, OwnedDeviceId), SyncHandle>>,
-	pub roomid_mutex_insert: RwLock<HashMap<OwnedRoomId, Arc<Mutex<()>>>>,
+	pub(crate) roomid_mutex_insert: RwLock<HashMap<OwnedRoomId, Arc<Mutex<()>>>>,
-	pub roomid_mutex_state: RwLock<HashMap<OwnedRoomId, Arc<Mutex<()>>>>,
+	pub(crate) roomid_mutex_state: RwLock<HashMap<OwnedRoomId, Arc<Mutex<()>>>>,
-	pub roomid_mutex_federation: RwLock<HashMap<OwnedRoomId, Arc<Mutex<()>>>>, // this lock will be held longer
+	pub(crate) roomid_mutex_federation: RwLock<HashMap<OwnedRoomId, Arc<Mutex<()>>>>, // this lock will be held longer
-	pub roomid_federationhandletime: RwLock<HashMap<OwnedRoomId, (OwnedEventId, Instant)>>,
+	pub(crate) roomid_federationhandletime: RwLock<HashMap<OwnedRoomId, (OwnedEventId, Instant)>>,
-	pub stateres_mutex: Arc<Mutex<()>>,
+	pub(crate) stateres_mutex: Arc<Mutex<()>>,
 	pub(crate) rotate: RotationHandler,
 
-	pub shutdown: AtomicBool,
+	pub(crate) shutdown: AtomicBool,
-	pub argon: Argon2<'a>,
+	pub(crate) argon: Argon2<'a>,
 }
 
 /// Handles "rotation" of long-polling requests. "Rotation" in this context is
@@ -78,12 +78,12 @@ pub struct Service<'a> {
 pub(crate) struct RotationHandler(broadcast::Sender<()>, ());
 
 impl RotationHandler {
-	pub fn new() -> Self {
+	fn new() -> Self {
 		let (s, _r) = broadcast::channel(1);
 		Self(s, ())
 	}
 
-	pub fn watch(&self) -> impl Future<Output = ()> {
+	pub(crate) fn watch(&self) -> impl Future<Output = ()> {
 		let mut r = self.0.subscribe();
 
 		async move {
@@ -91,7 +91,7 @@ impl RotationHandler {
 		}
 	}
 
-	pub fn fire(&self) { _ = self.0.send(()); }
+	fn fire(&self) { _ = self.0.send(()); }
 }
 
 impl Default for RotationHandler {
@@ -99,7 +99,7 @@ impl Default for RotationHandler {
 }
 
 impl Service<'_> {
-	pub fn load(
+	pub(crate) fn load(
 		db: &'static dyn Data, config: &Config,
 		tracing_reload_handle: tracing_subscriber::reload::Handle<EnvFilter, Registry>,
 	) -> Result<Self> {
@@ -187,171 +187,179 @@ impl Service<'_> {
 	}
 
 	/// Returns this server's keypair.
-	pub fn keypair(&self) -> &ruma::signatures::Ed25519KeyPair { &self.keypair }
+	pub(crate) fn keypair(&self) -> &ruma::signatures::Ed25519KeyPair { &self.keypair }
 
 	#[tracing::instrument(skip(self))]
-	pub fn next_count(&self) -> Result<u64> { self.db.next_count() }
+	pub(crate) fn next_count(&self) -> Result<u64> { self.db.next_count() }
 
 	#[tracing::instrument(skip(self))]
-	pub fn current_count(&self) -> Result<u64> { self.db.current_count() }
+	pub(crate) fn current_count(&self) -> Result<u64> { self.db.current_count() }
 
 	#[tracing::instrument(skip(self))]
-	pub fn last_check_for_updates_id(&self) -> Result<u64> { self.db.last_check_for_updates_id() }
+	pub(crate) fn last_check_for_updates_id(&self) -> Result<u64> { self.db.last_check_for_updates_id() }
 
 	#[tracing::instrument(skip(self))]
-	pub fn update_check_for_updates_id(&self, id: u64) -> Result<()> { self.db.update_check_for_updates_id(id) }
+	pub(crate) fn update_check_for_updates_id(&self, id: u64) -> Result<()> { self.db.update_check_for_updates_id(id) }
 
-	pub async fn watch(&self, user_id: &UserId, device_id: &DeviceId) -> Result<()> {
+	pub(crate) async fn watch(&self, user_id: &UserId, device_id: &DeviceId) -> Result<()> {
 		self.db.watch(user_id, device_id).await
 	}
 
-	pub fn cleanup(&self) -> Result<()> { self.db.cleanup() }
+	pub(crate) fn cleanup(&self) -> Result<()> { self.db.cleanup() }
 
-	pub fn flush(&self) -> Result<()> { self.db.flush() }
+	pub(crate) fn flush(&self) -> Result<()> { self.db.flush() }
 
-	pub fn server_name(&self) -> &ServerName { self.config.server_name.as_ref() }
+	pub(crate) fn server_name(&self) -> &ServerName { self.config.server_name.as_ref() }
 
-	pub fn max_request_size(&self) -> u32 { self.config.max_request_size }
+	pub(crate) fn max_request_size(&self) -> u32 { self.config.max_request_size }
 
-	pub fn max_fetch_prev_events(&self) -> u16 { self.config.max_fetch_prev_events }
+	pub(crate) fn max_fetch_prev_events(&self) -> u16 { self.config.max_fetch_prev_events }
 
-	pub fn allow_registration(&self) -> bool { self.config.allow_registration }
+	pub(crate) fn allow_registration(&self) -> bool { self.config.allow_registration }
 
-	pub fn allow_guest_registration(&self) -> bool { self.config.allow_guest_registration }
+	pub(crate) fn allow_guest_registration(&self) -> bool { self.config.allow_guest_registration }
 
-	pub fn allow_guests_auto_join_rooms(&self) -> bool { self.config.allow_guests_auto_join_rooms }
+	pub(crate) fn allow_guests_auto_join_rooms(&self) -> bool { self.config.allow_guests_auto_join_rooms }
 
-	pub fn log_guest_registrations(&self) -> bool { self.config.log_guest_registrations }
+	pub(crate) fn log_guest_registrations(&self) -> bool { self.config.log_guest_registrations }
 
-	pub fn allow_encryption(&self) -> bool { self.config.allow_encryption }
+	pub(crate) fn allow_encryption(&self) -> bool { self.config.allow_encryption }
 
-	pub fn allow_federation(&self) -> bool { self.config.allow_federation }
+	pub(crate) fn allow_federation(&self) -> bool { self.config.allow_federation }
 
-	pub fn allow_public_room_directory_over_federation(&self) -> bool {
+	pub(crate) fn allow_public_room_directory_over_federation(&self) -> bool {
 		self.config.allow_public_room_directory_over_federation
 	}
 
-	pub fn allow_public_room_directory_without_auth(&self) -> bool {
+	pub(crate) fn allow_public_room_directory_without_auth(&self) -> bool {
 		self.config.allow_public_room_directory_without_auth
 	}
 
-	pub fn allow_device_name_federation(&self) -> bool { self.config.allow_device_name_federation }
+	pub(crate) fn allow_device_name_federation(&self) -> bool { self.config.allow_device_name_federation }
 
-	pub fn allow_room_creation(&self) -> bool { self.config.allow_room_creation }
+	pub(crate) fn allow_room_creation(&self) -> bool { self.config.allow_room_creation }
 
-	pub fn allow_unstable_room_versions(&self) -> bool { self.config.allow_unstable_room_versions }
+	pub(crate) fn allow_unstable_room_versions(&self) -> bool { self.config.allow_unstable_room_versions }
 
-	pub fn default_room_version(&self) -> RoomVersionId { self.config.default_room_version.clone() }
+	pub(crate) fn default_room_version(&self) -> RoomVersionId { self.config.default_room_version.clone() }
 
-	pub fn new_user_displayname_suffix(&self) -> &String { &self.config.new_user_displayname_suffix }
+	pub(crate) fn new_user_displayname_suffix(&self) -> &String { &self.config.new_user_displayname_suffix }
 
-	pub fn allow_check_for_updates(&self) -> bool { self.config.allow_check_for_updates }
+	pub(crate) fn allow_check_for_updates(&self) -> bool { self.config.allow_check_for_updates }
 
-	pub fn trusted_servers(&self) -> &[OwnedServerName] { &self.config.trusted_servers }
+	pub(crate) fn trusted_servers(&self) -> &[OwnedServerName] { &self.config.trusted_servers }
 
-	pub fn query_trusted_key_servers_first(&self) -> bool { self.config.query_trusted_key_servers_first }
+	pub(crate) fn query_trusted_key_servers_first(&self) -> bool { self.config.query_trusted_key_servers_first }
 
-	pub fn dns_resolver(&self) -> &TokioAsyncResolver { &self.resolver.resolver }
+	pub(crate) fn dns_resolver(&self) -> &TokioAsyncResolver { &self.resolver.resolver }
 
-	pub fn query_all_nameservers(&self) -> bool { self.config.query_all_nameservers }
+	pub(crate) fn query_all_nameservers(&self) -> bool { self.config.query_all_nameservers }
 
-	pub fn actual_destinations(&self) -> &Arc<RwLock<resolver::WellKnownMap>> { &self.resolver.destinations }
+	pub(crate) fn actual_destinations(&self) -> &Arc<RwLock<resolver::WellKnownMap>> { &self.resolver.destinations }
 
-	pub fn jwt_decoding_key(&self) -> Option<&jsonwebtoken::DecodingKey> { self.jwt_decoding_key.as_ref() }
+	pub(crate) fn jwt_decoding_key(&self) -> Option<&jsonwebtoken::DecodingKey> { self.jwt_decoding_key.as_ref() }
 
-	pub fn turn_password(&self) -> &String { &self.config.turn_password }
+	pub(crate) fn turn_password(&self) -> &String { &self.config.turn_password }
 
-	pub fn turn_ttl(&self) -> u64 { self.config.turn_ttl }
+	pub(crate) fn turn_ttl(&self) -> u64 { self.config.turn_ttl }
 
-	pub fn turn_uris(&self) -> &[String] { &self.config.turn_uris }
+	pub(crate) fn turn_uris(&self) -> &[String] { &self.config.turn_uris }
 
-	pub fn turn_username(&self) -> &String { &self.config.turn_username }
+	pub(crate) fn turn_username(&self) -> &String { &self.config.turn_username }
 
-	pub fn turn_secret(&self) -> &String { &self.config.turn_secret }
+	pub(crate) fn turn_secret(&self) -> &String { &self.config.turn_secret }
 
-	pub fn auto_join_rooms(&self) -> &[OwnedRoomId] { &self.config.auto_join_rooms }
+	pub(crate) fn auto_join_rooms(&self) -> &[OwnedRoomId] { &self.config.auto_join_rooms }
 
-	pub fn allow_profile_lookup_federation_requests(&self) -> bool {
+	pub(crate) fn allow_profile_lookup_federation_requests(&self) -> bool {
 		self.config.allow_profile_lookup_federation_requests
 	}
 
-	pub fn notification_push_path(&self) -> &String { &self.config.notification_push_path }
+	pub(crate) fn notification_push_path(&self) -> &String { &self.config.notification_push_path }
 
-	pub fn emergency_password(&self) -> &Option<String> { &self.config.emergency_password }
+	pub(crate) fn emergency_password(&self) -> &Option<String> { &self.config.emergency_password }
 
-	pub fn url_preview_domain_contains_allowlist(&self) -> &Vec<String> {
+	pub(crate) fn url_preview_domain_contains_allowlist(&self) -> &Vec<String> {
 		&self.config.url_preview_domain_contains_allowlist
 	}
 
-	pub fn url_preview_domain_explicit_allowlist(&self) -> &Vec<String> {
+	pub(crate) fn url_preview_domain_explicit_allowlist(&self) -> &Vec<String> {
 		&self.config.url_preview_domain_explicit_allowlist
 	}
 
-	pub fn url_preview_domain_explicit_denylist(&self) -> &Vec<String> {
+	pub(crate) fn url_preview_domain_explicit_denylist(&self) -> &Vec<String> {
 		&self.config.url_preview_domain_explicit_denylist
 	}
 
-	pub fn url_preview_url_contains_allowlist(&self) -> &Vec<String> { &self.config.url_preview_url_contains_allowlist }
+	pub(crate) fn url_preview_url_contains_allowlist(&self) -> &Vec<String> {
+		&self.config.url_preview_url_contains_allowlist
+	}
 
-	pub fn url_preview_max_spider_size(&self) -> usize { self.config.url_preview_max_spider_size }
+	pub(crate) fn url_preview_max_spider_size(&self) -> usize { self.config.url_preview_max_spider_size }
 
-	pub fn url_preview_check_root_domain(&self) -> bool { self.config.url_preview_check_root_domain }
+	pub(crate) fn url_preview_check_root_domain(&self) -> bool { self.config.url_preview_check_root_domain }
 
-	pub fn forbidden_alias_names(&self) -> &RegexSet { &self.config.forbidden_alias_names }
+	pub(crate) fn forbidden_alias_names(&self) -> &RegexSet { &self.config.forbidden_alias_names }
 
-	pub fn forbidden_usernames(&self) -> &RegexSet { &self.config.forbidden_usernames }
+	pub(crate) fn forbidden_usernames(&self) -> &RegexSet { &self.config.forbidden_usernames }
 
-	pub fn allow_local_presence(&self) -> bool { self.config.allow_local_presence }
+	pub(crate) fn allow_local_presence(&self) -> bool { self.config.allow_local_presence }
 
-	pub fn allow_incoming_presence(&self) -> bool { self.config.allow_incoming_presence }
+	pub(crate) fn allow_incoming_presence(&self) -> bool { self.config.allow_incoming_presence }
 
-	pub fn allow_outgoing_presence(&self) -> bool { self.config.allow_outgoing_presence }
+	pub(crate) fn allow_outgoing_presence(&self) -> bool { self.config.allow_outgoing_presence }
 
-	pub fn presence_idle_timeout_s(&self) -> u64 { self.config.presence_idle_timeout_s }
+	pub(crate) fn presence_idle_timeout_s(&self) -> u64 { self.config.presence_idle_timeout_s }
 
-	pub fn presence_offline_timeout_s(&self) -> u64 { self.config.presence_offline_timeout_s }
+	pub(crate) fn presence_offline_timeout_s(&self) -> u64 { self.config.presence_offline_timeout_s }
 
-	pub fn allow_incoming_read_receipts(&self) -> bool { self.config.allow_incoming_read_receipts }
+	pub(crate) fn allow_incoming_read_receipts(&self) -> bool { self.config.allow_incoming_read_receipts }
 
-	pub fn allow_outgoing_read_receipts(&self) -> bool { self.config.allow_outgoing_read_receipts }
+	pub(crate) fn allow_outgoing_read_receipts(&self) -> bool { self.config.allow_outgoing_read_receipts }
 
-	pub fn rocksdb_log_level(&self) -> &String { &self.config.rocksdb_log_level }
+	pub(crate) fn rocksdb_log_level(&self) -> &String { &self.config.rocksdb_log_level }
 
-	pub fn rocksdb_max_log_file_size(&self) -> usize { self.config.rocksdb_max_log_file_size }
+	pub(crate) fn rocksdb_max_log_file_size(&self) -> usize { self.config.rocksdb_max_log_file_size }
 
-	pub fn rocksdb_log_time_to_roll(&self) -> usize { self.config.rocksdb_log_time_to_roll }
+	pub(crate) fn rocksdb_log_time_to_roll(&self) -> usize { self.config.rocksdb_log_time_to_roll }
 
-	pub fn rocksdb_optimize_for_spinning_disks(&self) -> bool { self.config.rocksdb_optimize_for_spinning_disks }
+	pub(crate) fn rocksdb_optimize_for_spinning_disks(&self) -> bool { self.config.rocksdb_optimize_for_spinning_disks }
 
-	pub fn rocksdb_parallelism_threads(&self) -> usize { self.config.rocksdb_parallelism_threads }
+	pub(crate) fn rocksdb_parallelism_threads(&self) -> usize { self.config.rocksdb_parallelism_threads }
 
-	pub fn rocksdb_compression_algo(&self) -> &String { &self.config.rocksdb_compression_algo }
+	pub(crate) fn rocksdb_compression_algo(&self) -> &String { &self.config.rocksdb_compression_algo }
 
-	pub fn rocksdb_compression_level(&self) -> i32 { self.config.rocksdb_compression_level }
+	pub(crate) fn rocksdb_compression_level(&self) -> i32 { self.config.rocksdb_compression_level }
 
-	pub fn rocksdb_bottommost_compression_level(&self) -> i32 { self.config.rocksdb_bottommost_compression_level }
+	pub(crate) fn rocksdb_bottommost_compression_level(&self) -> i32 {
+		self.config.rocksdb_bottommost_compression_level
+	}
 
-	pub fn prevent_media_downloads_from(&self) -> &[OwnedServerName] { &self.config.prevent_media_downloads_from }
+	pub(crate) fn prevent_media_downloads_from(&self) -> &[OwnedServerName] {
+		&self.config.prevent_media_downloads_from
+	}
 
-	pub fn forbidden_remote_server_names(&self) -> &[OwnedServerName] { &self.config.forbidden_remote_server_names }
+	pub(crate) fn forbidden_remote_server_names(&self) -> &[OwnedServerName] {
+		&self.config.forbidden_remote_server_names
+	}
 
-	pub fn forbidden_remote_room_directory_server_names(&self) -> &[OwnedServerName] {
+	pub(crate) fn forbidden_remote_room_directory_server_names(&self) -> &[OwnedServerName] {
 		&self.config.forbidden_remote_room_directory_server_names
 	}
 
-	pub fn ip_range_denylist(&self) -> &[String] { &self.config.ip_range_denylist }
+	pub(crate) fn ip_range_denylist(&self) -> &[String] { &self.config.ip_range_denylist }
 
-	pub fn well_known_support_page(&self) -> &Option<Url> { &self.config.well_known.support_page }
+	pub(crate) fn well_known_support_page(&self) -> &Option<Url> { &self.config.well_known.support_page }
 
-	pub fn well_known_support_role(&self) -> &Option<ContactRole> { &self.config.well_known.support_role }
+	pub(crate) fn well_known_support_role(&self) -> &Option<ContactRole> { &self.config.well_known.support_role }
 
-	pub fn well_known_support_email(&self) -> &Option<String> { &self.config.well_known.support_email }
+	pub(crate) fn well_known_support_email(&self) -> &Option<String> { &self.config.well_known.support_email }
 
-	pub fn well_known_support_mxid(&self) -> &Option<OwnedUserId> { &self.config.well_known.support_mxid }
+	pub(crate) fn well_known_support_mxid(&self) -> &Option<OwnedUserId> { &self.config.well_known.support_mxid }
 
-	pub fn block_non_admin_invites(&self) -> bool { self.config.block_non_admin_invites }
+	pub(crate) fn block_non_admin_invites(&self) -> bool { self.config.block_non_admin_invites }
 
-	pub fn supported_room_versions(&self) -> Vec<RoomVersionId> {
+	pub(crate) fn supported_room_versions(&self) -> Vec<RoomVersionId> {
 		let mut room_versions: Vec<RoomVersionId> = vec![];
 		room_versions.extend(self.stable_room_versions.clone());
 		if self.allow_unstable_room_versions() {
@@ -367,7 +375,7 @@ impl Service<'_> {
 	///
 	/// This doesn't actually check that the keys provided are newer than the
 	/// old set.
-	pub fn add_signing_key(
+	pub(crate) fn add_signing_key(
 		&self, origin: &ServerName, new_keys: ServerSigningKeys,
 	) -> Result<BTreeMap<OwnedServerSigningKeyId, VerifyKey>> {
 		self.db.add_signing_key(origin, new_keys)
@@ -375,7 +383,7 @@ impl Service<'_> {
 
 	/// This returns an empty `Ok(BTreeMap<..>)` when there are no keys found
 	/// for the server.
-	pub fn signing_keys_for(&self, origin: &ServerName) -> Result<BTreeMap<OwnedServerSigningKeyId, VerifyKey>> {
+	pub(crate) fn signing_keys_for(&self, origin: &ServerName) -> Result<BTreeMap<OwnedServerSigningKeyId, VerifyKey>> {
 		let mut keys = self.db.signing_keys_for(origin)?;
 		if origin == self.server_name() {
 			keys.insert(
@@ -391,11 +399,13 @@ impl Service<'_> {
 		Ok(keys)
 	}
 
-	pub fn database_version(&self) -> Result<u64> { self.db.database_version() }
+	pub(crate) fn database_version(&self) -> Result<u64> { self.db.database_version() }
 
-	pub fn bump_database_version(&self, new_version: u64) -> Result<()> { self.db.bump_database_version(new_version) }
+	pub(crate) fn bump_database_version(&self, new_version: u64) -> Result<()> {
+		self.db.bump_database_version(new_version)
+	}
 
-	pub fn get_media_folder(&self) -> PathBuf {
+	pub(crate) fn get_media_folder(&self) -> PathBuf {
 		let mut r = PathBuf::new();
 		r.push(self.config.database_path.clone());
 		r.push("media");
@@ -406,7 +416,7 @@ impl Service<'_> {
 	/// flag enabled and database migrated uses SHA256 hash of the base64 key as
 	/// the file name
 	#[cfg(feature = "sha256_media")]
-	pub fn get_media_file_new(&self, key: &[u8]) -> PathBuf {
+	pub(crate) fn get_media_file_new(&self, key: &[u8]) -> PathBuf {
 		let mut r = PathBuf::new();
 		r.push(self.config.database_path.clone());
 		r.push("media");
@@ -420,7 +430,7 @@ impl Service<'_> {
 	/// old base64 file name media function
 	/// This is the old version of `get_media_file` that uses the full base64
 	/// key as the filename.
-	pub fn get_media_file(&self, key: &[u8]) -> PathBuf {
+	pub(crate) fn get_media_file(&self, key: &[u8]) -> PathBuf {
 		let mut r = PathBuf::new();
 		r.push(self.config.database_path.clone());
 		r.push("media");
@@ -428,13 +438,13 @@ impl Service<'_> {
 		r
 	}
 
-	pub fn well_known_client(&self) -> &Option<Url> { &self.config.well_known.client }
+	pub(crate) fn well_known_client(&self) -> &Option<Url> { &self.config.well_known.client }
 
-	pub fn well_known_server(&self) -> &Option<OwnedServerName> { &self.config.well_known.server }
+	pub(crate) fn well_known_server(&self) -> &Option<OwnedServerName> { &self.config.well_known.server }
 
-	pub fn unix_socket_path(&self) -> &Option<PathBuf> { &self.config.unix_socket_path }
+	pub(crate) fn unix_socket_path(&self) -> &Option<PathBuf> { &self.config.unix_socket_path }
 
-	pub fn valid_cidr_range(&self, ip: &IPAddress) -> bool {
+	pub(crate) fn valid_cidr_range(&self, ip: &IPAddress) -> bool {
 		for cidr in &self.cidr_range_denylist {
 			if cidr.includes(ip) {
 				return false;
@@ -444,7 +454,7 @@ impl Service<'_> {
 		true
 	}
 
-	pub fn shutdown(&self) {
+	pub(crate) fn shutdown(&self) {
 		self.shutdown.store(true, atomic::Ordering::Relaxed);
 		// On shutdown
 

src/service/globals/resolver.rs

@@ -14,19 +14,19 @@ use tracing::error;
 
 use crate::{service::sending::FedDest, Config, Error};
 
-pub type WellKnownMap = HashMap<OwnedServerName, (FedDest, String)>;
+pub(crate) type WellKnownMap = HashMap<OwnedServerName, (FedDest, String)>;
-pub type TlsNameMap = HashMap<String, (Vec<IpAddr>, u16)>;
+type TlsNameMap = HashMap<String, (Vec<IpAddr>, u16)>;
 
-pub struct Resolver {
+pub(crate) struct Resolver {
-	pub destinations: Arc<RwLock<WellKnownMap>>, // actual_destination, host
+	pub(crate) destinations: Arc<RwLock<WellKnownMap>>, // actual_destination, host
-	pub overrides: Arc<StdRwLock<TlsNameMap>>,
+	pub(crate) overrides: Arc<StdRwLock<TlsNameMap>>,
-	pub resolver: Arc<TokioAsyncResolver>,
+	pub(crate) resolver: Arc<TokioAsyncResolver>,
-	pub hooked: Arc<Hooked>,
+	pub(crate) hooked: Arc<Hooked>,
 }
 
-pub struct Hooked {
+pub(crate) struct Hooked {
-	pub overrides: Arc<StdRwLock<TlsNameMap>>,
+	pub(crate) overrides: Arc<StdRwLock<TlsNameMap>>,
-	pub resolver: Arc<TokioAsyncResolver>,
+	pub(crate) resolver: Arc<TokioAsyncResolver>,
 }
 
 impl Resolver {

src/service/key_backups/data.rs

@@ -8,7 +8,7 @@ use ruma::{
 
 use crate::Result;
 
-pub trait Data: Send + Sync {
+pub(crate) trait Data: Send + Sync {
 	fn create_backup(&self, user_id: &UserId, backup_metadata: &Raw<BackupAlgorithm>) -> Result<String>;
 
 	fn delete_backup(&self, user_id: &UserId, version: &str) -> Result<()>;

src/service/key_backups/mod.rs

@@ -10,73 +10,79 @@ use ruma::{
 
 use crate::Result;
 
-pub struct Service {
+pub(crate) struct Service {
-	pub db: &'static dyn Data,
+	pub(crate) db: &'static dyn Data,
 }
 
 impl Service {
-	pub fn create_backup(&self, user_id: &UserId, backup_metadata: &Raw<BackupAlgorithm>) -> Result<String> {
+	pub(crate) fn create_backup(&self, user_id: &UserId, backup_metadata: &Raw<BackupAlgorithm>) -> Result<String> {
 		self.db.create_backup(user_id, backup_metadata)
 	}
 
-	pub fn delete_backup(&self, user_id: &UserId, version: &str) -> Result<()> {
+	pub(crate) fn delete_backup(&self, user_id: &UserId, version: &str) -> Result<()> {
 		self.db.delete_backup(user_id, version)
 	}
 
-	pub fn update_backup(
+	pub(crate) fn update_backup(
 		&self, user_id: &UserId, version: &str, backup_metadata: &Raw<BackupAlgorithm>,
 	) -> Result<String> {
 		self.db.update_backup(user_id, version, backup_metadata)
 	}
 
-	pub fn get_latest_backup_version(&self, user_id: &UserId) -> Result<Option<String>> {
+	pub(crate) fn get_latest_backup_version(&self, user_id: &UserId) -> Result<Option<String>> {
 		self.db.get_latest_backup_version(user_id)
 	}
 
-	pub fn get_latest_backup(&self, user_id: &UserId) -> Result<Option<(String, Raw<BackupAlgorithm>)>> {
+	pub(crate) fn get_latest_backup(&self, user_id: &UserId) -> Result<Option<(String, Raw<BackupAlgorithm>)>> {
 		self.db.get_latest_backup(user_id)
 	}
 
-	pub fn get_backup(&self, user_id: &UserId, version: &str) -> Result<Option<Raw<BackupAlgorithm>>> {
+	pub(crate) fn get_backup(&self, user_id: &UserId, version: &str) -> Result<Option<Raw<BackupAlgorithm>>> {
 		self.db.get_backup(user_id, version)
 	}
 
-	pub fn add_key(
+	pub(crate) fn add_key(
 		&self, user_id: &UserId, version: &str, room_id: &RoomId, session_id: &str, key_data: &Raw<KeyBackupData>,
 	) -> Result<()> {
 		self.db
 			.add_key(user_id, version, room_id, session_id, key_data)
 	}
 
-	pub fn count_keys(&self, user_id: &UserId, version: &str) -> Result<usize> { self.db.count_keys(user_id, version) }
+	pub(crate) fn count_keys(&self, user_id: &UserId, version: &str) -> Result<usize> {
+		self.db.count_keys(user_id, version)
+	}
 
-	pub fn get_etag(&self, user_id: &UserId, version: &str) -> Result<String> { self.db.get_etag(user_id, version) }
+	pub(crate) fn get_etag(&self, user_id: &UserId, version: &str) -> Result<String> {
+		self.db.get_etag(user_id, version)
+	}
 
-	pub fn get_all(&self, user_id: &UserId, version: &str) -> Result<BTreeMap<OwnedRoomId, RoomKeyBackup>> {
+	pub(crate) fn get_all(&self, user_id: &UserId, version: &str) -> Result<BTreeMap<OwnedRoomId, RoomKeyBackup>> {
 		self.db.get_all(user_id, version)
 	}
 
-	pub fn get_room(
+	pub(crate) fn get_room(
 		&self, user_id: &UserId, version: &str, room_id: &RoomId,
 	) -> Result<BTreeMap<String, Raw<KeyBackupData>>> {
 		self.db.get_room(user_id, version, room_id)
 	}
 
-	pub fn get_session(
+	pub(crate) fn get_session(
 		&self, user_id: &UserId, version: &str, room_id: &RoomId, session_id: &str,
 	) -> Result<Option<Raw<KeyBackupData>>> {
 		self.db.get_session(user_id, version, room_id, session_id)
 	}
 
-	pub fn delete_all_keys(&self, user_id: &UserId, version: &str) -> Result<()> {
+	pub(crate) fn delete_all_keys(&self, user_id: &UserId, version: &str) -> Result<()> {
 		self.db.delete_all_keys(user_id, version)
 	}
 
-	pub fn delete_room_keys(&self, user_id: &UserId, version: &str, room_id: &RoomId) -> Result<()> {
+	pub(crate) fn delete_room_keys(&self, user_id: &UserId, version: &str, room_id: &RoomId) -> Result<()> {
 		self.db.delete_room_keys(user_id, version, room_id)
 	}
 
-	pub fn delete_room_key(&self, user_id: &UserId, version: &str, room_id: &RoomId, session_id: &str) -> Result<()> {
+	pub(crate) fn delete_room_key(
+		&self, user_id: &UserId, version: &str, room_id: &RoomId, session_id: &str,
+	) -> Result<()> {
 		self.db
 			.delete_room_key(user_id, version, room_id, session_id)
 	}

src/service/media/data.rs

@@ -1,6 +1,6 @@
 use crate::Result;
 
-pub trait Data: Send + Sync {
+pub(crate) trait Data: Send + Sync {
 	fn create_file_metadata(
 		&self, sender_user: Option<&str>, mxc: String, width: u32, height: u32, content_disposition: Option<&str>,
 		content_type: Option<&str>,

src/service/media/mod.rs

@@ -15,36 +15,36 @@ use tracing::{debug, error};
 use crate::{services, utils, Error, Result};
 
 #[derive(Debug)]
-pub struct FileMeta {
+pub(crate) struct FileMeta {
-	pub content_disposition: Option<String>,
+	pub(crate) content_disposition: Option<String>,
-	pub content_type: Option<String>,
+	pub(crate) content_type: Option<String>,
-	pub file: Vec<u8>,
+	pub(crate) file: Vec<u8>,
 }
 
 #[derive(Serialize, Default)]
-pub struct UrlPreviewData {
+pub(crate) struct UrlPreviewData {
 	#[serde(skip_serializing_if = "Option::is_none", rename(serialize = "og:title"))]
-	pub title: Option<String>,
+	pub(crate) title: Option<String>,
 	#[serde(skip_serializing_if = "Option::is_none", rename(serialize = "og:description"))]
-	pub description: Option<String>,
+	pub(crate) description: Option<String>,
 	#[serde(skip_serializing_if = "Option::is_none", rename(serialize = "og:image"))]
-	pub image: Option<String>,
+	pub(crate) image: Option<String>,
 	#[serde(skip_serializing_if = "Option::is_none", rename(serialize = "matrix:image:size"))]
-	pub image_size: Option<usize>,
+	pub(crate) image_size: Option<usize>,
 	#[serde(skip_serializing_if = "Option::is_none", rename(serialize = "og:image:width"))]
-	pub image_width: Option<u32>,
+	pub(crate) image_width: Option<u32>,
 	#[serde(skip_serializing_if = "Option::is_none", rename(serialize = "og:image:height"))]
-	pub image_height: Option<u32>,
+	pub(crate) image_height: Option<u32>,
 }
 
-pub struct Service {
+pub(crate) struct Service {
-	pub db: &'static dyn Data,
+	pub(crate) db: &'static dyn Data,
-	pub url_preview_mutex: RwLock<HashMap<String, Arc<Mutex<()>>>>,
+	pub(crate) url_preview_mutex: RwLock<HashMap<String, Arc<Mutex<()>>>>,
 }
 
 impl Service {
 	/// Uploads a file.
-	pub async fn create(
+	pub(crate) async fn create(
 		&self, sender_user: Option<OwnedUserId>, mxc: String, content_disposition: Option<&str>,
 		content_type: Option<&str>, file: &[u8],
 	) -> Result<()> {
@@ -78,7 +78,7 @@ impl Service {
 	}
 
 	/// Deletes a file in the database and from the media directory via an MXC
-	pub async fn delete(&self, mxc: String) -> Result<()> {
+	pub(crate) async fn delete(&self, mxc: String) -> Result<()> {
 		if let Ok(keys) = self.db.search_mxc_metadata_prefix(mxc.clone()) {
 			for key in keys {
 				let file_path;
@@ -115,7 +115,7 @@ impl Service {
 
 	/// Uploads or replaces a file thumbnail.
 	#[allow(clippy::too_many_arguments)]
-	pub async fn upload_thumbnail(
+	pub(crate) async fn upload_thumbnail(
 		&self, sender_user: Option<OwnedUserId>, mxc: String, content_disposition: Option<&str>,
 		content_type: Option<&str>, width: u32, height: u32, file: &[u8],
 	) -> Result<()> {
@@ -148,7 +148,7 @@ impl Service {
 	}
 
 	/// Downloads a file.
-	pub async fn get(&self, mxc: String) -> Result<Option<FileMeta>> {
+	pub(crate) async fn get(&self, mxc: String) -> Result<Option<FileMeta>> {
 		if let Ok((content_disposition, content_type, key)) = self.db.search_file_metadata(mxc, 0, 0) {
 			let path;
 
@@ -181,7 +181,7 @@ impl Service {
 
 	/// Deletes all remote only media files in the given at or after
 	/// time/duration. Returns a u32 with the amount of media files deleted.
-	pub async fn delete_all_remote_media_at_after_time(&self, time: String) -> Result<u32> {
+	pub(crate) async fn delete_all_remote_media_at_after_time(&self, time: String) -> Result<u32> {
 		if let Ok(all_keys) = self.db.get_all_media_keys() {
 			let user_duration: SystemTime = match cyborgtime::parse_duration(&time) {
 				Ok(duration) => {
@@ -286,7 +286,7 @@ impl Service {
 
 	/// Returns width, height of the thumbnail and whether it should be cropped.
 	/// Returns None when the server should send the original file.
-	pub fn thumbnail_properties(&self, width: u32, height: u32) -> Option<(u32, u32, bool)> {
+	pub(crate) fn thumbnail_properties(&self, width: u32, height: u32) -> Option<(u32, u32, bool)> {
 		match (width, height) {
 			(0..=32, 0..=32) => Some((32, 32, true)),
 			(0..=96, 0..=96) => Some((96, 96, true)),
@@ -310,7 +310,7 @@ impl Service {
 	///
 	/// For width,height <= 96 the server uses another thumbnailing algorithm
 	/// which crops the image afterwards.
-	pub async fn get_thumbnail(&self, mxc: String, width: u32, height: u32) -> Result<Option<FileMeta>> {
+	pub(crate) async fn get_thumbnail(&self, mxc: String, width: u32, height: u32) -> Result<Option<FileMeta>> {
 		let (width, height, crop) = self
 			.thumbnail_properties(width, height)
 			.unwrap_or((0, 0, false)); // 0, 0 because that's the original file
@@ -457,14 +457,14 @@ impl Service {
 		}
 	}
 
-	pub async fn get_url_preview(&self, url: &str) -> Option<UrlPreviewData> { self.db.get_url_preview(url) }
+	pub(crate) async fn get_url_preview(&self, url: &str) -> Option<UrlPreviewData> { self.db.get_url_preview(url) }
 
-	pub async fn remove_url_preview(&self, url: &str) -> Result<()> {
+	pub(crate) async fn remove_url_preview(&self, url: &str) -> Result<()> {
 		// TODO: also remove the downloaded image
 		self.db.remove_url_preview(url)
 	}
 
-	pub async fn set_url_preview(&self, url: &str, data: &UrlPreviewData) -> Result<()> {
+	pub(crate) async fn set_url_preview(&self, url: &str, data: &UrlPreviewData) -> Result<()> {
 		let now = SystemTime::now()
 			.duration_since(SystemTime::UNIX_EPOCH)
 			.expect("valid system time");

src/service/mod.rs

@@ -23,24 +23,24 @@ pub(crate) mod transaction_ids;
 pub(crate) mod uiaa;
 pub(crate) mod users;
 
-pub struct Services<'a> {
+pub(crate) struct Services<'a> {
-	pub appservice: appservice::Service,
+	pub(crate) appservice: appservice::Service,
-	pub pusher: pusher::Service,
+	pub(crate) pusher: pusher::Service,
-	pub rooms: rooms::Service,
+	pub(crate) rooms: rooms::Service,
-	pub transaction_ids: transaction_ids::Service,
+	pub(crate) transaction_ids: transaction_ids::Service,
-	pub uiaa: uiaa::Service,
+	pub(crate) uiaa: uiaa::Service,
-	pub users: users::Service,
+	pub(crate) users: users::Service,
-	pub account_data: account_data::Service,
+	pub(crate) account_data: account_data::Service,
-	pub presence: Arc<presence::Service>,
+	pub(crate) presence: Arc<presence::Service>,
-	pub admin: Arc<admin::Service>,
+	pub(crate) admin: Arc<admin::Service>,
-	pub globals: globals::Service<'a>,
+	pub(crate) globals: globals::Service<'a>,
-	pub key_backups: key_backups::Service,
+	pub(crate) key_backups: key_backups::Service,
-	pub media: media::Service,
+	pub(crate) media: media::Service,
-	pub sending: Arc<sending::Service>,
+	pub(crate) sending: Arc<sending::Service>,
 }
 
 impl Services<'_> {
-	pub fn build<
+	pub(crate) fn build<
 		D: appservice::Data
 			+ pusher::Data
 			+ rooms::Data

src/service/pdu.rs

@@ -23,39 +23,40 @@ use crate::{services, Error};
 
 /// Content hashes of a PDU.
 #[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct EventHash {
+pub(crate) struct EventHash {
 	/// The SHA-256 hash.
-	pub sha256: String,
+	pub(crate) sha256: String,
 }
 
 #[derive(Clone, Deserialize, Serialize, Debug)]
-pub struct PduEvent {
+pub(crate) struct PduEvent {
-	pub event_id: Arc<EventId>,
+	pub(crate) event_id: Arc<EventId>,
-	pub room_id: OwnedRoomId,
+	pub(crate) room_id: OwnedRoomId,
-	pub sender: OwnedUserId,
+	pub(crate) sender: OwnedUserId,
 	#[serde(skip_serializing_if = "Option::is_none")]
-	pub origin: Option<String>,
+	pub(crate) origin: Option<String>,
-	pub origin_server_ts: UInt,
+	pub(crate) origin_server_ts: UInt,
 	#[serde(rename = "type")]
-	pub kind: TimelineEventType,
+	pub(crate) kind: TimelineEventType,
-	pub content: Box<RawJsonValue>,
+	pub(crate) content: Box<RawJsonValue>,
 	#[serde(skip_serializing_if = "Option::is_none")]
-	pub state_key: Option<String>,
+	pub(crate) state_key: Option<String>,
-	pub prev_events: Vec<Arc<EventId>>,
+	pub(crate) prev_events: Vec<Arc<EventId>>,
-	pub depth: UInt,
+	pub(crate) depth: UInt,
-	pub auth_events: Vec<Arc<EventId>>,
+	pub(crate) auth_events: Vec<Arc<EventId>>,
 	#[serde(skip_serializing_if = "Option::is_none")]
-	pub redacts: Option<Arc<EventId>>,
+	pub(crate) redacts: Option<Arc<EventId>>,
 	#[serde(default, skip_serializing_if = "Option::is_none")]
-	pub unsigned: Option<Box<RawJsonValue>>,
+	pub(crate) unsigned: Option<Box<RawJsonValue>>,
-	pub hashes: EventHash,
+	pub(crate) hashes: EventHash,
 	#[serde(default, skip_serializing_if = "Option::is_none")]
-	pub signatures: Option<Box<RawJsonValue>>, // BTreeMap<Box<ServerName>, BTreeMap<ServerSigningKeyId, String>>
+	pub(crate) signatures: Option<Box<RawJsonValue>>, /* BTreeMap<Box<ServerName>, BTreeMap<ServerSigningKeyId,
+	                                                   * String>> */
 }
 
 impl PduEvent {
 	#[tracing::instrument(skip(self))]
-	pub fn redact(&mut self, room_version_id: RoomVersionId, reason: &PduEvent) -> crate::Result<()> {
+	pub(crate) fn redact(&mut self, room_version_id: RoomVersionId, reason: &PduEvent) -> crate::Result<()> {
 		self.unsigned = None;
 
 		let mut content = serde_json::from_str(self.content.get())
@@ -75,7 +76,7 @@ impl PduEvent {
 		Ok(())
 	}
 
-	pub fn remove_transaction_id(&mut self) -> crate::Result<()> {
+	pub(crate) fn remove_transaction_id(&mut self) -> crate::Result<()> {
 		if let Some(unsigned) = &self.unsigned {
 			let mut unsigned: BTreeMap<String, Box<RawJsonValue>> = serde_json::from_str(unsigned.get())
 				.map_err(|_| Error::bad_database("Invalid unsigned in pdu event"))?;
@@ -86,7 +87,7 @@ impl PduEvent {
 		Ok(())
 	}
 
-	pub fn add_age(&mut self) -> crate::Result<()> {
+	pub(crate) fn add_age(&mut self) -> crate::Result<()> {
 		let mut unsigned: BTreeMap<String, Box<RawJsonValue>> = self
 			.unsigned
 			.as_ref()
@@ -117,7 +118,7 @@ impl PduEvent {
 	/// > serving
 	/// > such events over the Client-Server API.
 	#[must_use]
-	pub fn copy_redacts(&self) -> (Option<Arc<EventId>>, Box<RawJsonValue>) {
+	pub(crate) fn copy_redacts(&self) -> (Option<Arc<EventId>>, Box<RawJsonValue>) {
 		if self.kind == TimelineEventType::RoomRedaction {
 			if let Ok(mut content) = serde_json::from_str::<RoomRedactionEventContent>(self.content.get()) {
 				if let Some(redacts) = content.redacts {
@@ -136,7 +137,7 @@ impl PduEvent {
 	}
 
 	#[tracing::instrument(skip(self))]
-	pub fn to_sync_room_event(&self) -> Raw<AnySyncTimelineEvent> {
+	pub(crate) fn to_sync_room_event(&self) -> Raw<AnySyncTimelineEvent> {
 		let (redacts, content) = self.copy_redacts();
 		let mut json = json!({
 			"content": content,
@@ -161,7 +162,7 @@ impl PduEvent {
 
 	/// This only works for events that are also AnyRoomEvents.
 	#[tracing::instrument(skip(self))]
-	pub fn to_any_event(&self) -> Raw<AnyEphemeralRoomEvent> {
+	pub(crate) fn to_any_event(&self) -> Raw<AnyEphemeralRoomEvent> {
 		let (redacts, content) = self.copy_redacts();
 		let mut json = json!({
 			"content": content,
@@ -186,7 +187,7 @@ impl PduEvent {
 	}
 
 	#[tracing::instrument(skip(self))]
-	pub fn to_room_event(&self) -> Raw<AnyTimelineEvent> {
+	pub(crate) fn to_room_event(&self) -> Raw<AnyTimelineEvent> {
 		let (redacts, content) = self.copy_redacts();
 		let mut json = json!({
 			"content": content,
@@ -211,7 +212,7 @@ impl PduEvent {
 	}
 
 	#[tracing::instrument(skip(self))]
-	pub fn to_message_like_event(&self) -> Raw<AnyMessageLikeEvent> {
+	pub(crate) fn to_message_like_event(&self) -> Raw<AnyMessageLikeEvent> {
 		let (redacts, content) = self.copy_redacts();
 		let mut json = json!({
 			"content": content,
@@ -236,7 +237,7 @@ impl PduEvent {
 	}
 
 	#[tracing::instrument(skip(self))]
-	pub fn to_state_event(&self) -> Raw<AnyStateEvent> {
+	pub(crate) fn to_state_event(&self) -> Raw<AnyStateEvent> {
 		let mut json = json!({
 			"content": self.content,
 			"type": self.kind,
@@ -255,7 +256,7 @@ impl PduEvent {
 	}
 
 	#[tracing::instrument(skip(self))]
-	pub fn to_sync_state_event(&self) -> Raw<AnySyncStateEvent> {
+	pub(crate) fn to_sync_state_event(&self) -> Raw<AnySyncStateEvent> {
 		let mut json = json!({
 			"content": self.content,
 			"type": self.kind,
@@ -273,7 +274,7 @@ impl PduEvent {
 	}
 
 	#[tracing::instrument(skip(self))]
-	pub fn to_stripped_state_event(&self) -> Raw<AnyStrippedStateEvent> {
+	pub(crate) fn to_stripped_state_event(&self) -> Raw<AnyStrippedStateEvent> {
 		let json = json!({
 			"content": self.content,
 			"type": self.kind,
@@ -285,7 +286,7 @@ impl PduEvent {
 	}
 
 	#[tracing::instrument(skip(self))]
-	pub fn to_stripped_spacechild_state_event(&self) -> Raw<HierarchySpaceChildEvent> {
+	pub(crate) fn to_stripped_spacechild_state_event(&self) -> Raw<HierarchySpaceChildEvent> {
 		let json = json!({
 			"content": self.content,
 			"type": self.kind,
@@ -298,7 +299,7 @@ impl PduEvent {
 	}
 
 	#[tracing::instrument(skip(self))]
-	pub fn to_member_event(&self) -> Raw<StateEvent<RoomMemberEventContent>> {
+	pub(crate) fn to_member_event(&self) -> Raw<StateEvent<RoomMemberEventContent>> {
 		let mut json = json!({
 			"content": self.content,
 			"type": self.kind,
@@ -319,7 +320,7 @@ impl PduEvent {
 
 	/// This does not return a full `Pdu` it is only to satisfy ruma's types.
 	#[tracing::instrument]
-	pub fn convert_to_outgoing_federation_event(mut pdu_json: CanonicalJsonObject) -> Box<RawJsonValue> {
+	pub(crate) fn convert_to_outgoing_federation_event(mut pdu_json: CanonicalJsonObject) -> Box<RawJsonValue> {
 		if let Some(unsigned) = pdu_json
 			.get_mut("unsigned")
 			.and_then(|val| val.as_object_mut())
@@ -356,7 +357,7 @@ impl PduEvent {
 		to_raw_value(&pdu_json).expect("CanonicalJson is valid serde_json::Value")
 	}
 
-	pub fn from_id_val(event_id: &EventId, mut json: CanonicalJsonObject) -> Result<Self, serde_json::Error> {
+	pub(crate) fn from_id_val(event_id: &EventId, mut json: CanonicalJsonObject) -> Result<Self, serde_json::Error> {
 		json.insert("event_id".to_owned(), CanonicalJsonValue::String(event_id.as_str().to_owned()));
 
 		serde_json::from_value(serde_json::to_value(json).expect("valid JSON"))
@@ -425,11 +426,11 @@ pub(crate) fn gen_event_id_canonical_json(
 
 /// Build the start of a PDU in order to add it to the Database.
 #[derive(Debug, Deserialize)]
-pub struct PduBuilder {
+pub(crate) struct PduBuilder {
 	#[serde(rename = "type")]
-	pub event_type: TimelineEventType,
+	pub(crate) event_type: TimelineEventType,
-	pub content: Box<RawJsonValue>,
+	pub(crate) content: Box<RawJsonValue>,
-	pub unsigned: Option<BTreeMap<String, serde_json::Value>>,
+	pub(crate) unsigned: Option<BTreeMap<String, serde_json::Value>>,
-	pub state_key: Option<String>,
+	pub(crate) state_key: Option<String>,
-	pub redacts: Option<Arc<EventId>>,
+	pub(crate) redacts: Option<Arc<EventId>>,
 }

src/service/presence/data.rs

@@ -2,7 +2,7 @@ use ruma::{events::presence::PresenceEvent, presence::PresenceState, OwnedUserId
 
 use crate::Result;
 
-pub trait Data: Send + Sync {
+pub(crate) trait Data: Send + Sync {
 	/// Returns the latest presence event for the given user.
 	fn get_presence(&self, user_id: &UserId) -> Result<Option<(u64, PresenceEvent)>>;
 

src/service/presence/mod.rs

@@ -2,7 +2,7 @@ mod data;
 
 use std::{sync::Arc, time::Duration};
 
-pub use data::Data;
+pub(crate) use data::Data;
 use futures_util::{stream::FuturesUnordered, StreamExt};
 use ruma::{
 	events::presence::{PresenceEvent, PresenceEventContent},
@@ -18,15 +18,17 @@ use crate::{services, utils, Config, Error, Result};
 /// Represents data required to be kept in order to implement the presence
 /// specification.
 #[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct Presence {
+pub(crate) struct Presence {
-	pub state: PresenceState,
+	state: PresenceState,
-	pub currently_active: bool,
+	currently_active: bool,
-	pub last_active_ts: u64,
+	last_active_ts: u64,
-	pub status_msg: Option<String>,
+	status_msg: Option<String>,
 }
 
 impl Presence {
-	pub fn new(state: PresenceState, currently_active: bool, last_active_ts: u64, status_msg: Option<String>) -> Self {
+	pub(crate) fn new(
+		state: PresenceState, currently_active: bool, last_active_ts: u64, status_msg: Option<String>,
+	) -> Self {
 		Self {
 			state,
 			currently_active,
@@ -35,21 +37,21 @@ impl Presence {
 		}
 	}
 
-	pub fn from_json_bytes_to_event(bytes: &[u8], user_id: &UserId) -> Result<PresenceEvent> {
+	pub(crate) fn from_json_bytes_to_event(bytes: &[u8], user_id: &UserId) -> Result<PresenceEvent> {
 		let presence = Self::from_json_bytes(bytes)?;
 		presence.to_presence_event(user_id)
 	}
 
-	pub fn from_json_bytes(bytes: &[u8]) -> Result<Self> {
+	pub(crate) fn from_json_bytes(bytes: &[u8]) -> Result<Self> {
 		serde_json::from_slice(bytes).map_err(|_| Error::bad_database("Invalid presence data in database"))
 	}
 
-	pub fn to_json_bytes(&self) -> Result<Vec<u8>> {
+	pub(crate) fn to_json_bytes(&self) -> Result<Vec<u8>> {
 		serde_json::to_vec(self).map_err(|_| Error::bad_database("Could not serialize Presence to JSON"))
 	}
 
 	/// Creates a PresenceEvent from available data.
-	pub fn to_presence_event(&self, user_id: &UserId) -> Result<PresenceEvent> {
+	pub(crate) fn to_presence_event(&self, user_id: &UserId) -> Result<PresenceEvent> {
 		let now = utils::millis_since_unix_epoch();
 		let last_active_ago = if self.currently_active {
 			None
@@ -71,15 +73,15 @@ impl Presence {
 	}
 }
 
-pub struct Service {
+pub(crate) struct Service {
-	pub db: &'static dyn Data,
+	pub(crate) db: &'static dyn Data,
-	pub timer_sender: loole::Sender<(OwnedUserId, Duration)>,
+	pub(crate) timer_sender: loole::Sender<(OwnedUserId, Duration)>,
 	timer_receiver: Mutex<loole::Receiver<(OwnedUserId, Duration)>>,
 	timeout_remote_users: bool,
 }
 
 impl Service {
-	pub fn build(db: &'static dyn Data, config: &Config) -> Arc<Self> {
+	pub(crate) fn build(db: &'static dyn Data, config: &Config) -> Arc<Self> {
 		let (timer_sender, timer_receiver) = loole::unbounded();
 
 		Arc::new(Self {
@@ -90,7 +92,7 @@ impl Service {
 		})
 	}
 
-	pub fn start_handler(self: &Arc<Self>) {
+	pub(crate) fn start_handler(self: &Arc<Self>) {
 		let self_ = Arc::clone(self);
 		tokio::spawn(async move {
 			self_
@@ -101,7 +103,7 @@ impl Service {
 	}
 
 	/// Returns the latest presence event for the given user.
-	pub fn get_presence(&self, user_id: &UserId) -> Result<Option<PresenceEvent>> {
+	pub(crate) fn get_presence(&self, user_id: &UserId) -> Result<Option<PresenceEvent>> {
 		if let Some((_, presence)) = self.db.get_presence(user_id)? {
 			Ok(Some(presence))
 		} else {
@@ -111,7 +113,7 @@ impl Service {
 
 	/// Pings the presence of the given user in the given room, setting the
 	/// specified state.
-	pub fn ping_presence(&self, user_id: &UserId, new_state: &PresenceState) -> Result<()> {
+	pub(crate) fn ping_presence(&self, user_id: &UserId, new_state: &PresenceState) -> Result<()> {
 		const REFRESH_TIMEOUT: u64 = 60 * 25 * 1000;
 
 		let last_presence = self.db.get_presence(user_id)?;
@@ -140,7 +142,7 @@ impl Service {
 	}
 
 	/// Adds a presence event which will be saved until a new event replaces it.
-	pub fn set_presence(
+	pub(crate) fn set_presence(
 		&self, user_id: &UserId, state: &PresenceState, currently_active: Option<bool>, last_active_ago: Option<UInt>,
 		status_msg: Option<String>,
 	) -> Result<()> {
@@ -170,11 +172,14 @@ impl Service {
 	}
 
 	/// Removes the presence record for the given user from the database.
-	pub fn remove_presence(&self, user_id: &UserId) -> Result<()> { self.db.remove_presence(user_id) }
+	///
+	/// TODO: Why is this not used?
+	#[allow(dead_code)]
+	pub(crate) fn remove_presence(&self, user_id: &UserId) -> Result<()> { self.db.remove_presence(user_id) }
 
 	/// Returns the most recent presence updates that happened after the event
 	/// with id `since`.
-	pub fn presence_since(&self, since: u64) -> Box<dyn Iterator<Item = (OwnedUserId, u64, Vec<u8>)>> {
+	pub(crate) fn presence_since(&self, since: u64) -> Box<dyn Iterator<Item = (OwnedUserId, u64, Vec<u8>)>> {
 		self.db.presence_since(since)
 	}
 

src/service/pusher/data.rs

@@ -5,7 +5,7 @@ use ruma::{
 
 use crate::Result;
 
-pub trait Data: Send + Sync {
+pub(crate) trait Data: Send + Sync {
 	fn set_pusher(&self, sender: &UserId, pusher: set_pusher::v3::PusherAction) -> Result<()>;
 
 	fn get_pusher(&self, sender: &UserId, pushkey: &str) -> Result<Option<Pusher>>;

src/service/pusher/mod.rs

@@ -2,7 +2,7 @@ mod data;
 use std::{fmt::Debug, mem};
 
 use bytes::BytesMut;
-pub use data::Data;
+pub(crate) use data::Data;
 use ipaddress::IPAddress;
 use ruma::{
 	api::{
@@ -24,27 +24,27 @@ use tracing::{info, trace, warn};
 
 use crate::{services, Error, PduEvent, Result};
 
-pub struct Service {
+pub(crate) struct Service {
-	pub db: &'static dyn Data,
+	pub(crate) db: &'static dyn Data,
 }
 
 impl Service {
-	pub fn set_pusher(&self, sender: &UserId, pusher: set_pusher::v3::PusherAction) -> Result<()> {
+	pub(crate) fn set_pusher(&self, sender: &UserId, pusher: set_pusher::v3::PusherAction) -> Result<()> {
 		self.db.set_pusher(sender, pusher)
 	}
 
-	pub fn get_pusher(&self, sender: &UserId, pushkey: &str) -> Result<Option<Pusher>> {
+	pub(crate) fn get_pusher(&self, sender: &UserId, pushkey: &str) -> Result<Option<Pusher>> {
 		self.db.get_pusher(sender, pushkey)
 	}
 
-	pub fn get_pushers(&self, sender: &UserId) -> Result<Vec<Pusher>> { self.db.get_pushers(sender) }
+	pub(crate) fn get_pushers(&self, sender: &UserId) -> Result<Vec<Pusher>> { self.db.get_pushers(sender) }
 
-	pub fn get_pushkeys(&self, sender: &UserId) -> Box<dyn Iterator<Item = Result<String>>> {
+	pub(crate) fn get_pushkeys(&self, sender: &UserId) -> Box<dyn Iterator<Item = Result<String>>> {
 		self.db.get_pushkeys(sender)
 	}
 
 	#[tracing::instrument(skip(self, destination, request))]
-	pub async fn send_request<T>(&self, destination: &str, request: T) -> Result<T::IncomingResponse>
+	pub(crate) async fn send_request<T>(&self, destination: &str, request: T) -> Result<T::IncomingResponse>
 	where
 		T: OutgoingRequest + Debug,
 	{
@@ -138,7 +138,7 @@ impl Service {
 	}
 
 	#[tracing::instrument(skip(self, user, unread, pusher, ruleset, pdu))]
-	pub async fn send_push_notice(
+	pub(crate) async fn send_push_notice(
 		&self, user: &UserId, unread: UInt, pusher: &Pusher, ruleset: Ruleset, pdu: &PduEvent,
 	) -> Result<()> {
 		let mut notify = None;
@@ -183,7 +183,7 @@ impl Service {
 	}
 
 	#[tracing::instrument(skip(self, user, ruleset, pdu))]
-	pub fn get_actions<'a>(
+	pub(crate) fn get_actions<'a>(
 		&self, user: &UserId, ruleset: &'a Ruleset, power_levels: &RoomPowerLevelsEventContent,
 		pdu: &Raw<AnySyncTimelineEvent>, room_id: &RoomId,
 	) -> Result<&'a [Action]> {

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(crate) struct Service {
-	pub db: &'static dyn Data,
+	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(crate) struct Service {
-	pub db: &'static dyn Data,
+	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(crate) struct Service {
-	pub db: &'static dyn Data,
+	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;
+mod signing_keys;
-pub struct Service;
+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(crate) struct Service {
-	pub db: &'static dyn Data,
+	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(crate) struct Service {
-	pub db: &'static dyn Data,
+	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(crate) mod alias;
-pub mod auth_chain;
+pub(crate) mod auth_chain;
-pub mod directory;
+pub(crate) mod directory;
-pub mod event_handler;
+pub(crate) mod event_handler;
-pub mod lazy_loading;
+pub(crate) mod lazy_loading;
-pub mod metadata;
+pub(crate) mod metadata;
-pub mod outlier;
+pub(crate) mod outlier;
-pub mod pdu_metadata;
+pub(crate) mod pdu_metadata;
-pub mod read_receipt;
+pub(crate) mod read_receipt;
-pub mod search;
+pub(crate) mod search;
-pub mod short;
+pub(crate) mod short;
-pub mod spaces;
+pub(crate) mod spaces;
-pub mod state;
+pub(crate) mod state;
-pub mod state_accessor;
+pub(crate) mod state_accessor;
-pub mod state_cache;
+pub(crate) mod state_cache;
-pub mod state_compressor;
+pub(crate) mod state_compressor;
-pub mod threads;
+pub(crate) mod threads;
-pub mod timeline;
+pub(crate) mod timeline;
-pub mod typing;
+pub(crate) mod typing;
-pub mod user;
+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(crate) struct Service {
-	pub alias: alias::Service,
+	pub(crate) alias: alias::Service,
-	pub auth_chain: auth_chain::Service,
+	pub(crate) auth_chain: auth_chain::Service,
-	pub directory: directory::Service,
+	pub(crate) directory: directory::Service,
-	pub event_handler: event_handler::Service,
+	pub(crate) event_handler: event_handler::Service,
-	pub lazy_loading: lazy_loading::Service,
+	pub(crate) lazy_loading: lazy_loading::Service,
-	pub metadata: metadata::Service,
+	pub(crate) metadata: metadata::Service,
-	pub outlier: outlier::Service,
+	pub(crate) outlier: outlier::Service,
-	pub pdu_metadata: pdu_metadata::Service,
+	pub(crate) pdu_metadata: pdu_metadata::Service,
-	pub read_receipt: read_receipt::Service,
+	pub(crate) read_receipt: read_receipt::Service,
-	pub search: search::Service,
+	pub(crate) search: search::Service,
-	pub short: short::Service,
+	pub(crate) short: short::Service,
-	pub state: state::Service,
+	pub(crate) state: state::Service,
-	pub state_accessor: state_accessor::Service,
+	pub(crate) state_accessor: state_accessor::Service,
-	pub state_cache: state_cache::Service,
+	pub(crate) state_cache: state_cache::Service,
-	pub state_compressor: state_compressor::Service,
+	pub(crate) state_compressor: state_compressor::Service,
-	pub timeline: timeline::Service,
+	pub(crate) timeline: timeline::Service,
-	pub threads: threads::Service,
+	pub(crate) threads: threads::Service,
-	pub typing: typing::Service,
+	pub(crate) typing: typing::Service,
-	pub spaces: spaces::Service,
+	pub(crate) spaces: spaces::Service,
-	pub user: user::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(crate) struct Service {
-	pub db: &'static dyn Data,
+	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)
 	}
 }