refactor: Ruma upstraming, bake a little more

src/api/Cargo.toml

@@ -88,6 +88,7 @@ lettre.workspace = true
 log.workspace = true
 rand.workspace = true
 reqwest.workspace = true
+assign.workspace = true
 ruma.workspace = true
 ruminuwuity.workspace = true
 serde_html_form.workspace = true

src/api/admin/rooms/ban.rs

@@ -1,10 +1,7 @@
 use axum::extract::State;
 use conduwuit::{Err, Result, info, utils::ReadyExt, warn};
 use futures::{FutureExt, StreamExt};
-use ruma::{
-	OwnedRoomAliasId,
-	events::room::message::RoomMessageEventContent,
-};
+use ruma::{OwnedRoomAliasId, events::room::message::RoomMessageEventContent};
 use ruminuwuity::admin::continuwuity::rooms;
 
 use crate::{Ruma, client::leave_room};

src/api/client/device.rs

@@ -81,7 +81,8 @@ pub(crate) async fn update_device_route(
 			};
 
 			debug!(
-				"Creating new device for {sender_user} from appservice {} as device ID does not exist",
+				"Creating new device for {sender_user} from appservice {} as device ID does not \
+				 exist",
 				appservice.registration.id
 			);
 
@@ -121,9 +122,7 @@ pub(crate) async fn delete_device_route(
 	let appservice = body.appservice_info.as_ref();
 
 	if appservice.is_some() {
-		debug!(
-			"Skipping UIAA for {sender_user} as this is from an appservice"
-		);
+		debug!("Skipping UIAA for {sender_user} as this is from an appservice");
 		services
 			.users
 			.remove_device(sender_user, &body.device_id)

src/api/client/directory.rs

@@ -17,7 +17,8 @@ use futures::{
 	future::{join, join4, join5},
 };
 use ruma::{
-	OwnedRoomId, RoomId, ServerName, UInt, UserId, api::{
+	OwnedRoomId, RoomId, ServerName, UInt, UserId,
+	api::{
 		client::{
 			directory::{
 				get_public_rooms, get_public_rooms_filtered, get_room_visibility,
@@ -26,14 +27,18 @@ use ruma::{
 			room,
 		},
 		federation,
-	}, directory::{Filter, PublicRoomsChunk, RoomNetwork, RoomTypeFilter}, events::{
+	},
+	directory::{Filter, PublicRoomsChunk, RoomNetwork, RoomTypeFilter},
+	events::{
 		StateEventType,
 		room::{
 			create::RoomCreateEventContent,
 			join_rules::{JoinRule, RoomJoinRulesEventContent},
 			power_levels::{RoomPowerLevels, RoomPowerLevelsEventContent},
 		},
-	}, room::JoinRuleKind, uint
+	},
+	room::JoinRuleKind,
+	uint,
 };
 use tokio::join;
 

src/api/client/membership/invite.rs

@@ -8,7 +8,10 @@ use conduwuit::{
 use futures::FutureExt;
 use ruma::{
 	RoomId, UserId,
-	api::{client::membership::invite_user, federation::membership::{RawStrippedState, create_invite}},
+	api::{
+		client::membership::invite_user,
+		federation::membership::{RawStrippedState, create_invite},
+	},
 	events::room::member::{MembershipState, RoomMemberEventContent},
 };
 use ruminuwuity::invite_permission_config::FilterLevel;

src/api/client/membership/join.rs

@@ -208,10 +208,7 @@ 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);
+			let addl_via_servers = services.rooms.state_cache.servers_invite_via(&room_id);
 
 			let addl_state_servers = services
 				.rooms
@@ -432,8 +429,7 @@ async fn join_room_by_id_helper_remote(
 
 	join_event_stub.insert(
 		"content".to_owned(),
-		to_canonical_value(join_content)
-		.expect("event is valid, we just created it"),
+		to_canonical_value(join_content).expect("event is valid, we just created it"),
 	);
 
 	// We keep the "event_id" in the pdu only in v1 or
@@ -462,10 +458,14 @@ async fn join_room_by_id_helper_remote(
 	let mut join_event = join_event_stub;
 
 	info!("Asking {remote_server} for send_join in room {room_id}");
-	let send_join_request = federation::membership::create_join_event::v2::Request::new(room_id.to_owned(), event_id.clone(), services
+	let send_join_request = federation::membership::create_join_event::v2::Request::new(
+		room_id.to_owned(),
+		event_id.clone(),
+		services
 			.sending
 			.convert_to_outgoing_federation_event(join_event.clone())
-			.await);
+			.await,
+	);
 
 	let send_join_response = match services
 		.sending
@@ -816,15 +816,15 @@ async fn make_join_request(
 			servers.len()
 		);
 
-		let mut request = federation::membership::prepare_join_event::v1::Request::new(room_id.to_owned(), sender_user.to_owned());
+		let mut request = federation::membership::prepare_join_event::v1::Request::new(
+			room_id.to_owned(),
+			sender_user.to_owned(),
+		);
 		request.ver = services.server.supported_room_versions().collect();
 
 		let make_join_response = services
 			.sending
-			.send_federation_request(
-				remote_server,
-				request
-			)
+			.send_federation_request(remote_server, request)
 			.await;
 
 		trace!("make_join response: {:?}", make_join_response);

src/api/client/membership/knock.rs

@@ -15,16 +15,20 @@ use conduwuit::{
 };
 use futures::{FutureExt, StreamExt};
 use ruma::{
-	CanonicalJsonObject, CanonicalJsonValue, OwnedEventId, OwnedRoomId, OwnedServerName, OwnedUserId, RoomId, RoomVersionId, UserId, api::{
+	CanonicalJsonObject, CanonicalJsonValue, OwnedEventId, OwnedRoomId, OwnedServerName,
+	OwnedUserId, RoomId, RoomVersionId, UserId,
+	api::{
 		client::knock::knock_room,
 		federation::{self},
-	}, canonical_json::to_canonical_value, events::{
+	},
+	canonical_json::to_canonical_value,
+	events::{
 		StateEventType,
 		room::{
 			join_rules::{AllowRule, JoinRule},
 			member::{MembershipState, RoomMemberEventContent},
 		},
-	}
+	},
 };
 use service::{
 	Services,
@@ -108,10 +112,7 @@ pub(crate) async fn knock_room_route(
 			)
 			.await?;
 
-			let addl_via_servers = services
-				.rooms
-				.state_cache
-				.servers_invite_via(&room_id);
+			let addl_via_servers = services.rooms.state_cache.servers_invite_via(&room_id);
 
 			let addl_state_servers = services
 				.rooms
@@ -416,8 +417,7 @@ async fn knock_room_helper_local(
 	);
 	knock_event_stub.insert(
 		"content".to_owned(),
-		to_canonical_value(content)
-		.expect("event is valid, we just created it"),
+		to_canonical_value(content).expect("event is valid, we just created it"),
 	);
 
 	// In order to create a compatible ref hash (EventID) the `hashes` field needs
@@ -540,8 +540,7 @@ async fn knock_room_helper_remote(
 
 	knock_event_stub.insert(
 		"content".to_owned(),
-		to_canonical_value(knock_content)
-		.expect("event is valid, we just created it"),
+		to_canonical_value(knock_content).expect("event is valid, we just created it"),
 	);
 
 	// In order to create a compatible ref hash (EventID) the `hashes` field needs
@@ -567,7 +566,7 @@ async fn knock_room_helper_remote(
 		services
 			.sending
 			.convert_to_outgoing_federation_event(knock_event.clone())
-			.await
+			.await,
 	);
 
 	let send_knock_response = services
@@ -594,13 +593,10 @@ async fn knock_room_helper_remote(
 		.map(|event| {
 			#[allow(deprecated)]
 			let raw_value = match event {
-				federation::membership::RawStrippedState::Stripped(raw_state) => {
-					&raw_state.clone().into_json()
-				},
-				federation::membership::RawStrippedState::Pdu(raw_value) => {
-					raw_value
-				},
-				_ => panic!("unknown raw stripped state type"),
+				| federation::membership::RawStrippedState::Stripped(raw_state) =>
+					&raw_state.clone().into_json(),
+				| federation::membership::RawStrippedState::Pdu(raw_value) => raw_value,
+				| _ => panic!("unknown raw stripped state type"),
 			};
 
 			serde_json::from_str::<CanonicalJsonObject>(raw_value.get())
@@ -722,15 +718,15 @@ async fn make_knock_request(
 
 		info!("Asking {remote_server} for make_knock ({make_knock_counter})");
 
-		let mut request = federation::membership::prepare_knock_event::v1::Request::new(room_id.to_owned(), sender_user.to_owned());
+		let mut request = federation::membership::prepare_knock_event::v1::Request::new(
+			room_id.to_owned(),
+			sender_user.to_owned(),
+		);
 		request.ver = services.server.supported_room_versions().collect();
 
 		let make_knock_response = services
 			.sending
-			.send_federation_request(
-				remote_server,
-				request,
-			)
+			.send_federation_request(remote_server, request)
 			.await;
 
 		trace!("make_knock response: {make_knock_response:?}");

src/api/client/membership/leave.rs

@@ -42,10 +42,7 @@ pub(crate) async fn leave_room_route(
 // Make a user leave all their joined rooms, rescinds knocks, forgets all rooms,
 // 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);
+	let rooms_joined = services.rooms.state_cache.rooms_joined(user_id);
 
 	let rooms_invited = services
 		.rooms
@@ -286,7 +283,10 @@ pub async fn remote_leave_room<S: ::std::hash::BuildHasher>(
 			.sending
 			.send_federation_request(
 				remote_server.as_ref(),
-				federation::membership::prepare_leave_event::v1::Request::new(room_id.to_owned(), user_id.to_owned())
+				federation::membership::prepare_leave_event::v1::Request::new(
+					room_id.to_owned(),
+					user_id.to_owned(),
+				),
 			)
 			.await;
 
@@ -387,10 +387,14 @@ pub async fn remote_leave_room<S: ::std::hash::BuildHasher>(
 		.sending
 		.send_federation_request(
 			&remote_server,
-			federation::membership::create_leave_event::v2::Request::new(room_id.to_owned(), event_id.clone(), services
+			federation::membership::create_leave_event::v2::Request::new(
+				room_id.to_owned(),
+				event_id.clone(),
+				services
 					.sending
 					.convert_to_outgoing_federation_event(leave_event.clone())
-					.await),
+					.await,
+			),
 		)
 		.await?;
 

src/api/client/membership/members.rs

@@ -44,17 +44,17 @@ pub(crate) async fn get_member_events_route(
 	}
 
 	let chunk = services
-			.rooms
-			.state_accessor
-			.room_state_full(&body.room_id)
-			.ready_filter_map(Result::ok)
-			.ready_filter(|((ty, _), _)| *ty == StateEventType::RoomMember)
-			.map(at!(1))
-			.ready_filter_map(|pdu| membership_filter(pdu, membership, not_membership))
-			.map(Event::into_format)
-			.collect()
-			.boxed()
-			.await;
+		.rooms
+		.state_accessor
+		.room_state_full(&body.room_id)
+		.ready_filter_map(Result::ok)
+		.ready_filter(|((ty, _), _)| *ty == StateEventType::RoomMember)
+		.map(at!(1))
+		.ready_filter_map(|pdu| membership_filter(pdu, membership, not_membership))
+		.map(Event::into_format)
+		.collect()
+		.boxed()
+		.await;
 
 	Ok(get_member_events::v3::Response::new(chunk))
 }
@@ -79,23 +79,23 @@ pub(crate) async fn joined_members_route(
 	}
 
 	let joined = services
-			.rooms
-			.state_cache
-			.room_members(&body.room_id)
-			.broad_then(|user_id| async move {
-				let mut member = RoomMember::new();
-				let (display_name, avatar_url) = join(
-					services.users.displayname(&user_id).ok(),
-					services.users.avatar_url(&user_id).ok(),
-				)
-				.await;
-				member.display_name = display_name;
-				member.avatar_url = avatar_url;
-
-				(user_id, member)
-			})
-			.collect()
+		.rooms
+		.state_cache
+		.room_members(&body.room_id)
+		.broad_then(|user_id| async move {
+			let mut member = RoomMember::new();
+			let (display_name, avatar_url) = join(
+				services.users.displayname(&user_id).ok(),
+				services.users.avatar_url(&user_id).ok(),
+			)
 			.await;
+			member.display_name = display_name;
+			member.avatar_url = avatar_url;
+
+			(user_id, member)
+		})
+		.collect()
+		.await;
 
 	Ok(joined_members::v3::Response::new(joined))
 }
@@ -108,12 +108,14 @@ fn membership_filter<Pdu: Event>(
 	let evt_membership = pdu.get_content::<RoomMemberEventContent>().ok()?.membership;
 
 	if let Some(membership_state_filter) = membership_state_filter
-		&& *membership_state_filter != evt_membership {
+		&& *membership_state_filter != evt_membership
+	{
 		return None;
 	}
 
 	if let Some(not_membership_state_filter) = not_membership_state_filter
-		&& *not_membership_state_filter == evt_membership {
+		&& *not_membership_state_filter == evt_membership
+	{
 		return None;
 	}
 

src/api/client/membership/mod.rs

@@ -48,11 +48,11 @@ pub(crate) async fn joined_rooms_route(
 	body: Ruma<joined_rooms::v3::Request>,
 ) -> Result<joined_rooms::v3::Response> {
 	let joined_rooms = services
-			.rooms
-			.state_cache
-			.rooms_joined(body.sender_user())
-			.collect()
-			.await;
+		.rooms
+		.state_cache
+		.rooms_joined(body.sender_user())
+		.collect()
+		.await;
 
 	Ok(joined_rooms::v3::Response::new(joined_rooms))
 }

src/api/client/room/aliases.rs

@@ -27,11 +27,11 @@ pub(crate) async fn get_room_aliases_route(
 	}
 
 	let aliases = services
-			.rooms
-			.alias
-			.local_aliases_for_room(&body.room_id)
-			.collect()
-			.await;
+		.rooms
+		.alias
+		.local_aliases_for_room(&body.room_id)
+		.collect()
+		.await;
 
 	Ok(aliases::v3::Response::new(aliases))
 }

src/api/client/room/create.rs

@@ -9,7 +9,9 @@ use conduwuit::{
 use conduwuit_service::{Services, appservice::RegistrationInfo};
 use futures::FutureExt;
 use ruma::{
-	CanonicalJsonObject, Int, OwnedRoomAliasId, OwnedRoomId, OwnedUserId, RoomId, RoomVersionId, api::client::room::{self, create_room}, events::{
+	CanonicalJsonObject, Int, OwnedRoomAliasId, OwnedRoomId, OwnedUserId, RoomId, RoomVersionId,
+	api::client::room::{self, create_room},
+	events::{
 		TimelineEventType,
 		room::{
 			canonical_alias::RoomCanonicalAliasEventContent,
@@ -22,7 +24,10 @@ use ruma::{
 			power_levels::RoomPowerLevelsEventContent,
 			topic::RoomTopicEventContent,
 		},
-	}, int, room_version_rules::RoomIdFormatVersion, serde::{JsonObject, Raw}
+	},
+	int,
+	room_version_rules::RoomIdFormatVersion,
+	serde::{JsonObject, Raw},
 };
 use ruminuwuity::invite_permission_config::FilterLevel;
 use serde_json::{json, value::to_raw_value};
@@ -80,8 +85,8 @@ pub(crate) async fn create_room_route(
 	let room_version_rules = room_version.rules().unwrap();
 
 	let room_id: Option<OwnedRoomId> = match room_version_rules.room_id_format {
-		RoomIdFormatVersion::V1 => Some(RoomId::new_v1(services.globals.server_name())),
-		_ => None,
+		| RoomIdFormatVersion::V1 => Some(RoomId::new_v1(services.globals.server_name())),
+		| _ => None,
 	};
 
 	// check if room ID doesn't already exist instead of erroring on auth check

src/api/router/handler.rs

@@ -45,7 +45,7 @@ macro_rules! ruma_handler {
 		{
 			fn add_routes(&'static self, router: Router<State>) -> Router<State> {
 				use ruma::api::path_builder::PathBuilder;
-				
+
 				Req::PATH_BUILDER
 					.all_paths()
 					.fold(router, |router, path| self.add_route(router, path))