Introduce OptionFuture helpers

Optimize user directory searches

src/service/membership/join.rs

@@ -8,7 +8,7 @@ use std::{
 
 use futures::{
 	FutureExt, StreamExt, TryFutureExt, TryStreamExt,
-	future::{OptionFuture, join3, join4},
+	future::{join3, join4},
 };
 use ruma::{
 	CanonicalJsonObject, CanonicalJsonValue, OwnedEventId, OwnedServerName, OwnedUserId, RoomId,
@@ -31,7 +31,7 @@ use tuwunel_core::{
 	matrix::{event::gen_event_id_canonical_json, room_version},
 	pdu::{PduBuilder, format::from_incoming_federation},
 	state_res, trace,
-	utils::{self, IterStream, ReadyExt, future::TryExtExt, math::Expected, shuffle},
+	utils::{self, BoolExt, IterStream, ReadyExt, future::TryExtExt, math::Expected, shuffle},
 	warn,
 };
 
@@ -544,25 +544,23 @@ pub async fn join_local(
 		})
 		.await;
 
-	let join_authorized_via_users_server: OptionFuture<_> = is_joined_restricted_rooms
-		.then(async || {
-			self.services
-				.state_cache
-				.local_users_in_room(room_id)
-				.filter(|user| {
-					self.services.state_accessor.user_can_invite(
-						room_id,
-						user,
-						sender_user,
-						state_lock,
-					)
-				})
-				.map(ToOwned::to_owned)
-				.boxed()
-				.next()
-				.await
-		})
-		.into();
+	let join_authorized_via_users_server = is_joined_restricted_rooms.then_async(async || {
+		self.services
+			.state_cache
+			.local_users_in_room(room_id)
+			.filter(|user| {
+				self.services.state_accessor.user_can_invite(
+					room_id,
+					user,
+					sender_user,
+					state_lock,
+				)
+			})
+			.map(ToOwned::to_owned)
+			.boxed()
+			.next()
+			.await
+	});
 
 	let displayname = self.services.users.displayname(sender_user).ok();
 

src/service/presence/mod.rs

@@ -4,19 +4,17 @@ mod presence;
 use std::{collections::HashMap, sync::Arc, time::Duration};
 
 use async_trait::async_trait;
-use futures::{
-	Stream, StreamExt, TryFutureExt,
-	future::{OptionFuture, try_join},
-	stream::FuturesUnordered,
-};
+use futures::{Stream, StreamExt, TryFutureExt, future::try_join, stream::FuturesUnordered};
 use loole::{Receiver, Sender};
 use ruma::{
 	DeviceId, OwnedUserId, UInt, UserId, events::presence::PresenceEvent, presence::PresenceState,
 };
 use tokio::{sync::RwLock, time::sleep};
 use tuwunel_core::{
-	Error, Result, checked, debug, debug_warn, error, result::LogErr, trace,
-	utils::future::OptionExt,
+	Error, Result, checked, debug, debug_warn, error,
+	result::LogErr,
+	trace,
+	utils::{future::OptionFutureExt, option::OptionExt},
 };
 
 use self::{data::Data, presence::Presence};
@@ -164,13 +162,11 @@ impl Service {
 			return Ok(());
 		}
 
-		let update_device_seen: OptionFuture<_> = device_id
-			.map(|device_id| {
-				self.services
-					.users
-					.update_device_last_seen(user_id, device_id, None)
-			})
-			.into();
+		let update_device_seen = device_id.map_async(|device_id| {
+			self.services
+				.users
+				.update_device_last_seen(user_id, device_id, None)
+		});
 
 		let status_msg = match last_presence {
 			| Ok((_, ref presence)) => presence.content.status_msg.clone(),

src/service/pusher/append.rs

@@ -1,9 +1,6 @@
 use std::{collections::HashSet, sync::Arc};
 
-use futures::{
-	FutureExt, StreamExt,
-	future::{OptionFuture, join},
-};
+use futures::{FutureExt, StreamExt, future::join};
 use ruma::{
 	RoomId, UserId,
 	api::client::push::ProfileTag,
@@ -111,13 +108,11 @@ pub(crate) async fn append_pdu(&self, pdu_id: RawPduId, pdu: &Pdu) -> Result {
 			.iter()
 			.any(|action| matches!(action, Action::SetTweak(Tweak::Highlight(true))));
 
-		let increment_notify: OptionFuture<_> = notify
-			.then(|| self.increment_notificationcount(pdu.room_id(), user))
-			.into();
+		let increment_notify =
+			notify.then_async(|| self.increment_notificationcount(pdu.room_id(), user));
 
-		let increment_highlight: OptionFuture<_> = highlight
-			.then(|| self.increment_highlightcount(pdu.room_id(), user))
-			.into();
+		let increment_highlight =
+			highlight.then_async(|| self.increment_highlightcount(pdu.room_id(), user));
 
 		join(increment_notify, increment_highlight).await;
 

src/service/rooms/event_handler/handle_incoming_pdu.rs

@@ -1,7 +1,4 @@
-use futures::{
-	FutureExt, TryFutureExt, TryStreamExt,
-	future::{OptionFuture, try_join5},
-};
+use futures::{FutureExt, TryFutureExt, TryStreamExt, future::try_join5};
 use ruma::{CanonicalJsonObject, EventId, RoomId, ServerName, UserId, events::StateEventType};
 use tuwunel_core::{
 	Err, Result, debug,
@@ -9,7 +6,7 @@ use tuwunel_core::{
 	err, implement,
 	matrix::{Event, room_version},
 	trace,
-	utils::stream::IterStream,
+	utils::{BoolExt, stream::IterStream},
 	warn,
 };
 
@@ -83,11 +80,10 @@ pub async fn handle_incoming_pdu<'a>(
 		.try_into()
 		.map_err(|e| err!(Request(InvalidParam("PDU does not have a valid sender key: {e}"))))?;
 
-	let sender_acl_check: OptionFuture<_> = sender
+	let sender_acl_check = sender
 		.server_name()
 		.ne(origin)
-		.then(|| self.acl_check(sender.server_name(), room_id))
-		.into();
+		.then_async(|| self.acl_check(sender.server_name(), room_id));
 
 	// Fetch create event
 	let create_event =

src/service/rooms/event_handler/state_at_incoming.rs

@@ -3,16 +3,16 @@ use std::{
 	iter::{Iterator, once},
 };
 
-use futures::{
-	FutureExt, StreamExt, TryFutureExt, TryStreamExt,
-	future::{OptionFuture, try_join},
-};
+use futures::{FutureExt, StreamExt, TryFutureExt, TryStreamExt, future::try_join};
 use ruma::{OwnedEventId, RoomId, RoomVersionId};
 use tuwunel_core::{
 	Result, apply, err, implement,
 	matrix::{Event, StateMap, state_res::AuthSet},
 	ref_at, trace,
-	utils::stream::{BroadbandExt, IterStream, ReadyExt, TryBroadbandExt, TryWidebandExt},
+	utils::{
+		option::OptionExt,
+		stream::{BroadbandExt, IterStream, ReadyExt, TryBroadbandExt, TryWidebandExt},
+	},
 };
 
 use crate::rooms::short::ShortStateHash;
@@ -174,16 +174,15 @@ async fn state_at_incoming_fork<Pdu>(
 where
 	Pdu: Event,
 {
-	let leaf: OptionFuture<_> = prev_event
+	let leaf = prev_event
 		.state_key()
-		.map(async |state_key| {
+		.map_async(async |state_key| {
 			self.services
 				.short
 				.get_or_create_shortstatekey(&prev_event.kind().to_cow_str().into(), state_key)
 				.map(|shortstatekey| once((shortstatekey, prev_event.event_id().to_owned())))
 				.await
-		})
-		.into();
+		});
 
 	let leaf_state_after_event: Vec<_> = self
 		.services

src/service/rooms/state_cache/mod.rs

@@ -6,11 +6,7 @@ use std::{
 	sync::{Arc, RwLock},
 };
 
-use futures::{
-	Stream, StreamExt,
-	future::{OptionFuture, join5},
-	pin_mut,
-};
+use futures::{Stream, StreamExt, future::join5, pin_mut};
 use ruma::{
 	OwnedRoomId, RoomId, ServerName, UserId,
 	events::{AnyStrippedStateEvent, AnySyncStateEvent, room::member::MembershipState},
@@ -21,6 +17,7 @@ use tuwunel_core::{
 	result::LogErr,
 	trace,
 	utils::{
+		BoolExt,
 		future::OptionStream,
 		stream::{BroadbandExt, ReadyExt, TryIgnore},
 	},
@@ -411,45 +408,41 @@ pub fn user_memberships<'a>(
 	use MembershipState::*;
 	use futures::stream::select;
 
-	let joined: OptionFuture<_> = mask
+	let joined = mask
 		.is_none_or(|mask| mask.contains(&Join))
-		.then(|| {
+		.then_async(|| {
 			self.rooms_joined(user_id)
 				.map(|room_id| (Join, room_id))
 				.boxed()
 				.into_future()
-		})
-		.into();
+		});
 
-	let invited: OptionFuture<_> = mask
+	let invited = mask
 		.is_none_or(|mask| mask.contains(&Invite))
-		.then(|| {
+		.then_async(|| {
 			self.rooms_invited(user_id)
 				.map(|room_id| (Invite, room_id))
 				.boxed()
 				.into_future()
-		})
-		.into();
+		});
 
-	let knocked: OptionFuture<_> = mask
+	let knocked = mask
 		.is_none_or(|mask| mask.contains(&Knock))
-		.then(|| {
+		.then_async(|| {
 			self.rooms_knocked(user_id)
 				.map(|room_id| (Knock, room_id))
 				.boxed()
 				.into_future()
-		})
-		.into();
+		});
 
-	let left: OptionFuture<_> = mask
+	let left = mask
 		.is_none_or(|mask| mask.contains(&Leave))
-		.then(|| {
+		.then_async(|| {
 			self.rooms_left(user_id)
 				.map(|room_id| (Leave, room_id))
 				.boxed()
 				.into_future()
-		})
-		.into();
+		});
 
 	select(
 		select(joined.stream(), left.stream()),

src/service/sending/sender.rs

@@ -11,7 +11,7 @@ use std::{
 use base64::{Engine as _, engine::general_purpose::URL_SAFE_NO_PAD};
 use futures::{
 	FutureExt, StreamExt, TryFutureExt,
-	future::{BoxFuture, OptionFuture, join3, try_join3},
+	future::{BoxFuture, join3, try_join3},
 	pin_mut,
 	stream::FuturesUnordered,
 };
@@ -43,7 +43,7 @@ use tuwunel_core::{
 	result::LogErr,
 	trace,
 	utils::{
-		ReadyExt, calculate_hash, continue_exponential_backoff_secs,
+		BoolExt, ReadyExt, calculate_hash, continue_exponential_backoff_secs,
 		future::TryExtExt,
 		stream::{BroadbandExt, IterStream, WidebandExt},
 	},
@@ -388,19 +388,17 @@ impl Service {
 		let device_changes =
 			self.select_edus_device_changes(server_name, batch, &max_edu_count, &events_len);
 
-		let receipts: OptionFuture<_> = self
+		let receipts = self
 			.server
 			.config
 			.allow_outgoing_read_receipts
-			.then(|| self.select_edus_receipts(server_name, batch, &max_edu_count))
-			.into();
+			.then_async(|| self.select_edus_receipts(server_name, batch, &max_edu_count));
 
-		let presence: OptionFuture<_> = self
+		let presence = self
 			.server
 			.config
 			.allow_outgoing_presence
-			.then(|| self.select_edus_presence(server_name, batch, &max_edu_count))
-			.into();
+			.then_async(|| self.select_edus_presence(server_name, batch, &max_edu_count));
 
 		let (device_changes, receipts, presence) =
 			join3(device_changes, receipts, presence).await;