feat(delta): rewrite emoji routes w/o quark

#283

.gitignore

@@ -1,4 +1,6 @@
 Rocket.toml
+Revolt.toml
+
 target
 .data
 .env

Cargo.lock

@@ -3591,6 +3591,7 @@ dependencies = [
  "redis-kiss",
  "regex",
  "reqwest",
+ "revolt-config",
  "revolt-database",
  "revolt-models",
  "revolt-permissions",

crates/core/config/src/lib.rs

@@ -13,8 +13,8 @@ static CONFIG_BUILDER: Lazy<RwLock<Config>> = Lazy::new(|| {
             FileFormat::Toml,
         ));
 
-        if std::path::Path::new("revolt.toml").exists() {
-            builder = builder.add_source(File::new("revolt.toml", FileFormat::Toml));
+        if std::path::Path::new("Revolt.toml").exists() {
+            builder = builder.add_source(File::new("Revolt.toml", FileFormat::Toml));
         }
 
         builder.build().unwrap()

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

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use revolt_models::v0::MessageAuthor;
+use revolt_models::v0::{self, MessageAuthor};
 use revolt_permissions::OverrideField;
 use revolt_result::Result;
 use serde::{Deserialize, Serialize};
@@ -168,7 +168,7 @@ auto_derived!(
 
 #[allow(clippy::disallowed_methods)]
 impl Channel {
-    /// Create a channel
+    /* /// Create a channel
     pub async fn create(&self, db: &Database) -> Result<()> {
         db.insert_channel(self).await?;
 
@@ -186,6 +186,39 @@ impl Channel {
         }
 
         Ok(())
+    }*/
+
+    /// Create a group
+    pub async fn create_group(
+        db: &Database,
+        data: v0::DataCreateGroup,
+        owner_id: String,
+    ) -> Result<Channel> {
+        let recipients = data.users.into_iter().collect::<Vec<String>>();
+        let channel = Channel::Group {
+            id: ulid::Ulid::new().to_string(),
+
+            name: data.name,
+            owner: owner_id,
+            description: data.description,
+            recipients: recipients.clone(),
+
+            icon: None,
+            last_message_id: None,
+
+            permissions: None,
+
+            nsfw: data.nsfw.unwrap_or(false),
+        };
+
+        db.insert_channel(&channel).await?;
+
+        let event = EventV1::ChannelCreate(channel.clone().into());
+        for recipient in recipients {
+            event.clone().private(recipient).await;
+        }
+
+        Ok(channel)
     }
 
     /// Add user to a group

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

@@ -6,7 +6,7 @@ use crate::MongoDb;
 
 use super::AbstractAttachments;
 
-static COL: &str = "bots";
+static COL: &str = "attachments";
 
 #[async_trait]
 impl AbstractAttachments for MongoDb {

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

@@ -182,6 +182,21 @@ impl User {
         Ok(user)
     }
 
+    /// Get the relationship with another user
+    pub fn relationship_with(&self, user_b: &str) -> RelationshipStatus {
+        if self.id == user_b {
+            return RelationshipStatus::User;
+        }
+
+        if let Some(relations) = &self.relations {
+            if let Some(relationship) = relations.iter().find(|x| x.id == user_b) {
+                return relationship.status.clone();
+            }
+        }
+
+        RelationshipStatus::None
+    }
+
     /// Check whether two users have a mutual connection
     ///
     /// This will check if user and user_b share a server or a group.

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

@@ -275,6 +275,15 @@ impl From<crate::EmojiParent> for EmojiParent {
     }
 }
 
+impl From<EmojiParent> for crate::EmojiParent {
+    fn from(value: EmojiParent) -> Self {
+        match value {
+            EmojiParent::Detached => crate::EmojiParent::Detached,
+            EmojiParent::Server { id } => crate::EmojiParent::Server { id },
+        }
+    }
+}
+
 impl From<crate::File> for File {
     fn from(value: crate::File) -> Self {
         File {

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

@@ -7,7 +7,7 @@ use schemars::{
     JsonSchema,
 };
 
-use crate::{Bot, Channel, Database, Webhook};
+use crate::{Bot, Channel, Database, Emoji, Message, Webhook};
 
 /// Reference to some object in the database
 #[derive(Serialize, Deserialize)]
@@ -27,11 +27,21 @@ impl Reference {
         db.fetch_bot(&self.id).await
     }
 
+    /// Fetch emoji from Ref
+    pub async fn as_emoji(&self, db: &Database) -> Result<Emoji> {
+        db.fetch_emoji(&self.id).await
+    }
+
     /// Fetch channel from Ref
     pub async fn as_channel(&self, db: &Database) -> Result<Channel> {
         db.fetch_channel(&self.id).await
     }
 
+    /// Fetch message from Ref
+    pub async fn as_message(&self, db: &Database) -> Result<Message> {
+        db.fetch_message(&self.id).await
+    }
+
     /// Fetch webhook from Ref
     pub async fn as_webhook(&self, db: &Database) -> Result<Webhook> {
         db.fetch_webhook(&self.id).await

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

@@ -1,10 +1,11 @@
 use super::File;
 
 use revolt_permissions::OverrideField;
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 
 auto_derived!(
     /// Channel
+    #[serde(tag = "channel_type")]
     pub enum Channel {
         /// Personal "Saved Notes" channel which allows users to save messages
         SavedMessages {
@@ -205,4 +206,28 @@ auto_derived!(
         #[cfg_attr(feature = "serde", serde(default))]
         pub remove: Option<Vec<FieldsChannel>>,
     }
+
+    /// Create new group
+    #[derive(Default)]
+    #[cfg_attr(feature = "validator", derive(validator::Validate))]
+    pub struct DataCreateGroup {
+        /// Group name
+        #[validate(length(min = 1, max = 32))]
+        pub name: String,
+        /// Group description
+        #[validate(length(min = 0, max = 1024))]
+        pub description: Option<String>,
+        /// Group icon
+        #[validate(length(min = 1, max = 128))]
+        pub icon: Option<String>,
+        /// Array of user IDs to add to the group
+        ///
+        /// Must be friends with these users.
+        #[validate(length(min = 0, max = 49))]
+        #[serde(default)]
+        pub users: HashSet<String>,
+        /// Whether this group is age-restricted
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub nsfw: Option<bool>,
+    }
 );

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

@@ -1,3 +1,12 @@
+use once_cell::sync::Lazy;
+use regex::Regex;
+use validator::Validate;
+
+/// Regex for valid emoji names
+///
+/// Alphanumeric and underscores
+pub static RE_EMOJI: Lazy<Regex> = Lazy::new(|| Regex::new(r"^[a-z0-9_]+$").unwrap());
+
 auto_derived!(
     /// Emoji
     pub struct Emoji {
@@ -30,4 +39,17 @@ auto_derived!(
         Server { id: String },
         Detached,
     }
+
+    /// Create a new emoji
+    #[derive(Validate)]
+    pub struct DataCreateEmoji {
+        /// Server name
+        #[validate(length(min = 1, max = 32), regex = "RE_EMOJI")]
+        pub name: String,
+        /// Parent information
+        pub parent: EmojiParent,
+        /// Whether the emoji is mature
+        #[serde(default)]
+        pub nsfw: bool,
+    }
 );

crates/delta/Cargo.toml

@@ -68,6 +68,7 @@ revolt_rocket_okapi = { version = "0.9.1", features = ["swagger"] }
 revolt-quark = { path = "../quark" }
 
 # core
+revolt-config = { path = "../core/config" }
 revolt-database = { path = "../core/database", features = [
     "rocket-impl",
     "redis-is-patched",

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

@@ -78,20 +78,16 @@ mod test {
             .await
             .expect("`Bot`");
 
-        // FIXME: Channel::create_group
-        let group = Channel::Group {
-            id: ulid::Ulid::new().to_string(),
-            name: TestHarness::rand_string(),
-            owner: user.id.to_string(),
-            description: None,
-            last_message_id: None,
-            icon: None,
-            nsfw: false,
-            permissions: None,
-            recipients: vec![user.id.to_string()],
-        };
-
-        group.create(&harness.db).await.unwrap();
+        let group = Channel::create_group(
+            &harness.db,
+            v0::DataCreateGroup {
+                name: TestHarness::rand_string(),
+                ..Default::default()
+            },
+            user.id.to_string(),
+        )
+        .await
+        .unwrap();
 
         let response = harness
             .client

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

@@ -1,8 +1,11 @@
-use revolt_quark::{
-    models::{Channel, User},
-    perms, Database, Permission, Ref, Result,
+use revolt_database::{
+    util::{permissions::DatabasePermissionQuery, reference::Reference},
+    Database, User,
 };
 
+use revolt_models::v0;
+use revolt_permissions::{calculate_channel_permissions, ChannelPermission};
+use revolt_result::Result;
 use rocket::{serde::json::Json, State};
 
 /// # Fetch Channel
@@ -10,12 +13,54 @@ use rocket::{serde::json::Json, State};
 /// Fetch channel by its id.
 #[openapi(tag = "Channel Information")]
 #[get("/<target>")]
-pub async fn req(db: &State<Database>, user: User, target: Ref) -> Result<Json<Channel>> {
+pub async fn fetch_channel(
+    db: &State<Database>,
+    user: User,
+    target: Reference,
+) -> Result<Json<v0::Channel>> {
     let channel = target.as_channel(db).await?;
-    perms(&user)
-        .channel(&channel)
-        .throw_permission(db, Permission::ViewChannel)
-        .await?;
 
-    Ok(Json(channel))
+    let mut query = DatabasePermissionQuery::new(db, &user).channel(&channel);
+    calculate_channel_permissions(&mut query)
+        .await
+        .throw_if_lacking_channel_permission(ChannelPermission::ViewChannel)?;
+
+    Ok(Json(channel.into()))
+}
+
+#[cfg(test)]
+mod test {
+    use crate::{rocket, util::test::TestHarness};
+    use revolt_database::Channel;
+    use revolt_models::v0;
+    use rocket::http::{Header, Status};
+
+    #[rocket::async_test]
+    async fn fetch_channel() {
+        let harness = TestHarness::new().await;
+        let (_, session, user) = harness.new_user().await;
+
+        let group = Channel::create_group(
+            &harness.db,
+            v0::DataCreateGroup {
+                name: TestHarness::rand_string(),
+                ..Default::default()
+            },
+            user.id.to_string(),
+        )
+        .await
+        .unwrap();
+
+        let response = harness
+            .client
+            .get(format!("/channels/{}", group.id()))
+            .header(Header::new("x-session-token", session.token.to_string()))
+            .dispatch()
+            .await;
+
+        assert_eq!(response.status(), Status::Ok);
+
+        let channel: v0::Channel = response.into_json().await.expect("`Channel`");
+        assert_eq!(channel, group.into());
+    }
 }

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

@@ -1,84 +1,96 @@
-use std::{collections::HashSet, iter::FromIterator};
-
-use revolt_quark::{
-    get_relationship,
-    models::{user::RelationshipStatus, Channel, User},
-    variables::delta::MAX_GROUP_SIZE,
-    Db, Error, Result,
-};
+use revolt_config::config;
+use revolt_database::{Channel, Database, RelationshipStatus, User};
+use revolt_models::v0;
+use revolt_result::{create_error, Result};
 
 use rocket::serde::json::Json;
-use serde::{Deserialize, Serialize};
-use ulid::Ulid;
+use rocket::State;
 use validator::Validate;
 
-/// # Group Data
-#[derive(Validate, Serialize, Deserialize, JsonSchema)]
-pub struct DataCreateGroup {
-    /// Group name
-    #[validate(length(min = 1, max = 32))]
-    name: String,
-    /// Group description
-    #[validate(length(min = 0, max = 1024))]
-    description: Option<String>,
-    /// Array of user IDs to add to the group
-    ///
-    /// Must be friends with these users.
-    #[validate(length(min = 0, max = 49))]
-    users: Vec<String>,
-    /// Whether this group is age-restricted
-    #[serde(skip_serializing_if = "Option::is_none")]
-    nsfw: Option<bool>,
-}
-
 /// # Create Group
 ///
 /// Create a new group channel.
 #[openapi(tag = "Groups")]
-#[post("/create", data = "<info>")]
-pub async fn req(db: &Db, user: User, info: Json<DataCreateGroup>) -> Result<Json<Channel>> {
+#[post("/create", data = "<data>")]
+pub async fn create_group(
+    db: &State<Database>,
+    user: User,
+    data: Json<v0::DataCreateGroup>,
+) -> Result<Json<v0::Channel>> {
+    let config = config().await;
     if user.bot.is_some() {
-        return Err(Error::IsBot);
+        return Err(create_error!(IsBot));
     }
 
-    let info = info.into_inner();
-    info.validate()
-        .map_err(|error| Error::FailedValidation { error })?;
+    let mut data = data.into_inner();
+    data.validate().map_err(|error| {
+        create_error!(FailedValidation {
+            error: error.to_string()
+        })
+    })?;
 
-    let mut set: HashSet<String> = HashSet::from_iter(info.users.into_iter());
-    set.insert(user.id.clone());
+    data.users.insert(user.id.to_string());
 
-    if set.len() > *MAX_GROUP_SIZE {
-        return Err(Error::GroupTooLarge {
-            max: *MAX_GROUP_SIZE,
-        });
+    if data.users.len() > config.features.limits.default.group_size {
+        return Err(create_error!(GroupTooLarge {
+            max: config.features.limits.default.group_size,
+        }));
     }
 
-    for target in &set {
-        match get_relationship(&user, target) {
+    for target in &data.users {
+        match user.relationship_with(target) {
             RelationshipStatus::Friend | RelationshipStatus::User => {}
             _ => {
-                return Err(Error::NotFriends);
+                return Err(create_error!(NotFriends));
             }
         }
     }
 
-    let group = Channel::Group {
-        id: Ulid::new().to_string(),
+    Ok(Json(Channel::create_group(db, data, user.id).await?.into()))
+}
 
-        name: info.name,
-        owner: user.id,
-        description: info.description,
-        recipients: set.into_iter().collect::<Vec<String>>(),
+#[cfg(test)]
+mod test {
+    use crate::{rocket, util::test::TestHarness};
+    use revolt_models::v0;
+    use rocket::http::{ContentType, Header, Status};
 
-        icon: None,
-        last_message_id: None,
+    #[rocket::async_test]
+    async fn create_group() {
+        let harness = TestHarness::new().await;
+        let (_, session, user) = harness.new_user().await;
 
-        permissions: None,
+        let response = harness
+            .client
+            .post("/channels/create")
+            .header(Header::new("x-session-token", session.token.to_string()))
+            .header(ContentType::JSON)
+            .body(
+                json!(v0::DataCreateBot {
+                    name: TestHarness::rand_string(),
+                })
+                .to_string(),
+            )
+            .dispatch()
+            .await;
 
-        nsfw: info.nsfw.unwrap_or(false),
-    };
+        assert_eq!(response.status(), Status::Ok);
 
-    group.create(db).await?;
-    Ok(Json(group))
+        let channel: v0::Channel = response.into_json().await.expect("`Channel`");
+        match channel {
+            v0::Channel::Group {
+                id,
+                owner,
+                recipients,
+                ..
+            } => {
+                assert_eq!(owner, user.id);
+                assert_eq!(recipients.len(), 1);
+                assert!(harness.db.fetch_channel(&id).await.is_ok());
+
+                // TODO: does not check for events
+            }
+            _ => unreachable!(),
+        }
+    }
 }

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

@@ -1,26 +1,34 @@
-use revolt_quark::{
-    models::{Message, User},
-    perms, Db, Error, Permission, Ref, Result,
+use revolt_database::{
+    util::{permissions::DatabasePermissionQuery, reference::Reference},
+    Database, User,
 };
-
-use rocket::serde::json::Json;
+use revolt_models::v0;
+use revolt_permissions::{calculate_channel_permissions, ChannelPermission};
+use revolt_result::{create_error, Result};
+use rocket::{serde::json::Json, State};
 
 /// # Fetch Message
 ///
 /// Retrieves a message by its id.
 #[openapi(tag = "Messaging")]
 #[get("/<target>/messages/<msg>")]
-pub async fn req(db: &Db, user: User, target: Ref, msg: Ref) -> Result<Json<Message>> {
+pub async fn req(
+    db: &State<Database>,
+    user: User,
+    target: Reference,
+    msg: Reference,
+) -> Result<Json<v0::Message>> {
     let channel = target.as_channel(db).await?;
-    perms(&user)
-        .channel(&channel)
-        .throw_permission(db, Permission::ViewChannel)
-        .await?;
+
+    let mut query = DatabasePermissionQuery::new(db, &user).channel(&channel);
+    calculate_channel_permissions(&mut query)
+        .await
+        .throw_if_lacking_channel_permission(ChannelPermission::ViewChannel)?;
 
     let message = msg.as_message(db).await?;
-    if message.channel != channel.as_id() {
-        return Err(Error::NotFound);
+    if message.channel != channel.id() {
+        return Err(create_error!(NotFound));
     }
 
-    Ok(Json(message))
+    Ok(Json(message.into()))
 }

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

@@ -1,26 +0,0 @@
-use revolt_quark::{models::User, Ref, Result};
-
-use rocket::serde::json::Json;
-use serde::{Deserialize, Serialize};
-use validator::Validate;
-
-/// # Query Parameters
-#[derive(Validate, Serialize, Deserialize, JsonSchema)]
-pub struct OptionsQueryStale {
-    /// Array of message IDs
-    #[validate(length(min = 0, max = 150))]
-    ids: Vec<String>,
-}
-
-/// # Poll Message Changes
-///
-/// This route returns any changed message objects and tells you if any have been deleted.
-///
-/// Don't actually poll this route, instead use this to update your local database.
-///
-/// **DEPRECATED**
-#[openapi(tag = "Messaging")]
-#[post("/<_target>/messages/stale", data = "<_data>")]
-pub async fn req(_user: User, _target: Ref, _data: Json<OptionsQueryStale>) -> Result<()> {
-    Ok(())
-}

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

@@ -16,7 +16,6 @@ mod message_delete;
 mod message_edit;
 mod message_fetch;
 mod message_query;
-mod message_query_stale;
 mod message_react;
 mod message_search;
 mod message_send;
@@ -30,7 +29,7 @@ mod webhook_fetch_all;
 pub fn routes() -> (Vec<Route>, OpenApi) {
     openapi_get_routes_spec![
         channel_ack::req,
-        channel_fetch::req,
+        channel_fetch::fetch_channel,
         members_fetch::req,
         channel_delete::req,
         channel_edit::req,
@@ -38,12 +37,11 @@ pub fn routes() -> (Vec<Route>, OpenApi) {
         message_send::message_send,
         message_query::req,
         message_search::req,
-        message_query_stale::req,
         message_fetch::req,
         message_edit::req,
         message_bulk_delete::req,
         message_delete::req,
-        group_create::req,
+        group_create::create_group,
         group_add_member::req,
         group_remove_member::req,
         voice_join::req,

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

@@ -1,31 +1,11 @@
-use once_cell::sync::Lazy;
-use regex::Regex;
-use revolt_quark::models::emoji::EmojiParent;
-use revolt_quark::models::{Emoji, File, User};
-use revolt_quark::variables::delta::MAX_EMOJI_COUNT;
-use revolt_quark::{perms, Db, Error, Permission, Result};
-use serde::Deserialize;
+use revolt_config::config;
+use revolt_database::{util::permissions::DatabasePermissionQuery, Database, Emoji, File, User};
+use revolt_models::v0;
+use revolt_permissions::{calculate_server_permissions, ChannelPermission};
+use revolt_result::{create_error, Result};
 use validator::Validate;
 
-use rocket::serde::json::Json;
-
-/// Regex for valid emoji names
-///
-/// Alphanumeric and underscores
-pub static RE_EMOJI: Lazy<Regex> = Lazy::new(|| Regex::new(r"^[a-z0-9_]+$").unwrap());
-
-/// # Emoji Data
-#[derive(Validate, Deserialize, JsonSchema)]
-pub struct DataCreateEmoji {
-    /// Server name
-    #[validate(length(min = 1, max = 32), regex = "RE_EMOJI")]
-    name: String,
-    /// Parent information
-    parent: EmojiParent,
-    /// Whether the emoji is mature
-    #[serde(default)]
-    nsfw: bool,
-}
+use rocket::{serde::json::Json, State};
 
 /// # Create New Emoji
 ///
@@ -33,41 +13,45 @@ pub struct DataCreateEmoji {
 #[openapi(tag = "Emojis")]
 #[put("/emoji/<id>", data = "<data>")]
 pub async fn create_emoji(
-    db: &Db,
+    db: &State<Database>,
     user: User,
     id: String,
-    data: Json<DataCreateEmoji>,
-) -> Result<Json<Emoji>> {
+    data: Json<v0::DataCreateEmoji>,
+) -> Result<Json<v0::Emoji>> {
+    let config = config().await;
+
     let data = data.into_inner();
-    data.validate()
-        .map_err(|error| Error::FailedValidation { error })?;
+    data.validate().map_err(|error| {
+        create_error!(FailedValidation {
+            error: error.to_string()
+        })
+    })?;
 
     // Bots cannot manage emojis
     if user.bot.is_some() {
-        return Err(Error::IsBot);
+        return Err(create_error!(IsBot));
     }
 
     // Validate we have permission to write into parent
     match &data.parent {
-        EmojiParent::Server { id } => {
+        v0::EmojiParent::Server { id } => {
             let server = db.fetch_server(id).await?;
 
             // Check for permission
-            perms(&user)
-                .server(&server)
-                .throw_permission(db, Permission::ManageCustomisation)
-                .await?;
+            let mut query = DatabasePermissionQuery::new(db, &user).server(&server);
+            calculate_server_permissions(&mut query)
+                .await
+                .throw_if_lacking_channel_permission(ChannelPermission::ManageCustomisation)?;
 
-            // Check that there are no more than 100 emoji
-            // ! FIXME: hardcoded upper limit
+            // Check that we haven't hit the emoji limit
             let emojis = db.fetch_emoji_by_parent_id(&server.id).await?;
-            if emojis.len() > *MAX_EMOJI_COUNT {
-                return Err(Error::TooManyEmoji {
-                    max: *MAX_EMOJI_COUNT,
-                });
+            if emojis.len() > config.features.limits.default.server_emoji {
+                return Err(create_error!(TooManyEmoji {
+                    max: config.features.limits.default.server_emoji,
+                }));
             }
         }
-        EmojiParent::Detached => return Err(Error::InvalidOperation),
+        v0::EmojiParent::Detached => return Err(create_error!(InvalidOperation)),
     };
 
     // Find the relevant attachment
@@ -76,7 +60,7 @@ pub async fn create_emoji(
     // Create the emoji object
     let emoji = Emoji {
         id,
-        parent: data.parent,
+        parent: data.parent.into(),
         creator_id: user.id,
         name: data.name,
         animated: "image/gif" == &attachment.content_type,
@@ -85,5 +69,5 @@ pub async fn create_emoji(
 
     // Save emoji
     emoji.create(db).await?;
-    Ok(Json(emoji))
+    Ok(Json(emoji.into()))
 }

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

@@ -1,19 +1,30 @@
-use revolt_quark::models::{emoji::EmojiParent, User};
-use revolt_quark::{perms, Db, EmptyResponse, Error, Permission, Ref, Result};
+use revolt_database::{
+    util::{permissions::DatabasePermissionQuery, reference::Reference},
+    Database, EmojiParent, User,
+};
+use revolt_permissions::{calculate_server_permissions, ChannelPermission};
+use revolt_result::{create_error, Result};
+
+use rocket::State;
+use rocket_empty::EmptyResponse;
 
 /// # 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> {
+#[delete("/emoji/<emoji_id>")]
+pub async fn delete_emoji(
+    db: &State<Database>,
+    user: User,
+    emoji_id: Reference,
+) -> Result<EmptyResponse> {
     // Bots cannot manage emoji
     if user.bot.is_some() {
-        return Err(Error::IsBot);
+        return Err(create_error!(IsBot));
     }
 
     // Fetch the emoji
-    let emoji = id.as_emoji(db).await?;
+    let emoji = emoji_id.as_emoji(db).await?;
 
     // If we uploaded the emoji, then we have permission to delete it
     if emoji.creator_id != user.id {
@@ -23,10 +34,10 @@ pub async fn delete_emoji(db: &Db, user: User, id: Ref) -> Result<EmptyResponse>
                 let server = db.fetch_server(id).await?;
 
                 // Check for permission
-                perms(&user)
-                    .server(&server)
-                    .throw_permission(db, Permission::ManageCustomisation)
-                    .await?;
+                let mut query = DatabasePermissionQuery::new(db, &user).server(&server);
+                calculate_server_permissions(&mut query)
+                    .await
+                    .throw_if_lacking_channel_permission(ChannelPermission::ManageCustomisation)?;
             }
             EmojiParent::Detached => return Ok(EmptyResponse),
         };

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

@@ -1,13 +1,18 @@
-use revolt_quark::models::{Emoji, User};
-use revolt_quark::{Db, Ref, Result};
+use revolt_database::{util::reference::Reference, Database};
+use revolt_models::v0;
+use revolt_result::Result;
 
-use rocket::serde::json::Json;
+use rocket::{serde::json::Json, State};
 
 /// # 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)
+#[get("/emoji/<emoji_id>")]
+pub async fn fetch_emoji(db: &State<Database>, emoji_id: Reference) -> Result<Json<v0::Emoji>> {
+    emoji_id
+        .as_emoji(db)
+        .await
+        .map(|emoji| emoji.into())
+        .map(Json)
 }