chore(monorepo): delta, january, quark

crates/quark/src/impl/dummy/channels/channel.rs

@@ -0,0 +1,90 @@
+use std::collections::HashSet;
+
+use crate::models::channel::{Channel, FieldsChannel, PartialChannel};
+use crate::{AbstractAttachment, AbstractChannel, Error, OverrideField, Result};
+
+use super::super::DummyDb;
+
+#[async_trait]
+impl AbstractChannel for DummyDb {
+    async fn fetch_channel(&self, id: &str) -> Result<Channel> {
+        Ok(Channel::Group {
+            id: id.into(),
+
+            name: "group".into(),
+            owner: "owner".into(),
+            description: None,
+            recipients: vec!["owner".into()],
+
+            icon: Some(
+                self.find_and_use_attachment("dummy", "dummy", "dummy", "dummy")
+                    .await?,
+            ),
+            last_message_id: None,
+
+            permissions: None,
+
+            nsfw: false,
+        })
+    }
+
+    async fn fetch_channels<'a>(&self, _ids: &'a [String]) -> Result<Vec<Channel>> {
+        Ok(vec![self.fetch_channel("sus").await.unwrap()])
+    }
+
+    async fn insert_channel(&self, channel: &Channel) -> Result<()> {
+        info!("Insert {channel:?}");
+        Ok(())
+    }
+
+    async fn update_channel(
+        &self,
+        id: &str,
+        channel: &PartialChannel,
+        remove: Vec<FieldsChannel>,
+    ) -> Result<()> {
+        info!("Update {id} with {channel:?} and remove {remove:?}");
+        Ok(())
+    }
+
+    async fn delete_channel(&self, channel: &Channel) -> Result<()> {
+        info!("Delete {channel:?}");
+        Ok(())
+    }
+
+    async fn find_direct_messages(&self, user_id: &str) -> Result<Vec<Channel>> {
+        Ok(vec![self.fetch_channel(user_id).await?])
+    }
+
+    async fn find_saved_messages_channel(&self, user: &str) -> Result<Channel> {
+        self.fetch_channel(user).await
+    }
+
+    async fn find_direct_message_channel(&self, _user_a: &str, _user_b: &str) -> Result<Channel> {
+        Err(Error::NotFound)
+    }
+
+    async fn add_user_to_group(&self, channel: &str, user: &str) -> Result<()> {
+        info!("Added {user} to {channel}");
+        Ok(())
+    }
+
+    async fn remove_user_from_group(&self, channel: &str, user: &str) -> Result<()> {
+        info!("Removed {user} from {channel}");
+        Ok(())
+    }
+
+    async fn set_channel_role_permission(
+        &self,
+        channel: &str,
+        role: &str,
+        permissions: OverrideField,
+    ) -> Result<()> {
+        info!("Updating permissions for role {role} in {channel} with {permissions:?}");
+        Ok(())
+    }
+
+    async fn check_channels_exist(&self, _channels: &HashSet<String>) -> Result<bool> {
+        Ok(true)
+    }
+}

crates/quark/src/impl/dummy/channels/channel_invite.rs

@@ -0,0 +1,30 @@
+use crate::models::Invite;
+use crate::{AbstractChannelInvite, Result};
+
+use super::super::DummyDb;
+
+#[async_trait]
+impl AbstractChannelInvite for DummyDb {
+    async fn fetch_invite(&self, code: &str) -> Result<Invite> {
+        Ok(Invite::Server {
+            code: code.into(),
+            server: "server".into(),
+            creator: "creator".into(),
+            channel: "channel".into(),
+        })
+    }
+
+    async fn insert_invite(&self, invite: &Invite) -> Result<()> {
+        info!("Insert {invite:?}");
+        Ok(())
+    }
+
+    async fn delete_invite(&self, code: &str) -> Result<()> {
+        info!("Delete {code}");
+        Ok(())
+    }
+
+    async fn fetch_invites_for_server(&self, server: &str) -> Result<Vec<Invite>> {
+        Ok(vec![self.fetch_invite(server).await.unwrap()])
+    }
+}

crates/quark/src/impl/dummy/channels/channel_unread.rs

@@ -0,0 +1,31 @@
+use crate::models::channel_unread::ChannelUnread;
+use crate::{AbstractChannelUnread, Result};
+
+use super::super::DummyDb;
+
+#[async_trait]
+impl AbstractChannelUnread for DummyDb {
+    async fn acknowledge_message(&self, channel: &str, user: &str, message: &str) -> Result<()> {
+        info!("Acknowledged {message} in {channel} for {user}");
+        Ok(())
+    }
+
+    async fn acknowledge_channels(&self, user: &str, channels: &[String]) -> Result<()> {
+        info!("Acknowledged {channels:?} for {user}");
+        Ok(())
+    }
+
+    async fn add_mention_to_unread<'a>(
+        &self,
+        channel: &str,
+        user: &str,
+        ids: &[String],
+    ) -> Result<()> {
+        info!("Added mentions for {user} in {channel}: {ids:?}");
+        Ok(())
+    }
+
+    async fn fetch_unreads(&self, _user: &str) -> Result<Vec<ChannelUnread>> {
+        Ok(vec![])
+    }
+}

crates/quark/src/impl/dummy/channels/message.rs

@@ -0,0 +1,67 @@
+use crate::models::message::{AppendMessage, Message, MessageSort, PartialMessage};
+use crate::{AbstractMessage, Result};
+
+use super::super::DummyDb;
+
+#[async_trait]
+impl AbstractMessage for DummyDb {
+    async fn fetch_message(&self, id: &str) -> Result<Message> {
+        Ok(Message {
+            id: id.into(),
+            channel: "channel".into(),
+            author: "author".into(),
+            content: Some("message content".into()),
+
+            ..Default::default()
+        })
+    }
+
+    async fn insert_message(&self, message: &Message) -> Result<()> {
+        info!("Insert {message:?}");
+        Ok(())
+    }
+
+    async fn update_message(&self, id: &str, message: &PartialMessage) -> Result<()> {
+        info!("Update {id} with {message:?}");
+        Ok(())
+    }
+
+    async fn append_message(&self, id: &str, append: &AppendMessage) -> Result<()> {
+        info!("Append {id} with {append:?}");
+        Ok(())
+    }
+
+    async fn delete_message(&self, id: &str) -> Result<()> {
+        info!("Delete {id}");
+        Ok(())
+    }
+
+    async fn delete_messages(&self, channel: &str, ids: Vec<String>) -> Result<()> {
+        info!("Delete {ids:?} in {channel}");
+        Ok(())
+    }
+
+    async fn fetch_messages(
+        &self,
+        channel: &str,
+        _limit: Option<i64>,
+        _before: Option<String>,
+        _after: Option<String>,
+        _sort: Option<MessageSort>,
+        _nearby: Option<String>,
+    ) -> Result<Vec<Message>> {
+        Ok(vec![self.fetch_message(channel).await.unwrap()])
+    }
+
+    async fn search_messages(
+        &self,
+        channel: &str,
+        _query: &str,
+        _limit: Option<i64>,
+        _before: Option<String>,
+        _after: Option<String>,
+        _sort: MessageSort,
+    ) -> Result<Vec<Message>> {
+        Ok(vec![self.fetch_message(channel).await.unwrap()])
+    }
+}