run.sh

-#!/bin/bash
-# Split at \n instead of space.
-# https://unix.stackexchange.com/a/39482
-set -f
-IFS='
-'
-
-input=($(egrep -v '^#' .env))
-prepended=(${input[@]/#/-e\"})
-variables=${prepended[@]/%/\"}
-
-unset IFS
-set +f
-
-echo "Running Revolt in detached mode."
-docker run \
-    -d \
-    --name revolt \
-    -p 8000:8000 \
-    -p 9000:9000 \
-    $variables \
-    revolt

set_version.sh

+#!/bin/bash
+export version=0.5.1-alpha.21
+echo "pub const VERSION: &str = \"${version}\";" > src/version.rs

src/bin/dummy.rs

+fn main() {}

src/database/channel.rs

-use super::get_collection;
-
-use lru::LruCache;
-use mongodb::bson::{doc, from_bson, Bson};
-use rocket::http::RawStr;
-use rocket::request::FromParam;
-use rocket_contrib::json::JsonValue;
-use serde::{Deserialize, Serialize};
-use std::sync::{Arc, Mutex};
-use rocket::futures::StreamExt;
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct LastMessage {
-    // message id
-    id: String,
-    // author's id
-    user_id: String,
-    // truncated content with author's name prepended (for GDM / GUILD)
-    short_content: String,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct Channel {
-    #[serde(rename = "_id")]
-    pub id: String,
-    #[serde(rename = "type")]
-    pub channel_type: u8,
-
-    // DM: whether the DM is active
-    pub active: Option<bool>,
-    // DM + GDM: last message in channel
-    pub last_message: Option<LastMessage>,
-    // DM + GDM: recipients for channel
-    pub recipients: Option<Vec<String>>,
-    // GDM: owner of group
-    pub owner: Option<String>,
-    // GUILD: channel parent
-    pub guild: Option<String>,
-    // GUILD + GDM: channel name
-    pub name: Option<String>,
-    // GUILD + GDM: channel description
-    pub description: Option<String>,
-}
-
-impl Channel {
-    pub fn serialise(self) -> JsonValue {
-        match self.channel_type {
-            0 => json!({
-                "id": self.id,
-                "type": self.channel_type,
-                "last_message": self.last_message,
-                "recipients": self.recipients,
-            }),
-            1 => json!({
-                "id": self.id,
-                "type": self.channel_type,
-                "last_message": self.last_message,
-                "recipients": self.recipients,
-                "name": self.name,
-                "owner": self.owner,
-                "description": self.description,
-            }),
-            2 => json!({
-                "id": self.id,
-                "type": self.channel_type,
-                "guild": self.guild,
-                "name": self.name,
-                "description": self.description,
-            }),
-            _ => unreachable!(),
-        }
-    }
-}
-
-lazy_static! {
-    static ref CACHE: Arc<Mutex<LruCache<String, Channel>>> =
-        Arc::new(Mutex::new(LruCache::new(4_000_000)));
-}
-
-pub async fn fetch_channel(id: &str) -> Result<Option<Channel>, String> {
-    {
-        if let Ok(mut cache) = CACHE.lock() {
-            let existing = cache.get(&id.to_string());
-
-            if let Some(channel) = existing {
-                return Ok(Some((*channel).clone()));
-            }
-        } else {
-            return Err("Failed to lock cache.".to_string());
-        }
-    }
-
-    let col = get_collection("channels");
-    if let Ok(result) = col.find_one(doc! { "_id": id }, None).await {
-        if let Some(doc) = result {
-            if let Ok(channel) = from_bson(Bson::Document(doc)) as Result<Channel, _> {
-                let mut cache = CACHE.lock().unwrap();
-                cache.put(id.to_string(), channel.clone());
-
-                Ok(Some(channel))
-            } else {
-                Err("Failed to deserialize channel!".to_string())
-            }
-        } else {
-            Ok(None)
-        }
-    } else {
-        Err("Failed to fetch channel from database.".to_string())
-    }
-}
-
-pub async fn fetch_channels(ids: &Vec<String>) -> Result<Vec<Channel>, String> {
-    let mut missing = vec![];
-    let mut channels = vec![];
-
-    {
-        if let Ok(mut cache) = CACHE.lock() {
-            for id in ids {
-                let existing = cache.get(id);
-
-                if let Some(channel) = existing {
-                    channels.push((*channel).clone());
-                } else {
-                    missing.push(id);
-                }
-            }
-        } else {
-            return Err("Failed to lock cache.".to_string());
-        }
-    }
-
-    if missing.len() == 0 {
-        return Ok(channels);
-    }
-
-    let col = get_collection("channels");
-    if let Ok(mut result) = col.find(doc! { "_id": { "$in": missing } }, None).await {
-        while let Some(item) = result.next().await {
-            let mut cache = CACHE.lock().unwrap();
-            if let Ok(doc) = item {
-                if let Ok(channel) = from_bson(Bson::Document(doc)) as Result<Channel, _> {
-                    cache.put(channel.id.clone(), channel.clone());
-                    channels.push(channel);
-                } else {
-                    return Err("Failed to deserialize channel!".to_string());
-                }
-            } else {
-                return Err("Failed to fetch channel.".to_string());
-            }
-        }
-
-        Ok(channels)
-    } else {
-        Err("Failed to fetch channel from database.".to_string())
-    }
-}
-
-impl<'r> FromParam<'r> for Channel {
-    type Error = &'r RawStr;
-
-    fn from_param(param: &'r RawStr) -> Result<Self, Self::Error> {
-        Err(param)
-        /*if let Ok(result) = fetch_channel(param).await {
-            if let Some(channel) = result {
-                Ok(channel)
-            } else {
-                Err(param)
-            }
-        } else {
-            Err(param)
-        }*/
-    }
-}
-
-/*use crate::notifications::events::Notification;
-
-pub fn process_event(event: &Notification) {
-    match event {
-        Notification::group_user_join(ev) => {
-            let mut cache = CACHE.lock().unwrap();
-            if let Some(channel) = cache.peek_mut(&ev.id) {
-                channel.recipients.as_mut().unwrap().push(ev.user.clone());
-            }
-        }
-        Notification::group_user_leave(ev) => {
-            let mut cache = CACHE.lock().unwrap();
-            if let Some(channel) = cache.peek_mut(&ev.id) {
-                let recipients = channel.recipients.as_mut().unwrap();
-                if let Some(pos) = recipients.iter().position(|x| *x == ev.user) {
-                    recipients.remove(pos);
-                }
-            }
-        }
-        Notification::guild_channel_create(ev) => {
-            let mut cache = CACHE.lock().unwrap();
-            cache.put(
-                ev.id.clone(),
-                Channel {
-                    id: ev.channel.clone(),
-                    channel_type: 2,
-                    active: None,
-                    last_message: None,
-                    recipients: None,
-                    owner: None,
-                    guild: Some(ev.id.clone()),
-                    name: Some(ev.name.clone()),
-                    description: Some(ev.description.clone()),
-                },
-            );
-        }
-        Notification::guild_channel_delete(ev) => {
-            let mut cache = CACHE.lock().unwrap();
-            cache.pop(&ev.channel);
-        }
-        _ => {}
-    }
-}*/

src/database/entities/channel.rs

+use std::collections::HashMap;
+
+use crate::database::*;
+use crate::notifications::events::ClientboundNotification;
+use crate::util::result::{Error, Result};
+use futures::StreamExt;
+use mongodb::bson::Bson;
+use mongodb::{
+    bson::{doc, to_document, Document},
+    options::FindOptions,
+};
+use rocket_contrib::json::JsonValue;
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct LastMessage {
+    #[serde(rename = "_id")]
+    id: String,
+    author: String,
+    short: String,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(tag = "channel_type")]
+pub enum Channel {
+    SavedMessages {
+        #[serde(rename = "_id")]
+        id: String,
+        user: String,
+    },
+    DirectMessage {
+        #[serde(rename = "_id")]
+        id: String,
+
+        active: bool,
+        recipients: Vec<String>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        last_message: Option<LastMessage>,
+    },
+    Group {
+        #[serde(rename = "_id")]
+        id: String,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        nonce: Option<String>,
+
+        name: String,
+        owner: String,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        description: Option<String>,
+        recipients: Vec<String>,
+
+        #[serde(skip_serializing_if = "Option::is_none")]
+        icon: Option<File>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        last_message: Option<LastMessage>,
+
+        #[serde(skip_serializing_if = "Option::is_none")]
+        permissions: Option<i32>,
+    },
+    TextChannel {
+        #[serde(rename = "_id")]
+        id: String,
+        server: String,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        nonce: Option<String>,
+
+        name: String,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        description: Option<String>,
+
+        #[serde(skip_serializing_if = "Option::is_none")]
+        icon: Option<File>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        last_message: Option<String>,
+
+        #[serde(skip_serializing_if = "Option::is_none")]
+        default_permissions: Option<i32>,
+        #[serde(default = "HashMap::new", skip_serializing_if = "HashMap::is_empty")]
+        role_permissions: HashMap<String, i32>
+    },
+    VoiceChannel {
+        #[serde(rename = "_id")]
+        id: String,
+        server: String,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        nonce: Option<String>,
+
+        name: String,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        description: Option<String>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        icon: Option<File>,
+
+        #[serde(skip_serializing_if = "Option::is_none")]
+        default_permissions: Option<i32>,
+        #[serde(default = "HashMap::new", skip_serializing_if = "HashMap::is_empty")]
+        role_permissions: HashMap<String, i32>
+    },
+}
+
+impl Channel {
+    pub fn id(&self) -> &str {
+        match self {
+            Channel::SavedMessages { id, .. }
+            | Channel::DirectMessage { id, .. }
+            | Channel::Group { id, .. }
+            | Channel::TextChannel { id, .. }
+            | Channel::VoiceChannel { id, .. } => id,
+        }
+    }
+    pub fn has_messaging(&self) -> Result<()> {
+        match self {
+            Channel::SavedMessages { .. }
+            | Channel::DirectMessage { .. }
+            | Channel::Group { .. }
+            | Channel::TextChannel { .. } => Ok(()),
+            Channel::VoiceChannel { .. } => Err(Error::InvalidOperation)
+        }
+    }
+
+    pub async fn publish(self) -> Result<()> {
+        get_collection("channels")
+            .insert_one(
+                to_document(&self).map_err(|_| Error::DatabaseError {
+                    operation: "to_bson",
+                    with: "channel",
+                })?,
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "insert_one",
+                with: "channel",
+            })?;
+
+        let channel_id = self.id().to_string();
+        ClientboundNotification::ChannelCreate(self).publish(channel_id);
+
+        Ok(())
+    }
+
+    pub async fn publish_update(&self, data: JsonValue) -> Result<()> {
+        let id = self.id().to_string();
+        ClientboundNotification::ChannelUpdate {
+            id: id.clone(),
+            data,
+            clear: None,
+        }
+        .publish(id);
+
+        Ok(())
+    }
+
+    pub async fn delete_associated_objects(id: Bson) -> Result<()> {
+        get_collection("channel_invites")
+            .delete_many(
+                doc! {
+                    "channel": id
+                },
+                None,
+            )
+            .await
+            .map(|_| ())
+            .map_err(|_| Error::DatabaseError {
+                operation: "delete_many",
+                with: "channel_invites",
+            })
+    }
+
+    pub async fn delete_messages(id: Bson) -> Result<()> {
+        let messages = get_collection("messages");
+
+        // Delete any unreads.
+        get_collection("channel_unreads")
+            .delete_many(
+                doc! {
+                    "_id.channel": &id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "delete_many",
+                with: "channel_unreads",
+            })?;
+
+        // Check if there are any attachments we need to delete.
+        let message_ids = messages
+            .find(
+                doc! {
+                    "channel": &id,
+                    "attachment": {
+                        "$exists": 1
+                    }
+                },
+                FindOptions::builder().projection(doc! { "_id": 1 }).build(),
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "fetch_many",
+                with: "messages",
+            })?
+            .filter_map(async move |s| s.ok())
+            .collect::<Vec<Document>>()
+            .await
+            .into_iter()
+            .filter_map(|x| x.get_str("_id").ok().map(|x| x.to_string()))
+            .collect::<Vec<String>>();
+
+        // If we found any, mark them as deleted.
+        if message_ids.len() > 0 {
+            get_collection("attachments")
+                .update_many(
+                    doc! {
+                        "message_id": {
+                            "$in": message_ids
+                        }
+                    },
+                    doc! {
+                        "$set": {
+                            "deleted": true
+                        }
+                    },
+                    None,
+                )
+                .await
+                .map_err(|_| Error::DatabaseError {
+                    operation: "update_many",
+                    with: "attachments",
+                })?;
+        }
+
+        // And then delete said messages.
+        messages
+            .delete_many(
+                doc! {
+                    "channel": id
+                },
+                None,
+            )
+            .await
+            .map(|_| ())
+            .map_err(|_| Error::DatabaseError {
+                operation: "delete_many",
+                with: "messages",
+            })
+    }
+
+    pub async fn delete(&self) -> Result<()> {
+        let id = self.id();
+
+        // Delete any invites.
+        Channel::delete_associated_objects(Bson::String(id.to_string())).await?;
+
+        // Delete messages.
+        match &self {
+            Channel::VoiceChannel { .. } => {},
+            _ => {
+                Channel::delete_messages(Bson::String(id.to_string())).await?;
+            }
+        }
+
+        // Remove from server object.
+        match &self {
+            Channel::TextChannel { server, .. }
+            | Channel::VoiceChannel { server, .. } => {
+                let server = Ref::from_unchecked(server.clone()).fetch_server().await?;
+                let mut update = doc! {
+                    "$pull": {
+                        "channels": id
+                    }
+                };
+
+                if let Some(sys) = &server.system_messages {
+                    let mut unset = doc! {};
+
+                    if let Some(cid) = &sys.user_joined {
+                        if id == cid {
+                            unset.insert("system_messages.user_joined", 1);
+                        }
+                    }
+
+                    if let Some(cid) = &sys.user_left {
+                        if id == cid {
+                            unset.insert("system_messages.user_left", 1);
+                        }
+                    }
+
+                    if let Some(cid) = &sys.user_kicked {
+                        if id == cid {
+                            unset.insert("system_messages.user_kicked", 1);
+                        }
+                    }
+
+                    if let Some(cid) = &sys.user_banned {
+                        if id == cid {
+                            unset.insert("system_messages.user_banned", 1);
+                        }
+                    }
+
+                    if unset.len() > 0 {
+                        update.insert("$unset", unset);
+                    }
+                }
+
+                get_collection("servers")
+                    .update_one(
+                        doc! {
+                            "_id": server.id
+                        },
+                        update,
+                        None,
+                    )
+                    .await
+                    .map_err(|_| Error::DatabaseError {
+                        operation: "update_one",
+                        with: "servers",
+                    })?;
+            },
+            _ => {}
+        }
+
+        // Finally, delete the channel object.
+        get_collection("channels")
+            .delete_one(
+                doc! {
+                    "_id": id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "delete_one",
+                with: "channel",
+            })?;
+
+        ClientboundNotification::ChannelDelete { id: id.to_string() }.publish(id.to_string());
+
+        if let Channel::Group { icon, .. } = self {
+            if let Some(attachment) = icon {
+                attachment.delete().await?;
+            }
+        }
+
+        Ok(())
+    }
+}

src/database/entities/invites.rs

+use mongodb::bson::doc;
+use mongodb::bson::from_document;
+use mongodb::bson::to_document;
+use serde::{Deserialize, Serialize};
+
+use crate::database::get_collection;
+use crate::util::result::Error;
+use crate::util::result::Result;
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(tag = "type")]
+pub enum Invite {
+    Server {
+        #[serde(rename = "_id")]
+        code: String,
+        server: String,
+        creator: String,
+        channel: String,
+    },
+    Group {
+        #[serde(rename = "_id")]
+        code: String,
+        creator: String,
+        channel: String,
+    }, /* User {
+           code: String,
+           user: String
+       } */
+}
+
+impl Invite {
+    pub fn code(&self) -> &String {
+        match &self {
+            Invite::Server { code, .. } => code,
+            Invite::Group { code, .. } => code,
+        }
+    }
+
+    pub fn creator(&self) -> &String {
+        match &self {
+            Invite::Server { creator, .. } => creator,
+            Invite::Group { creator, .. } => creator,
+        }
+    }
+
+    pub async fn get(code: &str) -> Result<Invite> {
+        let doc = get_collection("channel_invites")
+            .find_one(doc! { "_id": code }, None)
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "find_one",
+                with: "invite",
+            })?
+            .ok_or_else(|| Error::UnknownServer)?;
+
+        from_document::<Invite>(doc).map_err(|_| Error::DatabaseError {
+            operation: "from_document",
+            with: "invite",
+        })
+    }
+
+    pub async fn save(self) -> Result<()> {
+        get_collection("channel_invites")
+            .insert_one(
+                to_document(&self).map_err(|_| Error::DatabaseError {
+                    operation: "to_bson",
+                    with: "invite",
+                })?,
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "insert_one",
+                with: "invite",
+            })?;
+
+        Ok(())
+    }
+
+    pub async fn delete(&self) -> Result<()> {
+        get_collection("channel_invites")
+            .delete_one(
+                doc! {
+                    "_id": self.code()
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "delete_one",
+                with: "invite",
+            })?;
+
+        Ok(())
+    }
+}

src/database/entities/message.rs

+use crate::util::variables::{USE_JANUARY, VAPID_PRIVATE_KEY};
+use crate::{
+    database::*,
+    notifications::{events::ClientboundNotification, websocket::is_online},
+    util::result::{Error, Result},
+};
+
+use futures::StreamExt;
+use mongodb::options::UpdateOptions;
+use mongodb::{
+    bson::{doc, to_bson, DateTime},
+    options::FindOptions,
+};
+use rocket_contrib::json::JsonValue;
+use serde::{Deserialize, Serialize};
+use ulid::Ulid;
+use web_push::{
+    ContentEncoding, SubscriptionInfo, VapidSignatureBuilder, WebPushClient, WebPushMessageBuilder,
+};
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(tag = "type")]
+pub enum SystemMessage {
+    #[serde(rename = "text")]
+    Text { content: String },
+    #[serde(rename = "user_added")]
+    UserAdded { id: String, by: String },
+    #[serde(rename = "user_remove")]
+    UserRemove { id: String, by: String },
+    #[serde(rename = "user_joined")]
+    UserJoined { id: String },
+    #[serde(rename = "user_left")]
+    UserLeft { id: String },
+    #[serde(rename = "user_kicked")]
+    UserKicked { id: String },
+    #[serde(rename = "user_banned")]
+    UserBanned { id: String },
+    #[serde(rename = "channel_renamed")]
+    ChannelRenamed { name: String, by: String },
+    #[serde(rename = "channel_description_changed")]
+    ChannelDescriptionChanged { by: String },
+    #[serde(rename = "channel_icon_changed")]
+    ChannelIconChanged { by: String },
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(untagged)]
+pub enum Content {
+    Text(String),
+    SystemMessage(SystemMessage),
+}
+
+impl Content {
+    pub async fn send_as_system(self, target: &Channel) -> Result<()> {
+        Message::create(
+            "00000000000000000000000000".to_string(),
+            target.id().to_string(),
+            self,
+            None,
+            None
+        )
+        .publish(&target, false)
+        .await
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Message {
+    #[serde(rename = "_id")]
+    pub id: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub nonce: Option<String>,
+    pub channel: String,
+    pub author: String,
+
+    pub content: Content,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub attachments: Option<Vec<File>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub edited: Option<DateTime>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub embeds: Option<Vec<Embed>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub mentions: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub replies: Option<Vec<String>>
+}
+
+impl Message {
+    pub fn create(
+        author: String,
+        channel: String,
+        content: Content,
+        mentions: Option<Vec<String>>,
+        replies: Option<Vec<String>>,
+    ) -> Message {
+        Message {
+            id: Ulid::new().to_string(),
+            nonce: None,
+            channel,
+            author,
+
+            content,
+            attachments: None,
+            edited: None,
+            embeds: None,
+            mentions,
+            replies
+        }
+    }
+
+    pub async fn publish(self, channel: &Channel, process_embeds: bool) -> Result<()> {
+        get_collection("messages")
+            .insert_one(to_bson(&self).unwrap().as_document().unwrap().clone(), None)
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "insert_one",
+                with: "message",
+            })?;
+
+        // ! FIXME: all this code is legitimately crap
+        // ! rewrite when can be asked
+
+        let ss = self.clone();
+        let c_clone = channel.clone();
+        async_std::task::spawn(async move {
+            let mut set = if let Content::Text(text) = &ss.content {
+                doc! {
+                    "last_message": {
+                        "_id": ss.id.clone(),
+                        "author": ss.author.clone(),
+                        "short": text.chars().take(128).collect::<String>()
+                    }
+                }
+            } else {
+                doc! {}
+            };
+
+            // ! MARK AS ACTIVE
+            // ! FIXME: temp code
+            let channels = get_collection("channels");
+            match &c_clone {
+                Channel::DirectMessage { id, .. } => {
+                    set.insert("active", true);
+                    channels
+                        .update_one(
+                            doc! { "_id": id },
+                            doc! {
+                                "$set": set
+                            },
+                            None,
+                        )
+                        .await
+                        /*.map_err(|_| Error::DatabaseError {
+                            operation: "update_one",
+                            with: "channel",
+                        })?;*/
+                        .unwrap();
+                }
+                Channel::Group { id, .. } => {
+                    if let Content::Text(_) = &ss.content {
+                        channels
+                            .update_one(
+                                doc! { "_id": id },
+                                doc! {
+                                    "$set": set
+                                },
+                                None,
+                            )
+                            .await
+                            /*.map_err(|_| Error::DatabaseError {
+                                operation: "update_one",
+                                with: "channel",
+                            })?;*/
+                            .unwrap();
+                    }
+                }
+                Channel::TextChannel { id, .. } => {
+                    if let Content::Text(_) = &ss.content {
+                        channels
+                            .update_one(
+                                doc! { "_id": id },
+                                doc! {
+                                    "$set": {
+                                        "last_message": &ss.id
+                                    }
+                                },
+                                None,
+                            )
+                            .await
+                            /*.map_err(|_| Error::DatabaseError {
+                                operation: "update_one",
+                                with: "channel",
+                            })?;*/
+                            .unwrap();
+                    }
+                }
+                _ => {}
+            }
+        });
+
+        // ! FIXME: also temp code
+        // ! THIS ADDS ANY MENTIONS
+        if let Some(mentions) = &self.mentions {
+            let message = self.id.clone();
+            let channel = self.channel.clone();
+            let mentions = mentions.clone();
+            async_std::task::spawn(async move {
+                get_collection("channel_unreads")
+                    .update_many(
+                        doc! {
+                            "_id.channel": channel,
+                            "_id.user": {
+                                "$in": mentions
+                            }
+                        },
+                        doc! {
+                            "$push": {
+                                "mentions": message
+                            }
+                        },
+                        UpdateOptions::builder().upsert(true).build(),
+                    )
+                    .await
+                    /*.map_err(|_| Error::DatabaseError {
+                        operation: "update_many",
+                        with: "channel_unreads",
+                    })?;*/
+                    .unwrap();
+            });
+        }
+
+        if process_embeds {
+            self.process_embed();
+        }
+
+        let mentions = self.mentions.clone();
+        let enc = serde_json::to_string(&self).unwrap();
+        ClientboundNotification::Message(self).publish(channel.id().to_string());
+
+        /*
+           Web Push Test Code
+        */
+        let c_clone = channel.clone();
+        async_std::task::spawn(async move {
+            // Find all offline users.
+            let mut target_ids = vec![];
+            match &c_clone {
+                Channel::DirectMessage { recipients, .. } | Channel::Group { recipients, .. } => {
+                    for recipient in recipients {
+                        if !is_online(recipient) {
+                            target_ids.push(recipient.clone());
+                        }
+                    }
+                }
+                Channel::TextChannel { .. } => {
+                    if let Some(mut mentions) = mentions {
+                        target_ids.append(&mut mentions);
+                    }
+                }
+                _ => {}
+            }
+
+            // Fetch their corresponding sessions.
+            if let Ok(mut cursor) = get_collection("accounts")
+                .find(
+                    doc! {
+                        "_id": {
+                            "$in": target_ids
+                        },
+                        "sessions.subscription": {
+                            "$exists": true
+                        }
+                    },
+                    FindOptions::builder()
+                        .projection(doc! { "sessions": 1 })
+                        .build(),
+                )
+                .await
+            {
+                let mut subscriptions = vec![];
+                while let Some(result) = cursor.next().await {
+                    if let Ok(doc) = result {
+                        if let Ok(sessions) = doc.get_array("sessions") {
+                            for session in sessions {
+                                if let Some(doc) = session.as_document() {
+                                    if let Ok(sub) = doc.get_document("subscription") {
+                                        let endpoint = sub.get_str("endpoint").unwrap().to_string();
+                                        let p256dh = sub.get_str("p256dh").unwrap().to_string();
+                                        let auth = sub.get_str("auth").unwrap().to_string();
+
+                                        subscriptions
+                                            .push(SubscriptionInfo::new(endpoint, p256dh, auth));
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                if subscriptions.len() > 0 {
+                    let client = WebPushClient::new();
+                    let key =
+                        base64::decode_config(VAPID_PRIVATE_KEY.clone(), base64::URL_SAFE).unwrap();
+
+                    for subscription in subscriptions {
+                        let mut builder = WebPushMessageBuilder::new(&subscription).unwrap();
+                        let sig_builder = VapidSignatureBuilder::from_pem(
+                            std::io::Cursor::new(&key),
+                            &subscription,
+                        )
+                        .unwrap();
+                        let signature = sig_builder.build().unwrap();
+                        builder.set_vapid_signature(signature);
+                        builder.set_payload(ContentEncoding::AesGcm, enc.as_bytes());
+                        let m = builder.build().unwrap();
+                        client.send(m).await.ok();
+                    }
+                }
+            }
+        });
+
+        Ok(())
+    }
+
+    pub async fn publish_update(self, data: JsonValue) -> Result<()> {
+        let channel = self.channel.clone();
+        ClientboundNotification::MessageUpdate {
+            id: self.id.clone(),
+            channel: self.channel.clone(),
+            data,
+        }
+        .publish(channel);
+        self.process_embed();
+
+        Ok(())
+    }
+
+    pub fn process_embed(&self) {
+        if !*USE_JANUARY {
+            return;
+        }
+
+        if let Content::Text(text) = &self.content {
+            // ! FIXME: re-write this at some point,
+            // ! or just before we allow user generated embeds
+            let id = self.id.clone();
+            let content = text.clone();
+            let channel = self.channel.clone();
+            async_std::task::spawn(async move {
+                if let Ok(embeds) = Embed::generate(content).await {
+                    if let Ok(bson) = to_bson(&embeds) {
+                        if let Ok(_) = get_collection("messages")
+                            .update_one(
+                                doc! {
+                                    "_id": &id
+                                },
+                                doc! {
+                                    "$set": {
+                                        "embeds": bson
+                                    }
+                                },
+                                None,
+                            )
+                            .await
+                        {
+                            ClientboundNotification::MessageUpdate {
+                                id,
+                                channel: channel.clone(),
+                                data: json!({ "embeds": embeds }),
+                            }
+                            .publish(channel);
+                        }
+                    }
+                }
+            });
+        }
+    }
+
+    pub async fn delete(&self) -> Result<()> {
+        if let Some(attachments) = &self.attachments {
+            for attachment in attachments {
+                attachment.delete().await?;
+            }
+        }
+
+        get_collection("messages")
+            .delete_one(
+                doc! {
+                    "_id": &self.id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "delete_one",
+                with: "message",
+            })?;
+
+        let channel = self.channel.clone();
+        ClientboundNotification::MessageDelete {
+            id: self.id.clone(),
+            channel: self.channel.clone(),
+        }
+        .publish(channel);
+
+        if let Some(attachments) = &self.attachments {
+            let attachment_ids: Vec<String> =
+                attachments.iter().map(|f| f.id.to_string()).collect();
+            get_collection("attachments")
+                .update_one(
+                    doc! {
+                        "_id": {
+                            "$in": attachment_ids
+                        }
+                    },
+                    doc! {
+                        "$set": {
+                            "deleted": true
+                        }
+                    },
+                    None,
+                )
+                .await
+                .map_err(|_| Error::DatabaseError {
+                    operation: "update_one",
+                    with: "attachment",
+                })?;
+        }
+
+        Ok(())
+    }
+}

src/database/entities/microservice/autumn.rs

+use mongodb::bson::{doc, from_document};
+use serde::{Deserialize, Serialize};
+
+use crate::database::*;
+use crate::util::result::{Error, Result};
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(tag = "type")]
+enum Metadata {
+    File,
+    Text,
+    Image { width: isize, height: isize },
+    Video { width: isize, height: isize },
+    Audio,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct File {
+    #[serde(rename = "_id")]
+    pub id: String,
+    tag: String,
+    filename: String,
+    metadata: Metadata,
+    content_type: String,
+    size: isize,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    deleted: Option<bool>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    message_id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    user_id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    server_id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    object_id: Option<String>,
+}
+
+impl File {
+    pub async fn find_and_use(
+        attachment_id: &str,
+        tag: &str,
+        parent_type: &str,
+        parent_id: &str,
+    ) -> Result<File> {
+        let attachments = get_collection("attachments");
+        let key = format!("{}_id", parent_type);
+        if let Some(doc) = attachments
+            .find_one(
+                doc! {
+                    "_id": attachment_id,
+                    "tag": &tag,
+                    key.clone(): {
+                        "$exists": false
+                    }
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "find_one",
+                with: "attachment",
+            })?
+        {
+            let attachment = from_document::<File>(doc).map_err(|_| Error::DatabaseError {
+                operation: "from_document",
+                with: "attachment",
+            })?;
+
+            attachments
+                .update_one(
+                    doc! {
+                        "_id": &attachment.id
+                    },
+                    doc! {
+                        "$set": {
+                            key: &parent_id
+                        }
+                    },
+                    None,
+                )
+                .await
+                .map_err(|_| Error::DatabaseError {
+                    operation: "update_one",
+                    with: "attachment",
+                })?;
+
+            Ok(attachment)
+        } else {
+            Err(Error::UnknownAttachment)
+        }
+    }
+
+    pub async fn delete(&self) -> Result<()> {
+        get_collection("attachments")
+            .update_one(
+                doc! {
+                    "_id": &self.id
+                },
+                doc! {
+                    "$set": {
+                        "deleted": true
+                    }
+                },
+                None,
+            )
+            .await
+            .map(|_| ())
+            .map_err(|_| Error::DatabaseError {
+                operation: "update_one",
+                with: "attachment",
+            })
+    }
+}

src/database/entities/microservice/january.rs

+use crate::util::{
+    result::{Error, Result},
+    variables::JANUARY_URL,
+};
+use linkify::{LinkFinder, LinkKind};
+use regex::Regex;
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub enum ImageSize {
+    Large,
+    Preview,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Image {
+    pub url: String,
+    pub width: isize,
+    pub height: isize,
+    pub size: ImageSize,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Video {
+    pub url: String,
+    pub width: isize,
+    pub height: isize,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub enum TwitchType {
+    Channel,
+    Video,
+    Clip,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub enum BandcampType {
+    Album,
+    Track,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(tag = "type")]
+pub enum Special {
+    None,
+    YouTube {
+        id: String,
+    },
+    Twitch {
+        content_type: TwitchType,
+        id: String,
+    },
+    Spotify {
+        content_type: String,
+        id: String,
+    },
+    Soundcloud,
+    Bandcamp {
+        content_type: BandcampType,
+        id: String,
+    },
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Metadata {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    url: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    special: Option<Special>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    title: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    description: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    image: Option<Image>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    video: Option<Video>,
+
+    // #[serde(skip_serializing_if = "Option::is_none")]
+    // opengraph_type: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    site_name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    icon_url: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    color: Option<String>,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(tag = "type")]
+pub enum Embed {
+    Website(Metadata),
+    Image(Image),
+    None,
+}
+
+impl Embed {
+    pub async fn generate(content: String) -> Result<Vec<Embed>> {
+        lazy_static! {
+            static ref RE_CODE: Regex = Regex::new("```(?:.|\n)+?```|`(?:.|\n)+?`").unwrap();
+        }
+
+        // Ignore code blocks.
+        let content = RE_CODE.replace_all(&content, "");
+
+        let content = content
+            // Ignore quoted lines.
+            .split("\n")
+            .map(|v| {
+                if let Some(c) = v.chars().next() {
+                    if c == '>' {
+                        return "";
+                    }
+                }
+
+                v
+            })
+            .collect::<Vec<&str>>()
+            .join("\n");
+
+        // ! FIXME: allow multiple links
+        // ! FIXME: prevent generation if link is surrounded with < >
+        let mut finder = LinkFinder::new();
+        finder.kinds(&[LinkKind::Url]);
+        let links: Vec<_> = finder.links(&content).collect();
+
+        if links.len() == 0 {
+            return Err(Error::LabelMe);
+        }
+
+        let link = &links[0];
+
+        let client = reqwest::Client::new();
+        let result = client
+            .get(&format!("{}/embed", *JANUARY_URL))
+            .query(&[("url", link.as_str())])
+            .send()
+            .await;
+
+        match result {
+            Err(_) => return Err(Error::LabelMe),
+            Ok(result) => match result.status() {
+                reqwest::StatusCode::OK => {
+                    let res: Embed = result.json().await.map_err(|_| Error::InvalidOperation)?;
+
+                    Ok(vec![res])
+                }
+                _ => return Err(Error::LabelMe),
+            },
+        }
+    }
+}

src/database/entities/microservice/mod.rs

+pub mod autumn;
+pub mod january;

src/database/entities/mod.rs

+mod channel;
+mod invites;
+mod message;
+mod microservice;
+mod server;
+mod sync;
+mod user;
+
+use microservice::*;
+
+pub use autumn::*;
+pub use channel::*;
+pub use invites::*;
+pub use january::*;
+pub use message::*;
+pub use server::*;
+pub use sync::*;
+pub use user::*;

src/pubsub/events/groups.rs → src/database/entities/sync.rs

 use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+pub type UserSettings = HashMap<String, (i64, String)>;
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct UserJoin {
-    pub id: String,
+pub struct ChannelCompositeKey {
+    pub channel: String,
     pub user: String,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct UserLeave {
-    pub id: String,
-    pub user: String,
+pub struct ChannelUnread {
+    #[serde(rename = "_id")]
+    pub id: ChannelCompositeKey,
+
+    pub last_id: Option<String>,
+    pub mentions: Option<Vec<String>>,
 }

src/database/guards/mod.rs

+pub mod reference;
+pub mod user;
+
+pub use reference::Ref;

src/database/guards/user.rs

+use crate::database::*;
+
+use mongodb::bson::{doc, from_document};
+use rauth::auth::Session;
+use rocket::http::Status;
+use rocket::request::{self, FromRequest, Outcome, Request};
+
+#[rocket::async_trait]
+impl<'a, 'r> FromRequest<'a, 'r> for User {
+    type Error = rauth::util::Error;
+
+    async fn from_request(request: &'a Request<'r>) -> request::Outcome<Self, Self::Error> {
+        let session: Session = try_outcome!(request.guard::<Session>().await);
+
+        if let Ok(result) = get_collection("users")
+            .find_one(
+                doc! {
+                    "_id": &session.user_id
+                },
+                None,
+            )
+            .await
+        {
+            if let Some(doc) = result {
+                Outcome::Success(from_document(doc).unwrap())
+            } else {
+                Outcome::Failure((Status::Forbidden, rauth::util::Error::InvalidSession))
+            }
+        } else {
+            Outcome::Failure((
+                Status::InternalServerError,
+                rauth::util::Error::DatabaseError {
+                    operation: "find_one",
+                    with: "user",
+                },
+            ))
+        }
+    }
+}