chore(deps): update https://github.com/softprops/action-gh-release action to v3

.forgejo/workflows/release-image.yml

@@ -216,7 +216,7 @@ jobs:
           path: binaries
           merge-multiple: true
       - name: Create Release and Upload
-        uses: https://github.com/softprops/action-gh-release@v2
+        uses: https://github.com/softprops/action-gh-release@b4309332981a82ec1c5618f44dd2e27cc8bfbfda # v3
         with:
           draft: true
           files: binaries/*

Cargo.lock

@@ -981,7 +981,7 @@ dependencies = [
  "opentelemetry-otlp",
  "opentelemetry_sdk",
  "parking_lot",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "rustls",
  "sentry",
  "sentry-tower",
@@ -1045,7 +1045,7 @@ dependencies = [
  "lettre",
  "log",
  "rand 0.10.1",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "ruma",
  "ruminuwuity",
  "serde",
@@ -1106,7 +1106,7 @@ dependencies = [
  "rand 0.10.1",
  "rand_core 0.6.4",
  "regex",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "ruma",
  "sanitize-filename",
  "serde",
@@ -1230,7 +1230,7 @@ dependencies = [
  "recaptcha-verify",
  "regex",
  "reqwest 0.12.28",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "ruma",
  "ruminuwuity",
  "rustyline-async",
@@ -4567,9 +4567,9 @@ dependencies = [
 
 [[package]]
 name = "reqwest"
-version = "0.13.2"
+version = "0.13.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab3f43e3283ab1488b624b44b0e988d0acea0b3214e694730a055cb6b2efa801"
+checksum = "62e0021ea2c22aed41653bc7e1419abb2c97e038ff2c33d0e1309e49a97deec0"
 dependencies = [
  "base64 0.22.1",
  "bytes",
@@ -4918,9 +4918,9 @@ dependencies = [
 
 [[package]]
 name = "rustls"
-version = "0.23.39"
+version = "0.23.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c2c118cb077cca2822033836dfb1b975355dfb784b5e8da48f7b6c5db74e60e"
+checksum = "ef86cd5876211988985292b91c96a8f2d298df24e75989a43a3c73f2d4d8168b"
 dependencies = [
  "aws-lc-rs",
  "log",
@@ -5113,7 +5113,7 @@ checksum = "eb25f439f97d26fea01d717fa626167ceffcd981addaa670001e70505b72acbb"
 dependencies = [
  "cfg_aliases",
  "httpdate",
- "reqwest 0.13.2",
+ "reqwest 0.13.3",
  "sentry-backtrace",
  "sentry-contexts",
  "sentry-core",
@@ -5256,7 +5256,7 @@ checksum = "75e214449d107a81daf1453eb46c9314457660509534883e82db6faca2034a8a"
 dependencies = [
  "ahash",
  "annotate-snippets",
- "base64 0.22.1",
+ "base64 0.21.7",
  "encoding_rs_io",
  "getrandom 0.3.4",
  "nohash-hasher",

changelog.d/+48bfd52a.bugfix.md

@@ -0,0 +1 @@
+The invite recipient's membership event is now included in invite stripped state, which should fix flaky invite display in some clients. Contributed by @ginger

src/admin/room/moderation.rs

@@ -1,9 +1,9 @@
 use api::client::leave_room;
 use clap::Subcommand;
 use conduwuit::{
-	debug, info, utils::{IterStream, ReadyExt}, warn,
-	Err,
-	Result,
+	Err, Result, debug, info,
+	utils::{IterStream, ReadyExt},
+	warn,
 };
 use futures::{FutureExt, StreamExt};
 use ruma::{OwnedRoomId, OwnedRoomOrAliasId, RoomAliasId, RoomId, RoomOrAliasId};
@@ -43,12 +43,6 @@ pub enum RoomModerationCommand {
 		/// information
 		no_details: bool,
 	},
-
-	/// Deletes a room
-	Delete {
-		/// The room ID
-		room_id: OwnedRoomId,
-	},
 }
 
 #[admin_command]
@@ -458,62 +452,3 @@ async fn list_banned_rooms(&self, no_details: bool) -> Result {
 	self.write_str(&format!("Rooms Banned ({num}):\n```\n{body}\n```"))
 		.await
 }
-
-#[admin_command]
-async fn delete(&self, room_id: OwnedRoomId) -> Result {
-	let is_banned = self.services.rooms.metadata.is_banned(&room_id).await;
-	let is_disabled = self.services.rooms.metadata.is_disabled(&room_id).await;
-
-	// Temporarily forcefully ban the room to prevent people trying to join while
-	// deletion is ongoing.
-	self.services.rooms.metadata.disable_room(&room_id, true);
-	self.services.rooms.metadata.ban_room(&room_id, true);
-
-	let mut users = self
-		.services
-		.rooms
-		.state_cache
-		.room_members(&room_id)
-		.ready_filter(|user| self.services.globals.user_is_local(user))
-		.boxed();
-
-	while let Some(ref user_id) = users.next().await {
-		info!("Removing {user_id} from {room_id}",);
-
-		if let Err(e) = leave_room(self.services, user_id, &room_id, None)
-			.boxed()
-			.await
-		{
-			warn!("Failed to remove {user_id} from {room_id}: {e}");
-		}
-
-		self.services.rooms.state_cache.forget(&room_id, user_id);
-	}
-
-	self.services
-		.rooms
-		.alias
-		.local_aliases_for_room(&room_id)
-		.for_each(|local_alias| async move {
-			info!("Removing alias {local_alias}");
-			self.services
-				.rooms
-				.alias
-				.remove_alias(&local_alias, &self.services.globals.server_user)
-				.await
-				.ok();
-		})
-		.await;
-
-	info!("Removing the room from the directory if it is present");
-	self.services.rooms.directory.set_not_public(&room_id);
-	info!("Removing lazy-loading metadata");
-	self.services.rooms.lazy_loading.purge(&room_id).await;
-	info!("Removing PDU metadata");
-	self.services.rooms.pdu_metadata.purge(&room_id).await;
-	info!("Removing state cache");
-	self.services.rooms.state_cache.purge(&room_id).await;
-	info!("Removing room state");
-	self.services.rooms.state.purge(&room_id).await;
-	Ok(())
-}

src/api/client/media.rs

@@ -118,9 +118,8 @@ pub(crate) async fn get_content_thumbnail_route(
 	} = match fetch_thumbnail_meta(&services, &mxc, user, body.timeout_ms, &dim).await {
 		| Ok(meta) => meta,
 		| Err(conduwuit::Error::Io(e)) => match e.kind() {
-			| std::io::ErrorKind::NotFound => {
-				return Err!(Request(NotFound("Thumbnail not found.")));
-			},
+			| std::io::ErrorKind::NotFound =>
+				return Err!(Request(NotFound("Thumbnail not found."))),
 			| std::io::ErrorKind::PermissionDenied => {
 				error!("Permission denied when trying to read file: {e:?}");
 				return Err!(Request(Unknown("Unknown error when fetching thumbnail.")));

src/api/client/membership/invite.rs

@@ -163,7 +163,11 @@ pub(crate) async fn invite_helper(
 				)
 				.await?;
 
-			let invite_room_state = services.rooms.state.summary_stripped(&pdu, room_id).await;
+			let invite_room_state = services
+				.rooms
+				.state
+				.summary_stripped(&pdu, room_id, recipient_user)
+				.await;
 
 			drop(state_lock);
 

src/api/client/state.rs

@@ -375,7 +375,7 @@ async fn allowed_to_send_state_event(
 				},
 			}
 		},
-		| StateEventType::RoomMember => {
+		| StateEventType::RoomMember =>
 			match json.deserialize_as_unchecked::<RoomMemberEventContent>() {
 				| Ok(mut membership_content) => {
 					let Ok(state_key) = UserId::parse(state_key) else {
@@ -434,8 +434,7 @@ async fn allowed_to_send_state_event(
 						 membership state: {e}"
 					)));
 				},
-			}
-		},
+			},
 		| _ => (),
 	}
 

src/api/client/well_known.rs

@@ -19,11 +19,10 @@ pub(crate) async fn well_known_client(
 ) -> Result<discover_homeserver::Response> {
 	let client_url = match services.config.well_known.client.as_ref() {
 		| Some(url) => url.to_string(),
-		| None => {
+		| None =>
 			return Err!(Request(NotFound(
 				"This server is not configured to serve well-known client information."
-			)));
-		},
+			))),
 	};
 
 	Ok(assign!(discover_homeserver::Response::new(HomeserverInfo::new(client_url)), {

src/api/router/auth.rs

@@ -89,9 +89,8 @@ async fn verify<B: AsRef<[u8]> + Sync>(
 				origin: Some(output.origin.clone()),
 				..Default::default()
 			}),
-			| Err(err) => {
-				Err!(Request(Unauthorized(warn!("Failed to verify X-Matrix header: {err}"))))
-			},
+			| Err(err) =>
+				Err!(Request(Unauthorized(warn!("Failed to verify X-Matrix header: {err}")))),
 		}
 	}
 }

src/api/server/make_join.rs

@@ -252,7 +252,7 @@ pub(crate) async fn user_can_perform_restricted_join(
 					return Ok(true);
 				}
 			},
-			| other if other.rule_type() == "fi.mau.spam_checker" => {
+			| other if other.rule_type() == "fi.mau.spam_checker" =>
 				return match services
 					.antispam
 					.meowlnir_accept_make_join(room_id.to_owned(), user_id.to_owned())
@@ -260,8 +260,7 @@ pub(crate) async fn user_can_perform_restricted_join(
 				{
 					| Ok(()) => Ok(true),
 					| Err(_) => Err!(Request(Forbidden("Antispam rejected join request."))),
-				};
-			},
+				},
 			| _ => {
 				// We don't recognise this join rule, so we cannot satisfy the request.
 				could_satisfy = false;

src/api/server/send_knock.rs

@@ -183,7 +183,7 @@ pub(crate) async fn create_knock_event_v1_route(
 	let knock_room_state = services
 		.rooms
 		.state
-		.summary_stripped(&pdu, &body.room_id)
+		.summary_stripped(&pdu, &body.room_id, &sender)
 		.await;
 
 	Ok(create_knock_event::v1::Response::new(knock_room_state))

src/service/admin/create.rs

@@ -160,10 +160,7 @@ pub async fn create_admin_room(services: &Services) -> Result {
 		.boxed()
 		.await?;
 
-	let room_topic = format!(
-		"Manage {} | Run commands prefixed with `!admin` | Run `!admin -h` for help | Documentation: https://continuwuity.org/",
-		services.config.server_name
-	);
+	let room_topic = format!("Manage {} | Run commands prefixed with `!admin` | Run `!admin -h` for help | Documentation: https://continuwuity.org/", services.config.server_name);
 	services
 		.rooms
 		.timeline

src/service/firstrun/mod.rs

@@ -312,9 +312,7 @@ pub fn print_first_run_banner(&self) {
 				 to open the console."
 			);
 		}
-		eprintln!(
-			"If you need assistance setting up your homeserver, make a Matrix account on another homeserver and join our chatroom: https://matrix.to/#/#continuwuity:continuwuity.org"
-		);
+		eprintln!("If you need assistance setting up your homeserver, make a Matrix account on another homeserver and join our chatroom: https://matrix.to/#/#continuwuity:continuwuity.org");
 
 		eprintln!("{}", "============".bold());
 	}

src/service/migrations.rs

@@ -802,7 +802,7 @@ async fn fix_local_invite_state(services: &Services) -> Result {
 				&& services.globals.user_is_local(&membership_event.sender) {
 
 				// build and save stripped state for their invite in the database
-				let stripped_state = services.rooms.state.summary_stripped(&membership_event, &room_id).await;
+				let stripped_state = services.rooms.state.summary_stripped(&membership_event, &room_id, &user_id).await;
 				userroomid_invitestate.put((&user_id, &room_id), Json(stripped_state));
 				fixed = fixed.saturating_add(1);
 			}

src/service/rooms/lazy_loading/mod.rs

@@ -67,17 +67,6 @@ pub async fn reset(&self, ctx: &Context<'_>) {
 		.await;
 }
 
-#[implement(Service)]
-pub async fn purge(&self, room_id: &RoomId) {
-	let prefix = (Interfix, Interfix, room_id, Interfix);
-	self.db
-		.lazyloadedids
-		.keys_prefix_raw(&prefix)
-		.ignore_err()
-		.ready_for_each(|key| self.db.lazyloadedids.remove(key))
-		.await;
-}
-
 /// Returns only the subset of `senders` which should be sent to the client
 /// according to the provided lazy loading context.
 #[implement(Service)]

src/service/rooms/pdu_metadata/data.rs

@@ -9,7 +9,7 @@
 		u64_from_u8,
 	},
 };
-use database::{Interfix, Map};
+use database::Map;
 use futures::{Stream, StreamExt};
 use ruma::{EventId, RoomId, UserId, api::Direction};
 
@@ -46,16 +46,6 @@ pub(super) fn new(args: &crate::Args<'_>) -> Self {
 		}
 	}
 
-	pub(super) async fn purge(&self, room_id: &RoomId) {
-		// NOTE: This does not remove soft-failed event references, that must be done
-		// somewhere else.
-		self.referencedevents
-			.keys_prefix_raw(&(room_id, Interfix))
-			.ignore_err()
-			.ready_for_each(|key| self.referencedevents.remove(key))
-			.await;
-	}
-
 	pub(super) fn add_relation(&self, from: u64, to: u64) {
 		const BUFSIZE: usize = size_of::<u64>() * 2;
 
@@ -131,8 +121,4 @@ pub(super) fn mark_event_soft_failed(&self, event_id: &EventId) {
 	pub(super) async fn is_event_soft_failed(&self, event_id: &EventId) -> bool {
 		self.softfailedeventids.get(event_id).await.is_ok()
 	}
-
-	pub(super) async fn remove_soft_fail_marker(&self, event_id: &EventId) {
-		self.softfailedeventids.remove(event_id);
-	}
 }

src/service/rooms/pdu_metadata/mod.rs

@@ -140,10 +140,4 @@ pub fn mark_event_soft_failed(&self, event_id: &EventId) {
 	pub async fn is_event_soft_failed(&self, event_id: &EventId) -> bool {
 		self.db.is_event_soft_failed(event_id).await
 	}
-
-	pub async fn purge(&self, room_id: &RoomId) { self.db.purge(room_id).await; }
-
-	pub async fn remove_soft_fail_marker(&self, event_id: &EventId) {
-		self.db.remove_soft_fail_marker(event_id).await;
-	}
 }

src/service/rooms/read_receipt/data.rs

@@ -115,12 +115,4 @@ pub(super) async fn last_privateread_update(
 			.deserialized()
 			.unwrap_or(0)
 	}
-
-	pub(super) async fn purge(&self, room_id: &RoomId) {
-		self.readreceiptid_readreceipt
-			.keys_prefix_raw(room_id)
-			.ignore_err()
-			.ready_for_each(|key| self.readreceiptid_readreceipt.remove(key))
-			.await;
-	}
 }

src/service/rooms/read_receipt/mod.rs

@@ -142,8 +142,6 @@ pub async fn private_read_get_count(
 	pub async fn last_privateread_update(&self, user_id: &UserId, room_id: &RoomId) -> u64 {
 		self.db.last_privateread_update(user_id, room_id).await
 	}
-
-	pub async fn purge(&self, room_id: &RoomId) { self.db.purge(room_id).await }
 }
 
 #[must_use]

src/service/rooms/state/mod.rs

@@ -3,32 +3,32 @@
 use async_trait::async_trait;
 use conduwuit::debug;
 use conduwuit_core::{
-	err, result::FlatOk, state_res::{self, StateMap}, utils::{
-		calculate_hash, stream::{BroadbandExt, TryIgnore}, IterStream, MutexMap, MutexMapGuard,
-		ReadyExt,
+	Event, PduEvent, Result, err,
+	result::FlatOk,
+	state_res::{self, StateMap},
+	utils::{
+		IterStream, MutexMap, MutexMapGuard, ReadyExt, calculate_hash,
+		stream::{BroadbandExt, TryIgnore},
 	},
 	warn,
-	Event,
-	PduEvent,
-	Result,
 };
 use conduwuit_database::{Deserialized, Ignore, Interfix, Map};
 use futures::{
-	future::join_all, pin_mut, FutureExt, Stream, StreamExt, TryFutureExt, TryStreamExt,
+	FutureExt, Stream, StreamExt, TryFutureExt, TryStreamExt, future::join_all, pin_mut,
 };
 use ruma::{
-	api::federation::membership::RawStrippedState, events::{room::create::RoomCreateEventContent, StateEventType, TimelineEventType}, room_version_rules::RoomVersionRules, EventId, OwnedEventId, OwnedRoomId,
-	RoomId,
-	RoomVersionId,
-	UserId,
+	EventId, OwnedEventId, OwnedRoomId, RoomId, RoomVersionId, UserId,
+	api::federation::membership::RawStrippedState,
+	events::{StateEventType, TimelineEventType, room::create::RoomCreateEventContent},
+	room_version_rules::RoomVersionRules,
 };
 
 use crate::{
-	globals, rooms, rooms::{
+	Dep, globals, rooms,
+	rooms::{
 		short::{ShortEventId, ShortStateHash},
-		state_compressor::{parse_compressed_state_event, CompressedState},
+		state_compressor::{CompressedState, parse_compressed_state_event},
 	},
-	Dep,
 };
 
 pub struct Service {
@@ -89,25 +89,6 @@ fn name(&self) -> &str { crate::service::make_name(std::module_path!()) }
 }
 
 impl Service {
-	pub async fn purge(&self, room_id: &RoomId) {
-		self.db.roomid_pduleaves
-			.keys_prefix_raw(room_id)
-			.ignore_err()
-			.ready_for_each(|k| self.db.roomid_pduleaves.remove(k))
-			.await;
-		let mut shortstatehashes = self.db.roomid_shortstatehash
-			.keys_prefix_raw(room_id)
-			.ignore_err();
-		while let Some(key) = shortstatehashes.next().await {
-			self.db.shorteventid_shortstatehash
-				.keys_prefix_raw(&(Interfix, key))
-				.ignore_err()
-				.ready_for_each(|key| self.db.shorteventid_shortstatehash.remove(key))
-				.await;
-			self.db.roomid_shortstatehash.remove(key);
-		};
-	}
-
 	/// Set the room to the given statehash and update caches.
 	pub async fn force_state(
 		&self,
@@ -319,12 +300,13 @@ pub async fn summary_stripped<'a, E>(
 		&self,
 		event: &'a E,
 		room_id: &RoomId,
+		target_user: &UserId,
 	) -> Vec<RawStrippedState>
 	where
 		E: Event + Send + Sync,
 		&'a E: Event + Send,
 	{
-		let cells = [
+		let mut state_events = [
 			(&StateEventType::RoomCreate, ""),
 			(&StateEventType::RoomJoinRules, ""),
 			(&StateEventType::RoomCanonicalAlias, ""),
@@ -333,9 +315,14 @@ pub async fn summary_stripped<'a, E>(
 			(&StateEventType::RoomMember, event.sender().as_str()), // Add recommended events
 			(&StateEventType::RoomEncryption, ""),
 			(&StateEventType::RoomTopic, ""),
-		];
+		]
+		.to_vec();
 
-		let fetches = cells.into_iter().map(|(event_type, state_key)| {
+		if target_user != event.sender() {
+			state_events.push((&StateEventType::RoomMember, target_user.as_str()));
+		}
+
+		let fetches = state_events.into_iter().map(|(event_type, state_key)| {
 			self.services
 				.state_accessor
 				.room_state_get(room_id, event_type, state_key)

src/service/rooms/state_cache/mod.rs

@@ -4,21 +4,20 @@
 use std::{collections::HashMap, sync::Arc};
 
 use conduwuit::{
-	implement, result::LogErr, utils::{stream::TryIgnore, ReadyExt}, warn,
-	Pdu,
-	Result,
-	SyncRwLock,
+	Pdu, Result, SyncRwLock, implement,
+	result::LogErr,
+	utils::{ReadyExt, stream::TryIgnore},
+	warn,
 };
 use database::{Deserialized, Ignore, Interfix, Map};
-use futures::{future::join5, pin_mut, Stream, StreamExt};
+use futures::{Stream, StreamExt, future::join5, pin_mut};
 use ruma::{
-	events::{room::member::MembershipState, AnyStrippedStateEvent}, serde::Raw, OwnedRoomId, OwnedServerName, OwnedUserId, RoomId,
-	ServerName,
-	UserId,
+	OwnedRoomId, OwnedServerName, OwnedUserId, RoomId, ServerName, UserId,
+	events::{AnyStrippedStateEvent, room::member::MembershipState},
+	serde::Raw,
 };
-use tokio::join;
 
-use crate::{account_data, appservice::RegistrationInfo, config, globals, rooms, users, Dep};
+use crate::{Dep, account_data, appservice::RegistrationInfo, config, globals, rooms, users};
 
 pub struct Service {
 	appservice_in_room_cache: AppServiceInRoomCache,
@@ -94,90 +93,6 @@ fn build(args: crate::Args<'_>) -> Result<Arc<Self>> {
 	fn name(&self) -> &str { crate::service::make_name(std::module_path!()) }
 }
 
-#[implement(Service)]
-#[tracing::instrument(skip(self))]
-pub async fn purge(&self, room_id: &RoomId) {
-	let roomuser_key = (room_id, Interfix);
-	let userroom_key = (Interfix, room_id);
-	join!(
-		self.db
-			.roomid_invitedcount
-			.keys_prefix_raw(room_id)
-			.ignore_err()
-			.ready_for_each(|key| self.db.roomid_invitedcount.remove(key)),
-		self.db
-			.roomid_inviteviaservers
-			.keys_prefix_raw(room_id)
-			.ignore_err()
-			.ready_for_each(|key| self.db.roomid_inviteviaservers.remove(key)),
-		self.db
-			.roomid_joinedcount
-			.keys_prefix_raw(room_id)
-			.ignore_err()
-			.ready_for_each(|key| self.db.roomid_joinedcount.remove(key)),
-		self.db
-			.roomserverids
-			.keys_prefix_raw(room_id)
-			.ignore_err()
-			.ready_for_each(|key| self.db.roomserverids.remove(key)),
-		self.db
-			.roomuserid_invitecount
-			.keys_prefix_raw(&roomuser_key)
-			.ignore_err()
-			.ready_for_each(|key| self.db.roomuserid_invitecount.remove(key)),
-		self.db
-			.roomuserid_joined
-			.keys_prefix_raw(&roomuser_key)
-			.ignore_err()
-			.ready_for_each(|key| self.db.roomuserid_joined.remove(key)),
-		self.db
-			.roomuserid_leftcount
-			.keys_prefix_raw(&roomuser_key)
-			.ignore_err()
-			.ready_for_each(|key| self.db.roomuserid_leftcount.remove(key)),
-		self.db
-			.roomuserid_knockedcount
-			.keys_prefix_raw(&roomuser_key)
-			.ignore_err()
-			.ready_for_each(|key| self.db.roomuserid_knockedcount.remove(key)),
-		self.db
-			.roomuseroncejoinedids
-			.keys_prefix_raw(room_id)
-			.ignore_err()
-			.ready_for_each(|key| self.db.roomuseroncejoinedids.remove(key)),
-		self.db
-			.userroomid_invitestate
-			.keys_prefix_raw(&userroom_key)
-			.ignore_err()
-			.ready_for_each(|key| self.db.userroomid_invitestate.remove(key)),
-		self.db
-			.userroomid_joined
-			.keys_prefix_raw(&userroom_key)
-			.ignore_err()
-			.ready_for_each(|key| self.db.userroomid_joined.remove(key)),
-		self.db
-			.userroomid_leftstate
-			.keys_prefix_raw(&userroom_key)
-			.ignore_err()
-			.ready_for_each(|key| self.db.userroomid_leftstate.remove(key)),
-		self.db
-			.userroomid_knockedstate
-			.keys_prefix_raw(&userroom_key)
-			.ignore_err()
-			.ready_for_each(|key| self.db.userroomid_knockedstate.remove(key)),
-		self.db
-			.userroomid_invitesender
-			.keys_prefix_raw(&userroom_key)
-			.ignore_err()
-			.ready_for_each(|key| self.db.userroomid_invitesender.remove(key)),
-		self.db
-			.serverroomids
-			.keys_prefix_raw(&(Interfix, room_id))
-			.ignore_err()
-			.ready_for_each(|key| self.db.serverroomids.remove(key)),
-	);
-}
-
 #[implement(Service)]
 #[tracing::instrument(level = "trace", skip_all)]
 pub async fn appservice_in_room(&self, room_id: &RoomId, appservice: &RegistrationInfo) -> bool {

src/service/rooms/state_cache/update.rs

@@ -119,7 +119,11 @@ pub async fn update_membership(
 			self.mark_as_joined(user_id, room_id);
 		},
 		| MembershipState::Invite => {
-			let last_state = self.services.state.summary_stripped(pdu, room_id).await;
+			let last_state = self
+				.services
+				.state
+				.summary_stripped(pdu, room_id, user_id)
+				.await;
 
 			self.mark_as_invited(user_id, room_id, pdu.sender(), last_state, None)
 				.await?;

src/service/sending/antispam.rs

@@ -54,9 +54,8 @@ pub(crate) async fn send_antispam_request<T>(
 	if !status.is_success() {
 		debug_error!("Antispam response bytes: {:?}", utils::string_from_bytes(&body));
 		return match status {
-			| http::StatusCode::FORBIDDEN => {
-				Err!(Request(Forbidden("Request was rejected by antispam service.",)))
-			},
+			| http::StatusCode::FORBIDDEN =>
+				Err!(Request(Forbidden("Request was rejected by antispam service.",))),
 			| _ => Err!(BadServerResponse(warn!(
 				"Antispam returned unsuccessful HTTP response {status}",
 			))),

src/service/uiaa/mod.rs

@@ -360,12 +360,11 @@ async fn check_stage(
 							));
 						}
 					},
-					| _ => {
+					| _ =>
 						return Err(StandardErrorBody::new(
 							ErrorKind::Unrecognized,
 							"Identifier type not recognized".to_owned(),
-						));
-					},
+						)),
 				};
 
 				let Ok(user_id) = UserId::parse_with_server_name(