add event_bus_typed

src/domain/events/category.rs

@@ -0,0 +1,16 @@
+use crate::models::category;
+
+#[derive(Debug, Clone)]
+pub struct CategoryCreatedEvent {
+    pub category: category::Model,
+}
+
+#[derive(Debug, Clone)]
+pub struct CategoryUpdatedEvent {
+    pub category: category::Model,
+}
+
+#[derive(Debug, Clone)]
+pub struct CategoryDeletedEvent {
+    pub category: category::Model,
+}

src/domain/events/channel_permission.rs

@@ -0,0 +1,27 @@
+use crate::models::{channel_role_permission, channel_user_permission};
+use uuid::Uuid;
+
+#[derive(Debug, Clone)]
+pub struct ChannelUserPermissionCreatedEvent {
+    pub permission: channel_user_permission::Model,
+}
+
+#[derive(Debug, Clone)]
+pub struct ChannelUserPermissionUpdatedEvent {
+    pub channel_id: Uuid,
+    pub user_id: Uuid,
+    pub permission: Option<channel_user_permission::Model>,
+}
+
+#[derive(Debug, Clone)]
+pub struct ChannelUserPermissionDeletedEvent {
+    pub permission: channel_user_permission::Model,
+}
+
+#[derive(Debug, Clone)]
+pub struct ChannelRolePermissionUpdatedEvent {
+    pub channel_id: Uuid,
+    pub server_id: Uuid,
+    pub role_id: Uuid,
+    pub permission: Option<channel_role_permission::Model>,
+}

src/domain/events/mod.rs

@@ -1,5 +1,10 @@
+pub mod category;
 pub mod channel;
+pub mod channel_permission;
 pub mod emoji;
 pub mod message;
+pub mod role;
 pub mod server;
+pub mod server_permission;
 pub mod server_tree;
+pub mod user;

src/domain/events/role.rs

@@ -0,0 +1,29 @@
+use crate::models::{role, role_user};
+use uuid::Uuid;
+
+#[derive(Debug, Clone)]
+pub struct RoleCreatedEvent {
+    pub role: role::Model,
+}
+
+#[derive(Debug, Clone)]
+pub struct RoleUpdatedEvent {
+    pub role: role::Model,
+}
+
+#[derive(Debug, Clone)]
+pub struct RoleDeletedEvent {
+    pub role: role::Model,
+}
+
+#[derive(Debug, Clone)]
+pub struct RoleUserCreatedEvent {
+    pub role_user: role_user::Model,
+    pub server_id: Uuid,
+}
+
+#[derive(Debug, Clone)]
+pub struct RoleUserDeletedEvent {
+    pub role_user: role_user::Model,
+    pub server_id: Uuid,
+}

src/domain/events/server.rs

@@ -1,4 +1,6 @@
 use crate::models::server;
+use crate::models::server_user;
+use uuid::Uuid;
 
 #[derive(Debug, Clone)]
 pub struct ServerCreatedEvent {
@@ -13,4 +15,15 @@ pub struct ServerUpdatedEvent {
 #[derive(Debug, Clone)]
 pub struct ServerDeletedEvent {
     pub server: server::Model,
+    pub audience: Vec<Uuid>,
+}
+
+#[derive(Debug, Clone)]
+pub struct ServerUserCreatedEvent {
+    pub server_user: server_user::Model,
+}
+
+#[derive(Debug, Clone)]
+pub struct ServerUserDeletedEvent {
+    pub server_user: server_user::Model,
 }

src/domain/events/server_permission.rs

@@ -0,0 +1,16 @@
+use crate::models::{server_role_permission, server_user_permission};
+use uuid::Uuid;
+
+#[derive(Debug, Clone)]
+pub struct ServerUserPermissionUpdatedEvent {
+    pub server_id: Uuid,
+    pub user_id: Uuid,
+    pub permission: Option<server_user_permission::Model>,
+}
+
+#[derive(Debug, Clone)]
+pub struct ServerRolePermissionUpdatedEvent {
+    pub server_id: Uuid,
+    pub role_id: Uuid,
+    pub permission: Option<server_role_permission::Model>,
+}

src/domain/events/user.rs

@@ -0,0 +1,21 @@
+use crate::models::user;
+
+#[derive(Debug, Clone)]
+pub struct UserCreatedEvent {
+    pub user: user::Model,
+}
+
+#[derive(Debug, Clone)]
+pub struct UserUpdatedEvent {
+    pub user: user::Model,
+}
+
+#[derive(Debug, Clone)]
+pub struct UserChangedEvent {
+    pub user: user::Model,
+}
+
+#[derive(Debug, Clone)]
+pub struct UserDeletedEvent {
+    pub user: user::Model,
+}

src/routes/conversation/handlers.rs

@@ -108,12 +108,9 @@ async fn create_channel(state: &AppState, ids: &[Uuid]) -> Result<channel::Model
         .services
         .realtime_registry
         .set_channel_users(channel.id, ids.iter().copied());
-    state.event_bus.emit(
-        "channel_created",
-        ChannelCreatedEvent {
-            channel: channel.clone(),
-        },
-    );
+    state.event_bus.emit(ChannelCreatedEvent {
+        channel: channel.clone(),
+    });
     Ok(channel)
 }
 

src/routes/emoji/handlers.rs

@@ -155,12 +155,9 @@ pub async fn create(
         ..Default::default()
     };
     let created = state.services.emoji.create(model, name).await?;
-    state.event_bus.emit(
-        "emoji_created",
-        EmojiCreatedEvent {
-            emoji: created.clone(),
-        },
-    );
+    state.event_bus.emit(EmojiCreatedEvent {
+        emoji: created.clone(),
+    });
     Ok((StatusCode::CREATED, Json(mapper::response(created))))
 }
 
@@ -201,13 +198,10 @@ pub async fn update(
         active.name = Set(EmojiService::normalize_name(&name)?);
     }
     let updated = state.repositories.emoji.update(active).await?;
-    state.event_bus.emit(
-        "emoji_updated",
-        EmojiUpdatedEvent {
-            previous,
-            emoji: updated.clone(),
-        },
-    );
+    state.event_bus.emit(EmojiUpdatedEvent {
+        previous,
+        emoji: updated.clone(),
+    });
     Ok(Json(mapper::response(updated)))
 }
 
@@ -241,9 +235,7 @@ pub async fn delete(
             model.file_path.as_deref(),
         )
         .await;
-        state
-            .event_bus
-            .emit("emoji_deleted", EmojiDeletedEvent { emoji: model });
+        state.event_bus.emit(EmojiDeletedEvent { emoji: model });
         Ok(StatusCode::NO_CONTENT)
     } else {
         Err(HTTPError::NotFound)

src/routes/gateway/mod.rs

@@ -1,4 +1,7 @@
 use crate::core::AppState;
+use crate::domain::events::category::{
+    CategoryCreatedEvent, CategoryDeletedEvent, CategoryUpdatedEvent,
+};
 use crate::domain::events::channel::{
     ChannelCreatedEvent, ChannelDeletedEvent, ChannelUpdatedEvent,
 };
@@ -7,8 +10,9 @@ use crate::domain::events::message::{
     MessageCreatedEvent, MessageDeletedEvent, MessageReactionAddedEvent,
     MessageReactionRemovedEvent, MessageUpdatedEvent,
 };
+use crate::domain::events::server::{ServerCreatedEvent, ServerDeletedEvent, ServerUpdatedEvent};
 use crate::domain::events::server_tree::ServerTreeInvalidatedEvent;
-use crate::models::{category, server, server_user, user};
+use crate::models::{server_user, user};
 use crate::repositories::Repositories;
 use crate::routes::category::mapper::category_model_to_category_response;
 use crate::routes::channel::mapper::channel_model_to_channel_response;
@@ -112,7 +116,7 @@ impl RealtimeRouter {
 
     pub fn start(self: &Arc<Self>, event_bus: Arc<EventBus>) {
         let router = Arc::clone(self);
-        event_bus.on_async::<MessageCreatedEvent, _, _>("message_created", move |event| {
+        event_bus.on_async::<MessageCreatedEvent>(move |event| {
             let router = Arc::clone(&router);
             async move {
                 let attachments = router
@@ -142,7 +146,7 @@ impl RealtimeRouter {
         });
 
         let router = Arc::clone(self);
-        event_bus.on_async::<MessageUpdatedEvent, _, _>("message_updated", move |event| {
+        event_bus.on_async::<MessageUpdatedEvent>(move |event| {
             let router = Arc::clone(&router);
             async move {
                 let reactions = router
@@ -171,7 +175,7 @@ impl RealtimeRouter {
         });
 
         let router = Arc::clone(self);
-        event_bus.on_async::<MessageDeletedEvent, _, _>("message_deleted", move |event| {
+        event_bus.on_async::<MessageDeletedEvent>(move |event| {
             let router = Arc::clone(&router);
             async move {
                 let users = router
@@ -185,47 +189,41 @@ impl RealtimeRouter {
         });
 
         let router = Arc::clone(self);
-        event_bus.on_async::<MessageReactionAddedEvent, _, _>(
-            "message_reaction_added",
-            move |event| {
-                let router = Arc::clone(&router);
-                async move {
-                    let users = router
-                        .services
-                        .realtime_registry
-                        .users_for_channel(event.channel_id);
-                    router.gateway.send_to_users(
-                        users,
-                        "Reaction",
-                        "add",
-                        reaction_model_to_response(event.reaction),
-                    );
-                }
-            },
-        );
+        event_bus.on_async::<MessageReactionAddedEvent>(move |event| {
+            let router = Arc::clone(&router);
+            async move {
+                let users = router
+                    .services
+                    .realtime_registry
+                    .users_for_channel(event.channel_id);
+                router.gateway.send_to_users(
+                    users,
+                    "Reaction",
+                    "add",
+                    reaction_model_to_response(event.reaction),
+                );
+            }
+        });
 
         let router = Arc::clone(self);
-        event_bus.on_async::<MessageReactionRemovedEvent, _, _>(
-            "message_reaction_removed",
-            move |event| {
-                let router = Arc::clone(&router);
-                async move {
-                    let users = router
-                        .services
-                        .realtime_registry
-                        .users_for_channel(event.channel_id);
-                    router.gateway.send_to_users(
-                        users,
-                        "Reaction",
-                        "remove",
-                        reaction_model_to_response(event.reaction),
-                    );
-                }
-            },
-        );
+        event_bus.on_async::<MessageReactionRemovedEvent>(move |event| {
+            let router = Arc::clone(&router);
+            async move {
+                let users = router
+                    .services
+                    .realtime_registry
+                    .users_for_channel(event.channel_id);
+                router.gateway.send_to_users(
+                    users,
+                    "Reaction",
+                    "remove",
+                    reaction_model_to_response(event.reaction),
+                );
+            }
+        });
 
         let router = Arc::clone(self);
-        event_bus.on_async::<ChannelCreatedEvent, _, _>("channel_created", move |event| {
+        event_bus.on_async::<ChannelCreatedEvent>(move |event| {
             let router = Arc::clone(&router);
             async move {
                 if let Err(error) = router
@@ -251,7 +249,7 @@ impl RealtimeRouter {
         });
 
         let router = Arc::clone(self);
-        event_bus.on_async::<ChannelUpdatedEvent, _, _>("channel_updated", move |event| {
+        event_bus.on_async::<ChannelUpdatedEvent>(move |event| {
             let router = Arc::clone(&router);
             async move {
                 let mut users = router
@@ -274,7 +272,7 @@ impl RealtimeRouter {
         });
 
         let router = Arc::clone(self);
-        event_bus.on_async::<ChannelDeletedEvent, _, _>("channel_deleted", move |event| {
+        event_bus.on_async::<ChannelDeletedEvent>(move |event| {
             let router = Arc::clone(&router);
             async move {
                 let users = router
@@ -292,9 +290,10 @@ impl RealtimeRouter {
         });
 
         let router = Arc::clone(self);
-        event_bus.on_async::<category::Model, _, _>("category_created", move |category| {
+        event_bus.on_async::<CategoryCreatedEvent>(move |event| {
             let router = Arc::clone(&router);
             async move {
+                let category = event.category;
                 let users = router.server_users(category.server_id).await;
                 router.gateway.send_to_users(
                     users,
@@ -306,9 +305,10 @@ impl RealtimeRouter {
         });
 
         let router = Arc::clone(self);
-        event_bus.on_async::<category::Model, _, _>("category_updated", move |category| {
+        event_bus.on_async::<CategoryUpdatedEvent>(move |event| {
             let router = Arc::clone(&router);
             async move {
+                let category = event.category;
                 let users = router.server_users(category.server_id).await;
                 router.gateway.send_to_users(
                     users,
@@ -320,9 +320,10 @@ impl RealtimeRouter {
         });
 
         let router = Arc::clone(self);
-        event_bus.on_async::<category::Model, _, _>("category_deleted", move |category| {
+        event_bus.on_async::<CategoryDeletedEvent>(move |event| {
             let router = Arc::clone(&router);
             async move {
+                let category = event.category;
                 let users = router.server_users(category.server_id).await;
                 router
                     .gateway
@@ -331,9 +332,10 @@ impl RealtimeRouter {
         });
 
         let router = Arc::clone(self);
-        event_bus.on_async::<server::Model, _, _>("server_created", move |server| {
+        event_bus.on_async::<ServerCreatedEvent>(move |event| {
             let router = Arc::clone(&router);
             async move {
+                let server = event.server;
                 let users = router.server_users(server.id).await;
                 router.gateway.send_to_users(
                     users,
@@ -345,9 +347,10 @@ impl RealtimeRouter {
         });
 
         let router = Arc::clone(self);
-        event_bus.on_async::<server::Model, _, _>("server_updated", move |server| {
+        event_bus.on_async::<ServerUpdatedEvent>(move |event| {
             let router = Arc::clone(&router);
             async move {
+                let server = event.server;
                 let users = router.server_users(server.id).await;
                 router.gateway.send_to_users(
                     users,
@@ -359,37 +362,31 @@ impl RealtimeRouter {
         });
 
         let router = Arc::clone(self);
-        event_bus.on_async::<(server::Model, Vec<Uuid>), _, _>(
-            "server_deleted",
-            move |(server, users)| {
-                let router = Arc::clone(&router);
-                async move {
-                    router
-                        .gateway
-                        .send_to_users(users, "Server", "remove", server.id);
-                }
-            },
-        );
+        event_bus.on_async::<ServerDeletedEvent>(move |event| {
+            let router = Arc::clone(&router);
+            async move {
+                router
+                    .gateway
+                    .send_to_users(event.audience, "Server", "remove", event.server.id);
+            }
+        });
 
         let router = Arc::clone(self);
-        event_bus.on_async::<ServerTreeInvalidatedEvent, _, _>(
-            "server_tree_invalidated",
-            move |event| {
-                let router = Arc::clone(&router);
-                async move {
-                    let users = match event.user_ids {
-                        Some(users) => users,
-                        None => router.server_users(event.server_id).await,
-                    };
-                    router
-                        .gateway
-                        .send_to_users(users, "ServerTree", "refresh", event.server_id);
-                }
-            },
-        );
+        event_bus.on_async::<ServerTreeInvalidatedEvent>(move |event| {
+            let router = Arc::clone(&router);
+            async move {
+                let users = match event.user_ids {
+                    Some(users) => users,
+                    None => router.server_users(event.server_id).await,
+                };
+                router
+                    .gateway
+                    .send_to_users(users, "ServerTree", "refresh", event.server_id);
+            }
+        });
 
         let router = Arc::clone(self);
-        event_bus.on_async::<EmojiCreatedEvent, _, _>("emoji_created", move |event| {
+        event_bus.on_async::<EmojiCreatedEvent>(move |event| {
             let router = Arc::clone(&router);
             async move {
                 let users = router.emoji_users(event.emoji.server_id).await;
@@ -403,7 +400,7 @@ impl RealtimeRouter {
         });
 
         let router = Arc::clone(self);
-        event_bus.on_async::<EmojiUpdatedEvent, _, _>("emoji_updated", move |event| {
+        event_bus.on_async::<EmojiUpdatedEvent>(move |event| {
             let router = Arc::clone(&router);
             async move {
                 let mut users = router.emoji_users(event.emoji.server_id).await;
@@ -418,7 +415,7 @@ impl RealtimeRouter {
         });
 
         let router = Arc::clone(self);
-        event_bus.on_async::<EmojiDeletedEvent, _, _>("emoji_deleted", move |event| {
+        event_bus.on_async::<EmojiDeletedEvent>(move |event| {
             let router = Arc::clone(&router);
             async move {
                 let users = router.emoji_users(event.emoji.server_id).await;

src/routes/server/handlers.rs

@@ -1,8 +1,8 @@
 use crate::core::state::AppState;
 use crate::domain::dto::server::{
     CreateServerRequest, JoinServerRequest, ServerResponse, ServerRolePermissionResponse,
-    ServerTreeResponse,
-    ServerUserPermissionResponse, SetServerPermissionRequest, UpdateServerRequest,
+    ServerTreeResponse, ServerUserPermissionResponse, SetServerPermissionRequest,
+    UpdateServerRequest,
 };
 use crate::http::context::{CurrentUser, Superuser};
 use crate::http::error::HTTPError;
@@ -336,10 +336,6 @@ pub async fn set_user_permission(
         .server
         .set_user_permission(server_id, user_id, payload.permissions)
         .await?;
-    state
-        .event_bus
-        .emit("server_user_permission_updated", (server_id, user_id));
-
     let permission = state
         .repositories
         .server
@@ -347,6 +343,13 @@ pub async fn set_user_permission(
         .await?
         .ok_or(HTTPError::NotFound)?;
 
+    state.event_bus.emit(
+        crate::domain::events::server_permission::ServerUserPermissionUpdatedEvent {
+            server_id,
+            user_id,
+            permission: Some(permission.clone()),
+        },
+    );
     Ok(Json(mapper::server_user_permission_to_response(permission)))
 }
 
@@ -386,9 +389,13 @@ pub async fn remove_user_permission(
         .server
         .remove_user_permission(server_id, user_id)
         .await?;
-    state
-        .event_bus
-        .emit("server_user_permission_updated", (server_id, user_id));
+    state.event_bus.emit(
+        crate::domain::events::server_permission::ServerUserPermissionUpdatedEvent {
+            server_id,
+            user_id,
+            permission: None,
+        },
+    );
 
     Ok(StatusCode::NO_CONTENT)
 }
@@ -449,10 +456,6 @@ pub async fn set_role_permission(
         .server
         .set_role_permission(server_id, role_id, payload.permissions)
         .await?;
-    state
-        .event_bus
-        .emit("server_role_permission_updated", (role_id, server_id));
-
     let permission = state
         .repositories
         .server
@@ -460,6 +463,13 @@ pub async fn set_role_permission(
         .await?
         .ok_or(HTTPError::NotFound)?;
 
+    state.event_bus.emit(
+        crate::domain::events::server_permission::ServerRolePermissionUpdatedEvent {
+            server_id,
+            role_id,
+            permission: Some(permission.clone()),
+        },
+    );
     Ok(Json(mapper::server_role_permission_to_response(permission)))
 }
 
@@ -499,9 +509,13 @@ pub async fn remove_role_permission(
         .server
         .remove_role_permission(server_id, role_id)
         .await?;
-    state
-        .event_bus
-        .emit("server_role_permission_updated", (role_id, server_id));
+    state.event_bus.emit(
+        crate::domain::events::server_permission::ServerRolePermissionUpdatedEvent {
+            server_id,
+            role_id,
+            permission: None,
+        },
+    );
 
     Ok(StatusCode::NO_CONTENT)
 }

src/routes/server_item_order/handlers.rs

@@ -28,13 +28,10 @@ pub async fn reorder(
         .ok_or(HTTPError::NotFound)?;
 
     state.services.server_order.reorder(payload).await?;
-    state.event_bus.emit(
-        "server_tree_invalidated",
-        ServerTreeInvalidatedEvent {
-            server_id,
-            user_ids: None,
-        },
-    );
+    state.event_bus.emit(ServerTreeInvalidatedEvent {
+        server_id,
+        user_ids: None,
+    });
 
     Ok(StatusCode::NO_CONTENT)
 }

src/services/category.rs

@@ -1,3 +1,6 @@
+use crate::domain::events::category::{
+    CategoryCreatedEvent, CategoryDeletedEvent, CategoryUpdatedEvent,
+};
 use crate::models::category;
 use crate::models::server_item_order::OrderedResourceType;
 use crate::services::ServicesContext;
@@ -49,7 +52,9 @@ impl CategoryService {
             })
             .await?;
 
-        event_bus.emit("category_created", cat.clone());
+        event_bus.emit(CategoryCreatedEvent {
+            category: cat.clone(),
+        });
 
         Ok(cat)
     }
@@ -76,7 +81,9 @@ impl CategoryService {
 
         txn.commit().await?;
 
-        event_bus.emit("category_updated", cat.clone());
+        event_bus.emit(CategoryUpdatedEvent {
+            category: cat.clone(),
+        });
 
         Ok(cat)
     }
@@ -107,7 +114,7 @@ impl CategoryService {
         txn.commit().await?;
 
         if deleted {
-            event_bus.emit("category_deleted", existing);
+            event_bus.emit(CategoryDeletedEvent { category: existing });
         }
 
         Ok(deleted)

src/services/channel.rs

@@ -2,6 +2,10 @@ use crate::domain::dto::channel::{CreateChannelRequest, UpdateChannelRequest};
 use crate::domain::events::channel::{
     ChannelCreatedEvent, ChannelDeletedEvent, ChannelUpdatedEvent,
 };
+use crate::domain::events::channel_permission::{
+    ChannelRolePermissionUpdatedEvent, ChannelUserPermissionCreatedEvent,
+    ChannelUserPermissionDeletedEvent,
+};
 use crate::models::server_item_order::OrderedResourceType;
 use crate::models::{channel, role};
 use crate::permissions::PermissionSet;
@@ -91,12 +95,9 @@ impl ChannelService {
             .await?;
 
         // Post-commit event emission
-        event_bus.emit(
-            "channel_created",
-            ChannelCreatedEvent {
-                channel: channel.clone(),
-            },
-        );
+        event_bus.emit(ChannelCreatedEvent {
+            channel: channel.clone(),
+        });
 
         Ok(channel)
     }
@@ -141,13 +142,10 @@ impl ChannelService {
 
         txn.commit().await?;
 
-        event_bus.emit(
-            "channel_updated",
-            ChannelUpdatedEvent {
-                previous,
-                channel: channel.clone(),
-            },
-        );
+        event_bus.emit(ChannelUpdatedEvent {
+            previous,
+            channel: channel.clone(),
+        });
 
         Ok(channel)
     }
@@ -178,7 +176,7 @@ impl ChannelService {
         txn.commit().await?;
 
         if deleted {
-            event_bus.emit("channel_deleted", ChannelDeletedEvent { channel: existing });
+            event_bus.emit(ChannelDeletedEvent { channel: existing });
         }
 
         Ok(deleted)
@@ -214,12 +212,15 @@ impl ChannelService {
             .exec(&txn)
             .await?;
 
+        let permission = crate::models::channel_user_permission::Entity::find()
+            .filter(crate::models::channel_user_permission::Column::ChannelId.eq(channel_id))
+            .filter(crate::models::channel_user_permission::Column::UserId.eq(user_id))
+            .one(&txn)
+            .await?
+            .ok_or_else(|| anyhow::anyhow!("Permission not found"))?;
         txn.commit().await?;
 
-        event_bus.emit(
-            "channel_user_permission_created",
-            (channel_id, user_id, permissions),
-        );
+        event_bus.emit(ChannelUserPermissionCreatedEvent { permission });
 
         Ok(())
     }
@@ -234,6 +235,11 @@ impl ChannelService {
 
         let txn = db.begin().await?;
 
+        let existing = crate::models::channel_user_permission::Entity::find()
+            .filter(crate::models::channel_user_permission::Column::ChannelId.eq(channel_id))
+            .filter(crate::models::channel_user_permission::Column::UserId.eq(user_id))
+            .one(&txn)
+            .await?;
         crate::models::channel_user_permission::Entity::delete_many()
             .filter(crate::models::channel_user_permission::Column::ChannelId.eq(channel_id))
             .filter(crate::models::channel_user_permission::Column::UserId.eq(user_id))
@@ -242,7 +248,9 @@ impl ChannelService {
 
         txn.commit().await?;
 
-        event_bus.emit("channel_user_permission_deleted", (channel_id, user_id));
+        if let Some(permission) = existing {
+            event_bus.emit(ChannelUserPermissionDeletedEvent { permission });
+        }
 
         Ok(())
     }
@@ -285,9 +293,19 @@ impl ChannelService {
             .exec(&txn)
             .await?;
 
+        let permission = crate::models::channel_role_permission::Entity::find()
+            .filter(crate::models::channel_role_permission::Column::ChannelId.eq(channel_id))
+            .filter(crate::models::channel_role_permission::Column::RoleId.eq(role_id))
+            .one(&txn)
+            .await?;
         txn.commit().await?;
 
-        event_bus.emit("channel_role_permission_updated", (role_id, server_id));
+        event_bus.emit(ChannelRolePermissionUpdatedEvent {
+            channel_id,
+            server_id,
+            role_id,
+            permission,
+        });
 
         Ok(())
     }
@@ -318,7 +336,12 @@ impl ChannelService {
 
         txn.commit().await?;
 
-        event_bus.emit("channel_role_permission_updated", (role_id, server_id));
+        event_bus.emit(ChannelRolePermissionUpdatedEvent {
+            channel_id,
+            server_id,
+            role_id,
+            permission: None,
+        });
 
         Ok(())
     }

src/services/message.rs

@@ -3,7 +3,6 @@ use crate::domain::events::message::{
 };
 use crate::models::{attachment, channel, message};
 use crate::services::ServicesContext;
-use event_bus::Scope;
 use sea_orm::{
     ActiveModelTrait, ColumnTrait, EntityTrait, QueryFilter, QuerySelect, Set, TransactionTrait,
 };
@@ -41,9 +40,6 @@ impl MessageService {
 
         txn.commit().await?;
 
-        let mut scopes: Vec<Scope> = Vec::new();
-        scopes.push(Scope::uuid("channel", msg.channel_id));
-
         let server_id: Option<Uuid> = channel::Entity::find_by_id(msg.channel_id)
             .select_only()
             .column(channel::Column::ServerId)
@@ -52,19 +48,11 @@ impl MessageService {
             .await?
             .flatten();
 
-        if let Some(server_id) = server_id {
-            scopes.push(Scope::uuid("server", server_id));
-        }
-
-        event_bus.emit_scoped(
-            "message_created",
-            scopes,
-            MessageCreatedEvent {
-                server_id,
-                channel_id: msg.channel_id,
-                message: msg.clone(),
-            },
-        );
+        event_bus.emit(MessageCreatedEvent {
+            server_id,
+            channel_id: msg.channel_id,
+            message: msg.clone(),
+        });
 
         Ok(msg)
     }
@@ -119,19 +107,11 @@ impl MessageService {
             .one(db)
             .await?
             .flatten();
-        let mut scopes = vec![Scope::uuid("channel", msg.channel_id)];
-        if let Some(server_id) = server_id {
-            scopes.push(Scope::uuid("server", server_id));
-        }
-        event_bus.emit_scoped(
-            "message_created",
-            scopes,
-            MessageCreatedEvent {
-                server_id,
-                channel_id: msg.channel_id,
-                message: msg.clone(),
-            },
-        );
+        event_bus.emit(MessageCreatedEvent {
+            server_id,
+            channel_id: msg.channel_id,
+            message: msg.clone(),
+        });
         Ok(msg)
     }
 
@@ -165,19 +145,11 @@ impl MessageService {
             .await?
             .flatten();
 
-        let mut scopes = vec![Scope::uuid("channel", msg.channel_id)];
-        if let Some(server_id) = server_id {
-            scopes.push(Scope::uuid("server", server_id));
-        }
-        event_bus.emit_scoped(
-            "message_updated",
-            scopes,
-            MessageUpdatedEvent {
-                server_id,
-                channel_id: msg.channel_id,
-                message: msg.clone(),
-            },
-        );
+        event_bus.emit(MessageUpdatedEvent {
+            server_id,
+            channel_id: msg.channel_id,
+            message: msg.clone(),
+        });
 
         Ok(msg)
     }
@@ -208,19 +180,11 @@ impl MessageService {
         txn.commit().await?;
 
         if deleted {
-            let mut scopes = vec![Scope::uuid("channel", existing.channel_id)];
-            if let Some(server_id) = server_id {
-                scopes.push(Scope::uuid("server", server_id));
-            }
-            event_bus.emit_scoped(
-                "message_deleted",
-                scopes,
-                MessageDeletedEvent {
-                    server_id,
-                    channel_id: existing.channel_id,
-                    message: existing,
-                },
-            );
+            event_bus.emit(MessageDeletedEvent {
+                server_id,
+                channel_id: existing.channel_id,
+                message: existing,
+            });
         }
 
         Ok(deleted)

src/services/message_reaction.rs

@@ -3,7 +3,6 @@ use crate::domain::events::message::{MessageReactionAddedEvent, MessageReactionR
 use crate::http::error::HTTPError;
 use crate::models::{emoji, message_reaction};
 use crate::services::ServicesContext;
-use event_bus::Scope;
 use sea_orm::{ColumnTrait, EntityTrait, QueryFilter, Set};
 use std::collections::HashMap;
 use std::sync::Arc;
@@ -117,19 +116,11 @@ impl MessageReactionService {
             })
             .await?;
 
-        let mut scopes = vec![Scope::uuid("channel", message.channel_id)];
-        if let Some(server_id) = server_id {
-            scopes.push(Scope::uuid("server", server_id));
-        }
-        self.context.event_bus.emit_scoped(
-            "message_reaction_added",
-            scopes,
-            MessageReactionAddedEvent {
-                server_id,
-                channel_id: message.channel_id,
-                reaction: reaction.clone(),
-            },
-        );
+        self.context.event_bus.emit(MessageReactionAddedEvent {
+            server_id,
+            channel_id: message.channel_id,
+            reaction: reaction.clone(),
+        });
 
         Ok((reaction, true))
     }
@@ -151,19 +142,11 @@ impl MessageReactionService {
             .await?
             .ok_or(HTTPError::NotFound)?;
 
-        let mut scopes = vec![Scope::uuid("channel", message.channel_id)];
-        if let Some(server_id) = server_id {
-            scopes.push(Scope::uuid("server", server_id));
-        }
-        self.context.event_bus.emit_scoped(
-            "message_reaction_removed",
-            scopes,
-            MessageReactionRemovedEvent {
-                server_id,
-                channel_id: message.channel_id,
-                reaction: reaction.clone(),
-            },
-        );
+        self.context.event_bus.emit(MessageReactionRemovedEvent {
+            server_id,
+            channel_id: message.channel_id,
+            reaction: reaction.clone(),
+        });
 
         Ok(reaction)
     }

src/services/permission_sync.rs

@@ -1,6 +1,16 @@
 use crate::domain::events::channel::{ChannelCreatedEvent, ChannelDeletedEvent};
+use crate::domain::events::channel_permission::{
+    ChannelRolePermissionUpdatedEvent, ChannelUserPermissionCreatedEvent,
+    ChannelUserPermissionDeletedEvent, ChannelUserPermissionUpdatedEvent,
+};
+use crate::domain::events::role::{RoleUserCreatedEvent, RoleUserDeletedEvent};
+use crate::domain::events::server::{
+    ServerCreatedEvent, ServerUserCreatedEvent, ServerUserDeletedEvent,
+};
+use crate::domain::events::server_permission::{
+    ServerRolePermissionUpdatedEvent, ServerUserPermissionUpdatedEvent,
+};
 use crate::domain::events::server_tree::ServerTreeInvalidatedEvent;
-use crate::models::server;
 use crate::repositories::Repositories;
 use crate::services::ServicesContext;
 use event_bus::EventBus;
@@ -60,13 +70,10 @@ pub struct PermissionSyncService {
 
 impl PermissionSyncService {
     fn invalidate_tree(event_bus: &Arc<EventBus>, server_id: Uuid, user_ids: Option<Vec<Uuid>>) {
-        event_bus.emit(
-            "server_tree_invalidated",
-            ServerTreeInvalidatedEvent {
-                server_id,
-                user_ids,
-            },
-        );
+        event_bus.emit(ServerTreeInvalidatedEvent {
+            server_id,
+            user_ids,
+        });
     }
 
     pub fn new(service_context: Arc<ServicesContext>) -> Self {
@@ -83,18 +90,18 @@ impl PermissionSyncService {
         // Événements Serveur & Membres Serveur
         // ---------------------------------------------------------------------
         let notify = event_bus.clone();
-        event_bus.on_async_with(
-            "server_created",
+        event_bus.on_async_with::<ServerCreatedEvent, _>(
             repositories.clone(),
-            move |repositories, server: server::Model| async move {
-                Self::sync_server(repositories, server.id).await;
+            move |repositories, event| async move {
+                Self::sync_server(repositories, event.server.id).await;
             },
         );
 
-        event_bus.on_async_with(
-            "server_user_created",
+        event_bus.on_async_with::<ServerUserCreatedEvent, _>(
             repositories.clone(),
-            move |repositories, (server_id, user_id): (Uuid, Uuid)| {
+            move |repositories, event| {
+                let server_id = event.server_user.server_id;
+                let user_id = event.server_user.user_id;
                 let notify = notify.clone();
                 async move {
                     Self::sync_user(repositories, user_id, server_id).await;
@@ -104,10 +111,11 @@ impl PermissionSyncService {
         );
 
         let notify = event_bus.clone();
-        event_bus.on_async_with(
-            "server_user_deleted",
+        event_bus.on_async_with::<ServerUserDeletedEvent, _>(
             repositories.clone(),
-            move |repositories, (server_id, user_id): (Uuid, Uuid)| {
+            move |repositories, event| {
+                let server_id = event.server_user.server_id;
+                let user_id = event.server_user.user_id;
                 let notify = notify.clone();
                 async move {
                     Self::sync_user(repositories, user_id, server_id).await;
@@ -121,10 +129,11 @@ impl PermissionSyncService {
         // ---------------------------------------------------------------------
 
         let notify = event_bus.clone();
-        event_bus.on_async_with(
-            "role_user_created",
+        event_bus.on_async_with::<RoleUserCreatedEvent, _>(
             repositories.clone(),
-            move |repositories, (_role_id, user_id, server_id): (Uuid, Uuid, Uuid)| {
+            move |repositories, event| {
+                let server_id = event.server_id;
+                let user_id = event.role_user.user_id;
                 let notify = notify.clone();
                 async move {
                     Self::sync_user(repositories, user_id, server_id).await;
@@ -134,10 +143,11 @@ impl PermissionSyncService {
         );
 
         let notify = event_bus.clone();
-        event_bus.on_async_with(
-            "role_user_deleted",
+        event_bus.on_async_with::<RoleUserDeletedEvent, _>(
             repositories.clone(),
-            move |repositories, (_role_id, user_id, server_id): (Uuid, Uuid, Uuid)| {
+            move |repositories, event| {
+                let server_id = event.server_id;
+                let user_id = event.role_user.user_id;
                 let notify = notify.clone();
                 async move {
                     Self::sync_user(repositories, user_id, server_id).await;
@@ -151,10 +161,11 @@ impl PermissionSyncService {
         // ---------------------------------------------------------------------
 
         let notify = event_bus.clone();
-        event_bus.on_async_with(
-            "server_role_permission_updated",
+        event_bus.on_async_with::<ServerRolePermissionUpdatedEvent, _>(
             repositories.clone(),
-            move |repositories, (role_id, server_id): (Uuid, Uuid)| {
+            move |repositories, event| {
+                let role_id = event.role_id;
+                let server_id = event.server_id;
                 let notify = notify.clone();
                 async move {
                     Self::sync_role_members(repositories, role_id, server_id).await;
@@ -164,10 +175,11 @@ impl PermissionSyncService {
         );
 
         let notify = event_bus.clone();
-        event_bus.on_async_with(
-            "server_user_permission_updated",
+        event_bus.on_async_with::<ServerUserPermissionUpdatedEvent, _>(
             repositories.clone(),
-            move |repositories, (server_id, user_id): (Uuid, Uuid)| {
+            move |repositories, event| {
+                let server_id = event.server_id;
+                let user_id = event.user_id;
                 let notify = notify.clone();
                 async move {
                     Self::sync_user(repositories, user_id, server_id).await;
@@ -181,10 +193,9 @@ impl PermissionSyncService {
         // ---------------------------------------------------------------------
 
         let notify = event_bus.clone();
-        event_bus.on_async_with(
-            "channel_created",
+        event_bus.on_async_with::<ChannelCreatedEvent, _>(
             repositories.clone(),
-            move |repositories, event: ChannelCreatedEvent| {
+            move |repositories, event| {
                 let notify = notify.clone();
                 async move {
                     if let Some(server_id) = event.channel.server_id {
@@ -196,10 +207,9 @@ impl PermissionSyncService {
         );
 
         let notify = event_bus.clone();
-        event_bus.on_async_with(
-            "channel_deleted",
+        event_bus.on_async_with::<ChannelDeletedEvent, _>(
             repositories.clone(),
-            move |repositories, event: ChannelDeletedEvent| {
+            move |repositories, event| {
                 let notify = notify.clone();
                 async move {
                     if let Some(server_id) = event.channel.server_id {
@@ -211,10 +221,11 @@ impl PermissionSyncService {
         );
 
         let notify = event_bus.clone();
-        event_bus.on_async_with(
-            "channel_role_permission_updated",
+        event_bus.on_async_with::<ChannelRolePermissionUpdatedEvent, _>(
             repositories.clone(),
-            move |repositories, (role_id, server_id): (Uuid, Uuid)| {
+            move |repositories, event| {
+                let role_id = event.role_id;
+                let server_id = event.server_id;
                 let notify = notify.clone();
                 async move {
                     Self::sync_role_members(repositories, role_id, server_id).await;
@@ -224,23 +235,34 @@ impl PermissionSyncService {
         );
 
         let notify = event_bus.clone();
-        event_bus.on_async_with(
-            "channel_user_permission_updated",
+        event_bus.on_async_with::<ChannelUserPermissionUpdatedEvent, _>(
             repositories.clone(),
-            move |repositories, (server_id, user_id): (Uuid, Uuid)| {
+            move |repositories, event| {
+                let user_id = event.user_id;
                 let notify = notify.clone();
                 async move {
-                    Self::sync_user(repositories, user_id, server_id).await;
-                    Self::invalidate_tree(&notify, server_id, Some(vec![user_id]));
+                    if let Some(channel) = repositories
+                        .channel
+                        .get_by_id(event.channel_id)
+                        .await
+                        .ok()
+                        .flatten()
+                    {
+                        if let Some(server_id) = channel.server_id {
+                            Self::sync_user(repositories, user_id, server_id).await;
+                            Self::invalidate_tree(&notify, server_id, Some(vec![user_id]));
+                        }
+                    }
                 }
             },
         );
 
         let notify = event_bus.clone();
-        event_bus.on_async_with(
-            "channel_user_permission_created",
+        event_bus.on_async_with::<ChannelUserPermissionCreatedEvent, _>(
             repositories.clone(),
-            move |repositories, (channel_id, user_id, _permissions): (Uuid, Uuid, u64)| {
+            move |repositories, event| {
+                let channel_id = event.permission.channel_id;
+                let user_id = event.permission.user_id;
                 let notify = notify.clone();
                 async move {
                     if let Some(channel) = repositories
@@ -260,10 +282,11 @@ impl PermissionSyncService {
         );
 
         let notify = event_bus.clone();
-        event_bus.on_async_with(
-            "channel_user_permission_deleted",
+        event_bus.on_async_with::<ChannelUserPermissionDeletedEvent, _>(
             repositories,
-            move |repositories, (channel_id, user_id): (Uuid, Uuid)| {
+            move |repositories, event| {
+                let channel_id = event.permission.channel_id;
+                let user_id = event.permission.user_id;
                 let notify = notify.clone();
                 async move {
                     if let Some(channel) = repositories

src/services/realtime_registry.rs

@@ -1,3 +1,8 @@
+use crate::domain::events::channel_permission::{
+    ChannelUserPermissionCreatedEvent, ChannelUserPermissionDeletedEvent,
+    ChannelUserPermissionUpdatedEvent,
+};
+use crate::domain::events::server_permission::ServerUserPermissionUpdatedEvent;
 use crate::models::{channel, channel_user, computed_permission::PermissionScopeType};
 use crate::permissions::ChannelPermission;
 use crate::repositories::Repositories;
@@ -204,10 +209,10 @@ impl RealtimeRegistry {
         event_bus: Arc<EventBus>,
     ) {
         let registry = Arc::clone(self);
-        event_bus.on_async_with(
-            "channel_user_permission_updated",
+        event_bus.on_async_with::<ChannelUserPermissionUpdatedEvent, _>(
             repositories.clone(),
-            move |repositories, (_channel_id, user_id, _permissions): (Uuid, Uuid, u64)| {
+            move |repositories, event| {
+                let user_id = event.user_id;
                 let registry = Arc::clone(&registry);
                 async move {
                     if let Err(error) = registry.refresh_user(&repositories, user_id).await {
@@ -218,10 +223,10 @@ impl RealtimeRegistry {
         );
 
         let registry = Arc::clone(self);
-        event_bus.on_async_with(
-            "channel_user_permission_created",
+        event_bus.on_async_with::<ChannelUserPermissionCreatedEvent, _>(
             repositories.clone(),
-            move |repositories, (_channel_id, user_id, _permissions): (Uuid, Uuid, u64)| {
+            move |repositories, event| {
+                let user_id = event.permission.user_id;
                 let registry = Arc::clone(&registry);
                 async move {
                     if let Err(error) = registry.refresh_user(&repositories, user_id).await {
@@ -232,10 +237,10 @@ impl RealtimeRegistry {
         );
 
         let registry = Arc::clone(self);
-        event_bus.on_async_with(
-            "channel_user_permission_deleted",
+        event_bus.on_async_with::<ChannelUserPermissionDeletedEvent, _>(
             repositories.clone(),
-            move |repositories, (_channel_id, user_id): (Uuid, Uuid)| {
+            move |repositories, event| {
+                let user_id = event.permission.user_id;
                 let registry = Arc::clone(&registry);
                 async move {
                     if let Err(error) = registry.refresh_user(&repositories, user_id).await {
@@ -247,10 +252,10 @@ impl RealtimeRegistry {
 
         let registry = Arc::clone(self);
         let repositories = repositories.clone();
-        event_bus.on_async_with(
-            "server_user_permission_updated",
+        event_bus.on_async_with::<ServerUserPermissionUpdatedEvent, _>(
             repositories,
-            move |repositories, (_server_id, user_id): (Uuid, Uuid)| {
+            move |repositories, event| {
+                let user_id = event.user_id;
                 let registry = Arc::clone(&registry);
                 async move {
                     if let Err(error) = registry.refresh_user(&repositories, user_id).await {

src/services/role.rs

@@ -1,4 +1,8 @@
-use crate::models::role;
+use crate::domain::events::role::{
+    RoleCreatedEvent, RoleDeletedEvent, RoleUpdatedEvent, RoleUserCreatedEvent,
+    RoleUserDeletedEvent,
+};
+use crate::models::{role, role_user};
 use crate::services::ServicesContext;
 use sea_orm::{ActiveModelTrait, EntityTrait, TransactionTrait};
 use std::sync::Arc;
@@ -27,7 +31,7 @@ impl RoleService {
 
         txn.commit().await?;
 
-        event_bus.emit("role_created", role.clone());
+        event_bus.emit(RoleCreatedEvent { role: role.clone() });
 
         Ok(role)
     }
@@ -45,7 +49,7 @@ impl RoleService {
 
         txn.commit().await?;
 
-        event_bus.emit("role_updated", role.clone());
+        event_bus.emit(RoleUpdatedEvent { role: role.clone() });
 
         Ok(role)
     }
@@ -56,14 +60,15 @@ impl RoleService {
 
         let txn = db.begin().await?;
 
+        let existing = role::Entity::find_by_id(id).one(&txn).await?;
         let res = role::Entity::delete_by_id(id).exec(&txn).await?;
 
         let deleted = res.rows_affected > 0;
 
         txn.commit().await?;
 
-        if deleted {
-            event_bus.emit("role_deleted", id);
+        if let Some(role) = existing.filter(|_| deleted) {
+            event_bus.emit(RoleDeletedEvent { role });
         }
 
         Ok(deleted)
@@ -82,9 +87,14 @@ impl RoleService {
             .add_member(role_id, user_id)
             .await?;
         if added {
-            self.service_context
-                .event_bus
-                .emit("role_user_created", (role_id, user_id, server_id));
+            let role_user = role_user::Entity::find_by_id((role_id, user_id))
+                .one(&self.service_context.repositories.server.context.db)
+                .await?
+                .ok_or_else(|| anyhow::anyhow!("Role membership not found"))?;
+            self.service_context.event_bus.emit(RoleUserCreatedEvent {
+                role_user,
+                server_id,
+            });
         }
         Ok(added)
     }
@@ -95,16 +105,20 @@ impl RoleService {
         user_id: Uuid,
         server_id: Uuid,
     ) -> Result<bool, anyhow::Error> {
+        let existing = role_user::Entity::find_by_id((role_id, user_id))
+            .one(&self.service_context.repositories.server.context.db)
+            .await?;
         let removed = self
             .service_context
             .repositories
             .role
             .remove_member(role_id, user_id)
             .await?;
-        if removed {
-            self.service_context
-                .event_bus
-                .emit("role_user_deleted", (role_id, user_id, server_id));
+        if let Some(role_user) = existing.filter(|_| removed) {
+            self.service_context.event_bus.emit(RoleUserDeletedEvent {
+                role_user,
+                server_id,
+            });
         }
         Ok(removed)
     }

src/services/server.rs

@@ -1,3 +1,7 @@
+use crate::domain::events::server::{
+    ServerCreatedEvent, ServerDeletedEvent, ServerUpdatedEvent, ServerUserCreatedEvent,
+    ServerUserDeletedEvent,
+};
 use crate::models::{role, role_user, server, server_user};
 use crate::services::ServicesContext;
 use sea_orm::{
@@ -63,7 +67,9 @@ impl ServerService {
 
         txn.commit().await?;
 
-        event_bus.emit("server_created", srv.clone());
+        event_bus.emit(ServerCreatedEvent {
+            server: srv.clone(),
+        });
 
         Ok(srv)
     }
@@ -97,7 +103,7 @@ impl ServerService {
             return Ok(srv);
         }
 
-        server_user::ActiveModel {
+        let membership = server_user::ActiveModel {
             server_id: Set(server_id),
             user_id: Set(user_id),
             ..Default::default()
@@ -119,7 +125,9 @@ impl ServerService {
         .await?;
 
         txn.commit().await?;
-        event_bus.emit("server_user_created", (server_id, user_id));
+        event_bus.emit(ServerUserCreatedEvent {
+            server_user: membership,
+        });
         self.service_context
             .repositories
             .read_state
@@ -152,7 +160,9 @@ impl ServerService {
 
         txn.commit().await?;
 
-        event_bus.emit("server_updated", srv.clone());
+        event_bus.emit(ServerUpdatedEvent {
+            server: srv.clone(),
+        });
 
         Ok(srv)
     }
@@ -182,7 +192,10 @@ impl ServerService {
         txn.commit().await?;
 
         if deleted {
-            event_bus.emit("server_deleted", (existing, audience));
+            event_bus.emit(ServerDeletedEvent {
+                server: existing,
+                audience,
+            });
         }
 
         Ok(deleted)
@@ -194,7 +207,7 @@ impl ServerService {
 
         let txn = db.begin().await?;
 
-        crate::models::server_user::ActiveModel {
+        let membership = crate::models::server_user::ActiveModel {
             server_id: Set(server_id),
             user_id: Set(user_id),
             ..Default::default()
@@ -214,7 +227,9 @@ impl ServerService {
 
         txn.commit().await?;
 
-        event_bus.emit("server_user_created", (server_id, user_id));
+        event_bus.emit(ServerUserCreatedEvent {
+            server_user: membership,
+        });
 
         Ok(true)
     }
@@ -225,6 +240,11 @@ impl ServerService {
 
         let txn = db.begin().await?;
 
+        let membership = server_user::Entity::find()
+            .filter(server_user::Column::ServerId.eq(server_id))
+            .filter(server_user::Column::UserId.eq(user_id))
+            .one(&txn)
+            .await?;
         let res = crate::models::server_user::Entity::delete_many()
             .filter(crate::models::server_user::Column::ServerId.eq(server_id))
             .filter(crate::models::server_user::Column::UserId.eq(user_id))
@@ -235,8 +255,8 @@ impl ServerService {
 
         txn.commit().await?;
 
-        if deleted {
-            event_bus.emit("server_user_deleted", (server_id, user_id));
+        if let Some(server_user) = membership.filter(|_| deleted) {
+            event_bus.emit(ServerUserDeletedEvent { server_user });
         }
 
         Ok(deleted)

src/services/user.rs

@@ -1,4 +1,7 @@
 use crate::auth::password;
+use crate::domain::events::user::{
+    UserChangedEvent, UserCreatedEvent, UserDeletedEvent, UserUpdatedEvent,
+};
 use crate::models::{role, user};
 use crate::services::ServicesContext;
 use sea_orm::{
@@ -30,7 +33,7 @@ impl UserService {
 
         txn.commit().await?;
 
-        event_bus.emit("user_created", usr.clone());
+        event_bus.emit(UserCreatedEvent { user: usr.clone() });
 
         Ok(usr)
     }
@@ -48,7 +51,7 @@ impl UserService {
 
         txn.commit().await?;
 
-        event_bus.emit("user_updated", usr.clone());
+        event_bus.emit(UserUpdatedEvent { user: usr.clone() });
 
         Ok(usr)
     }
@@ -79,7 +82,7 @@ impl UserService {
 
         txn.commit().await?;
 
-        event_bus.emit("user_changed", usr);
+        event_bus.emit(UserChangedEvent { user: usr });
 
         Ok(())
     }
@@ -90,14 +93,15 @@ impl UserService {
 
         let txn = db.begin().await?;
 
+        let existing = user::Entity::find_by_id(id).one(&txn).await?;
         let res = user::Entity::delete_by_id(id).exec(&txn).await?;
 
         let deleted = res.rows_affected > 0;
 
         txn.commit().await?;
 
-        if deleted {
-            event_bus.emit("user_deleted", id);
+        if let Some(user) = existing.filter(|_| deleted) {
+            event_bus.emit(UserDeletedEvent { user });
         }
 
         Ok(deleted)