chore: cleanup

src/admin/room/commands.rs

@@ -96,32 +96,23 @@ pub(crate) enum RoomTargetOption {
 }
 
 #[admin_command]
-pub(super) async fn purge_empty_room_tokens(
+pub(super) async fn purge_all_sync_tokens(
 	&self,
-	yes: bool,
 	target_option: Option<RoomTargetOption>,
-	dry_run: bool,
+	execute: bool,
 ) -> Result {
 	use conduwuit::{debug, info};
 
-	if !yes && !dry_run {
-		return Err!(
-			"Please confirm this operation with --yes as it may delete tokens from many rooms, \
-			 or use --dry-run to simulate"
-		);
-	}
-
-	let mode = if dry_run { "Simulating" } else { "Starting" };
+	let mode = if !execute { "Simulating" } else { "Starting" };
 
 	// strictly, we should check if these reach the max value after the loop and
 	// warn the user that the count is too large
-	let mut total_rooms_processed: usize = 0;
-	let mut empty_rooms_processed: u32 = 0;
+	let mut total_rooms_checked: usize = 0;
 	let mut total_tokens_deleted: usize = 0;
 	let mut error_count: u32 = 0;
-	let mut skipped_rooms: u32 = 0;
+	let mut skipped_rooms: usize = 0;
 
-	info!("{} purge of sync tokens for rooms with no local users", mode);
+	info!("{} purge of sync tokens", mode);
 
 	// Get all rooms in the server
 	let all_rooms = self
@@ -169,33 +160,31 @@ pub(super) async fn purge_empty_room_tokens(
 
 	// Process each room
 	for room_id in rooms {
-		total_rooms_processed = total_rooms_processed.saturating_add(1);
+		total_rooms_checked = total_rooms_checked.saturating_add(1);
 
-		// Count local users in this room
-		let local_users_count = self
-			.services
-			.rooms
-			.state_cache
-			.local_users_in_room(room_id)
-			.count()
-			.await;
-
-		// Only process rooms with no local users
-		if local_users_count == 0 {
-			empty_rooms_processed = empty_rooms_processed.saturating_add(1);
+		// Log progress periodically
+		if total_rooms_checked % 100 == 0 || total_rooms_checked == total_rooms {
+			info!(
+				"Progress: {}/{} rooms checked, {} tokens {}",
+				total_rooms_checked,
+				total_rooms,
+				total_tokens_deleted,
+				if !execute { "would be deleted" } else { "deleted" }
+			);
+		}
 
 		// In dry run mode, just count what would be deleted, don't actually delete
 		debug!(
 			"Room {} has no local users, {}",
 			room_id,
-				if dry_run {
+			if !execute {
 				"would purge sync tokens"
 			} else {
 				"purging sync tokens"
 			}
 		);
 
-			if dry_run {
+		if !execute {
 			// For dry run mode, count tokens without deleting
 			match self.services.rooms.user.count_room_tokens(room_id).await {
 				| Ok(count) =>
@@ -226,45 +215,31 @@ pub(super) async fn purge_empty_room_tokens(
 				},
 			}
 		}
-		} else {
-			debug!("Room {} has {} local users, skipping", room_id, local_users_count);
 	}
 
-		// Log progress periodically
-		if total_rooms_processed % 100 == 0 || total_rooms_processed == total_rooms {
+	let action = if !execute { "would be deleted" } else { "deleted" };
 	info!(
-				"Progress: {}/{} rooms processed, {} empty rooms found, {} tokens {}",
-				total_rooms_processed,
-				total_rooms,
-				empty_rooms_processed,
-				total_tokens_deleted,
-				if dry_run { "would be deleted" } else { "deleted" }
-			);
-		}
-	}
-
-	let action = if dry_run { "would be deleted" } else { "deleted" };
-	info!(
-		"Finished {}: processed {} empty rooms out of {} total, {} tokens {}, errors: {}",
-		if dry_run {
+		"Finished {}: checked {} rooms out of {} total, {} tokens {}, errors: {}",
+		if !execute {
 			"purge simulation"
 		} else {
 			"purging sync tokens"
 		},
-		empty_rooms_processed,
+		total_rooms_checked,
 		total_rooms,
 		total_tokens_deleted,
 		action,
 		error_count
 	);
 
-	let mode_msg = if dry_run { "DRY RUN: " } else { "" };
 	self.write_str(&format!(
-		"{}Successfully processed {empty_rooms_processed} empty rooms (out of {total_rooms} \
-		 total rooms), {total_tokens_deleted} tokens {}. Skipped {skipped_rooms} rooms based on \
-		 filters. Failed for {error_count} rooms.",
-		mode_msg,
-		if dry_run { "would be deleted" } else { "deleted" }
+		"Finished {}: checked {} rooms out of {} total, {} tokens {}, errors: {}",
+		if !execute { "simulation" } else { "purging sync tokens" },
+		total_rooms_checked,
+		total_rooms,
+		total_tokens_deleted,
+		action,
+		error_count
 	))
 	.await
 }

src/admin/room/mod.rs

@@ -68,17 +68,14 @@ pub(super) enum RoomCommand {
 	/// - Delete sync tokens for all rooms that have no local users
 	///
 	/// By default, processes all empty rooms.
-	PurgeEmptyRoomTokens {
-		/// Confirm you want to delete tokens from potentially many rooms
-		#[arg(long)]
-		yes: bool,
-
+	PurgeAllSyncTokens {
 		/// Target specific room types
 		#[arg(long, value_enum)]
 		target_option: Option<RoomTargetOption>,
 
-		/// Perform a dry run without actually deleting any tokens
+		/// Execute token deletions. Otherwise,
+		/// Performs a dry run without actually deleting any tokens
 		#[arg(long)]
-		dry_run: bool,
+		execute: bool,
 	},
 }