fix: prevent short-circuit on permissions

the "fix" caused emails to not send

.env

@@ -0,0 +1,79 @@
+# MongoDB URI
+MONGODB=mongodb://localhost
+
+# URL to where the Revolt app is publicly accessible
+REVOLT_APP_URL=http://local.revolt.chat:5000
+
+# URL to where the API is publicly accessible
+REVOLT_PUBLIC_URL=http://local.revolt.chat:8000
+VITE_API_URL=http://local.revolt.chat:8000
+
+# URL to where the WebSocket server is publicly accessible
+REVOLT_EXTERNAL_WS_URL=ws://local.revolt.chat:9000
+
+# URL to where Autumn is publicly available
+AUTUMN_PUBLIC_URL=http://local.revolt.chat:3000
+
+# URL to where January is publicly available
+JANUARY_PUBLIC_URL=http://local.revolt.chat:7000
+
+# URL to where Vortex is publicly available
+# VOSO_PUBLIC_URL=https://voso.revolt.chat
+
+
+##
+## hCaptcha Settings
+##
+
+# If you are sure that you don't want to use hCaptcha, set to 1.
+REVOLT_UNSAFE_NO_CAPTCHA=1
+
+# hCaptcha API key
+# REVOLT_HCAPTCHA_KEY=0x0000000000000000000000000000000000000000
+
+# hCaptcha site key
+# REVOLT_HCAPTCHA_SITEKEY=10000000-ffff-ffff-ffff-000000000001
+
+
+##
+## Email Settings
+##
+
+# If you are sure that you don't want to use email verification, set to 1.
+REVOLT_UNSAFE_NO_EMAIL=1
+
+# SMTP host
+# REVOLT_SMTP_HOST=smtp.example.com
+
+# SMTP username
+# REVOLT_SMTP_USERNAME=noreply@example.com
+
+# SMTP password
+# REVOLT_SMTP_PASSWORD=CHANGEME
+
+# SMTP From header
+# REVOLT_SMTP_FROM=Revolt <noreply@example.com>
+
+
+##
+## Application Settings
+##
+
+# Whether to only allow users to sign up if they have an invite code
+REVOLT_INVITE_ONLY=0
+
+# Maximum number of people that can be in a group chat
+REVOLT_MAX_GROUP_SIZE=150
+
+# VAPID keys for push notifications
+# Generate using this guide: https://gitlab.insrt.uk/revolt/delta/-/wikis/vapid
+# --> Please replace these keys before going into production! <--
+REVOLT_VAPID_PRIVATE_KEY=LS0tLS1CRUdJTiBFQyBQUklWQVRFIEtFWS0tLS0tCk1IY0NBUUVFSUJSUWpyTWxLRnBiVWhsUHpUbERvcEliYk1yeVNrNXpKYzVYVzIxSjJDS3hvQW9HQ0NxR1NNNDkKQXdFSG9VUURRZ0FFWnkrQkg2TGJQZ2hEa3pEempXOG0rUXVPM3pCajRXT1phdkR6ZU00c0pqbmFwd1psTFE0WAp1ZDh2TzVodU94QWhMQlU3WWRldVovWHlBdFpWZmNyQi9BPT0KLS0tLS1FTkQgRUMgUFJJVkFURSBLRVktLS0tLQo=
+REVOLT_VAPID_PUBLIC_KEY=BGcvgR-i2z4IQ5Mw841vJvkLjt8wY-FjmWrw83jOLCY52qcGZS0OF7nfLzuYbjsQISwVO2HXrmf18gLWVX3Kwfw=
+
+
+##
+## Vortex configuration
+##
+
+# VOSO_MANAGE_TOKEN=CHANGEME

.gitignore

@@ -1,2 +1,3 @@
 Rocket.toml
 target
+.data

crates/bonfire/src/main.rs

@@ -14,7 +14,7 @@ mod websocket;
 #[async_std::main]
 async fn main() {
     // Configure requirements for Bonfire.
-    let _guard = revolt_quark::setup_logging();
+    revolt_quark::configure!();
     database::connect().await;
 
     // Clean up the current region information.

crates/delta/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-delta"
-version = "0.5.3-6"
+version = "0.5.4"
 license = "AGPL-3.0-or-later"
 authors = ["Paul Makles <paulmakles@gmail.com>"]
 edition = "2018"
@@ -18,7 +18,6 @@ linkify = "0.6.0"
 once_cell = "1.4.1"
 env_logger = "0.7.1"
 lazy_static = "1.4.0"
-ctrlc = { version = "3.0", features = ["termination"] }
 
 # Lang. Utilities
 regex = "1"
@@ -44,7 +43,6 @@ async-std = { version = "1.8.0", features = ["tokio1", "tokio02", "attributes"]
 
 # internal util
 lettre = "0.10.0-alpha.4"
-rauth = { git = "https://github.com/insertish/rauth", rev = "001a9698c56cea79e69e4ae71d7bc2cb48aec1a6" }
 
 # redis
 redis = { version = "0.21.2", features = ["async-std-comp"] }
@@ -52,15 +50,14 @@ mobc = { version = "0.7.3" }
 mobc-redis = { version = "0.7.0", default-features = false, features = ["async-std-comp"] }
 
 # web
-rocket_empty = { git = "https://github.com/insertish/rocket_empty", branch = "rc1" }
-rocket = { version = "0.5.0-rc.1", default-features = false, features = ["json"] }
-mongodb = { version = "1.2.2", features = ["async-std-runtime"], default-features = false }
-rocket_cors = { git = "https://github.com/lawliet89/rocket_cors", rev = "5843861a88958c16bfaa0b40f0d8910772bcd2f6" }
+rocket = { version = "0.5.0-rc.2", default-features = false, features = ["json"] }
+rocket_empty = { git = "https://github.com/insertish/rocket_empty", branch = "master" }
+rocket_rauth = { git = "https://github.com/insertish/rauth", rev = "c2acaf6b31213e3969f8b48f9deed3daa125d394" }
 
 # spec generation
 schemars = "0.8.8"
 # rocket_okapi = "0.8.0-rc.1"
-rocket_okapi = { git = "https://github.com/insertish/okapi", rev = "dcf0df115596ee07a587a7a543cddf3d7944645b", features = [ "swagger" ] }
+rocket_okapi = { git = "https://github.com/insertish/okapi", rev = "a1048d0c8cd771e424ec97d33d825c32e06aa120", features = [ "swagger" ] }
 
 # quark
 revolt-quark = { path = "../quark" }

crates/delta/src/main.rs

@@ -6,144 +6,46 @@ extern crate rocket_okapi;
 extern crate serde_json;
 #[macro_use]
 extern crate lazy_static;
-extern crate ctrlc;
 
 pub mod routes;
 pub mod util;
-pub mod version;
 
-use log::info;
-use rauth::{
-    config::{Captcha, Config, EmailVerification, SMTPSettings, Template, Templates},
-    logic::Auth,
-};
-use revolt_quark::variables::delta::{
-    APP_URL, HCAPTCHA_KEY, INVITE_ONLY, SMTP_FROM, SMTP_HOST, SMTP_PASSWORD, SMTP_USERNAME,
-    USE_EMAIL, USE_HCAPTCHA,
-};
+use revolt_quark::rauth::RAuth;
 use revolt_quark::DatabaseInfo;
-use rocket_cors::AllowedOrigins;
-use std::str::FromStr;
 
-#[async_std::main]
-async fn main() {
-    let _guard = revolt_quark::setup_logging();
-
-    info!(
-        "Starting Revolt server [version {}].",
-        crate::version::VERSION
-    );
+#[launch]
+async fn rocket() -> _ {
+    // Configure logging and environment
+    revolt_quark::configure!();
 
+    // Ensure environment variables are present
     revolt_quark::variables::delta::preflight_checks();
 
-    #[cfg(debug_assertions)]
-    ctrlc::set_handler(move || {
-        // Force ungraceful exit to avoid hang.
-        std::process::exit(0);
-    })
-    .expect("Error setting Ctrl-C handler");
-
-    let cors = rocket_cors::CorsOptions {
-        allowed_origins: AllowedOrigins::All,
-        allowed_methods: [
-            "Get", "Put", "Post", "Delete", "Options", "Head", "Trace", "Connect", "Patch",
-        ]
-        .iter()
-        .map(|s| FromStr::from_str(s).unwrap())
-        .collect(),
-        ..Default::default()
-    }
-    .to_cors()
-    .expect("Failed to create CORS.");
-
-    let mut config = Config {
-        email_verification: if *USE_EMAIL {
-            EmailVerification::Enabled {
-                smtp: SMTPSettings {
-                    from: (*SMTP_FROM).to_string(),
-                    host: (*SMTP_HOST).to_string(),
-                    username: (*SMTP_USERNAME).to_string(),
-                    password: (*SMTP_PASSWORD).to_string(),
-                    reply_to: Some("support@revolt.chat".into()),
-                    port: None,
-                    use_tls: None,
-                },
-                expiry: Default::default(),
-                templates: Templates {
-                    verify: Template {
-                        title: "Verify your Revolt account.".into(),
-                        text: include_str!(crate::asset!("templates/verify.txt")).into(),
-                        url: format!("{}/login/verify/", *APP_URL),
-                        html: None,
-                    },
-                    reset: Template {
-                        title: "Reset your Revolt password.".into(),
-                        text: include_str!(crate::asset!("templates/reset.txt")).into(),
-                        url: format!("{}/login/reset/", *APP_URL),
-                        html: None,
-                    },
-                    welcome: None,
-                },
-            }
-        } else {
-            EmailVerification::Disabled
-        },
-        ..Default::default()
-    };
-
-    if *INVITE_ONLY {
-        config.invite_only = true;
-    }
-
-    if *USE_HCAPTCHA {
-        config.captcha = Captcha::HCaptcha {
-            secret: HCAPTCHA_KEY.clone(),
-        };
-    }
-
+    // Setup database
     let db = DatabaseInfo::Auto.connect().await.unwrap();
     db.migrate_database().await.unwrap();
 
-    // This is entirely temporary code until rauth is migrated to quark.
-    // (and / or otherwise gets updated to MongoDB v2 driver)
-    let mongo_db = mongodb::Client::with_uri_str(
-        &std::env::var("MONGODB").unwrap_or_else(|_| "mongodb://localhost".to_string()),
-    )
-    .await
-    .expect("Failed to init db connection.");
-
-    rauth::entities::sync_models(&mongo_db.database("revolt")).await;
+    // Setup rAuth
+    let rauth = RAuth {
+        database: db.clone().into(),
+        config: revolt_quark::util::rauth::config(),
+    };
 
     // Launch background task workers.
     async_std::task::spawn(revolt_quark::tasks::start_workers(db.clone()));
 
-    let auth = Auth::new(mongo_db.database("revolt"), config);
+    // Configure CORS
+    let cors = revolt_quark::web::cors::new();
+
+    // Configure Rocket
     let rocket = rocket::build();
     routes::mount(rocket)
-        .mount("/", rocket_cors::catch_all_options_routes())
-        .mount("/", util::ratelimiter::routes())
-        .mount(
-            "/swagger/",
-            rocket_okapi::swagger_ui::make_swagger_ui(&rocket_okapi::swagger_ui::SwaggerUIConfig {
-                url: "../openapi.json".to_owned(),
-                ..Default::default()
-            }),
-        )
-        .manage(auth)
+        .mount("/", revolt_quark::web::cors::catch_all_options_routes())
+        .mount("/", revolt_quark::web::ratelimiter::routes())
+        .mount("/swagger/", revolt_quark::web::swagger::routes())
+        .manage(rauth)
         .manage(db)
         .manage(cors.clone())
-        .attach(util::ratelimiter::RatelimitFairing)
+        .attach(revolt_quark::web::ratelimiter::RatelimitFairing)
         .attach(cors)
-        .launch()
-        .await
-        .unwrap();
 }
-
-/// Resolve asset
-macro_rules! asset {
-    ($path:literal) => {
-        concat!(env!("CARGO_MANIFEST_DIR"), "/assets/", $path)
-    };
-}
-
-pub(crate) use asset;

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

@@ -36,6 +36,8 @@ pub async fn req(
     edit.validate()
         .map_err(|error| Error::FailedValidation { error })?;
 
+    Message::validate_sum(&edit.content, &edit.embeds)?;
+
     let mut message = msg.as_message(db).await?;
     if message.channel != target {
         return Err(Error::NotFound);

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

@@ -5,7 +5,9 @@ use revolt_quark::{
         message::{Masquerade, Reply, SendableEmbed},
         Message, User,
     },
-    perms, Db, Error, Permission, Ref, Result,
+    perms,
+    web::idempotency::IdempotencyKey,
+    Db, Error, Permission, Ref, Result,
 };
 
 use regex::Regex;
@@ -14,13 +16,12 @@ use serde::{Deserialize, Serialize};
 use ulid::Ulid;
 use validator::Validate;
 
-use crate::util::idempotency::IdempotencyKey;
-
 #[derive(Validate, Serialize, Deserialize, JsonSchema)]
 pub struct DataMessageSend {
     /// Unique token to prevent duplicate message sending
     ///
     /// **This is deprecated and replaced by `Idempotency-Key`!**
+    #[validate(length(min = 1, max = 64))]
     nonce: Option<String>,
 
     /// Message content to send
@@ -32,6 +33,8 @@ pub struct DataMessageSend {
     /// Messages to reply to
     replies: Option<Vec<Reply>>,
     /// Embeds to include in message
+    ///
+    /// Text embed content contributes to the content length cap
     #[validate(length(min = 1, max = 10))]
     embeds: Option<Vec<SendableEmbed>>,
     /// Masquerade to apply to this message
@@ -60,6 +63,8 @@ pub async fn message_send(
     data.validate()
         .map_err(|error| Error::FailedValidation { error })?;
 
+    Message::validate_sum(&data.content, &data.embeds)?;
+
     idempotency.consume_nonce(data.nonce).await?;
 
     let channel = target.as_channel(db).await?;
@@ -134,7 +139,19 @@ pub async fn message_send(
             .replace(replies.into_iter().collect::<Vec<String>>());
     }
 
-    // 4. Add attachments to message.
+    // 4. Process included embeds.
+    let mut embeds = vec![];
+    if let Some(sendable_embeds) = data.embeds {
+        for sendable_embed in sendable_embeds {
+            embeds.push(sendable_embed.into_embed(db, message_id.clone()).await?)
+        }
+    }
+
+    if !embeds.is_empty() {
+        message.embeds.replace(embeds);
+    }
+
+    // 5. Add attachments to message.
     let mut attachments = vec![];
     if let Some(ids) = &data.attachments {
         if !ids.is_empty() {
@@ -160,18 +177,6 @@ pub async fn message_send(
         message.attachments.replace(attachments);
     }
 
-    // 5. Process included embeds.
-    let mut embeds = vec![];
-    if let Some(sendable_embeds) = data.embeds {
-        for sendable_embed in sendable_embeds {
-            embeds.push(sendable_embed.into_embed(db, message_id.clone()).await?)
-        }
-    }
-
-    if !embeds.is_empty() {
-        message.embeds.replace(embeds);
-    }
-
     // 6. Set content
     message.content = data.content;
 

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

@@ -0,0 +1,75 @@
+use revolt_quark::models::emoji::EmojiParent;
+use revolt_quark::models::{Emoji, File, User};
+use revolt_quark::{perms, Db, Error, Permission, Result};
+use serde::Deserialize;
+use validator::Validate;
+
+use crate::util::regex::RE_EMOJI;
+
+use rocket::serde::json::Json;
+
+/// # Emoji Data
+#[derive(Validate, Deserialize, JsonSchema)]
+pub struct DataCreateEmoji {
+    /// Server name
+    #[validate(length(min = 1, max = 32), regex = "RE_EMOJI")]
+    name: String,
+    parent: EmojiParent,
+}
+
+/// # Create New Emoji
+///
+/// Create an emoji by its Autumn upload id.
+#[openapi(tag = "Emojis")]
+#[put("/emoji/<id>", data = "<data>")]
+pub async fn create_emoji(
+    db: &Db,
+    user: User,
+    id: String,
+    data: Json<DataCreateEmoji>,
+) -> Result<Json<Emoji>> {
+    let data = data.into_inner();
+    data.validate()
+        .map_err(|error| Error::FailedValidation { error })?;
+
+    // Bots cannot manage emojis
+    if user.bot.is_some() {
+        return Err(Error::IsBot);
+    }
+
+    // Validate we have permission to write into parent
+    match &data.parent {
+        EmojiParent::Server { id } => {
+            let server = db.fetch_server(id).await?;
+
+            // Check for permission
+            perms(&user)
+                .server(&server)
+                .throw_permission(db, Permission::ManageCustomisation)
+                .await?;
+
+            // Check that there are no more than 100 emoji
+            // ! FIXME: hardcoded upper limit
+            let emojis = db.fetch_emoji_by_parent_id(&server.id).await?;
+            if emojis.len() > 100 {
+                return Err(Error::TooManyEmoji);
+            }
+        }
+    };
+
+    // Find the relevant attachment
+    let attachment = File::use_emoji(db, &id, &id).await?;
+
+    // Create the emoji object
+    let emoji = Emoji {
+        id,
+        parent: data.parent,
+        creator_id: user.id,
+        name: data.name,
+        animated: "image/gif" == &attachment.content_type,
+    };
+
+    // Save emoji
+    emoji.create(db).await?;
+    Ok(Json(emoji))
+}

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

@@ -0,0 +1,36 @@
+use revolt_quark::models::{emoji::EmojiParent, User};
+use revolt_quark::{perms, Db, EmptyResponse, Error, Permission, Ref, Result};
+
+/// # Delete Emoji
+///
+/// Delete an emoji by its id.
+#[openapi(tag = "Emojis")]
+#[delete("/emoji/<id>")]
+pub async fn delete_emoji(db: &Db, user: User, id: Ref) -> Result<EmptyResponse> {
+    // Bots cannot manage emoji
+    if user.bot.is_some() {
+        return Err(Error::IsBot);
+    }
+
+    // Fetch the emoji
+    let emoji = id.as_emoji(db).await?;
+
+    // If we uploaded the emoji, then we have permission to delete it
+    if emoji.creator_id != user.id {
+        // Otherwise, validate we have permission to delete from parent
+        match &emoji.parent {
+            EmojiParent::Server { id } => {
+                let server = db.fetch_server(id).await?;
+
+                // Check for permission
+                perms(&user)
+                    .server(&server)
+                    .throw_permission(db, Permission::ManageCustomisation)
+                    .await?;
+            }
+        };
+    }
+
+    // Delete the emoji
+    emoji.delete(db).await.map(|_| EmptyResponse)
+}

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

@@ -0,0 +1,13 @@
+use revolt_quark::models::{Emoji, User};
+use revolt_quark::{Db, Ref, Result};
+
+use rocket::serde::json::Json;
+
+/// # Fetch Emoji
+///
+/// Fetch an emoji by its id.
+#[openapi(tag = "Emojis")]
+#[get("/emoji/<id>")]
+pub async fn fetch_emoji(db: &Db, _user: User, id: Ref) -> Result<Json<Emoji>> {
+    id.as_emoji(db).await.map(Json)
+}

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

@@ -0,0 +1,14 @@
+use rocket::Route;
+use rocket_okapi::okapi::openapi3::OpenApi;
+
+mod emoji_create;
+mod emoji_delete;
+mod emoji_fetch;
+
+pub fn routes() -> (Vec<Route>, OpenApi) {
+    openapi_get_routes_spec![
+        emoji_create::create_emoji,
+        emoji_delete::delete_emoji,
+        emoji_fetch::fetch_emoji
+    ]
+}

crates/delta/src/routes/mod.rs

@@ -5,6 +5,7 @@ use rocket_okapi::{okapi::openapi3::OpenApi, settings::OpenApiSettings};
 
 mod bots;
 mod channels;
+mod customisation;
 mod invites;
 mod onboard;
 mod push;
@@ -25,8 +26,10 @@ pub fn mount(mut rocket: Rocket<Build>) -> Rocket<Build> {
         "/channels" => channels::routes(),
         "/servers" => servers::routes(),
         "/invites" => invites::routes(),
-        "/auth/account" => rauth::web::account::routes(),
-        "/auth/session" => rauth::web::session::routes(),
+        "/custom" => customisation::routes(),
+        "/auth/account" => rocket_rauth::routes::account::routes(),
+        "/auth/session" => rocket_rauth::routes::session::routes(),
+        "/auth/mfa" => rocket_rauth::routes::mfa::routes(),
         "/onboard" => onboard::routes(),
         "/push" => push::routes(),
         "/sync" => sync::routes(),
@@ -95,12 +98,19 @@ fn custom_openapi_spec() -> OpenApi {
               "Invites"
             ]
           },
+          {
+            "name": "Customisation",
+            "tags": [
+              "Emojis"
+            ]
+          },
           {
             "name": "Authentication",
             "tags": [
               "Account",
               "Session",
-              "Onboarding"
+              "Onboarding",
+              "MFA"
             ]
           },
           {
@@ -117,7 +127,7 @@ fn custom_openapi_spec() -> OpenApi {
         openapi: OpenApi::default_version(),
         info: Info {
             title: "Revolt API".to_owned(),
-            description: Some("User-first privacy focused chat platform.".to_owned()),
+            description: Some("Open source user-first chat platform.".to_owned()),
             terms_of_service: Some("https://revolt.chat/terms".to_owned()),
             contact: Some(Contact {
                 name: Some("Revolt Support".to_owned()),
@@ -130,7 +140,7 @@ fn custom_openapi_spec() -> OpenApi {
                 url: Some("https://github.com/revoltchat/delta/blob/master/LICENSE".to_owned()),
                 ..Default::default()
             }),
-            version: "0.5.3-rc.1".to_owned(),
+            version: env!("CARGO_PKG_VERSION").to_string(),
             ..Default::default()
         },
         servers: vec![
@@ -242,6 +252,11 @@ fn custom_openapi_spec() -> OpenApi {
                 description: Some("Create and manage sessions".to_owned()),
                 ..Default::default()
             },
+            Tag {
+                name: "MFA".to_owned(),
+                description: Some("Multi-factor Authentication".to_owned()),
+                ..Default::default()
+            },
             Tag {
                 name: "Onboarding".to_owned(),
                 description: Some(

crates/delta/src/routes/onboard/complete.rs

@@ -1,7 +1,6 @@
 use crate::util::regex::RE_USERNAME;
-use revolt_quark::{models::User, Database, EmptyResponse, Error, Result};
+use revolt_quark::{models::User, rauth::models::Session, Database, EmptyResponse, Error, Result};
 
-use rauth::entities::Session;
 use rocket::{serde::json::Json, State};
 use serde::{Deserialize, Serialize};
 use validator::Validate;
@@ -33,13 +32,10 @@ pub async fn req(
     data.validate()
         .map_err(|error| Error::FailedValidation { error })?;
 
-    if db.is_username_taken(&data.username).await? {
-        return Err(Error::UsernameTaken);
-    }
-
+    let username = User::validate_username(db, data.username).await?;
     let user = User {
         id: session.user_id,
-        username: data.username,
+        username,
         ..Default::default()
     };
 

crates/delta/src/routes/onboard/hello.rs

@@ -1,5 +1,4 @@
-use rauth::entities::Session;
-use revolt_quark::models::User;
+use revolt_quark::{models::User, rauth::models::Session};
 use rocket::serde::json::Json;
 use serde::Serialize;
 

crates/delta/src/routes/push/subscribe.rs

@@ -1,9 +1,11 @@
-use revolt_quark::{EmptyResponse, Error, Result};
-
-use rauth::{
-    entities::{Model, Session, WebPushSubscription},
-    logic::Auth,
+use revolt_quark::{
+    rauth::{
+        models::{Session, WebPushSubscription},
+        RAuth,
+    },
+    EmptyResponse, Error, Result,
 };
+
 use rocket::{serde::json::Json, State};
 
 /// # Push Subscribe
@@ -14,13 +16,13 @@ use rocket::{serde::json::Json, State};
 #[openapi(tag = "Web Push")]
 #[post("/subscribe", data = "<data>")]
 pub async fn req(
-    auth: &State<Auth>,
+    rauth: &State<RAuth>,
     mut session: Session,
     data: Json<WebPushSubscription>,
 ) -> Result<EmptyResponse> {
     session.subscription = Some(data.into_inner());
     session
-        .save(&auth.db, None)
+        .save(&rauth)
         .await
         .map(|_| EmptyResponse)
         .map_err(|_| Error::DatabaseError {

crates/delta/src/routes/push/unsubscribe.rs

@@ -1,9 +1,8 @@
-use revolt_quark::{EmptyResponse, Error, Result};
-
-use rauth::{
-    entities::{Model, Session},
-    logic::Auth,
+use revolt_quark::{
+    rauth::{models::Session, RAuth},
+    EmptyResponse, Error, Result,
 };
+
 use rocket::State;
 
 /// # Unsubscribe
@@ -11,10 +10,10 @@ use rocket::State;
 /// Remove the Web Push subscription associated with the current session.
 #[openapi(tag = "Web Push")]
 #[post("/unsubscribe")]
-pub async fn req(auth: &State<Auth>, mut session: Session) -> Result<EmptyResponse> {
+pub async fn req(rauth: &State<RAuth>, mut session: Session) -> Result<EmptyResponse> {
     session.subscription = None;
     session
-        .save(&auth.db, None)
+        .save(&rauth)
         .await
         .map(|_| EmptyResponse)
         .map_err(|_| Error::DatabaseError {

crates/delta/src/routes/root.rs

@@ -76,7 +76,7 @@ pub struct RevoltConfig {
 #[get("/")]
 pub async fn root() -> Result<Json<RevoltConfig>> {
     Ok(Json(RevoltConfig {
-        revolt: crate::version::VERSION.to_string(),
+        revolt: env!("CARGO_PKG_VERSION").to_string(),
         features: RevoltFeatures {
             captcha: CaptchaFeature {
                 enabled: *USE_HCAPTCHA,

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

@@ -0,0 +1,17 @@
+use revolt_quark::models::{Emoji, User};
+use revolt_quark::{perms, Db, Ref, Result};
+
+use rocket::serde::json::Json;
+
+/// # Fetch Server Emoji
+///
+/// Fetch all emoji on a server.
+#[openapi(tag = "Server Customisation")]
+#[get("/<target>/emojis")]
+pub async fn list_emoji(db: &Db, user: User, target: Ref) -> Result<Json<Vec<Emoji>>> {
+    let server = target.as_server(db).await?;
+    perms(&user).server(&server).calc(db).await?;
+
+    // Fetch all emoji from server if we can view it
+    db.fetch_emoji_by_parent_id(&server.id).await.map(Json)
+}

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

@@ -1,30 +1,26 @@
 use rocket::Route;
 use rocket_okapi::okapi::openapi3::OpenApi;
 
-mod server_ack;
-mod server_create;
-mod server_delete;
-mod server_edit;
-mod server_fetch;
-
-mod channel_create;
-
-mod member_edit;
-mod member_fetch;
-mod member_fetch_all;
-mod member_remove;
-
 mod ban_create;
 mod ban_list;
 mod ban_remove;
-
+mod channel_create;
+mod emoji_list;
 mod invites_fetch;
-
+mod member_edit;
+mod member_fetch;
+mod member_fetch_all;
+mod member_remove;
 mod permissions_set;
 mod permissions_set_default;
 mod roles_create;
 mod roles_delete;
 mod roles_edit;
+mod server_ack;
+mod server_create;
+mod server_delete;
+mod server_edit;
+mod server_fetch;
 
 pub fn routes() -> (Vec<Route>, OpenApi) {
     openapi_get_routes_spec![
@@ -46,6 +42,7 @@ pub fn routes() -> (Vec<Route>, OpenApi) {
         roles_edit::req,
         roles_delete::req,
         permissions_set::req,
-        permissions_set_default::req
+        permissions_set_default::req,
+        emoji_list::list_emoji
     ]
 }

crates/delta/src/routes/sync/set_settings.rs

@@ -1,5 +1,5 @@
 use revolt_quark::models::User;
-use revolt_quark::r#impl::generic::users::user_settings::UserSettingsImpl;
+use revolt_quark::r#impl::UserSettingsImpl;
 use revolt_quark::{Db, EmptyResponse, Result};
 
 use chrono::prelude::*;

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

@@ -1,16 +1,16 @@
 use revolt_quark::models::User;
-use revolt_quark::{Database, Error, Result};
+use revolt_quark::{Database, Error, Ref, Result};
 
 use rocket::serde::json::Json;
 use rocket::State;
 
-/// # Send Friend Request / Accept Request
+/// # Accept Friend Request
 ///
-/// Send a friend request to another user or accept another user's friend request.
+/// Accept another user's friend request.
 #[openapi(tag = "Relationships")]
-#[put("/<username>/friend")]
-pub async fn req(db: &State<Database>, user: User, username: String) -> Result<Json<User>> {
-    let mut target = db.fetch_user_by_username(&username).await?;
+#[put("/<target>/friend")]
+pub async fn req(db: &State<Database>, user: User, target: Ref) -> Result<Json<User>> {
+    let mut target = target.as_user(db).await?;
 
     if user.bot.is_some() || target.bot.is_some() {
         return Err(Error::IsBot);

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

@@ -1,6 +1,5 @@
 use crate::util::regex::RE_USERNAME;
-use rauth::entities::Account;
-use revolt_quark::{models::User, Database, Error, Result};
+use revolt_quark::{models::User, rauth::models::Account, Database, Error, Result};
 use rocket::{serde::json::Json, State};
 use serde::{Deserialize, Serialize};
 use validator::Validate;

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

@@ -59,18 +59,6 @@ impl rocket_okapi::response::OpenApiResponderInner for CachedFile {
 pub async fn req(target: String) -> CachedFile {
     CachedFile((
         ContentType::PNG,
-        match target.chars().last().unwrap() {
-            // 0123456789ABCDEFGHJKMNPQRSTVWXYZ
-            '0' | '1' | '2' | '3' | 'S' | 'Z' => {
-                include_bytes!(crate::asset!("user/2.png")).to_vec()
-            }
-            '4' | '5' | '6' | '7' | 'T' => include_bytes!(crate::asset!("user/3.png")).to_vec(),
-            '8' | '9' | 'A' | 'B' => include_bytes!(crate::asset!("user/4.png")).to_vec(),
-            'C' | 'D' | 'E' | 'F' | 'V' => include_bytes!(crate::asset!("user/5.png")).to_vec(),
-            'G' | 'H' | 'J' | 'K' | 'W' => include_bytes!(crate::asset!("user/6.png")).to_vec(),
-            'M' | 'N' | 'P' | 'Q' | 'X' => include_bytes!(crate::asset!("user/7.png")).to_vec(),
-            /*'0' | '1' | '2' | '3' | 'R' | 'Y'*/
-            _ => include_bytes!(crate::asset!("user/1.png")).to_vec(),
-        },
+        revolt_quark::util::pfp::avatar(target.chars().last().unwrap()),
     ))
 }

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

@@ -13,6 +13,7 @@ mod find_mutual;
 mod get_default_avatar;
 mod open_dm;
 mod remove_friend;
+mod send_friend_request;
 mod unblock_user;
 
 pub fn routes() -> (Vec<Route>, OpenApi) {
@@ -33,5 +34,6 @@ pub fn routes() -> (Vec<Route>, OpenApi) {
         remove_friend::req,
         block_user::req,
         unblock_user::req,
+        send_friend_request::req,
     ]
 }

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

@@ -0,0 +1,32 @@
+use revolt_quark::models::User;
+use revolt_quark::{Database, Error, Result};
+
+use rocket::serde::json::Json;
+use rocket::State;
+use serde::{Deserialize, Serialize};
+
+/// # User Lookup Information
+#[derive(Serialize, Deserialize, JsonSchema)]
+pub struct DataSendFriendRequest {
+    username: String,
+}
+
+/// # Send Friend Request
+///
+/// Send a friend request to another user.
+#[openapi(tag = "Relationships")]
+#[post("/friend", data = "<data>")]
+pub async fn req(
+    db: &State<Database>,
+    user: User,
+    data: Json<DataSendFriendRequest>,
+) -> Result<Json<User>> {
+    let mut target = db.fetch_user_by_username(&data.username).await?;
+
+    if user.bot.is_some() || target.bot.is_some() {
+        return Err(Error::IsBot);
+    }
+
+    user.add_friend(db, &mut target).await?;
+    Ok(Json(target.with_auto_perspective(db, &user).await))
+}

crates/delta/src/util/mod.rs

@@ -1,3 +1 @@
-pub mod idempotency;
-pub mod ratelimiter;
 pub mod regex;

crates/delta/src/util/regex.rs

@@ -6,4 +6,9 @@ use regex::Regex;
 /// Block zero width space
 /// Block lookalike characters
 pub static RE_USERNAME: Lazy<Regex> =
-    Lazy::new(|| Regex::new(r"^[^\u200BА-Яа-яΑ-Ωα-ω]+$").unwrap());
+    Lazy::new(|| Regex::new(r"^[^\u200BА-Яа-яΑ-Ωα-ω@#:\n\r\[\]]+$").unwrap());
+
+/// Regex for valid emoji names
+///
+/// Alphanumeric and underscores
+pub static RE_EMOJI: Lazy<Regex> = Lazy::new(|| Regex::new(r"^[a-zA-Z0-9_]+$").unwrap());

crates/delta/src/version.rs

@@ -1 +0,0 @@
-pub const VERSION: &str = "0.5.3-5-patch.2";

crates/quark/Cargo.toml

@@ -8,8 +8,20 @@ edition = "2021"
 
 [features]
 mongo = [ "mongodb" ]
-rocket_impl = [ "rocket", "rocket_empty" ]
-test = [ "async-std", "mongo", "mongodb/async-std-runtime", "rocket_impl", "rauth" ]
+rocket_impl = [
+    "rocket",
+    "rocket_empty",
+    "rocket_cors",
+
+    "lru",
+    "dashmap",
+
+    "rauth/database-mongodb",
+    "rauth/rocket_impl",
+    "rauth/okapi_impl"
+]
+
+test = [ "async-std", "mongo", "mongodb/async-std-runtime", "rocket_impl" ]
 default = [ "test" ]
 
 [dependencies]
@@ -26,8 +38,8 @@ bson = { version = "2.1.0", features = ["chrono-0_4"] }
 
 # Spec Generation
 schemars = "0.8.8"
-okapi = { git = "https://github.com/insertish/okapi", rev = "dcf0df115596ee07a587a7a543cddf3d7944645b" }
-rocket_okapi = { git = "https://github.com/insertish/okapi", rev = "dcf0df115596ee07a587a7a543cddf3d7944645b" }
+okapi = { git = "https://github.com/insertish/okapi", rev = "a1048d0c8cd771e424ec97d33d825c32e06aa120" }
+rocket_okapi = { git = "https://github.com/insertish/okapi", rev = "a1048d0c8cd771e424ec97d33d825c32e06aa120" }
 # okapi = "0.7.0-rc.1"
 # rocket_okapi = "0.8.0-rc.1"
 
@@ -58,15 +70,21 @@ reqwest = "0.11.10"
 bitfield = "0.13.2"
 lazy_static = "1.4.0"
 
+lru = { version = "0.7.6", optional = true }
+dashmap = { version = "5.2.0", optional = true }
+
 # Web Push
 base64 = "0.13.0"
 web-push = "0.7.2"
 
 # Implementations
-rauth = { optional = true, git = "https://github.com/insertish/rauth", rev = "001a9698c56cea79e69e4ae71d7bc2cb48aec1a6" }
-rocket = { optional = true, version = "=0.5.0-rc.1", default-features = false, features = ["json"] }
-rocket_http = { optional = true, version = "=0.5.0-rc.1" }
-rocket_empty = { optional = true, git = "https://github.com/insertish/rocket_empty", branch = "rc1" }
+rocket_http = { optional = true, version = "0.5.0-rc.2" }
+rocket = { optional = true, version = "0.5.0-rc.2", default-features = false, features = ["json"] }
+rocket_empty = { optional = true, git = "https://github.com/insertish/rocket_empty", branch = "master" }
+rocket_cors = { optional = true, git = "https://github.com/lawliet89/rocket_cors", rev = "5843861a88958c16bfaa0b40f0d8910772bcd2f6" }
+
+# rAuth
+rauth = { git = "https://github.com/insertish/rauth", rev = "c2acaf6b31213e3969f8b48f9deed3daa125d394", features = [ "async-std-runtime" ] }
 
 # Sentry
 sentry = "0.25.0"

crates/quark/assets/templates/deletion.txt

@@ -0,0 +1,5 @@
+You requested to have your account deleted, if you did not perform this action please take measures to secure your account immediately.
+
+Confirm here: {{url}}
+
+Sent by Revolt.

crates/quark/src/database.rs

@@ -1,8 +1,7 @@
 use std::env;
 use std::ops::Deref;
 
-use crate::r#impl::dummy::DummyDb;
-use crate::r#impl::mongo::MongoDb;
+use crate::r#impl::{DummyDb, MongoDb};
 use crate::AbstractDatabase;
 
 /// Database information to use to create a client
@@ -61,3 +60,14 @@ impl Deref for Database {
         }
     }
 }
+
+impl From<Database> for rauth::Database {
+    fn from(val: Database) -> Self {
+        match val {
+            Database::Dummy(_) => rauth::Database::default(),
+            Database::MongoDb(MongoDb(client)) => {
+                rauth::Database::MongoDb(rauth::database::MongoDb(client.database("revolt")))
+            }
+        }
+    }
+}

crates/quark/src/events/client.rs

@@ -5,7 +5,7 @@ use crate::models::message::{AppendMessage, PartialMessage};
 use crate::models::server::{FieldsRole, FieldsServer, PartialRole, PartialServer};
 use crate::models::server_member::{FieldsMember, MemberCompositeKey, PartialMember};
 use crate::models::user::{FieldsUser, PartialUser, RelationshipStatus};
-use crate::models::{Channel, Member, Message, Server, User, UserSettings};
+use crate::models::{Channel, Emoji, Member, Message, Server, User, UserSettings};
 use crate::Error;
 
 /// WebSocket Client Errors
@@ -52,6 +52,7 @@ pub enum EventV1 {
         servers: Vec<Server>,
         channels: Vec<Channel>,
         members: Vec<Member>,
+        emojis: Option<Vec<Emoji>>,
     },
 
     /// Ping response
@@ -170,4 +171,10 @@ pub enum EventV1 {
 
     /// Settings updated remotely
     UserSettingsUpdate { id: String, update: UserSettings },
+
+    /// New emoji
+    EmojiCreate(Emoji),
+
+    /// Delete emoji
+    EmojiDelete { id: String },
 }

crates/quark/src/events/impl.rs

@@ -151,6 +151,17 @@ impl State {
             )
             .await?;
 
+        // Fetch customisations.
+        let emojis = Some(
+            db.fetch_emoji_by_parent_ids(
+                &servers
+                    .iter()
+                    .map(|x| x.id.to_string())
+                    .collect::<Vec<String>>(),
+            )
+            .await?,
+        );
+
         // Copy data into local state cache.
         self.cache.users = users.iter().cloned().map(|x| (x.id.clone(), x)).collect();
         self.cache
@@ -202,6 +213,7 @@ impl State {
             servers,
             channels,
             members,
+            emojis,
         })
     }
 

crates/quark/src/impl/dummy/media/attachment.rs

@@ -39,4 +39,9 @@ impl AbstractAttachment for DummyDb {
         info!("Marked {id} as deleted");
         Ok(())
     }
+
+    async fn mark_attachments_as_deleted(&self, ids: &[String]) -> Result<()> {
+        info!("Marked {ids:?} as deleted");
+        Ok(())
+    }
 }

crates/quark/src/impl/dummy/media/emoji.rs

@@ -0,0 +1,41 @@
+use crate::models::emoji::EmojiParent;
+use crate::models::Emoji;
+use crate::{AbstractEmoji, Result};
+
+use super::super::DummyDb;
+
+#[async_trait]
+impl AbstractEmoji for DummyDb {
+    /// Fetch an emoji by its id
+    async fn fetch_emoji(&self, id: &str) -> Result<Emoji> {
+        Ok(Emoji {
+            id: id.into(),
+            name: id.into(),
+            parent: EmojiParent::Server { id: id.into() },
+            creator_id: id.into(),
+            animated: false,
+        })
+    }
+
+    /// Fetch emoji by their ids
+    async fn fetch_emoji_by_parent_id(&self, parent_id: &str) -> Result<Vec<Emoji>> {
+        Ok(vec![self.fetch_emoji(parent_id).await?])
+    }
+
+    /// Fetch emoji by their parent ids
+    async fn fetch_emoji_by_parent_ids(&self, _parent_ids: &[String]) -> Result<Vec<Emoji>> {
+        Ok(vec![])
+    }
+
+    /// Insert emoji into database.
+    async fn insert_emoji(&self, emoji: &Emoji) -> Result<()> {
+        info!("Insert {emoji:?}");
+        Ok(())
+    }
+
+    /// Delete an emoji by its id
+    async fn delete_emoji(&self, emoji: &Emoji) -> Result<()> {
+        info!("Delete {emoji:?}");
+        Ok(())
+    }
+}

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

@@ -4,8 +4,9 @@ pub mod admin {
     pub mod migrations;
 }
 
-pub mod autumn {
+pub mod media {
     pub mod attachment;
+    pub mod emoji;
 }
 
 pub mod channels {

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

@@ -242,7 +242,12 @@ impl Channel {
     /// Add user to a group
     pub async fn add_user_to_group(&mut self, db: &Database, user: &str, by: &str) -> Result<()> {
         if let Channel::Group { recipients, .. } = self {
-            recipients.push(user.to_string());
+            let user = user.to_string();
+            if recipients.contains(&user) {
+                return Err(Error::AlreadyInGroup);
+            }
+
+            recipients.push(user);
         }
 
         match &self {

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

@@ -2,6 +2,7 @@ use std::collections::HashSet;
 
 use serde_json::json;
 use ulid::Ulid;
+use validator::Validate;
 
 use crate::{
     events::client::EventV1,
@@ -17,7 +18,7 @@ use crate::{
         january::{Embed, Text},
         push::PushNotification,
     },
-    Database, Result,
+    Database, Error, Result,
 };
 
 impl Message {
@@ -134,7 +135,17 @@ impl Message {
 
     /// Delete a message
     pub async fn delete(self, db: &Database) -> Result<()> {
+        let file_ids: Vec<String> = self
+            .attachments
+            .map(|files| files.iter().map(|file| file.id.to_string()).collect())
+            .unwrap_or_default();
+
+        if !file_ids.is_empty() {
+            db.mark_attachments_as_deleted(&file_ids).await?;
+        }
+
         db.delete_message(&self.id).await?;
+
         EventV1::MessageDelete {
             id: self.id,
             channel: self.channel.clone(),
@@ -155,6 +166,31 @@ impl Message {
         .await;
         Ok(())
     }
+
+    /// Validate the sum of content of a message is under threshold
+    pub fn validate_sum(
+        content: &Option<String>,
+        embeds: &Option<Vec<SendableEmbed>>,
+    ) -> Result<()> {
+        let mut running_total = 0;
+        if let Some(content) = content {
+            running_total += content.len();
+        }
+
+        if let Some(embeds) = embeds {
+            for embed in embeds {
+                if let Some(desc) = &embed.description {
+                    running_total += desc.len();
+                }
+            }
+        }
+
+        if running_total <= 2000 {
+            Ok(())
+        } else {
+            Err(Error::PayloadTooLarge)
+        }
+    }
 }
 
 pub trait IntoUsers {
@@ -232,6 +268,9 @@ impl From<SystemMessage> for String {
 
 impl SendableEmbed {
     pub async fn into_embed(self, db: &Database, message_id: String) -> Result<Embed> {
+        self.validate()
+            .map_err(|error| Error::FailedValidation { error })?;
+
         let media = if let Some(id) = self.media {
             Some(
                 db.find_and_use_attachment(&id, "attachments", "message", &message_id)

crates/quark/src/impl/generic/media/attachment.rs

@@ -30,4 +30,9 @@ impl File {
         db.find_and_use_attachment(id, "banners", "server", parent)
             .await
     }
+
+    pub async fn use_emoji(db: &Database, id: &str, parent: &str) -> Result<File> {
+        db.find_and_use_attachment(id, "emojis", "object", parent)
+            .await
+    }
 }

crates/quark/src/impl/generic/media/emoji.rs

@@ -0,0 +1,36 @@
+use crate::{
+    events::client::EventV1,
+    models::{emoji::EmojiParent, Emoji},
+    Database, Result,
+};
+
+impl Emoji {
+    /// Get parent id
+    fn parent(&self) -> &str {
+        match &self.parent {
+            EmojiParent::Server { id } => id,
+        }
+    }
+
+    /// Create an emoji
+    pub async fn create(&self, db: &Database) -> Result<()> {
+        db.insert_emoji(self).await?;
+        EventV1::EmojiCreate(self.clone())
+            .p(self.parent().to_string())
+            .await;
+
+        Ok(())
+    }
+
+    /// Delete an emoji
+    pub async fn delete(self, db: &Database) -> Result<()> {
+        EventV1::EmojiDelete {
+            id: self.id.to_string(),
+        }
+        .p(self.parent().to_string())
+        .await;
+
+        db.mark_attachment_as_deleted(&self.id).await?;
+        db.delete_emoji(&self).await
+    }
+}

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

@@ -4,8 +4,9 @@ pub mod admin {
     pub mod migrations;
 }
 
-pub mod autumn {
+pub mod media {
     pub mod attachment;
+    pub mod emoji;
 }
 
 pub mod channels {

crates/quark/src/impl/generic/users/user.rs

@@ -8,9 +8,6 @@ use crate::{perms, Database, Error, Result};
 
 use futures::try_join;
 use impl_ops::impl_op_ex_commutative;
-use okapi::openapi3::{SecurityScheme, SecuritySchemeData};
-use rocket_okapi::gen::OpenApiGenerator;
-use rocket_okapi::request::{OpenApiFromRequest, RequestHeaderInput};
 use std::ops;
 
 impl_op_ex_commutative!(+ |a: &i32, b: &Badges| -> i32 { *a | *b as i32 });
@@ -153,18 +150,51 @@ impl User {
         Ok(db.fetch_server_count(&self.id).await? <= 100)
     }
 
-    /// Update a user's username
-    pub async fn update_username(&mut self, db: &Database, username: String) -> Result<()> {
+    /// Sanitise and validate a username can be used
+    pub async fn validate_username(db: &Database, username: String) -> Result<String> {
+        // Trim surrounding spaces
         let username = username.trim().to_string();
 
+        // Make sure username is still at least 3 characters
+        if username.len() < 2 {
+            return Err(Error::InvalidUsername);
+        }
+
+        // Copy the username for validation
+        let username_lowercase = username.to_lowercase();
+
+        // Ensure the username itself isn't blocked
+        const BLOCKED_USERNAMES: &[&str] = &["admin", "revolt"];
+
+        for username in BLOCKED_USERNAMES {
+            if username_lowercase == *username {
+                return Err(Error::InvalidUsername);
+            }
+        }
+
+        // Ensure none of the following substrings show up in the username
+        const BLOCKED_SUBSTRINGS: &[&str] = &["```"];
+
+        for substr in BLOCKED_SUBSTRINGS {
+            if username_lowercase.contains(substr) {
+                return Err(Error::InvalidUsername);
+            }
+        }
+
+        // Make sure the username isn't taken
         if db.is_username_taken(&username).await? {
             return Err(Error::UsernameTaken);
         }
 
+        Ok(username)
+    }
+
+    /// Update a user's username
+    pub async fn update_username(&mut self, db: &Database, username: String) -> Result<()> {
         self.update(
             db,
             PartialUser {
-                username: Some(username),
+                username: Some(User::validate_username(db, username).await?),
                 ..Default::default()
             },
             vec![],
@@ -359,72 +389,3 @@ impl User {
         }
     }
 }
-
-use rauth::entities::Session;
-use rocket::http::Status;
-use rocket::request::{self, FromRequest, Outcome, Request};
-
-#[rocket::async_trait]
-impl<'r> FromRequest<'r> for User {
-    type Error = rauth::util::Error;
-
-    async fn from_request(request: &'r Request<'_>) -> request::Outcome<Self, Self::Error> {
-        let user: &Option<User> = request
-            .local_cache_async(async {
-                let db = request
-                    .rocket()
-                    .state::<Database>()
-                    .expect("Database state not reachable!");
-
-                let header_bot_token = request
-                    .headers()
-                    .get("x-bot-token")
-                    .next()
-                    .map(|x| x.to_string());
-
-                if let Some(bot_token) = header_bot_token {
-                    if let Ok(user) = User::from_token(db, &bot_token, UserHint::Bot).await {
-                        return Some(user);
-                    }
-                } else if let Outcome::Success(session) = request.guard::<Session>().await {
-                    // This uses a guard so can't really easily be refactored into from_token at this stage.
-                    if let Ok(user) = db.fetch_user(&session.user_id).await {
-                        return Some(user);
-                    }
-                }
-
-                None
-            })
-            .await;
-
-        if let Some(user) = user {
-            Outcome::Success(user.clone())
-        } else {
-            Outcome::Failure((Status::Unauthorized, rauth::util::Error::InvalidSession))
-        }
-    }
-}
-
-impl<'r> OpenApiFromRequest<'r> for User {
-    fn from_request_input(
-        _gen: &mut OpenApiGenerator,
-        _name: String,
-        _required: bool,
-    ) -> rocket_okapi::Result<RequestHeaderInput> {
-        let mut requirements = schemars::Map::new();
-        requirements.insert("Api Key".to_owned(), vec![]);
-
-        Ok(RequestHeaderInput::Security(
-            "Api Key".to_owned(),
-            SecurityScheme {
-                data: SecuritySchemeData::ApiKey {
-                    name: "x-session-token".to_owned(),
-                    location: "header".to_owned(),
-                },
-                description: Some("Session Token".to_owned()),
-                extensions: schemars::Map::new(),
-            },
-            requirements,
-        ))
-    }
-}

crates/quark/src/impl/mod.rs

@@ -1,3 +1,10 @@
-pub mod dummy;
-pub mod generic;
-pub mod mongo;
+mod dummy;
+mod generic;
+mod mongo;
+
+#[cfg(feature = "rocket_impl")]
+mod rocket;
+
+pub use self::generic::users::user_settings::UserSettingsImpl;
+pub use dummy::DummyDb;
+pub use mongo::MongoDb;

crates/quark/src/impl/mongo/admin/migrations/init.rs

@@ -2,7 +2,6 @@ use crate::r#impl::mongo::MongoDb;
 
 use super::scripts::LATEST_REVISION;
 
-use log::info;
 use mongodb::bson::doc;
 use mongodb::options::CreateCollectionOptions;
 

crates/quark/src/impl/mongo/admin/migrations/scripts.rs

@@ -2,7 +2,6 @@ use std::time::Duration;
 
 use bson::Bson;
 use futures::StreamExt;
-use log::info;
 use mongodb::{
     bson::{doc, from_bson, from_document, to_document, Document},
     options::FindOptions,
@@ -17,7 +16,7 @@ struct MigrationInfo {
     revision: i32,
 }
 
-pub const LATEST_REVISION: i32 = 15;
+pub const LATEST_REVISION: i32 = 17;
 
 pub async fn migrate_database(db: &MongoDb) {
     let migrations = db.col::<Document>("migrations");
@@ -603,6 +602,48 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
             .unwrap();
     }
 
+    if revision <= 15 {
+        info!("Running migration [revision 15 / 04-06-2022]: Migrate rAuth to latest version.");
+
+        let db = rauth::Database::MongoDb(rauth::database::MongoDb(db.db()));
+        db.run_migration(rauth::Migration::M2022_06_03EnsureUpToSpec)
+            .await
+            .unwrap();
+    }
+
+    if revision <= 16 {
+        info!("Running migration [revision 16 / 07-07-2022]: Add `emojis` collection and rAuth migration.");
+
+        let rauth_db = rauth::Database::MongoDb(rauth::database::MongoDb(db.db()));
+        rauth_db
+            .run_migration(rauth::Migration::M2022_06_09AddIndexForDeletion)
+            .await
+            .unwrap();
+
+        db.db()
+            .create_collection("emojis", None)
+            .await
+            .expect("Failed to create emojis collection.");
+
+        db.db()
+            .run_command(
+                doc! {
+                    "createIndexes": "emojis",
+                    "indexes": [
+                        {
+                            "key": {
+                                "parent.id": 1_i32,
+                            },
+                            "name": "parent_id"
+                        }
+                    ]
+                },
+                None,
+            )
+            .await
+            .expect("Failed to create emoji parent index.");
+    }
+
     // Need to migrate fields on attachments, change `user_id`, `object_id`, etc to `parent`.
 
     // Reminder to update LATEST_REVISION when adding new migrations.

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

@@ -37,30 +37,46 @@ impl AbstractChannelUnread for MongoDb {
     }
 
     async fn acknowledge_channels(&self, user: &str, channels: &[String]) -> Result<()> {
+        let current_time = Ulid::new().to_string();
+
         self.col::<Document>(COL)
-            .update_one(
+            .delete_many(
                 doc! {
                     "_id.channel": {
                         "$in": channels
                     },
-                    "_id.user": user,
+                    "_id.user": user
                 },
-                doc! {
-                    "$unset": {
-                        "mentions": 1_i32
-                    },
-                    "$set": {
-                        "last_id": Ulid::new().to_string()
-                    }
-                },
-                UpdateOptions::builder().upsert(true).build(),
+                None,
             )
             .await
-            .map(|_| ())
             .map_err(|_| Error::DatabaseError {
-                operation: "update",
-                with: "channel_unread",
+                operation: "delete_many",
+                with: "channel_unreads",
+            })?;
+
+        self.col::<Document>(COL)
+            .insert_many(
+                channels
+                    .iter()
+                    .map(|channel| {
+                        doc! {
+                            "_id": {
+                                "channel": channel,
+                                "user": user
+                            },
+                            "last_id": &current_time
+                        }
+                    })
+                    .collect::<Vec<Document>>(),
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "update_many",
+                with: "channel_unreads",
             })
+            .map(|_| ())
     }
 
     async fn add_mention_to_unread<'a>(

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

@@ -14,7 +14,7 @@ impl MongoDb {
     pub async fn delete_bulk_messages(&self, projection: Document) -> Result<()> {
         let mut for_attachments = projection.clone();
         for_attachments.insert(
-            "attachment",
+            "attachments",
             doc! {
                 "$exists": 1_i32
             },
@@ -126,10 +126,7 @@ impl AbstractMessage for MongoDb {
     }
 
     async fn delete_message(&self, id: &str) -> Result<()> {
-        self.delete_bulk_messages(doc! {
-            "_id": id
-        })
-        .await
+        self.delete_one_by_id(COL, id).await.map(|_| ())
     }
 
     async fn delete_messages(&self, channel: &str, ids: Vec<String>) -> Result<()> {

crates/quark/src/impl/mongo/media/attachment.rs

@@ -122,4 +122,27 @@ impl AbstractAttachment for MongoDb {
                 with: "attachment",
             })
     }
+
+    async fn mark_attachments_as_deleted(&self, ids: &[String]) -> Result<()> {
+        self.col::<Document>(COL)
+            .update_many(
+                doc! {
+                    "_id": {
+                        "$in": ids
+                    }
+                },
+                doc! {
+                    "$set": {
+                        "deleted": true
+                    }
+                },
+                None,
+            )
+            .await
+            .map(|_| ())
+            .map_err(|_| Error::DatabaseError {
+                operation: "update",
+                with: "attachments",
+            })
+    }
 }

crates/quark/src/impl/mongo/media/emoji.rs

@@ -0,0 +1,48 @@
+use crate::models::Emoji;
+use crate::{AbstractEmoji, Result};
+
+use super::super::MongoDb;
+
+static COL: &str = "emojis";
+
+#[async_trait]
+impl AbstractEmoji for MongoDb {
+    /// Fetch an emoji by its id
+    async fn fetch_emoji(&self, id: &str) -> Result<Emoji> {
+        self.find_one_by_id(COL, id).await
+    }
+
+    /// Fetch emoji by their ids
+    async fn fetch_emoji_by_parent_id(&self, parent_id: &str) -> Result<Vec<Emoji>> {
+        self.find(
+            COL,
+            doc! {
+                "parent.id": parent_id
+            },
+        )
+        .await
+    }
+
+    /// Fetch emoji by their parent ids
+    async fn fetch_emoji_by_parent_ids(&self, parent_ids: &[String]) -> Result<Vec<Emoji>> {
+        self.find(
+            COL,
+            doc! {
+                "parent.id": {
+                    "$in": parent_ids
+                }
+            },
+        )
+        .await
+    }
+
+    /// Insert emoji into database.
+    async fn insert_emoji(&self, emoji: &Emoji) -> Result<()> {
+        self.insert_one(COL, emoji).await.map(|_| ())
+    }
+
+    /// Delete an emoji by its id
+    async fn delete_emoji(&self, emoji: &Emoji) -> Result<()> {
+        self.delete_one_by_id(COL, &emoji.id).await.map(|_| ())
+    }
+}

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

@@ -15,8 +15,9 @@ pub mod admin {
     pub mod migrations;
 }
 
-pub mod autumn {
+pub mod media {
     pub mod attachment;
+    pub mod emoji;
 }
 
 pub mod channels {

crates/quark/src/impl/mongo/servers/server.rs

@@ -18,6 +18,20 @@ impl MongoDb {
         })
         .await?;
 
+        // Delete all emoji.
+        self.col::<Document>("emojis")
+            .delete_many(
+                doc! {
+                    "parent.id": &server.id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "delete_many",
+                with: "emojis",
+            })?;
+
         // Delete all channels.
         self.col::<Document>("channels")
             .delete_many(

crates/quark/src/impl/rocket.rs

@@ -0,0 +1,73 @@
+use okapi::openapi3::{SecurityScheme, SecuritySchemeData};
+use rauth::models::Session;
+use rocket_okapi::gen::OpenApiGenerator;
+use rocket_okapi::request::{OpenApiFromRequest, RequestHeaderInput};
+
+use rocket::http::Status;
+use rocket::request::{self, FromRequest, Outcome, Request};
+
+use crate::models::user::UserHint;
+use crate::models::User;
+use crate::Database;
+
+#[rocket::async_trait]
+impl<'r> FromRequest<'r> for User {
+    type Error = rauth::Error;
+
+    async fn from_request(request: &'r Request<'_>) -> request::Outcome<Self, Self::Error> {
+        let user: &Option<User> = request
+            .local_cache_async(async {
+                let db = request.rocket().state::<Database>().expect("`Database`");
+
+                let header_bot_token = request
+                    .headers()
+                    .get("x-bot-token")
+                    .next()
+                    .map(|x| x.to_string());
+
+                if let Some(bot_token) = header_bot_token {
+                    if let Ok(user) = User::from_token(db, &bot_token, UserHint::Bot).await {
+                        return Some(user);
+                    }
+                } else if let Outcome::Success(session) = request.guard::<Session>().await {
+                    // This uses a guard so can't really easily be refactored into from_token at this stage.
+                    if let Ok(user) = db.fetch_user(&session.user_id).await {
+                        return Some(user);
+                    }
+                }
+
+                None
+            })
+            .await;
+
+        if let Some(user) = user {
+            Outcome::Success(user.clone())
+        } else {
+            Outcome::Failure((Status::Unauthorized, rauth::Error::InvalidSession))
+        }
+    }
+}
+
+impl<'r> OpenApiFromRequest<'r> for User {
+    fn from_request_input(
+        _gen: &mut OpenApiGenerator,
+        _name: String,
+        _required: bool,
+    ) -> rocket_okapi::Result<RequestHeaderInput> {
+        let mut requirements = schemars::Map::new();
+        requirements.insert("Session Token".to_owned(), vec![]);
+
+        Ok(RequestHeaderInput::Security(
+            "Session Token".to_owned(),
+            SecurityScheme {
+                data: SecuritySchemeData::ApiKey {
+                    name: "x-session-token".to_owned(),
+                    location: "header".to_owned(),
+                },
+                description: Some("Used to authenticate as a user.".to_owned()),
+                extensions: schemars::Map::new(),
+            },
+            requirements,
+        ))
+    }
+}

crates/quark/src/lib.rs

@@ -15,9 +15,10 @@ extern crate lazy_static;
 #[macro_use]
 extern crate bitfield;
 #[macro_use]
-pub extern crate bson;
+extern crate bson;
 
 pub use iso8601_timestamp::Timestamp;
+pub use rauth;
 pub use redis_kiss;
 
 pub mod events;
@@ -26,11 +27,14 @@ pub mod models;
 pub mod presence;
 pub mod tasks;
 pub mod types;
+pub mod util;
+
+#[cfg(feature = "rocket_impl")]
+pub mod web;
 
 mod database;
 mod permissions;
 mod traits;
-mod util;
 
 pub use database::*;
 pub use traits::*;
@@ -38,38 +42,20 @@ pub use traits::*;
 pub use permissions::defn::*;
 pub use permissions::{get_relationship, perms};
 
-pub use util::r#ref::Ref;
-pub use util::result::{Error, Result};
-pub use util::variables;
+pub use util::{
+    r#ref::Ref,
+    result::{Error, Result},
+    variables,
+};
 
 #[cfg(feature = "rocket_impl")]
-pub use rocket_empty::EmptyResponse;
+pub use web::{Db, EmptyResponse};
 
-#[cfg(feature = "rocket_impl")]
-use rocket::State;
-
-#[cfg(feature = "rocket_impl")]
-pub type Db = State<Database>;
-
-/// Configure logging and common Rust variables
-pub fn setup_logging() -> sentry::ClientInitGuard {
-    dotenv::dotenv().ok();
-
-    if std::env::var("RUST_LOG").is_err() {
-        std::env::set_var("RUST_LOG", "info");
-    }
-
-    if std::env::var("ROCKET_ADDRESS").is_err() {
-        std::env::set_var("ROCKET_ADDRESS", "0.0.0.0");
-    }
-
-    pretty_env_logger::init();
-
-    sentry::init((
-        "https://62fd0e02c5354905b4e286757f4beb16@sentry.insert.moe/4",
-        sentry::ClientOptions {
-            release: sentry::release_name!(),
-            ..Default::default()
-        },
-    ))
+/// Resolve asset
+macro_rules! asset {
+    ($path:literal) => {
+        concat!(env!("CARGO_MANIFEST_DIR"), "/assets/", $path)
+    };
 }
+
+pub(crate) use asset;

crates/quark/src/models/media/emoji.rs

@@ -0,0 +1,24 @@
+use serde::{Deserialize, Serialize};
+
+/// Information about what owns this emoji
+#[derive(Serialize, Deserialize, JsonSchema, Debug, Clone)]
+#[serde(tag = "type")]
+pub enum EmojiParent {
+    Server { id: String },
+}
+
+/// Representation of an Emoji on Revolt
+#[derive(Serialize, Deserialize, JsonSchema, Debug, Clone)]
+pub struct Emoji {
+    /// Unique Id
+    #[serde(rename = "_id")]
+    pub id: String,
+    /// What owns this emoji
+    pub parent: EmojiParent,
+    /// Uploader user id
+    pub creator_id: String,
+    /// Emoji name
+    pub name: String,
+    /// Whether the emoji is animated
+    pub animated: bool,
+}

crates/quark/src/models/mod.rs

@@ -3,8 +3,9 @@ mod admin {
     pub mod simple;
 }
 
-mod autumn {
+mod media {
     pub mod attachment;
+    pub mod emoji;
 }
 
 mod channels {
@@ -27,8 +28,8 @@ mod users {
 }
 
 pub use admin::*;
-pub use autumn::*;
 pub use channels::*;
+pub use media::*;
 pub use servers::*;
 pub use users::*;
 
@@ -37,6 +38,7 @@ pub use bot::Bot;
 pub use channel::Channel;
 pub use channel_invite::Invite;
 pub use channel_unread::ChannelUnread;
+pub use emoji::Emoji;
 pub use message::Message;
 pub use migrations::MigrationInfo;
 pub use server::Server;

crates/quark/src/models/relations.drawio

@@ -0,0 +1,205 @@
+<mxfile host="65bd71144e">
+    <diagram id="9BKyaxnbqnTkbfLuLd1z" name="Page-1">
+        <mxGraphModel dx="1033" dy="710" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="827" pageHeight="1169" math="0" shadow="0">
+            <root>
+                <mxCell id="0"/>
+                <mxCell id="1" parent="0"/>
+                <mxCell id="56" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=0.5;entryY=1;entryDx=0;entryDy=0;startArrow=none;startFill=0;endArrow=diamondThin;endFill=0;strokeColor=#B3B3B3;dashed=1;" parent="1" source="2" target="6" edge="1">
+                    <mxGeometry relative="1" as="geometry"/>
+                </mxCell>
+                <mxCell id="57" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=0.75;entryY=1;entryDx=0;entryDy=0;startArrow=none;startFill=0;endArrow=diamondThin;endFill=0;strokeColor=#B3B3B3;dashed=1;" parent="1" source="2" target="5" edge="1">
+                    <mxGeometry relative="1" as="geometry">
+                        <Array as="points">
+                            <mxPoint x="260" y="370"/>
+                            <mxPoint x="275" y="370"/>
+                        </Array>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="58" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=0.25;entryY=1;entryDx=0;entryDy=0;startArrow=none;startFill=0;endArrow=diamondThin;endFill=0;strokeColor=#B3B3B3;dashed=1;" parent="1" source="2" target="9" edge="1">
+                    <mxGeometry relative="1" as="geometry">
+                        <Array as="points">
+                            <mxPoint x="260" y="370"/>
+                            <mxPoint x="342" y="370"/>
+                        </Array>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="59" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=0.5;exitY=0;exitDx=0;exitDy=0;startArrow=none;startFill=0;endArrow=diamondThin;endFill=0;entryX=0.5;entryY=1;entryDx=0;entryDy=0;strokeColor=#B3B3B3;dashed=1;" parent="1" source="2" target="12" edge="1">
+                    <mxGeometry relative="1" as="geometry">
+                        <mxPoint x="300" y="250" as="targetPoint"/>
+                        <Array as="points">
+                            <mxPoint x="260" y="370"/>
+                            <mxPoint x="300" y="370"/>
+                        </Array>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="2" value="Attachment" style="rounded=0;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+                    <mxGeometry x="220" y="490" width="80" height="30" as="geometry"/>
+                </mxCell>
+                <mxCell id="49" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=0.25;entryY=1;entryDx=0;entryDy=0;startArrow=none;startFill=0;endArrow=diamondThin;endFill=1;" parent="1" source="3" target="5" edge="1">
+                    <mxGeometry relative="1" as="geometry">
+                        <Array as="points">
+                            <mxPoint x="195" y="340"/>
+                            <mxPoint x="245" y="340"/>
+                        </Array>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="51" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=0.5;exitY=0;exitDx=0;exitDy=0;startArrow=none;startFill=0;endArrow=diamondThin;endFill=1;entryX=0.25;entryY=1;entryDx=0;entryDy=0;" parent="1" source="3" target="12" edge="1">
+                    <mxGeometry relative="1" as="geometry">
+                        <mxPoint x="290" y="160" as="targetPoint"/>
+                        <Array as="points">
+                            <mxPoint x="195" y="260"/>
+                            <mxPoint x="260" y="260"/>
+                            <mxPoint x="260" y="220"/>
+                            <mxPoint x="290" y="220"/>
+                        </Array>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="3" value="Channel Invite" style="rounded=0;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+                    <mxGeometry x="150" y="400" width="90" height="30" as="geometry"/>
+                </mxCell>
+                <mxCell id="4" value="Channel Unread" style="rounded=0;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+                    <mxGeometry x="40" y="400" width="100" height="30" as="geometry"/>
+                </mxCell>
+                <mxCell id="43" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=0.25;entryY=1;entryDx=0;entryDy=0;startArrow=none;startFill=0;endArrow=diamondThin;endFill=1;dashed=1;" parent="1" source="5" target="12" edge="1">
+                    <mxGeometry relative="1" as="geometry"/>
+                </mxCell>
+                <mxCell id="60" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;dashed=1;startArrow=none;startFill=0;endArrow=diamondThin;endFill=1;strokeColor=#FFFFFF;" parent="1" source="5" target="9" edge="1">
+                    <mxGeometry relative="1" as="geometry"/>
+                </mxCell>
+                <mxCell id="5" value="Channel" style="rounded=0;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+                    <mxGeometry x="230" y="280" width="60" height="30" as="geometry"/>
+                </mxCell>
+                <mxCell id="45" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=0.75;entryY=1;entryDx=0;entryDy=0;startArrow=none;startFill=0;endArrow=diamondThin;endFill=1;" parent="1" source="6" target="12" edge="1">
+                    <mxGeometry relative="1" as="geometry"/>
+                </mxCell>
+                <mxCell id="46" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=0.5;entryY=1;entryDx=0;entryDy=0;startArrow=none;startFill=0;endArrow=diamondThin;endFill=1;" parent="1" source="6" target="5" edge="1">
+                    <mxGeometry relative="1" as="geometry">
+                        <Array as="points">
+                            <mxPoint x="310" y="355"/>
+                            <mxPoint x="260" y="355"/>
+                        </Array>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="6" value="Message" style="rounded=0;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+                    <mxGeometry x="280" y="400" width="60" height="30" as="geometry"/>
+                </mxCell>
+                <mxCell id="54" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=0.5;entryY=1;entryDx=0;entryDy=0;startArrow=none;startFill=0;endArrow=diamondThin;endFill=1;" parent="1" source="7" target="9" edge="1">
+                    <mxGeometry relative="1" as="geometry">
+                        <Array as="points">
+                            <mxPoint x="505" y="350"/>
+                            <mxPoint x="355" y="350"/>
+                        </Array>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="7" value="Server Ban" style="rounded=0;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+                    <mxGeometry x="470" y="400" width="70" height="30" as="geometry"/>
+                </mxCell>
+                <mxCell id="47" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=0.5;entryY=1;entryDx=0;entryDy=0;startArrow=none;startFill=0;endArrow=diamondThin;endFill=1;" parent="1" source="8" target="9" edge="1">
+                    <mxGeometry relative="1" as="geometry">
+                        <Array as="points">
+                            <mxPoint x="405" y="350"/>
+                            <mxPoint x="355" y="350"/>
+                        </Array>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="48" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=0.75;entryY=1;entryDx=0;entryDy=0;startArrow=none;startFill=0;endArrow=diamondThin;endFill=1;" parent="1" source="8" target="12" edge="1">
+                    <mxGeometry relative="1" as="geometry">
+                        <Array as="points">
+                            <mxPoint x="405" y="350"/>
+                            <mxPoint x="310" y="350"/>
+                        </Array>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="8" value="Server Member" style="rounded=0;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+                    <mxGeometry x="360" y="400" width="90" height="30" as="geometry"/>
+                </mxCell>
+                <mxCell id="29" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;endArrow=diamondThin;endFill=1;startArrow=diamondThin;startFill=1;" parent="1" source="10" target="12" edge="1">
+                    <mxGeometry relative="1" as="geometry">
+                        <Array as="points">
+                            <mxPoint x="240" y="145"/>
+                        </Array>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="10" value="Bot" style="rounded=0;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+                    <mxGeometry x="200" y="130" width="40" height="30" as="geometry"/>
+                </mxCell>
+                <mxCell id="31" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=0.25;entryY=1;entryDx=0;entryDy=0;startArrow=none;startFill=0;endArrow=diamondThin;endFill=1;" parent="1" source="11" target="12" edge="1">
+                    <mxGeometry relative="1" as="geometry"/>
+                </mxCell>
+                <mxCell id="11" value="User Settings" style="rounded=0;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+                    <mxGeometry x="150" y="210" width="90" height="30" as="geometry"/>
+                </mxCell>
+                <mxCell id="15" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=0.5;entryY=1;entryDx=0;entryDy=0;endArrow=diamondThin;endFill=1;" parent="1" source="12" target="13" edge="1">
+                    <mxGeometry relative="1" as="geometry"/>
+                </mxCell>
+                <mxCell id="12" value="User" style="rounded=0;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+                    <mxGeometry x="280" y="130" width="40" height="30" as="geometry"/>
+                </mxCell>
+                <mxCell id="13" value="Account" style="rounded=0;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+                    <mxGeometry x="310" y="40" width="60" height="30" as="geometry"/>
+                </mxCell>
+                <mxCell id="17" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=0.5;entryY=1;entryDx=0;entryDy=0;endArrow=diamondThin;endFill=1;" parent="1" source="14" target="13" edge="1">
+                    <mxGeometry relative="1" as="geometry"/>
+                </mxCell>
+                <mxCell id="14" value="Session" style="rounded=0;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+                    <mxGeometry x="350" y="130" width="60" height="30" as="geometry"/>
+                </mxCell>
+                <mxCell id="44" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=0.5;exitY=0;exitDx=0;exitDy=0;startArrow=none;startFill=0;endArrow=diamondThin;endFill=1;entryX=0.75;entryY=1;entryDx=0;entryDy=0;" parent="1" source="9" target="12" edge="1">
+                    <mxGeometry relative="1" as="geometry">
+                        <mxPoint x="310" y="160" as="targetPoint"/>
+                        <Array as="points">
+                            <mxPoint x="355" y="220"/>
+                            <mxPoint x="310" y="220"/>
+                        </Array>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="9" value="Server" style="rounded=0;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+                    <mxGeometry x="330" y="280" width="50" height="30" as="geometry"/>
+                </mxCell>
+                <mxCell id="55" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=0.5;exitY=0;exitDx=0;exitDy=0;startArrow=none;startFill=0;endArrow=diamondThin;endFill=1;" parent="1" source="4" edge="1">
+                    <mxGeometry relative="1" as="geometry">
+                        <mxPoint x="290" y="160" as="targetPoint"/>
+                        <mxPoint x="200" y="400" as="sourcePoint"/>
+                        <Array as="points">
+                            <mxPoint x="90" y="370"/>
+                            <mxPoint x="195" y="370"/>
+                            <mxPoint x="195" y="260"/>
+                            <mxPoint x="260" y="260"/>
+                            <mxPoint x="260" y="220"/>
+                            <mxPoint x="290" y="220"/>
+                        </Array>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="63" value="" style="edgeStyle=orthogonalEdgeStyle;html=1;startArrow=none;startFill=0;endArrow=diamondThin;endFill=0;strokeColor=#FFFFFF;entryX=1;entryY=1;entryDx=0;entryDy=0;" parent="1" source="61" target="12" edge="1">
+                    <mxGeometry relative="1" as="geometry">
+                        <mxPoint x="584.25" y="335" as="targetPoint"/>
+                        <Array as="points">
+                            <mxPoint x="584" y="340"/>
+                            <mxPoint x="390" y="340"/>
+                            <mxPoint x="390" y="210"/>
+                            <mxPoint x="320" y="210"/>
+                        </Array>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="64" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=0.75;entryY=1;entryDx=0;entryDy=0;startArrow=none;startFill=0;endArrow=diamondThin;endFill=1;strokeColor=#FFFFFF;" parent="1" source="61" target="9" edge="1">
+                    <mxGeometry relative="1" as="geometry">
+                        <Array as="points">
+                            <mxPoint x="584" y="340"/>
+                            <mxPoint x="368" y="340"/>
+                            <mxPoint x="368" y="310"/>
+                        </Array>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="61" value="Emoji" style="rounded=0;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+                    <mxGeometry x="558.5" y="400" width="51.5" height="30" as="geometry"/>
+                </mxCell>
+                <mxCell id="65" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=0.5;entryY=1;entryDx=0;entryDy=0;startArrow=none;startFill=0;endArrow=diamondThin;endFill=0;strokeColor=#B3B3B3;dashed=1;" parent="1" source="2" target="61" edge="1">
+                    <mxGeometry relative="1" as="geometry">
+                        <mxPoint x="270" y="500" as="sourcePoint"/>
+                        <mxPoint x="320" y="440" as="targetPoint"/>
+                    </mxGeometry>
+                </mxCell>
+            </root>
+        </mxGraphModel>
+    </diagram>
+</mxfile>

crates/quark/src/permissions/defn/permission.rs

@@ -21,8 +21,10 @@ pub enum Permission {
     ManagePermissions = 1 << 2,
     /// Manage roles on server
     ManageRole = 1 << 3,
+    /// Manage server customisation (includes emoji)
+    ManageCustomisation = 1 << 4,
 
-    // % 2 bits reserved
+    // % 1 bits reserved
 
     // * Member permissions
     /// Kick other members below their ranking
@@ -122,6 +124,7 @@ bitfield! {
     pub can_manage_server, _: 62;
     pub can_manage_permissions, _: 61;
     pub can_manage_roles, _: 60;
+    pub can_manage_customisation, _: 59;
 
     // * Member permissions
     pub can_kick_members, _: 57;

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

@@ -110,7 +110,13 @@ async fn calculate_channel_permission(
 
     // 1. Check channel type.
     let value: PermissionValue = match channel {
-        Channel::SavedMessages { .. } => (*DEFAULT_PERMISSION_SAVED_MESSAGES).into(),
+        Channel::SavedMessages { user, .. } => {
+            if user == &data.perspective.id {
+                (*DEFAULT_PERMISSION_SAVED_MESSAGES).into()
+            } else {
+                0_u64.into()
+            }
+        }
         Channel::DirectMessage { recipients, .. } => {
             // 2. Fetch user.
             let other_user = recipients

crates/quark/src/tasks/last_message_id.rs

@@ -2,7 +2,6 @@
 use crate::{models::channel::PartialChannel, Database};
 
 use deadqueue::limited::Queue;
-use log::info;
 use mongodb::bson::doc;
 use std::{collections::HashMap, time::Duration};
 

crates/quark/src/tasks/mod.rs

@@ -18,7 +18,7 @@ pub async fn start_workers(db: Database) {
         task::spawn(ack::worker(db.clone()));
         task::spawn(last_message_id::worker(db.clone()));
         task::spawn(process_embeds::worker(db.clone()));
-        task::spawn(web_push::worker(db.clone()));
+        task::spawn(web_push::worker(db.clone().into()));
     }
 }
 

crates/quark/src/tasks/process_embeds.rs

@@ -6,7 +6,6 @@ use crate::{
 };
 
 use deadqueue::limited::Queue;
-use log::error;
 
 /// Task information
 #[derive(Debug)]

crates/quark/src/tasks/web_push.rs

@@ -1,9 +1,8 @@
+use crate::bson::doc;
 use crate::util::variables::delta::VAPID_PRIVATE_KEY;
-use crate::{bson::doc, r#impl::mongo::MongoDb, Database};
 
 use deadqueue::limited::Queue;
-use futures::StreamExt;
-use rauth::entities::Session;
+use rauth::Database;
 use web_push::{
     ContentEncoding, SubscriptionInfo, SubscriptionKeys, VapidSignatureBuilder, WebPushClient,
     WebPushMessageBuilder,
@@ -43,90 +42,69 @@ pub async fn worker(db: Database) {
     let key = base64::decode_config(VAPID_PRIVATE_KEY.clone(), base64::URL_SAFE)
         .expect("valid `VAPID_PRIVATE_KEY`");
 
-    if let Database::MongoDb(MongoDb(db)) = db {
-        loop {
-            let task = Q.pop().await;
+    loop {
+        let task = Q.pop().await;
 
-            // ! FIXME: this is hard-coded until rauth is merged into quark
-            if let Ok(mut cursor) = db
-                .database("revolt")
-                .collection::<Session>("sessions")
-                .find(
-                    doc! {
-                        "user_id": {
-                            "$in": task.recipients
+        if let Ok(sessions) = db.find_sessions_with_subscription(&task.recipients).await {
+            for session in sessions {
+                if let Some(sub) = session.subscription {
+                    let subscription = SubscriptionInfo {
+                        endpoint: sub.endpoint,
+                        keys: SubscriptionKeys {
+                            auth: sub.auth,
+                            p256dh: sub.p256dh,
                         },
-                        "subscription": {
-                            "$exists": true
-                        }
-                    },
-                    None,
-                )
-                .await
-            {
-                while let Some(Ok(session)) = cursor.next().await {
-                    if let Some(sub) = session.subscription {
-                        let subscription = SubscriptionInfo {
-                            endpoint: sub.endpoint,
-                            keys: SubscriptionKeys {
-                                auth: sub.auth,
-                                p256dh: sub.p256dh,
-                            },
-                        };
+                    };
 
-                        match WebPushMessageBuilder::new(&subscription) {
-                            Ok(mut builder) => {
-                                match VapidSignatureBuilder::from_pem(
-                                    std::io::Cursor::new(&key),
-                                    &subscription,
-                                ) {
-                                    Ok(sig_builder) => match sig_builder.build() {
-                                        Ok(signature) => {
-                                            builder.set_vapid_signature(signature);
-                                            builder.set_payload(
-                                                ContentEncoding::AesGcm,
-                                                task.payload.as_bytes(),
-                                            );
+                    match WebPushMessageBuilder::new(&subscription) {
+                        Ok(mut builder) => {
+                            match VapidSignatureBuilder::from_pem(
+                                std::io::Cursor::new(&key),
+                                &subscription,
+                            ) {
+                                Ok(sig_builder) => match sig_builder.build() {
+                                    Ok(signature) => {
+                                        builder.set_vapid_signature(signature);
+                                        builder.set_payload(
+                                            ContentEncoding::AesGcm,
+                                            task.payload.as_bytes(),
+                                        );
 
-                                            match builder.build() {
-                                                Ok(msg) => match client.send(msg).await {
-                                                    Ok(_) => {
-                                                        info!(
-                                                            "Sent Web Push notification to {:?}.",
-                                                            session.id
-                                                        )
-                                                    }
-                                                    Err(err) => {
-                                                        error!(
-                                                            "Hit error sending Web Push! {:?}",
-                                                            err
-                                                        )
-                                                    }
-                                                },
-                                                Err(err) => {
-                                                    error!(
-                                                        "Failed to build message for {}! {:?}",
-                                                        session.user_id, err
+                                        match builder.build() {
+                                            Ok(msg) => match client.send(msg).await {
+                                                Ok(_) => {
+                                                    info!(
+                                                        "Sent Web Push notification to {:?}.",
+                                                        session.id
                                                     )
                                                 }
+                                                Err(err) => {
+                                                    error!("Hit error sending Web Push! {:?}", err)
+                                                }
+                                            },
+                                            Err(err) => {
+                                                error!(
+                                                    "Failed to build message for {}! {:?}",
+                                                    session.user_id, err
+                                                )
                                             }
                                         }
-                                        Err(err) => error!(
-                                            "Failed to build signature for {}! {:?}",
-                                            session.user_id, err
-                                        ),
-                                    },
+                                    }
                                     Err(err) => error!(
-                                        "Failed to create signature builder for {}! {:?}",
+                                        "Failed to build signature for {}! {:?}",
                                         session.user_id, err
                                     ),
-                                }
+                                },
+                                Err(err) => error!(
+                                    "Failed to create signature builder for {}! {:?}",
+                                    session.user_id, err
+                                ),
                             }
-                            Err(err) => error!(
-                                "Invalid subscription information for {}! {:?}",
-                                session.user_id, err
-                            ),
                         }
+                        Err(err) => error!(
+                            "Invalid subscription information for {}! {:?}",
+                            session.user_id, err
+                        ),
                     }
                 }
             }

crates/quark/src/traits/media/attachment.rs

@@ -3,6 +3,7 @@ use crate::Result;
 
 #[async_trait]
 pub trait AbstractAttachment: Sync + Send {
+    /// Find an attachment by its details and mark it as used by a given parent.
     async fn find_and_use_attachment(
         &self,
         id: &str,
@@ -10,7 +11,16 @@ pub trait AbstractAttachment: Sync + Send {
         parent_type: &str,
         parent_id: &str,
     ) -> Result<File>;
+
+    /// Insert attachment into database.
     async fn insert_attachment(&self, attachment: &File) -> Result<()>;
+
+    /// Mark an attachment as having been reported.
     async fn mark_attachment_as_reported(&self, id: &str) -> Result<()>;
+
+    /// Mark an attachment as having been deleted.
     async fn mark_attachment_as_deleted(&self, id: &str) -> Result<()>;
+
+    /// Mark multiple attachments as having been deleted.
+    async fn mark_attachments_as_deleted(&self, ids: &[String]) -> Result<()>;
 }

crates/quark/src/traits/media/emoji.rs

@@ -0,0 +1,20 @@
+use crate::models::Emoji;
+use crate::Result;
+
+#[async_trait]
+pub trait AbstractEmoji: Sync + Send {
+    /// Fetch an emoji by its id
+    async fn fetch_emoji(&self, id: &str) -> Result<Emoji>;
+
+    /// Fetch emoji by their parent id
+    async fn fetch_emoji_by_parent_id(&self, parent_id: &str) -> Result<Vec<Emoji>>;
+
+    /// Fetch emoji by their parent ids
+    async fn fetch_emoji_by_parent_ids(&self, parent_ids: &[String]) -> Result<Vec<Emoji>>;
+
+    /// Insert emoji into database.
+    async fn insert_emoji(&self, emoji: &Emoji) -> Result<()>;
+
+    /// Delete an emoji by its id
+    async fn delete_emoji(&self, emoji: &Emoji) -> Result<()>;
+}

crates/quark/src/traits/mod.rs

@@ -2,8 +2,9 @@ mod admin {
     pub mod migrations;
 }
 
-mod autumn {
+mod media {
     pub mod attachment;
+    pub mod emoji;
 }
 
 mod channels {
@@ -27,7 +28,8 @@ mod users {
 
 pub use admin::migrations::AbstractMigrations;
 
-pub use autumn::attachment::AbstractAttachment;
+pub use media::attachment::AbstractAttachment;
+pub use media::emoji::AbstractEmoji;
 
 pub use channels::channel::AbstractChannel;
 pub use channels::channel_invite::AbstractChannelInvite;
@@ -42,14 +44,12 @@ pub use users::bot::AbstractBot;
 pub use users::user::AbstractUser;
 pub use users::user_settings::AbstractUserSettings;
 
-// pub trait AbstractEventEmitter {}
-// + AbstractEventEmitter
-
 pub trait AbstractDatabase:
     Sync
     + Send
     + AbstractMigrations
     + AbstractAttachment
+    + AbstractEmoji
     + AbstractChannel
     + AbstractChannelInvite
     + AbstractChannelUnread

crates/quark/src/types/january.rs

@@ -202,12 +202,22 @@ impl Embed {
         let mut finder = LinkFinder::new();
         finder.kinds(&[LinkKind::Url]);
 
-        let links: HashSet<String> = finder
+        // Process all links, stripping anchors and
+        // only taking up to `max_embeds` of links.
+        let links: Vec<String> = finder
             .links(&content)
+            .map(|x| {
+                x.as_str()
+                    .chars()
+                    .take_while(|&ch| ch != '#')
+                    .collect::<String>()
+            })
+            .collect::<HashSet<String>>()
+            .into_iter()
             .take(max_embeds)
-            .map(|x| x.as_str().to_string())
             .collect();
 
+        // If no links, fail out.
         if links.is_empty() {
             return Err(Error::LabelMe);
         }

crates/quark/src/util/log.rs

@@ -0,0 +1,34 @@
+/// Configure logging and common Rust variables
+pub fn setup_logging(release: &'static str) -> sentry::ClientInitGuard {
+    dotenv::dotenv().ok();
+
+    if std::env::var("RUST_LOG").is_err() {
+        std::env::set_var("RUST_LOG", "info");
+    }
+
+    if std::env::var("ROCKET_ADDRESS").is_err() {
+        std::env::set_var("ROCKET_ADDRESS", "0.0.0.0");
+    }
+
+    pretty_env_logger::init();
+    info!("Starting {release}");
+
+    sentry::init((
+        "https://62fd0e02c5354905b4e286757f4beb16@sentry.insert.moe/4",
+        sentry::ClientOptions {
+            release: Some(release.into()),
+            ..Default::default()
+        },
+    ))
+}
+
+#[macro_export]
+macro_rules! configure {
+    () => {
+        let _sentry = revolt_quark::util::log::setup_logging(concat!(
+            env!("CARGO_PKG_NAME"),
+            "@",
+            env!("CARGO_PKG_VERSION")
+        ));
+    };
+}

crates/quark/src/util/mod.rs

@@ -1,4 +1,7 @@
+pub mod log;
 pub mod manipulation;
+pub mod pfp;
+pub mod rauth;
 pub mod r#ref;
 pub mod result;
 pub mod value;

crates/quark/src/util/pfp.rs

@@ -0,0 +1,13 @@
+pub fn avatar(v: char) -> Vec<u8> {
+    match v {
+        // 0123456789ABCDEFGHJKMNPQRSTVWXYZ
+        '0' | '1' | '2' | '3' | 'S' | 'Z' => include_bytes!(crate::asset!("user/2.png")).to_vec(),
+        '4' | '5' | '6' | '7' | 'T' => include_bytes!(crate::asset!("user/3.png")).to_vec(),
+        '8' | '9' | 'A' | 'B' => include_bytes!(crate::asset!("user/4.png")).to_vec(),
+        'C' | 'D' | 'E' | 'F' | 'V' => include_bytes!(crate::asset!("user/5.png")).to_vec(),
+        'G' | 'H' | 'J' | 'K' | 'W' => include_bytes!(crate::asset!("user/6.png")).to_vec(),
+        'M' | 'N' | 'P' | 'Q' | 'X' => include_bytes!(crate::asset!("user/7.png")).to_vec(),
+        /*'0' | '1' | '2' | '3' | 'R' | 'Y'*/
+        _ => include_bytes!(crate::asset!("user/1.png")).to_vec(),
+    }
+}

crates/quark/src/util/rauth.rs

@@ -0,0 +1,63 @@
+use super::variables::delta::{
+    APP_URL, HCAPTCHA_KEY, INVITE_ONLY, SMTP_FROM, SMTP_HOST, SMTP_PASSWORD, SMTP_USERNAME,
+    USE_EMAIL, USE_HCAPTCHA,
+};
+
+use crate::rauth::config::{
+    Captcha, Config, EmailVerificationConfig, SMTPSettings, Template, Templates,
+};
+
+pub fn config() -> Config {
+    let mut config = Config {
+        email_verification: if *USE_EMAIL {
+            EmailVerificationConfig::Enabled {
+                smtp: SMTPSettings {
+                    from: (*SMTP_FROM).to_string(),
+                    host: (*SMTP_HOST).to_string(),
+                    username: (*SMTP_USERNAME).to_string(),
+                    password: (*SMTP_PASSWORD).to_string(),
+                    reply_to: Some("support@revolt.chat".into()),
+                    port: None,
+                    use_tls: None,
+                },
+                expiry: Default::default(),
+                templates: Templates {
+                    verify: Template {
+                        title: "Verify your Revolt account.".into(),
+                        text: include_str!(crate::asset!("templates/verify.txt")).into(),
+                        url: format!("{}/login/verify/", *APP_URL),
+                        html: None,
+                    },
+                    reset: Template {
+                        title: "Reset your Revolt password.".into(),
+                        text: include_str!(crate::asset!("templates/reset.txt")).into(),
+                        url: format!("{}/login/reset/", *APP_URL),
+                        html: None,
+                    },
+                    deletion: Template {
+                        title: "Confirm account deletion.".into(),
+                        text: include_str!(crate::asset!("templates/deletion.txt")).into(),
+                        url: format!("{}/delete/", *APP_URL),
+                        html: None,
+                    },
+                    welcome: None,
+                },
+            }
+        } else {
+            EmailVerificationConfig::Disabled
+        },
+        ..Default::default()
+    };
+
+    if *INVITE_ONLY {
+        config.invite_only = true;
+    }
+
+    if *USE_HCAPTCHA {
+        config.captcha = Captcha::HCaptcha {
+            secret: HCAPTCHA_KEY.clone(),
+        };
+    }
+
+    config
+}

crates/quark/src/util/ref.rs

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

crates/quark/src/util/result.rs

@@ -24,6 +24,7 @@ pub enum Error {
 
     // ? User related errors.
     UsernameTaken,
+    InvalidUsername,
     UnknownUser,
     AlreadyFriends,
     AlreadySentRequest,
@@ -40,6 +41,7 @@ pub enum Error {
     TooManyAttachments,
     TooManyReplies,
     EmptyMessage,
+    PayloadTooLarge,
     CannotRemoveYourself,
     GroupTooLarge {
         max: usize,
@@ -54,6 +56,7 @@ pub enum Error {
     TooManyServers {
         max: usize,
     },
+    TooManyEmoji,
 
     // ? Bot related errors.
     ReachedMaximumBots,
@@ -128,6 +131,7 @@ impl<'r> Responder<'r, 'static> for Error {
             Error::AlreadyOnboarded => Status::Forbidden,
 
             Error::UnknownUser => Status::NotFound,
+            Error::InvalidUsername => Status::BadRequest,
             Error::UsernameTaken => Status::Conflict,
             Error::AlreadyFriends => Status::Conflict,
             Error::AlreadySentRequest => Status::Conflict,
@@ -143,6 +147,7 @@ impl<'r> Responder<'r, 'static> for Error {
             Error::TooManyAttachments => Status::BadRequest,
             Error::TooManyReplies => Status::BadRequest,
             Error::EmptyMessage => Status::UnprocessableEntity,
+            Error::PayloadTooLarge => Status::UnprocessableEntity,
             Error::CannotRemoveYourself => Status::BadRequest,
             Error::GroupTooLarge { .. } => Status::Forbidden,
             Error::AlreadyInGroup => Status::Conflict,
@@ -152,6 +157,7 @@ impl<'r> Responder<'r, 'static> for Error {
             Error::InvalidRole => Status::NotFound,
             Error::Banned => Status::Forbidden,
             Error::TooManyServers { .. } => Status::Forbidden,
+            Error::TooManyEmoji => Status::BadRequest,
 
             Error::ReachedMaximumBots => Status::BadRequest,
             Error::IsBot => Status::BadRequest,

crates/quark/src/util/variables/delta.rs

@@ -1,8 +1,5 @@
 use std::env;
 
-#[cfg(debug_assertions)]
-use log::warn;
-
 lazy_static! {
     // Application Settings
     pub static ref PUBLIC_URL: String =

crates/quark/src/web/cors.rs

@@ -0,0 +1,19 @@
+use std::str::FromStr;
+
+pub use rocket_cors::catch_all_options_routes;
+use rocket_cors::{AllowedOrigins, Cors};
+
+pub fn new() -> Cors {
+    rocket_cors::CorsOptions {
+        allowed_origins: AllowedOrigins::All,
+        allowed_methods: [
+            "Get", "Put", "Post", "Delete", "Options", "Head", "Trace", "Connect", "Patch",
+        ]
+        .iter()
+        .map(|s| FromStr::from_str(s).unwrap())
+        .collect(),
+        ..Default::default()
+    }
+    .to_cors()
+    .expect("Failed to create CORS.")
+}

crates/quark/src/web/idempotency.rs

@@ -1,6 +1,6 @@
+use crate::{Error, Result};
+
 use async_std::sync::Mutex;
-use mongodb::bson::doc;
-use revolt_quark::{Error, Result};
 use rocket::http::Status;
 use rocket::request::{FromRequest, Outcome};
 use rocket_okapi::gen::OpenApiGenerator;

crates/quark/src/web/mod.rs

@@ -0,0 +1,10 @@
+use crate::Database;
+use rocket::State;
+
+pub mod cors;
+pub mod idempotency;
+pub mod ratelimiter;
+pub mod swagger;
+
+pub use rocket_empty::EmptyResponse;
+pub type Db = State<Database>;

crates/quark/src/web/ratelimiter.rs

@@ -8,6 +8,7 @@ use std::hash::Hasher;
 use std::ops::Add;
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
+use crate::rauth::models::Session;
 use rocket::fairing::{Fairing, Info, Kind};
 use rocket::http::uri::Origin;
 use rocket::http::{Method, Status};
@@ -22,8 +23,6 @@ use serde::Serialize;
 
 use dashmap::DashMap;
 
-use log::info;
-
 /// Ratelimit Bucket
 #[derive(Clone, Copy)]
 struct Entry {
@@ -101,7 +100,13 @@ fn resolve_bucket<'r>(request: &'r rocket::Request<'_>) -> (&'r str, Option<&'r
     if let Some(segment) = request.routed_segment(0) {
         let resource = request.routed_segment(1);
         match (segment, resource) {
-            ("users", _) => ("users", None),
+            ("users", _) => {
+                if let Some("default_avatar") = request.routed_segment(2) {
+                    return ("default_avatar", None);
+                }
+
+                ("users", None)
+            }
             ("bots", _) => ("bots", None),
             ("channels", Some(id)) => {
                 if request.method() == Method::Post {
@@ -138,6 +143,7 @@ fn resolve_bucket_limit(bucket: &str) -> u8 {
         "servers" => 5,
         "auth" => 15,
         "auth_delete" => 255,
+        "default_avatar" => 255,
         "swagger" => 100,
         _ => 20,
     }
@@ -207,10 +213,9 @@ impl<'r> FromRequest<'r> for Ratelimiter {
         let ratelimiter = request
             .local_cache_async(async {
                 use rocket::outcome::Outcome;
-                let identifier = if let Outcome::Success(session) =
-                    request.guard::<rauth::entities::Session>().await
+                let identifier = if let Outcome::Success(session) = request.guard::<Session>().await
                 {
-                    session.id.expect("`id` on User")
+                    session.id
                 } else {
                     to_real_ip(request)
                 };
@@ -304,11 +309,11 @@ impl<'r> FromRequest<'r> for RatelimitInformation {
     }
 }
 
-#[get("/ratelimit")]
+#[rocket::get("/ratelimit")]
 fn ratelimit_info(info: RatelimitInformation) -> Json<RatelimitInformation> {
     Json(info)
 }
 
 pub fn routes() -> Vec<rocket::Route> {
-    routes![ratelimit_info]
+    rocket::routes![ratelimit_info]
 }

crates/quark/src/web/swagger.rs

@@ -0,0 +1,9 @@
+use rocket::Route;
+
+pub fn routes() -> Vec<Route> {
+    rocket_okapi::swagger_ui::make_swagger_ui(&rocket_okapi::swagger_ui::SwaggerUIConfig {
+        url: "../openapi.json".to_owned(),
+        ..Default::default()
+    })
+    .into()
+}

docker-compose.yml

@@ -0,0 +1,73 @@
+version: "3.3"
+services:
+  # Redis
+  redis:
+    image: eqalpha/keydb
+    ports:
+      - "6379:6379"
+
+  # MongoDB
+  database:
+    image: mongo
+    ports:
+      - "27017:27017"
+    volumes:
+      - ./.data/db:/data/db
+
+  # MinIO
+  minio:
+    image: minio/minio
+    command: server /data
+    env_file: .env
+    volumes:
+      - ./.data/minio:/data
+    ports:
+      - "10000:9000"
+    restart: always
+
+  # Mongo Express
+  mongo-express:
+    image: mongo-express
+    ports:
+      - "8081:8081"
+    environment:
+      - ME_CONFIG_MONGODB_SERVER=database
+    depends_on:
+      - database
+
+  # Create buckets for minio.
+  createbuckets:
+    image: minio/mc
+    depends_on:
+      - minio
+    env_file: .env
+    entrypoint: >
+      /bin/sh -c "
+      while ! curl -s --output /dev/null --connect-timeout 1 http://minio:9000; do echo 'Waiting minio...' && sleep 0.1; done;
+      /usr/bin/mc alias set minio http://minio:9000 $MINIO_ROOT_USER $MINIO_ROOT_PASSWORD;
+      /usr/bin/mc mb minio/attachments;
+      /usr/bin/mc mb minio/avatars;
+      /usr/bin/mc mb minio/backgrounds;
+      /usr/bin/mc mb minio/icons;
+      /usr/bin/mc mb minio/banners;
+      exit 0;
+      "
+  # File server (autumn)
+  autumn:
+    image: ghcr.io/revoltchat/autumn:1.1.5
+    env_file: .env
+    depends_on:
+      - database
+      - createbuckets
+    environment:
+      - AUTUMN_MONGO_URI=mongodb://database
+    ports:
+      - "3000:3000"
+    restart: always
+
+  # Metadata and image proxy (january)
+  january:
+    image: ghcr.io/revoltchat/january:0.3.4
+    ports:
+      - "7000:7000"
+    restart: always