refactor(core): remove quark references from webhook routes

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

@@ -1,5 +1,9 @@
-use revolt_database::{util::reference::Reference, Database};
-use revolt_quark::{models::User, perms, Db, Error, Permission, Result};
+use revolt_database::{
+    util::{permissions::DatabasePermissionQuery, reference::Reference},
+    Database, User,
+};
+use revolt_permissions::{calculate_channel_permissions, ChannelPermission};
+use revolt_result::Result;
 use rocket::State;
 use rocket_empty::EmptyResponse;
 
@@ -10,21 +14,16 @@ use rocket_empty::EmptyResponse;
 #[delete("/<webhook_id>")]
 pub async fn webhook_delete(
     db: &State<Database>,
-    legacy_db: &Db,
     user: User,
     webhook_id: Reference,
 ) -> Result<EmptyResponse> {
-    let webhook = webhook_id.as_webhook(db).await.map_err(Error::from_core)?;
-    let channel = legacy_db.fetch_channel(&webhook.channel_id).await?;
+    let webhook = webhook_id.as_webhook(db).await?;
+    let channel = db.fetch_channel(&webhook.channel_id).await?;
 
-    perms(&user)
-        .channel(&channel)
-        .throw_permission(legacy_db, Permission::ManageWebhooks)
-        .await?;
-
-    webhook
-        .delete(db)
+    let mut query = DatabasePermissionQuery::new(db, &user).channel(&channel);
+    calculate_channel_permissions(&mut query)
         .await
-        .map(|_| EmptyResponse)
-        .map_err(Error::from_core)
+        .throw_if_lacking_channel_permission(ChannelPermission::ManageWebhooks)?;
+
+    webhook.delete(db).await.map(|_| EmptyResponse)
 }

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

@@ -1,6 +1,10 @@
-use revolt_database::{util::reference::Reference, Database, PartialWebhook};
+use revolt_database::{
+    util::{permissions::DatabasePermissionQuery, reference::Reference},
+    Database, PartialWebhook, User,
+};
 use revolt_models::v0::{DataEditWebhook, Webhook};
-use revolt_quark::{models::User, perms, Db, Error, Permission, Result};
+use revolt_permissions::{calculate_channel_permissions, ChannelPermission};
+use revolt_result::{create_error, Result};
 use rocket::{serde::json::Json, State};
 use validator::Validate;
 
@@ -11,22 +15,24 @@ use validator::Validate;
 #[patch("/<webhook_id>", data = "<data>")]
 pub async fn webhook_edit(
     db: &State<Database>,
-    legacy_db: &Db,
     webhook_id: Reference,
     user: User,
     data: Json<DataEditWebhook>,
 ) -> Result<Json<Webhook>> {
     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()
+        })
+    })?;
 
-    let mut webhook = webhook_id.as_webhook(db).await.map_err(Error::from_core)?;
-    let channel = legacy_db.fetch_channel(&webhook.channel_id).await?;
+    let mut webhook = webhook_id.as_webhook(db).await?;
+    let channel = db.fetch_channel(&webhook.channel_id).await?;
 
-    perms(&user)
-        .channel(&channel)
-        .throw_permission(legacy_db, Permission::ManageWebhooks)
-        .await?;
+    let mut query = DatabasePermissionQuery::new(db, &user).channel(&channel);
+    calculate_channel_permissions(&mut query)
+        .await
+        .throw_if_lacking_channel_permission(ChannelPermission::ManageWebhooks)?;
 
     if data.name.is_none() && data.avatar.is_none() && data.remove.is_empty() {
         return Ok(Json(webhook.into()));
@@ -48,16 +54,14 @@ pub async fn webhook_edit(
     if let Some(avatar) = avatar {
         let file = db
             .find_and_use_attachment(&avatar, "avatars", "user", &webhook.id)
-            .await
-            .map_err(Error::from_core)?;
+            .await?;
 
         partial.avatar = Some(file)
     }
 
     webhook
         .update(db, partial, remove.into_iter().map(|v| v.into()).collect())
-        .await
-        .map_err(Error::from_core)?;
+        .await?;
 
     Ok(Json(webhook.into()))
 }

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

@@ -1,12 +1,10 @@
 use revolt_database::{
     util::{idempotency::IdempotencyKey, reference::Reference},
-    Database,
-};
-use revolt_quark::{
-    models::message::{DataMessageSend, Message},
-    types::push::MessageAuthor,
-    Db, Error, Result,
+    Database, Message,
 };
+use revolt_models::v0;
+use revolt_permissions::{ChannelPermission, PermissionValue};
+use revolt_result::{create_error, Result};
 use rocket::{serde::json::Json, State};
 
 use validator::Validate;
@@ -18,31 +16,50 @@ use validator::Validate;
 #[post("/<webhook_id>/<token>", data = "<data>")]
 pub async fn webhook_execute(
     db: &State<Database>,
-    legacy_db: &Db,
     webhook_id: Reference,
     token: String,
-    data: Json<DataMessageSend>,
+    data: Json<v0::DataMessageSend>,
     idempotency: IdempotencyKey,
-) -> Result<Json<Message>> {
+) -> Result<Json<v0::Message>> {
     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()
+        })
+    })?;
 
-    let webhook = webhook_id.as_webhook(db).await.map_err(Error::from_core)?;
-    webhook.assert_token(&token).map_err(Error::from_core)?;
+    let webhook = webhook_id.as_webhook(db).await?;
+    webhook.assert_token(&token)?;
 
-    data.validate_webhook_permissions(webhook.permissions)?;
+    let mut value: PermissionValue = webhook.permissions.into();
+    value.throw_if_lacking_channel_permission(ChannelPermission::SendMessage)?;
 
-    let channel = legacy_db.fetch_channel(&webhook.channel_id).await?;
-    let message = channel
-        .send_message(
-            legacy_db,
-            data,
-            MessageAuthor::Webhook(&webhook.into()),
-            idempotency,
-            true,
-        )
-        .await?;
+    if data.attachments.as_ref().map_or(false, |v| !v.is_empty()) {
+        value.throw_if_lacking_channel_permission(ChannelPermission::UploadFiles)?;
+    }
 
-    Ok(Json(message))
+    if data.embeds.as_ref().map_or(false, |v| !v.is_empty()) {
+        value.throw_if_lacking_channel_permission(ChannelPermission::SendEmbeds)?;
+    }
+
+    if data.masquerade.is_some() {
+        value.throw_if_lacking_channel_permission(ChannelPermission::Masquerade)?;
+    }
+
+    if data.interactions.is_some() {
+        value.throw_if_lacking_channel_permission(ChannelPermission::React)?;
+    }
+
+    let channel = db.fetch_channel(&webhook.channel_id).await?;
+    let message = Message::create_from_api(
+        db,
+        channel,
+        data,
+        v0::MessageAuthor::Webhook(&webhook.into()),
+        idempotency,
+        true,
+    )
+    .await?;
+
+    Ok(Json(message.into()))
 }

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

@@ -1,10 +1,6 @@
-use revolt_database::{util::reference::Reference, Database};
-use revolt_models::v0::Webhook;
-use revolt_quark::{
-    models::{message::SendableEmbed, Message},
-    types::push::MessageAuthor,
-    Db, Error, Result,
-};
+use revolt_database::{util::reference::Reference, Database, Message};
+use revolt_models::v0::{MessageAuthor, SendableEmbed, Webhook};
+use revolt_result::{create_error, Error, Result};
 use revolt_rocket_okapi::{
     gen::OpenApiGenerator,
     request::{OpenApiFromRequest, RequestHeaderInput},
@@ -639,7 +635,7 @@ impl<'r> FromRequest<'r> for EventHeader<'r> {
     async fn from_request(request: &'r Request<'_>) -> rocket::request::Outcome<Self, Self::Error> {
         let headers = request.headers();
         let Some(event) = headers.get_one("X-GitHub-Event") else {
-            return rocket::request::Outcome::Failure((Status::BadRequest, Error::InvalidOperation))
+            return rocket::request::Outcome::Failure((Status::BadRequest, create_error!(InvalidOperation)))
         };
 
         rocket::request::Outcome::Success(Self(event))
@@ -702,7 +698,7 @@ fn safe_from_str<T: for<'de> Deserialize<'de>>(data: &str) -> Result<T> {
         Ok(output) => Ok(output),
         Err(err) => {
             log::error!("{err:?}");
-            Err(Error::InvalidOperation)
+            Err(create_error!(InvalidOperation))
         }
     }
 }
@@ -727,7 +723,7 @@ fn convert_event(data: &str, event_name: &str) -> Result<Event> {
         "issue_comment" => BaseEvent::IssueComment(safe_from_str(data)?),
         "issues" => BaseEvent::Issues(safe_from_str(data)?),
         "pull_request" => BaseEvent::PullRequest(safe_from_str(data)?),
-        _ => return Err(Error::InvalidOperation),
+        _ => return Err(create_error!(InvalidOperation)),
     };
 
     let _Event {
@@ -751,16 +747,15 @@ fn convert_event(data: &str, event_name: &str) -> Result<Event> {
 #[post("/<webhook_id>/<token>/github", data = "<data>")]
 pub async fn webhook_execute_github(
     db: &State<Database>,
-    legacy_db: &Db,
     webhook_id: Reference,
     token: String,
     event: EventHeader<'_>,
     data: String,
 ) -> Result<()> {
-    let webhook = webhook_id.as_webhook(db).await.map_err(Error::from_core)?;
-    webhook.assert_token(&token).map_err(Error::from_core)?;
+    let webhook = webhook_id.as_webhook(db).await?;
+    webhook.assert_token(&token)?;
 
-    let channel = legacy_db.fetch_channel(&webhook.channel_id).await?;
+    let channel = db.fetch_channel(&webhook.channel_id).await?;
     let event = convert_event(&data, &event)?;
 
     let sendable_embed = match event.event {
@@ -1058,30 +1053,25 @@ pub async fn webhook_execute_github(
         },
     };
 
-    sendable_embed
-        .validate()
-        .map_err(|error| Error::FailedValidation { error })?;
+    sendable_embed.validate().map_err(|error| {
+        create_error!(FailedValidation {
+            error: error.to_string()
+        })
+    })?;
 
     let message_id = Ulid::new().to_string();
 
-    let embed = sendable_embed
-        .into_embed(legacy_db, &message_id)
-        .await?;
-
     let mut message = Message {
         id: message_id,
         author: webhook.id.clone(),
         channel: webhook.channel_id.clone(),
-        embeds: Some(vec![embed]),
         webhook: Some(std::convert::Into::<Webhook>::into(webhook.clone()).into()),
         ..Default::default()
     };
 
+    #[allow(clippy::disallowed_methods)]
+    message.attach_sendable_embed(db, sendable_embed).await?;
     message
-        .create(
-            legacy_db,
-            &channel,
-            Some(MessageAuthor::Webhook(&webhook.into())),
-        )
+        .send(db, MessageAuthor::Webhook(&webhook.into()), &channel, false)
         .await
 }

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

@@ -1,6 +1,10 @@
-use revolt_database::{util::reference::Reference, Database};
+use revolt_database::{
+    util::{permissions::DatabasePermissionQuery, reference::Reference},
+    Database, User,
+};
 use revolt_models::v0::{ResponseWebhook, Webhook};
-use revolt_quark::{models::User, perms, Db, Error, Permission, Result};
+use revolt_permissions::{calculate_channel_permissions, ChannelPermission};
+use revolt_result::Result;
 use rocket::{serde::json::Json, State};
 
 /// # Gets a webhook
@@ -10,17 +14,16 @@ use rocket::{serde::json::Json, State};
 #[get("/<webhook_id>")]
 pub async fn webhook_fetch(
     db: &State<Database>,
-    legacy_db: &Db,
     webhook_id: Reference,
     user: User,
 ) -> Result<Json<ResponseWebhook>> {
-    let webhook = webhook_id.as_webhook(db).await.map_err(Error::from_core)?;
-    let channel = legacy_db.fetch_channel(&webhook.channel_id).await?;
+    let webhook = webhook_id.as_webhook(db).await?;
+    let channel = db.fetch_channel(&webhook.channel_id).await?;
 
-    perms(&user)
-        .channel(&channel)
-        .throw_permission(legacy_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)?;
 
     Ok(Json(std::convert::Into::<Webhook>::into(webhook).into()))
 }