feat: channels (merge #3 from channels)

Replaces the current `context` system in favor of any-sized `channels`

Author: SrGaabriel

README.md

@@ -11,7 +11,7 @@ The main technologies implemented in this project are:
 * **Websockets:** powered by `axum`
 * **Rest API:** powered by `axum`
 * **PostgreSQL:** powered by `diesel`
-* **Protobuf:** powered by `prost` and `protobuf.js`
+* **Protobuf _(soon to be dropped)_:** powered by `prost` and `protobuf.js`
 * **Serialization:** powered by `serde`
 * **Authentication:** powered by `jwt`
 * **Hashing:** powered by `argon2`

server/macros/src/lib.rs

@@ -22,27 +22,28 @@ pub fn packet(args: TokenStream, item: TokenStream) -> TokenStream {
     let struct_item = parse_macro_input!(item as syn::ItemStruct);
     let ident = struct_item.ident.clone();
     let expanded = quote! {
+        #[derive(Clone, PartialEq, serde::Serialize, serde::Deserialize)]
         #struct_item
 
-        impl PacketStaticId for #ident {
+        impl crate::server::messages::PacketStaticId for #ident {
             fn get_id() -> i32 {
                 #id
             }
         }
 
-        impl Packet for #ident {
+        impl crate::server::messages::Packet for #ident {
             fn get_id(&self) -> i32 {
                 #id
             }
 
             fn encode_data(&self) -> Vec<u8> {
                 let mut buffer = Vec::new();
-                prost::Message::encode(self, &mut buffer).unwrap();
+                serde_json::to_writer(&mut buffer, self).expect("Failed to encode packet data");
                 buffer
             }
 
-            fn decode_data(buffer: &[u8]) -> Result<Self, prost::DecodeError> {
-                prost::Message::decode(buffer)
+            fn decode_data(buffer: &[u8]) -> Result<Self, serde_json::Error> {
+                serde_json::from_slice(buffer)
             }
         }
 

server/src/entity/mod.rs

@@ -1,5 +1,5 @@
 mod server;
-mod entity;
+mod schema;
 mod database;
 mod util;
 
@@ -28,7 +28,8 @@ use tower_http::auth::{AsyncRequireAuthorizationLayer, AsyncAuthorizeRequest};
 use tower_http::cors::CorsLayer;
 use tracing::Subscriber;
 use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
-use crate::entity::user::User;
+use crate::schema::ctes::select_messages_from;
+use crate::schema::users::User;
 use crate::server::gateway::Gateway;
 use crate::server::messages::Packet;
 use crate::server::rest::middlewares::{authorize, IrisAuth};
@@ -60,22 +61,24 @@ async fn main() {
     tracing_subscriber::registry()
         .with(
             tracing_subscriber::EnvFilter::try_from_default_env()
-                .unwrap_or_else(|_| "example_websockets=debug,tower_http=debug                                      ,diesel=debug".into()),
+                .unwrap_or_else(|_| "example_websockets=debug,tower_http=info,diesel=debug".into()),
         )
         .with(tracing_subscriber::fmt::layer())
         .init();
 
     let app = Router::new()
         .route("/ws", get(server::subscribe_chat_handshake))
+        .route("/api/search", post(server::rest::search::search))
         .route("/api/users/@me", get(server::rest::user::get_self))
         .route("/api/contacts/@me", get(server::rest::contacts::get_contacts))
         .route("/api/contacts/:contact_id", get(server::rest::contacts::get_contact))
-        .route("/api/channels/:context_id/messages", post(server::rest::messages::create_message))
-        .route("/api/channels/:context_id/messages", get(server::rest::messages::get_messages))
-        .route("/api/channels/:context_id/messages/:message_id", put(server::rest::messages::edit_message))
-        .route("/api/channels/:context_id/messages/:message_id", delete(server::rest::messages::delete_message))
-        .route("/api/channels/:context_id/messages/:message_id/reactions", post(server::rest::reactions::add_reaction))
-        .route("/api/channels/:context_id/messages/:message_id/reactions/:reaction_id", delete(server::rest::reactions::remove_reaction))
+        .route("/api/contacts/:contact_id/chat", post(server::rest::contacts::chat))
+        .route("/api/channels/:channel_id/messages", post(server::rest::messages::create_message))
+        .route("/api/channels/:channel_id/messages", get(server::rest::messages::get_messages))
+        .route("/api/channels/:channel_id/messages/:message_id", put(server::rest::messages::edit_message))
+        .route("/api/channels/:channel_id/messages/:message_id", delete(server::rest::messages::delete_message))
+        .route("/api/channels/:channel_id/messages/:message_id/reactions", post(server::rest::reactions::add_reaction))
+        .route("/api/channels/:channel_id/messages/:message_id/reactions/:reaction_id", delete(server::rest::reactions::remove_reaction))
         .route_layer(
             middleware::from_fn(authorize)
         )

server/src/main.rs

@@ -0,0 +1,43 @@
+use diesel::sql_types::BigInt;
+use diesel::{Identifiable, Queryable, QueryableByName, Selectable, table};
+use crate::schema::users::users;
+
+#[derive(Queryable, Identifiable)]
+#[table_name = "channels"]
+#[primary_key(channel_id)]
+pub struct Channel {
+    pub channel_id: i64,
+    pub channel_type: i32,
+}
+
+#[derive(Queryable, Identifiable, Selectable)]
+#[table_name = "channel_members"]
+#[primary_key(channel_id, user_id)]
+pub struct ChannelMember {
+    pub channel_id: i64,
+    pub user_id: i64
+}
+
+table! {
+    channels (channel_id) {
+        channel_id -> BigInt,
+        channel_type -> Integer,
+    }
+}
+
+table! {
+    channel_members (channel_id, user_id) {
+        channel_id -> BigInt,
+        user_id -> BigInt,
+        joined_at -> Timestamp,
+    }
+}
+
+diesel::joinable!(channel_members -> channels (channel_id));
+diesel::joinable!(channel_members -> users (user_id));
+
+#[derive(Queryable, QueryableByName)]
+pub struct PrivateChannelQuery {
+    #[sql_type = "BigInt"]
+    pub channel_id: i64
+}

server/src/schema/channels.rs

@@ -0,0 +1,60 @@
+// global variable
+pub const REACTIONS_WITH_ME: &str = r#"
+WITH reactions_with_me AS (
+    SELECT
+        reactions.reaction_id,
+        reactions.message_id,
+        reactions.emoji,
+        reactions.reaction_count,
+        bool_or(reaction_users.user_id = $1) AS me
+    FROM
+        reactions
+    LEFT JOIN reaction_users ON reactions.reaction_id = reaction_users.reaction_id
+    GROUP BY
+        reactions.reaction_id, reactions.message_id, reactions.emoji, reactions.reaction_count
+)
+"#;
+
+pub const SELECT_MESSAGES: &str = r#"
+SELECT
+    qm.message_id,
+    qm.user_id,
+    qm.content,
+    qm.channel_id,
+    qm.reception_status,
+    qm.edited,
+    qm.reply_to,
+    u.name AS author_name,
+    u.username AS author_username,
+    COALESCE(
+        json_agg(
+            json_build_object(
+                'reaction_id', reactions_with_me.reaction_id,
+                'count', reactions_with_me.reaction_count,
+                'me', reactions_with_me.me,
+                'emoji', reactions_with_me.emoji
+            )
+        ) FILTER (WHERE reactions_with_me.message_id IS NOT NULL AND reactions_with_me.reaction_count > 0),
+        '[]'
+    ) AS reactions
+"#;
+
+pub fn select_messages_from(
+    from: &str
+) -> String {
+    let string = format!(r#"
+{},
+querying_messages AS (
+{}
+)
+{}
+FROM querying_messages qm
+LEFT JOIN reactions_with_me ON reactions_with_me.message_id = qm.message_id
+LEFT JOIN users u ON qm.user_id = u.user_id
+GROUP BY
+    qm.message_id, qm.user_id, qm.content, qm.channel_id, qm.reception_status, qm.edited, qm.reply_to, u.name, u.username
+ORDER BY
+    qm.message_id DESC
+"#, REACTIONS_WITH_ME, from, SELECT_MESSAGES);
+    return string;
+}

server/src/schema/ctes.rs

@@ -1,21 +1,19 @@
 use diesel::pg::Pg;
-use diesel::sql_types::{Nullable, Text, BigInt, SmallInt};
+use diesel::sql_types::{Nullable, Text, BigInt, SmallInt, VarChar};
 use diesel::{allow_tables_to_appear_in_same_query, Associations, Identifiable, Insertable, Queryable, QueryableByName, Selectable};
-use crate::entity::user::users;
+use crate::schema::users::users;
 use crate::User;
 use diesel::sql_types::Bool;
 
-pub type ContextType = i16;
-
 #[derive(Queryable, Identifiable, Associations, Selectable, Insertable)]
 #[diesel(belongs_to(User))]
 #[diesel(table_name = messages)]
+#[primary_key(message_id)]
 pub struct Message {
-    pub id: i64,
+    pub message_id: i64,
     pub user_id: i64,
     pub content: String,
-    pub context: i64,
-    pub context_type: ContextType,
+    pub channel_id: i64,
     pub reception_status: i16,
     pub edited: bool,
     pub reply_to: Option<i64>
@@ -24,12 +22,11 @@ pub struct Message {
 diesel::table! {
     use diesel::sql_types::*;
 
-    messages (id) {
-        id -> BigInt,
+    messages (message_id) {
+        message_id -> BigInt,
         user_id -> BigInt,
         content -> Text,
-        context -> BigInt,
-        context_type -> SmallInt,
+        channel_id -> BigInt,
         reception_status -> SmallInt,
         edited -> Bool,
         reply_to -> Nullable<BigInt>
@@ -38,15 +35,12 @@ diesel::table! {
 
 diesel::joinable!(messages -> users (user_id));
 
-allow_tables_to_appear_in_same_query!(
-    users,
-    messages,
-);
-
 #[derive(QueryableByName, Queryable, Debug)]
-pub struct ContactWithLastMessage {
+pub struct ContactWithChannel {
+    #[sql_type = "BigInt"]
+    pub user_id: i64,
     #[sql_type = "BigInt"]
-    pub id: i64,
+    pub channel_id: i64,
     #[sql_type = "Text"]
     pub name: String,
     #[sql_type = "Text"]
@@ -58,25 +52,29 @@ pub struct ContactWithLastMessage {
     #[sql_type = "Nullable<SmallInt>"]
     pub reception_status: Option<i16>,
     #[sql_type = "BigInt"]
-    pub reception_status_count: i64
+    pub unread_reception_count: i64
 }
 
 #[derive(QueryableByName, Queryable, Debug)]
 pub struct CompleteMessage {
     #[sql_type = "BigInt"]
-    pub id: i64,
+    pub message_id: i64,
     #[sql_type = "BigInt"]
     pub user_id: i64,
     #[sql_type = "Text"]
     pub content: String,
     #[sql_type = "BigInt"]
-    pub context: i64,
+    pub channel_id: i64,
     #[sql_type = "SmallInt"]
     pub reception_status: i16,
     #[sql_type = "Bool"]
     pub edited: bool,
     #[sql_type = "Nullable<BigInt>"]
     pub reply_to: Option<i64>,
+    #[sql_type = "VarChar"]
+    pub author_name: String,
+    #[sql_type = "VarChar"]
+    pub author_username: String,
     #[sql_type = "Text"]
     pub reactions: String
 }

server/src/entity/message.rs renamed to server/src/schema/messages.rs

@@ -0,0 +1,25 @@
+
+use diesel::allow_tables_to_appear_in_same_query;
+use serde::Serialize;
+
+pub mod users;
+pub mod messages;
+pub mod reactions;
+pub mod channels;
+pub mod ctes;
+
+use crate::schema::users::users as users_table;
+use crate::schema::channels::channels as channels_table;
+use crate::schema::channels::channel_members as channel_members_table;
+use crate::schema::messages::messages as messages_table;
+use crate::schema::reactions::reactions as reactions_table;
+use crate::schema::reactions::reaction_users as reaction_users_table;
+
+allow_tables_to_appear_in_same_query!(
+    users_table,
+    channels_table,
+    channel_members_table,
+    messages_table,
+    reactions_table,
+    reaction_users_table
+);

server/src/schema/mod.rs

@@ -1,6 +1,6 @@
 use diesel::{allow_tables_to_appear_in_same_query, Identifiable, Insertable, Queryable, Selectable};
-use crate::entity::message::messages;
-use crate::entity::user::users;
+use crate::schema::messages::messages;
+use crate::schema::users::users;
 use diesel::sql_types::{BigInt, Text, Varchar, Integer, Bool, Serial};
 use diesel::prelude::*;
 use serde::{Deserialize, Serialize};
@@ -49,12 +49,6 @@ diesel::joinable!(reactions -> messages (message_id));
 diesel::joinable!(reaction_users -> reactions (reaction_id));
 diesel::joinable!(reaction_users -> users (user_id));
 
-allow_tables_to_appear_in_same_query!(
-    messages,
-    reactions,
-    reaction_users,
-);
-
 #[derive(Insertable)]
 #[diesel(table_name = reactions)]
 pub struct ReactionInsert {
@@ -69,7 +63,7 @@ pub struct ReactionUserInsert {
     pub user_id: i64
 }
 
-#[derive(Debug, Serialize, Deserialize, QueryableByName)]
+#[derive(Debug, Serialize, Deserialize, QueryableByName, Clone, PartialEq)]
 pub struct ReactionSummary {
     #[sql_type = "Text"]
     pub emoji: String,

server/src/entity/reactions.rs renamed to server/src/schema/reactions.rs

@@ -2,18 +2,18 @@ use diesel::{Identifiable, Insertable, Queryable, Selectable};
 
 #[derive(Debug, Identifiable, Queryable, Selectable, Insertable, Clone)]
 #[diesel(table_name = users)]
-#[diesel(primary_key(id))]
+#[diesel(primary_key(user_id))]
 pub struct User {
-    pub id: i64,
+    pub user_id: i64,
     pub name: String,
     pub username: String,
     pub password: String,
     pub email: String,
 }
 
 diesel::table! {
-    users (id) {
-        id -> BigInt,
+    users (user_id) {
+        user_id -> BigInt,
         name -> Varchar,
         username -> Varchar,
         email -> Varchar,