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,5 +1,58 @@
+pub type Author = String;
+
+/// Shared data structures
+pub mod data {
     use serde::{Deserialize, Serialize};
 
+    use crate::types::Author;
+
+    #[derive(Debug, Clone, Serialize, Deserialize)]
+    pub struct Message {
+        pub id: i64,
+        pub channel_id: String,
+        pub from: Author,
+        pub contents: String,
+        pub timestamp: i64,
+    }
+
+    #[derive(Debug, Clone, Serialize, Deserialize)]
+    pub struct Channel {
+        pub id: String,
+        pub name: String,
+        pub kind: ChannelKind,
+    }
+
+    #[derive(Debug, Clone, Serialize, Deserialize)]
+    #[serde(rename_all = "snake_case")]
+    pub enum ChannelKind {
+        Text,
+        Voice,
+    }
+}
+
+pub mod handshake {
+    use serde::{Deserialize, Serialize};
+
+    #[derive(Debug, Clone, Serialize, Deserialize)]
+    pub struct ServerDetails {
+        pub version: String,
+        pub name: String,
+        pub id: String,
+    }
+
+    #[derive(Debug, Clone, Serialize, Deserialize)]
+    pub struct ClientDetails {
+        pub version: String,
+        pub auth_token: String,
+        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")]
@@ -76,53 +129,4 @@ pub enum WsMessage<T: Serialize + for<'de> Deserialize<'de>> {
         Binary(Vec<u8>),
         String(String),
     }
-
-pub type Author = String;
-
-/// Shared data structures
-pub mod data {
-    use serde::{Deserialize, Serialize};
-
-    use crate::types::Author;
-
-    #[derive(Debug, Clone, Serialize, Deserialize)]
-    pub struct Message {
-        pub id: i64,
-        pub channel_id: String,
-        pub from: Author,
-        pub contents: String,
-        pub timestamp: i64,
-    }
-
-    #[derive(Debug, Clone, Serialize, Deserialize)]
-    pub struct Channel {
-        pub id: String,
-        pub name: String,
-        pub kind: ChannelKind,
-    }
-
-    #[derive(Debug, Clone, Serialize, Deserialize)]
-    #[serde(rename_all = "snake_case")]
-    pub enum ChannelKind {
-        Text,
-        Voice,
-    }
-}
-
-pub mod handshake {
-    use serde::{Deserialize, Serialize};
-
-    #[derive(Debug, Clone, Serialize, Deserialize)]
-    pub struct ServerDetails {
-        pub version: String,
-        pub name: String,
-        pub id: String,
-    }
-
-    #[derive(Debug, Clone, Serialize, Deserialize)]
-    pub struct ClientDetails {
-        pub version: String,
-        pub auth_token: String,
-        pub last_message: Option<usize>,
-    }
 }

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::ClientMessage::SendMessage { contents, .. },
+            voxa_server::types::message::WsMessage::Message(
+                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();