Switch server to sqlite

server/src/server.rs

@@ -1,17 +1,20 @@
 use std::net::SocketAddr;
+
 use chrono::{DateTime, Utc};
-use sqlx::{Error, MySql, Pool, Row};
-use sqlx::mysql::MySqlRow;
+use sqlx::{FromRow, Pool, query_as, Sqlite};
+use sqlx::query;
 use tarpc::context::Context;
-use crate::types::{Edit, Message, MessageData, Reaction, RealmChat, Redaction, Reply, Room, User};
+
 use realm_shared::types::ErrorCode::*;
 use realm_shared::types::ErrorCode;
 
+use crate::types::{Message, MessageData, RealmChat, Room, User};
+
 #[derive(Clone)]
 pub struct RealmChatServer {
 	pub server_id: String,
 	pub socket: SocketAddr, 
-	pub db_pool: Pool<MySql>,
+	pub db_pool: Pool<Sqlite>,
 	pub typing_users: Vec<(u32, u32)> //NOTE: userid, roomid
 } //TODO: Cache for auth
 
@@ -25,29 +28,29 @@ impl RealmChat for RealmChatServer {
 		
 		let result = match &message.data {
 			MessageData::Text(text) => { 
-				sqlx::query("INSERT INTO message (timestamp, user, room, type, msgText) VALUES (?, ?, ?, 'text', ?)")
-					.bind(message.timestamp).bind(message.user.id).bind(message.room.id).bind(text)
+				query!("INSERT INTO message (timestamp, user, room, msg_type, msg_text) VALUES (?, ?, ?, 'text', ?)", 
+					message.timestamp, message.user.id, message.room.id, text)
 					.execute(&self.db_pool).await 
 			}
 			MessageData::Attachment(attachment) => { todo!() }
 			MessageData::Reply(reply) => {
-				sqlx::query("INSERT INTO message (timestamp, user, room, type, msgText, referencingID) VALUES (?, ?, ?, 'reply', ?, ?)")
-					.bind(message.timestamp).bind(message.user.id).bind(message.room.id).bind(reply.text.clone()).bind(reply.referencing_id)
+				query!("INSERT INTO message (timestamp, user, room, msg_type, msg_text, referencing_id) VALUES (?, ?, ?, 'reply', ?, ?)",
+					message.timestamp, message.user.id, message.room.id, reply.text, reply.referencing_id)
 					.execute(&self.db_pool).await
 			}
 			MessageData::Edit(edit) => {
-				sqlx::query("INSERT INTO message (timestamp, user, room, type, msgText, referencingID) VALUES (?, ?, ?, 'edit', ?, ?)")
-					.bind(message.timestamp).bind(message.user.id).bind(message.room.id).bind(edit.text.clone()).bind(edit.referencing_id)
+				query!("INSERT INTO message (timestamp, user, room, msg_type, msg_text, referencing_id) VALUES (?, ?, ?, 'edit', ?, ?)",
+					message.timestamp, message.user.id, message.room.id, edit.text, edit.referencing_id)
 					.execute(&self.db_pool).await
 			}
 			MessageData::Reaction(reaction) => {
-				sqlx::query("INSERT INTO message (timestamp, user, room, type, emoji, referencingID) VALUES (?, ?, ?, 'reaction', ?, ?)")
-					.bind(message.timestamp).bind(message.user.id).bind(message.room.id).bind(reaction.emoji.clone()).bind(reaction.referencing_id)
+				query!("INSERT INTO message (timestamp, user, room, msg_type, emoji, referencing_id) VALUES (?, ?, ?, 'reaction', ?, ?)",
+					message.timestamp, message.user.id, message.room.id, reaction.emoji, reaction.referencing_id)
 					.execute(&self.db_pool).await
 			}
 			MessageData::Redaction(redaction) => {
-				sqlx::query("INSERT INTO message (timestamp, user, room, type, redaction, referencingID) VALUES (?, ?, ?, 'redaction', ?, ?)")
-					.bind(message.timestamp).bind(message.user.id).bind(message.room.id).bind(true).bind(redaction.referencing_id)
+				query!("INSERT INTO message (timestamp, user, room, msg_type, referencing_id) VALUES (?, ?, ?, 'redaction', ?)",
+					message.timestamp, message.user.id, message.room.id, redaction.referencing_id)
 					.execute(&self.db_pool).await
 			}
 		};
@@ -58,7 +61,7 @@ impl RealmChat for RealmChatServer {
 
 				Ok(message)
 			},
-			Err(_) => Err(ErrorCode::Error),
+			Err(_) => Err(Error),
 		}
 	}
 
@@ -76,13 +79,16 @@ impl RealmChat for RealmChatServer {
 
 	async fn get_message_from_id(self, _: Context, auth_token: String, id: u32) -> Result<Message, ErrorCode> {
 		//TODO: Auth for admin room
-		let result = sqlx::query(
-			"SELECT * FROM message INNER JOIN room ON message.room = room.id INNER JOIN user ON message.user = user.id WHERE message.id = ?"
-		).bind(id).fetch_one(&self.db_pool).await;
+		let result = sqlx::query("SELECT message.*,
+        room.id AS 'room_id', room.roomid AS 'room_roomid', room.name AS 'room_name', room.admin_only_send AS 'room_admin_only_send', room.admin_only_view AS 'room_admin_only_view',
+        user.id AS 'user_id', user.userid AS 'user_userid', user.name AS 'user_name', user.online AS 'user_online', user.admin AS 'user_admin'
+	    FROM message INNER JOIN room ON message.room = room.id INNER JOIN user ON message.user = user.id WHERE message.id = ?")
+			.bind(id)
+			.fetch_one(&self.db_pool).await;
 
 		match result {
 		    Ok(row) => {
-				self.dbmessage_to_message(row)
+				Ok(Message::from_row(&row).unwrap())
 			},
 			Err(_) => {
 				Err(MessageNotFound)
@@ -97,74 +103,54 @@ impl RealmChat for RealmChatServer {
 
 	async fn get_rooms(self, _: Context, auth_token: String) -> Result<Vec<Room>, ErrorCode> {
 		//TODO: Auth for admin rooms!
-		let result = sqlx::query("SELECT * FROM room").fetch_all(&self.db_pool).await;
-		let mut rooms: Vec<Room> = Vec::new();
+		let result = query_as!(Room, "SELECT * FROM room").fetch_all(&self.db_pool).await;
 
 		match result {
-		    Ok(rows) => {
-				for row in rows {
-					let room = self.dbroom_to_room(row);
-					if let Some(err) = room.clone().err() {
-						return Err(err)
-					}
-					rooms.push(room.unwrap());
-				}
-				Ok(rooms)
-			},
-			Err(_) => {
-				Err(Error)
-			},
+		    Ok(rooms) => Ok(rooms),
+			Err(_) => Err(Error),
 		}
 	}
 
 	async fn get_room(self, _: Context, auth_token: String, roomid: String) -> Result<Room, ErrorCode> {
 		//TODO: Auth for admin rooms!
-		let result = sqlx::query("SELECT * FROM room WHERE room_id = ?").bind(roomid).fetch_one(&self.db_pool).await;
+		let result = query_as!(Room, "SELECT * FROM room WHERE roomid = ?", roomid).fetch_one(&self.db_pool).await;
 		
 		match result {
-		    Ok(row) => { self.dbroom_to_room(row) },
+		    Ok(room) => { Ok(room) },
 			Err(_) => Err(RoomNotFound),
 		}
 	}
 
 	async fn get_user(self, _: Context, userid: String) -> Result<User, ErrorCode> {
-		let result = sqlx::query("SELECT * FROM user WHERE user_id = ?").bind(userid).fetch_one(&self.db_pool).await;
+		let result = query_as!(User, "SELECT * FROM user WHERE userid = ?", userid).fetch_one(&self.db_pool).await;
 		
 		match result {
-		    Ok(row) => { self.dbuser_to_user(row) },
+		    Ok(user) => { Ok(user) },
 			Err(_) => Err(UserNotFound),
 		}
 	}
 
-	async fn get_users(self, _: Context, get_only_online: bool) -> Result<Vec<User>, ErrorCode> {
-		let mut query = sqlx::query("SELECT * FROM user");
-		if get_only_online {
-			query = sqlx::query("SELECT * FROM user WHERE online = true");
-		}
-		
-		let result = query.fetch_all(&self.db_pool).await;
-		let mut users: Vec<User> = Vec::new();
+	async fn get_users(self, _: Context) -> Result<Vec<User>, ErrorCode> {
+		let result = query_as!(User, "SELECT * FROM user").fetch_all(&self.db_pool).await;
 
 		match result {
-			Ok(rows) => {
-				for row in rows {
-					let user = self.dbuser_to_user(row);
-					if let Some(err) = user.clone().err() {
-						return Err(err)
-					}
-					users.push(user.unwrap())
-				}
-				Ok(users)
-			},
-			Err(_) => {
-				Err(Error)
-			},
-		}	
+			Ok(users) => Ok(users),
+			Err(_) => Err(Error),
+		}
+	}
+
+	async fn get_online_users(self, _: Context) -> Result<Vec<User>, ErrorCode> {
+		let result = query_as!(User, "SELECT * FROM user WHERE online = true").fetch_all(&self.db_pool).await;
+
+		match result {
+			Ok(users) => Ok(users),
+			Err(_) => Err(Error),
+		}
 	}
 }
 
 impl RealmChatServer {
-	pub fn new(server_id: String, socket: SocketAddr, db_pool: Pool<MySql>) -> RealmChatServer {
+	pub fn new(server_id: String, socket: SocketAddr, db_pool: Pool<Sqlite>) -> RealmChatServer {
 		RealmChatServer {
 			server_id,
 			socket,
@@ -172,131 +158,4 @@ impl RealmChatServer {
 			typing_users: Vec::new(),
 		}
 	}
-	
-	fn dbroom_to_room(&self, row: MySqlRow) -> Result<Room, ErrorCode> {
-		let id: Result<u32, _> = row.try_get("id");
-		let roomid: Result<String, _> = row.try_get("user_id");
-		let name: Result<String, _> = row.try_get("name");
-		let admin_only_send: Result<bool, _> = row.try_get("admin_only_send");
-		let admin_only_view: Result<bool, _> = row.try_get("admin_only_view");
-
-		if id.is_err() {
-			return Err(MalformedDBResponse)
-		}
-
-		Ok(Room {
-			id: id.unwrap(),
-			roomid: roomid.unwrap(),
-			name: name.unwrap(),
-			admin_only_send: admin_only_send.unwrap(),
-			admin_only_view: admin_only_view.unwrap(),
-		})
-	}
-	
-	fn dbuser_to_user(&self, row: MySqlRow) -> Result<User, ErrorCode> {
-		let id: Result<u32, _> = row.try_get("id");
-		let userid: Result<String, _> = row.try_get("user_id");
-		let name: Result<String, _> = row.try_get("name");
-		let online: Result<bool, _> = row.try_get("online");
-		let admin: Result<bool, _> = row.try_get("admin");
-		
-		if id.is_err() {
-			return Err(MalformedDBResponse)
-		}
-		
-		Ok(User {
-			id: id.unwrap(),
-			userid: userid.unwrap(),
-			name: name.unwrap(),
-			online: online.unwrap(),
-			admin: admin.unwrap(),
-		})
-	}
-	
-	fn dbmessage_to_message(&self, row: MySqlRow) -> Result<Message, ErrorCode> { //NOTE: Query results passed in should have a join
-		let result: Result<&str, Error> = row.try_get("type");
-		let type_enum: &str = match result {
-			Ok(string) => { string }
-			Err(_) => { "" }
-		};
-
-		if type_enum == "" {
-			return Err(MalformedDBResponse)
-		}
-
-		let id: u32 = row.try_get("message.id").unwrap();
-		let timestamp: DateTime<Utc> = row.try_get("timestamp").unwrap();
-		
-		let room = Room {
-			id: row.try_get("room").unwrap(),
-			roomid: row.try_get("room_id").unwrap(),
-			name: row.try_get("room.name").unwrap(),
-			admin_only_send: row.try_get("admin_only_send").unwrap(),
-			admin_only_view: row.try_get("admin_only_view").unwrap(),
-		};
-		
-		let user = User {
-			id: row.try_get("user.id").unwrap(),
-			userid: row.try_get("user_id").unwrap(),
-			name: row.try_get("user.name").unwrap(),
-			online: row.try_get("online").unwrap(),
-			admin: row.try_get("admin").unwrap(),
-		};
-
-		match type_enum {
-			"text" => {
-				let text: String = row.try_get("msgText").unwrap();
-				Ok(Message {
-					id, timestamp, user, room,
-					data: MessageData::Text(text),
-				})
-			}
-			"attachment" => {
-				todo!()
-			}
-			"reply" => {
-				let text: &str = row.try_get("msgText").unwrap();
-				let referencing_id: u32 = row.try_get("referencingID").unwrap();
-				Ok(Message {
-					id, timestamp, user, room,
-					data: MessageData::Reply(Reply {
-						referencing_id,
-						text: text.to_string(),
-					}),
-				})
-			}
-			"edit" => {
-				let text: &str = row.try_get("msgText").unwrap();
-				let referencing_id: u32 = row.try_get("referencingID").unwrap();
-				Ok(Message {
-					id, timestamp, user, room,
-					data: MessageData::Edit(Edit {
-						referencing_id,
-						text: text.to_string(),
-					}),
-				})
-			}
-			"reaction" => {
-				let emoji: &str = row.try_get("emoji").unwrap();
-				let referencing_id: u32 = row.try_get("referencingID").unwrap();
-				Ok(Message {
-					id, timestamp, user, room,
-					data: MessageData::Reaction(Reaction {
-						referencing_id,
-						emoji: emoji.to_string(),
-					}),
-				})
-			}
-			"redaction" => {
-				let referencing_id: u32 = row.try_get("referencingID").unwrap();
-				Ok(Message {
-					id, timestamp, user, room,
-					data: MessageData::Redaction(Redaction {
-						referencing_id,
-					}),
-				})
-			}
-			_ => { Err(MalformedDBResponse) }
-		}
-	}
 }