Slight re-structure

src/lib.rs

@@ -134,7 +134,7 @@ impl Server {
         )?;
 
         match self.wrap_err(&client, client.read_t::<types::handshake::ClientDetails>())? {
-            Some(types::WsMessage::Message(types::handshake::ClientDetails {
+            Some(types::message::WsMessage::Message(types::handshake::ClientDetails {
                 auth_token,
                 last_message,
                 ..
@@ -143,7 +143,7 @@ impl Server {
                 let uuid = self.wrap_err(&client, auth_res)?;
                 self.wrap_err(
                     &client,
-                    client.send(types::ServerMessage::Authenticated {
+                    client.send(types::message::ServerMessage::Authenticated {
                         uuid,
                         messages: if let Some(i) = last_message {
                             self.wrap_err(&client, self.db.get_messages_after_id(i))?
@@ -156,7 +156,7 @@ impl Server {
             Some(v) => {
                 self.wrap_err(
                     &client,
-                    client.send(types::ResponseError::InvalidHandshake(format!(
+                    client.send(types::message::ResponseError::InvalidHandshake(format!(
                         "Invalid handshake: {v:?}"
                     ))),
                 )?;
@@ -195,7 +195,7 @@ impl Server {
         if let Err(e) = &res {
             self.clients.lock().unwrap().remove(&client);
             if client
-                .send(types::ResponseError::InternalError(e.to_string()))
+                .send(types::message::ResponseError::InternalError(e.to_string()))
                 .is_err()
             {}
         }

src/requests/message.rs

@@ -13,7 +13,7 @@ pub fn send(
     LOGGER.info(format!("SendMessage to {channel_id}: {contents}"));
 
     if contents.is_empty() {
-        client.send(types::ResponseError::InvalidRequest(format!(
+        client.send(types::message::ResponseError::InvalidRequest(format!(
             "Invalid message: empty message"
         )))?;
 
@@ -35,7 +35,10 @@ pub fn send(
         let msg = msg.clone();
         std::thread::spawn(move || {
             server
-                .wrap_err(&c, c.send(types::ServerMessage::MessageCreate(msg)))
+                .wrap_err(
+                    &c,
+                    c.send(types::message::ServerMessage::MessageCreate(msg)),
+                )
                 .expect("Failed to broadcast");
         });
     }

src/requests/mod.rs

@@ -4,7 +4,7 @@ use std::sync::Arc;
 
 use crate::{
     Server,
-    types::{ClientMessage, WsMessage},
+    types::message::{ClientMessage, WsMessage},
     utils::client::Client,
 };
 

src/types.rs

@@ -1,82 +1,3 @@
-use serde::{Deserialize, Serialize};
-
-/// Messages sent *from the client* (user’s app) to the server
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(tag = "type", content = "params", rename_all = "snake_case")]
-pub enum ClientMessage {
-    /// Send a message to a channel
-    SendMessage {
-        channel_id: String,
-        contents: String,
-    },
-
-    /// Edit a message (if allowed)
-    EditMessage {
-        message_id: usize,
-        new_contents: String,
-    },
-
-    /// Delete a message (if allowed)
-    DeleteMessage { message_id: usize },
-}
-
-/// Messages sent *from the server* to the client
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(tag = "type", content = "params", rename_all = "snake_case")]
-pub enum ServerMessage {
-    /// Successful authentication
-    Authenticated {
-        uuid: Author,
-        messages: Vec<data::Message>,
-    },
-
-    TempMessage {
-        message: String,
-    },
-
-    /// A new message in a channel
-    MessageCreate(data::Message),
-
-    /// A message was edited
-    MessageUpdate(data::Message),
-
-    /// A message was deleted
-    MessageDelete {
-        channel_id: String,
-        message_id: usize,
-    },
-
-    /// Presence updates
-    PresenceUpdate {
-        user_id: Author,
-        status: String,
-    },
-
-    /// Typing indicator
-    Typing {
-        user_id: Author,
-        channel_id: String,
-    },
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(tag = "error", content = "message", rename_all = "snake_case")]
-pub enum ResponseError {
-    InvalidRequest(String),
-    InvalidHandshake(String),
-    Unauthorized(String),
-    NotFound(String),
-    InternalError(String),
-}
-
-/// WebSocket wrapper
-#[derive(Debug, Clone)]
-pub enum WsMessage<T: Serialize + for<'de> Deserialize<'de>> {
-    Message(T),
-    Binary(Vec<u8>),
-    String(String),
-}
-
 pub type Author = String;
 
 /// Shared data structures
@@ -126,3 +47,86 @@ pub mod handshake {
         pub last_message: Option<usize>,
     }
 }
+
+pub mod message {
+    use serde::{Deserialize, Serialize};
+
+    use crate::types::{Author, data};
+
+    /// Messages sent *from the client* (user’s app) to the server
+    #[derive(Debug, Clone, Serialize, Deserialize)]
+    #[serde(tag = "type", content = "params", rename_all = "snake_case")]
+    pub enum ClientMessage {
+        /// Send a message to a channel
+        SendMessage {
+            channel_id: String,
+            contents: String,
+        },
+
+        /// Edit a message (if allowed)
+        EditMessage {
+            message_id: usize,
+            new_contents: String,
+        },
+
+        /// Delete a message (if allowed)
+        DeleteMessage { message_id: usize },
+    }
+
+    /// Messages sent *from the server* to the client
+    #[derive(Debug, Clone, Serialize, Deserialize)]
+    #[serde(tag = "type", content = "params", rename_all = "snake_case")]
+    pub enum ServerMessage {
+        /// Successful authentication
+        Authenticated {
+            uuid: Author,
+            messages: Vec<data::Message>,
+        },
+
+        TempMessage {
+            message: String,
+        },
+
+        /// A new message in a channel
+        MessageCreate(data::Message),
+
+        /// A message was edited
+        MessageUpdate(data::Message),
+
+        /// A message was deleted
+        MessageDelete {
+            channel_id: String,
+            message_id: usize,
+        },
+
+        /// Presence updates
+        PresenceUpdate {
+            user_id: Author,
+            status: String,
+        },
+
+        /// Typing indicator
+        Typing {
+            user_id: Author,
+            channel_id: String,
+        },
+    }
+
+    #[derive(Debug, Clone, Serialize, Deserialize)]
+    #[serde(tag = "error", content = "message", rename_all = "snake_case")]
+    pub enum ResponseError {
+        InvalidRequest(String),
+        InvalidHandshake(String),
+        Unauthorized(String),
+        NotFound(String),
+        InternalError(String),
+    }
+
+    /// WebSocket wrapper
+    #[derive(Debug, Clone)]
+    pub enum WsMessage<T: Serialize + for<'de> Deserialize<'de>> {
+        Message(T),
+        Binary(Vec<u8>),
+        String(String),
+    }
+}

src/utils/client.rs

@@ -8,7 +8,7 @@ use std::{
 use anyhow::anyhow;
 use serde::{Deserialize, Serialize};
 
-use crate::types::{ClientMessage, WsMessage};
+use crate::types::message::{ClientMessage, WsMessage};
 
 pub mod handshake {
     use base64::Engine;

src/utils/plugin.rs

@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use crate::{
     Server,
-    types::{ClientMessage, WsMessage},
+    types::message::{ClientMessage, WsMessage},
     utils::client::Client,
 };
 

test-plugin/src/lib.rs

@@ -15,24 +15,24 @@ impl Plugin for MyPlugin {
 
     fn on_request(
         &mut self,
-        msg: &voxa_server::types::WsMessage<voxa_server::types::ClientMessage>,
+        msg: &voxa_server::types::message::WsMessage<voxa_server::types::message::ClientMessage>,
         client: &voxa_server::utils::client::Client,
         _server: &Arc<Server>,
     ) -> bool {
         LOGGER.info(&format!("Received message: {:?}", msg));
         match msg {
-            voxa_server::types::WsMessage::Message(
+            voxa_server::types::message::WsMessage::Message(
-                voxa_server::types::ClientMessage::SendMessage { contents, .. },
+                voxa_server::types::message::ClientMessage::SendMessage { contents, .. },
             ) => {
                 if contents == "ping" {
                     LOGGER.info("Pong!");
                     // client
-                    //     .send(voxa_server::types::ServerMessage::TempMessage {
+                    //     .send(voxa_server::types::message::ServerMessage::TempMessage {
                     //         message: "pong".to_string(),
                     //     })
                     //     .unwrap();
                     client
-                        .send(voxa_server::types::ServerMessage::TempMessage {
+                        .send(voxa_server::types::message::ServerMessage::TempMessage {
                             message: "pong".to_string(),
                         })
                         .unwrap();