feat: rewrite requests to include events

src/routes/channels/channel_ack.rs

@@ -12,7 +12,8 @@ pub async fn req(db: &Db, user: User, target: Ref, message: Ref) -> Result<Empty
         return Err(Error::NotFound);
     }
 
-    db.acknowledge_message(channel.id(), &user.id, &message.id)
+    channel
+        .ack(db, &user.id, &message.id)
         .await
         .map(|_| EmptyResponse)
 }

src/routes/channels/channel_delete.rs

@@ -12,63 +12,26 @@ pub async fn req(db: &Db, user: User, target: Ref) -> Result<EmptyResponse> {
         return Err(Error::NotFound);
     }
 
-    match channel {
+    match &channel {
         Channel::SavedMessages { .. } => Err(Error::NoEffect),
-        Channel::DirectMessage { id, .. } => {
+        Channel::DirectMessage { id, .. } => db
-            db.update_channel(
+            .update_channel(
-                &id,
+                id,
                 &PartialChannel {
                     active: Some(false),
                     ..Default::default()
                 },
                 vec![],
             )
-            .await?;
+            .await
-
+            .map(|_| EmptyResponse),
-            Ok(EmptyResponse)
+        Channel::Group { .. } => channel
-        }
+            .remove_user_from_group(db, &user.id)
-        Channel::Group {
+            .await
-            id,
+            .map(|_| EmptyResponse),
-            owner,
+        Channel::TextChannel { .. } | Channel::VoiceChannel { .. } => {
-            recipients,
-            ..
-        } => {
-            if user.id == owner {
-                if let Some(new_owner) = recipients.iter().find(|x| *x != &user.id) {
-                    db.update_channel(
-                        &id,
-                        &PartialChannel {
-                            owner: Some(new_owner.into()),
-                            ..Default::default()
-                        },
-                        vec![],
-                    )
-                    .await?;
-                } else {
-                    db.delete_channel(&id).await?;
-                    return Ok(EmptyResponse);
-                }
-            }
-
-            db.remove_user_from_group(&id, &user.id).await?;
-
-            /*ClientboundNotification::ChannelGroupLeave {
-                id: id.clone(),
-                user: user.id.clone(),
-            }
-            .publish(id.clone());
-
-            Content::SystemMessage(SystemMessage::UserLeft { id: user.id })
-                .send_as_system(&target)
-                .await
-                .ok();*/
-
-            Ok(EmptyResponse)
-        }
-        Channel::TextChannel { id, .. } | Channel::VoiceChannel { id, .. } => {
             if perm.get_manage_channel() {
-                db.delete_channel(&id).await?;
+                channel.delete(db).await.map(|_| EmptyResponse)
-                Ok(EmptyResponse)
             } else {
                 Err(Error::MissingPermission {
                     permission: ChannelPermission::ManageChannel as i32,

src/routes/channels/channel_edit.rs

@@ -124,7 +124,8 @@ pub async fn req(
                 partial.nsfw = Some(new_nsfw);
             }
 
-            db.update_channel(id, &partial, data.remove.unwrap_or_default())
+            channel
+                .update(db, partial, data.remove.unwrap_or_default())
                 .await?;
         }
         _ => return Err(Error::InvalidOperation),

src/routes/channels/group_add_member.rs

@@ -17,11 +17,13 @@ pub async fn req(db: &Db, user: User, target: Ref, member: Ref) -> Result<EmptyR
         });
     }
 
-    match channel {
+    match &channel {
-        Channel::Group { id, .. } => {
+        Channel::Group { .. } => {
-            let user = member.as_user(db).await?;
+            let member = member.as_user(db).await?;
-            db.add_user_to_group(&id, &user.id).await?;
+            channel
-            Ok(EmptyResponse)
+                .add_user_to_group(db, &member.id, &user.id)
+                .await
+                .map(|_| EmptyResponse)
         }
         _ => Err(Error::InvalidOperation),
     }

src/routes/channels/group_create.rs

@@ -64,6 +64,6 @@ pub async fn req(db: &Db, user: User, info: Json<Data>) -> Result<Json<Channel>>
         nsfw: info.nsfw.unwrap_or(false),
     };
 
-    db.insert_channel(&group).await?;
+    group.create(db).await?;
     Ok(Json(group))
 }

src/routes/channels/group_remove_member.rs

@@ -7,14 +7,11 @@ use revolt_quark::{
 pub async fn req(db: &Db, user: User, target: Ref, member: Ref) -> Result<EmptyResponse> {
     let channel = target.as_channel(db).await?;
 
-    match channel {
+    match &channel {
         Channel::Group {
-            id,
+            owner, recipients, ..
-            owner,
-            recipients,
-            ..
         } => {
-            if user.id != owner {
+            if &user.id != owner {
                 return Err(Error::MissingPermission { permission: 0 });
             }
 
@@ -27,8 +24,10 @@ pub async fn req(db: &Db, user: User, target: Ref, member: Ref) -> Result<EmptyR
                 return Err(Error::NotInGroup);
             }
 
-            db.remove_user_from_group(&id, &member.id).await?;
+            channel
-            Ok(EmptyResponse)
+                .remove_user_from_group(db, &member.id)
+                .await
+                .map(|_| EmptyResponse)
         }
         _ => Err(Error::InvalidOperation),
     }

src/routes/channels/message_delete.rs

@@ -21,5 +21,5 @@ pub async fn req(db: &Db, user: User, target: Ref, msg: Ref) -> Result<EmptyResp
         });
     }
 
-    db.delete_message(&message.id).await.map(|_| EmptyResponse)
+    message.delete(db).await.map(|_| EmptyResponse)
 }

src/routes/channels/message_edit.rs

@@ -48,8 +48,7 @@ pub async fn req(
 
     // 1. Handle content update
     if let Some(content) = edit.content {
-        message.content = Content::Text(content);
+        partial.content = Some(Content::Text(content));
-        partial.content = Some(message.content.clone());
     }
 
     // 2. Clear any auto generated embeds
@@ -71,9 +70,8 @@ pub async fn req(
         }
     }
 
-    message.embeds = Some(new_embeds);
     partial.embeds = message.embeds.clone();
 
-    db.update_message(&message.id, &partial).await?;
+    message.update(db, partial).await?;
     Ok(Json(message))
 }

src/routes/channels/message_send.rs

@@ -152,6 +152,6 @@ pub async fn message_send(
     // 6. Set content
     message.content = Content::Text(data.content);
 
-    db.insert_message(&message).await?;
+    message.create(db).await?;
     Ok(Json(message))
 }

src/routes/channels/permissions_set.rs

@@ -3,7 +3,7 @@ use serde::{Deserialize, Serialize};
 
 use revolt_quark::{
     models::{Channel, User},
-    perms, ChannelPermission, Db, EmptyResponse, Error, Ref, Result,
+    perms, ChannelPermission, Db, Error, Ref, Result,
 };
 
 #[derive(Serialize, Deserialize)]
@@ -18,8 +18,8 @@ pub async fn req(
     target: Ref,
     role: String,
     data: Json<Data>,
-) -> Result<EmptyResponse> {
+) -> Result<Json<Channel>> {
-    let channel = target.as_channel(db).await?;
+    let mut channel = target.as_channel(db).await?;
     if !perms(&user)
         .channel(&channel)
         .calc_channel(db)
@@ -31,13 +31,9 @@ pub async fn req(
         });
     }
 
-    match channel {
+    channel
-        Channel::TextChannel { id, .. } | Channel::VoiceChannel { id, .. } => {
+        .set_role_permission(db, &role, data.permissions)
-            db.set_channel_role_permission(&id, &role, data.permissions)
+        .await?;
-                .await?;
-        }
-        _ => return Err(Error::InvalidOperation),
-    }
 
-    Ok(EmptyResponse)
+    Ok(Json(channel))
 }

src/routes/channels/permissions_set_default.rs

@@ -3,7 +3,7 @@ use serde::{Deserialize, Serialize};
 
 use revolt_quark::{
     models::{channel::PartialChannel, Channel, User},
-    perms, ChannelPermission, Db, EmptyResponse, Error, Ref, Result,
+    perms, ChannelPermission, Db, Error, Ref, Result,
 };
 
 #[derive(Serialize, Deserialize)]
@@ -12,8 +12,8 @@ pub struct Data {
 }
 
 #[put("/<target>/permissions/default", data = "<data>", rank = 1)]
-pub async fn req(db: &Db, user: User, target: Ref, data: Json<Data>) -> Result<EmptyResponse> {
+pub async fn req(db: &Db, user: User, target: Ref, data: Json<Data>) -> Result<Json<Channel>> {
-    let channel = target.as_channel(db).await?;
+    let mut channel = target.as_channel(db).await?;
     if !perms(&user)
         .channel(&channel)
         .calc_channel(db)
@@ -25,31 +25,33 @@ pub async fn req(db: &Db, user: User, target: Ref, data: Json<Data>) -> Result<E
         });
     }
 
-    match channel {
+    match &channel {
-        Channel::Group { id, .. } => {
+        Channel::Group { .. } => {
-            db.update_channel(
+            channel
-                &id,
+                .update(
-                &PartialChannel {
+                    db,
-                    permissions: Some(data.permissions as i32),
+                    PartialChannel {
-                    ..Default::default()
+                        permissions: Some(data.permissions as i32),
-                },
+                        ..Default::default()
-                vec![],
+                    },
-            )
+                    vec![],
-            .await?;
+                )
+                .await?;
         }
-        Channel::TextChannel { id, .. } | Channel::VoiceChannel { id, .. } => {
+        Channel::TextChannel { .. } | Channel::VoiceChannel { .. } => {
-            db.update_channel(
+            channel
-                &id,
+                .update(
-                &PartialChannel {
+                    db,
-                    default_permissions: Some(data.permissions as i32),
+                    PartialChannel {
-                    ..Default::default()
+                        default_permissions: Some(data.permissions as i32),
-                },
+                        ..Default::default()
-                vec![],
+                    },
-            )
+                    vec![],
-            .await?;
+                )
+                .await?;
         }
         _ => return Err(Error::InvalidOperation),
     }
 
-    Ok(EmptyResponse)
+    Ok(Json(channel))
 }

src/routes/servers/channel_create.rs

@@ -40,7 +40,7 @@ pub async fn req(db: &Db, user: User, target: Ref, info: Json<Data>) -> Result<J
     info.validate()
         .map_err(|error| Error::FailedValidation { error })?;
 
-    let server = target.as_server(db).await?;
+    let mut server = target.as_server(db).await?;
     if !perms(&user)
         .server(&server)
         .calc_server(db)
@@ -53,7 +53,7 @@ pub async fn req(db: &Db, user: User, target: Ref, info: Json<Data>) -> Result<J
     }
 
     let id = Ulid::new().to_string();
-    let mut channels = server.channels;
+    let mut channels = server.channels.clone();
     channels.push(id.clone());
 
     let Data {
@@ -93,16 +93,17 @@ pub async fn req(db: &Db, user: User, target: Ref, info: Json<Data>) -> Result<J
         },
     };
 
-    db.insert_channel(&channel).await?;
+    channel.create(db).await?;
-    db.update_server(
+    server
-        &server.id,
+        .update(
-        &PartialServer {
+            db,
-            channels: Some(channels),
+            PartialServer {
-            ..Default::default()
+                channels: Some(channels),
-        },
+                ..Default::default()
-        vec![],
+            },
-    )
+            vec![],
-    .await?;
+        )
+        .await?;
 
     Ok(Json(channel))
 }

src/routes/servers/member_edit.rs

@@ -63,28 +63,15 @@ pub async fn req(
                 db.mark_attachment_as_deleted(&avatar.id).await?;
             }
         }
-
-        for field in fields {
-            member.remove(field);
-        }
     }
 
     // 2. Apply new avatar
     if let Some(avatar) = avatar {
         partial.avatar = Some(File::use_avatar(db, &avatar, &user.id).await?);
-        member.avatar = partial.avatar.clone();
     }
 
-    // 3. Copy over other fields
+    member
-    if let Some(nickname) = &partial.nickname {
+        .update(db, partial, remove.unwrap_or_default())
-        member.nickname.replace(nickname.clone());
-    }
-
-    if let Some(roles) = &partial.roles {
-        member.roles.replace(roles.clone());
-    }
-
-    db.update_member(&member.id, &partial, remove.unwrap_or_else(Vec::new))
         .await?;
 
     Ok(Json(member))

src/routes/servers/member_remove.rs

@@ -17,5 +17,5 @@ pub async fn req(db: &Db, user: User, target: Ref, member: Ref) -> Result<EmptyR
     let member = member.as_member(db, &server.id).await?;
     // ! FIXME: calculate permission against member
 
-    db.delete_member(&member.id).await.map(|_| EmptyResponse)
+    member.delete(db).await.map(|_| EmptyResponse)
 }

src/routes/servers/permissions_set.rs

@@ -1,7 +1,10 @@
 use rocket::serde::json::Json;
 use serde::{Deserialize, Serialize};
 
-use revolt_quark::{models::User, perms, Db, EmptyResponse, Error, Ref, Result};
+use revolt_quark::{
+    models::{Server, User},
+    perms, Db, Error, Ref, Result,
+};
 
 #[derive(Serialize, Deserialize)]
 pub struct Values {
@@ -21,8 +24,8 @@ pub async fn req(
     target: Ref,
     role_id: String,
     data: Json<Data>,
-) -> Result<EmptyResponse> {
+) -> Result<Json<Server>> {
-    let server = target.as_server(db).await?;
+    let mut server = target.as_server(db).await?;
     if !perms(&user)
         .server(&server)
         .calc_server(db)
@@ -34,18 +37,16 @@ pub async fn req(
 
     // ! FIXME: calculate permission against role
 
-    if !server.roles.contains_key(&role_id) {
+    server
-        return Err(Error::NotFound);
+        .set_role_permission(
-    }
+            db,
+            &role_id,
+            &(
+                data.permissions.server as i32,
+                data.permissions.channel as i32,
+            ),
+        )
+        .await?;
 
-    db.update_role_permission(
+    Ok(Json(server))
-        &server.id,
-        &role_id,
-        &(
-            data.permissions.server as i32,
-            data.permissions.channel as i32,
-        ),
-    )
-    .await
-    .map(|_| EmptyResponse)
 }

src/routes/servers/permissions_set_default.rs

@@ -2,8 +2,8 @@ use rocket::serde::json::Json;
 use serde::{Deserialize, Serialize};
 
 use revolt_quark::{
-    models::{server::PartialServer, User},
+    models::{server::PartialServer, Server, User},
-    perms, Db, EmptyResponse, Error, Ref, Result,
+    perms, Db, Error, Ref, Result,
 };
 
 #[derive(Serialize, Deserialize)]
@@ -18,10 +18,10 @@ pub struct Data {
 }
 
 #[put("/<target>/permissions/default", data = "<data>", rank = 1)]
-pub async fn req(db: &Db, user: User, target: Ref, data: Json<Data>) -> Result<EmptyResponse> {
+pub async fn req(db: &Db, user: User, target: Ref, data: Json<Data>) -> Result<Json<Server>> {
     let data = data.into_inner();
 
-    let server = target.as_server(db).await?;
+    let mut server = target.as_server(db).await?;
     if !perms(&user)
         .server(&server)
         .calc_server(db)
@@ -31,17 +31,19 @@ pub async fn req(db: &Db, user: User, target: Ref, data: Json<Data>) -> Result<E
         return Err(Error::NotFound);
     }
 
-    db.update_server(
+    server
-        &server.id,
+        .update(
-        &PartialServer {
+            db,
-            default_permissions: Some((
+            PartialServer {
-                data.permissions.server as i32,
+                default_permissions: Some((
-                data.permissions.channel as i32,
+                    data.permissions.server as i32,
-            )),
+                    data.permissions.channel as i32,
-            ..Default::default()
+                )),
-        },
+                ..Default::default()
-        vec![],
+            },
-    )
+            vec![],
-    .await
+        )
-    .map(|_| EmptyResponse)
+        .await?;
+
+    Ok(Json(server))
 }

src/routes/servers/roles_create.rs

@@ -5,7 +5,6 @@ use revolt_quark::{
 
 use rocket::serde::json::{Json, Value};
 use serde::{Deserialize, Serialize};
-use ulid::Ulid;
 use validator::Validate;
 
 #[derive(Validate, Serialize, Deserialize)]
@@ -30,20 +29,16 @@ pub async fn req(db: &Db, user: User, target: Ref, data: Json<Data>) -> Result<V
         return Err(Error::NotFound);
     }
 
-    let role_id = Ulid::new().to_string();
+    let role = Role {
-    db.insert_role(
+        name: data.name,
-        &server.id,
+        permissions: (
-        &role_id,
+            *DEFAULT_SERVER_PERMISSION as i32,
-        &Role {
+            *DEFAULT_PERMISSION_CHANNEL_SERVER as i32,
-            name: data.name,
+        ),
-            permissions: (
+        ..Default::default()
-                *DEFAULT_SERVER_PERMISSION as i32,
+    };
-                *DEFAULT_PERMISSION_CHANNEL_SERVER as i32,
-            ),
-            ..Default::default()
-        },
-    )
-    .await?;
 
-    Ok(json!({ "id": role_id }))
+    Ok(json!({
+        "id": role.create(db, &server.id).await?
+    }))
 }

src/routes/servers/roles_delete.rs

@@ -2,7 +2,7 @@ use revolt_quark::{models::User, perms, Db, EmptyResponse, Error, Ref, Result};
 
 #[delete("/<target>/roles/<role_id>")]
 pub async fn req(db: &Db, user: User, target: Ref, role_id: String) -> Result<EmptyResponse> {
-    let server = target.as_server(db).await?;
+    let mut server = target.as_server(db).await?;
     if !perms(&user)
         .server(&server)
         .calc_server(db)
@@ -14,7 +14,11 @@ pub async fn req(db: &Db, user: User, target: Ref, role_id: String) -> Result<Em
 
     // ! FIXME: check perms against role
 
-    db.delete_role(&server.id, &role_id)
+    if let Some(role) = server.roles.remove(&role_id) {
-        .await
+        role.delete(db, &server.id, &role_id)
-        .map(|_| EmptyResponse)
+            .await
+            .map(|_| EmptyResponse)
+    } else {
+        Err(Error::NotFound)
+    }
 }

src/routes/servers/roles_edit.rs

@@ -61,21 +61,15 @@ pub async fn req(
             ..Default::default()
         };
 
-        if let Some(remove) = &remove {
+        role.update(
-            for field in remove {
+            db,
-                role.remove(field);
-            }
-        }
-
-        db.update_role(
             &server.id,
             &role_id,
-            &partial,
+            partial,
-            remove.unwrap_or_else(Vec::new),
+            remove.unwrap_or_default(),
         )
         .await?;
 
-        role.apply_options(partial.clone());
         Ok(Json(role))
     } else {
         Err(Error::NotFound)

src/routes/servers/server_create.rs

@@ -82,7 +82,9 @@ pub async fn req(db: &Db, user: User, info: Json<Data>) -> Result<Json<Server>>
     };
 
     db.insert_channel(&channel).await?;
-    db.insert_server(&server).await?;
+
-    db.insert_member(&member).await?;
+    server.create(db).await?;
+    member.create(db).await?;
+
     Ok(Json(server))
 }

src/routes/servers/server_delete.rs

@@ -6,10 +6,9 @@ pub async fn req(db: &Db, user: User, target: Ref) -> Result<EmptyResponse> {
     let member = db.fetch_member(&target.id, &user.id).await?;
 
     if server.owner == user.id {
-        db.delete_server(&server.id).await?;
+        server.delete(db).await
     } else {
-        db.delete_member(&member.id).await?;
+        member.delete(db).await
     }
-
+    .map(|_| EmptyResponse)
-    Ok(EmptyResponse)
 }

src/routes/servers/server_edit.rs

@@ -109,10 +109,6 @@ pub async fn req(db: &Db, user: User, target: Ref, data: Json<Data>) -> Result<J
                 db.mark_attachment_as_deleted(&icon.id).await?;
             }
         }
-
-        for field in fields {
-            server.remove(field);
-        }
     }
 
     // 2. Apply new icon
@@ -127,19 +123,7 @@ pub async fn req(db: &Db, user: User, target: Ref, data: Json<Data>) -> Result<J
         server.banner = partial.banner.clone();
     }
 
-    // 4. Pass-through and validate changes
+    // 4. Validate changes
-    if let Some(name) = &partial.name {
-        server.name = name.clone();
-    }
-
-    if let Some(description) = &partial.description {
-        server.description.replace(description.clone());
-    }
-
-    if let Some(categories) = &partial.categories {
-        server.categories.replace(categories.clone());
-    }
-
     if let Some(system_messages) = &partial.system_messages {
         let channels = system_messages.clone().into_channel_ids();
         if !db
@@ -148,19 +132,11 @@ pub async fn req(db: &Db, user: User, target: Ref, data: Json<Data>) -> Result<J
         {
             return Err(Error::NotFound);
         }
-
-        server.system_messages.replace(system_messages.clone());
     }
 
-    if let Some(analytics) = &partial.analytics {
+    server
-        server.analytics = *analytics;
+        .update(db, partial, remove.unwrap_or_default())
-    }
-
-    if let Some(nsfw) = &partial.nsfw {
-        server.nsfw = *nsfw;
-    }
-
-    db.update_server(&server.id, &partial, remove.unwrap_or_else(Vec::new))
         .await?;
+
     Ok(Json(server))
 }

src/routes/sync/set_settings.rs

@@ -1,4 +1,5 @@
 use revolt_quark::models::User;
+use revolt_quark::r#impl::generic::users::user_settings::UserSettingsImpl;
 use revolt_quark::{Db, EmptyResponse, Result};
 
 use chrono::prelude::*;
@@ -32,7 +33,5 @@ pub async fn req(db: &Db, user: User, data: Json<Data>, options: Options) -> Res
         settings.insert(key, (timestamp, data));
     }
 
-    db.set_user_settings(&user.id, &settings)
+    settings.set(db, &user.id).await.map(|_| EmptyResponse)
-        .await
-        .map(|_| EmptyResponse)
 }

src/routes/users/edit_user.rs

@@ -72,7 +72,6 @@ pub async fn req(db: &State<Database>, mut user: User, data: Json<Data>) -> Resu
     // 2. Apply new avatar
     if let Some(avatar) = data.avatar {
         partial.avatar = Some(File::use_avatar(db, &avatar, &user.id).await?);
-        user.avatar = partial.avatar.clone();
     }
 
     // 3. Apply new status
@@ -87,7 +86,6 @@ pub async fn req(db: &State<Database>, mut user: User, data: Json<Data>) -> Resu
         }
 
         partial.status = Some(new_status);
-        user.status = partial.status.clone();
     }
 
     // 4. Apply new profile
@@ -102,10 +100,9 @@ pub async fn req(db: &State<Database>, mut user: User, data: Json<Data>) -> Resu
         }
 
         partial.profile = Some(new_profile);
-        user.profile = partial.profile.clone();
     }
 
-    db.update_user(&user.id, &partial, data.remove.unwrap_or_default())
+    user.update(db, partial, data.remove.unwrap_or_default())
         .await?;
 
     Ok(Json(user.foreign()))

src/routes/users/open_dm.rs

@@ -27,7 +27,7 @@ pub async fn req(db: &State<Database>, user: User, target: Ref) -> Result<Json<C
             last_message_id: None,
         };
 
-        db.insert_channel(&new_channel).await?;
+        new_channel.create(db).await?;
         Ok(Json(new_channel))
     } else {
         Error::from_permission(UserPermission::SendMessage)