chore(monorepo): delta, january, quark

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

@@ -0,0 +1,228 @@
+use bson::{to_document, Bson, Document};
+
+use crate::models::server::{FieldsRole, FieldsServer, PartialRole, PartialServer, Role, Server};
+use crate::r#impl::mongo::IntoDocumentPath;
+use crate::{AbstractServer, Database, Error, Result};
+
+use super::super::MongoDb;
+
+static COL: &str = "servers";
+
+impl MongoDb {
+    pub async fn delete_associated_server_objects(&self, server: &Server) -> Result<()> {
+        // Check if there are any attachments we need to delete.
+        self.delete_bulk_messages(doc! {
+            "channel": {
+                "$in": &server.channels
+            }
+        })
+        .await?;
+
+        // Delete all channels.
+        self.col::<Document>("channels")
+            .delete_many(
+                doc! {
+                    "server": &server.id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "delete_many",
+                with: "channels",
+            })?;
+
+        // Delete any associated objects, e.g. unreads and invites.
+        self.delete_associated_channel_objects(Bson::Document(doc! { "$in": &server.channels }))
+            .await?;
+
+        // Delete members and bans.
+        for with in &["server_members", "server_bans"] {
+            self.col::<Document>(with)
+                .delete_many(
+                    doc! {
+                        "_id.server": &server.id
+                    },
+                    None,
+                )
+                .await
+                .map_err(|_| Error::DatabaseError {
+                    operation: "delete_many",
+                    with,
+                })?;
+        }
+
+        // Update many attachments with parent id.
+        self.delete_many_attachments(doc! {
+            "object_id": &server.id
+        })
+        .await?;
+
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl AbstractServer for MongoDb {
+    async fn fetch_server(&self, id: &str) -> Result<Server> {
+        self.find_one_by_id(COL, id).await
+    }
+
+    async fn fetch_servers<'a>(&self, ids: &'a [String]) -> Result<Vec<Server>> {
+        self.find(
+            COL,
+            doc! {
+                "_id": {
+                    "$in": ids
+                }
+            },
+        )
+        .await
+    }
+
+    async fn insert_server(&self, server: &Server) -> Result<()> {
+        self.insert_one(COL, server).await.map(|_| ())
+    }
+
+    async fn update_server(
+        &self,
+        id: &str,
+        server: &PartialServer,
+        remove: Vec<FieldsServer>,
+    ) -> Result<()> {
+        self.update_one_by_id(
+            COL,
+            id,
+            server,
+            remove.iter().map(|x| x as &dyn IntoDocumentPath).collect(),
+            None,
+        )
+        .await
+        .map(|_| ())
+    }
+
+    async fn delete_server(&self, server: &Server) -> Result<()> {
+        self.delete_associated_server_objects(server).await?;
+        self.delete_one_by_id(COL, &server.id).await.map(|_| ())
+    }
+
+    async fn insert_role(&self, server_id: &str, role_id: &str, role: &Role) -> Result<()> {
+        self.col::<Database>(COL)
+            .update_one(
+                doc! {
+                    "_id": server_id
+                },
+                doc! {
+                    "$set": {
+                        "roles.".to_owned() + role_id: to_document(role)
+                            .map_err(|_| Error::DatabaseError {
+                                operation: "to_document",
+                                with: "role"
+                            })?
+                    }
+                },
+                None,
+            )
+            .await
+            .map(|_| ())
+            .map_err(|_| Error::DatabaseError {
+                operation: "update_one",
+                with: "server",
+            })
+    }
+
+    async fn update_role(
+        &self,
+        server_id: &str,
+        role_id: &str,
+        role: &PartialRole,
+        remove: Vec<FieldsRole>,
+    ) -> Result<()> {
+        self.update_one_by_id(
+            COL,
+            server_id,
+            role,
+            remove.iter().map(|x| x as &dyn IntoDocumentPath).collect(),
+            "roles.".to_owned() + role_id + ".",
+        )
+        .await
+        .map(|_| ())
+    }
+
+    async fn delete_role(&self, server_id: &str, role_id: &str) -> Result<()> {
+        self.col::<Document>("server_members")
+            .update_many(
+                doc! {
+                    "_id.server": server_id
+                },
+                doc! {
+                    "$pull": {
+                        "roles": &role_id
+                    }
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "update_many",
+                with: "server_members",
+            })?;
+
+        self.col::<Document>("channels")
+            .update_one(
+                doc! {
+                    "server": server_id
+                },
+                doc! {
+                    "$unset": {
+                        "role_permissions.".to_owned() + role_id: 1_i32
+                    }
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "update_one",
+                with: "channels",
+            })?;
+
+        self.col::<Document>("servers")
+            .update_one(
+                doc! {
+                    "_id": server_id
+                },
+                doc! {
+                    "$unset": {
+                        "roles.".to_owned() + role_id: 1_i32
+                    }
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "update_one",
+                with: "servers",
+            })
+            .map(|_| ())
+    }
+}
+
+impl IntoDocumentPath for FieldsServer {
+    fn as_path(&self) -> Option<&'static str> {
+        Some(match self {
+            FieldsServer::Banner => "banner",
+            FieldsServer::Categories => "categories",
+            FieldsServer::Description => "description",
+            FieldsServer::Icon => "icon",
+            FieldsServer::SystemMessages => "system_messages",
+        })
+    }
+}
+
+impl IntoDocumentPath for FieldsRole {
+    fn as_path(&self) -> Option<&'static str> {
+        Some(match self {
+            FieldsRole::Colour => "colour",
+        })
+    }
+}

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

@@ -0,0 +1,47 @@
+use crate::models::server_member::MemberCompositeKey;
+use crate::models::ServerBan;
+use crate::{AbstractServerBan, Result};
+
+use super::super::MongoDb;
+
+static COL: &str = "server_bans";
+
+#[async_trait]
+impl AbstractServerBan for MongoDb {
+    async fn fetch_ban(&self, server: &str, user: &str) -> Result<ServerBan> {
+        self.find_one(
+            COL,
+            doc! {
+                "_id.server": server,
+                "_id.user": user
+            },
+        )
+        .await
+    }
+
+    async fn fetch_bans(&self, server: &str) -> Result<Vec<ServerBan>> {
+        self.find(
+            COL,
+            doc! {
+                "_id.server": server
+            },
+        )
+        .await
+    }
+
+    async fn insert_ban(&self, ban: &ServerBan) -> Result<()> {
+        self.insert_one(COL, ban).await.map(|_| ())
+    }
+
+    async fn delete_ban(&self, id: &MemberCompositeKey) -> Result<()> {
+        self.delete_one(
+            COL,
+            doc! {
+                "_id.server": &id.server,
+                "_id.user": &id.user
+            },
+        )
+        .await
+        .map(|_| ())
+    }
+}

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

@@ -0,0 +1,134 @@
+use bson::Document;
+
+use crate::models::server_member::{FieldsMember, Member, MemberCompositeKey, PartialMember};
+use crate::r#impl::mongo::IntoDocumentPath;
+use crate::{AbstractServerMember, Error, Result};
+
+use super::super::MongoDb;
+
+static COL: &str = "server_members";
+
+#[async_trait]
+impl AbstractServerMember for MongoDb {
+    async fn fetch_member(&self, server: &str, user: &str) -> Result<Member> {
+        self.find_one(
+            COL,
+            doc! {
+                "_id.server": server,
+                "_id.user": user
+            },
+        )
+        .await
+    }
+
+    async fn insert_member(&self, member: &Member) -> Result<()> {
+        self.insert_one(COL, member).await.map(|_| ())
+    }
+
+    async fn update_member(
+        &self,
+        id: &MemberCompositeKey,
+        member: &PartialMember,
+        remove: Vec<FieldsMember>,
+    ) -> Result<()> {
+        self.update_one(
+            COL,
+            doc! {
+                "_id.server": &id.server,
+                "_id.user": &id.user
+            },
+            member,
+            remove.iter().map(|x| x as &dyn IntoDocumentPath).collect(),
+            None,
+        )
+        .await
+        .map(|_| ())
+    }
+
+    async fn delete_member(&self, id: &MemberCompositeKey) -> Result<()> {
+        self.delete_one(
+            COL,
+            doc! {
+                "_id.server": &id.server,
+                "_id.user": &id.user
+            },
+        )
+        .await
+        .map(|_| ())
+    }
+
+    async fn fetch_all_members<'a>(&self, server: &str) -> Result<Vec<Member>> {
+        self.find(
+            COL,
+            doc! {
+                "_id.server": server
+            },
+        )
+        .await
+    }
+
+    async fn fetch_all_memberships<'a>(&self, user: &str) -> Result<Vec<Member>> {
+        self.find(
+            COL,
+            doc! {
+                "_id.user": user
+            },
+        )
+        .await
+    }
+
+    async fn fetch_members<'a>(&self, server: &str, ids: &'a [String]) -> Result<Vec<Member>> {
+        self.find(
+            COL,
+            doc! {
+                "_id.server": server,
+                "_id.user": {
+                    "$in": ids
+                }
+            },
+        )
+        .await
+    }
+
+    async fn fetch_member_count(&self, server: &str) -> Result<usize> {
+        self.col::<Document>(COL)
+            .count_documents(
+                doc! {
+                    "_id.server": server
+                },
+                None,
+            )
+            .await
+            .map(|c| c as usize)
+            .map_err(|_| Error::DatabaseError {
+                operation: "count_documents",
+                with: "server_members",
+            })
+    }
+
+    async fn fetch_server_count(&self, user: &str) -> Result<usize> {
+        self.col::<Document>(COL)
+            .count_documents(
+                doc! {
+                    "_id.user": user
+                },
+                None,
+            )
+            .await
+            .map(|c| c as usize)
+            .map_err(|_| Error::DatabaseError {
+                operation: "count_documents",
+                with: "server_members",
+            })
+    }
+}
+
+impl IntoDocumentPath for FieldsMember {
+    fn as_path(&self) -> Option<&'static str> {
+        Some(match self {
+            FieldsMember::Avatar => "avatar",
+            FieldsMember::Nickname => "nickname",
+            FieldsMember::Roles => "roles",
+        })
+    }
+}