fix: correct shebang for try-tag-and-release

fixes #392

.vscode/settings.json

@@ -1,6 +1,6 @@
 {
   "editor.formatOnSave": true,
-  "rust-analyzer.checkOnSave.command": "clippy",
+  "rust-analyzer.check.command": "clippy",
   "nixEnvSelector.suggestion": false,
   "nixEnvSelector.nixFile": "${workspaceFolder}/default.nix"
-}
+}

Cargo.toml

@@ -11,6 +11,8 @@ members = [
 
 [patch.crates-io]
 redis23 = { package = "redis", version = "0.23.3", git = "https://github.com/revoltchat/redis-rs", rev = "523b2937367e17bd0073722bf6e23d06042cb4e4" }
+#authifier = { package = "authifier", version = "1.0.10", path = "../authifier/crates/authifier" }
+#rocket_authifier = { package = "rocket_authifier", version = "1.0.10", path = "../authifier/crates/rocket_authifier" }
 
 # I'm 99% sure this is overloading the GitHub worker
 # hence builds have been failing since, let's just

README.md

@@ -114,7 +114,8 @@ If you'd like to change anything, create a `Revolt.overrides.toml` file and spec
 > And corresponding Revolt configuration:
 >
 > ```toml
-> # Revolt.overrides.toml
+> #     Revolt.overrides.toml
+> # and Revolt.test-overrides.toml
 > [database]
 > mongodb = "mongodb://127.0.0.1:14017"
 > redis = "redis://127.0.0.1:14079/"

compose.yml

@@ -34,7 +34,7 @@ services:
       - minio
     entrypoint: >
       /bin/sh -c "while ! /usr/bin/mc ready minio; do
-        /usr/bin/mc config host add minio http://minio:9000 minioautumn minioautumn;
+        /usr/bin/mc alias set minio http://minio:9000 minioautumn minioautumn;
         echo 'Waiting minio...' && sleep 1;
       done; /usr/bin/mc mb minio/revolt-uploads; exit 0;"
 

crates/bonfire/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-bonfire"
-version = "0.8.5"
+version = "0.8.8"
 license = "AGPL-3.0-or-later"
 edition = "2021"
 
@@ -36,12 +36,12 @@ async-std = { version = "1.8.0", features = [
 ] }
 
 # core
-authifier = { version = "1.0.13" }
+authifier = { version = "1.0.15" }
 revolt-result = { path = "../core/result" }
 revolt-models = { path = "../core/models" }
 revolt-config = { path = "../core/config" }
 revolt-database = { path = "../core/database" }
-revolt-permissions = { version = "0.8.5", path = "../core/permissions" }
+revolt-permissions = { version = "0.8.8", path = "../core/permissions" }
 revolt-presence = { path = "../core/presence", features = ["redis-is-patched"] }
 
 # redis

crates/bonfire/src/events/impl.rs

@@ -100,6 +100,18 @@ impl State {
         let user = self.clone_user();
         self.cache.is_bot = user.bot.is_some();
 
+        // Fetch pending policy changes.
+        let policy_changes = if user.bot.is_some() {
+            vec![]
+        } else {
+            db.fetch_policy_changes()
+                .await?
+                .into_iter()
+                .filter(|policy| policy.created_time > user.last_acknowledged_policy_change)
+                .map(Into::into)
+                .collect()
+        };
+
         // Find all relationships to the user.
         let mut user_ids: HashSet<String> = user
             .relations
@@ -175,7 +187,7 @@ impl State {
             .iter()
             .find(|e| matches!(e, ReadyPayloadFields::UserSettings(_)))
         {
-            Some(db.fetch_user_settings(&user.id, &keys).await?)
+            Some(db.fetch_user_settings(&user.id, keys).await?)
         } else {
             None
         };
@@ -199,12 +211,11 @@ impl State {
             .collect();
 
         // Make all users appear from our perspective.
-        let mut users: Vec<v0::User> = join_all(users
-            .into_iter()
-            .map(|other_user| async {
-                let is_online = online_ids.contains(&other_user.id);
-                other_user.into_known(&user, is_online).await
-            })).await;
+        let mut users: Vec<v0::User> = join_all(users.into_iter().map(|other_user| async {
+            let is_online = online_ids.contains(&other_user.id);
+            other_user.into_known(&user, is_online).await
+        }))
+        .await;
 
         // Make sure we see our own user correctly.
         users.push(user.into_self(true).await);
@@ -228,6 +239,7 @@ impl State {
         for channel in &channels {
             self.insert_subscription(channel.id().to_string()).await;
         }
+
         Ok(EventV1::Ready {
             users: if fields.contains(&ReadyPayloadFields::Users) {
                 Some(users)
@@ -253,6 +265,8 @@ impl State {
 
             user_settings,
             channel_unreads: channel_unreads.map(|vec| vec.into_iter().map(Into::into).collect()),
+
+            policy_changes,
         })
     }
 

crates/bonfire/src/websocket.rs

@@ -3,7 +3,7 @@ use std::{collections::HashSet, net::SocketAddr, sync::Arc};
 use async_tungstenite::WebSocketStream;
 use authifier::AuthifierEvent;
 use fred::{
-    error::{RedisError, RedisErrorKind},
+    error::RedisErrorKind,
     interfaces::{ClientLike, EventInterface, PubsubInterface},
     types::RedisConfig,
 };
@@ -17,6 +17,7 @@ use redis_kiss::{PayloadType, REDIS_PAYLOAD_TYPE, REDIS_URI};
 use revolt_config::report_internal_error;
 use revolt_database::{
     events::{client::EventV1, server::ClientMessage},
+    iso8601_timestamp::Timestamp,
     Database, User, UserHint,
 };
 use revolt_presence::{create_session, delete_session};
@@ -100,6 +101,10 @@ pub async fn client(db: &'static Database, stream: TcpStream, addr: SocketAddr)
 
     info!("User {addr:?} authenticated as @{}", user.username);
 
+    db.update_session_last_seen(&session_id, Timestamp::now_utc())
+        .await
+        .ok();
+
     // Create local state.
     let mut state = State::from(user, session_id);
     let user_id = state.cache.user_id.clone();

crates/core/config/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-config"
-version = "0.8.5"
+version = "0.8.8"
 edition = "2021"
 license = "MIT"
 authors = ["Paul Makles <me@insrt.uk>"]
@@ -9,9 +9,10 @@ description = "Revolt Backend: Configuration"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [features]
+anyhow = ["dep:sentry-anyhow"]
 report-macros = ["revolt-result"]
 test = ["async-std"]
-default = ["test"]
+default = ["test", "anyhow"]
 
 [dependencies]
 # Utility
@@ -32,6 +33,7 @@ pretty_env_logger = "0.4.0"
 
 # Sentry
 sentry = "0.31.5"
+sentry-anyhow = { version = "0.38.1", optional = true }
 
 # Core
-revolt-result = { version = "0.8.5", path = "../result", optional = true }
+revolt-result = { version = "0.8.8", path = "../result", optional = true }

crates/core/config/Revolt.toml

@@ -275,4 +275,5 @@ api = ""
 events = ""
 files = ""
 proxy = ""
+pushd = ""
 crond = ""

crates/core/config/src/lib.rs

@@ -7,6 +7,7 @@ use once_cell::sync::Lazy;
 use serde::Deserialize;
 
 pub use sentry::{capture_error, capture_message, Level};
+pub use sentry_anyhow::capture_anyhow;
 
 #[cfg(feature = "report-macros")]
 #[macro_export]
@@ -59,6 +60,9 @@ static CONFIG_SEARCH_PATHS: [&str; 3] = [
     "/Revolt.toml",
 ];
 
+/// Path to search for test overrides
+static TEST_OVERRIDE_PATH: &str = "Revolt.test-overrides.toml";
+
 /// Configuration builder
 static CONFIG_BUILDER: Lazy<RwLock<Config>> = Lazy::new(|| {
     RwLock::new({
@@ -72,6 +76,20 @@ static CONFIG_BUILDER: Lazy<RwLock<Config>> = Lazy::new(|| {
                 include_str!("../Revolt.test.toml"),
                 FileFormat::Toml,
             ));
+
+            // recursively search upwards for an overrides file (if there is one)
+            if let Ok(cwd) = std::env::current_dir() {
+                let mut path = Some(cwd.as_path());
+                while let Some(current_path) = path {
+                    let target_path = current_path.join(TEST_OVERRIDE_PATH);
+                    if target_path.exists() {
+                        builder = builder
+                            .add_source(File::new(target_path.to_str().unwrap(), FileFormat::Toml));
+                    }
+
+                    path = current_path.parent();
+                }
+            }
         }
 
         for path in CONFIG_SEARCH_PATHS {
@@ -343,6 +361,7 @@ pub struct Sentry {
     pub events: String,
     pub files: String,
     pub proxy: String,
+    pub pushd: String,
     pub crond: String,
 }
 
@@ -386,6 +405,11 @@ pub async fn read() -> Config {
 pub async fn config() -> Settings {
     let mut config = read().await.try_deserialize::<Settings>().unwrap();
 
+    // inject REDIS_URI for redis-kiss library
+    if std::env::var("REDIS_URL").is_err() {
+        std::env::set_var("REDIS_URI", config.database.redis.clone());
+    }
+
     // auto-detect production nodes
     if config.hosts.api.contains("https") && config.hosts.api.contains("revolt.chat") {
         config.production = true;
@@ -404,12 +428,6 @@ pub async fn setup_logging(release: &'static str, dsn: String) -> Option<sentry:
         std::env::set_var("ROCKET_ADDRESS", "0.0.0.0");
     }
 
-    if std::env::var("REDIS_URL").is_err() {
-        // Configure redis-kiss library
-        let config = config().await;
-        std::env::set_var("REDIS_URI", config.database.redis);
-    }
-
     pretty_env_logger::init();
     log::info!("Starting {release}");
 

crates/core/database/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-database"
-version = "0.8.5"
+version = "0.8.8"
 edition = "2021"
 license = "AGPL-3.0-or-later"
 authors = ["Paul Makles <me@insrt.uk>"]
@@ -24,19 +24,19 @@ default = ["mongodb", "async-std-runtime", "tasks"]
 
 [dependencies]
 # Core
-revolt-config = { version = "0.8.5", path = "../config", features = [
+revolt-config = { version = "0.8.8", path = "../config", features = [
     "report-macros",
 ] }
-revolt-result = { version = "0.8.5", path = "../result" }
-revolt-models = { version = "0.8.5", path = "../models", features = [
+revolt-result = { version = "0.8.8", path = "../result" }
+revolt-models = { version = "0.8.8", path = "../models", features = [
     "validator",
 ] }
-revolt-presence = { version = "0.8.5", path = "../presence" }
-revolt-permissions = { version = "0.8.5", path = "../permissions", features = [
+revolt-presence = { version = "0.8.8", path = "../presence" }
+revolt-permissions = { version = "0.8.8", path = "../permissions", features = [
     "serde",
     "bson",
 ] }
-revolt-parser = { version = "0.1.1", path = "../parser" }
+revolt-parser = { version = "0.8.8", path = "../parser" }
 
 # Utility
 log = "0.4"
@@ -97,7 +97,7 @@ web-push = "0.10.0"
 revolt_a2 = { version = "0.10", default-features = false, features = ["ring"] }
 
 # Authifier
-authifier = { version = "1.0.13", features = ["rocket_impl"] }
+authifier = { version = "1.0.15", features = ["rocket_impl"] }
 
 # RabbitMQ
 amqprs = { version = "1.7.0" }

crates/core/database/fixtures/group_with_members.json

@@ -3,18 +3,21 @@
     "_object_type": "User",
     "_id": "__ID:0__",
     "username": "Owner",
+    "last_acknowledged_policy_change": "2025-06-07T04:04:48+0000",
     "discriminator": "0001"
   },
   {
     "_object_type": "User",
     "_id": "__ID:1__",
     "username": "Member",
+    "last_acknowledged_policy_change": "2025-06-07T04:04:48+0000",
     "discriminator": "0001"
   },
   {
     "_object_type": "User",
     "_id": "__ID:2__",
     "username": "Member",
+    "last_acknowledged_policy_change": "2025-06-07T04:04:48+0000",
     "discriminator": "0002"
   },
   {
@@ -23,6 +26,9 @@
     "channel_type": "Group",
     "name": "My Group",
     "owner": "__ID:0__",
-    "recipients": ["__ID:0__", "__ID:1__"]
+    "recipients": [
+      "__ID:0__",
+      "__ID:1__"
+    ]
   }
-]
+]

crates/core/database/fixtures/server_with_roles.json

@@ -3,18 +3,21 @@
     "_object_type": "User",
     "_id": "__ID:0__",
     "username": "Owner",
+    "last_acknowledged_policy_change": "2025-06-07T04:04:48+0000",
     "discriminator": "0001"
   },
   {
     "_object_type": "User",
     "_id": "__ID:1__",
     "username": "Moderator",
+    "last_acknowledged_policy_change": "2025-06-07T04:04:48+0000",
     "discriminator": "0001"
   },
   {
     "_object_type": "User",
     "_id": "__ID:2__",
     "username": "User",
+    "last_acknowledged_policy_change": "2025-06-07T04:04:48+0000",
     "discriminator": "0001"
   },
   {
@@ -39,7 +42,9 @@
     "_id": "__ID:4__",
     "owner": "__ID:0__",
     "name": "Server",
-    "channels": ["__ID:3__"],
+    "channels": [
+      "__ID:3__"
+    ],
     "roles": {
       "__ID:5__": {
         "name": "Moderator",
@@ -47,7 +52,7 @@
           "a": 545270208,
           "d": 0
         },
-        "rank": 3
+        "rank": 1
       },
       "__ID:6__": {
         "name": "Owner",
@@ -66,7 +71,9 @@
       "user": "__ID:0__",
       "server": "__ID:4__"
     },
-    "roles": ["__ID:6__"],
+    "roles": [
+      "__ID:6__"
+    ],
     "joined_at": 1698318340195
   },
   {
@@ -75,7 +82,9 @@
       "user": "__ID:1__",
       "server": "__ID:4__"
     },
-    "roles": ["__ID:5__"],
+    "roles": [
+      "__ID:5__"
+    ],
     "joined_at": 1698318340195
   },
   {
@@ -86,4 +95,4 @@
     },
     "joined_at": 1698318340195
   }
-]
+]

crates/core/database/src/drivers/reference.rs

@@ -4,8 +4,8 @@ use futures::lock::Mutex;
 
 use crate::{
     Bot, Channel, ChannelCompositeKey, ChannelUnread, Emoji, File, FileHash, Invite, Member,
-    MemberCompositeKey, Message, RatelimitEvent, Report, Server, ServerBan, Snapshot, User,
-    UserSettings, Webhook,
+    MemberCompositeKey, Message, PolicyChange, RatelimitEvent, Report, Server, ServerBan, Snapshot,
+    User, UserSettings, Webhook,
 };
 
 database_derived!(
@@ -21,6 +21,7 @@ database_derived!(
         pub file_hashes: Arc<Mutex<HashMap<String, FileHash>>>,
         pub files: Arc<Mutex<HashMap<String, File>>>,
         pub messages: Arc<Mutex<HashMap<String, Message>>>,
+        pub policy_changes: Arc<Mutex<HashMap<String, PolicyChange>>>,
         pub ratelimit_events: Arc<Mutex<HashMap<String, RatelimitEvent>>>,
         pub user_settings: Arc<Mutex<HashMap<String, UserSettings>>>,
         pub users: Arc<Mutex<HashMap<String, User>>>,

crates/core/database/src/events/client.rs

@@ -6,7 +6,7 @@ use revolt_models::v0::{
     AppendMessage, Channel, ChannelUnread, Emoji, FieldsChannel, FieldsMember, FieldsMessage,
     FieldsRole, FieldsServer, FieldsUser, FieldsWebhook, Member, MemberCompositeKey, Message,
     PartialChannel, PartialMember, PartialMessage, PartialRole, PartialServer, PartialUser,
-    PartialWebhook, RemovalIntention, Report, Server, User, UserSettings, Webhook,
+    PartialWebhook, PolicyChange, RemovalIntention, Report, Server, User, UserSettings, Webhook,
 };
 
 use crate::Database;
@@ -62,6 +62,8 @@ pub enum EventV1 {
         user_settings: Option<UserSettings>,
         #[serde(skip_serializing_if = "Option::is_none")]
         channel_unreads: Option<Vec<ChannelUnread>>,
+
+        policy_changes: Vec<PolicyChange>,
     },
 
     /// Ping response
@@ -163,6 +165,9 @@ pub enum EventV1 {
     /// Server role deleted
     ServerRoleDelete { id: String, role_id: String },
 
+    /// Server roles ranks updated
+    ServerRoleRanksUpdate { id: String, ranks: Vec<String> },
+
     /// Update existing user
     UserUpdate {
         id: String,

crates/core/database/src/models/admin_migrations/ops/mongodb/init.rs

@@ -64,6 +64,10 @@ pub async fn create_database(db: &MongoDb) {
         .await
         .expect("Failed to create user_settings collection.");
 
+    db.create_collection("policy_changes")
+        .await
+        .expect("Failed to create policy_changes collection.");
+
     db.create_collection("safety_reports")
         .await
         .expect("Failed to create safety_reports collection.");

crates/core/database/src/models/admin_migrations/ops/mongodb/scripts.rs

@@ -1,14 +1,19 @@
-use std::{collections::HashSet, ops::BitXor, time::Duration};
+use std::{
+    collections::{HashMap, HashSet},
+    ops::BitXor,
+    time::Duration,
+};
 
 use crate::{
     mongodb::{
         bson::{doc, from_bson, from_document, to_document, Bson, DateTime, Document},
         options::FindOptions,
     },
-    AbstractChannels, AbstractServers, Channel, Invite, MongoDb, DISCRIMINATOR_SEARCH_SPACE,
+    AbstractChannels, AbstractServers, Channel, Invite, MongoDb, User, DISCRIMINATOR_SEARCH_SPACE,
 };
-use bson::oid::ObjectId;
+use bson::{oid::ObjectId, to_bson};
 use futures::StreamExt;
+use iso8601_timestamp::Timestamp;
 use rand::seq::SliceRandom;
 use revolt_permissions::DEFAULT_WEBHOOK_PERMISSIONS;
 use revolt_result::{Error, ErrorType};
@@ -21,7 +26,7 @@ struct MigrationInfo {
     revision: i32,
 }
 
-pub const LATEST_REVISION: i32 = 31;
+pub const LATEST_REVISION: i32 = 42; // MUST BE +1 to last migration
 
 pub async fn migrate_database(db: &MongoDb) {
     let migrations = db.col::<Document>("migrations");
@@ -1128,6 +1133,99 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
         }
     }
 
+    if revision <= 32 {
+        info!(
+            "Running migration [revision 32 / 12-05-2025]: (Authifier) Add last_seen to sessions."
+        );
+
+        let db = authifier::Database::MongoDb(authifier::database::MongoDb(db.db()));
+        db.run_migration(authifier::Migration::M2025_02_20AddLastSeenToSession)
+            .await
+            .unwrap();
+    }
+
+    if revision <= 40 {
+        info!(
+            "Running migration [revision |> 40 / 30-05-2025]: Set last policy acknowlegement date to now and create policy changes collection."
+        );
+
+        db.db()
+            .create_collection("policy_changes")
+            .await
+            .expect("Failed to create policy_changes collection.");
+
+        db.db()
+            .collection::<User>("users")
+            .update_many(
+                doc! {},
+                doc! {
+                    "$set": {
+                        "last_acknowledged_policy_change": to_bson(&Timestamp::now_utc())
+                            .expect("failed to serialise timestamp")
+                    }
+                },
+            )
+            .await
+            .expect("failed to update users");
+    }
+
+    if revision <= 41 {
+        info!(
+            "Running migration [revision 41 / 05-06-2025]: convert role ranks to uniform numbers."
+        );
+
+        #[derive(Serialize, Deserialize, Clone)]
+        struct Role {
+            pub rank: i64,
+        }
+
+        #[derive(Serialize, Deserialize, Clone)]
+        struct Server {
+            #[serde(rename = "_id")]
+            pub id: String,
+            #[serde(default = "HashMap::<String, Role>::new")]
+            pub roles: HashMap<String, Role>,
+        }
+
+        let mut servers = db
+            .db()
+            .collection::<Server>("servers")
+            .find(doc! {
+                "roles": {
+                    "$exists": true,
+                    "$ne": []
+                }
+            })
+            .await
+            .unwrap()
+            .filter_map(|s| async { s.ok() })
+            .boxed();
+
+        while let Some(server) = servers.next().await {
+            let mut ordered_roles = server.roles.clone().into_iter().collect::<Vec<_>>();
+            ordered_roles.sort_by(|(_, role_a), (_, role_b)| role_a.rank.cmp(&role_b.rank));
+            let ordered_roles = ordered_roles
+                .into_iter()
+                .map(|(id, _)| id)
+                .collect::<Vec<_>>();
+
+            let mut doc = doc! {};
+
+            for id in server.roles.keys() {
+                doc.insert(
+                    format!("roles.{id}.rank"),
+                    ordered_roles.iter().position(|x| id == x).unwrap() as i64,
+                );
+            }
+
+            db.db()
+                .collection::<Server>("servers")
+                .update_one(doc! { "_id": &server.id }, doc! { "$set": doc })
+                .await
+                .unwrap();
+        }
+    }
+
     // Reminder to update LATEST_REVISION when adding new migrations.
     LATEST_REVISION.max(revision)
 }

crates/core/database/src/models/bots/model.rs

@@ -1,4 +1,3 @@
-use revolt_config::config;
 use revolt_result::Result;
 use ulid::Ulid;
 

crates/core/database/src/models/channel_webhooks/model.rs

@@ -142,7 +142,7 @@ mod tests {
                 ..Default::default()
             };
 
-            db.insert_webhook(&webhook).await.unwrap();
+            webhook.create(&db).await.unwrap();
 
             let mut updated_webhook = webhook.clone();
             updated_webhook

crates/core/database/src/models/channels/model.rs

@@ -328,13 +328,10 @@ impl Channel {
 
             db.insert_channel(&channel).await?;
 
-            match &channel {
-                Channel::DirectMessage { .. } => {
-                    let event = EventV1::ChannelCreate(channel.clone().into());
-                    event.clone().private(user_a.id.clone()).await;
-                    event.private(user_b.id.clone()).await;
-                }
-                _ => {}
+            if let Channel::DirectMessage { .. } = &channel {
+                let event = EventV1::ChannelCreate(channel.clone().into());
+                event.clone().private(user_a.id.clone()).await;
+                event.private(user_b.id.clone()).await;
             };
 
             Ok(channel)

crates/core/database/src/models/file_hashes/model.rs

@@ -28,7 +28,7 @@ auto_derived_partial!(
         /// Size of this file (in bytes)
         pub size: isize,
     },
-    "PartialFile"
+    "PartialFileHash"
 );
 
 auto_derived!(

crates/core/database/src/models/messages/model.rs

@@ -5,7 +5,7 @@ use iso8601_timestamp::Timestamp;
 use revolt_config::{config, FeaturesLimits};
 use revolt_models::v0::{
     self, BulkMessageResponse, DataMessageSend, Embed, MessageAuthor, MessageFlags, MessageSort,
-    MessageWebhook, PushNotification, ReplyIntent, SendableEmbed, Text
+    MessageWebhook, PushNotification, ReplyIntent, SendableEmbed, Text,
 };
 use revolt_permissions::{calculate_channel_permissions, ChannelPermission, PermissionValue};
 use revolt_result::{ErrorType, Result};
@@ -286,9 +286,9 @@ impl Message {
             .map_err(|_| create_error!(InvalidOperation))?;
 
         // Check the message is not empty
-        if (data.content.as_ref().map_or(true, |v| v.is_empty()))
-            && (data.attachments.as_ref().map_or(true, |v| v.is_empty()))
-            && (data.embeds.as_ref().map_or(true, |v| v.is_empty()))
+        if (data.content.as_ref().is_none_or(|v| v.is_empty()))
+            && (data.attachments.as_ref().is_none_or(|v| v.is_empty()))
+            && (data.embeds.as_ref().is_none_or(|v| v.is_empty()))
         {
             return Err(create_error!(EmptyMessage));
         }
@@ -382,7 +382,7 @@ impl Message {
             mut user_mentions,
             mut role_mentions,
             mut mentions_everyone,
-            mut mentions_online
+            mut mentions_online,
         } = message_mentions;
 
         if allow_mass_mentions && server_id.is_some() && !role_mentions.is_empty() {
@@ -489,7 +489,9 @@ impl Message {
 
                     let valid_members = db.fetch_members(server.as_str(), &mentions_vec[..]).await;
                     if let Ok(valid_members) = valid_members {
-                        let valid_mentions = HashSet::<&String, RandomState>::from_iter(valid_members.iter().map(|m| &m.id.user));
+                        let valid_mentions = HashSet::<&String, RandomState>::from_iter(
+                            valid_members.iter().map(|m| &m.id.user),
+                        );
 
                         user_mentions.retain(|m| valid_mentions.contains(m)); // quick pass, validate mentions are in the server
 
@@ -503,7 +505,8 @@ impl Message {
                                     .members_can_see_channel()
                                     .await;
 
-                            user_mentions.retain(|m| *member_channel_view_perms.get(m).unwrap_or(&false));
+                            user_mentions
+                                .retain(|m| *member_channel_view_perms.get(m).unwrap_or(&false));
                         }
                     } else {
                         revolt_config::capture_error(&valid_members.unwrap_err());
@@ -517,7 +520,9 @@ impl Message {
         }
 
         if !user_mentions.is_empty() {
-            message.mentions.replace(user_mentions.into_iter().collect());
+            message
+                .mentions
+                .replace(user_mentions.into_iter().collect());
         }
 
         if !role_mentions.is_empty() {
@@ -651,7 +656,7 @@ impl Message {
     pub async fn send(
         &mut self,
         db: &Database,
-        amqp: Option<&AMQP>, // this is optional mostly for tests.
+        _amqp: Option<&AMQP>, // this is optional mostly for tests.
         author: MessageAuthor<'_>,
         user: Option<v0::User>,
         member: Option<v0::Member>,

crates/core/database/src/models/mod.rs

@@ -8,6 +8,7 @@ mod emojis;
 mod file_hashes;
 mod files;
 mod messages;
+mod policy_changes;
 mod ratelimit_events;
 mod safety_reports;
 mod safety_snapshots;
@@ -27,6 +28,7 @@ pub use emojis::*;
 pub use file_hashes::*;
 pub use files::*;
 pub use messages::*;
+pub use policy_changes::*;
 pub use ratelimit_events::*;
 pub use safety_reports::*;
 pub use safety_snapshots::*;
@@ -51,6 +53,7 @@ pub trait AbstractDatabase:
     + file_hashes::AbstractAttachmentHashes
     + files::AbstractAttachments
     + messages::AbstractMessages
+    + policy_changes::AbstractPolicyChange
     + ratelimit_events::AbstractRatelimitEvents
     + safety_reports::AbstractReport
     + safety_snapshots::AbstractSnapshot

crates/core/database/src/models/policy_changes/mod.rs

@@ -0,0 +1,5 @@
+mod model;
+mod ops;
+
+pub use model::*;
+pub use ops::*;

crates/core/database/src/models/policy_changes/model.rs

@@ -0,0 +1,20 @@
+use iso8601_timestamp::Timestamp;
+
+auto_derived!(
+    /// Platform policy change
+    pub struct PolicyChange {
+        /// Unique Id
+        #[serde(rename = "_id")]
+        pub id: String,
+
+        /// Time at which this policy was created
+        pub created_time: Timestamp,
+        /// Time at which this policy is effective
+        pub effective_time: Timestamp,
+
+        /// Message shown to users
+        pub description: String,
+        /// URL with details about changes
+        pub url: String,
+    }
+);

crates/core/database/src/models/policy_changes/ops.rs

@@ -0,0 +1,15 @@
+use revolt_result::Result;
+
+use crate::PolicyChange;
+
+mod mongodb;
+mod reference;
+
+#[async_trait]
+pub trait AbstractPolicyChange: Sync + Send {
+    /// Fetch all policy changes
+    async fn fetch_policy_changes(&self) -> Result<Vec<PolicyChange>>;
+
+    /// Acknowledge policy changes
+    async fn acknowledge_policy_changes(&self, user_id: &str) -> Result<()>;
+}

crates/core/database/src/models/policy_changes/ops/mongodb.rs

@@ -0,0 +1,46 @@
+use bson::to_bson;
+use iso8601_timestamp::Timestamp;
+use revolt_result::Result;
+
+use crate::MongoDb;
+use crate::PolicyChange;
+use crate::User;
+
+use super::AbstractPolicyChange;
+
+static COL: &str = "policy_changes";
+
+#[async_trait]
+impl AbstractPolicyChange for MongoDb {
+    /// Fetch all policy changes
+    async fn fetch_policy_changes(&self) -> Result<Vec<PolicyChange>> {
+        query!(self, find, COL, doc! {})
+    }
+
+    /// Acknowledge policy changes
+    async fn acknowledge_policy_changes(&self, user_id: &str) -> Result<()> {
+        let latest_policy = self
+            .fetch_policy_changes()
+            .await?
+            .into_iter()
+            .map(|policy| policy.created_time)
+            .max()
+            .unwrap_or(Timestamp::UNIX_EPOCH);
+
+        self.col::<User>("users")
+            .update_one(
+                doc! {
+                    "_id": user_id
+                },
+                doc! {
+                    "$set": {
+                        "last_acknowledged_policy_change": to_bson(&latest_policy)
+                            .map_err(|_| create_database_error!("to_bson", "timestamp"))?
+                    }
+                },
+            )
+            .await
+            .map(|_| ())
+            .map_err(|_| create_database_error!("update_one", COL))
+    }
+}

crates/core/database/src/models/policy_changes/ops/reference.rs

@@ -0,0 +1,31 @@
+use iso8601_timestamp::Timestamp;
+use revolt_result::Result;
+
+use crate::PolicyChange;
+use crate::ReferenceDb;
+
+use super::AbstractPolicyChange;
+
+#[async_trait]
+impl AbstractPolicyChange for ReferenceDb {
+    /// Fetch all policy changes
+    async fn fetch_policy_changes(&self) -> Result<Vec<PolicyChange>> {
+        let policy_changes = self.policy_changes.lock().await;
+        Ok(policy_changes.values().cloned().collect())
+    }
+
+    /// Acknowledge policy changes
+    async fn acknowledge_policy_changes(&self, user_id: &str) -> Result<()> {
+        let mut users = self.users.lock().await;
+        let user = users.get_mut(user_id).expect("user doesn't exist");
+        user.last_acknowledged_policy_change = self
+            .fetch_policy_changes()
+            .await?
+            .into_iter()
+            .map(|policy| policy.created_time)
+            .max()
+            .unwrap_or(Timestamp::UNIX_EPOCH);
+
+        Ok(())
+    }
+}

crates/core/database/src/models/safety_snapshots/model.rs

@@ -85,8 +85,8 @@ impl SnapshotContent {
         Ok((
             SnapshotContent::Message {
                 message,
-                prior_context: prior_context.into_iter().map(Into::into).collect(),
-                leading_context: leading_context.into_iter().map(Into::into).collect(),
+                prior_context: prior_context.into_iter().collect(),
+                leading_context: leading_context.into_iter().collect(),
             },
             files,
         ))

crates/core/database/src/models/server_bans/model.rs

@@ -13,6 +13,7 @@ auto_derived!(
     }
 );
 
+#[allow(clippy::disallowed_methods)]
 impl ServerBan {
     /// Create ban
     pub async fn create(

crates/core/database/src/models/server_members/model.rs

@@ -159,7 +159,7 @@ impl Member {
     }
 
     /// Update member data
-    pub async fn update<'a>(
+    pub async fn update(
         &mut self,
         db: &Database,
         partial: PartialMember,

crates/core/database/src/models/servers/model.rs

@@ -181,7 +181,7 @@ impl Server {
     }
 
     /// Update server data
-    pub async fn update<'a>(
+    pub async fn update(
         &mut self,
         db: &Database,
         partial: PartialServer,
@@ -228,6 +228,13 @@ impl Server {
         }
     }
 
+    /// Ordered roles list
+    pub fn ordered_roles(&self) -> Vec<(String, Role)> {
+        let mut ordered_roles = self.roles.clone().into_iter().collect::<Vec<_>>();
+        ordered_roles.sort_by(|(_, role_a), (_, role_b)| role_a.rank.cmp(&role_b.rank));
+        ordered_roles
+    }
+
     /// Set role permission on a server
     pub async fn set_role_permission(
         &mut self,
@@ -253,6 +260,37 @@ impl Server {
             Err(create_error!(NotFound))
         }
     }
+
+    /// Reorders the server's roles rankings
+    pub async fn set_role_ordering(&mut self, db: &Database, new_order: Vec<String>) -> Result<()> {
+        // New order must always contain every role
+        debug_assert_eq!(self.roles.len(), new_order.len());
+
+        // Set the role's ranks to the positions in the vec
+        for (rank, id) in new_order.iter().enumerate() {
+            self.roles.get_mut(id).unwrap().rank = rank as i64;
+        }
+
+        db.update_server(
+            &self.id,
+            &PartialServer {
+                roles: Some(self.roles.clone()),
+                ..Default::default()
+            },
+            Vec::new(),
+        )
+        .await?;
+
+        // Publish bulk update event
+        EventV1::ServerRoleRanksUpdate {
+            id: self.id.clone(),
+            ranks: new_order,
+        }
+        .p(self.id.clone())
+        .await;
+
+        Ok(())
+    }
 }
 
 impl Role {
@@ -285,7 +323,7 @@ impl Role {
     }
 
     /// Update server data
-    pub async fn update<'a>(
+    pub async fn update(
         &mut self,
         db: &Database,
         server_id: &str,

crates/core/database/src/models/users/mod.rs

@@ -7,11 +7,5 @@ mod rocket;
 #[cfg(feature = "rocket-impl")]
 mod schema;
 
-#[cfg(feature = "axum-impl")]
-pub use self::axum::*;
-#[cfg(feature = "rocket-impl")]
-pub use self::rocket::*;
-#[cfg(feature = "rocket-impl")]
-pub use self::schema::*;
 pub use model::*;
 pub use ops::*;

crates/core/database/src/models/users/model.rs

@@ -8,7 +8,7 @@ use iso8601_timestamp::Timestamp;
 use once_cell::sync::Lazy;
 use rand::seq::SliceRandom;
 use revolt_config::{config, FeaturesLimits};
-use revolt_models::v0::{self, UserFlags, UserBadges};
+use revolt_models::v0::{self, UserBadges, UserFlags};
 use revolt_presence::filter_online;
 use revolt_result::{create_error, Result};
 use serde_json::json;
@@ -57,6 +57,8 @@ auto_derived_partial!(
         /// Time until user is unsuspended
         #[serde(skip_serializing_if = "Option::is_none")]
         pub suspended_until: Option<Timestamp>,
+        /// Last acknowledged policy change
+        pub last_acknowledged_policy_change: Timestamp,
     },
     "PartialUser"
 );
@@ -178,6 +180,7 @@ impl Default for User {
             privileged: Default::default(),
             bot: Default::default(),
             suspended_until: Default::default(),
+            last_acknowledged_policy_change: Timestamp::UNIX_EPOCH,
         }
     }
 }
@@ -200,6 +203,7 @@ impl User {
             id: account_id.into().unwrap_or_else(|| Ulid::new().to_string()),
             discriminator: User::find_discriminator(db, &username, None).await?,
             username,
+            last_acknowledged_policy_change: Timestamp::now_utc(),
             ..Default::default()
         };
 
@@ -349,16 +353,13 @@ impl User {
     ) -> Result<Vec<v0::User>> {
         let online_ids = filter_online(ids).await;
 
-        Ok(join_all(
-            db
-            .fetch_users(ids)
-            .await?
-            .into_iter()
-            .map(|user| async {
+        Ok(
+            join_all(db.fetch_users(ids).await?.into_iter().map(|user| async {
                 let is_online = online_ids.contains(&user.id);
                 user.into_known(perspective, is_online).await
-            })
-        ).await)
+            }))
+            .await,
+        )
     }
 
     /// Find a free discriminator for a given username
@@ -639,7 +640,7 @@ impl User {
     }
 
     /// Update user data
-    pub async fn update<'a>(
+    pub async fn update(
         &mut self,
         db: &Database,
         partial: PartialUser,
@@ -817,7 +818,7 @@ impl User {
 
         if let Some(cutoff) = config.api.users.early_adopter_cutoff {
             if Ulid::from_string(&self.id).unwrap().timestamp_ms() < cutoff {
-                return badges + UserBadges::EarlyAdopter as u32
+                return badges + UserBadges::EarlyAdopter as u32;
             };
         };
 

crates/core/database/src/models/users/ops.rs

@@ -1,4 +1,5 @@
 use authifier::models::Session;
+use iso8601_timestamp::Timestamp;
 use revolt_result::Result;
 
 use crate::{FieldsUser, PartialUser, RelationshipStatus, User};
@@ -61,4 +62,6 @@ pub trait AbstractUsers: Sync + Send {
 
     /// Remove push subscription for a session by session id (TODO: remove)
     async fn remove_push_subscription_by_session_id(&self, session_id: &str) -> Result<()>;
+
+    async fn update_session_last_seen(&self, session_id: &str, when: Timestamp) -> Result<()>;
 }

crates/core/database/src/models/users/ops/mongodb.rs

@@ -1,6 +1,7 @@
 use ::mongodb::options::{Collation, CollationStrength, FindOneOptions, FindOptions};
 use authifier::models::Session;
 use futures::StreamExt;
+use iso8601_timestamp::Timestamp;
 use revolt_result::Result;
 
 use crate::DocumentId;
@@ -211,16 +212,34 @@ impl AbstractUsers for MongoDb {
         partial: &PartialUser,
         remove: Vec<FieldsUser>,
     ) -> Result<()> {
-        query!(
-            self,
-            update_one_by_id,
-            COL,
-            id,
-            partial,
-            remove.iter().map(|x| x as &dyn IntoDocumentPath).collect(),
-            None
-        )
-        .map(|_| ())
+        if remove.contains(&FieldsUser::StatusText) && partial.status.is_some() {
+            // stupid-ass workaround to fix mongo conflicting the same item
+            let _: Result<()> = query!(
+                self,
+                update_one_by_id,
+                COL,
+                id,
+                PartialUser {
+                    ..Default::default()
+                },
+                remove.iter().map(|x| x as &dyn IntoDocumentPath).collect(),
+                None
+            )
+            .map(|_| ());
+
+            query!(self, update_one_by_id, COL, id, partial, vec![], None).map(|_| ())
+        } else {
+            query!(
+                self,
+                update_one_by_id,
+                COL,
+                id,
+                partial,
+                remove.iter().map(|x| x as &dyn IntoDocumentPath).collect(),
+                None
+            )
+            .map(|_| ())
+        }
     }
 
     /// Set relationship with another user
@@ -317,7 +336,26 @@ impl AbstractUsers for MongoDb {
             )
             .await
             .map(|_| ())
-            .map_err(|_| create_database_error!("update_one", COL))
+            .map_err(|_| create_database_error!("update_one", "sessions"))
+    }
+
+    async fn update_session_last_seen(&self, session_id: &str, when: Timestamp) -> Result<()> {
+        let formatted: &str = &when.format();
+
+        self.col::<Session>("sessions")
+            .update_one(
+                doc! {
+                    "_id": session_id
+                },
+                doc! {
+                    "$set": {
+                        "last_seen": formatted
+                    }
+                },
+            )
+            .await
+            .map(|_| ())
+            .map_err(|_| create_database_error!("update_one", "sessions"))
     }
 }
 

crates/core/database/src/models/users/ops/reference.rs

@@ -1,4 +1,5 @@
 use authifier::models::Session;
+use iso8601_timestamp::Timestamp;
 use revolt_result::Result;
 
 use crate::{FieldsUser, PartialUser, RelationshipStatus, User};
@@ -168,4 +169,8 @@ impl AbstractUsers for ReferenceDb {
     async fn remove_push_subscription_by_session_id(&self, _session_id: &str) -> Result<()> {
         todo!()
     }
+
+    async fn update_session_last_seen(&self, _session_id: &str, _when: Timestamp) -> Result<()> {
+        todo!()
+    }
 }

crates/core/database/src/models/users/schema.rs

@@ -6,7 +6,7 @@ use revolt_rocket_okapi::{
 
 use crate::User;
 
-impl<'r> OpenApiFromRequest<'r> for User {
+impl OpenApiFromRequest<'_> for User {
     fn from_request_input(
         _gen: &mut OpenApiGenerator,
         _name: String,

crates/core/database/src/tasks/ack.rs

@@ -3,8 +3,8 @@ use crate::{Database, Message, AMQP};
 
 use deadqueue::limited::Queue;
 use once_cell::sync::Lazy;
+use revolt_config::capture_message;
 use revolt_models::v0::PushNotification;
-use rocket::form::validate::Contains;
 use std::{
     collections::{HashMap, HashSet},
     time::Duration,
@@ -65,6 +65,7 @@ pub async fn queue_ack(channel: String, user: String, event: AckEvent) {
     );
 }
 
+/// Do not add more than one message per event.
 pub async fn queue_message(channel: String, event: AckEvent) {
     Q.try_push(Data {
         channel,
@@ -114,7 +115,7 @@ pub async fn handle_ack_event(
         }
         AckEvent::ProcessMessage { messages } => {
             let mut users: HashSet<&String> = HashSet::new();
-            debug!(
+            info!(
                 "Processing {} messages from channel {}",
                 messages.len(),
                 messages[0].1.channel
@@ -125,7 +126,7 @@ pub async fn handle_ack_event(
                 users.extend(recipents.iter());
             });
 
-            debug!("Found {} users to notify.", users.len());
+            info!("Found {} users to notify.", users.len());
 
             for user in users {
                 let message_ids: Vec<String> = messages
@@ -143,7 +144,7 @@ pub async fn handle_ack_event(
                     db.add_mention_to_unread(channel, user, &message_ids)
                         .await?;
                 }
-                debug!("Added {} mentions for user {}", message_ids.len(), &user);
+                info!("Added {} mentions for user {}", message_ids.len(), &user);
             }
 
             let mut mass_mentions = vec![];
@@ -232,7 +233,7 @@ pub async fn worker(db: Database, amqp: AMQP) {
                     revolt_config::capture_error(&err);
                     error!("{err:?} for {event:?}. ({user:?}, {channel})");
                 } else {
-                    debug!("User {user:?} ack in {channel} with {event:?}");
+                    info!("User {user:?} ack in {channel} with {event:?}");
                 }
             }
         }
@@ -247,6 +248,8 @@ pub async fn worker(db: Database, amqp: AMQP) {
             mut event,
         }) = Q.try_pop()
         {
+            info!("Took next ack from queue, now {} remaining", Q.len());
+
             let key: (Option<String>, String, u8) = (
                 user,
                 channel,
@@ -261,24 +264,31 @@ pub async fn worker(db: Database, amqp: AMQP) {
                         if let AckEvent::ProcessMessage { messages: existing } =
                             &mut task.data.event
                         {
-                            // add the new message to the list of messages to be processed.
-                            existing.append(new_data);
+                            if let Some(new_event) = new_data.pop() {
+                                // if the message contains a mass mention, do not delay it any further.
+                                if new_event.1.contains_mass_push_mention() {
+                                    // add the new message to the list of messages to be processed.
+                                    existing.push(new_event);
+                                    task.run_immediately();
+                                    continue;
+                                }
 
-                            // if the message contains a mass mention, do not delay it any further.
-                            if new_data[0].1.contains_mass_push_mention() {
-                                task.run_immediately();
-                                continue;
-                            }
+                                existing.push(new_event);
 
-                            // put a cap on the amount of messages that can be queued, for particularly active channels
-                            if (existing.length() as u16)
-                                < revolt_config::config()
-                                    .await
-                                    .features
-                                    .advanced
-                                    .process_message_delay_limit
-                            {
-                                task.delay();
+                                // put a cap on the amount of messages that can be queued, for particularly active channels
+                                if (existing.length() as u16)
+                                    < revolt_config::config()
+                                        .await
+                                        .features
+                                        .advanced
+                                        .process_message_delay_limit
+                                {
+                                    task.delay();
+                                }
+                            } else {
+                                let err_msg = format!("Got zero-length message event: {event:?}");
+                                capture_message(&err_msg, revolt_config::Level::Warning);
+                                info!("{err_msg}")
                             }
                         } else {
                             panic!("Somehow got an ack message in the add mention arm");

crates/core/database/src/tasks/authifier_relay.rs

@@ -4,7 +4,7 @@ use once_cell::sync::Lazy;
 
 use crate::events::client::EventV1;
 
-static Q: Lazy<(Sender<AuthifierEvent>, Receiver<AuthifierEvent>)> = Lazy::new(|| unbounded());
+static Q: Lazy<(Sender<AuthifierEvent>, Receiver<AuthifierEvent>)> = Lazy::new(unbounded);
 
 /// Get sender
 pub fn sender() -> Sender<AuthifierEvent> {

crates/core/database/src/util/bridge/v0.rs

@@ -1,7 +1,8 @@
+use iso8601_timestamp::Timestamp;
 use revolt_models::v0::*;
 use revolt_permissions::{calculate_user_permissions, UserPermission};
 
-use crate::{util::permissions::DatabasePermissionQuery, Database, FileUsedFor};
+use crate::{util::permissions::DatabasePermissionQuery, Database};
 
 impl crate::Bot {
     pub fn into_public_bot(self, user: crate::User) -> PublicBot {
@@ -14,8 +15,7 @@ impl crate::Bot {
             avatar: user.avatar.map(|x| x.id).unwrap_or_default(),
             description: user
                 .profile
-                .map(|profile| profile.content)
-                .flatten()
+                .and_then(|profile| profile.content)
                 .unwrap_or_default(),
         }
     }
@@ -488,7 +488,7 @@ impl crate::Message {
             reactions: self.reactions,
             interactions: self.interactions.into(),
             masquerade: self.masquerade.map(Into::into),
-            flags: self.flags.map(|flags| flags as u32).unwrap_or_default(),
+            flags: self.flags.unwrap_or_default(),
             pinned: self.pinned,
         }
     }
@@ -517,7 +517,7 @@ impl From<crate::PartialMessage> for PartialMessage {
             reactions: value.reactions,
             interactions: value.interactions.map(Into::into),
             masquerade: value.masquerade.map(Into::into),
-            flags: value.flags.map(|flags| flags as u32),
+            flags: value.flags,
             pinned: value.pinned,
         }
     }
@@ -597,6 +597,17 @@ impl From<Masquerade> for crate::Masquerade {
     }
 }
 
+impl From<crate::PolicyChange> for PolicyChange {
+    fn from(value: crate::PolicyChange) -> Self {
+        PolicyChange {
+            created_time: value.created_time,
+            effective_time: value.effective_time,
+            description: value.description,
+            url: value.url,
+        }
+    }
+}
+
 impl From<crate::Report> for Report {
     fn from(value: crate::Report) -> Self {
         Report {
@@ -1102,7 +1113,7 @@ impl crate::User {
     }
 
     /// Convert user object into user model without presence information
-    pub async fn into_known_static<'a>(self, is_online: bool) -> User {
+    pub async fn into_known_static(self, is_online: bool) -> User {
         let badges = self.get_badges().await;
 
         User {
@@ -1188,6 +1199,7 @@ impl From<User> for crate::User {
             privileged: value.privileged,
             bot: value.bot.map(Into::into),
             suspended_until: None,
+            last_acknowledged_policy_change: Timestamp::UNIX_EPOCH,
         }
     }
 }

crates/core/database/src/util/bulk_permissions.rs

@@ -87,7 +87,7 @@ impl<'z> BulkDatabasePermissionQuery<'z> {
         }
     }
 
-    pub fn channel(self, channel: &'z Channel) -> BulkDatabasePermissionQuery {
+    pub fn channel(self, channel: &'z Channel) -> BulkDatabasePermissionQuery<'z> {
         BulkDatabasePermissionQuery {
             channel: Some(channel.clone()),
             ..self
@@ -109,7 +109,7 @@ impl<'z> BulkDatabasePermissionQuery<'z> {
         }
     }
 
-    pub fn members(self, members: &'z [Member]) -> BulkDatabasePermissionQuery {
+    pub fn members(self, members: &'z [Member]) -> BulkDatabasePermissionQuery<'z> {
         BulkDatabasePermissionQuery {
             members: Some(members.to_owned()),
             cached_member_perms: None,
@@ -120,7 +120,7 @@ impl<'z> BulkDatabasePermissionQuery<'z> {
         }
     }
 
-    pub fn users(self, users: &'z [User]) -> BulkDatabasePermissionQuery {
+    pub fn users(self, users: &'z [User]) -> BulkDatabasePermissionQuery<'z> {
         BulkDatabasePermissionQuery {
             users: Some(users.to_owned()),
             cached_member_perms: None,

crates/core/database/src/util/idempotency.rs

@@ -54,7 +54,7 @@ use revolt_rocket_okapi::{
 use schemars::schema::{InstanceType, SchemaObject, SingleOrVec};
 
 #[cfg(feature = "rocket-impl")]
-impl<'r> OpenApiFromRequest<'r> for IdempotencyKey {
+impl OpenApiFromRequest<'_> for IdempotencyKey {
     fn from_request_input(
         _gen: &mut OpenApiGenerator,
         _name: String,

crates/core/database/src/util/permissions.rs

@@ -104,7 +104,7 @@ impl PermissionQuery for DatabasePermissionQuery<'_> {
                 .unwrap_or_default();
 
             self.cached_mutual_connection = Some(value);
-            matches!(value, true)
+            value
         } else {
             false
         }
@@ -305,16 +305,14 @@ impl PermissionQuery for DatabasePermissionQuery<'_> {
 
     /// Are we a recipient of this channel?
     async fn are_we_part_of_the_channel(&mut self) -> bool {
-        if let Some(channel) = &self.channel {
-            match channel {
-                Cow::Borrowed(Channel::DirectMessage { recipients, .. })
-                | Cow::Owned(Channel::DirectMessage { recipients, .. })
-                | Cow::Borrowed(Channel::Group { recipients, .. })
-                | Cow::Owned(Channel::Group { recipients, .. }) => {
-                    recipients.contains(&self.perspective.id)
-                }
-                _ => false,
-            }
+        if let Some(
+            Cow::Borrowed(Channel::DirectMessage { recipients, .. })
+            | Cow::Owned(Channel::DirectMessage { recipients, .. })
+            | Cow::Borrowed(Channel::Group { recipients, .. })
+            | Cow::Owned(Channel::Group { recipients, .. }),
+        ) = &self.channel
+        {
+            recipients.contains(&self.perspective.id)
         } else {
             false
         }
@@ -420,7 +418,7 @@ impl<'a> DatabasePermissionQuery<'a> {
     }
 
     /// Use user
-    pub fn user(self, user: &'a User) -> DatabasePermissionQuery {
+    pub fn user(self, user: &'a User) -> DatabasePermissionQuery<'a> {
         DatabasePermissionQuery {
             user: Some(Cow::Borrowed(user)),
             ..self
@@ -428,7 +426,7 @@ impl<'a> DatabasePermissionQuery<'a> {
     }
 
     /// Use channel
-    pub fn channel(self, channel: &'a Channel) -> DatabasePermissionQuery {
+    pub fn channel(self, channel: &'a Channel) -> DatabasePermissionQuery<'a> {
         DatabasePermissionQuery {
             channel: Some(Cow::Borrowed(channel)),
             ..self
@@ -436,7 +434,7 @@ impl<'a> DatabasePermissionQuery<'a> {
     }
 
     /// Use server
-    pub fn server(self, server: &'a Server) -> DatabasePermissionQuery {
+    pub fn server(self, server: &'a Server) -> DatabasePermissionQuery<'a> {
         DatabasePermissionQuery {
             server: Some(Cow::Borrowed(server)),
             ..self
@@ -444,7 +442,7 @@ impl<'a> DatabasePermissionQuery<'a> {
     }
 
     /// Use member
-    pub fn member(self, member: &'a Member) -> DatabasePermissionQuery {
+    pub fn member(self, member: &'a Member) -> DatabasePermissionQuery<'a> {
         DatabasePermissionQuery {
             member: Some(Cow::Borrowed(member)),
             ..self

crates/core/files/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-files"
-version = "0.8.5"
+version = "0.8.8"
 edition = "2021"
 license = "AGPL-3.0-or-later"
 authors = ["Paul Makles <me@insrt.uk>"]
@@ -20,10 +20,10 @@ typenum = "1.17.0"
 aws-config = "1.5.5"
 aws-sdk-s3 = { version = "1.46.0", features = ["behavior-version-latest"] }
 
-revolt-config = { version = "0.8.5", path = "../config", features = [
+revolt-config = { version = "0.8.8", path = "../config", features = [
     "report-macros",
 ] }
-revolt-result = { version = "0.8.5", path = "../result" }
+revolt-result = { version = "0.8.8", path = "../result" }
 
 # image processing
 jxl-oxide = "0.8.1"

crates/core/models/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-models"
-version = "0.8.5"
+version = "0.8.8"
 edition = "2021"
 license = "MIT"
 authors = ["Paul Makles <me@insrt.uk>"]
@@ -20,8 +20,8 @@ default = ["serde", "partials", "rocket"]
 
 [dependencies]
 # Core
-revolt-config = { version = "0.8.5", path = "../config" }
-revolt-permissions = { version = "0.8.5", path = "../permissions" }
+revolt-config = { version = "0.8.8", path = "../config" }
+revolt-permissions = { version = "0.8.8", path = "../permissions" }
 
 # Utility
 regex = "1.11"

crates/core/models/src/v0/bots.rs

@@ -132,8 +132,8 @@ auto_derived!(
         #[cfg_attr(feature = "validator", validate(length(min = 1, max = 2048)))]
         pub interactions_url: Option<String>,
         /// Fields to remove from bot object
-        #[cfg_attr(feature = "validator", validate(length(min = 1)))]
-        pub remove: Option<Vec<FieldsBot>>,
+        #[cfg_attr(feature = "serde", serde(default))]
+        pub remove: Vec<FieldsBot>,
     }
 
     /// Where we are inviting a bot to

crates/core/models/src/v0/channels.rs

@@ -207,7 +207,7 @@ auto_derived!(
 
         /// Fields to remove from channel
         #[cfg_attr(feature = "serde", serde(default))]
-        pub remove: Option<Vec<FieldsChannel>>,
+        pub remove: Vec<FieldsChannel>,
     }
 
     /// Create new group
@@ -310,14 +310,14 @@ impl Channel {
     /// This returns a Result because the recipient name can't be determined here without a db call,
     /// which can't be done since this is models, which can't reference the database crate.
     ///
-    /// If it returns Err, you need to fetch the name from the db.
-    pub fn name(&self) -> Result<&str, ()> {
+    /// If it returns None, you need to fetch the name from the db.
+    pub fn name(&self) -> Option<&str> {
         match self {
-            Channel::DirectMessage { .. } => Err(()),
-            Channel::SavedMessages { .. } => Ok("Saved Messages"),
+            Channel::DirectMessage { .. } => None,
+            Channel::SavedMessages { .. } => Some("Saved Messages"),
             Channel::TextChannel { name, .. }
             | Channel::Group { name, .. }
-            | Channel::VoiceChannel { name, .. } => Ok(name),
+            | Channel::VoiceChannel { name, .. } => Some(name),
         }
     }
 }

crates/core/models/src/v0/messages.rs

@@ -215,7 +215,7 @@ auto_derived!(
     #[derive(Default)]
     #[cfg_attr(feature = "validator", derive(Validate))]
     pub struct SendableEmbed {
-        #[cfg_attr(feature = "validator", validate(length(min = 1, max = 128)))]
+        #[cfg_attr(feature = "validator", validate(length(min = 1, max = 256)))]
         pub icon_url: Option<String>,
         #[cfg_attr(feature = "validator", validate(length(min = 1, max = 256)))]
         pub url: Option<String>,
@@ -399,7 +399,7 @@ impl Interactions {
     }
 }
 
-impl<'a> MessageAuthor<'a> {
+impl MessageAuthor<'_> {
     pub fn id(&self) -> &str {
         match self {
             MessageAuthor::User(user) => &user.id,

crates/core/models/src/v0/mod.rs

@@ -7,6 +7,7 @@ mod embeds;
 mod emojis;
 mod files;
 mod messages;
+mod policy_changes;
 mod safety_reports;
 mod server_bans;
 mod server_members;
@@ -23,6 +24,7 @@ pub use embeds::*;
 pub use emojis::*;
 pub use files::*;
 pub use messages::*;
+pub use policy_changes::*;
 pub use safety_reports::*;
 pub use server_bans::*;
 pub use server_members::*;

crates/core/models/src/v0/policy_changes.rs

@@ -0,0 +1,16 @@
+use iso8601_timestamp::Timestamp;
+
+auto_derived!(
+    /// Platform policy change
+    pub struct PolicyChange {
+        /// Time at which this policy was created
+        pub created_time: Timestamp,
+        /// Time at which this policy is effective
+        pub effective_time: Timestamp,
+
+        /// Message shown to users
+        pub description: String,
+        /// URL with details about changes
+        pub url: String,
+    }
+);

crates/core/models/src/v0/server_members.rs

@@ -124,7 +124,7 @@ auto_derived!(
         /// Timestamp this member is timed out until
         pub timeout: Option<Timestamp>,
         /// Fields to remove from channel object
-        #[cfg_attr(feature = "validator", validate(length(min = 1)))]
-        pub remove: Option<Vec<FieldsMember>>,
+        #[cfg_attr(feature = "serde", serde(default))]
+        pub remove: Vec<FieldsMember>,
     }
 );

crates/core/models/src/v0/servers.rs

@@ -175,6 +175,8 @@ auto_derived!(
         /// Ranking position
         ///
         /// Smaller values take priority.
+        ///
+        /// **Removed** - no effect, use the edit server role positions route
         pub rank: Option<i64>,
     }
 
@@ -247,8 +249,8 @@ auto_derived!(
         pub analytics: Option<bool>,
 
         /// Fields to remove from server object
-        #[cfg_attr(feature = "validator", validate(length(min = 1)))]
-        pub remove: Option<Vec<FieldsServer>>,
+        #[cfg_attr(feature = "serde", serde(default))]
+        pub remove: Vec<FieldsServer>,
     }
 
     /// New role information
@@ -267,11 +269,11 @@ auto_derived!(
         pub hoist: Option<bool>,
         /// Ranking position
         ///
-        /// Smaller values take priority.
+        /// **Removed** - no effect, use the edit server role positions route
         pub rank: Option<i64>,
         /// Fields to remove from role object
-        #[cfg_attr(feature = "validator", validate(length(min = 1)))]
-        pub remove: Option<Vec<FieldsRole>>,
+        #[cfg_attr(feature = "serde", serde(default))]
+        pub remove: Vec<FieldsRole>,
     }
 
     /// New role permissions
@@ -286,4 +288,9 @@ auto_derived!(
         /// Whether to not send a leave message
         pub leave_silently: Option<bool>,
     }
+
+    /// New role positions
+    pub struct DataEditRoleRanks {
+        pub ranks: Vec<String>,
+    }
 );

crates/core/models/src/v0/users.rs

@@ -245,8 +245,8 @@ auto_derived!(
         pub flags: Option<i32>,
 
         /// Fields to remove from user object
-        #[cfg_attr(feature = "validator", validate(length(min = 1)))]
-        pub remove: Option<Vec<FieldsUser>>,
+        #[cfg_attr(feature = "serde", serde(default))]
+        pub remove: Vec<FieldsUser>,
     }
 
     /// User flag reponse

crates/core/parser/Cargo.toml

@@ -1,7 +1,9 @@
 [package]
 name = "revolt-parser"
-version = "0.1.1"
+version = "0.8.8"
 edition = "2021"
+license = "AGPL-3.0-or-later"
+description = "Revolt Backend: Message Parser"
 
 [dependencies]
-logos = { version = "*" }
+logos = { version = "0.15" }

crates/core/permissions/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-permissions"
-version = "0.8.5"
+version = "0.8.8"
 edition = "2021"
 license = "MIT"
 authors = ["Paul Makles <me@insrt.uk>"]
@@ -21,7 +21,7 @@ async-std = { version = "1.8.0", features = ["attributes"] }
 
 [dependencies]
 # Core
-revolt-result = { version = "0.8.5", path = "../result" }
+revolt-result = { version = "0.8.8", path = "../result" }
 
 # Utility
 auto_ops = "0.3.0"

crates/core/presence/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-presence"
-version = "0.8.5"
+version = "0.8.8"
 edition = "2021"
 license = "AGPL-3.0-or-later"
 authors = ["Paul Makles <me@insrt.uk>"]
@@ -15,6 +15,9 @@ redis-is-patched = []
 # Async
 async-std = { version = "1.8.0", features = ["attributes"] }
 
+# Config for loading Redis URI
+revolt-config = { version = "0.8.8", path = "../config" }
+
 [dependencies]
 # Utility
 log = "0.4.17"

crates/core/presence/src/lib.rs

@@ -197,6 +197,8 @@ mod tests {
 
     #[async_std::test]
     async fn it_works() {
+        revolt_config::config().await;
+
         // Clear the region before we start the tests:
         clear_region(None).await;
 

crates/core/result/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-result"
-version = "0.8.5"
+version = "0.8.8"
 edition = "2021"
 license = "MIT"
 authors = ["Paul Makles <me@insrt.uk>"]

crates/daemons/crond/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-crond"
-version = "0.8.5"
+version = "0.8.8"
 license = "AGPL-3.0-or-later"
 authors = ["Paul Makles <me@insrt.uk>"]
 edition = "2021"
@@ -16,7 +16,7 @@ log = "0.4"
 tokio = { version = "1" }
 
 # Core
-revolt-database = { version = "0.8.5", path = "../../core/database" }
-revolt-result = { version = "0.8.5", path = "../../core/result" }
-revolt-config = { version = "0.8.5", path = "../../core/config" }
-revolt-files = { version = "0.8.5", path = "../../core/files" }
+revolt-database = { version = "0.8.8", path = "../../core/database" }
+revolt-result = { version = "0.8.8", path = "../../core/result" }
+revolt-config = { version = "0.8.8", path = "../../core/config" }
+revolt-files = { version = "0.8.8", path = "../../core/files" }

crates/daemons/pushd/Cargo.toml

@@ -1,19 +1,24 @@
 [package]
 name = "revolt-pushd"
-version = "0.8.5"
+version = "0.8.8"
 edition = "2021"
 license = "AGPL-3.0-or-later"
 
 [dependencies]
-revolt-config = { version = "0.8.5", path = "../../core/config" }
-revolt-database = { version = "0.8.5", path = "../../core/database" }
-revolt-models = { version = "0.8.5", path = "../../core/models", features = [
+revolt-result = { version = "0.8.8", path = "../../core/result" }
+revolt-config = { version = "0.8.8", path = "../../core/config", features = [
+    "report-macros",
+] }
+revolt-database = { version = "0.8.8", path = "../../core/database" }
+revolt-models = { version = "0.8.8", path = "../../core/models", features = [
     "validator",
 ] }
-revolt-presence = { version = "0.8.5", path = "../../core/presence", features = [
+revolt-presence = { version = "0.8.8", path = "../../core/presence", features = [
     "redis-is-patched",
 ] }
 
+anyhow = { version = "1.0.98" }
+
 amqprs = { version = "1.7.0" }
 fcm_v1 = "0.3.0"
 web-push = "0.10.0"
@@ -23,7 +28,7 @@ tokio = "1.39.2"
 async-trait = "0.1.81"
 ulid = "1.0.0"
 
-authifier = "1.0.10"
+authifier = "1.0.15"
 
 log = "0.4.11"
 pretty_env_logger = "0.4.0"

crates/daemons/pushd/src/consumers/inbound/fr_accepted.rs

@@ -7,6 +7,7 @@ use amqprs::{
     consumer::AsyncConsumer,
     BasicProperties, Deliver,
 };
+use anyhow::Result;
 use async_trait::async_trait;
 use log::debug;
 use revolt_database::{events::rabbit::*, Database};
@@ -54,21 +55,16 @@ impl FRAcceptedConsumer {
             channel: None,
         }
     }
-}
 
-#[allow(unused_variables)]
-#[async_trait]
-impl AsyncConsumer for FRAcceptedConsumer {
-    /// This consumer handles delegating messages into their respective platform queues.
-    async fn consume(
+    async fn consume_event(
         &mut self,
-        channel: &Channel,
-        deliver: Deliver,
-        basic_properties: BasicProperties,
+        _channel: &Channel,
+        _deliver: Deliver,
+        _basic_properties: BasicProperties,
         content: Vec<u8>,
-    ) {
-        let content = String::from_utf8(content).unwrap();
-        let payload: FRAcceptedPayload = serde_json::from_str(content.as_str()).unwrap();
+    ) -> Result<()> {
+        let content = String::from_utf8(content)?;
+        let payload: FRAcceptedPayload = serde_json::from_str(content.as_str())?;
 
         debug!("Received FR accept event");
 
@@ -111,11 +107,34 @@ impl AsyncConsumer for FRAcceptedConsumer {
                             .insert("endpoint".to_string(), sub.endpoint.clone());
                     }
 
-                    let payload = serde_json::to_string(&sendable).unwrap();
+                    let payload = serde_json::to_string(&sendable)?;
 
                     publish_message(self, payload.into(), args).await;
                 }
             }
         }
+
+        Ok(())
+    }
+}
+
+#[allow(unused_variables)]
+#[async_trait]
+impl AsyncConsumer for FRAcceptedConsumer {
+    /// This consumer handles delegating messages into their respective platform queues.
+    async fn consume(
+        &mut self,
+        channel: &Channel,
+        deliver: Deliver,
+        basic_properties: BasicProperties,
+        content: Vec<u8>,
+    ) {
+        if let Err(err) = self
+            .consume_event(channel, deliver, basic_properties, content)
+            .await
+        {
+            revolt_config::capture_anyhow(&err);
+            eprintln!("Failed to process friend request accepted event: {err:?}");
+        }
     }
 }

crates/daemons/pushd/src/consumers/inbound/fr_received.rs

@@ -7,6 +7,7 @@ use amqprs::{
     consumer::AsyncConsumer,
     BasicProperties, Deliver,
 };
+use anyhow::Result;
 use async_trait::async_trait;
 use log::debug;
 use revolt_database::{events::rabbit::*, Database};
@@ -54,21 +55,16 @@ impl FRReceivedConsumer {
             channel: None,
         }
     }
-}
 
-#[allow(unused_variables)]
-#[async_trait]
-impl AsyncConsumer for FRReceivedConsumer {
-    /// This consumer handles delegating messages into their respective platform queues.
-    async fn consume(
+    async fn consume_event(
         &mut self,
-        channel: &Channel,
-        deliver: Deliver,
-        basic_properties: BasicProperties,
+        _channel: &Channel,
+        _deliver: Deliver,
+        _basic_properties: BasicProperties,
         content: Vec<u8>,
-    ) {
-        let content = String::from_utf8(content).unwrap();
-        let payload: FRReceivedPayload = serde_json::from_str(content.as_str()).unwrap();
+    ) -> Result<()> {
+        let content = String::from_utf8(content)?;
+        let payload: FRReceivedPayload = serde_json::from_str(content.as_str())?;
 
         debug!("Received FR received event");
 
@@ -111,11 +107,34 @@ impl AsyncConsumer for FRReceivedConsumer {
                             .insert("endpoint".to_string(), sub.endpoint.clone());
                     }
 
-                    let payload = serde_json::to_string(&sendable).unwrap();
+                    let payload = serde_json::to_string(&sendable)?;
 
                     publish_message(self, payload.into(), args).await;
                 }
             }
         }
+
+        Ok(())
+    }
+}
+
+#[allow(unused_variables)]
+#[async_trait]
+impl AsyncConsumer for FRReceivedConsumer {
+    /// This consumer handles delegating messages into their respective platform queues.
+    async fn consume(
+        &mut self,
+        channel: &Channel,
+        deliver: Deliver,
+        basic_properties: BasicProperties,
+        content: Vec<u8>,
+    ) {
+        if let Err(err) = self
+            .consume_event(channel, deliver, basic_properties, content)
+            .await
+        {
+            revolt_config::capture_anyhow(&err);
+            eprintln!("Failed to process friend request received event: {err:?}");
+        }
     }
 }

crates/daemons/pushd/src/consumers/inbound/generic.rs

@@ -7,6 +7,7 @@ use amqprs::{
     consumer::AsyncConsumer,
     BasicProperties, Deliver,
 };
+use anyhow::Result;
 use async_trait::async_trait;
 use log::debug;
 use revolt_database::{events::rabbit::*, Database};
@@ -54,21 +55,16 @@ impl GenericConsumer {
             channel: None,
         }
     }
-}
 
-#[allow(unused_variables)]
-#[async_trait]
-impl AsyncConsumer for GenericConsumer {
-    /// This consumer handles delegating messages into their respective platform queues.
-    async fn consume(
+    async fn consume_event(
         &mut self,
-        channel: &Channel,
-        deliver: Deliver,
-        basic_properties: BasicProperties,
+        _channel: &Channel,
+        _deliver: Deliver,
+        _basic_properties: BasicProperties,
         content: Vec<u8>,
-    ) {
-        let content = String::from_utf8(content).unwrap();
-        let payload: MessageSentPayload = serde_json::from_str(content.as_str()).unwrap();
+    ) -> Result<()> {
+        let content = String::from_utf8(content)?;
+        let payload: MessageSentPayload = serde_json::from_str(content.as_str())?;
 
         debug!("Received message event on origin");
 
@@ -117,11 +113,34 @@ impl AsyncConsumer for GenericConsumer {
                             .insert("endpoint".to_string(), sub.endpoint.clone());
                     }
 
-                    let payload = serde_json::to_string(&sendable).unwrap();
+                    let payload = serde_json::to_string(&sendable)?;
 
                     publish_message(self, payload.into(), args).await;
                 }
             }
         }
+
+        Ok(())
+    }
+}
+
+#[allow(unused_variables)]
+#[async_trait]
+impl AsyncConsumer for GenericConsumer {
+    /// This consumer handles delegating messages into their respective platform queues.
+    async fn consume(
+        &mut self,
+        channel: &Channel,
+        deliver: Deliver,
+        basic_properties: BasicProperties,
+        content: Vec<u8>,
+    ) {
+        if let Err(err) = self
+            .consume_event(channel, deliver, basic_properties, content)
+            .await
+        {
+            revolt_config::capture_anyhow(&err);
+            eprintln!("Failed to process generic event: {err:?}");
+        }
     }
 }

crates/daemons/pushd/src/consumers/inbound/mass_mention.rs

@@ -10,6 +10,7 @@ use amqprs::{
     consumer::AsyncConsumer,
     BasicProperties, Deliver,
 };
+use anyhow::Result;
 use async_trait::async_trait;
 use revolt_database::{
     events::rabbit::*, util::bulk_permissions::BulkDatabasePermissionQuery, Database, Member,
@@ -61,7 +62,11 @@ impl MassMessageConsumer {
         }
     }
 
-    async fn fire_notification_for_users(&mut self, push: &PushNotification, users: &[String]) {
+    async fn fire_notification_for_users(
+        &mut self,
+        push: &PushNotification,
+        users: &[String],
+    ) -> Result<()> {
         if let Ok(sessions) = self
             .authifier_db
             .find_sessions_with_subscription(users)
@@ -105,29 +110,26 @@ impl MassMessageConsumer {
                             .insert("endpoint".to_string(), sub.endpoint.clone());
                     }
 
-                    let payload = serde_json::to_string(&sendable).unwrap();
+                    let payload = serde_json::to_string(&sendable)?;
 
                     publish_message(self, payload.into(), args).await;
                 }
             }
         }
-    }
-}
 
-#[allow(unused_variables)]
-#[async_trait]
-impl AsyncConsumer for MassMessageConsumer {
-    /// This consumer handles adding mentions for all the users affected by a mass mention ping, and then sends out push notifications
-    async fn consume(
+        Ok(())
+    }
+
+    async fn consume_event(
         &mut self,
-        channel: &Channel,
-        deliver: Deliver,
-        basic_properties: BasicProperties,
+        _channel: &Channel,
+        _deliver: Deliver,
+        _basic_properties: BasicProperties,
         content: Vec<u8>,
-    ) {
+    ) -> Result<()> {
         let config = revolt_config::config().await;
-        let content = String::from_utf8(content).unwrap();
-        let payload: MassMessageSentPayload = serde_json::from_str(content.as_str()).unwrap();
+        let content = String::from_utf8(content)?;
+        let payload: MassMessageSentPayload = serde_json::from_str(content.as_str())?;
 
         debug!("Received mass message event");
 
@@ -159,8 +161,7 @@ impl AsyncConsumer for MassMessageConsumer {
                     let mut db_query = self
                         .db
                         .fetch_all_members_chunked(&payload.server_id)
-                        .await
-                        .expect("Failed to fetch members from database");
+                        .await?;
 
                     let mut exhausted = false;
                     let ack_chnl = vec![push.channel.id().to_string()];
@@ -203,7 +204,8 @@ impl AsyncConsumer for MassMessageConsumer {
                             target_users, online_users
                         );
 
-                        self.fire_notification_for_users(&push, &target_users).await;
+                        self.fire_notification_for_users(&push, &target_users)
+                            .await?;
 
                         if exhausted {
                             break;
@@ -211,19 +213,11 @@ impl AsyncConsumer for MassMessageConsumer {
                     }
                 } else if let Some(roles) = &push.message.role_mentions {
                     // role mentions
-                    let _role_members = self
+                    let mut role_members = self
                         .db
                         .fetch_all_members_with_roles_chunked(&payload.server_id, roles)
-                        .await;
+                        .await?;
 
-                    debug!("role members: {:?}", _role_members);
-
-                    if _role_members.is_err() {
-                        revolt_config::capture_error(&_role_members.err().unwrap());
-                        return;
-                    }
-
-                    let mut role_members = _role_members.unwrap();
                     let mut chunk = vec![];
                     let mut exhausted = false;
 
@@ -266,10 +260,33 @@ impl AsyncConsumer for MassMessageConsumer {
 
                         debug!("targets: {:?}", targets);
 
-                        self.fire_notification_for_users(&push, &targets).await;
+                        self.fire_notification_for_users(&push, &targets).await?;
                     }
                 }
             }
         }
+
+        Ok(())
+    }
+}
+
+#[allow(unused_variables)]
+#[async_trait]
+impl AsyncConsumer for MassMessageConsumer {
+    /// This consumer handles adding mentions for all the users affected by a mass mention ping, and then sends out push notifications
+    async fn consume(
+        &mut self,
+        channel: &Channel,
+        deliver: Deliver,
+        basic_properties: BasicProperties,
+        content: Vec<u8>,
+    ) {
+        if let Err(err) = self
+            .consume_event(channel, deliver, basic_properties, content)
+            .await
+        {
+            revolt_config::capture_anyhow(&err);
+            eprintln!("Failed to process mass message event: {err:?}");
+        }
     }
 }

crates/daemons/pushd/src/consumers/inbound/message.rs

@@ -7,6 +7,7 @@ use amqprs::{
     consumer::AsyncConsumer,
     BasicProperties, Deliver,
 };
+use anyhow::Result;
 use async_trait::async_trait;
 use log::debug;
 use revolt_database::{events::rabbit::*, Database};
@@ -54,21 +55,16 @@ impl MessageConsumer {
             channel: None,
         }
     }
-}
 
-#[allow(unused_variables)]
-#[async_trait]
-impl AsyncConsumer for MessageConsumer {
-    /// This consumer handles delegating messages into their respective platform queues.
-    async fn consume(
+    async fn consume_event(
         &mut self,
-        channel: &Channel,
-        deliver: Deliver,
-        basic_properties: BasicProperties,
+        _channel: &Channel,
+        _deliver: Deliver,
+        _basic_properties: BasicProperties,
         content: Vec<u8>,
-    ) {
-        let content = String::from_utf8(content).unwrap();
-        let payload: MessageSentPayload = serde_json::from_str(content.as_str()).unwrap();
+    ) -> Result<()> {
+        let content = String::from_utf8(content)?;
+        let payload: MessageSentPayload = serde_json::from_str(content.as_str())?;
 
         debug!("Received message event on origin");
 
@@ -117,11 +113,34 @@ impl AsyncConsumer for MessageConsumer {
                             .insert("endpoint".to_string(), sub.endpoint.clone());
                     }
 
-                    let payload = serde_json::to_string(&sendable).unwrap();
+                    let payload = serde_json::to_string(&sendable)?;
 
                     publish_message(self, payload.into(), args).await;
                 }
             }
         }
+
+        Ok(())
+    }
+}
+
+#[allow(unused_variables)]
+#[async_trait]
+impl AsyncConsumer for MessageConsumer {
+    /// This consumer handles delegating messages into their respective platform queues.
+    async fn consume(
+        &mut self,
+        channel: &Channel,
+        deliver: Deliver,
+        basic_properties: BasicProperties,
+        content: Vec<u8>,
+    ) {
+        if let Err(err) = self
+            .consume_event(channel, deliver, basic_properties, content)
+            .await
+        {
+            revolt_config::capture_anyhow(&err);
+            eprintln!("Failed to process message event: {err:?}");
+        }
     }
 }

crates/daemons/pushd/src/consumers/outbound/apn.rs

@@ -1,6 +1,7 @@
 use std::{borrow::Cow, collections::BTreeMap, io::Cursor};
 
 use amqprs::{channel::Channel as AmqpChannel, consumer::AsyncConsumer, BasicProperties, Deliver};
+use anyhow::{anyhow, Result};
 use async_trait::async_trait;
 use base64::{
     engine::{self},
@@ -122,20 +123,16 @@ impl ApnsOutboundConsumer {
 
         Ok(ApnsOutboundConsumer { db, client })
     }
-}
 
-#[allow(unused_variables)]
-#[async_trait]
-impl AsyncConsumer for ApnsOutboundConsumer {
-    async fn consume(
+    async fn consume_event(
         &mut self,
-        channel: &AmqpChannel,
-        deliver: Deliver,
-        basic_properties: BasicProperties,
+        _channel: &AmqpChannel,
+        _deliver: Deliver,
+        _basic_properties: BasicProperties,
         content: Vec<u8>,
-    ) {
-        let content = String::from_utf8(content).unwrap();
-        let payload: PayloadToService = serde_json::from_str(content.as_str()).unwrap();
+    ) -> Result<()> {
+        let content = String::from_utf8(content)?;
+        let payload: PayloadToService = serde_json::from_str(content.as_str())?;
 
         let payload_options = NotificationOptions {
             apns_id: None,
@@ -159,7 +156,7 @@ impl AsyncConsumer for ApnsOutboundConsumer {
                             alert.from_user.username, alert.from_user.discriminator
                         )))
                         .clone()
-                        .unwrap(),
+                        .ok_or_else(|| anyhow!("missing name"))?,
                 )];
 
                 let apn_payload = Payload {
@@ -205,7 +202,7 @@ impl AsyncConsumer for ApnsOutboundConsumer {
                             alert.accepted_user.username, alert.accepted_user.discriminator
                         )))
                         .clone()
-                        .unwrap(),
+                        .ok_or_else(|| anyhow!("missing name"))?,
                 )];
 
                 let apn_payload = Payload {
@@ -355,5 +352,27 @@ impl AsyncConsumer for ApnsOutboundConsumer {
                 }
             }
         }
+
+        Ok(())
+    }
+}
+
+#[allow(unused_variables)]
+#[async_trait]
+impl AsyncConsumer for ApnsOutboundConsumer {
+    async fn consume(
+        &mut self,
+        channel: &AmqpChannel,
+        deliver: Deliver,
+        basic_properties: BasicProperties,
+        content: Vec<u8>,
+    ) {
+        if let Err(err) = self
+            .consume_event(channel, deliver, basic_properties, content)
+            .await
+        {
+            revolt_config::capture_anyhow(&err);
+            eprintln!("Failed to process APN event: {err:?}");
+        }
     }
 }

crates/daemons/pushd/src/consumers/outbound/fcm.rs

@@ -2,6 +2,7 @@ use std::{collections::HashMap, time::Duration};
 
 use amqprs::{channel::Channel as AmqpChannel, consumer::AsyncConsumer, BasicProperties, Deliver};
 
+use anyhow::{anyhow, bail, Result};
 use async_trait::async_trait;
 use fcm_v1::{
     android::AndroidConfig,
@@ -64,22 +65,16 @@ impl FcmOutboundConsumer {
             ),
         })
     }
-}
 
-#[allow(unused_variables)]
-#[async_trait]
-impl AsyncConsumer for FcmOutboundConsumer {
-    async fn consume(
+    async fn consume_event(
         &mut self,
-        channel: &AmqpChannel,
-        deliver: Deliver,
-        basic_properties: BasicProperties,
+        _channel: &AmqpChannel,
+        _deliver: Deliver,
+        _basic_properties: BasicProperties,
         content: Vec<u8>,
-    ) {
-        let content = String::from_utf8(content).unwrap();
-        let payload: PayloadToService = serde_json::from_str(content.as_str()).unwrap();
-
-        let config = revolt_config::config().await;
+    ) -> Result<()> {
+        let content = String::from_utf8(content)?;
+        let payload: PayloadToService = serde_json::from_str(content.as_str())?;
 
         #[allow(clippy::needless_late_init)]
         let resp: Result<Message, FcmError>;
@@ -94,7 +89,7 @@ impl AsyncConsumer for FcmOutboundConsumer {
                         alert.from_user.username, alert.from_user.discriminator
                     )))
                     .clone()
-                    .unwrap();
+                    .ok_or_else(|| anyhow!("missing name"))?;
 
                 let mut data = HashMap::new();
                 data.insert(
@@ -122,7 +117,7 @@ impl AsyncConsumer for FcmOutboundConsumer {
                         alert.accepted_user.username, alert.accepted_user.discriminator
                     )))
                     .clone()
-                    .unwrap();
+                    .ok_or_else(|| anyhow!("missing name"))?;
 
                 let mut data: HashMap<String, Value> = HashMap::new();
                 data.insert(
@@ -175,7 +170,7 @@ impl AsyncConsumer for FcmOutboundConsumer {
             }
 
             PayloadKind::BadgeUpdate(_) => {
-                panic!("FCM cannot handle badge updates, and they should not be sent here.")
+                bail!("FCM cannot handle badge updates and they should not be sent here.");
             }
         }
 
@@ -195,5 +190,27 @@ impl AsyncConsumer for FcmOutboundConsumer {
                 }
             }
         }
+
+        Ok(())
+    }
+}
+
+#[allow(unused_variables)]
+#[async_trait]
+impl AsyncConsumer for FcmOutboundConsumer {
+    async fn consume(
+        &mut self,
+        channel: &AmqpChannel,
+        deliver: Deliver,
+        basic_properties: BasicProperties,
+        content: Vec<u8>,
+    ) {
+        if let Err(err) = self
+            .consume_event(channel, deliver, basic_properties, content)
+            .await
+        {
+            revolt_config::capture_anyhow(&err);
+            eprintln!("Failed to process FCM event: {err:?}");
+        }
     }
 }

crates/daemons/pushd/src/consumers/outbound/vapid.rs

@@ -2,13 +2,13 @@ use std::collections::HashMap;
 
 use amqprs::{channel::Channel as AmqpChannel, consumer::AsyncConsumer, BasicProperties, Deliver};
 
+use anyhow::{anyhow, bail, Result};
 use async_trait::async_trait;
 use base64::{
     engine::{self},
     Engine as _,
 };
 use revolt_database::{events::rabbit::*, Database};
-// use revolt_models::v0::{Channel, PushNotification};
 use web_push::{
     ContentEncoding, IsahcWebPushClient, SubscriptionInfo, SubscriptionKeys, VapidSignatureBuilder,
     WebPushClient, WebPushError, WebPushMessageBuilder,
@@ -21,11 +21,11 @@ pub struct VapidOutboundConsumer {
 }
 
 impl VapidOutboundConsumer {
-    pub async fn new(db: Database) -> Result<VapidOutboundConsumer, &'static str> {
+    pub async fn new(db: Database) -> Result<VapidOutboundConsumer> {
         let config = revolt_config::config().await;
 
         if config.pushd.vapid.private_key.is_empty() | config.pushd.vapid.public_key.is_empty() {
-            return Err("No Vapid keys present");
+            bail!("no Vapid keys present");
         }
 
         let web_push_private_key = engine::general_purpose::URL_SAFE_NO_PAD
@@ -38,28 +38,30 @@ impl VapidOutboundConsumer {
             pkey: web_push_private_key,
         })
     }
-}
 
-#[allow(unused_variables)]
-#[async_trait]
-impl AsyncConsumer for VapidOutboundConsumer {
-    async fn consume(
+    async fn consume_event(
         &mut self,
-        channel: &AmqpChannel,
-        deliver: Deliver,
-        basic_properties: BasicProperties,
+        _channel: &AmqpChannel,
+        _deliver: Deliver,
+        _basic_properties: BasicProperties,
         content: Vec<u8>,
-    ) {
-        let content = String::from_utf8(content).unwrap();
-        let payload: PayloadToService = serde_json::from_str(content.as_str()).unwrap();
-
-        let config = revolt_config::config().await;
+    ) -> Result<()> {
+        let content = String::from_utf8(content)?;
+        let payload: PayloadToService = serde_json::from_str(content.as_str())?;
 
         let subscription = SubscriptionInfo {
-            endpoint: payload.extras.get("endpoint").unwrap().clone(),
+            endpoint: payload
+                .extras
+                .get("endpoint")
+                .ok_or_else(|| anyhow!("missing endpoint"))?
+                .clone(),
             keys: SubscriptionKeys {
                 auth: payload.token,
-                p256dh: payload.extras.get("p256dh").unwrap().clone(),
+                p256dh: payload
+                    .extras
+                    .get("p256dh")
+                    .ok_or_else(|| anyhow!("missing p256dh"))?
+                    .clone(),
             },
         };
 
@@ -76,12 +78,12 @@ impl AsyncConsumer for VapidOutboundConsumer {
                         alert.from_user.username, alert.from_user.discriminator
                     )))
                     .clone()
-                    .unwrap();
+                    .ok_or_else(|| anyhow!("missing name"))?;
 
                 let mut body = HashMap::new();
                 body.insert("body", format!("{} sent you a friend request", name));
 
-                payload_body = serde_json::to_string(&body).unwrap();
+                payload_body = serde_json::to_string(&body)?;
             }
             PayloadKind::FRAccepted(alert) => {
                 let name = alert
@@ -92,21 +94,21 @@ impl AsyncConsumer for VapidOutboundConsumer {
                         alert.accepted_user.username, alert.accepted_user.discriminator
                     )))
                     .clone()
-                    .unwrap();
+                    .ok_or_else(|| anyhow!("missing name"))?;
 
                 let mut body = HashMap::new();
                 body.insert("body", format!("{} accepted your friend request", name));
 
-                payload_body = serde_json::to_string(&body).unwrap();
+                payload_body = serde_json::to_string(&body)?;
             }
             PayloadKind::Generic(alert) => {
-                payload_body = serde_json::to_string(&alert).unwrap();
+                payload_body = serde_json::to_string(&alert)?;
             }
             PayloadKind::MessageNotification(alert) => {
-                payload_body = serde_json::to_string(&alert).unwrap();
+                payload_body = serde_json::to_string(&alert)?;
             }
             PayloadKind::BadgeUpdate(_) => {
-                panic!("Vapid cannot handle badge updates, and they should not be sent here.")
+                bail!("Vapid cannot handle badge updates and they should not be sent here.");
             }
         }
 
@@ -122,28 +124,40 @@ impl AsyncConsumer for VapidOutboundConsumer {
                         Ok(msg) => {
                             if let Err(err) = self.client.send(msg).await {
                                 if err == WebPushError::Unauthorized {
-                                    if let Err(err) = self
-                                        .db
+                                    self.db
                                         .remove_push_subscription_by_session_id(&payload.session_id)
-                                        .await
-                                    {
-                                        revolt_config::capture_error(&err);
-                                    }
+                                        .await?;
                                 }
                             }
+
+                            Ok(())
                         }
-                        Err(err) => {
-                            revolt_config::capture_error(&err);
-                        }
+                        Err(err) => Err(err.into()),
                     }
                 }
-                Err(err) => {
-                    revolt_config::capture_error(&err);
-                }
+                Err(err) => Err(err.into()),
             },
-            Err(err) => {
-                revolt_config::capture_error(&err);
-            }
+            Err(err) => Err(err.into()),
+        }
+    }
+}
+
+#[allow(unused_variables)]
+#[async_trait]
+impl AsyncConsumer for VapidOutboundConsumer {
+    async fn consume(
+        &mut self,
+        channel: &AmqpChannel,
+        deliver: Deliver,
+        basic_properties: BasicProperties,
+        content: Vec<u8>,
+    ) {
+        if let Err(err) = self
+            .consume_event(channel, deliver, basic_properties, content)
+            .await
+        {
+            revolt_config::capture_anyhow(&err);
+            eprintln!("Failed to process Vapid event: {err:?}");
         }
     }
 }

crates/daemons/pushd/src/main.rs

@@ -24,8 +24,8 @@ use consumers::{
 
 #[tokio::main(flavor = "multi_thread", worker_threads = 2)]
 async fn main() {
-    let config = config().await;
-    pretty_env_logger::init();
+    // Configure logging and environment
+    revolt_config::configure!(pushd);
 
     // Setup database
     let db = revolt_database::DatabaseInfo::Auto.connect().await.unwrap();
@@ -52,6 +52,8 @@ async fn main() {
     // This'll require some interesting shimming if we need to add more events once this is in prod (different payloads between prod and test),
     // but that sounds like a problem for future us.
 
+    let config = config().await;
+
     // inbound: generic
     connections.push(
         make_queue_and_consume(

crates/delta/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-delta"
-version = "0.8.5"
+version = "0.8.8"
 license = "AGPL-3.0-or-later"
 authors = ["Paul Makles <paulmakles@gmail.com>"]
 edition = "2018"
@@ -56,7 +56,7 @@ lettre = "0.10.0-alpha.4"
 rocket = { version = "0.5.1", default-features = false, features = ["json"] }
 rocket_cors = { git = "https://github.com/lawliet89/rocket_cors", rev = "072d90359b23e9b291df6b672c07c93de9c46011" }
 rocket_empty = { version = "0.1.1", features = ["schema"] }
-rocket_authifier = { version = "1.0.13" }
+rocket_authifier = { version = "1.0.15" }
 rocket_prometheus = "0.10.0-rc.3"
 
 # spec generation
@@ -67,7 +67,7 @@ revolt_rocket_okapi = { version = "0.10.0", features = ["swagger"] }
 amqprs = { version = "1.7.0" }
 
 # core
-authifier = "1.0.13"
+authifier = "1.0.15"
 revolt-config = { path = "../core/config" }
 revolt-database = { path = "../core/database", features = [
     "rocket-impl",

crates/delta/fixtures/server_with_many_roles.json

@@ -0,0 +1,114 @@
+[
+  {
+    "_object_type": "User",
+    "_id": "__ID:0__",
+    "username": "Owner",
+    "last_acknowledged_policy_change": "2025-06-07T04:04:48+0000",
+    "discriminator": "0001"
+  },
+  {
+    "_object_type": "User",
+    "_id": "__ID:1__",
+    "username": "Moderator",
+    "last_acknowledged_policy_change": "2025-06-07T04:04:48+0000",
+    "discriminator": "0001"
+  },
+  {
+    "_object_type": "User",
+    "_id": "__ID:2__",
+    "username": "User",
+    "last_acknowledged_policy_change": "2025-06-07T04:04:48+0000",
+    "discriminator": "0001"
+  },
+  {
+    "_object_type": "Channel",
+    "_id": "__ID:3__",
+    "channel_type": "TextChannel",
+    "name": "General",
+    "server": "__ID:4__",
+    "default_permissions": {
+      "a": 0,
+      "d": 1048576
+    },
+    "role_permissions": {
+      "__ID:5__": {
+        "a": 1048576,
+        "d": 0
+      }
+    }
+  },
+  {
+    "_object_type": "Server",
+    "_id": "__ID:4__",
+    "owner": "__ID:0__",
+    "name": "Server",
+    "channels": [
+      "__ID:3__"
+    ],
+    "roles": {
+      "__ID:5__": {
+        "name": "Moderator",
+        "permissions": {
+          "a": 545270216,
+          "d": 0
+        },
+        "rank": 1
+      },
+      "__ID:6__": {
+        "name": "Owner",
+        "permissions": {
+          "a": 0,
+          "d": 0
+        },
+        "rank": 0
+      },
+      "__ID:7__": {
+        "name": "Lower Rank 1",
+        "permissions": {
+          "a": 0,
+          "d": 0
+        },
+        "rank": 2
+      },
+      "__ID:8__": {
+        "name": "Lower Rank 2",
+        "permissions": {
+          "a": 0,
+          "d": 0
+        },
+        "rank": 2
+      }
+    },
+    "default_permissions": 4000322560
+  },
+  {
+    "_object_type": "ServerMember",
+    "_id": {
+      "user": "__ID:0__",
+      "server": "__ID:4__"
+    },
+    "roles": [
+      "__ID:6__"
+    ],
+    "joined_at": 1698318340195
+  },
+  {
+    "_object_type": "ServerMember",
+    "_id": {
+      "user": "__ID:1__",
+      "server": "__ID:4__"
+    },
+    "roles": [
+      "__ID:5__"
+    ],
+    "joined_at": 1698318340195
+  },
+  {
+    "_object_type": "ServerMember",
+    "_id": {
+      "user": "__ID:2__",
+      "server": "__ID:4__"
+    },
+    "joined_at": 1698318340195
+  }
+]

crates/delta/src/routes/bots/edit.rs

@@ -37,7 +37,7 @@ pub async fn edit_bot(
     if data.public.is_none()
         && data.analytics.is_none()
         && data.interactions_url.is_none()
-        && data.remove.is_none()
+        && data.remove.is_empty()
     {
         return Ok(Json(v0::BotWithUserResponse {
             bot: bot.into(),
@@ -64,7 +64,6 @@ pub async fn edit_bot(
         db,
         partial,
         remove
-            .unwrap_or_default()
             .into_iter()
             .map(|v| v.into())
             .collect(),
@@ -100,7 +99,7 @@ mod test {
             .body(
                 json!(v0::DataEditBot {
                     public: Some(true),
-                    remove: Some(vec![FieldsBot::Token]),
+                    remove: vec![FieldsBot::Token],
                     ..Default::default()
                 })
                 .to_string(),

crates/delta/src/routes/bots/fetch_public.rs

@@ -16,7 +16,7 @@ pub async fn fetch_public_bot(
     target: Reference,
 ) -> Result<Json<PublicBot>> {
     let bot = db.fetch_bot(&target.id).await?;
-    if !bot.public && user.map_or(true, |x| x.id != bot.owner) {
+    if !bot.public && user.is_none_or(|x| x.id != bot.owner) {
         return Err(create_error!(NotFound));
     }
 

crates/delta/src/routes/channels/channel_edit.rs

@@ -38,7 +38,7 @@ pub async fn edit(
         && data.icon.is_none()
         && data.nsfw.is_none()
         && data.owner.is_none()
-        && data.remove.is_none()
+        && data.remove.is_empty()
     {
         return Ok(Json(channel.into()));
     }
@@ -112,23 +112,21 @@ pub async fn edit(
             nsfw,
             ..
         } => {
-            if let Some(fields) = &data.remove {
-                if fields.contains(&v0::FieldsChannel::Icon) {
-                    if let Some(icon) = &icon {
-                        db.mark_attachment_as_deleted(&icon.id).await?;
-                    }
+            if data.remove.contains(&v0::FieldsChannel::Icon) {
+                if let Some(icon) = &icon {
+                    db.mark_attachment_as_deleted(&icon.id).await?;
                 }
+            }
 
-                for field in fields {
-                    match field {
-                        v0::FieldsChannel::Description => {
-                            description.take();
-                        }
-                        v0::FieldsChannel::Icon => {
-                            icon.take();
-                        }
-                        _ => {}
+            for field in &data.remove {
+                match field {
+                    v0::FieldsChannel::Description => {
+                        description.take();
                     }
+                    v0::FieldsChannel::Icon => {
+                        icon.take();
+                    }
+                    _ => {}
                 }
             }
 
@@ -214,11 +212,7 @@ pub async fn edit(
                 .update(
                     db,
                     partial,
-                    data.remove
-                        .unwrap_or_default()
-                        .into_iter()
-                        .map(|f| f.into())
-                        .collect(),
+                    data.remove.into_iter().map(|f| f.into()).collect(),
                 )
                 .await?;
         }

crates/delta/src/routes/channels/members_fetch.rs

@@ -1,4 +1,3 @@
-use futures::future::join_all;
 use revolt_database::{
     util::{permissions::DatabasePermissionQuery, reference::Reference},
     Channel, Database, User,

crates/delta/src/routes/channels/message_bulk_delete.rs

@@ -8,7 +8,6 @@ use revolt_permissions::{calculate_channel_permissions, ChannelPermission};
 use revolt_result::{create_error, Result};
 use rocket::{serde::json::Json, State};
 use rocket_empty::EmptyResponse;
-use serde::Deserialize;
 use validator::Validate;
 
 /// # Bulk Delete Messages

crates/delta/src/routes/channels/message_edit.rs

@@ -1,5 +1,4 @@
 use iso8601_timestamp::Timestamp;
-use revolt_config::config;
 use revolt_database::{
     tasks,
     util::{permissions::DatabasePermissionQuery, reference::Reference},

crates/delta/src/routes/channels/message_send.rs

@@ -84,7 +84,8 @@ pub async fn message_send(
     // Create model user / members
     let model_user = user
         .clone()
-        .into_known_static(revolt_presence::is_online(&user.id).await).await;
+        .into_known_static(revolt_presence::is_online(&user.id).await)
+        .await;
 
     let model_member: Option<v0::Member> = query
         .member_ref()
@@ -491,7 +492,7 @@ mod test {
         let (_, _, other_user) = harness.new_user().await;
         let (server, _) = harness.new_server(&user).await;
         let channel = harness.new_channel(&server).await;
-        let (role_id, mut role) = harness
+        let (role_id, _role) = harness
             .new_role(
                 &server,
                 1,

crates/delta/src/routes/channels/mod.rs

@@ -50,7 +50,7 @@ pub fn routes() -> (Vec<Route>, OpenApi) {
         group_remove_member::remove_member,
         voice_join::call,
         permissions_set::set_role_permissions,
-        permissions_set_default::set_default_permissions,
+        permissions_set_default::set_default_channel_permissions,
         message_react::react_message,
         message_unreact::unreact_message,
         message_clear_reactions::clear_reactions,

crates/delta/src/routes/channels/permissions_set.rs

@@ -1,12 +1,11 @@
 use revolt_database::{
     util::{permissions::DatabasePermissionQuery, reference::Reference},
-    Channel, Database, User,
+    Database, User,
 };
 use revolt_models::v0;
 use revolt_permissions::{calculate_channel_permissions, ChannelPermission, Override};
 use revolt_result::{create_error, Result};
 use rocket::{serde::json::Json, State};
-use serde::Deserialize;
 
 /// # Set Role Permission
 ///

crates/delta/src/routes/channels/permissions_set_default.rs

@@ -14,7 +14,7 @@ use rocket::{serde::json::Json, State};
 /// Channel must be a `Group`, `TextChannel` or `VoiceChannel`.
 #[openapi(tag = "Channel Permissions")]
 #[put("/<target>/permissions/default", data = "<data>", rank = 1)]
-pub async fn set_default_permissions(
+pub async fn set_default_channel_permissions(
     db: &State<Database>,
     user: User,
     target: Reference,

crates/delta/src/routes/channels/voice_join.rs

@@ -41,7 +41,7 @@ pub async fn call(
     // - If not, create it.
     let client = reqwest::Client::new();
     let result = client
-        .get(&format!(
+        .get(format!(
             "{}/room/{}",
             config.hosts.voso_legacy,
             channel.id()
@@ -59,7 +59,7 @@ pub async fn call(
             reqwest::StatusCode::OK => (),
             reqwest::StatusCode::NOT_FOUND => {
                 if (client
-                    .post(&format!(
+                    .post(format!(
                         "{}/room/{}",
                         config.hosts.voso_legacy,
                         channel.id()
@@ -81,7 +81,7 @@ pub async fn call(
 
     // Then create a user for the room.
     if let Ok(response) = client
-        .post(&format!(
+        .post(format!(
             "{}/room/{}/user/{}",
             config.hosts.voso_legacy,
             channel.id(),

crates/delta/src/routes/customisation/emoji_delete.rs

@@ -3,7 +3,7 @@ use revolt_database::{
     Database, EmojiParent, User,
 };
 use revolt_permissions::{calculate_server_permissions, ChannelPermission};
-use revolt_result::{create_error, Result};
+use revolt_result::Result;
 
 use rocket::State;
 use rocket_empty::EmptyResponse;
@@ -18,7 +18,6 @@ pub async fn delete_emoji(
     user: User,
     emoji_id: Reference,
 ) -> Result<EmptyResponse> {
-
     // Fetch the emoji
     let emoji = emoji_id.as_emoji(db).await?;
 

crates/delta/src/routes/mod.rs

@@ -1,4 +1,4 @@
-use revolt_config::{config, Settings};
+use revolt_config::Settings;
 use revolt_rocket_okapi::{revolt_okapi::openapi3::OpenApi, settings::OpenApiSettings};
 pub use rocket::http::Status;
 pub use rocket::response::Redirect;
@@ -9,6 +9,7 @@ mod channels;
 mod customisation;
 mod invites;
 mod onboard;
+mod policy;
 mod push;
 mod root;
 mod safety;
@@ -36,6 +37,7 @@ pub fn mount(config: Settings, mut rocket: Rocket<Build>) -> Rocket<Build> {
             "/auth/session" => rocket_authifier::routes::session::routes(),
             "/auth/mfa" => rocket_authifier::routes::mfa::routes(),
             "/onboard" => onboard::routes(),
+            "/policy" => policy::routes(),
             "/push" => push::routes(),
             "/sync" => sync::routes(),
             "/webhooks" => webhooks::routes()
@@ -56,6 +58,7 @@ pub fn mount(config: Settings, mut rocket: Rocket<Build>) -> Rocket<Build> {
             "/auth/session" => rocket_authifier::routes::session::routes(),
             "/auth/mfa" => rocket_authifier::routes::mfa::routes(),
             "/onboard" => onboard::routes(),
+            "/policy" => policy::routes(),
             "/push" => push::routes(),
             "/sync" => sync::routes()
         };

crates/delta/src/routes/policy/acknowledge_policy_changes.rs

@@ -0,0 +1,13 @@
+use revolt_database::{Database, User};
+use revolt_result::Result;
+
+use rocket::State;
+
+/// # Acknowledge Policy Changes
+///
+/// Accept/acknowledge changes to platform policy.
+#[openapi(tag = "Policy")]
+#[post("/acknowledge")]
+pub async fn acknowledge_policy_changes(db: &State<Database>, user: User) -> Result<()> {
+    db.acknowledge_policy_changes(&user.id).await
+}

crates/delta/src/routes/policy/mod.rs

@@ -0,0 +1,11 @@
+use revolt_rocket_okapi::revolt_okapi::openapi3::OpenApi;
+use rocket::Route;
+
+mod acknowledge_policy_changes;
+
+pub fn routes() -> (Vec<Route>, OpenApi) {
+    openapi_get_routes_spec![
+        // Policy
+        acknowledge_policy_changes::acknowledge_policy_changes,
+    ]
+}

crates/delta/src/routes/root.rs

@@ -136,7 +136,6 @@ pub async fn root() -> Result<Json<RevoltConfig>> {
 }
 
 #[cfg(test)]
-#[cfg(feature = "FIXME: THIS TEST CAUSES cargo test TO SEG FAULT, I HAVE NO CLUE HOW")]
 mod test {
     use crate::rocket;
     use rocket::http::Status;

crates/delta/src/routes/servers/ban_create.rs

@@ -4,12 +4,9 @@ use revolt_database::{
 };
 use revolt_models::v0;
 
-use revolt_permissions::{
-    calculate_channel_permissions, calculate_server_permissions, ChannelPermission,
-};
+use revolt_permissions::{calculate_server_permissions, ChannelPermission};
 use revolt_result::{create_error, Result};
 use rocket::{serde::json::Json, State};
-use serde::{Deserialize, Serialize};
 use validator::Validate;
 
 /// # Ban User

crates/delta/src/routes/servers/member_edit.rs

@@ -39,13 +39,7 @@ pub async fn edit(
     let permissions = calculate_server_permissions(&mut query).await;
 
     // Check permissions in server
-    if data.nickname.is_some()
-        || data
-            .remove
-            .as_ref()
-            .map(|x| x.contains(&v0::FieldsMember::Nickname))
-            .unwrap_or_default()
-    {
+    if data.nickname.is_some() || data.remove.contains(&v0::FieldsMember::Nickname) {
         if user.id == member.id.user {
             permissions.throw_if_lacking_channel_permission(ChannelPermission::ChangeNickname)?;
         } else {
@@ -53,13 +47,7 @@ pub async fn edit(
         }
     }
 
-    if data.avatar.is_some()
-        || data
-            .remove
-            .as_ref()
-            .map(|x| x.contains(&v0::FieldsMember::Avatar))
-            .unwrap_or_default()
-    {
+    if data.avatar.is_some() || data.remove.contains(&v0::FieldsMember::Avatar) {
         if user.id == member.id.user {
             permissions.throw_if_lacking_channel_permission(ChannelPermission::ChangeAvatar)?;
         } else {
@@ -67,23 +55,11 @@ pub async fn edit(
         }
     }
 
-    if data.roles.is_some()
-        || data
-            .remove
-            .as_ref()
-            .map(|x| x.contains(&v0::FieldsMember::Roles))
-            .unwrap_or_default()
-    {
+    if data.roles.is_some() || data.remove.contains(&v0::FieldsMember::Roles) {
         permissions.throw_if_lacking_channel_permission(ChannelPermission::AssignRoles)?;
     }
 
-    if data.timeout.is_some()
-        || data
-            .remove
-            .as_ref()
-            .map(|x| x.contains(&v0::FieldsMember::Timeout))
-            .unwrap_or_default()
-    {
+    if data.timeout.is_some() || data.remove.contains(&v0::FieldsMember::Timeout) {
         if data.timeout.is_some() && member.id.user == user.id {
             return Err(create_error!(CannotTimeoutYourself));
         }
@@ -136,11 +112,9 @@ pub async fn edit(
     };
 
     // 1. Remove fields from object
-    if let Some(fields) = &remove {
-        if fields.contains(&v0::FieldsMember::Avatar) {
-            if let Some(avatar) = &member.avatar {
-                db.mark_attachment_as_deleted(&avatar.id).await?;
-            }
+    if remove.contains(&v0::FieldsMember::Avatar) {
+        if let Some(avatar) = &member.avatar {
+            db.mark_attachment_as_deleted(&avatar.id).await?;
         }
     }
 
@@ -150,13 +124,7 @@ pub async fn edit(
     }
 
     member
-        .update(
-            db,
-            partial,
-            remove
-                .map(|v| v.into_iter().map(Into::into).collect())
-                .unwrap_or_default(),
-        )
+        .update(db, partial, remove.into_iter().map(Into::into).collect())
         .await?;
 
     Ok(Json(member.into()))

crates/delta/src/routes/servers/mod.rs

@@ -17,6 +17,7 @@ mod permissions_set_default;
 mod roles_create;
 mod roles_delete;
 mod roles_edit;
+mod roles_edit_positions;
 mod roles_fetch;
 mod server_ack;
 mod server_create;
@@ -46,7 +47,8 @@ pub fn routes() -> (Vec<Route>, OpenApi) {
         roles_fetch::fetch,
         roles_delete::delete,
         permissions_set::set_role_permission,
-        permissions_set_default::set_default_permissions,
-        emoji_list::list_emoji
+        permissions_set_default::set_default_server_permissions,
+        emoji_list::list_emoji,
+        roles_edit_positions::edit_role_ranks
     ]
 }

crates/delta/src/routes/servers/permissions_set_default.rs

@@ -1,6 +1,6 @@
 use revolt_database::{
     util::{permissions::DatabasePermissionQuery, reference::Reference},
-    Database, PartialServer, Server, User,
+    Database, PartialServer, User,
 };
 use revolt_models::v0;
 use revolt_permissions::{
@@ -14,7 +14,7 @@ use rocket::{serde::json::Json, State};
 /// Sets permissions for the default role in this server.
 #[openapi(tag = "Server Permissions")]
 #[put("/<target>/permissions/default", data = "<data>", rank = 1)]
-pub async fn set_default_permissions(
+pub async fn set_default_server_permissions(
     db: &State<Database>,
     user: User,
     target: Reference,

crates/delta/src/routes/servers/roles_create.rs

@@ -40,20 +40,10 @@ pub async fn create(
         }));
     };
 
-    let member_rank = query.get_member_rank();
-    let rank = if let Some(given_rank) = data.rank {
-        if given_rank <= member_rank.unwrap_or(i64::MIN) {
-            return Err(create_error!(NotElevated));
-        }
-
-        given_rank
-    } else {
-        member_rank.unwrap_or(0).saturating_add(1)
-    };
-
     let role = Role {
         name: data.name,
-        rank,
+        // Rank of the new role should be below the lowest role
+        rank: server.roles.len() as i64,
         colour: None,
         hoist: false,
         permissions: Default::default(),

crates/delta/src/routes/servers/roles_edit.rs

@@ -6,14 +6,13 @@ use revolt_models::v0;
 use revolt_permissions::{calculate_server_permissions, ChannelPermission};
 use revolt_result::{create_error, Result};
 use rocket::{serde::json::Json, State};
-use serde::{Deserialize, Serialize};
 use validator::Validate;
 
 /// # Edit Role
 ///
 /// Edit a role by its id.
 #[openapi(tag = "Server Permissions")]
-#[patch("/<target>/roles/<role_id>", data = "<data>")]
+#[patch("/<target>/roles/<role_id>", data = "<data>", rank = 1)]
 pub async fn edit(
     db: &State<Database>,
     user: User,
@@ -46,22 +45,14 @@ pub async fn edit(
             name,
             colour,
             hoist,
-            rank,
             remove,
+            ..
         } = data;
 
-        // Prevent us from moving a role above other roles
-        if let Some(rank) = &rank {
-            if rank <= &member_rank {
-                return Err(create_error!(NotElevated));
-            }
-        }
-
         let partial = PartialRole {
             name,
             colour,
             hoist,
-            rank,
             ..Default::default()
         };
 
@@ -70,9 +61,7 @@ pub async fn edit(
             &server.id,
             &role_id,
             partial,
-            remove
-                .map(|v| v.into_iter().map(Into::into).collect())
-                .unwrap_or_default(),
+            remove.into_iter().map(Into::into).collect(),
         )
         .await?;
 

crates/delta/src/routes/servers/roles_edit_positions.rs

@@ -0,0 +1,177 @@
+use revolt_database::{
+    util::{permissions::DatabasePermissionQuery, reference::Reference},
+    Database, User,
+};
+use revolt_models::v0;
+use revolt_permissions::{calculate_server_permissions, ChannelPermission};
+use revolt_result::{create_error, Result};
+use rocket::{serde::json::Json, State};
+
+/// # Edits server roles ranks
+///
+/// Edit's server role's ranks.
+#[openapi(tag = "Server Permissions")]
+#[patch("/<target>/roles/ranks", data = "<data>")]
+pub async fn edit_role_ranks(
+    db: &State<Database>,
+    user: User,
+    target: Reference,
+    data: Json<v0::DataEditRoleRanks>,
+) -> Result<Json<v0::Server>> {
+    let data = data.into_inner();
+
+    let mut server = target.as_server(db).await?;
+    let mut query = DatabasePermissionQuery::new(db, &user).server(&server);
+    calculate_server_permissions(&mut query)
+        .await
+        .throw_if_lacking_channel_permission(ChannelPermission::ManageRole)?;
+
+    let existing_order = server
+        .ordered_roles()
+        .into_iter()
+        .map(|(id, _)| id)
+        .collect::<Vec<_>>();
+
+    let new_order = data.ranks.clone().into_iter().collect::<Vec<_>>();
+
+    // Verify all roles are in the new ordering
+    if data.ranks.len() != server.roles.len()
+        || !server.roles.iter().all(|(id, _)| data.ranks.contains(id))
+    {
+        return Err(create_error!(InvalidOperation));
+    }
+
+    // Don't have to check what the user can't modify if they are the server owner
+    if server.owner != user.id {
+        let member_top_rank = query.get_member_rank();
+
+        if server
+            .roles
+            .iter()
+            // Find all roles above the member which we should not be able to reorder
+            .filter(|(_, role)| {
+                if let Some(top_rank) = member_top_rank {
+                    role.rank <= top_rank
+                } else {
+                    true
+                }
+            })
+            // Check if user is trying to reorder roles they can't reorder (as found previously)
+            .any(|(id, _)| {
+                existing_order
+                    .iter()
+                    .position(|existing_id| id == existing_id)
+                    != new_order.iter().position(|new_id| id == new_id)
+            })
+        {
+            return Err(create_error!(NotElevated));
+        }
+    }
+
+    server.set_role_ordering(db, new_order).await?;
+
+    Ok(Json(server.into()))
+}
+
+#[cfg(test)]
+mod test {
+    use revolt_database::fixture;
+    use revolt_models::v0;
+    use rocket::http::{ContentType, Header, Status};
+
+    use crate::util::test::TestHarness;
+
+    #[rocket::async_test]
+    async fn edit_role_rankings() {
+        let harness = TestHarness::new().await;
+
+        fixture!(harness.db, "server_with_many_roles",
+            owner user 0
+            moderator user 1
+            server server 4);
+
+        // Moderator can re-order the roles below them
+        let (_, moderator_session) = harness.account_from_user(moderator.id).await;
+        let mut target_order: Vec<String> = server
+            .ordered_roles()
+            .into_iter()
+            .map(|(id, _)| id)
+            .collect();
+
+        // Swap the two lower ranked roles
+        target_order.swap(2, 3);
+
+        let response = harness
+            .client
+            .patch(format!("/servers/{}/roles/ranks", server.id))
+            .header(ContentType::JSON)
+            .body(
+                json!(v0::DataEditRoleRanks {
+                    ranks: target_order.clone()
+                })
+                .to_string(),
+            )
+            .header(Header::new(
+                "x-session-token",
+                moderator_session.token.to_string(),
+            ))
+            .dispatch()
+            .await;
+
+        assert_eq!(response.status(), Status::Ok);
+        drop(response);
+
+        // ... but not above them
+        let mut target_order: Vec<String> = server
+            .ordered_roles()
+            .into_iter()
+            .map(|(id, _)| id)
+            .collect();
+
+        // Swap the two lower ranked roles
+        target_order.swap(0, 1);
+
+        let response = harness
+            .client
+            .patch(format!("/servers/{}/roles/ranks", server.id))
+            .header(ContentType::JSON)
+            .body(
+                json!(v0::DataEditRoleRanks {
+                    ranks: target_order.clone()
+                })
+                .to_string(),
+            )
+            .header(Header::new(
+                "x-session-token",
+                moderator_session.token.to_string(),
+            ))
+            .dispatch()
+            .await;
+
+        assert_eq!(response.status(), Status::Forbidden);
+        drop(response);
+
+        // The owner can set any order they want
+        let (_, owner_session) = harness.account_from_user(owner.id).await;
+
+        let response = harness
+            .client
+            .patch(format!("/servers/{}/roles/ranks", server.id))
+            .header(ContentType::JSON)
+            .body(
+                json!(v0::DataEditRoleRanks {
+                    ranks: target_order.clone()
+                })
+                .to_string(),
+            )
+            .header(Header::new(
+                "x-session-token",
+                owner_session.token.to_string(),
+            ))
+            .dispatch()
+            .await;
+
+        assert_eq!(response.status(), Status::Ok);
+        drop(response);
+    }
+}

crates/delta/src/routes/servers/server_edit.rs

@@ -43,7 +43,7 @@ pub async fn edit(
         && data.flags.is_none()
         && data.analytics.is_none()
         && data.discoverable.is_none()
-        && data.remove.is_none()
+        && data.remove.is_empty()
     {
         return Ok(Json(server.into()));
     } else if data.name.is_some()
@@ -52,7 +52,7 @@ pub async fn edit(
         || data.banner.is_some()
         || data.system_messages.is_some()
         || data.analytics.is_some()
-        || data.remove.is_some()
+        || !data.remove.is_empty()
     {
         permissions.throw_if_lacking_channel_permission(ChannelPermission::ManageServer)?;
     }
@@ -96,17 +96,15 @@ pub async fn edit(
     };
 
     // 1. Remove fields from object
-    if let Some(fields) = &remove {
-        if fields.contains(&v0::FieldsServer::Banner) {
-            if let Some(banner) = &server.banner {
-                db.mark_attachment_as_deleted(&banner.id).await?;
-            }
+    if remove.contains(&v0::FieldsServer::Banner) {
+        if let Some(banner) = &server.banner {
+            db.mark_attachment_as_deleted(&banner.id).await?;
         }
+    }
 
-        if fields.contains(&v0::FieldsServer::Icon) {
-            if let Some(icon) = &server.icon {
-                db.mark_attachment_as_deleted(&icon.id).await?;
-            }
+    if remove.contains(&v0::FieldsServer::Icon) {
+        if let Some(icon) = &server.icon {
+            db.mark_attachment_as_deleted(&icon.id).await?;
         }
     }
 
@@ -149,13 +147,7 @@ pub async fn edit(
     }
 
     server
-        .update(
-            db,
-            partial,
-            remove
-                .map(|v| v.into_iter().map(Into::into).collect())
-                .unwrap_or_default(),
-        )
+        .update(db, partial, remove.into_iter().map(Into::into).collect())
         .await?;
 
     Ok(Json(server.into()))

crates/delta/src/routes/users/edit_user.rs

@@ -53,31 +53,29 @@ pub async fn edit(
         && data.avatar.is_none()
         && data.badges.is_none()
         && data.flags.is_none()
-        && data.remove.is_none()
+        && data.remove.is_empty()
     {
         return Ok(Json(user.into_self(false).await));
     }
 
     // 1. Remove fields from object
-    if let Some(fields) = &data.remove {
-        if fields.contains(&v0::FieldsUser::Avatar) {
-            if let Some(avatar) = &user.avatar {
-                db.mark_attachment_as_deleted(&avatar.id).await?;
+    if data.remove.contains(&v0::FieldsUser::Avatar) {
+        if let Some(avatar) = &user.avatar {
+            db.mark_attachment_as_deleted(&avatar.id).await?;
+        }
+    }
+
+    if data.remove.contains(&v0::FieldsUser::ProfileBackground) {
+        if let Some(profile) = &user.profile {
+            if let Some(background) = &profile.background {
+                db.mark_attachment_as_deleted(&background.id).await?;
             }
         }
+    }
 
-        if fields.contains(&v0::FieldsUser::ProfileBackground) {
-            if let Some(profile) = &user.profile {
-                if let Some(background) = &profile.background {
-                    db.mark_attachment_as_deleted(&background.id).await?;
-                }
-            }
-        }
-
-        for field in fields {
-            let field: FieldsUser = field.clone().into();
-            user.remove_field(&field);
-        }
+    for field in &data.remove {
+        let field: FieldsUser = field.clone().into();
+        user.remove_field(&field);
     }
 
     let mut partial: PartialUser = PartialUser {
@@ -124,9 +122,7 @@ pub async fn edit(
     user.update(
         db,
         partial,
-        data.remove
-            .map(|v| v.into_iter().map(Into::into).collect())
-            .unwrap_or_default(),
+        data.remove.into_iter().map(Into::into).collect(),
     )
     .await?;
 

crates/delta/src/routes/users/fetch_user_flags.rs

@@ -2,7 +2,6 @@ use revolt_database::{util::reference::Reference, Database};
 use revolt_models::v0;
 use revolt_result::Result;
 use rocket::{serde::json::Json, State};
-use serde::Serialize;
 
 /// # Fetch User Flags
 ///

crates/delta/src/routes/webhooks/webhook_execute.rs

@@ -36,11 +36,11 @@ pub async fn webhook_execute(
     let permissions: PermissionValue = webhook.permissions.into();
     permissions.throw_if_lacking_channel_permission(ChannelPermission::SendMessage)?;
 
-    if data.attachments.as_ref().map_or(false, |v| !v.is_empty()) {
+    if data.attachments.as_ref().is_some_and(|v| !v.is_empty()) {
         permissions.throw_if_lacking_channel_permission(ChannelPermission::UploadFiles)?;
     }
 
-    if data.embeds.as_ref().map_or(false, |v| !v.is_empty()) {
+    if data.embeds.as_ref().is_some_and(|v| !v.is_empty()) {
         permissions.throw_if_lacking_channel_permission(ChannelPermission::SendEmbeds)?;
     }