chore(monorepo): delta, january, quark

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

@@ -0,0 +1,78 @@
+use crate::models::server::{FieldsRole, FieldsServer, PartialRole, PartialServer, Role, Server};
+use crate::{AbstractServer, Result, DEFAULT_PERMISSION_SERVER};
+
+use super::super::DummyDb;
+
+#[async_trait]
+impl AbstractServer for DummyDb {
+    async fn fetch_server(&self, id: &str) -> Result<Server> {
+        Ok(Server {
+            id: id.into(),
+            owner: "owner".into(),
+
+            name: "server".into(),
+            description: Some("server description".into()),
+
+            channels: vec!["channel".into()],
+            categories: None,
+            system_messages: None,
+
+            roles: std::collections::HashMap::new(),
+            default_permissions: *DEFAULT_PERMISSION_SERVER as i64,
+
+            icon: None,
+            banner: None,
+
+            flags: None,
+
+            nsfw: false,
+            analytics: true,
+            discoverable: true,
+        })
+    }
+
+    async fn fetch_servers<'a>(&self, _ids: &'a [String]) -> Result<Vec<Server>> {
+        Ok(vec![self.fetch_server("sus").await.unwrap()])
+    }
+
+    async fn insert_server(&self, server: &Server) -> Result<()> {
+        info!("Insert {server:?}");
+        Ok(())
+    }
+
+    async fn update_server(
+        &self,
+        id: &str,
+        server: &PartialServer,
+        remove: Vec<FieldsServer>,
+    ) -> Result<()> {
+        info!("Update {id} with {server:?} and remove {remove:?}");
+        Ok(())
+    }
+
+    async fn delete_server(&self, server: &Server) -> Result<()> {
+        info!("Delete {server:?}");
+        Ok(())
+    }
+
+    async fn insert_role(&self, server_id: &str, role_id: &str, role: &Role) -> Result<()> {
+        info!("Create {role:?} on {server_id} as {role_id}");
+        Ok(())
+    }
+
+    async fn update_role(
+        &self,
+        server_id: &str,
+        role_id: &str,
+        role: &PartialRole,
+        remove: Vec<FieldsRole>,
+    ) -> Result<()> {
+        info!("Update {role_id} on {server_id} with {role:?} and remove {remove:?}");
+        Ok(())
+    }
+
+    async fn delete_role(&self, server_id: &str, role_id: &str) -> Result<()> {
+        info!("Delete {role_id} on {server_id}");
+        Ok(())
+    }
+}

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

@@ -0,0 +1,32 @@
+use crate::models::server_member::MemberCompositeKey;
+use crate::models::ServerBan;
+use crate::{AbstractServerBan, Result};
+
+use super::super::DummyDb;
+
+#[async_trait]
+impl AbstractServerBan for DummyDb {
+    async fn fetch_ban(&self, server: &str, user: &str) -> Result<ServerBan> {
+        Ok(ServerBan {
+            id: MemberCompositeKey {
+                server: server.into(),
+                user: user.into(),
+            },
+            reason: Some("ban reason".into()),
+        })
+    }
+
+    async fn fetch_bans(&self, server: &str) -> Result<Vec<ServerBan>> {
+        Ok(vec![self.fetch_ban(server, "user").await.unwrap()])
+    }
+
+    async fn insert_ban(&self, ban: &ServerBan) -> Result<()> {
+        info!("Insert {ban:?}");
+        Ok(())
+    }
+
+    async fn delete_ban(&self, id: &MemberCompositeKey) -> Result<()> {
+        info!("Delete {id:?}");
+        Ok(())
+    }
+}

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

@@ -0,0 +1,59 @@
+use crate::models::server_member::{FieldsMember, Member, MemberCompositeKey, PartialMember};
+use crate::{AbstractServerMember, Result};
+
+use super::super::DummyDb;
+
+#[async_trait]
+impl AbstractServerMember for DummyDb {
+    async fn fetch_member(&self, server: &str, user: &str) -> Result<Member> {
+        Ok(Member {
+            id: MemberCompositeKey {
+                server: server.into(),
+                user: user.into(),
+            },
+            nickname: None,
+            avatar: None,
+            roles: None,
+        })
+    }
+
+    async fn insert_member(&self, member: &Member) -> Result<()> {
+        info!("Create {member:?}");
+        Ok(())
+    }
+
+    async fn update_member(
+        &self,
+        id: &MemberCompositeKey,
+        member: &PartialMember,
+        remove: Vec<FieldsMember>,
+    ) -> Result<()> {
+        info!("Update {id:?} with {member:?} and remove {remove:?}");
+        Ok(())
+    }
+
+    async fn delete_member(&self, id: &MemberCompositeKey) -> Result<()> {
+        info!("Delete {id:?}");
+        Ok(())
+    }
+
+    async fn fetch_all_members<'a>(&self, server: &str) -> Result<Vec<Member>> {
+        Ok(vec![self.fetch_member(server, "member").await.unwrap()])
+    }
+
+    async fn fetch_all_memberships<'a>(&self, user: &str) -> Result<Vec<Member>> {
+        Ok(vec![self.fetch_member("server", user).await.unwrap()])
+    }
+
+    async fn fetch_members<'a>(&self, server: &str, _ids: &'a [String]) -> Result<Vec<Member>> {
+        Ok(vec![self.fetch_member(server, "member").await.unwrap()])
+    }
+
+    async fn fetch_member_count(&self, _server: &str) -> Result<usize> {
+        Ok(100)
+    }
+
+    async fn fetch_server_count(&self, _user: &str) -> Result<usize> {
+        Ok(5)
+    }
+}