Better modularity

src/lib.rs

@@ -6,16 +6,13 @@ use std::{
 };
 
 pub mod macros;
+pub mod requests;
 pub mod types;
 pub mod utils;
 
 pub use anyhow::Result;
 
-use crate::{
+use crate::{utils::client::Client, utils::plugin::DynPlugin};
-    types::{ClientMessage, WsMessage},
-    utils::client::Client,
-    utils::plugin::DynPlugin,
-};
 pub use once_cell;
 
 #[derive(serde::Serialize, serde::Deserialize)]
@@ -123,67 +120,10 @@ impl Server {
                         continue 'outer;
                     }
                 }
-            }
 
-            match req {
+                self.call_request(r, &client)?;
-                Some(WsMessage::Message(req)) => match req {
-                    ClientMessage::SendMessage {
-                        channel_id,
-                        contents,
-                    } => {
-                        Self::LOGGER.info(format!("SendMessage to {channel_id}: {contents}"));
-                        let msg = self.wrap_err(
-                            &client,
-                            self.db.messages_db.insert(
-                                &channel_id,
-                                "idk",
-                                &contents,
-                                chrono::Utc::now().timestamp(),
-                            ),
-                        )?;
-
-                        for c in self.clients.lock().unwrap().iter() {
-                            self.wrap_err(
-                                &c,
-                                c.send(types::ServerMessage::MessageCreate(msg.clone())),
-                            )?;
-                        }
-                    }
-
-                    ClientMessage::EditMessage {
-                        channel_id,
-                        message_id,
-                        new_contents,
-                    } => {
-                        Self::LOGGER.info(format!(
-                            "EditMessage {message_id} in {channel_id}: {new_contents}"
-                        ));
-                    }
-
-                    ClientMessage::DeleteMessage {
-                        channel_id,
-                        message_id,
-                    } => {
-                        Self::LOGGER.info(format!("DeleteMessage {message_id} in {channel_id}"));
-                    }
-                },
-
-                Some(WsMessage::Binary(b)) => {
-                    Self::LOGGER.info(format!("Binary message: {b:?}"));
-                }
-
-                Some(WsMessage::String(s)) => {
-                    Self::LOGGER.info(format!("String message: {s}"));
-                }
-
-                None => {
-                    self.clients.lock().unwrap().remove(&client);
-                    break;
-                }
             }
         }
-
-        Ok(())
     }
 
     /// When there is a error it removes the client

src/requests/message.rs

@@ -0,0 +1,63 @@
+use std::sync::Arc;
+
+use crate::{Server, types, utils::client::Client};
+
+crate::logger!(LOGGER "Message Manager");
+
+pub fn send(
+    server: &Arc<Server>,
+    client: &Client,
+    channel_id: &str,
+    contents: &str,
+) -> crate::Result<()> {
+    LOGGER.info(format!("SendMessage to {channel_id}: {contents}"));
+
+    if contents.is_empty() {
+        server.wrap_err(
+            &client,
+            client.send(types::data::ResponseError::InvalidRequest(format!(
+                "Invalid message: empty message"
+            ))),
+        )?;
+        return Ok(());
+    }
+
+    let msg = server.wrap_err(
+        &client,
+        server.db.messages_db.insert(
+            &channel_id,
+            "idk",
+            &contents,
+            chrono::Utc::now().timestamp(),
+        ),
+    )?;
+
+    for c in server.clients.lock().unwrap().iter() {
+        server.wrap_err(&c, c.send(types::ServerMessage::MessageCreate(msg.clone())))?;
+    }
+
+    Ok(())
+}
+
+pub fn edit(
+    _server: &Arc<Server>,
+    _client: &Client,
+    channel_id: &str,
+    message_id: &str,
+    new_contents: &str,
+) -> crate::Result<()> {
+    LOGGER.info(format!(
+        "EditMessage {message_id} in {channel_id}: {new_contents}"
+    ));
+    Ok(())
+}
+
+pub fn delete(
+    _server: &Arc<Server>,
+    _client: &Client,
+    channel_id: &str,
+    message_id: &str,
+) -> crate::Result<()> {
+    LOGGER.info(format!("DeleteMessage {message_id} in {channel_id}"));
+    Ok(())
+}

src/requests/mod.rs

@@ -0,0 +1,49 @@
+pub mod message;
+
+use std::sync::Arc;
+
+use crate::{
+    Server,
+    types::{ClientMessage, WsMessage},
+    utils::client::Client,
+};
+
+impl Server {
+    pub fn call_request(
+        self: &Arc<Self>,
+        req: &WsMessage<ClientMessage>,
+        client: &Client,
+    ) -> crate::Result<()> {
+        match req {
+            WsMessage::Message(req) => match req {
+                ClientMessage::SendMessage {
+                    channel_id,
+                    contents,
+                } => {
+                    message::send(self, client, channel_id, contents)?;
+                }
+
+                ClientMessage::EditMessage {
+                    channel_id,
+                    message_id,
+                    new_contents,
+                } => message::edit(self, client, channel_id, message_id, new_contents)?,
+
+                ClientMessage::DeleteMessage {
+                    channel_id,
+                    message_id,
+                } => message::delete(self, client, channel_id, message_id)?,
+            },
+
+            WsMessage::Binary(b) => {
+                Self::LOGGER.info(format!("Binary message: {b:?}"));
+            }
+
+            WsMessage::String(s) => {
+                Self::LOGGER.info(format!("String message: {s}"));
+            }
+        }
+
+        Ok(())
+    }
+}

src/types.rs

@@ -33,9 +33,6 @@ pub enum ServerMessage {
         user_id: String,
     },
 
-    /// Error responses
-    Error(),
-
     TempMessage {
         message: String,
     },
@@ -101,11 +98,11 @@ pub mod data {
     }
 
     #[derive(Debug, Clone, Serialize, Deserialize)]
-    #[serde(tag = "error", rename_all = "snake_case")]
+    #[serde(tag = "error", content = "message", rename_all = "snake_case")]
     pub enum ResponseError {
-        InvalidRequest { message: String },
+        InvalidRequest(String),
-        Unauthorized { message: String },
+        Unauthorized(String),
-        NotFound { message: String },
+        NotFound(String),
-        InternalError { message: String },
+        InternalError(String),
     }
 }