feat: member fetching with roles (#299)

crates/quark/src/impl/dummy/servers/server_member.rs

@@ -1,4 +1,6 @@
-use crate::models::server_member::{FieldsMember, Member, MemberCompositeKey, PartialMember};
+use crate::models::server_member::{
+    FieldsMember, Member, MemberCompositeKey, MemberWithRoles, PartialMember,
+};
 use crate::{AbstractServerMember, Result};
 
 use super::super::DummyDb;
@@ -8,6 +10,9 @@ impl AbstractServerMember for DummyDb {
     async fn fetch_member(&self, server: &str, user: &str) -> Result<Member> {
         Ok(Member::new(server.into(), user.into()))
     }
+    async fn fetch_member_with_roles(&self, server: &str, user: &str) -> Result<MemberWithRoles> {
+        Ok(MemberWithRoles::new(server.into(), user.into()))
+    }
 
     async fn insert_member(&self, member: &Member) -> Result<()> {
         info!("Create {member:?}");

crates/quark/src/impl/generic/servers/server_member.rs

@@ -1,9 +1,12 @@
+use std::collections::HashMap;
+
 use iso8601_timestamp::Timestamp;
 
 use crate::{
     events::client::EventV1,
     models::{
-        server_member::{FieldsMember, MemberCompositeKey, PartialMember},
+        server::Role,
+        server_member::{FieldsMember, MemberCompositeKey, MemberWithRoles, PartialMember},
         Member, Server,
     },
     Database, Result,
@@ -81,4 +84,30 @@ impl Member {
             FieldsMember::Timeout => self.timeout = None,
         }
     }
+
+    pub fn with_roles(&self, roles: HashMap<String, Role>) -> MemberWithRoles {
+        MemberWithRoles {
+            id: self.id.clone(),
+            joined_at: self.joined_at,
+            nickname: self.nickname.clone(),
+            avatar: self.avatar.clone(),
+            roles,
+            timeout: self.timeout,
+        }
+    }
+}
+impl MemberWithRoles {
+    pub fn new(server_id: String, user_id: String) -> Self {
+        Self {
+            id: MemberCompositeKey {
+                server: server_id,
+                user: user_id,
+            },
+            joined_at: Timestamp::now_utc(),
+            nickname: None,
+            avatar: None,
+            roles: HashMap::new(),
+            timeout: None,
+        }
+    }
 }

crates/quark/src/impl/mongo/servers/server_member.rs

@@ -1,10 +1,10 @@
 use bson::Document;
 
+use super::super::MongoDb;
+use crate::models::server_member::MemberWithRoles;
 use crate::models::server_member::{FieldsMember, Member, MemberCompositeKey, PartialMember};
 use crate::r#impl::mongo::IntoDocumentPath;
-use crate::{AbstractServerMember, Error, Result};
-
-use super::super::MongoDb;
+use crate::{AbstractServer, AbstractServerMember, Error, Result};
 
 static COL: &str = "server_members";
 
@@ -21,6 +21,13 @@ impl AbstractServerMember for MongoDb {
         .await
     }
 
+    async fn fetch_member_with_roles(&self, server: &str, user: &str) -> Result<MemberWithRoles> {
+        Ok(self
+            .fetch_member(server, user)
+            .await?
+            .with_roles(self.fetch_server(server).await?.roles))
+    }
+
     async fn insert_member(&self, member: &Member) -> Result<()> {
         self.insert_one(COL, member).await.map(|_| ())
     }

crates/quark/src/models/servers/server_member.rs

@@ -1,8 +1,13 @@
+use std::collections::HashMap;
+
 use iso8601_timestamp::Timestamp;
+
 use serde::{Deserialize, Serialize};
 
 use crate::models::attachment::File;
 
+use super::server::Role;
+
 /// Composite primary key consisting of server and user id
 #[derive(Serialize, Deserialize, JsonSchema, Debug, Clone, Default)]
 pub struct MemberCompositeKey {
@@ -41,6 +46,50 @@ pub struct Member {
     pub timeout: Option<Timestamp>,
 }
 
+/// Representation of a member of a server on Revolt With Role Data
+#[derive(Serialize, Deserialize, JsonSchema, Debug, Clone, OptionalStruct)]
+#[optional_derive(Serialize, Deserialize, JsonSchema, Debug, Default, Clone)]
+#[opt_skip_serializing_none]
+#[opt_some_priority]
+pub struct MemberWithRoles {
+    /// Unique member id
+    #[serde(rename = "_id")]
+    pub id: MemberCompositeKey,
+
+    /// Time at which this user joined the server
+    pub joined_at: Timestamp,
+
+    /// Member's nickname
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub nickname: Option<String>,
+    /// Avatar attachment
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub avatar: Option<File>,
+
+    /// Member's roles
+    #[serde(skip_serializing_if = "HashMap::is_empty", default)]
+    pub roles: HashMap<String, Role>,
+    /// Timestamp this member is timed out until
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub timeout: Option<Timestamp>,
+}
+
+#[derive(Serialize, Deserialize, JsonSchema, Debug, Clone)]
+pub enum MemberResponse {
+    Members(Member),
+    MembersWithRoles(MemberWithRoles),
+}
+
+impl From<Member> for MemberResponse {
+    fn from(value: Member) -> Self {
+        Self::Members(value)
+    }
+}
+impl From<MemberWithRoles> for MemberResponse {
+    fn from(value: MemberWithRoles) -> Self {
+        Self::MembersWithRoles(value)
+    }
+}
 /// Optional fields on server member object
 #[derive(Serialize, Deserialize, JsonSchema, Debug, PartialEq, Eq, Clone)]
 pub enum FieldsMember {

crates/quark/src/traits/servers/server_member.rs

@@ -1,4 +1,6 @@
-use crate::models::server_member::{FieldsMember, Member, MemberCompositeKey, PartialMember};
+use crate::models::server_member::{
+    FieldsMember, Member, MemberCompositeKey, MemberWithRoles, PartialMember,
+};
 use crate::Result;
 
 #[async_trait]
@@ -6,6 +8,8 @@ pub trait AbstractServerMember: Sync + Send {
     /// Fetch a server member by their id
     async fn fetch_member(&self, server: &str, user: &str) -> Result<Member>;
 
+    async fn fetch_member_with_roles(&self, server: &str, user: &str) -> Result<MemberWithRoles>;
+
     /// Insert a new server member into the database
     async fn insert_member(&self, member: &Member) -> Result<()>;
 

crates/quark/src/util/ref.rs

@@ -5,9 +5,8 @@ use schemars::schema::{InstanceType, Schema, SchemaObject, SingleOrVec};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
-use crate::models::{
-    Channel, Emoji, Invite, Member, Message, Report, Server, ServerBan, User,
-};
+use crate::models::server_member::MemberWithRoles;
+use crate::models::{Channel, Emoji, Invite, Member, Message, Report, Server, ServerBan, User};
 use crate::{Database, Error, Result};
 
 /// Reference to some object in the database
@@ -66,6 +65,14 @@ impl Ref {
         db.fetch_member(server, &self.id).await
     }
 
+    pub async fn as_member_with_roles(
+        &self,
+        db: &Database,
+        server: &str,
+    ) -> Result<MemberWithRoles> {
+        db.fetch_member_with_roles(server, &self.id).await
+    }
+
     /// Fetch ban from Ref
     pub async fn as_ban(&self, db: &Database, server: &str) -> Result<ServerBan> {
         db.fetch_ban(server, &self.id).await