various cleanup tweaks/fixes

Signed-off-by: Jason Volk <jason@zemos.net>

src/api/client/keys.rs

@@ -244,7 +244,7 @@ pub(crate) async fn get_key_changes_route(
 		device_list_updates.extend(
 			services
 				.users
-				.keys_changed(room_id.as_ref(), from, Some(to))
+				.keys_changed(room_id.as_str(), from, Some(to))
 				.map(ToOwned::to_owned)
 				.collect::<Vec<_>>()
 				.await,

src/api/client/membership.rs

@@ -167,12 +167,12 @@ pub(crate) async fn join_room_by_id_route(
 	.await?;
 
 	// There is no body.server_name for /roomId/join
-	let mut servers = services
+	let mut servers: Vec<_> = services
 		.rooms
 		.state_cache
 		.servers_invite_via(&body.room_id)
 		.map(ToOwned::to_owned)
-		.collect::<Vec<_>>()
+		.collect()
 		.await;
 
 	servers.extend(
@@ -641,12 +641,13 @@ pub(crate) async fn joined_members_route(
 		.rooms
 		.state_cache
 		.room_members(&body.room_id)
+		.map(ToOwned::to_owned)
 		.then(|user| async move {
 			(
-				user.to_owned(),
+				user.clone(),
 				RoomMember {
-					display_name: services.users.displayname(user).await.ok(),
-					avatar_url: services.users.avatar_url(user).await.ok(),
+					display_name: services.users.displayname(&user).await.ok(),
+					avatar_url: services.users.avatar_url(&user).await.ok(),
 				},
 			)
 		})
@@ -1575,7 +1576,7 @@ pub(crate) async fn invite_helper(
 // Make a user leave all their joined rooms, forgets all rooms, and ignores
 // errors
 pub async fn leave_all_rooms(services: &Services, user_id: &UserId) {
-	let all_rooms = services
+	let all_rooms: Vec<_> = services
 		.rooms
 		.state_cache
 		.rooms_joined(user_id)
@@ -1587,7 +1588,7 @@ pub async fn leave_all_rooms(services: &Services, user_id: &UserId) {
 				.rooms_invited(user_id)
 				.map(|(r, _)| r),
 		)
-		.collect::<Vec<_>>()
+		.collect()
 		.await;
 
 	for room_id in all_rooms {

src/api/client/search.rs

@@ -77,14 +77,14 @@ pub(crate) async fn search_events_route(
 				.user_can_see_state_events(sender_user, room_id)
 				.await
 			{
-				let room_state = services
+				let room_state: Vec<_> = services
 					.rooms
 					.state_accessor
 					.room_state_full(room_id)
 					.await?
 					.values()
 					.map(|pdu| pdu.to_state_event())
-					.collect::<Vec<_>>();
+					.collect();
 
 				debug!("Room state: {:?}", room_state);
 

src/api/client/sync.rs

@@ -7,13 +7,14 @@ use std::{
 use axum::extract::State;
 use conduit::{
 	debug, err, error, is_equal_to,
+	result::IntoIsOk,
 	utils::{
 		math::{ruma_from_u64, ruma_from_usize, usize_from_ruma, usize_from_u64_truncated},
-		IterStream, ReadyExt,
+		BoolExt, IterStream, ReadyExt, TryFutureExtExt,
 	},
 	warn, PduCount,
 };
-use futures::{pin_mut, StreamExt};
+use futures::{pin_mut, FutureExt, StreamExt, TryFutureExt};
 use ruma::{
 	api::client::{
 		error::ErrorKind,
@@ -172,12 +173,12 @@ pub(crate) async fn sync_events_route(
 		process_presence_updates(&services, &mut presence_updates, since, &sender_user).await?;
 	}
 
-	let all_joined_rooms = services
+	let all_joined_rooms: Vec<_> = services
 		.rooms
 		.state_cache
 		.rooms_joined(&sender_user)
 		.map(ToOwned::to_owned)
-		.collect::<Vec<_>>()
+		.collect()
 		.await;
 
 	// Coalesce database writes for the remainder of this scope.
@@ -869,15 +870,13 @@ async fn load_joined_room(
 						.rooms
 						.state_cache
 						.room_members(room_id)
-						.ready_filter(|user_id| {
-							// Don't send key updates from the sender to the sender
-							sender_user != *user_id
-						})
-						.filter_map(|user_id| async move {
-							// Only send keys if the sender doesn't share an encrypted room with the target
-							// already
-							(!share_encrypted_room(services, sender_user, user_id, Some(room_id)).await)
-								.then_some(user_id.to_owned())
+						// Don't send key updates from the sender to the sender
+						.ready_filter(|user_id| sender_user != *user_id)
+						// Only send keys if the sender doesn't share an encrypted room with the target
+						// already
+						.filter_map(|user_id| {
+							share_encrypted_room(services, sender_user, user_id, Some(room_id))
+								.map(|res| res.or_some(user_id.to_owned()))
 						})
 						.collect::<Vec<_>>()
 						.await,
@@ -1117,13 +1116,12 @@ async fn share_encrypted_room(
 		.user
 		.get_shared_rooms(sender_user, user_id)
 		.ready_filter(|&room_id| Some(room_id) != ignore_room)
-		.any(|other_room_id| async move {
+		.any(|other_room_id| {
 			services
 				.rooms
 				.state_accessor
 				.room_state_get(other_room_id, &StateEventType::RoomEncryption, "")
-				.await
-				.is_ok()
+				.map(Result::into_is_ok)
 		})
 		.await
 }
@@ -1178,20 +1176,20 @@ pub(crate) async fn sync_events_v4_route(
 			.sync
 			.update_sync_request_with_cache(sender_user.clone(), sender_device.clone(), &mut body);
 
-	let all_joined_rooms = services
+	let all_joined_rooms: Vec<_> = services
 		.rooms
 		.state_cache
 		.rooms_joined(&sender_user)
 		.map(ToOwned::to_owned)
-		.collect::<Vec<_>>()
+		.collect()
 		.await;
 
-	let all_invited_rooms = services
+	let all_invited_rooms: Vec<_> = services
 		.rooms
 		.state_cache
 		.rooms_invited(&sender_user)
 		.map(|r| r.0)
-		.collect::<Vec<_>>()
+		.collect()
 		.await;
 
 	let all_rooms = all_joined_rooms
@@ -1364,15 +1362,13 @@ pub(crate) async fn sync_events_v4_route(
 								.rooms
 								.state_cache
 								.room_members(room_id)
-								.ready_filter(|user_id| {
-									// Don't send key updates from the sender to the sender
-									sender_user != user_id
-								})
-								.filter_map(|user_id| async move {
-									// Only send keys if the sender doesn't share an encrypted room with the target
-									// already
-									(!share_encrypted_room(&services, sender_user, user_id, Some(room_id)).await)
-										.then_some(user_id.to_owned())
+								// Don't send key updates from the sender to the sender
+								.ready_filter(|user_id| sender_user != user_id)
+								// Only send keys if the sender doesn't share an encrypted room with the target
+								// already
+								.filter_map(|user_id| {
+									share_encrypted_room(&services, sender_user, user_id, Some(room_id))
+										.map(|res| res.or_some(user_id.to_owned()))
 								})
 								.collect::<Vec<_>>()
 								.await,
@@ -1650,26 +1646,25 @@ pub(crate) async fn sync_events_v4_route(
 			.await;
 
 		// Heroes
-		let heroes = services
+		let heroes: Vec<_> = services
 			.rooms
 			.state_cache
 			.room_members(room_id)
 			.ready_filter(|member| member != &sender_user)
-			.filter_map(|member| async move {
+			.filter_map(|user_id| {
 				services
 					.rooms
 					.state_accessor
-					.get_member(room_id, member)
-					.await
-					.map(|memberevent| SlidingSyncRoomHero {
-						user_id: member.to_owned(),
+					.get_member(room_id, user_id)
+					.map_ok(|memberevent| SlidingSyncRoomHero {
+						user_id: user_id.into(),
 						name: memberevent.displayname,
 						avatar: memberevent.avatar_url,
 					})
 					.ok()
 			})
 			.take(5)
-			.collect::<Vec<_>>()
+			.collect()
 			.await;
 
 		let name = match heroes.len().cmp(&(1_usize)) {

src/api/client/user_directory.rs

@@ -1,4 +1,5 @@
 use axum::extract::State;
+use conduit::utils::TryFutureExtExt;
 use futures::{pin_mut, StreamExt};
 use ruma::{
 	api::client::user_directory::search_users,
@@ -56,16 +57,12 @@ pub(crate) async fn search_users_route(
 			.rooms
 			.state_cache
 			.rooms_joined(&user.user_id)
-			.any(|room| async move {
+			.any(|room| {
 				services
 					.rooms
 					.state_accessor
-					.room_state_get(room, &StateEventType::RoomJoinRules, "")
-					.await
-					.map_or(false, |event| {
-						serde_json::from_str(event.content.get())
-							.map_or(false, |r: RoomJoinRulesEventContent| r.join_rule == JoinRule::Public)
-					})
+					.room_state_get_content::<RoomJoinRulesEventContent>(room, &StateEventType::RoomJoinRules, "")
+					.map_ok_or(false, |content| content.join_rule == JoinRule::Public)
 			})
 			.await;