feat(admin): add global message query route

fix: separate privileged check when editing server

Cargo.lock

@@ -2170,7 +2170,7 @@ dependencies = [
 [[package]]
 name = "optional_struct"
 version = "0.2.0"
-source = "git+https://github.com/insertish/OptionalStruct?rev=e275d2726595474632485934aa0887fa52281f70#e275d2726595474632485934aa0887fa52281f70"
+source = "git+https://github.com/insertish/OptionalStruct?rev=ee56427cee1f007839825d93d07fffd5a5e038c7#ee56427cee1f007839825d93d07fffd5a5e038c7"
 dependencies = [
  "quote 0.3.15",
  "syn 0.11.11",
@@ -2792,7 +2792,7 @@ dependencies = [
 
 [[package]]
 name = "revolt-bonfire"
-version = "0.5.10"
+version = "0.5.16"
 dependencies = [
  "async-std",
  "async-tungstenite",
@@ -2808,7 +2808,7 @@ dependencies = [
 
 [[package]]
 name = "revolt-delta"
-version = "0.5.10"
+version = "0.5.16"
 dependencies = [
  "async-channel",
  "async-std",
@@ -2848,7 +2848,7 @@ dependencies = [
 
 [[package]]
 name = "revolt-quark"
-version = "0.5.10"
+version = "0.5.16"
 dependencies = [
  "async-lock",
  "async-recursion",

crates/bonfire/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-bonfire"
-version = "0.5.10"
+version = "0.5.16"
 license = "AGPL-3.0-or-later"
 edition = "2021"
 

crates/delta/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-delta"
-version = "0.5.10"
+version = "0.5.16"
 license = "AGPL-3.0-or-later"
 authors = ["Paul Makles <paulmakles@gmail.com>"]
 edition = "2018"

crates/delta/src/routes/admin/message_query.rs

@@ -0,0 +1,31 @@
+use revolt_quark::{
+    models::{
+        message::{BulkMessageResponse, MessageQuery},
+        User,
+    },
+    Db, Error, Result,
+};
+use rocket::serde::json::Json;
+
+/// # Globally Fetch Messages
+///
+/// This is a privileged route to globally fetch messages.
+#[openapi(tag = "Admin")]
+#[post("/messages", data = "<data>")]
+pub async fn message_query(
+    db: &Db,
+    user: User,
+    data: Json<MessageQuery>,
+) -> Result<Json<BulkMessageResponse>> {
+    // Must be privileged for this route
+    if !user.privileged {
+        return Err(Error::NotPrivileged);
+    }
+
+    // Fetch data using query
+    let data = data.into_inner();
+    let messages = db.fetch_messages(data).await?;
+    BulkMessageResponse::transform(db, None, messages, Some(true))
+        .await
+        .map(Json)
+}

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

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

crates/delta/src/routes/admin/stats.rs

@@ -0,0 +1,13 @@
+use revolt_quark::models::stats::Stats;
+use revolt_quark::{Db, Result};
+
+use rocket::serde::json::Json;
+
+/// # Query Stats
+///
+/// Fetch various technical statistics.
+#[openapi(tag = "Admin")]
+#[get("/stats")]
+pub async fn stats(db: &Db) -> Result<Json<Stats>> {
+    Ok(Json(db.generate_stats().await?))
+}

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

@@ -1,8 +1,9 @@
 use revolt_quark::{
     models::message::{PartialMessage, SendableEmbed},
     models::{Message, User},
+    perms,
     types::january::Embed,
-    Db, Error, Ref, Result, Timestamp,
+    Db, Error, Permission, Ref, Result, Timestamp,
 };
 
 use rocket::serde::json::Json;
@@ -28,7 +29,7 @@ pub struct DataEditMessage {
 pub async fn req(
     db: &Db,
     user: User,
-    target: String,
+    target: Ref,
     msg: Ref,
     edit: Json<DataEditMessage>,
 ) -> Result<Json<Message>> {
@@ -36,10 +37,17 @@ pub async fn req(
     edit.validate()
         .map_err(|error| Error::FailedValidation { error })?;
 
+    // Ensure we have permissions to send a message
+    let channel = target.as_channel(db).await?;
+    let mut permissions = perms(&user).channel(&channel);
+    permissions
+        .throw_permission_and_view_channel(db, Permission::SendMessage)
+        .await?;
+
     Message::validate_sum(&edit.content, &edit.embeds)?;
 
     let mut message = msg.as_message(db).await?;
-    if message.channel != target {
+    if message.channel != channel.id() {
         return Err(Error::NotFound);
     }
 

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

@@ -1,6 +1,8 @@
 use revolt_quark::{
     models::{
-        message::{BulkMessageResponse, MessageSort},
+        message::{
+            BulkMessageResponse, MessageFilter, MessageQuery, MessageSort, MessageTimePeriod,
+        },
         User,
     },
     perms, Db, Error, Permission, Ref, Result,
@@ -68,14 +70,28 @@ pub async fn req(
         sort,
         nearby,
         include_users,
-        ..
     } = options;
 
     let messages = db
-        .fetch_messages(channel.id(), limit, before, after, sort, nearby)
+        .fetch_messages(MessageQuery {
+            filter: MessageFilter {
+                channel: Some(channel.id().to_string()),
+                ..Default::default()
+            },
+            time_period: if let Some(nearby) = nearby {
+                MessageTimePeriod::Relative { nearby }
+            } else {
+                MessageTimePeriod::Absolute {
+                    before,
+                    after,
+                    sort,
+                }
+            },
+            limit,
+        })
         .await?;
 
-    BulkMessageResponse::transform(db, &channel, messages, include_users)
+    BulkMessageResponse::transform(db, Some(&channel), messages, include_users)
         .await
         .map(Json)
 }

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

@@ -1,6 +1,8 @@
 use revolt_quark::{
     models::{
-        message::{BulkMessageResponse, MessageSort},
+        message::{
+            BulkMessageResponse, MessageFilter, MessageQuery, MessageSort, MessageTimePeriod,
+        },
         User,
     },
     perms, Db, Error, Permission, Ref, Result,
@@ -30,7 +32,7 @@ pub struct OptionsMessageSearch {
     after: Option<String>,
     /// Message sort direction
     ///
-    /// By default, it will be sorted by relevance.
+    /// By default, it will be sorted by latest.
     #[serde(default = "MessageSort::default")]
     sort: MessageSort,
     /// Whether to include user (and member, if server channel) objects
@@ -73,10 +75,22 @@ pub async fn req(
     } = options;
 
     let messages = db
-        .search_messages(channel.id(), &query, limit, before, after, sort)
+        .fetch_messages(MessageQuery {
+            filter: MessageFilter {
+                channel: Some(channel.id().to_string()),
+                query: Some(query),
+                ..Default::default()
+            },
+            time_period: MessageTimePeriod::Absolute {
+                before,
+                after,
+                sort: Some(sort),
+            },
+            limit,
+        })
         .await?;
 
-    BulkMessageResponse::transform(db, &channel, messages, include_users)
+    BulkMessageResponse::transform(db, Some(&channel), messages, include_users)
         .await
         .map(Json)
 }

crates/delta/src/routes/mod.rs

@@ -3,6 +3,7 @@ pub use rocket::http::Status;
 pub use rocket::response::Redirect;
 use rocket::{Build, Rocket};
 
+mod admin;
 mod bots;
 mod channels;
 mod customisation;
@@ -22,6 +23,7 @@ pub fn mount(mut rocket: Rocket<Build>) -> Rocket<Build> {
         rocket, "/".to_owned(), settings,
         "/" => (vec![], custom_openapi_spec()),
         "" => openapi_get_routes_spec![root::root, root::ping],
+        "/admin" => admin::routes(),
         "/users" => users::routes(),
         "/bots" => bots::routes(),
         "/channels" => channels::routes(),
@@ -108,8 +110,9 @@ fn custom_openapi_spec() -> OpenApi {
             ]
           },
           {
-            "name": "Platform Moderation",
+            "name": "Platform Administration",
             "tags": [
+              "Admin",
               "User Safety"
             ]
           },

crates/delta/src/routes/safety/edit_report.rs

@@ -0,0 +1,56 @@
+use revolt_quark::{
+    models::{
+        report::{PartialReport, ReportStatus},
+        Report, User,
+    },
+    Db, Error, Ref, Result,
+};
+use rocket::serde::json::Json;
+use serde::Deserialize;
+use validator::Validate;
+
+/// # Report Data
+#[derive(Validate, Deserialize, JsonSchema)]
+pub struct DataEditReport {
+    /// New report status
+    status: Option<ReportStatus>,
+    /// Report notes
+    notes: Option<String>,
+}
+
+/// # Edit Report
+///
+/// Edit a report.
+#[openapi(tag = "User Safety")]
+#[patch("/reports/<report>", data = "<edit>")]
+pub async fn edit_report(
+    db: &Db,
+    user: User,
+    report: Ref,
+    edit: Json<DataEditReport>,
+) -> Result<Json<Report>> {
+    // Must be privileged for this route
+    if !user.privileged {
+        return Err(Error::NotPrivileged);
+    }
+
+    // Validate data
+    let edit = edit.into_inner();
+    edit.validate()
+        .map_err(|error| Error::FailedValidation { error })?;
+
+    // Create and apply update to report
+    let mut report = report.as_report(db).await?;
+    report
+        .update(
+            db,
+            PartialReport {
+                status: edit.status,
+                notes: edit.notes,
+                ..Default::default()
+            },
+        )
+        .await?;
+
+    Ok(Json(report))
+}

crates/delta/src/routes/safety/fetch_report.rs

@@ -0,0 +1,17 @@
+use revolt_quark::models::{Report, User};
+use revolt_quark::{Db, Error, Result};
+use rocket::serde::json::Json;
+
+/// # Fetch Report
+///
+/// Fetch a report by its ID
+#[openapi(tag = "User Safety")]
+#[get("/report/<id>")]
+pub async fn fetch_report(db: &Db, user: User, id: String) -> Result<Json<Report>> {
+    // Must be privileged for this route
+    if !user.privileged {
+        return Err(Error::NotPrivileged);
+    }
+
+    db.fetch_report(&id).await.map(Json)
+}

crates/delta/src/routes/safety/fetch_snapshot.rs

@@ -44,8 +44,13 @@ pub async fn fetch_snapshot(
             user_ids.insert(&message.author);
             channel_ids.insert(&message.channel);
         }
-        _ => {
-            todo!()
+        SnapshotContent::User(user) => {
+            user_ids.insert(&user.id);
+        }
+        SnapshotContent::Server(server) => {
+            for channel in &server.channels {
+                channel_ids.insert(channel);
+            }
         }
     }
 

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

@@ -1,6 +1,8 @@
 use revolt_rocket_okapi::revolt_okapi::openapi3::OpenApi;
 use rocket::Route;
 
+mod edit_report;
+mod fetch_report;
 mod fetch_reports;
 mod report_content;
 
@@ -9,8 +11,10 @@ mod fetch_snapshot;
 pub fn routes() -> (Vec<Route>, OpenApi) {
     openapi_get_routes_spec![
         // Reports
-        report_content::report_content,
+        edit_report::edit_report,
+        fetch_report::fetch_report,
         fetch_reports::fetch_reports,
+        report_content::report_content,
         // Snapshots
         fetch_snapshot::fetch_snapshot
     ]

crates/delta/src/routes/safety/report_content.rs

@@ -1,4 +1,5 @@
 use revolt_quark::events::client::EventV1;
+use revolt_quark::models::message::{MessageFilter, MessageQuery, MessageSort, MessageTimePeriod};
 use revolt_quark::models::report::{ReportStatus, ReportedContent};
 use revolt_quark::models::snapshot::{Snapshot, SnapshotContent};
 use revolt_quark::models::{Report, User};
@@ -55,26 +56,34 @@ pub async fn report_content(db: &Db, user: User, data: Json<DataReportContent>)
 
             // Collect prior context
             let prior_context = db
-                .fetch_messages(
-                    &message.channel,
-                    Some(15),
-                    Some(message.id.to_string()),
-                    None,
-                    None,
-                    None,
-                )
+                .fetch_messages(MessageQuery {
+                    filter: MessageFilter {
+                        channel: Some(message.channel.to_string()),
+                        ..Default::default()
+                    },
+                    limit: Some(15),
+                    time_period: MessageTimePeriod::Absolute {
+                        before: Some(message.id.to_string()),
+                        after: None,
+                        sort: Some(MessageSort::Latest),
+                    },
+                })
                 .await?;
 
             // Collect leading context
             let leading_context = db
-                .fetch_messages(
-                    &message.channel,
-                    Some(15),
-                    None,
-                    Some(message.id.to_string()),
-                    None,
-                    None,
-                )
+                .fetch_messages(MessageQuery {
+                    filter: MessageFilter {
+                        channel: Some(message.channel.to_string()),
+                        ..Default::default()
+                    },
+                    limit: Some(15),
+                    time_period: MessageTimePeriod::Absolute {
+                        before: None,
+                        after: Some(message.id.to_string()),
+                        sort: Some(MessageSort::Oldest),
+                    },
+                })
                 .await?;
 
             (
@@ -149,7 +158,8 @@ pub async fn report_content(db: &Db, user: User, data: Json<DataReportContent>)
         author_id: user.id,
         content: data.content,
         additional_context: data.additional_context,
-        status: ReportStatus::Created,
+        status: ReportStatus::Created {},
+        notes: String::new(),
     };
 
     db.insert_report(&report).await?;

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

@@ -33,6 +33,10 @@ pub struct DataEditServer {
     /// System message configuration
     system_messages: Option<SystemMessageChannels>,
 
+    /// Bitfield of server flags
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub flags: Option<i32>,
+
     // Whether this server is age-restricted
     // nsfw: Option<bool>,
     /// Whether this server is public and should show up on [Revolt Discover](https://rvlt.gg)
@@ -92,6 +96,11 @@ pub async fn req(
             .await?;
     }
 
+    // Check we are privileged if changing sensitive fields
+    if data.flags.is_some() && !user.privileged {
+        return Err(Error::NotPrivileged);
+    }
+
     if data.categories.is_some() {
         permissions
             .throw_permission(db, Permission::ManageChannel)
@@ -105,6 +114,7 @@ pub async fn req(
         banner,
         categories,
         system_messages,
+        flags,
         // nsfw,
         discoverable,
         analytics,
@@ -116,6 +126,7 @@ pub async fn req(
         description,
         categories,
         system_messages,
+        flags,
         // nsfw,
         discoverable,
         analytics,

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

@@ -1,6 +1,6 @@
 use revolt_quark::models::user::{FieldsUser, PartialUser, User};
 use revolt_quark::models::File;
-use revolt_quark::{Database, Error, Result};
+use revolt_quark::{Database, Error, Ref, Result};
 
 use revolt_quark::models::user::UserStatus;
 use rocket::serde::json::Json;
@@ -24,6 +24,10 @@ pub struct UserProfileData {
 /// # User Data
 #[derive(Validate, Serialize, Deserialize, JsonSchema)]
 pub struct DataEditUser {
+    /// Attachment Id for avatar
+    #[validate(length(min = 1, max = 128))]
+    avatar: Option<String>,
+
     /// New user status
     #[validate]
     status: Option<UserStatus>,
@@ -32,9 +36,14 @@ pub struct DataEditUser {
     /// This is applied as a partial.
     #[validate]
     profile: Option<UserProfileData>,
-    /// Attachment Id for avatar
-    #[validate(length(min = 1, max = 128))]
-    avatar: Option<String>,
+
+    /// Bitfield of user badges
+    #[serde(skip_serializing_if = "Option::is_none")]
+    badges: Option<i32>,
+    /// Enum of user flags
+    #[serde(skip_serializing_if = "Option::is_none")]
+    flags: Option<i32>,
+
     /// Fields to remove from user object
     #[validate(length(min = 1))]
     remove: Option<Vec<FieldsUser>>,
@@ -44,19 +53,36 @@ pub struct DataEditUser {
 ///
 /// Edit currently authenticated user.
 #[openapi(tag = "User Information")]
-#[patch("/@me", data = "<data>")]
+#[patch("/<target>", data = "<data>")]
 pub async fn req(
     db: &State<Database>,
     mut user: User,
+    target: Ref,
     data: Json<DataEditUser>,
 ) -> Result<Json<User>> {
     let data = data.into_inner();
     data.validate()
         .map_err(|error| Error::FailedValidation { error })?;
 
+    // If we want to edit a different user than self, ensure we have
+    // permissions and subsequently replace the user in question
+    if target.id != "@me" {
+        if !user.privileged {
+            return Err(Error::NotPrivileged);
+        }
+
+        user = target.as_user(db).await?;
+    // Otherwise, filter out invalid edit fields
+    } else if data.badges.is_some() || data.flags.is_some() {
+        return Err(Error::NotPrivileged);
+    }
+
+    // Exit out early if nothing is changed
     if data.status.is_none()
         && data.profile.is_none()
         && data.avatar.is_none()
+        && data.badges.is_none()
+        && data.flags.is_none()
         && data.remove.is_none()
     {
         return Ok(Json(user));
@@ -83,7 +109,11 @@ pub async fn req(
         }
     }
 
-    let mut partial: PartialUser = Default::default();
+    let mut partial: PartialUser = PartialUser {
+        badges: data.badges,
+        flags: data.flags,
+        ..Default::default()
+    };
 
     // 2. Apply new avatar
     if let Some(avatar) = data.avatar {

crates/quark/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-quark"
-version = "0.5.10"
+version = "0.5.16"
 license = "AGPL-3.0-or-later"
 edition = "2021"
 
@@ -29,7 +29,7 @@ default = [ "test" ]
 serde = { version = "1", features = ["derive"] }
 validator = { version = "0.14", features = ["derive"] }
 iso8601-timestamp = { version = "0.1.8", features = ["schema", "bson"] }
-optional_struct = { git = "https://github.com/insertish/OptionalStruct", rev = "e275d2726595474632485934aa0887fa52281f70" }
+optional_struct = { git = "https://github.com/insertish/OptionalStruct", rev = "ee56427cee1f007839825d93d07fffd5a5e038c7" }
 
 # Formats
 bincode = "1.3.3"

crates/quark/src/impl/dummy/admin/stats.rs

@@ -0,0 +1,10 @@
+use crate::{models::stats::Stats, AbstractStats, Result};
+
+use super::super::DummyDb;
+
+#[async_trait]
+impl AbstractStats for DummyDb {
+    async fn generate_stats(&self) -> Result<Stats> {
+        todo!()
+    }
+}

crates/quark/src/impl/dummy/channels/message.rs

@@ -1,4 +1,4 @@
-use crate::models::message::{AppendMessage, Message, MessageSort, PartialMessage};
+use crate::models::message::{AppendMessage, Message, MessageQuery, PartialMessage};
 use crate::{AbstractMessage, Result};
 
 use super::super::DummyDb;
@@ -41,28 +41,8 @@ impl AbstractMessage for DummyDb {
         Ok(())
     }
 
-    async fn fetch_messages(
-        &self,
-        channel: &str,
-        _limit: Option<i64>,
-        _before: Option<String>,
-        _after: Option<String>,
-        _sort: Option<MessageSort>,
-        _nearby: Option<String>,
-    ) -> Result<Vec<Message>> {
-        Ok(vec![self.fetch_message(channel).await.unwrap()])
-    }
-
-    async fn search_messages(
-        &self,
-        channel: &str,
-        _query: &str,
-        _limit: Option<i64>,
-        _before: Option<String>,
-        _after: Option<String>,
-        _sort: MessageSort,
-    ) -> Result<Vec<Message>> {
-        Ok(vec![self.fetch_message(channel).await.unwrap()])
+    async fn fetch_messages(&self, _query: MessageQuery) -> Result<Vec<Message>> {
+        Ok(vec![])
     }
 
     /// Add a new reaction to a message

crates/quark/src/impl/dummy/mod.rs

@@ -2,6 +2,7 @@ use crate::AbstractDatabase;
 
 pub mod admin {
     pub mod migrations;
+    pub mod stats;
 }
 
 pub mod media {

crates/quark/src/impl/dummy/safety/report.rs

@@ -1,3 +1,4 @@
+use crate::models::report::PartialReport;
 use crate::models::Report;
 use crate::{AbstractReport, Result};
 
@@ -10,6 +11,14 @@ impl AbstractReport for DummyDb {
         Ok(())
     }
 
+    async fn update_report(&self, _id: &str, _report: &PartialReport) -> Result<()> {
+        todo!()
+    }
+
+    async fn fetch_report(&self, _report_id: &str) -> Result<Report> {
+        todo!()
+    }
+
     async fn fetch_reports(&self) -> Result<Vec<Report>> {
         Ok(vec![])
     }

crates/quark/src/impl/generic/channels/message.rs

@@ -377,7 +377,7 @@ impl SendableEmbed {
 impl BulkMessageResponse {
     pub async fn transform(
         db: &Database,
-        channel: &Channel,
+        channel: Option<&Channel>,
         messages: Vec<Message>,
         include_users: Option<bool>,
     ) -> Result<BulkMessageResponse> {
@@ -386,7 +386,8 @@ impl BulkMessageResponse {
             let users = User::fetch_foreign_users(db, &user_ids).await?;
 
             Ok(match channel {
-                Channel::TextChannel { server, .. } | Channel::VoiceChannel { server, .. } => {
+                Some(Channel::TextChannel { server, .. })
+                | Some(Channel::VoiceChannel { server, .. }) => {
                     BulkMessageResponse::MessagesAndUsers {
                         messages,
                         users,

crates/quark/src/impl/generic/mod.rs

@@ -27,3 +27,7 @@ pub mod users {
     pub mod user;
     pub mod user_settings;
 }
+
+pub mod safety {
+    pub mod report;
+}

crates/quark/src/impl/generic/safety/report.rs

@@ -0,0 +1,9 @@
+use crate::{models::report::PartialReport, models::Report, Database, Result};
+
+impl Report {
+    /// Update report data
+    pub async fn update(&mut self, db: &Database, partial: PartialReport) -> Result<()> {
+        self.apply_options(partial.clone());
+        db.update_report(&self.id, &partial).await
+    }
+}

crates/quark/src/impl/mongo/admin/stats.rs

@@ -0,0 +1,90 @@
+use std::collections::HashMap;
+
+use bson::{from_document, Document};
+use futures::StreamExt;
+
+use crate::{
+    models::stats::{Index, Stats},
+    AbstractStats, Error, Result,
+};
+
+use super::super::MongoDb;
+
+#[async_trait]
+impl AbstractStats for MongoDb {
+    async fn generate_stats(&self) -> Result<Stats> {
+        let mut indices = HashMap::new();
+        let mut coll_stats = HashMap::new();
+
+        let collection_names =
+            self.db()
+                .list_collection_names(None)
+                .await
+                .map_err(|_| Error::DatabaseError {
+                    operation: "list_collection_names",
+                    with: "database",
+                })?;
+
+        for collection in collection_names {
+            indices.insert(
+                collection.to_string(),
+                self.col::<Document>(&collection)
+                    .aggregate(
+                        vec![doc! {
+                           "$indexStats": { }
+                        }],
+                        None,
+                    )
+                    .await
+                    .map_err(|_| Error::DatabaseError {
+                        operation: "aggregate",
+                        with: "col",
+                    })?
+                    .filter_map(|s| async { s.ok() })
+                    .collect::<Vec<Document>>()
+                    .await
+                    .into_iter()
+                    .filter_map(|doc| from_document(doc).ok())
+                    .collect::<Vec<Index>>(),
+            );
+
+            coll_stats.insert(
+                collection.to_string(),
+                self.col::<Document>(&collection)
+                    .aggregate(
+                        vec![doc! {
+                           "$collStats": {
+                                "latencyStats": {
+                                    "histograms": true
+                                },
+                                "storageStats": {},
+                                "count": {},
+                                "queryExecStats": {}
+                            }
+                        }],
+                        None,
+                    )
+                    .await
+                    .map_err(|_| Error::DatabaseError {
+                        operation: "aggregate",
+                        with: "col",
+                    })?
+                    .filter_map(|s| async { s.ok() })
+                    .collect::<Vec<Document>>()
+                    .await
+                    .into_iter()
+                    .filter_map(|doc| from_document(doc).ok())
+                    .next()
+                    .ok_or(Error::DatabaseError {
+                        operation: "next aggregation",
+                        with: "col",
+                    })?,
+            );
+        }
+
+        Ok(Stats {
+            indices,
+            coll_stats,
+        })
+    }
+}

crates/quark/src/impl/mongo/channels/message.rs

@@ -2,7 +2,9 @@ use bson::{to_bson, Document};
 use futures::try_join;
 use mongodb::options::FindOptions;
 
-use crate::models::message::{AppendMessage, Message, MessageSort, PartialMessage};
+use crate::models::message::{
+    AppendMessage, Message, MessageQuery, MessageSort, MessageTimePeriod, PartialMessage,
+};
 use crate::r#impl::mongo::DocumentId;
 use crate::{AbstractMessage, Error, Result};
 
@@ -139,145 +141,138 @@ impl AbstractMessage for MongoDb {
         .await
     }
 
-    async fn fetch_messages(
-        &self,
-        channel: &str,
-        limit: Option<i64>,
-        before: Option<String>,
-        after: Option<String>,
-        sort: Option<MessageSort>,
-        nearby: Option<String>,
-    ) -> Result<Vec<Message>> {
-        let limit = limit.unwrap_or(50);
-        Ok(if let Some(nearby) = nearby {
-            let (a, b) = try_join!(
-                self.find_with_options::<_, Message>(
-                    COL,
+    async fn fetch_messages(&self, query: MessageQuery) -> Result<Vec<Message>> {
+        let mut filter = doc! {};
+
+        // 1. Apply message filters
+        if let Some(channel) = query.filter.channel {
+            filter.insert("channel", channel);
+        }
+
+        if let Some(author) = query.filter.author {
+            filter.insert("author", author);
+        }
+
+        let is_search_query = if let Some(query) = query.filter.query {
+            filter.insert(
+                "$text",
+                doc! {
+                    "$search": query
+                },
+            );
+
+            true
+        } else {
+            false
+        };
+
+        // 2. Find query limit
+        let limit = query.limit.unwrap_or(50);
+
+        // 3. Apply message time period
+        match query.time_period {
+            MessageTimePeriod::Relative { nearby } => {
+                // 3.1. Prepare filters
+                let mut older_message_filter = filter.clone();
+                let mut newer_message_filter = filter;
+
+                older_message_filter.insert(
+                    "_id",
                     doc! {
-                        "channel": channel,
-                        "_id": {
-                            "$gte": &nearby
-                        }
+                        "$lt": &nearby
                     },
-                    FindOptions::builder()
-                        .limit(limit / 2 + 1)
-                        .sort(doc! {
-                            "_id": 1_i32
-                        })
-                        .build(),
-                ),
-                self.find_with_options::<_, Message>(
-                    COL,
+                );
+
+                newer_message_filter.insert(
+                    "_id",
                     doc! {
-                        "channel": channel,
-                        "_id": {
-                            "$lt": &nearby
-                        }
+                        "$gte": &nearby
                     },
+                );
+
+                // 3.2. Execute in both directions
+                let (a, b) = try_join!(
+                    self.find_with_options::<_, Message>(
+                        COL,
+                        newer_message_filter,
+                        FindOptions::builder()
+                            .limit(limit / 2 + 1)
+                            .sort(doc! {
+                                "_id": 1_i32
+                            })
+                            .build(),
+                    ),
+                    self.find_with_options::<_, Message>(
+                        COL,
+                        older_message_filter,
+                        FindOptions::builder()
+                            .limit(limit / 2)
+                            .sort(doc! {
+                                "_id": -1_i32
+                            })
+                            .build(),
+                    )
+                )?;
+
+                Ok([a, b].concat())
+            }
+            MessageTimePeriod::Absolute {
+                before,
+                after,
+                sort,
+            } => {
+                // 3.1. Apply message ID filter
+                if let Some(doc) = match (before, after) {
+                    (Some(before), Some(after)) => Some(doc! {
+                        "$lt": before,
+                        "$gt": after
+                    }),
+                    (Some(before), _) => Some(doc! {
+                        "$lt": before
+                    }),
+                    (_, Some(after)) => Some(doc! {
+                        "$gt": after
+                    }),
+                    _ => None,
+                } {
+                    filter.insert("_id", doc);
+                }
+
+                // 3.2. Execute with given message sort
+                self.find_with_options(
+                    COL,
+                    filter,
                     FindOptions::builder()
-                        .limit(limit / 2)
-                        .sort(doc! {
-                            "_id": -1_i32
+                        .limit(limit)
+                        .sort(match sort.unwrap_or(MessageSort::Latest) {
+                            // Sort by relevance, fallback to latest
+                            MessageSort::Relevance => {
+                                if is_search_query {
+                                    doc! {
+                                        "score": {
+                                            "$meta": "textScore"
+                                        }
+                                    }
+                                } else {
+                                    doc! {
+                                        "_id": -1_i32
+                                    }
+                                }
+                            }
+                            // Sort by latest first
+                            MessageSort::Latest => doc! {
+                                "_id": -1_i32
+                            },
+                            // Sort by oldest first
+                            MessageSort::Oldest => doc! {
+                                "_id": 1_i32
+                            },
                         })
                         .build(),
                 )
-            )?;
-
-            [a, b].concat()
-        } else {
-            let mut query = doc! { "channel": channel };
-            if let Some(before) = before {
-                query.insert("_id", doc! { "$lt": before });
+                .await
             }
-
-            if let Some(after) = after {
-                query.insert("_id", doc! { "$gt": after });
-            }
-
-            let sort: i32 = if let MessageSort::Latest = sort.unwrap_or(MessageSort::Latest) {
-                -1
-            } else {
-                1
-            };
-
-            self.find_with_options::<_, Message>(
-                COL,
-                query,
-                FindOptions::builder()
-                    .limit(limit)
-                    .sort(doc! {
-                        "_id": sort
-                    })
-                    .build(),
-            )
-            .await?
-        })
-    }
-
-    async fn search_messages(
-        &self,
-        channel: &str,
-        query: &str,
-        limit: Option<i64>,
-        before: Option<String>,
-        after: Option<String>,
-        sort: MessageSort,
-    ) -> Result<Vec<Message>> {
-        let limit = limit.unwrap_or(50);
-
-        let mut filter = doc! {
-            "channel": channel,
-            "$text": {
-                "$search": query
-            }
-        };
-
-        if let Some(doc) = match (before, after) {
-            (Some(before), Some(after)) => Some(doc! {
-                "lt": before,
-                "gt": after
-            }),
-            (Some(before), _) => Some(doc! {
-                "lt": before
-            }),
-            (_, Some(after)) => Some(doc! {
-                "gt": after
-            }),
-            _ => None,
-        } {
-            filter.insert("_id", doc);
         }
-
-        self.find_with_options(
-            COL,
-            filter,
-            FindOptions::builder()
-                .projection(if let MessageSort::Relevance = &sort {
-                    doc! {
-                        "score": {
-                            "$meta": "textScore"
-                        }
-                    }
-                } else {
-                    doc! {}
-                })
-                .limit(limit)
-                .sort(match &sort {
-                    MessageSort::Relevance => doc! {
-                        "score": {
-                            "$meta": "textScore"
-                        }
-                    },
-                    MessageSort::Latest => doc! {
-                        "_id": -1_i32
-                    },
-                    MessageSort::Oldest => doc! {
-                        "_id": 1_i32
-                    },
-                })
-                .build(),
-        )
-        .await
     }
 
     /// Add a new reaction to a message

crates/quark/src/impl/mongo/mod.rs

@@ -13,6 +13,7 @@ use crate::{util::manipulation::prefix_keys, AbstractDatabase, Error, Result};
 
 pub mod admin {
     pub mod migrations;
+    pub mod stats;
 }
 
 pub mod media {
@@ -89,17 +90,25 @@ impl MongoDb {
     where
         O: Into<Option<FindOptions>>,
     {
-        Ok(self
-            .col::<T>(collection)
-            .find(projection, options)
-            .await
-            .map_err(|_| Error::DatabaseError {
+        let result = self.col::<T>(collection).find(projection, options).await;
+        Ok(if cfg!(debug_assertions) {
+            result.unwrap()
+        } else {
+            result.map_err(|_| Error::DatabaseError {
                 operation: "find",
                 with: collection,
             })?
-            .filter_map(|s| async { s.ok() })
-            .collect::<Vec<T>>()
-            .await)
+        }
+        .filter_map(|s| async {
+            if cfg!(debug_assertions) {
+                // Hard fail on invalid documents
+                Some(s.unwrap())
+            } else {
+                s.ok()
+            }
+        })
+        .collect::<Vec<T>>()
+        .await)
     }
 
     async fn find<T: DeserializeOwned + Unpin + Send + Sync>(

crates/quark/src/impl/mongo/safety/report.rs

@@ -1,3 +1,4 @@
+use crate::models::report::PartialReport;
 use crate::models::Report;
 use crate::{AbstractReport, Result};
 
@@ -11,6 +12,16 @@ impl AbstractReport for MongoDb {
         self.insert_one(COL, report).await.map(|_| ())
     }
 
+    async fn update_report(&self, id: &str, report: &PartialReport) -> Result<()> {
+        self.update_one_by_id(COL, id, report, vec![], None)
+            .await
+            .map(|_| ())
+    }
+
+    async fn fetch_report(&self, report_id: &str) -> Result<Report> {
+        self.find_one_by_id(COL, report_id).await
+    }
+
     async fn fetch_reports(&self) -> Result<Vec<Report>> {
         self.find(COL, doc! {}).await
     }

crates/quark/src/models/admin/stats.rs

@@ -0,0 +1,122 @@
+use std::collections::HashMap;
+
+use iso8601_timestamp::Timestamp;
+use serde::{Deserialize, Serialize};
+
+/// Index access information
+#[derive(Serialize, Deserialize, JsonSchema, Debug)]
+pub struct IndexAccess {
+    /// Operations since timestamp
+    ops: i32,
+
+    /// Timestamp at which data keeping begun
+    since: Timestamp,
+}
+
+/// Collection index
+#[derive(Serialize, Deserialize, JsonSchema, Debug)]
+pub struct Index {
+    /// Index name
+    name: String,
+
+    /// Access information
+    accesses: IndexAccess,
+}
+
+/// Histogram entry
+#[derive(Serialize, Deserialize, JsonSchema, Debug)]
+pub struct LatencyHistogramEntry {
+    /// Time
+    micros: i64,
+
+    /// Count
+    count: i64,
+}
+
+/// Collection latency stats
+#[derive(Serialize, Deserialize, JsonSchema, Debug)]
+pub struct LatencyStats {
+    /// Total operations
+    ops: i64,
+
+    /// Timestamp at which data keeping begun
+    latency: i64,
+
+    /// Histogram representation of latency data
+    histogram: Vec<LatencyHistogramEntry>,
+}
+
+/// Collection storage stats
+#[derive(Serialize, Deserialize, JsonSchema, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct StorageStats {
+    /// Uncompressed data size
+    size: i64,
+
+    /// Data size on disk
+    storage_size: i64,
+
+    /// Total size of all indexes
+    total_index_size: i64,
+
+    /// Sum of storage size and total index size
+    total_size: i64,
+
+    /// Individual index sizes
+    index_sizes: HashMap<String, i64>,
+
+    /// Number of documents in collection
+    count: i64,
+
+    /// Average size of each document
+    avg_obj_size: i64,
+}
+
+/// Query collection scan stats
+#[derive(Serialize, Deserialize, JsonSchema, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct CollectionScans {
+    /// Number of total collection scans
+    total: i64,
+
+    /// Number of total collection scans not using a tailable cursor
+    non_tailable: i64,
+}
+
+/// Collection query execution stats
+#[derive(Serialize, Deserialize, JsonSchema, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct QueryExecStats {
+    /// Stats regarding collection scans
+    collection_scans: CollectionScans,
+}
+
+/// Collection stats
+#[derive(Serialize, Deserialize, JsonSchema, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct CollectionStats {
+    /// Namespace
+    ns: String,
+
+    /// Local time
+    local_time: Timestamp,
+
+    /// Latency stats
+    latency_stats: HashMap<String, LatencyStats>,
+
+    /// Query exec stats
+    query_exec_stats: QueryExecStats,
+
+    /// Number of documents in collection
+    count: u64,
+}
+
+/// Server Stats
+#[derive(Serialize, JsonSchema, Debug)]
+pub struct Stats {
+    /// Index usage information
+    pub indices: HashMap<String, Vec<Index>>,
+
+    /// Collection stats
+    pub coll_stats: HashMap<String, CollectionStats>,
+}

crates/quark/src/models/channels/message.rs

@@ -157,7 +157,7 @@ pub struct Message {
 /// # Message Sort
 ///
 /// Sort used for retrieving messages
-#[derive(Serialize, Deserialize, JsonSchema)]
+#[derive(Serialize, Deserialize, JsonSchema, Debug)]
 #[cfg_attr(feature = "rocket_impl", derive(FromFormField))]
 pub enum MessageSort {
     /// Sort by the most relevant messages
@@ -174,6 +174,56 @@ impl Default for MessageSort {
     }
 }
 
+/// # Message Time Period
+///
+/// Filter and sort messages by time
+#[derive(Serialize, Deserialize, JsonSchema)]
+#[serde(untagged)]
+pub enum MessageTimePeriod {
+    Relative {
+        /// Message id to search around
+        ///
+        /// Specifying 'nearby' ignores 'before', 'after' and 'sort'.
+        /// It will also take half of limit rounded as the limits to each side.
+        /// It also fetches the message ID specified.
+        nearby: String,
+    },
+    Absolute {
+        /// Message id before which messages should be fetched
+        before: Option<String>,
+        /// Message id after which messages should be fetched
+        after: Option<String>,
+        /// Message sort direction
+        sort: Option<MessageSort>,
+    },
+}
+
+/// # Message Filter
+#[derive(Serialize, Deserialize, JsonSchema, Default)]
+pub struct MessageFilter {
+    /// Parent channel ID
+    pub channel: Option<String>,
+    /// Message author ID
+    pub author: Option<String>,
+    /// Search query
+    pub query: Option<String>,
+}
+
+/// # Message Query
+#[derive(Serialize, Deserialize, JsonSchema)]
+pub struct MessageQuery {
+    /// Maximum number of messages to fetch
+    ///
+    /// For fetching nearby messages, this is \`(limit + 1)\`.
+    pub limit: Option<i64>,
+    /// Filter to apply
+    #[serde(flatten)]
+    pub filter: MessageFilter,
+    /// Time period to fetch
+    #[serde(flatten)]
+    pub time_period: MessageTimePeriod,
+}
+
 /// # Bulk Message Response
 ///
 /// Response used when multiple messages are fetched

crates/quark/src/models/mod.rs

@@ -1,6 +1,7 @@
 mod admin {
     pub mod migrations;
     pub mod simple;
+    pub mod stats;
 }
 
 mod media {

crates/quark/src/models/safety/report.rs

@@ -76,17 +76,20 @@ pub enum ReportedContent {
 #[serde(tag = "status")]
 pub enum ReportStatus {
     /// Report is waiting for triage / action
-    Created,
+    Created {},
 
     /// Report was rejected
     Rejected { rejection_reason: String },
 
     /// Report was actioned and resolved
-    Resolved,
+    Resolved {},
 }
 
 /// User-generated platform moderation report.
-#[derive(Serialize, Deserialize, JsonSchema, Debug, Clone)]
+#[derive(Serialize, Deserialize, JsonSchema, Debug, OptionalStruct, Clone)]
+#[optional_derive(Serialize, Deserialize, JsonSchema, Debug, Default, Clone)]
+#[optional_name = "PartialReport"]
+#[opt_skip_serializing_none]
 pub struct Report {
     /// Unique Id
     #[serde(rename = "_id")]
@@ -98,6 +101,10 @@ pub struct Report {
     /// Additional report context
     pub additional_context: String,
     /// Status of the report
+    #[opt_passthrough]
     #[serde(flatten)]
     pub status: ReportStatus,
+    /// Additional notes included on the report
+    #[serde(default)]
+    pub notes: String,
 }

crates/quark/src/models/servers/server.rs

@@ -118,7 +118,7 @@ pub struct Server {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub banner: Option<File>,
 
-    /// Enum of server flags
+    /// Bitfield of server flags
     #[serde(skip_serializing_if = "Option::is_none")]
     pub flags: Option<i32>,
 

crates/quark/src/permissions/impl/user.rs

@@ -51,6 +51,10 @@ pub fn get_relationship(a: &User, b: &str) -> RelationshipStatus {
 async fn calculate_permission(data: &mut PermissionCalculator<'_>, db: &crate::Database) -> u32 {
     let user = data.user.get().unwrap();
 
+    if data.perspective.privileged {
+        return u32::MAX;
+    }
+
     if data.perspective.id == user.id {
         return u32::MAX;
     }

crates/quark/src/traits/admin/stats.rs

@@ -0,0 +1,6 @@
+use crate::{models::stats::Stats, Result};
+
+#[async_trait]
+pub trait AbstractStats: Sync + Send {
+    async fn generate_stats(&self) -> Result<Stats>;
+}

crates/quark/src/traits/channels/message.rs

@@ -1,4 +1,4 @@
-use crate::models::message::{AppendMessage, Message, MessageSort, PartialMessage};
+use crate::models::message::{AppendMessage, Message, MessageQuery, PartialMessage};
 use crate::Result;
 
 #[async_trait]
@@ -21,27 +21,8 @@ pub trait AbstractMessage: Sync + Send {
     /// Delete messages from a channel by their ids and corresponding channel id
     async fn delete_messages(&self, channel: &str, ids: Vec<String>) -> Result<()>;
 
-    /// Fetch multiple messages
-    async fn fetch_messages(
-        &self,
-        channel: &str,
-        limit: Option<i64>,
-        before: Option<String>,
-        after: Option<String>,
-        sort: Option<MessageSort>,
-        nearby: Option<String>,
-    ) -> Result<Vec<Message>>;
-
-    /// Search for messages
-    async fn search_messages(
-        &self,
-        channel: &str,
-        query: &str,
-        limit: Option<i64>,
-        before: Option<String>,
-        after: Option<String>,
-        sort: MessageSort,
-    ) -> Result<Vec<Message>>;
+    /// Fetch multiple messages by given query
+    async fn fetch_messages(&self, query: MessageQuery) -> Result<Vec<Message>>;
 
     /// Add a new reaction to a message
     async fn add_reaction(&self, id: &str, emoji: &str, user: &str) -> Result<()>;

crates/quark/src/traits/mod.rs

@@ -1,5 +1,6 @@
 mod admin {
     pub mod migrations;
+    pub mod stats;
 }
 
 mod media {
@@ -32,6 +33,7 @@ mod safety {
 }
 
 pub use admin::migrations::AbstractMigrations;
+pub use admin::stats::AbstractStats;
 
 pub use media::attachment::AbstractAttachment;
 pub use media::emoji::AbstractEmoji;
@@ -56,6 +58,7 @@ pub trait AbstractDatabase:
     Sync
     + Send
     + AbstractMigrations
+    + AbstractStats
     + AbstractAttachment
     + AbstractEmoji
     + AbstractChannel

crates/quark/src/traits/safety/report.rs

@@ -1,3 +1,4 @@
+use crate::models::report::PartialReport;
 use crate::models::Report;
 use crate::Result;
 
@@ -6,6 +7,12 @@ pub trait AbstractReport: Sync + Send {
     /// Insert a new report into the database
     async fn insert_report(&self, report: &Report) -> Result<()>;
 
+    /// Update a given report with new information
+    async fn update_report(&self, id: &str, message: &PartialReport) -> Result<()>;
+
+    /// Fetch report
+    async fn fetch_report(&self, report_id: &str) -> Result<Report>;
+
     /// Fetch reports
     async fn fetch_reports(&self) -> Result<Vec<Report>>;
 }

crates/quark/src/util/ref.rs

@@ -4,7 +4,9 @@ use schemars::schema::{InstanceType, Schema, SchemaObject, SingleOrVec};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
-use crate::models::{Bot, Channel, Emoji, Invite, Member, Message, Server, ServerBan, User};
+use crate::models::{
+    Bot, Channel, Emoji, Invite, Member, Message, Report, Server, ServerBan, User,
+};
 use crate::presence::presence_is_online;
 use crate::{Database, Error, Result};
 
@@ -78,6 +80,11 @@ impl Ref {
     pub async fn as_emoji(&self, db: &Database) -> Result<Emoji> {
         db.fetch_emoji(&self.id).await
     }
+
+    /// Fetch report from Ref
+    pub async fn as_report(&self, db: &Database) -> Result<Report> {
+        db.fetch_report(&self.id).await
+    }
 }
 
 impl<'r> FromParam<'r> for Ref {