Merge branch 'wip/ban'

Reviewed-on: #38
Reviewed-by: Radical <radical@radical.fun>

.woodpecker/build-and-publish.yml

@@ -1,14 +1,13 @@
 steps:
   - name: build-x86_64
-    image: rust:bookworm
+    image: rust:1.88-bookworm
     commands:
       - cargo build --release
     when:
       - event: push
-      - event: pull_request
 
   - name: build-arm64
-    image: rust:bookworm
+    image: rust:1.88-bookworm
     commands:
       - dpkg --add-architecture arm64
       - apt-get update -y && apt-get install -y crossbuild-essential-arm64 libssl-dev:arm64
@@ -20,7 +19,6 @@ steps:
       PKG_CONFIG_PATH: /usr/aarch64-linux-gnu/lib/pkgconfig
     when:
       - event: push
-      - event: pull_request
 
   - name: container-build-and-publish
     image: docker

.woodpecker/publish-docs.yml

@@ -4,7 +4,7 @@ when:
 
 steps:
   - name: build-docs
-    image: rust:bookworm
+    image: rust:1.88-bookworm
     commands:
       - cargo doc --release --no-deps
 

migrations/2025-07-22-195121_add_ban/down.sql

@@ -0,0 +1,2 @@
+-- This file should undo anything in `up.sql`
+DROP TABLE guild_bans;

migrations/2025-07-22-195121_add_ban/up.sql

@@ -0,0 +1,8 @@
+-- Your SQL goes here
+CREATE TABLE guild_bans (
+	guild_uuid uuid NOT NULL REFERENCES guilds(uuid) ON DELETE CASCADE,
+	user_uuid uuid NOT NULL REFERENCES users(uuid),
+	reason VARCHAR(200) DEFAULT NULL,
+	banned_since TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+	PRIMARY KEY (user_uuid, guild_uuid)
+);

src/api/v1/channels/mod.rs

@@ -1,11 +1,13 @@
 use std::sync::Arc;
 
 use axum::{
-    middleware::from_fn_with_state, routing::{any, delete, get, patch}, Router
+    Router,
+    middleware::from_fn_with_state,
+    routing::{any, delete, get, patch},
 };
 //use socketioxide::SocketIo;
 
-use crate::{api::v1::auth::CurrentUser, AppState};
+use crate::{AppState, api::v1::auth::CurrentUser};
 
 mod uuid;
 

src/api/v1/guilds/uuid/bans.rs

@@ -0,0 +1,57 @@
+use std::sync::Arc;
+
+use axum::{
+    Extension, Json,
+    extract::{Path, State},
+    http::StatusCode,
+    response::IntoResponse,
+};
+use uuid::Uuid;
+
+use crate::{
+    AppState,
+    api::v1::auth::CurrentUser,
+    error::Error,
+    objects::{GuildBan, Member, Permissions},
+    utils::global_checks,
+};
+
+pub async fn get(
+    State(app_state): State<Arc<AppState>>,
+    Path(guild_uuid): Path<Uuid>,
+    Extension(CurrentUser(uuid)): Extension<CurrentUser<Uuid>>,
+) -> Result<impl IntoResponse, Error> {
+    global_checks(&app_state, uuid).await?;
+
+    let mut conn = app_state.pool.get().await?;
+
+    let caller = Member::check_membership(&mut conn, uuid, guild_uuid).await?;
+    caller
+        .check_permission(&app_state, Permissions::BanMember)
+        .await?;
+
+    let all_guild_bans = GuildBan::fetch_all(&mut conn, guild_uuid).await?;
+
+    Ok((StatusCode::OK, Json(all_guild_bans)))
+}
+
+pub async fn unban(
+    State(app_state): State<Arc<AppState>>,
+    Path((guild_uuid, user_uuid)): Path<(Uuid, Uuid)>,
+    Extension(CurrentUser(uuid)): Extension<CurrentUser<Uuid>>,
+) -> Result<impl IntoResponse, Error> {
+    global_checks(&app_state, uuid).await?;
+
+    let mut conn = app_state.pool.get().await?;
+
+    let caller = Member::check_membership(&mut conn, uuid, guild_uuid).await?;
+    caller
+        .check_permission(&app_state, Permissions::BanMember)
+        .await?;
+
+    let ban = GuildBan::fetch_one(&mut conn, guild_uuid, user_uuid).await?;
+
+    ban.unban(&mut conn).await?;
+
+    Ok(StatusCode::OK)
+}

src/api/v1/guilds/uuid/channels.rs

@@ -35,8 +35,9 @@ pub async fn get(
     if let Ok(cache_hit) = app_state
         .get_cache_key(format!("{guild_uuid}_channels"))
         .await
+        && let Ok(channels) = serde_json::from_str::<Vec<Channel>>(&cache_hit)
     {
-        return Ok((StatusCode::OK, Json(cache_hit)).into_response());
+        return Ok((StatusCode::OK, Json(channels)).into_response());
     }
 
     let channels = Channel::fetch_all(&app_state.pool, guild_uuid).await?;

src/api/v1/guilds/uuid/mod.rs

@@ -7,11 +7,12 @@ use axum::{
     extract::{Multipart, Path, State},
     http::StatusCode,
     response::IntoResponse,
-    routing::{get, patch, post},
+    routing::{delete, get, patch, post},
 };
 use bytes::Bytes;
 use uuid::Uuid;
 
+mod bans;
 mod channels;
 mod invites;
 mod members;
@@ -42,6 +43,9 @@ pub fn router() -> Router<Arc<AppState>> {
         .route("/invites", post(invites::create))
         // Members
         .route("/members", get(members::get))
+        // Bans
+        .route("/bans", get(bans::get))
+        .route("/bans/{uuid}", delete(bans::unban))
 }
 
 /// `GET /api/v1/guilds/{uuid}` DESCRIPTION

src/api/v1/guilds/uuid/roles/mod.rs

@@ -35,8 +35,10 @@ pub async fn get(
 
     Member::check_membership(&mut conn, uuid, guild_uuid).await?;
 
-    if let Ok(cache_hit) = app_state.get_cache_key(format!("{guild_uuid}_roles")).await {
-        return Ok((StatusCode::OK, Json(cache_hit)).into_response());
+    if let Ok(cache_hit) = app_state.get_cache_key(format!("{guild_uuid}_roles")).await
+        && let Ok(roles) = serde_json::from_str::<Vec<Role>>(&cache_hit)
+    {
+        return Ok((StatusCode::OK, Json(roles)).into_response());
     }
 
     let roles = Role::fetch_all(&mut conn, guild_uuid).await?;

src/api/v1/guilds/uuid/roles/uuid.rs

@@ -27,8 +27,10 @@ pub async fn get(
 
     Member::check_membership(&mut conn, uuid, guild_uuid).await?;
 
-    if let Ok(cache_hit) = app_state.get_cache_key(format!("{role_uuid}")).await {
-        return Ok((StatusCode::OK, Json(cache_hit)).into_response());
+    if let Ok(cache_hit) = app_state.get_cache_key(format!("{role_uuid}")).await
+        && let Ok(role) = serde_json::from_str::<Role>(&cache_hit)
+    {
+        return Ok((StatusCode::OK, Json(role)).into_response());
     }
 
     let role = Role::fetch_one(&mut conn, role_uuid).await?;

src/api/v1/members/mod.rs

@@ -0,0 +1,17 @@
+use std::sync::Arc;
+
+use axum::{
+    Router,
+    routing::{delete, get, post},
+};
+
+use crate::AppState;
+
+mod uuid;
+
+pub fn router() -> Router<Arc<AppState>> {
+    Router::new()
+        .route("/{uuid}", get(uuid::get))
+        .route("/{uuid}", delete(uuid::delete))
+        .route("/{uuid}/ban", post(uuid::ban::post))
+}

src/api/v1/members/uuid/ban.rs

@@ -0,0 +1,47 @@
+use std::sync::Arc;
+
+use axum::{
+    Extension,
+    extract::{Json, Path, State},
+    http::StatusCode,
+    response::IntoResponse,
+};
+use serde::Deserialize;
+
+use crate::{
+    AppState,
+    api::v1::auth::CurrentUser,
+    error::Error,
+    objects::{Member, Permissions},
+    utils::global_checks,
+};
+
+use uuid::Uuid;
+
+#[derive(Deserialize)]
+pub struct RequstBody {
+    reason: String,
+}
+
+pub async fn post(
+    State(app_state): State<Arc<AppState>>,
+    Path(member_uuid): Path<Uuid>,
+    Extension(CurrentUser(uuid)): Extension<CurrentUser<Uuid>>,
+    Json(payload): Json<RequstBody>,
+) -> Result<impl IntoResponse, Error> {
+    global_checks(&app_state, uuid).await?;
+
+    let mut conn = app_state.pool.get().await?;
+
+    let member = Member::fetch_one_with_member(&app_state, None, member_uuid).await?;
+
+    let caller = Member::check_membership(&mut conn, uuid, member.guild_uuid).await?;
+
+    caller
+        .check_permission(&app_state, Permissions::BanMember)
+        .await?;
+
+    member.ban(&mut conn, &payload.reason).await?;
+
+    Ok(StatusCode::OK)
+}

src/api/v1/members/uuid/mod.rs

@@ -0,0 +1,62 @@
+//! `/api/v1/members/{uuid}` Member specific endpoints
+
+pub mod ban;
+
+use std::sync::Arc;
+
+use crate::{
+    AppState,
+    api::v1::auth::CurrentUser,
+    error::Error,
+    objects::{Me, Member, Permissions},
+    utils::global_checks,
+};
+use axum::{
+    Extension, Json,
+    extract::{Path, State},
+    http::StatusCode,
+    response::IntoResponse,
+};
+
+use uuid::Uuid;
+
+pub async fn get(
+    State(app_state): State<Arc<AppState>>,
+    Path(member_uuid): Path<Uuid>,
+    Extension(CurrentUser(uuid)): Extension<CurrentUser<Uuid>>,
+) -> Result<impl IntoResponse, Error> {
+    global_checks(&app_state, uuid).await?;
+
+    let mut conn = app_state.pool.get().await?;
+
+    let me = Me::get(&mut conn, uuid).await?;
+
+    let member = Member::fetch_one_with_member(&app_state, Some(&me), member_uuid).await?;
+    Member::check_membership(&mut conn, uuid, member.guild_uuid).await?;
+
+    Ok((StatusCode::OK, Json(member)))
+}
+
+pub async fn delete(
+    State(app_state): State<Arc<AppState>>,
+    Path(member_uuid): Path<Uuid>,
+    Extension(CurrentUser(uuid)): Extension<CurrentUser<Uuid>>,
+) -> Result<impl IntoResponse, Error> {
+    global_checks(&app_state, uuid).await?;
+
+    let mut conn = app_state.pool.get().await?;
+
+    let me = Me::get(&mut conn, uuid).await?;
+
+    let member = Member::fetch_one_with_member(&app_state, Some(&me), member_uuid).await?;
+
+    let deleter = Member::check_membership(&mut conn, uuid, member.guild_uuid).await?;
+
+    deleter
+        .check_permission(&app_state, Permissions::KickMember)
+        .await?;
+
+    member.delete(&mut conn).await?;
+
+    Ok(StatusCode::OK)
+}

src/api/v1/mod.rs

@@ -11,6 +11,7 @@ mod channels;
 mod guilds;
 mod invites;
 mod me;
+mod members;
 mod stats;
 mod users;
 
@@ -19,6 +20,7 @@ pub fn router(app_state: Arc<AppState>) -> Router<Arc<AppState>> {
         .nest("/users", users::router())
         .nest("/guilds", guilds::router())
         .nest("/invites", invites::router())
+        .nest("/members", members::router())
         .nest("/me", me::router())
         .layer(from_fn_with_state(
             app_state.clone(),

src/objects/bans.rs

@@ -0,0 +1,57 @@
+use diesel::{ExpressionMethods, QueryDsl, Queryable, Selectable, SelectableHelper};
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use diesel_async::RunQueryDsl;
+
+use crate::{Conn, error::Error, objects::load_or_empty, schema::guild_bans};
+
+#[derive(Selectable, Queryable, Serialize, Deserialize)]
+#[diesel(table_name = guild_bans)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
+pub struct GuildBan {
+    pub guild_uuid: Uuid,
+    pub user_uuid: Uuid,
+    pub reason: Option<String>,
+    pub banned_since: chrono::DateTime<chrono::Utc>,
+}
+
+impl GuildBan {
+    pub async fn fetch_one(
+        conn: &mut Conn,
+        guild_uuid: Uuid,
+        user_uuid: Uuid,
+    ) -> Result<GuildBan, Error> {
+        use guild_bans::dsl;
+        let guild_ban = dsl::guild_bans
+            .filter(dsl::guild_uuid.eq(guild_uuid))
+            .filter(dsl::user_uuid.eq(user_uuid))
+            .select(GuildBan::as_select())
+            .get_result(conn)
+            .await?;
+
+        Ok(guild_ban)
+    }
+
+    pub async fn fetch_all(conn: &mut Conn, guild_uuid: Uuid) -> Result<Vec<Self>, Error> {
+        use guild_bans::dsl;
+        let all_guild_bans = load_or_empty(
+            dsl::guild_bans
+                .filter(dsl::guild_uuid.eq(guild_uuid))
+                .load(conn)
+                .await,
+        )?;
+
+        Ok(all_guild_bans)
+    }
+
+    pub async fn unban(self, conn: &mut Conn) -> Result<(), Error> {
+        use guild_bans::dsl;
+        diesel::delete(guild_bans::table)
+            .filter(dsl::guild_uuid.eq(self.guild_uuid))
+            .filter(dsl::user_uuid.eq(self.user_uuid))
+            .execute(conn)
+            .await?;
+        Ok(())
+    }
+}

src/objects/member.rs

@@ -1,5 +1,6 @@
 use diesel::{
-    ExpressionMethods, Insertable, QueryDsl, Queryable, Selectable, SelectableHelper, insert_into,
+    ExpressionMethods, Insertable, QueryDsl, Queryable, Selectable, SelectableHelper, delete,
+    insert_into,
 };
 use diesel_async::RunQueryDsl;
 use serde::{Deserialize, Serialize};
@@ -8,8 +9,8 @@ use uuid::Uuid;
 use crate::{
     AppState, Conn,
     error::Error,
-    objects::{Me, Permissions, Role},
-    schema::guild_members,
+    objects::{GuildBan, Me, Permissions, Role},
+    schema::{guild_bans, guild_members},
 };
 
 use super::{User, load_or_empty};
@@ -119,6 +120,23 @@ impl Member {
         member.build(app_state, Some(me)).await
     }
 
+    pub async fn fetch_one_with_member(
+        app_state: &AppState,
+        me: Option<&Me>,
+        uuid: Uuid,
+    ) -> Result<Self, Error> {
+        let mut conn = app_state.pool.get().await?;
+
+        use guild_members::dsl;
+        let member: MemberBuilder = dsl::guild_members
+            .filter(dsl::uuid.eq(uuid))
+            .select(MemberBuilder::as_select())
+            .get_result(&mut conn)
+            .await?;
+
+        member.build(app_state, me).await
+    }
+
     pub async fn fetch_all(
         app_state: &AppState,
         me: &Me,
@@ -151,6 +169,13 @@ impl Member {
     ) -> Result<Self, Error> {
         let mut conn = app_state.pool.get().await?;
 
+        let banned = GuildBan::fetch_one(&mut conn, guild_uuid, user_uuid).await;
+        match banned {
+            Ok(_) => Err(Error::Forbidden("User banned".to_string())),
+            Err(Error::SqlError(diesel::result::Error::NotFound)) => Ok(()),
+            Err(e) => Err(e),
+        }?;
+
         let member_uuid = Uuid::now_v7();
 
         let member = MemberBuilder {
@@ -168,4 +193,36 @@ impl Member {
 
         member.build(app_state, None).await
     }
+
+    pub async fn delete(self, conn: &mut Conn) -> Result<(), Error> {
+        if self.is_owner {
+            return Err(Error::Forbidden("Can not kick owner".to_string()))
+        }
+        delete(guild_members::table)
+            .filter(guild_members::uuid.eq(self.uuid))
+            .execute(conn)
+            .await?;
+
+        Ok(())
+    }
+
+    pub async fn ban(self, conn: &mut Conn, reason: &String) -> Result<(), Error> {
+        if self.is_owner {
+            return Err(Error::Forbidden("Can not ban owner".to_string()));
+        }
+
+        use guild_bans::dsl;
+        insert_into(guild_bans::table)
+            .values((
+                dsl::guild_uuid.eq(self.guild_uuid),
+                dsl::user_uuid.eq(self.user_uuid),
+                dsl::reason.eq(reason),
+            ))
+            .execute(conn)
+            .await?;
+
+        self.delete(conn).await?;
+
+        Ok(())
+    }
 }

src/objects/mod.rs

@@ -7,6 +7,7 @@ use log::debug;
 use serde::Deserialize;
 use uuid::Uuid;
 
+mod bans;
 mod channel;
 mod email_token;
 mod friends;
@@ -19,6 +20,7 @@ mod password_reset_token;
 mod role;
 mod user;
 
+pub use bans::GuildBan;
 pub use channel::Channel;
 pub use email_token::EmailToken;
 pub use friends::Friend;

src/objects/role.rs

@@ -176,6 +176,10 @@ pub enum Permissions {
     ManageGuild = 32,
     /// Lets users change member settings (nickname, etc)
     ManageMember = 64,
+    /// Lets users ban members
+    BanMember = 128,
+    /// Lets users kick members
+    KickMember = 256,
 }
 
 impl Permissions {
@@ -188,6 +192,8 @@ impl Permissions {
             Self::ManageInvite,
             Self::ManageGuild,
             Self::ManageMember,
+            Self::BanMember,
+            Self::KickMember,
         ];
 
         all_perms

src/schema.rs

@@ -47,6 +47,16 @@ diesel::table! {
     }
 }
 
+diesel::table! {
+    guild_bans (user_uuid, guild_uuid) {
+        guild_uuid -> Uuid,
+        user_uuid -> Uuid,
+        #[max_length = 200]
+        reason -> Nullable<Varchar>,
+        banned_since -> Timestamptz,
+    }
+}
+
 diesel::table! {
     guild_members (uuid) {
         uuid -> Uuid,
@@ -154,6 +164,8 @@ diesel::joinable!(access_tokens -> refresh_tokens (refresh_token));
 diesel::joinable!(access_tokens -> users (uuid));
 diesel::joinable!(channel_permissions -> channels (channel_uuid));
 diesel::joinable!(channels -> guilds (guild_uuid));
+diesel::joinable!(guild_bans -> guilds (guild_uuid));
+diesel::joinable!(guild_bans -> users (user_uuid));
 diesel::joinable!(guild_members -> guilds (guild_uuid));
 diesel::joinable!(guild_members -> users (user_uuid));
 diesel::joinable!(instance_permissions -> users (uuid));
@@ -171,6 +183,7 @@ diesel::allow_tables_to_appear_in_same_query!(
     channels,
     friend_requests,
     friends,
+    guild_bans,
     guild_members,
     guilds,
     instance_permissions,