Complete fancier audit logging, reimplement ban data deletion

Author: randomairborne

Cargo.lock

@@ -6,10 +6,10 @@ CREATE TABLE new_audit_logs (
     timestamp INT8 NOT NULL,
     previous INT8 NOT NULL,
     delta INT8 NOT NULL,
-    kind INT8 NOT NULL,
+    kind INT8 NOT NULL
 );
-CREATE TABLE new_audit_logs AS
-SELECT guild_id as guild, user_id as target, moderator, timestamp, previous, delta,
+
+INSERT INTO new_audit_logs SELECT guild_id as guild, user_id as target, moderator, timestamp, previous, delta,
 CASE
     /* set */
     WHEN set THEN 2

migrations/20250224222943_audit_log_types.sql

@@ -16,7 +16,13 @@ twilight-gateway = { version = "0.16", default-features = false }
 twilight-cache-inmemory = "0.16"
 twilight-model = "0.16"
 
+# serialize / deserialize
 serde = { version = "1", features = ["derive"] }
+serde_repr = "0.1"
+
+# convert enums to numbers
+strum = "0.27"
+strum_macros = "0.27"
 
 # internal
 simpleinterpolation = { workspace = true }

xpd-common/Cargo.toml

@@ -6,6 +6,7 @@ use std::{
 };
 
 use simpleinterpolation::Interpolation;
+use strum_macros::FromRepr;
 use twilight_cache_inmemory::ResourceType;
 use twilight_gateway::EventTypeFlags;
 use twilight_model::{
@@ -198,14 +199,48 @@ impl Display for GuildConfig {
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub struct AuditLogEvent {
-    pub guild_id: Id<GuildMarker>,
-    pub user_id: Id<UserMarker>,
+    pub guild: Id<GuildMarker>,
+    pub target: Id<UserMarker>,
     pub moderator: Id<UserMarker>,
     pub timestamp: i64,
     pub previous: i64,
     pub delta: i64,
-    pub reset: bool,
-    pub set: bool,
+    pub kind: AuditLogEventKind,
+}
+
+#[derive(
+    Clone,
+    Copy,
+    Debug,
+    PartialEq,
+    Eq,
+    serde_repr::Serialize_repr,
+    serde_repr::Deserialize_repr,
+    FromRepr,
+)]
+#[non_exhaustive]
+#[repr(i16)]
+pub enum AuditLogEventKind {
+    AddSub = 0,
+    Reset = 1,
+    Set = 2,
+    KickReset = 3,
+    BanReset = 4,
+}
+
+impl AuditLogEventKind {
+    #[must_use]
+    pub fn from_i64(t: i64) -> Option<Self> {
+        let Ok(disc) = t.try_into() else {
+            return None;
+        };
+        Self::from_repr(disc)
+    }
+
+    #[must_use]
+    pub const fn to_i64(self) -> i64 {
+        self as i64
+    }
 }
 
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]

xpd-common/src/lib.rs

@@ -23,7 +23,7 @@ use twilight_model::id::{
     marker::{ChannelMarker, GenericMarker, GuildMarker, RoleMarker, UserMarker},
 };
 use util::{db_to_id, id_to_db};
-use xpd_common::{AuditLogEvent, GuildConfig, RoleReward, UserInGuild, UserStatus};
+use xpd_common::{AuditLogEvent, AuditLogEventKind, GuildConfig, RoleReward, UserInGuild, UserStatus};
 pub async fn guild_rewards<
     'a,
     D: DerefMut<Target = PgConnection> + Send,
@@ -187,17 +187,16 @@ pub async fn add_audit_log_event<
     let mut conn = conn.acquire().await?;
     query!(
         "INSERT INTO audit_logs \
-            (guild_id, user_id, moderator,
-                timestamp, previous, delta, reset, set)
-             VALUES ($1, $2, $3, $4, $5, $6, $7, $8)",
-        id_to_db(event.guild_id),
-        id_to_db(event.user_id),
+            (guild, target, moderator,
+                timestamp, previous, delta, kind)
+             VALUES ($1, $2, $3, $4, $5, $6, $7)",
+        id_to_db(event.guild),
+        id_to_db(event.target),
         id_to_db(event.moderator),
         event.timestamp,
         event.previous,
         event.delta,
-        event.reset,
-        event.set
+        event.kind.to_i64(),
     )
     .execute(conn.as_mut())
     .await?;
@@ -210,36 +209,35 @@ pub async fn get_audit_log_events<
     A: Acquire<'a, Database = Postgres, Connection = D> + Send,
 >(
     conn: A,
-    guild_id: Id<GuildMarker>,
+    guild: Id<GuildMarker>,
     actions_on_user: Option<Id<UserMarker>>,
     actions_by_moderator: Option<Id<UserMarker>>,
 ) -> Result<Vec<AuditLogEvent>, Error> {
     let mut conn = conn.acquire().await?;
     let mut stream = query!(
-        "SELECT user_id, moderator,
-        timestamp, previous, delta, reset, set
-        FROM audit_logs WHERE guild_id = $1",
-        id_to_db(guild_id)
+        "SELECT target, moderator,
+        timestamp, previous, delta, kind
+        FROM audit_logs WHERE guild = $1",
+        id_to_db(guild)
     )
     .fetch(conn.as_mut());
     let mut logs = Vec::new();
     while let Some(row) = stream.next().await.transpose()? {
-        let user_id = db_to_id(row.user_id);
+        let target = db_to_id(row.target);
         let moderator = db_to_id(row.moderator);
         if actions_by_moderator.is_some_and(|requested_moderator| requested_moderator != moderator)
-            || actions_on_user.is_some_and(|requested_user| requested_user != user_id)
+            || actions_on_user.is_some_and(|requested_user| requested_user != target)
         {
             continue;
         }
         let log = AuditLogEvent {
-            guild_id,
-            user_id,
+            guild,
+            target,
             moderator: db_to_id(row.moderator),
             timestamp: row.timestamp,
             previous: row.previous,
             delta: row.delta,
-            reset: row.reset,
-            set: row.set,
+            kind: AuditLogEventKind::from_i64(row.kind).ok_or(Error::UnknownAuditLogEventKind)?,
         };
         logs.push(log);
     }
@@ -252,12 +250,12 @@ pub async fn delete_audit_log_events_guild<
     A: Acquire<'a, Database = Postgres, Connection = D> + Send,
 >(
     conn: A,
-    guild_id: Id<GuildMarker>,
+    guild: Id<GuildMarker>,
 ) -> Result<(), Error> {
     let mut conn = conn.acquire().await?;
     query!(
-        "DELETE FROM audit_logs WHERE guild_id = $1",
-        id_to_db(guild_id)
+        "DELETE FROM audit_logs WHERE guild = $1",
+        id_to_db(guild)
     )
     .execute(conn.as_mut())
     .await?;
@@ -270,12 +268,12 @@ pub async fn delete_audit_log_events_user<
     A: Acquire<'a, Database = Postgres, Connection = D> + Send,
 >(
     conn: A,
-    user_id: Id<UserMarker>,
+    target: Id<UserMarker>,
 ) -> Result<(), Error> {
     let mut conn = conn.acquire().await?;
     query!(
-        "DELETE FROM audit_logs WHERE user_id = $1",
-        id_to_db(user_id)
+        "DELETE FROM audit_logs WHERE target = $1",
+        id_to_db(target)
     )
     .execute(conn.as_mut())
     .await?;
@@ -288,14 +286,14 @@ pub async fn delete_audit_log_events_user_guild<
     A: Acquire<'a, Database = Postgres, Connection = D> + Send,
 >(
     conn: A,
-    user_id: Id<UserMarker>,
-    guild_id: Id<GuildMarker>,
+    target: Id<UserMarker>,
+    guild: Id<GuildMarker>,
 ) -> Result<(), Error> {
     let mut conn = conn.acquire().await?;
     query!(
-        "DELETE FROM audit_logs WHERE user_id = $1 AND guild_id = $2",
-        id_to_db(user_id),
-        id_to_db(guild_id)
+        "DELETE FROM audit_logs WHERE target = $1 AND guild = $2",
+        id_to_db(target),
+        id_to_db(guild)
     )
     .execute(conn.as_mut())
     .await?;
@@ -1091,6 +1089,7 @@ pub enum Error {
     Database(sqlx::Error),
     Interpolation(simpleinterpolation::ParseError),
     UnspecifiedDelete,
+    UnknownAuditLogEventKind,
 }
 
 impl Display for Error {
@@ -1099,6 +1098,7 @@ impl Display for Error {
             Self::Database(de) => write!(f, "{de}"),
             Self::Interpolation(ie) => write!(f, "{ie}"),
             Self::UnspecifiedDelete => f.write_str("No constraints specified to delete by."),
+            Self::UnknownAuditLogEventKind => f.write_str("Unknown audit log event kind")
         }
     }
 }

xpd-database/src/lib.rs

@@ -1,5 +1,6 @@
 use sqlx::PgPool;
 use twilight_model::id::Id;
+use xpd_common::AuditLogEventKind;
 
 use crate::*;
 
@@ -37,14 +38,13 @@ async fn find_deletes_returns_correctly(db: PgPool) -> Result<(), Box<dyn std::e
 #[sqlx::test(migrations = "../migrations/")]
 async fn audit_log_refetch(db: PgPool) -> Result<(), Box<dyn std::error::Error>> {
     let original_event = AuditLogEvent {
-        guild_id: Id::new(1),
-        user_id: Id::new(2),
+        guild: Id::new(1),
+        target: Id::new(2),
         moderator: Id::new(3),
         timestamp: 50,
         previous: 100,
         delta: -100,
-        reset: true,
-        set: false,
+        kind: AuditLogEventKind::Reset,
     };
     add_audit_log_event(&db, original_event).await?;
     let roundtripped_event = get_audit_log_events(&db, Id::new(1), None, None).await?;
@@ -56,24 +56,22 @@ async fn audit_log_refetch(db: PgPool) -> Result<(), Box<dyn std::error::Error>>
 async fn audit_log_multi(db: PgPool) -> Result<(), Box<dyn std::error::Error>> {
     let original_events = vec![
         AuditLogEvent {
-            guild_id: Id::new(1),
-            user_id: Id::new(2),
+            guild: Id::new(1),
+            target: Id::new(2),
             moderator: Id::new(3),
             timestamp: 50,
             previous: 100,
             delta: -100,
-            reset: true,
-            set: false,
+            kind: AuditLogEventKind::Reset
         },
         AuditLogEvent {
-            guild_id: Id::new(1),
-            user_id: Id::new(4),
+            guild: Id::new(1),
+            target: Id::new(4),
             moderator: Id::new(5),
             timestamp: 591,
             previous: 15,
             delta: 50,
-            reset: false,
-            set: true,
+            kind: AuditLogEventKind::Set
         },
     ];
     for event in &original_events {
@@ -92,34 +90,31 @@ async fn audit_log_multi(db: PgPool) -> Result<(), Box<dyn std::error::Error>> {
 async fn audit_logs_deleted_guild(db: PgPool) -> Result<(), Box<dyn std::error::Error>> {
     let original_events = vec![
         AuditLogEvent {
-            guild_id: Id::new(1),
-            user_id: Id::new(2),
+        guild: Id::new(1),
+        target: Id::new(2),
             moderator: Id::new(3),
             timestamp: 50,
             previous: 100,
             delta: -100,
-            reset: false,
-            set: false,
+            kind: AuditLogEventKind::AddSub
         },
         AuditLogEvent {
-            guild_id: Id::new(1),
-            user_id: Id::new(4),
+            guild: Id::new(1),
+            target: Id::new(4),
             moderator: Id::new(5),
             timestamp: 591,
             previous: 15,
             delta: 50,
-            reset: false,
-            set: false,
+            kind: AuditLogEventKind::AddSub
         },
         AuditLogEvent {
-            guild_id: Id::new(2),
-            user_id: Id::new(4),
+            guild: Id::new(2),
+            target: Id::new(4),
             moderator: Id::new(5),
             timestamp: 595,
             previous: 100,
             delta: 50,
-            reset: false,
-            set: true,
+            kind: AuditLogEventKind::Set
         },
     ];
     for event in &original_events {