feat: add /guilds/{uuid}members

Also makes it return user object with the query

src/structs.rs

@@ -473,7 +473,7 @@ impl Guild {
 
         let member_uuid = Uuid::now_v7();
 
-        let member = Member {
+        let member = MemberBuilder {
             uuid: member_uuid,
             nickname: None,
             user_uuid: owner_uuid,
@@ -512,7 +512,7 @@ impl Guild {
     pub async fn create_invite(
         &self,
         conn: &mut Conn,
-        member: &Member,
+        user_uuid: Uuid,
         custom_id: Option<String>,
     ) -> Result<Invite, Error> {
         let invite_id;
@@ -530,7 +530,7 @@ impl Guild {
 
         let invite = Invite {
             id: invite_id,
-            user_uuid: member.user_uuid,
+            user_uuid,
             guild_uuid: self.uuid,
         };
 
@@ -666,11 +666,34 @@ impl Role {
 #[derive(Serialize, Queryable, Selectable, Insertable)]
 #[diesel(table_name = guild_members)]
 #[diesel(check_for_backend(diesel::pg::Pg))]
+pub struct MemberBuilder {
+    pub uuid: Uuid,
+    pub nickname: Option<String>,
+    pub user_uuid: Uuid,
+    pub guild_uuid: Uuid,
+}
+
+impl MemberBuilder {
+    async fn build(&self, data: &Data) -> Result<Member, Error> {
+        let user = User::fetch_one(data, self.user_uuid).await?;
+
+        Ok(Member {
+            uuid: self.uuid,
+            nickname: self.nickname.clone(),
+            user_uuid: self.user_uuid,
+            guild_uuid: self.guild_uuid,
+            user,
+        })
+    }
+}
+
+#[derive(Serialize, Deserialize)]
 pub struct Member {
     pub uuid: Uuid,
     pub nickname: Option<String>,
     pub user_uuid: Uuid,
     pub guild_uuid: Uuid,
+    user: User,
 }
 
 impl Member {
@@ -685,26 +708,61 @@ impl Member {
         Ok(count)
     }
 
-    pub async fn fetch_one(
-        conn: &mut Conn,
-        user_uuid: Uuid,
-        guild_uuid: Uuid,
-    ) -> Result<Self, Error> {
+    pub async fn check_membership(conn: &mut Conn, user_uuid: Uuid, guild_uuid: Uuid) -> Result<(), Error> {
         use guild_members::dsl;
-        let member: Member = dsl::guild_members
+        dsl::guild_members
             .filter(dsl::user_uuid.eq(user_uuid))
             .filter(dsl::guild_uuid.eq(guild_uuid))
-            .select(Member::as_select())
+            .select(MemberBuilder::as_select())
             .get_result(conn)
             .await?;
 
-        Ok(member)
+        Ok(())
     }
 
-    pub async fn new(conn: &mut Conn, user_uuid: Uuid, guild_uuid: Uuid) -> Result<Self, Error> {
+    pub async fn fetch_one(
+        data: &Data,
+        user_uuid: Uuid,
+        guild_uuid: Uuid,
+    ) -> Result<Self, Error> {
+        let mut conn = data.pool.get().await?;
+
+        use guild_members::dsl;
+        let member: MemberBuilder = dsl::guild_members
+            .filter(dsl::user_uuid.eq(user_uuid))
+            .filter(dsl::guild_uuid.eq(guild_uuid))
+            .select(MemberBuilder::as_select())
+            .get_result(&mut conn)
+            .await?;
+
+        member.build(data).await
+    }
+
+    pub async fn fetch_all(data: &Data, guild_uuid: Uuid) -> Result<Vec<Self>, Error> {
+        let mut conn = data.pool.get().await?;
+
+        use guild_members::dsl;
+        let member_builders: Vec<MemberBuilder> = load_or_empty(
+            dsl::guild_members
+                .filter(dsl::guild_uuid.eq(guild_uuid))
+                .select(MemberBuilder::as_select())
+                .load(&mut conn)
+                .await
+        )?;
+
+        let member_futures = member_builders.iter().map(async move |m| {
+            m.build(data).await
+        });
+
+        futures::future::try_join_all(member_futures).await
+    }
+
+    pub async fn new(data: &Data, user_uuid: Uuid, guild_uuid: Uuid) -> Result<Self, Error> {
+        let mut conn = data.pool.get().await?;
+
         let member_uuid = Uuid::now_v7();
 
-        let member = Member {
+        let member = MemberBuilder {
             uuid: member_uuid,
             guild_uuid,
             user_uuid,
@@ -712,16 +770,11 @@ impl Member {
         };
 
         insert_into(guild_members::table)
-            .values(member)
-            .execute(conn)
+            .values(&member)
+            .execute(&mut conn)
             .await?;
 
-        Ok(Self {
-            uuid: member_uuid,
-            nickname: None,
-            user_uuid,
-            guild_uuid,
-        })
+        member.build(data).await
     }
 }
 
@@ -856,14 +909,28 @@ impl Me {
         Ok(me)
     }
 
-    pub async fn fetch_memberships(&self, conn: &mut Conn) -> Result<Vec<Member>, Error> {
+    pub async fn fetch_memberships(&self, data: &Data) -> Result<Vec<Member>, Error> {
+        let mut conn = data.pool.get().await?;
+
         use guild_members::dsl;
-        let memberships: Vec<Member> = dsl::guild_members
+        let member_builders: Vec<MemberBuilder> = dsl::guild_members
             .filter(dsl::user_uuid.eq(self.uuid))
-            .select(Member::as_select())
-            .load(conn)
+            .select(MemberBuilder::as_select())
+            .load(&mut conn)
             .await?;
 
+        let user = User::fetch_one(data, self.uuid).await?;
+
+        let memberships = member_builders.iter().map(|m| {
+            Member {
+                uuid: m.uuid,
+                nickname: m.nickname.clone(),
+                user_uuid: m.user_uuid,
+                guild_uuid: m.guild_uuid,
+                user: user.clone(),
+            }
+        }).collect();
+
         Ok(memberships)
     }