Services refactor

Replace structs of Dep<Service> with OnceServices, so each service has a Services reference

Remove service name => Service map

Flatten Services.rooms

Make reqwest Clients lazy initialized (client service)

src/api/client/account.rs

@@ -215,7 +215,6 @@ pub(crate) async fn deactivate_route(
 
 	// Remove profile pictures and display name
 	let all_joined_rooms: Vec<OwnedRoomId> = services
-		.rooms
 		.state_cache
 		.rooms_joined(sender_user)
 		.map(Into::into)
@@ -317,10 +316,9 @@ pub async fn full_user_deactivate(
 		.await;
 
 	for room_id in all_joined_rooms {
-		let state_lock = services.rooms.state.mutex.lock(room_id).await;
+		let state_lock = services.state.mutex.lock(room_id).await;
 
 		let room_power_levels = services
-			.rooms
 			.state_accessor
 			.get_power_levels(room_id)
 			.await
@@ -334,7 +332,6 @@ pub async fn full_user_deactivate(
 
 		let user_can_demote_self = user_can_change_self
 			|| services
-				.rooms
 				.state_accessor
 				.room_state_get(room_id, &StateEventType::RoomCreate, "")
 				.await
@@ -350,7 +347,6 @@ pub async fn full_user_deactivate(
 
 			// ignore errors so deactivation doesn't fail
 			match services
-				.rooms
 				.timeline
 				.build_and_append_pdu(
 					PduBuilder::state(String::new(), &power_levels_content),

src/api/client/alias.rs

@@ -19,7 +19,6 @@ pub(crate) async fn create_alias_route(
 ) -> Result<create_alias::v3::Response> {
 	let sender_user = body.sender_user();
 	services
-		.rooms
 		.alias
 		.appservice_checks(&body.room_alias, &body.appservice_info)
 		.await?;
@@ -35,7 +34,6 @@ pub(crate) async fn create_alias_route(
 	}
 
 	if services
-		.rooms
 		.alias
 		.resolve_local_alias(&body.room_alias)
 		.await
@@ -45,7 +43,6 @@ pub(crate) async fn create_alias_route(
 	}
 
 	services
-		.rooms
 		.alias
 		.set_alias(&body.room_alias, &body.room_id, sender_user)?;
 
@@ -63,13 +60,11 @@ pub(crate) async fn delete_alias_route(
 ) -> Result<delete_alias::v3::Response> {
 	let sender_user = body.sender_user();
 	services
-		.rooms
 		.alias
 		.appservice_checks(&body.room_alias, &body.appservice_info)
 		.await?;
 
 	services
-		.rooms
 		.alias
 		.remove_alias(&body.room_alias, sender_user)
 		.await?;
@@ -89,7 +84,6 @@ pub(crate) async fn get_alias_route(
 	let room_alias = body.body.room_alias;
 
 	let Ok((room_id, servers)) = services
-		.rooms
 		.alias
 		.resolve_alias(&room_alias, None)
 		.await
@@ -111,7 +105,6 @@ async fn room_available_servers(
 ) -> Vec<OwnedServerName> {
 	// find active servers in room state cache to suggest
 	let mut servers: Vec<OwnedServerName> = services
-		.rooms
 		.state_cache
 		.room_servers(room_id)
 		.map(ToOwned::to_owned)

src/api/client/context.rs

@@ -38,7 +38,7 @@ pub(crate) async fn get_context_route(
 	let event_id = &body.event_id;
 	let filter = &body.filter;
 
-	if !services.rooms.metadata.exists(room_id).await {
+	if !services.metadata.exists(room_id).await {
 		return Err!(Request(Forbidden("Room does not exist to this server")));
 	}
 
@@ -50,19 +50,16 @@ pub(crate) async fn get_context_route(
 		.min(LIMIT_MAX);
 
 	let base_id = services
-		.rooms
 		.timeline
 		.get_pdu_id(event_id)
 		.map_err(|_| err!(Request(NotFound("Event not found."))));
 
 	let base_pdu = services
-		.rooms
 		.timeline
 		.get_pdu(event_id)
 		.map_err(|_| err!(Request(NotFound("Base event not found."))));
 
 	let visible = services
-		.rooms
 		.state_accessor
 		.user_can_see_event(sender_user, room_id, event_id)
 		.map(Ok);
@@ -83,7 +80,6 @@ pub(crate) async fn get_context_route(
 	let base_event = ignored_filter(&services, (base_count, base_pdu), sender_user);
 
 	let events_before = services
-		.rooms
 		.timeline
 		.pdus_rev(Some(sender_user), room_id, Some(base_count))
 		.ignore_err()
@@ -94,7 +90,6 @@ pub(crate) async fn get_context_route(
 		.collect();
 
 	let events_after = services
-		.rooms
 		.timeline
 		.pdus(Some(sender_user), room_id, Some(base_count))
 		.ignore_err()
@@ -135,18 +130,11 @@ pub(crate) async fn get_context_route(
 		.map_or_else(|| body.event_id.as_ref(), |pdu| pdu.event_id.as_ref());
 
 	let state_ids = services
-		.rooms
 		.state_accessor
 		.pdu_shortstatehash(state_at)
-		.or_else(|_| {
-			services
-				.rooms
-				.state
-				.get_room_shortstatehash(room_id)
-		})
+		.or_else(|_| services.state.get_room_shortstatehash(room_id))
 		.map_ok(|shortstatehash| {
 			services
-				.rooms
 				.state_accessor
 				.state_full_ids(shortstatehash)
 				.map(Ok)
@@ -163,7 +151,6 @@ pub(crate) async fn get_context_route(
 	let shorteventids = state_ids.iter().map(ref_at!(1)).stream();
 	let lazy_loading_witnessed = lazy_loading_witnessed.unwrap_or_default();
 	let state: Vec<_> = services
-		.rooms
 		.short
 		.multi_get_statekey_from_short(shortstatekeys)
 		.zip(shorteventids)
@@ -182,11 +169,7 @@ pub(crate) async fn get_context_route(
 			Some(event_id)
 		})
 		.broad_filter_map(|event_id: &OwnedEventId| {
-			services
-				.rooms
-				.timeline
-				.get_pdu(event_id.as_ref())
-				.ok()
+			services.timeline.get_pdu(event_id.as_ref()).ok()
 		})
 		.map(Event::into_format)
 		.collect()

src/api/client/directory.rs

@@ -111,12 +111,7 @@ pub(crate) async fn set_room_visibility_route(
 ) -> Result<set_room_visibility::v3::Response> {
 	let sender_user = body.sender_user();
 
-	if !services
-		.rooms
-		.metadata
-		.exists(&body.room_id)
-		.await
-	{
+	if !services.metadata.exists(&body.room_id).await {
 		// Return 404 if the room doesn't exist
 		return Err!(Request(NotFound("Room not found")));
 	}
@@ -166,7 +161,7 @@ pub(crate) async fn set_room_visibility_route(
 				)));
 			}
 
-			services.rooms.directory.set_public(&body.room_id);
+			services.directory.set_public(&body.room_id);
 
 			if services.server.config.admin_room_notices {
 				services
@@ -179,10 +174,7 @@ pub(crate) async fn set_room_visibility_route(
 			}
 			info!("{sender_user} made {0} public to the room directory", body.room_id);
 		},
-		| room::Visibility::Private => services
-			.rooms
-			.directory
-			.set_not_public(&body.room_id),
+		| room::Visibility::Private => services.directory.set_not_public(&body.room_id),
 		| _ => {
 			return Err!(Request(InvalidParam("Room visibility type is not supported.",)));
 		},
@@ -198,19 +190,13 @@ pub(crate) async fn get_room_visibility_route(
 	State(services): State<crate::State>,
 	body: Ruma<get_room_visibility::v3::Request>,
 ) -> Result<get_room_visibility::v3::Response> {
-	if !services
-		.rooms
-		.metadata
-		.exists(&body.room_id)
-		.await
-	{
+	if !services.metadata.exists(&body.room_id).await {
 		// Return 404 if the room doesn't exist
 		return Err!(Request(NotFound("Room not found")));
 	}
 
 	Ok(get_room_visibility::v3::Response {
 		visibility: if services
-			.rooms
 			.directory
 			.is_public_room(&body.room_id)
 			.await
@@ -295,13 +281,12 @@ pub(crate) async fn get_public_rooms_filtered_helper(
 
 	let meta_public_rooms = search_room_id
 		.filter(|_| services.config.allow_unlisted_room_search_by_id)
-		.map(|prefix| services.rooms.metadata.public_ids_prefix(prefix))
+		.map(|prefix| services.metadata.public_ids_prefix(prefix))
 		.into_iter()
 		.stream()
 		.flatten();
 
 	let mut all_rooms: Vec<PublicRoomsChunk> = services
-		.rooms
 		.directory
 		.public_rooms()
 		.map(ToOwned::to_owned)
@@ -388,7 +373,6 @@ async fn user_can_publish_room(
 	room_id: &RoomId,
 ) -> Result<bool> {
 	match services
-		.rooms
 		.state_accessor
 		.get_power_levels(room_id)
 		.await
@@ -397,7 +381,6 @@ async fn user_can_publish_room(
 			Ok(power_levels.user_can_send_state(user_id, StateEventType::RoomHistoryVisibility)),
 		| _ => {
 			match services
-				.rooms
 				.state_accessor
 				.room_state_get(room_id, &StateEventType::RoomCreate, "")
 				.await
@@ -410,39 +393,30 @@ async fn user_can_publish_room(
 }
 
 async fn public_rooms_chunk(services: &Services, room_id: OwnedRoomId) -> PublicRoomsChunk {
-	let name = services
-		.rooms
-		.state_accessor
-		.get_name(&room_id)
-		.ok();
+	let name = services.state_accessor.get_name(&room_id).ok();
 
 	let room_type = services
-		.rooms
 		.state_accessor
 		.get_room_type(&room_id)
 		.ok();
 
 	let canonical_alias = services
-		.rooms
 		.state_accessor
 		.get_canonical_alias(&room_id)
 		.ok();
 
-	let avatar_url = services.rooms.state_accessor.get_avatar(&room_id);
+	let avatar_url = services.state_accessor.get_avatar(&room_id);
 
 	let topic = services
-		.rooms
 		.state_accessor
 		.get_room_topic(&room_id)
 		.ok();
 
 	let world_readable = services
-		.rooms
 		.state_accessor
 		.is_world_readable(&room_id);
 
 	let join_rule = services
-		.rooms
 		.state_accessor
 		.room_state_get_content(&room_id, &StateEventType::RoomJoinRules, "")
 		.map_ok(|c: RoomJoinRulesEventContent| match c.join_rule {
@@ -452,15 +426,9 @@ async fn public_rooms_chunk(services: &Services, room_id: OwnedRoomId) -> Public
 			| _ => "invite".into(),
 		});
 
-	let guest_can_join = services
-		.rooms
-		.state_accessor
-		.guest_can_join(&room_id);
+	let guest_can_join = services.state_accessor.guest_can_join(&room_id);
 
-	let num_joined_members = services
-		.rooms
-		.state_cache
-		.room_joined_count(&room_id);
+	let num_joined_members = services.state_cache.room_joined_count(&room_id);
 
 	let (
 		(avatar_url, canonical_alias, guest_can_join, join_rule, name),

src/api/client/keys.rs

@@ -394,7 +394,6 @@ pub(crate) async fn get_key_changes_route(
 	);
 
 	let mut rooms_joined = services
-		.rooms
 		.state_cache
 		.rooms_joined(sender_user)
 		.boxed();

src/api/client/membership/ban.rs

@@ -20,22 +20,15 @@ pub(crate) async fn ban_user_route(
 		return Err!(Request(Forbidden("You cannot ban yourself.")));
 	}
 
-	let state_lock = services
-		.rooms
-		.state
-		.mutex
-		.lock(&body.room_id)
-		.await;
+	let state_lock = services.state.mutex.lock(&body.room_id).await;
 
 	let current_member_content = services
-		.rooms
 		.state_accessor
 		.get_member(&body.room_id, &body.user_id)
 		.await
 		.unwrap_or_else(|_| RoomMemberEventContent::new(MembershipState::Ban));
 
 	services
-		.rooms
 		.timeline
 		.build_and_append_pdu(
 			PduBuilder::state(body.user_id.to_string(), &RoomMemberEventContent {

src/api/client/membership/forget.rs

@@ -21,18 +21,9 @@ pub(crate) async fn forget_room_route(
 	let user_id = body.sender_user();
 	let room_id = &body.room_id;
 
-	let joined = services
-		.rooms
-		.state_cache
-		.is_joined(user_id, room_id);
-	let knocked = services
-		.rooms
-		.state_cache
-		.is_knocked(user_id, room_id);
-	let invited = services
-		.rooms
-		.state_cache
-		.is_invited(user_id, room_id);
+	let joined = services.state_cache.is_joined(user_id, room_id);
+	let knocked = services.state_cache.is_knocked(user_id, room_id);
+	let invited = services.state_cache.is_invited(user_id, room_id);
 
 	pin_mut!(joined, knocked, invited);
 	if joined.or(knocked).or(invited).await {
@@ -40,7 +31,6 @@ pub(crate) async fn forget_room_route(
 	}
 
 	let membership = services
-		.rooms
 		.state_accessor
 		.get_member(room_id, user_id)
 		.await;
@@ -55,15 +45,11 @@ pub(crate) async fn forget_room_route(
 
 	if non_membership
 		|| services
-			.rooms
 			.state_cache
 			.is_left(user_id, room_id)
 			.await
 	{
-		services
-			.rooms
-			.state_cache
-			.forget(room_id, user_id);
+		services.state_cache.forget(room_id, user_id);
 	}
 
 	Ok(forget_room::v3::Response::new())

src/api/client/membership/invite.rs

@@ -61,7 +61,6 @@ pub(crate) async fn invite_user_route(
 			}
 
 			if let Ok(target_user_membership) = services
-				.rooms
 				.state_accessor
 				.get_member(&body.room_id, user_id)
 				.await
@@ -111,7 +110,7 @@ pub(crate) async fn invite_helper(
 
 	if !services.globals.user_is_local(user_id) {
 		let (pdu, pdu_json, invite_room_state) = {
-			let state_lock = services.rooms.state.mutex.lock(room_id).await;
+			let state_lock = services.state.mutex.lock(room_id).await;
 
 			let content = RoomMemberEventContent {
 				avatar_url: services.users.avatar_url(user_id).await.ok(),
@@ -121,7 +120,6 @@ pub(crate) async fn invite_helper(
 			};
 
 			let (pdu, pdu_json) = services
-				.rooms
 				.timeline
 				.create_hash_and_sign_event(
 					PduBuilder::state(user_id.to_string(), &content),
@@ -131,18 +129,14 @@ pub(crate) async fn invite_helper(
 				)
 				.await?;
 
-			let invite_room_state = services.rooms.state.summary_stripped(&pdu).await;
+			let invite_room_state = services.state.summary_stripped(&pdu).await;
 
 			drop(state_lock);
 
 			(pdu, pdu_json, invite_room_state)
 		};
 
-		let room_version_id = services
-			.rooms
-			.state
-			.get_room_version(room_id)
-			.await?;
+		let room_version_id = services.state.get_room_version(room_id).await?;
 
 		let response = services
 			.sending
@@ -159,7 +153,6 @@ pub(crate) async fn invite_helper(
 					.map(Into::into)
 					.collect(),
 				via: services
-					.rooms
 					.state_cache
 					.servers_route_via(room_id)
 					.await
@@ -192,7 +185,6 @@ pub(crate) async fn invite_helper(
 		})?;
 
 		let pdu_id = services
-			.rooms
 			.event_handler
 			.handle_incoming_pdu(&origin, room_id, &event_id, value, true)
 			.boxed()
@@ -208,7 +200,6 @@ pub(crate) async fn invite_helper(
 	}
 
 	if !services
-		.rooms
 		.state_cache
 		.is_joined(sender_user, room_id)
 		.await
@@ -218,7 +209,7 @@ pub(crate) async fn invite_helper(
 		)));
 	}
 
-	let state_lock = services.rooms.state.mutex.lock(room_id).await;
+	let state_lock = services.state.mutex.lock(room_id).await;
 
 	let content = RoomMemberEventContent {
 		displayname: services.users.displayname(user_id).await.ok(),
@@ -230,7 +221,6 @@ pub(crate) async fn invite_helper(
 	};
 
 	services
-		.rooms
 		.timeline
 		.build_and_append_pdu(
 			PduBuilder::state(user_id.to_string(), &content),

src/api/client/membership/join.rs

@@ -76,7 +76,6 @@ pub(crate) async fn join_room_by_id_route(
 
 	// There is no body.server_name for /roomId/join
 	let mut servers: Vec<_> = services
-		.rooms
 		.state_cache
 		.servers_invite_via(&body.room_id)
 		.map(ToOwned::to_owned)
@@ -85,7 +84,6 @@ pub(crate) async fn join_room_by_id_route(
 
 	servers.extend(
 		services
-			.rooms
 			.state_cache
 			.invite_state(sender_user, &body.room_id)
 			.await
@@ -151,7 +149,6 @@ pub(crate) async fn join_room_by_id_or_alias_route(
 			let mut servers = body.via.clone();
 			servers.extend(
 				services
-					.rooms
 					.state_cache
 					.servers_invite_via(&room_id)
 					.map(ToOwned::to_owned)
@@ -161,7 +158,6 @@ pub(crate) async fn join_room_by_id_or_alias_route(
 
 			servers.extend(
 				services
-					.rooms
 					.state_cache
 					.invite_state(sender_user, &room_id)
 					.await
@@ -184,7 +180,6 @@ pub(crate) async fn join_room_by_id_or_alias_route(
 		},
 		| Err(room_alias) => {
 			let (room_id, mut servers) = services
-				.rooms
 				.alias
 				.resolve_alias(&room_alias, Some(body.via.clone()))
 				.await?;
@@ -199,13 +194,11 @@ pub(crate) async fn join_room_by_id_or_alias_route(
 			.await?;
 
 			let addl_via_servers = services
-				.rooms
 				.state_cache
 				.servers_invite_via(&room_id)
 				.map(ToOwned::to_owned);
 
 			let addl_state_servers = services
-				.rooms
 				.state_cache
 				.invite_state(sender_user, &room_id)
 				.await
@@ -254,7 +247,7 @@ pub async fn join_room_by_id_helper(
 	third_party_signed: Option<&ThirdPartySigned>,
 	appservice_info: &Option<RegistrationInfo>,
 ) -> Result<join_room_by_id::v3::Response> {
-	let state_lock = services.rooms.state.mutex.lock(room_id).await;
+	let state_lock = services.state.mutex.lock(room_id).await;
 
 	let user_is_guest = services
 		.users
@@ -265,7 +258,6 @@ pub async fn join_room_by_id_helper(
 
 	if user_is_guest
 		&& !services
-			.rooms
 			.state_accessor
 			.guest_can_join(room_id)
 			.await
@@ -274,7 +266,6 @@ pub async fn join_room_by_id_helper(
 	}
 
 	if services
-		.rooms
 		.state_cache
 		.is_joined(sender_user, room_id)
 		.await
@@ -284,7 +275,6 @@ pub async fn join_room_by_id_helper(
 	}
 
 	if let Ok(membership) = services
-		.rooms
 		.state_accessor
 		.get_member(room_id, sender_user)
 		.await
@@ -296,7 +286,6 @@ pub async fn join_room_by_id_helper(
 	}
 
 	let server_in_room = services
-		.rooms
 		.state_cache
 		.server_in_room(services.globals.server_name(), room_id)
 		.await;
@@ -518,7 +507,6 @@ async fn join_room_by_id_helper_remote(
 	}
 
 	services
-		.rooms
 		.short
 		.get_or_create_shortroomid(room_id)
 		.await;
@@ -565,13 +553,11 @@ async fn join_room_by_id_helper_remote(
 			};
 
 			services
-				.rooms
 				.timeline
 				.add_pdu_outlier(&event_id, &value);
 
 			if let Some(state_key) = &pdu.state_key {
 				let shortstatekey = services
-					.rooms
 					.short
 					.get_or_create_shortstatekey(&pdu.kind.to_string().into(), state_key)
 					.await;
@@ -600,7 +586,6 @@ async fn join_room_by_id_helper_remote(
 		.ready_filter_map(Result::ok)
 		.ready_for_each(|(event_id, value)| {
 			services
-				.rooms
 				.timeline
 				.add_pdu_outlier(&event_id, &value);
 		})
@@ -612,10 +597,9 @@ async fn join_room_by_id_helper_remote(
 	state_res::auth_check(
 		&room_version::rules(&room_version_id)?,
 		&parsed_join_pdu,
-		&async |event_id| services.rooms.timeline.get_pdu(&event_id).await,
+		&async |event_id| services.timeline.get_pdu(&event_id).await,
 		&async |event_type, state_key| {
 			let shortstatekey = services
-				.rooms
 				.short
 				.get_shortstatekey(&event_type, state_key.as_str())
 				.await?;
@@ -624,7 +608,7 @@ async fn join_room_by_id_helper_remote(
 				err!(Request(NotFound("Missing fetch_state {shortstatekey:?}")))
 			})?;
 
-			services.rooms.timeline.get_pdu(event_id).await
+			services.timeline.get_pdu(event_id).await
 		},
 	)
 	.boxed()
@@ -632,7 +616,6 @@ async fn join_room_by_id_helper_remote(
 
 	info!("Compressing state from send_join");
 	let compressed: CompressedState = services
-		.rooms
 		.state_compressor
 		.compress_state_events(state.iter().map(|(ssk, eid)| (ssk, eid.borrow())))
 		.collect()
@@ -644,21 +627,18 @@ async fn join_room_by_id_helper_remote(
 		added,
 		removed,
 	} = services
-		.rooms
 		.state_compressor
 		.save_state(room_id, Arc::new(compressed))
 		.await?;
 
 	debug!("Forcing state for new room");
 	services
-		.rooms
 		.state
 		.force_state(room_id, statehash_before_join, added, removed, &state_lock)
 		.await?;
 
 	info!("Updating joined counts for new room");
 	services
-		.rooms
 		.state_cache
 		.update_joined_count(room_id)
 		.await;
@@ -667,14 +647,12 @@ async fn join_room_by_id_helper_remote(
 	// time with the pdu without it's state. This is okay because append_pdu can't
 	// fail.
 	let statehash_after_join = services
-		.rooms
 		.state
 		.append_to_state(&parsed_join_pdu)
 		.await?;
 
 	info!("Appending new room join event");
 	services
-		.rooms
 		.timeline
 		.append_pdu(
 			&parsed_join_pdu,
@@ -688,7 +666,6 @@ async fn join_room_by_id_helper_remote(
 	// We set the room state after inserting the pdu, so that we never have a moment
 	// in time where events in the current room state do not exist
 	services
-		.rooms
 		.state
 		.set_room_state(room_id, statehash_after_join, &state_lock);
 
@@ -708,7 +685,6 @@ async fn join_room_by_id_helper_local(
 	debug_info!("We can join locally");
 
 	let join_rules_event_content = services
-		.rooms
 		.state_accessor
 		.room_state_get_content::<RoomJoinRulesEventContent>(
 			room_id,
@@ -737,18 +713,16 @@ async fn join_room_by_id_helper_local(
 			.stream()
 			.any(|restriction_room_id| {
 				services
-					.rooms
 					.state_cache
 					.is_joined(sender_user, restriction_room_id)
 			})
 			.await
 		{
 			let users = services
-				.rooms
 				.state_cache
 				.local_users_in_room(room_id)
 				.filter(|user| {
-					services.rooms.state_accessor.user_can_invite(
+					services.state_accessor.user_can_invite(
 						room_id,
 						user,
 						sender_user,
@@ -775,7 +749,6 @@ async fn join_room_by_id_helper_local(
 
 	// Try normal join first
 	let Err(error) = services
-		.rooms
 		.timeline
 		.build_and_append_pdu(
 			PduBuilder::state(sender_user.to_string(), &content),
@@ -912,7 +885,6 @@ async fn join_room_by_id_helper_local(
 
 		drop(state_lock);
 		services
-			.rooms
 			.event_handler
 			.handle_incoming_pdu(&remote_server, room_id, &signed_event_id, signed_value, true)
 			.boxed()

src/api/client/membership/kick.rs

@@ -14,15 +14,9 @@ pub(crate) async fn kick_user_route(
 	State(services): State<crate::State>,
 	body: Ruma<kick_user::v3::Request>,
 ) -> Result<kick_user::v3::Response> {
-	let state_lock = services
-		.rooms
-		.state
-		.mutex
-		.lock(&body.room_id)
-		.await;
+	let state_lock = services.state.mutex.lock(&body.room_id).await;
 
 	let Ok(event) = services
-		.rooms
 		.state_accessor
 		.get_member(&body.room_id, &body.user_id)
 		.await
@@ -43,7 +37,6 @@ pub(crate) async fn kick_user_route(
 	}
 
 	services
-		.rooms
 		.timeline
 		.build_and_append_pdu(
 			PduBuilder::state(body.user_id.to_string(), &RoomMemberEventContent {

src/api/client/membership/knock.rs

@@ -67,7 +67,6 @@ pub(crate) async fn knock_room_route(
 			let mut servers = body.via.clone();
 			servers.extend(
 				services
-					.rooms
 					.state_cache
 					.servers_invite_via(&room_id)
 					.map(ToOwned::to_owned)
@@ -77,7 +76,6 @@ pub(crate) async fn knock_room_route(
 
 			servers.extend(
 				services
-					.rooms
 					.state_cache
 					.invite_state(sender_user, &room_id)
 					.await
@@ -100,7 +98,6 @@ pub(crate) async fn knock_room_route(
 		},
 		| Err(room_alias) => {
 			let (room_id, mut servers) = services
-				.rooms
 				.alias
 				.resolve_alias(&room_alias, Some(body.via.clone()))
 				.await?;
@@ -115,13 +112,11 @@ pub(crate) async fn knock_room_route(
 			.await?;
 
 			let addl_via_servers = services
-				.rooms
 				.state_cache
 				.servers_invite_via(&room_id)
 				.map(ToOwned::to_owned);
 
 			let addl_state_servers = services
-				.rooms
 				.state_cache
 				.invite_state(sender_user, &room_id)
 				.await
@@ -158,10 +153,9 @@ async fn knock_room_by_id_helper(
 	reason: Option<String>,
 	servers: &[OwnedServerName],
 ) -> Result<knock_room::v3::Response> {
-	let state_lock = services.rooms.state.mutex.lock(room_id).await;
+	let state_lock = services.state.mutex.lock(room_id).await;
 
 	if services
-		.rooms
 		.state_cache
 		.is_invited(sender_user, room_id)
 		.await
@@ -173,7 +167,6 @@ async fn knock_room_by_id_helper(
 	}
 
 	if services
-		.rooms
 		.state_cache
 		.is_joined(sender_user, room_id)
 		.await
@@ -183,7 +176,6 @@ async fn knock_room_by_id_helper(
 	}
 
 	if services
-		.rooms
 		.state_cache
 		.is_knocked(sender_user, room_id)
 		.await
@@ -193,7 +185,6 @@ async fn knock_room_by_id_helper(
 	}
 
 	if let Ok(membership) = services
-		.rooms
 		.state_accessor
 		.get_member(room_id, sender_user)
 		.await
@@ -205,7 +196,6 @@ async fn knock_room_by_id_helper(
 	}
 
 	let server_in_room = services
-		.rooms
 		.state_cache
 		.server_in_room(services.globals.server_name(), room_id)
 		.await;
@@ -237,11 +227,7 @@ async fn knock_room_helper_local(
 ) -> Result {
 	debug_info!("We can knock locally");
 
-	let room_version_id = services
-		.rooms
-		.state
-		.get_room_version(room_id)
-		.await?;
+	let room_version_id = services.state.get_room_version(room_id).await?;
 
 	if matches!(
 		room_version_id,
@@ -265,7 +251,6 @@ async fn knock_room_helper_local(
 
 	// Try normal knock first
 	let Err(error) = services
-		.rooms
 		.timeline
 		.build_and_append_pdu(
 			PduBuilder::state(sender_user.to_string(), &content),
@@ -366,7 +351,6 @@ async fn knock_room_helper_local(
 	info!("send_knock finished");
 
 	services
-		.rooms
 		.short
 		.get_or_create_shortroomid(room_id)
 		.await;
@@ -378,7 +362,6 @@ async fn knock_room_helper_local(
 
 	info!("Updating membership locally to knock state with provided stripped state events");
 	services
-		.rooms
 		.state_cache
 		.update_membership(
 			room_id,
@@ -401,7 +384,6 @@ async fn knock_room_helper_local(
 
 	info!("Appending room knock event locally");
 	services
-		.rooms
 		.timeline
 		.append_pdu(
 			&parsed_knock_pdu,
@@ -503,7 +485,6 @@ async fn knock_room_helper_remote(
 	info!("send_knock finished");
 
 	services
-		.rooms
 		.short
 		.get_or_create_shortroomid(room_id)
 		.await;
@@ -550,13 +531,11 @@ async fn knock_room_helper_remote(
 
 		let event_id = gen_event_id(&event, &room_version_id)?;
 		let shortstatekey = services
-			.rooms
 			.short
 			.get_or_create_shortstatekey(&event_type, &state_key)
 			.await;
 
 		services
-			.rooms
 			.timeline
 			.add_pdu_outlier(&event_id, &event);
 
@@ -565,7 +544,6 @@ async fn knock_room_helper_remote(
 
 	info!("Compressing state from send_knock");
 	let compressed: CompressedState = services
-		.rooms
 		.state_compressor
 		.compress_state_events(
 			state_map
@@ -581,27 +559,23 @@ async fn knock_room_helper_remote(
 		added,
 		removed,
 	} = services
-		.rooms
 		.state_compressor
 		.save_state(room_id, Arc::new(compressed))
 		.await?;
 
 	debug!("Forcing state for new room");
 	services
-		.rooms
 		.state
 		.force_state(room_id, statehash_before_knock, added, removed, &state_lock)
 		.await?;
 
 	let statehash_after_knock = services
-		.rooms
 		.state
 		.append_to_state(&parsed_knock_pdu)
 		.await?;
 
 	info!("Updating membership locally to knock state with provided stripped state events");
 	services
-		.rooms
 		.state_cache
 		.update_membership(
 			room_id,
@@ -624,7 +598,6 @@ async fn knock_room_helper_remote(
 
 	info!("Appending room knock event locally");
 	services
-		.rooms
 		.timeline
 		.append_pdu(
 			&parsed_knock_pdu,
@@ -638,7 +611,6 @@ async fn knock_room_helper_remote(
 	// We set the room state after inserting the pdu, so that we never have a moment
 	// in time where events in the current room state do not exist
 	services
-		.rooms
 		.state
 		.set_room_state(room_id, statehash_after_knock, &state_lock);
 

src/api/client/membership/leave.rs

@@ -42,19 +42,16 @@ pub(crate) async fn leave_room_route(
 // and ignores errors
 pub async fn leave_all_rooms(services: &Services, user_id: &UserId) {
 	let rooms_joined = services
-		.rooms
 		.state_cache
 		.rooms_joined(user_id)
 		.map(ToOwned::to_owned);
 
 	let rooms_invited = services
-		.rooms
 		.state_cache
 		.rooms_invited(user_id)
 		.map(|(r, _)| r);
 
 	let rooms_knocked = services
-		.rooms
 		.state_cache
 		.rooms_knocked(user_id)
 		.map(|(r, _)| r);
@@ -74,10 +71,7 @@ pub async fn leave_all_rooms(services: &Services, user_id: &UserId) {
 			warn!(%user_id, "Failed to leave {room_id} remotely: {e}");
 		}
 
-		services
-			.rooms
-			.state_cache
-			.forget(&room_id, user_id);
+		services.state_cache.forget(&room_id, user_id);
 	}
 }
 
@@ -98,15 +92,14 @@ pub async fn leave_room(
 		blurhash: None,
 	};
 
-	let is_banned = services.rooms.metadata.is_banned(room_id);
-	let is_disabled = services.rooms.metadata.is_disabled(room_id);
+	let is_banned = services.metadata.is_banned(room_id);
+	let is_disabled = services.metadata.is_disabled(room_id);
 
 	pin_mut!(is_banned, is_disabled);
 	if is_banned.or(is_disabled).await {
 		// the room is banned/disabled, the room must be rejected locally since we
 		// cant/dont want to federate with this server
 		services
-			.rooms
 			.state_cache
 			.update_membership(
 				room_id,
@@ -123,13 +116,11 @@ pub async fn leave_room(
 	}
 
 	let dont_have_room = services
-		.rooms
 		.state_cache
 		.server_in_room(services.globals.server_name(), room_id)
 		.eq(&false);
 
 	let not_knocked = services
-		.rooms
 		.state_cache
 		.is_knocked(user_id, room_id)
 		.eq(&false);
@@ -145,27 +136,15 @@ pub async fn leave_room(
 		}
 
 		let last_state = services
-			.rooms
 			.state_cache
 			.invite_state(user_id, room_id)
-			.or_else(|_| {
-				services
-					.rooms
-					.state_cache
-					.knock_state(user_id, room_id)
-			})
-			.or_else(|_| {
-				services
-					.rooms
-					.state_cache
-					.left_state(user_id, room_id)
-			})
+			.or_else(|_| services.state_cache.knock_state(user_id, room_id))
+			.or_else(|_| services.state_cache.left_state(user_id, room_id))
 			.await
 			.ok();
 
 		// We always drop the invite, we can't rely on other servers
 		services
-			.rooms
 			.state_cache
 			.update_membership(
 				room_id,
@@ -178,10 +157,9 @@ pub async fn leave_room(
 			)
 			.await?;
 	} else {
-		let state_lock = services.rooms.state.mutex.lock(room_id).await;
+		let state_lock = services.state.mutex.lock(room_id).await;
 
 		let Ok(event) = services
-			.rooms
 			.state_accessor
 			.room_state_get_content::<RoomMemberEventContent>(
 				room_id,
@@ -195,7 +173,6 @@ pub async fn leave_room(
 			);
 
 			return services
-				.rooms
 				.state_cache
 				.update_membership(
 					room_id,
@@ -210,7 +187,6 @@ pub async fn leave_room(
 		};
 
 		services
-			.rooms
 			.timeline
 			.build_and_append_pdu(
 				PduBuilder::state(user_id.to_string(), &RoomMemberEventContent {
@@ -235,7 +211,6 @@ async fn remote_leave_room(services: &Services, user_id: &UserId, room_id: &Room
 		Err!(BadServerResponse("No remote server available to assist in leaving {room_id}."));
 
 	let mut servers: HashSet<OwnedServerName> = services
-		.rooms
 		.state_cache
 		.servers_invite_via(room_id)
 		.map(ToOwned::to_owned)
@@ -243,7 +218,6 @@ async fn remote_leave_room(services: &Services, user_id: &UserId, room_id: &Room
 		.await;
 
 	match services
-		.rooms
 		.state_cache
 		.invite_state(user_id, room_id)
 		.await
@@ -259,7 +233,6 @@ async fn remote_leave_room(services: &Services, user_id: &UserId, room_id: &Room
 		},
 		| _ => {
 			match services
-				.rooms
 				.state_cache
 				.knock_state(user_id, room_id)
 				.await

src/api/client/membership/members.rs

@@ -25,7 +25,6 @@ pub(crate) async fn get_member_events_route(
 	body: Ruma<get_member_events::v3::Request>,
 ) -> Result<get_member_events::v3::Response> {
 	if !services
-		.rooms
 		.state_accessor
 		.user_can_see_state_events(body.sender_user(), &body.room_id)
 		.await
@@ -37,7 +36,6 @@ pub(crate) async fn get_member_events_route(
 	let not_membership = body.not_membership.as_ref();
 	Ok(get_member_events::v3::Response {
 		chunk: services
-			.rooms
 			.state_accessor
 			.room_state_full(&body.room_id)
 			.ready_filter_map(Result::ok)
@@ -62,7 +60,6 @@ pub(crate) async fn joined_members_route(
 	body: Ruma<joined_members::v3::Request>,
 ) -> Result<joined_members::v3::Response> {
 	if !services
-		.rooms
 		.state_accessor
 		.user_can_see_state_events(body.sender_user(), &body.room_id)
 		.await
@@ -72,7 +69,6 @@ pub(crate) async fn joined_members_route(
 
 	Ok(joined_members::v3::Response {
 		joined: services
-			.rooms
 			.state_accessor
 			.room_state_full(&body.room_id)
 			.ready_filter_map(Result::ok)

src/api/client/membership/mod.rs

@@ -42,7 +42,6 @@ pub(crate) async fn joined_rooms_route(
 ) -> Result<joined_rooms::v3::Response> {
 	Ok(joined_rooms::v3::Response {
 		joined_rooms: services
-			.rooms
 			.state_cache
 			.rooms_joined(body.sender_user())
 			.map(ToOwned::to_owned)
@@ -69,7 +68,7 @@ pub(crate) async fn banned_room_check(
 	}
 
 	if let Some(room_id) = room_id {
-		if services.rooms.metadata.is_banned(room_id).await
+		if services.metadata.is_banned(room_id).await
 			|| (room_id.server_name().is_some()
 				&& services
 					.config
@@ -105,7 +104,6 @@ pub(crate) async fn banned_room_check(
 				}
 
 				let all_joined_rooms: Vec<OwnedRoomId> = services
-					.rooms
 					.state_cache
 					.rooms_joined(user_id)
 					.map(Into::into)
@@ -150,7 +148,6 @@ pub(crate) async fn banned_room_check(
 				}
 
 				let all_joined_rooms: Vec<OwnedRoomId> = services
-					.rooms
 					.state_cache
 					.rooms_joined(user_id)
 					.map(Into::into)

src/api/client/membership/unban.rs

@@ -14,15 +14,9 @@ pub(crate) async fn unban_user_route(
 	State(services): State<crate::State>,
 	body: Ruma<unban_user::v3::Request>,
 ) -> Result<unban_user::v3::Response> {
-	let state_lock = services
-		.rooms
-		.state
-		.mutex
-		.lock(&body.room_id)
-		.await;
+	let state_lock = services.state.mutex.lock(&body.room_id).await;
 
 	let current_member_content = services
-		.rooms
 		.state_accessor
 		.get_member(&body.room_id, &body.user_id)
 		.await
@@ -36,7 +30,6 @@ pub(crate) async fn unban_user_route(
 	}
 
 	services
-		.rooms
 		.timeline
 		.build_and_append_pdu(
 			PduBuilder::state(body.user_id.to_string(), &RoomMemberEventContent {

src/api/client/message.rs

@@ -73,7 +73,7 @@ pub(crate) async fn get_message_events_route(
 	let room_id = &body.room_id;
 	let filter = &body.filter;
 
-	if !services.rooms.metadata.exists(room_id).await {
+	if !services.metadata.exists(room_id).await {
 		return Err!(Request(Forbidden("Room does not exist to this server")));
 	}
 
@@ -97,7 +97,6 @@ pub(crate) async fn get_message_events_route(
 
 	if matches!(body.dir, Direction::Backward) {
 		services
-			.rooms
 			.timeline
 			.backfill_if_required(room_id, from)
 			.await
@@ -107,14 +106,12 @@ pub(crate) async fn get_message_events_route(
 
 	let it = match body.dir {
 		| Direction::Forward => services
-			.rooms
 			.timeline
 			.pdus(Some(sender_user), room_id, Some(from))
 			.ignore_err()
 			.boxed(),
 
 		| Direction::Backward => services
-			.rooms
 			.timeline
 			.pdus_rev(Some(sender_user), room_id, Some(from))
 			.ignore_err()
@@ -192,7 +189,7 @@ where
 		.max()
 		.unwrap_or_else(PduCount::max);
 
-	let receipts = services.rooms.read_receipt.readreceipts_since(
+	let receipts = services.read_receipt.readreceipts_since(
 		lazy_loading_context.room_id,
 		oldest.into_unsigned(),
 		Some(newest.into_unsigned()),
@@ -213,7 +210,6 @@ where
 		.await;
 
 	services
-		.rooms
 		.lazy_loading
 		.witness_retain(witness, lazy_loading_context)
 		.await
@@ -225,7 +221,6 @@ async fn get_member_event(
 	user_id: &UserId,
 ) -> Option<Raw<AnyStateEvent>> {
 	services
-		.rooms
 		.state_accessor
 		.room_state_get(room_id, &StateEventType::RoomMember, user_id.as_str())
 		.map_ok(Event::into_format)
@@ -293,7 +288,6 @@ pub(crate) async fn visibility_filter(
 	let (_, pdu) = &item;
 
 	services
-		.rooms
 		.state_accessor
 		.user_can_see_event(user_id, pdu.room_id(), pdu.event_id())
 		.await

src/api/client/presence.rs

@@ -44,7 +44,6 @@ pub(crate) async fn get_presence_route(
 
 	let mut presence_event = None;
 	let has_shared_rooms = services
-		.rooms
 		.state_cache
 		.user_sees_user(body.sender_user(), &body.user_id)
 		.await;

src/api/client/profile.rs

@@ -42,7 +42,6 @@ pub(crate) async fn set_displayname_route(
 	}
 
 	let all_joined_rooms: Vec<OwnedRoomId> = services
-		.rooms
 		.state_cache
 		.rooms_joined(&body.user_id)
 		.map(ToOwned::to_owned)
@@ -138,7 +137,6 @@ pub(crate) async fn set_avatar_url_route(
 	}
 
 	let all_joined_rooms: Vec<OwnedRoomId> = services
-		.rooms
 		.state_cache
 		.rooms_joined(&body.user_id)
 		.map(ToOwned::to_owned)
@@ -448,9 +446,8 @@ async fn update_all_rooms(
 	user_id: &UserId,
 ) {
 	for (pdu_builder, room_id) in all_joined_rooms {
-		let state_lock = services.rooms.state.mutex.lock(room_id).await;
+		let state_lock = services.state.mutex.lock(room_id).await;
 		if let Err(e) = services
-			.rooms
 			.timeline
 			.build_and_append_pdu(pdu_builder, user_id, room_id, &state_lock)
 			.await

src/api/client/read_marker.rs

@@ -44,7 +44,6 @@ pub(crate) async fn set_read_marker_route(
 
 	if body.private_read_receipt.is_some() || body.read_receipt.is_some() {
 		services
-			.rooms
 			.user
 			.reset_notification_counts(sender_user, &body.room_id);
 	}
@@ -70,7 +69,6 @@ pub(crate) async fn set_read_marker_route(
 		)]);
 
 		services
-			.rooms
 			.read_receipt
 			.readreceipt_update(
 				sender_user,
@@ -85,7 +83,6 @@ pub(crate) async fn set_read_marker_route(
 
 	if let Some(event) = &body.private_read_receipt {
 		let count = services
-			.rooms
 			.timeline
 			.get_pdu_count(event)
 			.await
@@ -98,7 +95,6 @@ pub(crate) async fn set_read_marker_route(
 		};
 
 		services
-			.rooms
 			.read_receipt
 			.private_read_set(&body.room_id, sender_user, count);
 	}
@@ -120,7 +116,6 @@ pub(crate) async fn create_receipt_route(
 		create_receipt::v3::ReceiptType::Read | create_receipt::v3::ReceiptType::ReadPrivate
 	) {
 		services
-			.rooms
 			.user
 			.reset_notification_counts(sender_user, &body.room_id);
 	}
@@ -166,7 +161,6 @@ pub(crate) async fn create_receipt_route(
 			)]);
 
 			services
-				.rooms
 				.read_receipt
 				.readreceipt_update(
 					sender_user,
@@ -180,7 +174,6 @@ pub(crate) async fn create_receipt_route(
 		},
 		| create_receipt::v3::ReceiptType::ReadPrivate => {
 			let count = services
-				.rooms
 				.timeline
 				.get_pdu_count(&body.event_id)
 				.await
@@ -193,7 +186,6 @@ pub(crate) async fn create_receipt_route(
 			};
 
 			services
-				.rooms
 				.read_receipt
 				.private_read_set(&body.room_id, sender_user, count);
 		},

src/api/client/redact.rs

@@ -18,15 +18,9 @@ pub(crate) async fn redact_event_route(
 	let sender_user = body.sender_user();
 	let body = &body.body;
 
-	let state_lock = services
-		.rooms
-		.state
-		.mutex
-		.lock(&body.room_id)
-		.await;
+	let state_lock = services.state.mutex.lock(&body.room_id).await;
 
 	let event_id = services
-		.rooms
 		.timeline
 		.build_and_append_pdu(
 			PduBuilder {

src/api/client/register.rs

@@ -517,7 +517,6 @@ pub(crate) async fn register_route(
 		&& services.config.grant_admin_to_first_user
 		&& let Ok(admin_room) = services.admin.get_admin_room().await
 		&& services
-			.rooms
 			.state_cache
 			.room_joined_count(&admin_room)
 			.await
@@ -536,7 +535,7 @@ pub(crate) async fn register_route(
 		&& (services.config.allow_guests_auto_join_rooms || !is_guest)
 	{
 		for room in &services.server.config.auto_join_rooms {
-			let Ok(room_id) = services.rooms.alias.resolve(room).await else {
+			let Ok(room_id) = services.alias.resolve(room).await else {
 				error!(
 					"Failed to resolve room alias to room ID when attempting to auto join \
 					 {room}, skipping"
@@ -545,7 +544,6 @@ pub(crate) async fn register_route(
 			};
 
 			if !services
-				.rooms
 				.state_cache
 				.server_in_room(services.globals.server_name(), &room_id)
 				.await

src/api/client/relations.rs

@@ -133,7 +133,6 @@ async fn paginate_relations_with_filter(
 	let depth: u8 = if recurse { 3 } else { 1 };
 
 	let events: Vec<_> = services
-		.rooms
 		.pdu_metadata
 		.get_relations(sender_user, room_id, target, start, limit, depth, dir)
 		.await
@@ -183,7 +182,6 @@ async fn visibility_filter<Pdu: Event>(
 	let (_, pdu) = &item;
 
 	services
-		.rooms
 		.state_accessor
 		.user_can_see_event(sender_user, pdu.room_id(), pdu.event_id())
 		.await

src/api/client/report.rs

@@ -43,7 +43,6 @@ pub(crate) async fn report_room_route(
 	delay_response().await;
 
 	if !services
-		.rooms
 		.state_cache
 		.server_in_room(&services.server.name, &body.room_id)
 		.await
@@ -92,12 +91,7 @@ pub(crate) async fn report_event_route(
 	delay_response().await;
 
 	// check if we know about the reported event ID or if it's invalid
-	let Ok(pdu) = services
-		.rooms
-		.timeline
-		.get_pdu(&body.event_id)
-		.await
-	else {
+	let Ok(pdu) = services.timeline.get_pdu(&body.event_id).await else {
 		return Err!(Request(NotFound("Event ID is not known to us or Event ID is invalid")));
 	};
 
@@ -167,7 +161,6 @@ async fn is_event_report_valid(
 	}
 
 	if !services
-		.rooms
 		.state_cache
 		.room_members(room_id)
 		.ready_any(|user_id| user_id == sender_user)

src/api/client/room/aliases.rs

@@ -18,7 +18,6 @@ pub(crate) async fn get_room_aliases_route(
 	let sender_user = body.sender_user();
 
 	if !services
-		.rooms
 		.state_accessor
 		.user_can_see_state_events(sender_user, &body.room_id)
 		.await
@@ -28,7 +27,6 @@ pub(crate) async fn get_room_aliases_route(
 
 	Ok(aliases::v3::Response {
 		aliases: services
-			.rooms
 			.alias
 			.local_aliases_for_room(&body.room_id)
 			.map(ToOwned::to_owned)

src/api/client/room/create.rs

@@ -114,7 +114,6 @@ pub(crate) async fn create_room_route(
 	// 2. Let the room creator join
 	let sender_user = body.sender_user();
 	services
-		.rooms
 		.timeline
 		.build_and_append_pdu(
 			PduBuilder::state(sender_user.to_string(), &RoomMemberEventContent {
@@ -176,7 +175,6 @@ pub(crate) async fn create_room_route(
 	)?;
 
 	services
-		.rooms
 		.timeline
 		.build_and_append_pdu(
 			PduBuilder {
@@ -195,7 +193,6 @@ pub(crate) async fn create_room_route(
 	// 4. Canonical room alias
 	if let Some(room_alias_id) = &alias {
 		services
-			.rooms
 			.timeline
 			.build_and_append_pdu(
 				PduBuilder::state(String::new(), &RoomCanonicalAliasEventContent {
@@ -214,7 +211,6 @@ pub(crate) async fn create_room_route(
 
 	// 5.1 Join Rules
 	services
-		.rooms
 		.timeline
 		.build_and_append_pdu(
 			PduBuilder::state(
@@ -234,7 +230,6 @@ pub(crate) async fn create_room_route(
 
 	// 5.2 History Visibility
 	services
-		.rooms
 		.timeline
 		.build_and_append_pdu(
 			PduBuilder::state(
@@ -250,7 +245,6 @@ pub(crate) async fn create_room_route(
 
 	// 5.3 Guest Access
 	services
-		.rooms
 		.timeline
 		.build_and_append_pdu(
 			PduBuilder::state(
@@ -299,7 +293,6 @@ pub(crate) async fn create_room_route(
 		}
 
 		services
-			.rooms
 			.timeline
 			.build_and_append_pdu(pdu_builder, sender_user, &room_id, &state_lock)
 			.boxed()
@@ -309,7 +302,6 @@ pub(crate) async fn create_room_route(
 	// 7. Events implied by name and topic
 	if let Some(name) = &body.name {
 		services
-			.rooms
 			.timeline
 			.build_and_append_pdu(
 				PduBuilder::state(String::new(), &RoomNameEventContent::new(name.clone())),
@@ -323,7 +315,6 @@ pub(crate) async fn create_room_route(
 
 	if let Some(topic) = &body.topic {
 		services
-			.rooms
 			.timeline
 			.build_and_append_pdu(
 				PduBuilder::state(String::new(), &RoomTopicEventContent {
@@ -371,13 +362,12 @@ pub(crate) async fn create_room_route(
 	// Homeserver specific stuff
 	if let Some(alias) = alias {
 		services
-			.rooms
 			.alias
 			.set_alias(&alias, &room_id, sender_user)?;
 	}
 
 	if body.visibility == room::Visibility::Public {
-		services.rooms.directory.set_public(&room_id);
+		services.directory.set_public(&room_id);
 
 		if services.server.config.admin_room_notices {
 			services
@@ -463,9 +453,8 @@ async fn create_create_event(
 
 	// 1. The room create event, using a placeholder room_id
 	let room_id = ruma::room_id!("!thiswillbereplaced").to_owned();
-	let state_lock = services.rooms.state.mutex.lock(&room_id).await;
+	let state_lock = services.state.mutex.lock(&room_id).await;
 	let create_event_id = services
-		.rooms
 		.timeline
 		.build_and_append_pdu(
 			PduBuilder {
@@ -485,7 +474,7 @@ async fn create_create_event(
 
 	// The real room_id is now the event_id.
 	let room_id = OwnedRoomId::from_parts('!', create_event_id.localpart(), None)?;
-	let state_lock = services.rooms.state.mutex.lock(&room_id).await;
+	let state_lock = services.state.mutex.lock(&room_id).await;
 
 	Ok((room_id, state_lock))
 }
@@ -501,10 +490,9 @@ async fn create_create_event_legacy(
 		| Some(custom_id) => custom_room_id_check(services, custom_id).await?,
 	};
 
-	let state_lock = services.rooms.state.mutex.lock(&room_id).await;
+	let state_lock = services.state.mutex.lock(&room_id).await;
 
 	let _short_id = services
-		.rooms
 		.short
 		.get_or_create_shortroomid(&room_id)
 		.await;
@@ -567,7 +555,6 @@ async fn create_create_event_legacy(
 
 	// 1. The room create event
 	services
-		.rooms
 		.timeline
 		.build_and_append_pdu(
 			PduBuilder {
@@ -681,7 +668,6 @@ async fn room_alias_check(
 		})?;
 
 	if services
-		.rooms
 		.alias
 		.resolve_local_alias(&full_room_alias)
 		.await
@@ -740,7 +726,6 @@ async fn custom_room_id_check(services: &Services, custom_room_id: &str) -> Resu
 
 	// check if room ID doesn't already exist instead of erroring on auth check
 	if services
-		.rooms
 		.short
 		.get_shortroomid(&room_id)
 		.await

src/api/client/room/event.rs

@@ -16,13 +16,11 @@ pub(crate) async fn get_room_event_route(
 	let room_id = &body.room_id;
 
 	let event = services
-		.rooms
 		.timeline
 		.get_pdu(event_id)
 		.map_err(|_| err!(Request(NotFound("Event {} not found.", event_id))));
 
 	let visible = services
-		.rooms
 		.state_accessor
 		.user_can_see_event(body.sender_user(), room_id, event_id)
 		.map(Ok);

src/api/client/room/initial_sync.rs

@@ -17,7 +17,6 @@ pub(crate) async fn room_initial_sync_route(
 	let room_id = &body.room_id;
 
 	if !services
-		.rooms
 		.state_accessor
 		.user_can_see_state_events(body.sender_user(), room_id)
 		.await
@@ -26,19 +25,13 @@ pub(crate) async fn room_initial_sync_route(
 	}
 
 	let membership = services
-		.rooms
 		.state_cache
 		.user_membership(body.sender_user(), room_id)
 		.map(Ok);
 
-	let visibility = services
-		.rooms
-		.directory
-		.visibility(room_id)
-		.map(Ok);
+	let visibility = services.directory.visibility(room_id).map(Ok);
 
 	let state = services
-		.rooms
 		.state_accessor
 		.room_state_full_pdus(room_id)
 		.map_ok(Event::into_format)
@@ -46,7 +39,6 @@ pub(crate) async fn room_initial_sync_route(
 
 	let limit = LIMIT_MAX;
 	let events = services
-		.rooms
 		.timeline
 		.pdus_rev(None, room_id, None)
 		.try_take(limit)

src/api/client/room/summary.rs

@@ -54,12 +54,11 @@ pub(crate) async fn get_room_summary(
 	body: Ruma<get_summary::v1::Request>,
 ) -> Result<get_summary::v1::Response> {
 	let (room_id, servers) = services
-		.rooms
 		.alias
 		.resolve_with_servers(&body.room_id_or_alias, Some(body.via.clone()))
 		.await?;
 
-	if services.rooms.metadata.is_banned(&room_id).await {
+	if services.metadata.is_banned(&room_id).await {
 		return Err!(Request(Forbidden("This room is banned on this homeserver.")));
 	}
 
@@ -75,7 +74,6 @@ async fn room_summary_response(
 	sender_user: Option<&UserId>,
 ) -> Result<get_summary::v1::Response> {
 	if services
-		.rooms
 		.state_cache
 		.server_in_room(services.globals.server_name(), room_id)
 		.await
@@ -103,20 +101,11 @@ async fn local_room_summary_response(
 	sender_user: Option<&UserId>,
 ) -> Result<get_summary::v1::Response> {
 	trace!(?sender_user, "Sending local room summary response for {room_id:?}");
-	let join_rule = services
-		.rooms
-		.state_accessor
-		.get_join_rules(room_id);
+	let join_rule = services.state_accessor.get_join_rules(room_id);
 
-	let world_readable = services
-		.rooms
-		.state_accessor
-		.is_world_readable(room_id);
+	let world_readable = services.state_accessor.is_world_readable(room_id);
 
-	let guest_can_join = services
-		.rooms
-		.state_accessor
-		.guest_can_join(room_id);
+	let guest_can_join = services.state_accessor.guest_can_join(room_id);
 
 	let (join_rule, world_readable, guest_can_join) =
 		join3(join_rule, world_readable, guest_can_join).await;
@@ -134,49 +123,35 @@ async fn local_room_summary_response(
 	.await?;
 
 	let canonical_alias = services
-		.rooms
 		.state_accessor
 		.get_canonical_alias(room_id)
 		.ok();
 
-	let name = services
-		.rooms
-		.state_accessor
-		.get_name(room_id)
-		.ok();
+	let name = services.state_accessor.get_name(room_id).ok();
 
 	let topic = services
-		.rooms
 		.state_accessor
 		.get_room_topic(room_id)
 		.ok();
 
 	let room_type = services
-		.rooms
 		.state_accessor
 		.get_room_type(room_id)
 		.ok();
 
 	let avatar_url = services
-		.rooms
 		.state_accessor
 		.get_avatar(room_id)
 		.map(|res| res.into_option().unwrap_or_default().url);
 
-	let room_version = services
-		.rooms
-		.state
-		.get_room_version(room_id)
-		.ok();
+	let room_version = services.state.get_room_version(room_id).ok();
 
 	let encryption = services
-		.rooms
 		.state_accessor
 		.get_room_encryption(room_id)
 		.ok();
 
 	let num_joined_members = services
-		.rooms
 		.state_cache
 		.room_joined_count(room_id)
 		.unwrap_or(0);
@@ -184,7 +159,6 @@ async fn local_room_summary_response(
 	let membership: OptionFuture<_> = sender_user
 		.map(|sender_user| {
 			services
-				.rooms
 				.state_accessor
 				.get_member(room_id, sender_user)
 				.map_ok_or(MembershipState::Leave, |content| content.membership)
@@ -244,7 +218,7 @@ async fn remote_room_summary_hierarchy_response(
 		return Err!(Request(Forbidden("Federation is disabled.")));
 	}
 
-	if services.rooms.metadata.is_disabled(room_id).await {
+	if services.metadata.is_disabled(room_id).await {
 		return Err!(Request(Forbidden(
 			"Federaton of room {room_id} is currently disabled on this server."
 		)));
@@ -313,7 +287,6 @@ where
 	match sender_user {
 		| Some(sender_user) => {
 			let user_can_see_state_events = services
-				.rooms
 				.state_accessor
 				.user_can_see_state_events(sender_user, room_id);
 
@@ -322,12 +295,9 @@ where
 				.is_deactivated(sender_user)
 				.unwrap_or(false);
 
-			let user_in_allowed_restricted_room = allowed_room_ids.stream().any(|room| {
-				services
-					.rooms
-					.state_cache
-					.is_joined(sender_user, room)
-			});
+			let user_in_allowed_restricted_room = allowed_room_ids
+				.stream()
+				.any(|room| services.state_cache.is_joined(sender_user, room));
 
 			let (user_can_see_state_events, is_guest, user_in_allowed_restricted_room) =
 				join3(user_can_see_state_events, is_guest, user_in_allowed_restricted_room)

src/api/client/room/upgrade.rs

@@ -81,23 +81,16 @@ pub(crate) async fn upgrade_room_route(
 	let replacement_room = RoomId::new_v1(services.globals.server_name());
 
 	let _short_id = services
-		.rooms
 		.short
 		.get_or_create_shortroomid(&replacement_room)
 		.await;
 
-	let state_lock = services
-		.rooms
-		.state
-		.mutex
-		.lock(&body.room_id)
-		.await;
+	let state_lock = services.state.mutex.lock(&body.room_id).await;
 
 	// Send a m.room.tombstone event to the old room to indicate that it is not
 	// intended to be used any further Fail if the sender does not have the required
 	// permissions
 	let tombstone_event_id = services
-		.rooms
 		.timeline
 		.build_and_append_pdu(
 			PduBuilder::state(StateKey::new(), &RoomTombstoneEventContent {
@@ -112,16 +105,10 @@ pub(crate) async fn upgrade_room_route(
 
 	// Change lock to replacement room
 	drop(state_lock);
-	let state_lock = services
-		.rooms
-		.state
-		.mutex
-		.lock(&replacement_room)
-		.await;
+	let state_lock = services.state.mutex.lock(&replacement_room).await;
 
 	// Get the old room creation event
 	let mut create_event_content: CanonicalJsonObject = services
-		.rooms
 		.state_accessor
 		.room_state_get_content(&body.room_id, &StateEventType::RoomCreate, "")
 		.await
@@ -174,7 +161,6 @@ pub(crate) async fn upgrade_room_route(
 	}
 
 	services
-		.rooms
 		.timeline
 		.build_and_append_pdu(
 			PduBuilder {
@@ -193,7 +179,6 @@ pub(crate) async fn upgrade_room_route(
 
 	// Join the new room
 	services
-		.rooms
 		.timeline
 		.build_and_append_pdu(
 			PduBuilder {
@@ -222,7 +207,6 @@ pub(crate) async fn upgrade_room_route(
 	// Replicate transferable state events to the new room
 	for event_type in TRANSFERABLE_STATE_EVENTS {
 		let event_content = match services
-			.rooms
 			.state_accessor
 			.room_state_get(&body.room_id, event_type, "")
 			.await
@@ -232,7 +216,6 @@ pub(crate) async fn upgrade_room_route(
 		};
 
 		services
-			.rooms
 			.timeline
 			.build_and_append_pdu(
 				PduBuilder {
@@ -250,27 +233,23 @@ pub(crate) async fn upgrade_room_route(
 
 	// Moves any local aliases to the new room
 	let mut local_aliases = services
-		.rooms
 		.alias
 		.local_aliases_for_room(&body.room_id)
 		.boxed();
 
 	while let Some(alias) = local_aliases.next().await {
 		services
-			.rooms
 			.alias
 			.remove_alias(alias, sender_user)
 			.await?;
 
 		services
-			.rooms
 			.alias
 			.set_alias(alias, &replacement_room, sender_user)?;
 	}
 
 	// Get the old room power levels
 	let power_levels_event_content: RoomPowerLevelsEventContent = services
-		.rooms
 		.state_accessor
 		.room_state_get_content(&body.room_id, &StateEventType::RoomPowerLevels, "")
 		.await
@@ -290,7 +269,6 @@ pub(crate) async fn upgrade_room_route(
 	// Modify the power levels in the old room to prevent sending of events and
 	// inviting new users
 	services
-		.rooms
 		.timeline
 		.build_and_append_pdu(
 			PduBuilder::state(StateKey::new(), &RoomPowerLevelsEventContent {

src/api/client/search.rs

@@ -87,7 +87,6 @@ async fn category_room_events(
 		.map(StreamExt::boxed)
 		.unwrap_or_else(|| {
 			services
-				.rooms
 				.state_cache
 				.rooms_joined(sender_user)
 				.map(ToOwned::to_owned)
@@ -110,12 +109,7 @@ async fn category_room_events(
 				limit,
 			};
 
-			let (count, results) = services
-				.rooms
-				.search
-				.search_pdus(&query)
-				.await
-				.ok()?;
+			let (count, results) = services.search.search_pdus(&query).await.ok()?;
 
 			results
 				.collect::<Vec<_>>()
@@ -187,7 +181,6 @@ async fn category_room_events(
 
 async fn procure_room_state(services: &Services, room_id: &RoomId) -> Result<RoomState> {
 	let state = services
-		.rooms
 		.state_accessor
 		.room_state_full_pdus(room_id)
 		.map_ok(Event::into_format)
@@ -208,14 +201,12 @@ async fn check_room_visible(
 
 	let is_joined = !check_visible
 		|| services
-			.rooms
 			.state_cache
 			.is_joined(user_id, room_id)
 			.await;
 
 	let state_visible = !check_state
 		|| services
-			.rooms
 			.state_accessor
 			.user_can_see_state_events(user_id, room_id)
 			.await;

src/api/client/send.rs

@@ -30,16 +30,10 @@ pub(crate) async fn send_message_event_route(
 		return Err!(Request(Forbidden("Encryption has been disabled")));
 	}
 
-	let state_lock = services
-		.rooms
-		.state
-		.mutex
-		.lock(&body.room_id)
-		.await;
+	let state_lock = services.state.mutex.lock(&body.room_id).await;
 
 	if body.event_type == MessageLikeEventType::CallInvite
 		&& services
-			.rooms
 			.directory
 			.is_public_room(&body.room_id)
 			.await
@@ -75,7 +69,6 @@ pub(crate) async fn send_message_event_route(
 		.map_err(|e| err!(Request(BadJson("Invalid JSON body: {e}"))))?;
 
 	let event_id = services
-		.rooms
 		.timeline
 		.build_and_append_pdu(
 			PduBuilder {

src/api/client/space.rs

@@ -90,7 +90,6 @@ where
 			.collect::<Vec<_>>();
 
 		let summary = services
-			.rooms
 			.spaces
 			.get_summary_and_children_client(room_id, suggested_only, sender_user, &via)
 			.await;
@@ -139,7 +138,6 @@ where
 						.stream()
 						.skip_while(|(room, _)| {
 							services
-								.rooms
 								.short
 								.get_shortroomid(room)
 								.map_ok(|short| {
@@ -172,7 +170,6 @@ where
 					.into_iter()
 					.map(|(room_id, via)| async move {
 						let summary = services
-							.rooms
 							.spaces
 							.get_summary_and_children_client(
 								&room_id,
@@ -199,7 +196,7 @@ where
 			let next_short_room_ids: Vec<_> = parents
 				.iter()
 				.stream()
-				.filter_map(|room_id| services.rooms.short.get_shortroomid(room_id).ok())
+				.filter_map(|room_id| services.short.get_shortroomid(room_id).ok())
 				.collect()
 				.await;
 

src/api/client/state.rs

@@ -78,7 +78,6 @@ pub(crate) async fn get_state_events_route(
 	let sender_user = body.sender_user();
 
 	if !services
-		.rooms
 		.state_accessor
 		.user_can_see_state_events(sender_user, &body.room_id)
 		.await
@@ -88,7 +87,6 @@ pub(crate) async fn get_state_events_route(
 
 	Ok(get_state_events::v3::Response {
 		room_state: services
-			.rooms
 			.state_accessor
 			.room_state_full_pdus(&body.room_id)
 			.map_ok(Event::into_format)
@@ -112,7 +110,6 @@ pub(crate) async fn get_state_events_for_key_route(
 	let sender_user = body.sender_user();
 
 	if !services
-		.rooms
 		.state_accessor
 		.user_can_see_state_events(sender_user, &body.room_id)
 		.await
@@ -123,7 +120,6 @@ pub(crate) async fn get_state_events_for_key_route(
 	}
 
 	let event = services
-		.rooms
 		.state_accessor
 		.room_state_get(&body.room_id, &body.event_type, &body.state_key)
 		.await
@@ -184,9 +180,8 @@ async fn send_state_event_for_key_helper(
 	timestamp: Option<ruma::MilliSecondsSinceUnixEpoch>,
 ) -> Result<OwnedEventId> {
 	allowed_to_send_state_event(services, room_id, event_type, state_key, json).await?;
-	let state_lock = services.rooms.state.mutex.lock(room_id).await;
+	let state_lock = services.state.mutex.lock(room_id).await;
 	let event_id = services
-		.rooms
 		.timeline
 		.build_and_append_pdu(
 			PduBuilder {
@@ -332,7 +327,6 @@ async fn allowed_to_send_state_event(
 
 					for alias in aliases {
 						let (alias_room_id, _servers) = services
-							.rooms
 							.alias
 							.resolve_alias(&alias, None)
 							.await
@@ -380,7 +374,6 @@ async fn allowed_to_send_state_event(
 						}
 
 						services
-							.rooms
 							.state_cache
 							.is_joined(&authorising_user, room_id)
 							.map(is_false!())

src/api/client/sync/mod.rs

@@ -29,7 +29,6 @@ async fn load_timeline(
 	limit: usize,
 ) -> Result<(Vec<(PduCount, PduEvent)>, bool, PduCount), Error> {
 	let last_timeline_count = services
-		.rooms
 		.timeline
 		.last_timeline_count(Some(sender_user), room_id, next_batch)
 		.await?;
@@ -39,7 +38,6 @@ async fn load_timeline(
 	}
 
 	let non_timeline_pdus = services
-		.rooms
 		.timeline
 		.pdus_rev(Some(sender_user), room_id, None)
 		.ready_filter_map(Result::ok)
@@ -70,14 +68,12 @@ async fn share_encrypted_room(
 	ignore_room: Option<&RoomId>,
 ) -> bool {
 	services
-		.rooms
 		.state_cache
 		.get_shared_rooms(sender_user, user_id)
 		.ready_filter(|&room_id| Some(room_id) != ignore_room)
 		.map(ToOwned::to_owned)
 		.broad_any(async |other_room_id| {
 			services
-				.rooms
 				.state_accessor
 				.is_encrypted_room(&other_room_id)
 				.await

src/api/client/sync/v3.rs

@@ -225,7 +225,6 @@ async fn build_sync_events(
 	};
 
 	let joined_rooms = services
-		.rooms
 		.state_cache
 		.rooms_joined(sender_user)
 		.map(ToOwned::to_owned)
@@ -258,7 +257,6 @@ async fn build_sync_events(
 		);
 
 	let left_rooms = services
-		.rooms
 		.state_cache
 		.rooms_left(sender_user)
 		.broad_filter_map(|(room_id, _)| {
@@ -278,12 +276,10 @@ async fn build_sync_events(
 		.collect();
 
 	let invited_rooms = services
-		.rooms
 		.state_cache
 		.rooms_invited(sender_user)
 		.fold_default(async |mut invited_rooms: BTreeMap<_, _>, (room_id, invite_state)| {
 			let invite_count = services
-				.rooms
 				.state_cache
 				.get_invite_count(&room_id, sender_user)
 				.await
@@ -303,12 +299,10 @@ async fn build_sync_events(
 		});
 
 	let knocked_rooms = services
-		.rooms
 		.state_cache
 		.rooms_knocked(sender_user)
 		.fold_default(async |mut knocked_rooms: BTreeMap<_, _>, (room_id, knock_state)| {
 			let knock_count = services
-				.rooms
 				.state_cache
 				.get_knock_count(&room_id, sender_user)
 				.await
@@ -439,7 +433,6 @@ async fn process_presence_updates(
 		.presence_since(since, Some(next_batch))
 		.filter(|(user_id, ..)| {
 			services
-				.rooms
 				.state_cache
 				.user_sees_user(syncing_user, user_id)
 		})
@@ -475,7 +468,6 @@ async fn handle_left_room(
 	filter: &FilterDefinition,
 ) -> Result<Option<LeftRoom>> {
 	let left_count = services
-		.rooms
 		.state_cache
 		.get_left_count(room_id, sender_user)
 		.await
@@ -504,11 +496,11 @@ async fn handle_left_room(
 		return Ok(None);
 	}
 
-	let is_not_found = services.rooms.metadata.exists(room_id).eq(&false);
+	let is_not_found = services.metadata.exists(room_id).eq(&false);
 
-	let is_disabled = services.rooms.metadata.is_disabled(room_id);
+	let is_disabled = services.metadata.is_disabled(room_id);
 
-	let is_banned = services.rooms.metadata.is_banned(room_id);
+	let is_banned = services.metadata.is_banned(room_id);
 
 	pin_mut!(is_not_found, is_disabled, is_banned);
 	if is_not_found.or(is_disabled).or(is_banned).await {
@@ -547,14 +539,12 @@ async fn handle_left_room(
 	let mut left_state_events = Vec::new();
 
 	let since_shortstatehash = services
-		.rooms
 		.user
 		.get_token_shortstatehash(room_id, since);
 
 	let since_state_ids: HashMap<_, OwnedEventId> = since_shortstatehash
 		.map_ok(|since_shortstatehash| {
 			services
-				.rooms
 				.state_accessor
 				.state_full_ids(since_shortstatehash)
 				.map(Ok)
@@ -565,7 +555,6 @@ async fn handle_left_room(
 		.unwrap_or_default();
 
 	let Ok(left_event_id): Result<OwnedEventId> = services
-		.rooms
 		.state_accessor
 		.room_state_get_id(room_id, &StateEventType::RoomMember, sender_user.as_str())
 		.await
@@ -575,7 +564,6 @@ async fn handle_left_room(
 	};
 
 	let Ok(left_shortstatehash) = services
-		.rooms
 		.state_accessor
 		.pdu_shortstatehash(&left_event_id)
 		.await
@@ -585,14 +573,12 @@ async fn handle_left_room(
 	};
 
 	let mut left_state_ids: HashMap<_, _> = services
-		.rooms
 		.state_accessor
 		.state_full_ids(left_shortstatehash)
 		.collect()
 		.await;
 
 	let leave_shortstatekey = services
-		.rooms
 		.short
 		.get_or_create_shortstatekey(&StateEventType::RoomMember, sender_user.as_str())
 		.await;
@@ -602,7 +588,6 @@ async fn handle_left_room(
 	for (shortstatekey, event_id) in left_state_ids {
 		if full_state || since_state_ids.get(&shortstatekey) != Some(&event_id) {
 			let (event_type, state_key) = services
-				.rooms
 				.short
 				.get_statekey_from_short(shortstatekey)
 				.await?;
@@ -618,7 +603,7 @@ async fn handle_left_room(
 				continue;
 			}
 
-			let Ok(pdu) = services.rooms.timeline.get_pdu(&event_id).await else {
+			let Ok(pdu) = services.timeline.get_pdu(&event_id).await else {
 				error!("Pdu in state not found: {event_id}");
 				continue;
 			};
@@ -659,7 +644,6 @@ async fn load_joined_room(
 	filter: &FilterDefinition,
 ) -> Result<(JoinedRoom, HashSet<OwnedUserId>, HashSet<OwnedUserId>)> {
 	let since_shortstatehash = services
-		.rooms
 		.user
 		.get_token_shortstatehash(room_id, since)
 		.ok()
@@ -682,7 +666,6 @@ async fn load_joined_room(
 	);
 
 	let receipt_events = services
-		.rooms
 		.read_receipt
 		.readreceipts_since(room_id, since, Some(next_batch))
 		.filter_map(async |(read_user, _, edu)| {
@@ -706,7 +689,6 @@ async fn load_joined_room(
 		.map(PduCount::into_unsigned)
 		.map(|shorteventid| {
 			services
-				.rooms
 				.state_accessor
 				.get_shortstatehash(shorteventid)
 		})
@@ -714,7 +696,6 @@ async fn load_joined_room(
 		.into();
 
 	let current_shortstatehash = services
-		.rooms
 		.state_accessor
 		.get_shortstatehash(last_timeline_count.into_unsigned())
 		.or_else(|_| services.state.get_room_shortstatehash(room_id));
@@ -727,10 +708,10 @@ async fn load_joined_room(
 	let current_shortstatehash = current_shortstatehash
 		.map_err(|_| err!(Database(error!("Room {room_id} has no state"))))?;
 
-	let associate_token = services
-		.rooms
-		.user
-		.associate_token_shortstatehash(room_id, next_batch, current_shortstatehash);
+	let associate_token =
+		services
+			.user
+			.associate_token_shortstatehash(room_id, next_batch, current_shortstatehash);
 
 	let lazy_loading_enabled = filter.room.state.lazy_load_options.is_enabled()
 		|| filter
@@ -751,12 +732,7 @@ async fn load_joined_room(
 
 	// Reset lazy loading because this is an initial sync
 	let lazy_load_reset: OptionFuture<_> = initial
-		.then(|| {
-			services
-				.rooms
-				.lazy_loading
-				.reset(lazy_loading_context)
-		})
+		.then(|| services.lazy_loading.reset(lazy_loading_context))
 		.into();
 
 	lazy_load_reset.await;
@@ -771,7 +747,6 @@ async fn load_joined_room(
 				.collect();
 
 			services
-				.rooms
 				.lazy_loading
 				.witness_retain(witness, lazy_loading_context)
 		})
@@ -781,7 +756,6 @@ async fn load_joined_room(
 		.is_empty()
 		.then(|| {
 			services
-				.rooms
 				.user
 				.last_notification_read(sender_user, room_id)
 		})
@@ -790,20 +764,15 @@ async fn load_joined_room(
 	let since_sender_member: OptionFuture<_> = since_shortstatehash
 		.map(|short| {
 			services
-				.rooms
 				.state_accessor
 				.state_get_content(short, &StateEventType::RoomMember, sender_user.as_str())
 				.ok()
 		})
 		.into();
 
-	let encrypted_room = services
-		.rooms
-		.state_accessor
-		.is_encrypted_room(room_id);
+	let encrypted_room = services.state_accessor.is_encrypted_room(room_id);
 
 	let last_privateread_update = services
-		.rooms
 		.read_receipt
 		.last_privateread_update(sender_user, room_id);
 
@@ -867,7 +836,6 @@ async fn load_joined_room(
 	let notification_count: OptionFuture<_> = send_notification_counts
 		.then(|| {
 			services
-				.rooms
 				.user
 				.notification_count(sender_user, room_id)
 				.map(TryInto::try_into)
@@ -878,7 +846,6 @@ async fn load_joined_room(
 	let highlight_count: OptionFuture<_> = send_notification_counts
 		.then(|| {
 			services
-				.rooms
 				.user
 				.highlight_count(sender_user, room_id)
 				.map(TryInto::try_into)
@@ -890,7 +857,6 @@ async fn load_joined_room(
 		.gt(&since)
 		.then(|| {
 			services
-				.rooms
 				.read_receipt
 				.private_read_get(room_id, sender_user)
 				.map(Result::ok)
@@ -898,7 +864,6 @@ async fn load_joined_room(
 		.into();
 
 	let typing_events = services
-		.rooms
 		.typing
 		.last_typing_update(room_id)
 		.and_then(async |count| {
@@ -1086,7 +1051,6 @@ async fn calculate_state_changes<'a>(
 
 	let state_get_shorteventid = |user_id: &'a UserId| {
 		services
-			.rooms
 			.state_accessor
 			.state_get_shortid(
 				horizon_shortstatehash,
@@ -1112,7 +1076,6 @@ async fn calculate_state_changes<'a>(
 		.then(|| {
 			StreamExt::into_future(
 				services
-					.rooms
 					.state_accessor
 					.state_added((since_shortstatehash, horizon_shortstatehash))
 					.boxed(),
@@ -1124,7 +1087,6 @@ async fn calculate_state_changes<'a>(
 		.then(|| {
 			StreamExt::into_future(
 				services
-					.rooms
 					.state_accessor
 					.state_full_shortids(horizon_shortstatehash)
 					.expect_ok(),
@@ -1145,18 +1107,12 @@ async fn calculate_state_changes<'a>(
 		.chain(lazy_state_ids.stream())
 		.broad_filter_map(|shorteventid| {
 			services
-				.rooms
 				.short
 				.get_eventid_from_short(shorteventid)
 				.ok()
 		})
 		.broad_filter_map(async |event_id: OwnedEventId| {
-			services
-				.rooms
-				.timeline
-				.get_pdu(&event_id)
-				.ok()
-				.await
+			services.timeline.get_pdu(&event_id).ok().await
 		})
 		.collect::<Vec<_>>()
 		.boxed()
@@ -1188,7 +1144,6 @@ async fn lazy_filter(
 	shorteventid: ShortEventId,
 ) -> Option<ShortEventId> {
 	let (event_type, state_key) = services
-		.rooms
 		.short
 		.get_statekey_from_short(shortstatekey)
 		.await
@@ -1204,13 +1159,11 @@ async fn calculate_counts(
 	sender_user: &UserId,
 ) -> (Option<u64>, Option<u64>, Option<Vec<OwnedUserId>>) {
 	let joined_member_count = services
-		.rooms
 		.state_cache
 		.room_joined_count(room_id)
 		.unwrap_or(0);
 
 	let invited_member_count = services
-		.rooms
 		.state_cache
 		.room_invited_count(room_id)
 		.unwrap_or(0);
@@ -1233,7 +1186,6 @@ async fn calculate_heroes(
 	sender_user: &UserId,
 ) -> Vec<OwnedUserId> {
 	services
-		.rooms
 		.timeline
 		.all_pdus(sender_user, room_id)
 		.ready_filter(|(_, pdu)| pdu.kind == RoomMember)
@@ -1277,14 +1229,8 @@ async fn fold_hero(
 	}
 
 	let (is_invited, is_joined) = join(
-		services
-			.rooms
-			.state_cache
-			.is_invited(user_id, room_id),
-		services
-			.rooms
-			.state_cache
-			.is_joined(user_id, room_id),
+		services.state_cache.is_invited(user_id, room_id),
+		services.state_cache.is_joined(user_id, room_id),
 	)
 	.await;
 
@@ -1304,7 +1250,6 @@ async fn typings_event_for_user(
 	Ok(SyncEphemeralRoomEvent {
 		content: TypingEventContent {
 			user_ids: services
-				.rooms
 				.typing
 				.typing_users_for_user(room_id, sender_user)
 				.await?,

src/api/client/sync/v5.rs

@@ -98,21 +98,18 @@ pub(crate) async fn sync_events_v5_route(
 		.update_snake_sync_request_with_cache(&snake_key, &mut cached);
 
 	let all_joined_rooms = services
-		.rooms
 		.state_cache
 		.rooms_joined(sender_user)
 		.map(ToOwned::to_owned)
 		.collect::<Vec<OwnedRoomId>>();
 
 	let all_invited_rooms = services
-		.rooms
 		.state_cache
 		.rooms_invited(sender_user)
 		.map(|r| r.0)
 		.collect::<Vec<OwnedRoomId>>();
 
 	let all_knocked_rooms = services
-		.rooms
 		.state_cache
 		.rooms_knocked(sender_user)
 		.map(|r| r.0)
@@ -234,11 +231,11 @@ async fn fetch_subscriptions(
 ) {
 	let mut known_subscription_rooms = BTreeSet::new();
 	for (room_id, room) in &body.room_subscriptions {
-		let not_exists = services.rooms.metadata.exists(room_id).eq(&false);
+		let not_exists = services.metadata.exists(room_id).eq(&false);
 
-		let is_disabled = services.rooms.metadata.is_disabled(room_id);
+		let is_disabled = services.metadata.is_disabled(room_id);
 
-		let is_banned = services.rooms.metadata.is_banned(room_id);
+		let is_banned = services.metadata.is_banned(room_id);
 
 		pin_mut!(not_exists, is_disabled, is_banned);
 		if not_exists.or(is_disabled).or(is_banned).await {
@@ -414,7 +411,6 @@ where
 		{
 			// TODO: figure out a timestamp we can use for remote invites
 			invite_state = services
-				.rooms
 				.state_cache
 				.invite_state(sender_user, room_id)
 				.await
@@ -453,7 +449,6 @@ where
 		}
 
 		let last_privateread_update = services
-			.rooms
 			.read_receipt
 			.last_privateread_update(sender_user, room_id)
 			.await;
@@ -461,7 +456,6 @@ where
 		let private_read_event: OptionFuture<_> = (last_privateread_update > *roomsince)
 			.then(|| {
 				services
-					.rooms
 					.read_receipt
 					.private_read_get(room_id, sender_user)
 					.ok()
@@ -469,7 +463,6 @@ where
 			.into();
 
 		let mut receipts: Vec<Raw<AnySyncEphemeralRoomEvent>> = services
-			.rooms
 			.read_receipt
 			.readreceipts_since(room_id, *roomsince, Some(next_batch))
 			.filter_map(async |(read_user, _ts, v)| {
@@ -552,7 +545,6 @@ where
 			.stream()
 			.filter_map(async |state| {
 				services
-					.rooms
 					.state_accessor
 					.room_state_get(room_id, &state.0, &state.1)
 					.await
@@ -563,7 +555,6 @@ where
 			.await;
 
 		let room_name = services
-			.rooms
 			.state_accessor
 			.get_name(room_id)
 			.await
@@ -572,13 +563,11 @@ where
 		// Heroes
 		let heroes: Vec<_> = if room_name.is_none() {
 			services
-				.rooms
 				.state_cache
 				.room_members(room_id)
 				.ready_filter(|member| *member != sender_user)
 				.filter_map(|user_id| {
 					services
-						.rooms
 						.state_accessor
 						.get_member(room_id, user_id)
 						.map_ok(|memberevent| sync_events::v5::response::Hero {
@@ -629,12 +618,7 @@ where
 			None
 		};
 
-		let room_avatar = match services
-			.rooms
-			.state_accessor
-			.get_avatar(room_id)
-			.await
-		{
+		let room_avatar = match services.state_accessor.get_avatar(room_id).await {
 			| ruma::JsOption::Some(avatar) => ruma::JsOption::from_option(avatar.url),
 			| ruma::JsOption::Null => ruma::JsOption::Null,
 			| ruma::JsOption::Undefined => ruma::JsOption::Undefined,
@@ -653,7 +637,6 @@ where
 			unread_notifications: UnreadNotificationsCount {
 				highlight_count: Some(
 					services
-						.rooms
 						.user
 						.highlight_count(sender_user, room_id)
 						.await
@@ -662,7 +645,6 @@ where
 				),
 				notification_count: Some(
 					services
-						.rooms
 						.user
 						.notification_count(sender_user, room_id)
 						.await
@@ -676,7 +658,6 @@ where
 			limited,
 			joined_count: Some(
 				services
-					.rooms
 					.state_cache
 					.room_joined_count(room_id)
 					.await
@@ -686,7 +667,6 @@ where
 			),
 			invited_count: Some(
 				services
-					.rooms
 					.state_cache
 					.room_invited_count(room_id)
 					.await
@@ -780,7 +760,6 @@ where
 
 	for room_id in all_joined_rooms {
 		let Ok(current_shortstatehash) = services
-			.rooms
 			.state
 			.get_room_shortstatehash(room_id)
 			.await
@@ -790,14 +769,12 @@ where
 		};
 
 		let since_shortstatehash = services
-			.rooms
 			.user
 			.get_token_shortstatehash(room_id, globalsince)
 			.await
 			.ok();
 
 		let encrypted_room = services
-			.rooms
 			.state_accessor
 			.state_get(current_shortstatehash, &StateEventType::RoomEncryption, "")
 			.await
@@ -810,13 +787,11 @@ where
 			}
 
 			let since_encryption = services
-				.rooms
 				.state_accessor
 				.state_get(since_shortstatehash, &StateEventType::RoomEncryption, "")
 				.await;
 
 			let since_sender_member: Option<RoomMemberEventContent> = services
-				.rooms
 				.state_accessor
 				.state_get_content(
 					since_shortstatehash,
@@ -834,14 +809,12 @@ where
 
 			if encrypted_room {
 				let current_state_ids: HashMap<_, OwnedEventId> = services
-					.rooms
 					.state_accessor
 					.state_full_ids(current_shortstatehash)
 					.collect()
 					.await;
 
 				let since_state_ids: HashMap<_, _> = services
-					.rooms
 					.state_accessor
 					.state_full_ids(since_shortstatehash)
 					.collect()
@@ -852,7 +825,7 @@ where
 						continue;
 					}
 
-					let Ok(pdu) = services.rooms.timeline.get_pdu(&id).await else {
+					let Ok(pdu) = services.timeline.get_pdu(&id).await else {
 						error!("Pdu in state not found: {id}");
 						continue;
 					};
@@ -897,7 +870,6 @@ where
 					// If the user is in a new encrypted room, give them all joined users
 					device_list_changes.extend(
 						services
-						.rooms
 						.state_cache
 						.room_members(room_id)
 						// Don't send key updates from the sender to the sender
@@ -995,7 +967,6 @@ where
 		.stream()
 		.filter_map(async |room_id| {
 			services
-				.rooms
 				.typing
 				.typing_users_for_user(room_id, sender_user)
 				.inspect_err(|e| warn!(%room_id, "Failed to get typing events for room: {e}"))
@@ -1037,7 +1008,6 @@ where
 {
 	rooms.filter_map(async |room_id| {
 		let room_type = services
-			.rooms
 			.state_accessor
 			.get_room_type(room_id)
 			.await;

src/api/client/threads.rs

@@ -32,13 +32,11 @@ pub(crate) async fn get_threads_route(
 		.unwrap_or_else(PduCount::max);
 
 	let threads: Vec<(PduCount, PduEvent)> = services
-		.rooms
 		.threads
 		.threads_until(body.sender_user(), &body.room_id, from, &body.include)
 		.take(limit)
 		.try_filter_map(async |(count, pdu)| {
 			Ok(services
-				.rooms
 				.state_accessor
 				.user_can_see_event(body.sender_user(), &body.room_id, &pdu.event_id)
 				.await

src/api/client/typing.rs

@@ -19,7 +19,6 @@ pub(crate) async fn create_typing_event_route(
 	}
 
 	if !services
-		.rooms
 		.state_cache
 		.is_joined(sender_user, &body.room_id)
 		.await
@@ -46,7 +45,6 @@ pub(crate) async fn create_typing_event_route(
 					.try_mul(1000)?,
 			);
 			services
-				.rooms
 				.typing
 				.typing_add(
 					sender_user,
@@ -59,7 +57,6 @@ pub(crate) async fn create_typing_event_route(
 		},
 		| _ => {
 			services
-				.rooms
 				.typing
 				.typing_remove(sender_user, &body.room_id)
 				.await?;

src/api/client/unstable.rs

@@ -45,7 +45,6 @@ pub(crate) async fn get_mutual_rooms_route(
 	}
 
 	let mutual_rooms: Vec<OwnedRoomId> = services
-		.rooms
 		.state_cache
 		.get_shared_rooms(sender_user, &body.user_id)
 		.map(ToOwned::to_owned)
@@ -137,7 +136,6 @@ pub(crate) async fn set_profile_field_route(
 
 	if body.value.field_name() == ProfileFieldName::DisplayName {
 		let all_joined_rooms: Vec<OwnedRoomId> = services
-			.rooms
 			.state_cache
 			.rooms_joined(&body.user_id)
 			.map(Into::into)
@@ -155,7 +153,6 @@ pub(crate) async fn set_profile_field_route(
 		let mxc = ruma::OwnedMxcUri::from(body.value.value().to_string());
 
 		let all_joined_rooms: Vec<OwnedRoomId> = services
-			.rooms
 			.state_cache
 			.rooms_joined(&body.user_id)
 			.map(Into::into)
@@ -199,7 +196,6 @@ pub(crate) async fn delete_profile_field_route(
 
 	if body.field == ProfileFieldName::DisplayName {
 		let all_joined_rooms: Vec<OwnedRoomId> = services
-			.rooms
 			.state_cache
 			.rooms_joined(&body.user_id)
 			.map(Into::into)
@@ -209,7 +205,6 @@ pub(crate) async fn delete_profile_field_route(
 		update_displayname(&services, &body.user_id, None, &all_joined_rooms).await;
 	} else if body.field == ProfileFieldName::AvatarUrl {
 		let all_joined_rooms: Vec<OwnedRoomId> = services
-			.rooms
 			.state_cache
 			.rooms_joined(&body.user_id)
 			.map(Into::into)

src/api/client/user_directory.rs

@@ -57,13 +57,11 @@ pub(crate) async fn search_users_route(
 			}
 
 			let user_in_public_room = services
-				.rooms
 				.state_cache
 				.rooms_joined(&user_id)
 				.map(ToOwned::to_owned)
 				.broad_any(async |room_id| {
 					services
-						.rooms
 						.state_accessor
 						.get_join_rules(&room_id)
 						.map(|rule| matches!(rule, JoinRule::Public))
@@ -71,7 +69,6 @@ pub(crate) async fn search_users_route(
 				});
 
 			let user_sees_user = services
-				.rooms
 				.state_cache
 				.user_sees_user(sender_user, &user_id);