run.sh

-#!/bin/bash
-export $(egrep -v '^#' .env | xargs)
-echo "Running Revolt in detached mode."
-docker run \
-    -d \
-    --name revolt \
-    -p 8000:8000 \
-    -p 9000:9000 \
-    -e "DB_URI=$DB_URI" \
-    -e "PUBLIC_URI=$PUBLIC_URI" \
-    -e "PORTAL_URL=$PORTAL_URI" \
-    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};
-
-#[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 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) {
-        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 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(result) = col.find(doc! { "_id": { "$in": missing } }, None) {
-        for item in result {
-            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> {
-        if let Ok(result) = fetch_channel(param) {
-            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/database/entities/server.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, doc};
+use mongodb::bson::from_document;
+use mongodb::bson::to_document;
+use mongodb::bson::Document;
+use rocket_contrib::json::JsonValue;
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct MemberCompositeKey {
+    pub server: String,
+    pub user: String,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Member {
+    #[serde(rename = "_id")]
+    pub id: MemberCompositeKey,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub nickname: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub avatar: Option<File>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub roles: Option<Vec<String>>
+}
+
+pub type PermissionTuple = (
+    i32, // server permission
+    i32  // channel permission
+);
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Role {
+    pub name: String,
+    pub permissions: PermissionTuple,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub colour: Option<String>
+    // Bri'ish API conventions
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Category {
+    pub id: String,
+    pub title: String,
+    pub channels: Vec<String>
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Ban {
+    #[serde(rename = "_id")]
+    pub id: MemberCompositeKey,
+    pub reason: Option<String>,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct SystemMessageChannels {
+    pub user_joined: Option<String>,
+    pub user_left: Option<String>,
+    pub user_kicked: Option<String>,
+    pub user_banned: Option<String>,
+}
+
+pub enum RemoveMember {
+    Leave,
+    Kick,
+    Ban,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Server {
+    #[serde(rename = "_id")]
+    pub id: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub nonce: Option<String>,
+    pub owner: String,
+
+    pub name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    
+    pub channels: Vec<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub categories: Option<Vec<Category>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub system_messages: Option<SystemMessageChannels>,
+
+    #[serde(default = "HashMap::new", skip_serializing_if = "HashMap::is_empty")]
+    pub roles: HashMap<String, Role>,
+    pub default_permissions: PermissionTuple,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub icon: Option<File>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub banner: Option<File>,
+}
+
+impl Server {
+    pub async fn create(self) -> Result<()> {
+        get_collection("servers")
+            .insert_one(
+                to_document(&self).map_err(|_| Error::DatabaseError {
+                    operation: "to_bson",
+                    with: "channel",
+                })?,
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "insert_one",
+                with: "server",
+            })?;
+
+        Ok(())
+    }
+
+    pub async fn publish_update(&self, data: JsonValue) -> Result<()> {
+        ClientboundNotification::ServerUpdate {
+            id: self.id.clone(),
+            data,
+            clear: None,
+        }
+        .publish(self.id.clone());
+
+        Ok(())
+    }
+
+    pub async fn delete(&self) -> Result<()> {
+        // Check if there are any attachments we need to delete.
+        Channel::delete_messages(Bson::Document(doc! { "$in": &self.channels })).await?;
+
+        // Delete all channels.
+        get_collection("channels")
+            .delete_many(
+                doc! {
+                    "server": &self.id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "delete_many",
+                with: "channels",
+            })?;
+
+        // Delete any associated objects, e.g. unreads and invites.
+        Channel::delete_associated_objects(Bson::Document(doc! { "$in": &self.channels })).await?;
+
+        // Delete members and bans.
+        for with in &["server_members", "server_bans"] {
+            get_collection(with)
+                .delete_many(
+                    doc! {
+                        "_id.server": &self.id
+                    },
+                    None,
+                )
+                .await
+                .map_err(|_| Error::DatabaseError {
+                    operation: "delete_many",
+                    with,
+                })?;
+        }
+
+        // Delete server icon / banner.
+        if let Some(attachment) = &self.icon {
+            attachment.delete().await?;
+        }
+
+        if let Some(attachment) = &self.banner {
+            attachment.delete().await?;
+        }
+
+        // Delete the server
+        get_collection("servers")
+            .delete_one(
+                doc! {
+                    "_id": &self.id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "delete_one",
+                with: "server",
+            })?;
+
+        ClientboundNotification::ServerDelete {
+            id: self.id.clone(),
+        }
+        .publish(self.id.clone());
+
+        Ok(())
+    }
+
+    pub async fn fetch_members(id: &str) -> Result<Vec<Member>> {
+        Ok(get_collection("server_members")
+            .find(
+                doc! {
+                    "_id.server": id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "find",
+                with: "server_members",
+            })?
+            .filter_map(async move |s| s.ok())
+            .collect::<Vec<Document>>()
+            .await
+            .into_iter()
+            .filter_map(|x| from_document(x).ok())
+            .collect::<Vec<Member>>())
+    }
+
+    pub async fn fetch_member_ids(id: &str) -> Result<Vec<String>> {
+        Ok(get_collection("server_members")
+            .find(
+                doc! {
+                    "_id.server": id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "find",
+                with: "server_members",
+            })?
+            .filter_map(async move |s| s.ok())
+            .collect::<Vec<Document>>()
+            .await
+            .into_iter()
+            .filter_map(|x| {
+                x.get_document("_id")
+                    .ok()
+                    .map(|i| i.get_str("user").ok().map(|x| x.to_string()))
+            })
+            .flatten()
+            .collect::<Vec<String>>())
+    }
+
+    pub async fn join_member(&self, id: &str) -> Result<()> {
+        if get_collection("server_bans")
+            .find_one(
+                doc! {
+                    "_id.server": &self.id,
+                    "_id.user": &id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "find_one",
+                with: "server_bans",
+            })?
+            .is_some()
+        {
+            return Err(Error::Banned);
+        }
+
+        get_collection("server_members")
+            .insert_one(
+                doc! {
+                    "_id": {
+                        "server": &self.id,
+                        "user": &id
+                    }
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "insert_one",
+                with: "server_members",
+            })?;
+
+        ClientboundNotification::ServerMemberJoin {
+            id: self.id.clone(),
+            user: id.to_string(),
+        }
+        .publish(self.id.clone());
+
+        if let Some(channels) = &self.system_messages {
+            if let Some(cid) = &channels.user_joined {
+                let channel = Ref::from_unchecked(cid.clone()).fetch_channel().await?;
+                Content::SystemMessage(SystemMessage::UserJoined { id: id.to_string() })
+                    .send_as_system(&channel)
+                    .await?;
+            }
+        }
+
+        Ok(())
+    }
+
+    pub async fn remove_member(&self, id: &str, removal: RemoveMember) -> Result<()> {
+        let result = get_collection("server_members")
+            .delete_one(
+                doc! {
+                    "_id": {
+                        "server": &self.id,
+                        "user": &id
+                    }
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "delete_one",
+                with: "server_members",
+            })?;
+
+        if result.deleted_count > 0 {
+            ClientboundNotification::ServerMemberLeave {
+                id: self.id.clone(),
+                user: id.to_string(),
+            }
+            .publish(self.id.clone());
+
+            if let Some(channels) = &self.system_messages {
+                let message = match removal {
+                    RemoveMember::Leave => {
+                        if let Some(cid) = &channels.user_left {
+                            Some((cid.clone(), SystemMessage::UserLeft { id: id.to_string() }))
+                        } else {
+                            None
+                        }
+                    }
+                    RemoveMember::Kick => {
+                        if let Some(cid) = &channels.user_kicked {
+                            Some((
+                                cid.clone(),
+                                SystemMessage::UserKicked { id: id.to_string() },
+                            ))
+                        } else {
+                            None
+                        }
+                    }
+                    RemoveMember::Ban => {
+                        if let Some(cid) = &channels.user_banned {
+                            Some((
+                                cid.clone(),
+                                SystemMessage::UserBanned { id: id.to_string() },
+                            ))
+                        } else {
+                            None
+                        }
+                    }
+                };
+
+                if let Some((cid, message)) = message {
+                    let channel = Ref::from_unchecked(cid).fetch_channel().await?;
+                    Content::SystemMessage(message)
+                        .send_as_system(&channel)
+                        .await?;
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    pub async fn get_member_count(id: &str) -> Result<i64> {
+        Ok(get_collection("server_members")
+            .count_documents(
+                doc! {
+                    "_id.server": id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "count_documents",
+                with: "server_members",
+            })?)
+    }
+}

src/notifications/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/entities/user.rs

+use futures::StreamExt;
+use mongodb::bson::Document;
+use mongodb::options::{Collation, FindOneOptions};
+use mongodb::{
+    bson::{doc, from_document},
+    options::FindOptions,
+};
+use num_enum::TryFromPrimitive;
+use serde::{Deserialize, Serialize};
+use std::ops;
+use ulid::Ulid;
+use validator::Validate;
+
+use crate::database::permissions::user::UserPermissions;
+use crate::database::*;
+use crate::notifications::websocket::is_online;
+use crate::util::result::{Error, Result};
+use crate::util::variables::EARLY_ADOPTER_BADGE;
+
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
+pub enum RelationshipStatus {
+    None,
+    User,
+    Friend,
+    Outgoing,
+    Incoming,
+    Blocked,
+    BlockedOther,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Relationship {
+    #[serde(rename = "_id")]
+    pub id: String,
+    pub status: RelationshipStatus,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub enum Presence {
+    Online,
+    Idle,
+    Busy,
+    Invisible,
+}
+
+#[derive(Validate, Serialize, Deserialize, Debug, Clone)]
+pub struct UserStatus {
+    #[validate(length(min = 1, max = 128))]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub text: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub presence: Option<Presence>,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct UserProfile {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub content: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub background: Option<File>,
+}
+
+#[derive(Debug, PartialEq, Eq, TryFromPrimitive, Copy, Clone)]
+#[repr(i32)]
+pub enum Badges {
+    Developer = 1,
+    Translator = 2,
+    Supporter = 4,
+    ResponsibleDisclosure = 8,
+    RevoltTeam = 16,
+    EarlyAdopter = 256,
+}
+
+impl_op_ex_commutative!(+ |a: &i32, b: &Badges| -> i32 { *a | *b as i32 });
+
+// When changing this struct, update notifications/payload.rs#80
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct User {
+    #[serde(rename = "_id")]
+    pub id: String,
+    pub username: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub avatar: Option<File>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub relations: Option<Vec<Relationship>>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub badges: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub status: Option<UserStatus>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub profile: Option<UserProfile>,
+
+    // ? This should never be pushed to the collection.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub relationship: Option<RelationshipStatus>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub online: Option<bool>,
+}
+
+impl User {
+    /// Mutate the user object to include relationship as seen by user.
+    pub fn from(mut self, user: &User) -> User {
+        self.relationship = Some(RelationshipStatus::None);
+
+        if self.id == user.id {
+            self.relationship = Some(RelationshipStatus::User);
+            return self;
+        }
+
+        self.relations = None;
+        if let Some(relations) = &user.relations {
+            if let Some(relationship) = relations.iter().find(|x| self.id == x.id) {
+                self.relationship = Some(relationship.status.clone());
+                return self;
+            }
+        }
+
+        self
+    }
+
+    /// Mutate the user object to appear as seen by user.
+    pub fn with(mut self, permissions: UserPermissions<[u32; 1]>) -> User {
+        let mut badges = self.badges.unwrap_or_else(|| 0);
+        if let Ok(id) = Ulid::from_string(&self.id) {
+            if id.datetime().timestamp_millis() < *EARLY_ADOPTER_BADGE {
+                badges = badges + Badges::EarlyAdopter;
+            }
+        }
+
+        self.badges = Some(badges);
+
+        if permissions.get_view_profile() {
+            self.online = Some(is_online(&self.id));
+        } else {
+            self.status = None;
+        }
+
+        self.profile = None;
+        self
+    }
+
+    /// Mutate the user object to appear as seen by user.
+    /// Also overrides the relationship status.
+    pub async fn from_override(
+        mut self,
+        user: &User,
+        relationship: RelationshipStatus,
+    ) -> Result<User> {
+        let permissions = PermissionCalculator::new(&user)
+            .with_relationship(&relationship)
+            .for_user(&self.id)
+            .await?;
+
+        self.relations = None;
+        self.relationship = Some(relationship);
+        Ok(self.with(permissions))
+    }
+
+    /// Utility function for checking claimed usernames.
+    pub async fn is_username_taken(username: &str) -> Result<bool> {
+        if username.to_lowercase() == "revolt" || username.to_lowercase() == "admin" || username.to_lowercase() == "system" {
+            return Ok(true);
+        }
+
+        if get_collection("users")
+            .find_one(
+                doc! {
+                    "username": username
+                },
+                FindOneOptions::builder()
+                    .collation(Collation::builder().locale("en").strength(2).build())
+                    .build(),
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "find_one",
+                with: "user",
+            })?
+            .is_some()
+        {
+            Ok(true)
+        } else {
+            Ok(false)
+        }
+    }
+
+    /// Utility function for fetching multiple users from the perspective of one.
+    /// Assumes user has a mutual connection with others.
+    pub async fn fetch_multiple_users(&self, user_ids: Vec<String>) -> Result<Vec<User>> {
+        let mut users = vec![];
+        let mut cursor = get_collection("users")
+            .find(
+                doc! {
+                    "_id": {
+                        "$in": user_ids
+                    }
+                },
+                FindOptions::builder()
+                    .projection(
+                        doc! { "_id": 1, "username": 1, "avatar": 1, "badges": 1, "status": 1 },
+                    )
+                    .build(),
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "find",
+                with: "users",
+            })?;
+
+        while let Some(result) = cursor.next().await {
+            if let Ok(doc) = result {
+                let other: User = from_document(doc).map_err(|_| Error::DatabaseError {
+                    operation: "from_document",
+                    with: "user",
+                })?;
+
+                let permissions = PermissionCalculator::new(&self)
+                    .with_mutual_connection()
+                    .with_user(&other)
+                    .for_user_given()
+                    .await?;
+
+                users.push(other.from(&self).with(permissions));
+            }
+        }
+
+        Ok(users)
+    }
+
+    /// Utility function to get all of a user's memberships.
+    pub async fn fetch_memberships(id: &str) -> Result<Vec<Member>> {
+        Ok(get_collection("server_members")
+            .find(
+                doc! {
+                    "_id.user": id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "find",
+                with: "server_members",
+            })?
+            .filter_map(async move |s| s.ok())
+            .collect::<Vec<Document>>()
+            .await
+            .into_iter()
+            .filter_map(|x| {
+                from_document(x).ok()
+            })
+            .collect::<Vec<Member>>())
+    }
+
+    /// Utility function to get all the server IDs the user is in.
+    pub async fn fetch_server_ids(id: &str) -> Result<Vec<String>> {
+        Ok(get_collection("server_members")
+            .find(
+                doc! {
+                    "_id.user": id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "find",
+                with: "server_members",
+            })?
+            .filter_map(async move |s| s.ok())
+            .collect::<Vec<Document>>()
+            .await
+            .into_iter()
+            .filter_map(|x| {
+                x.get_document("_id")
+                    .ok()
+                    .map(|i| i.get_str("server").ok().map(|x| x.to_string()))
+            })
+            .flatten()
+            .collect::<Vec<String>>())
+    }
+
+    /// Utility function to fetch unread objects for user.
+    pub async fn fetch_unreads(id: &str) -> Result<Vec<Document>> {
+        Ok(get_collection("channel_unreads")
+            .find(
+                doc! {
+                    "_id.user": id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "find_one",
+                with: "user_settings",
+            })?
+            .filter_map(async move |s| s.ok())
+            .collect::<Vec<Document>>()
+            .await)
+    }
+}

src/database/guards/mod.rs

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

src/database/guards/reference.rs

+use crate::database::*;
+use crate::util::result::{Error, Result};
+
+use mongodb::bson::{doc, from_document};
+use rocket::http::RawStr;
+use rocket::request::FromParam;
+use serde::{de::DeserializeOwned, Deserialize, Serialize};
+use validator::Validate;
+
+#[derive(Validate, Serialize, Deserialize)]
+pub struct Ref {
+    #[validate(length(min = 1, max = 26))]
+    pub id: String,
+}
+
+impl Ref {
+    pub fn from_unchecked(id: String) -> Ref {
+        Ref { id }
+    }
+
+    pub fn from(id: String) -> Result<Ref> {
+        let r = Ref { id };
+        r.validate()
+            .map_err(|error| Error::FailedValidation { error })?;
+        Ok(r)
+    }
+
+    async fn fetch<T: DeserializeOwned>(&self, collection: &'static str) -> Result<T> {
+        let doc = get_collection(&collection)
+            .find_one(
+                doc! {
+                    "_id": &self.id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "find_one",
+                with: &collection,
+            })?
+            .ok_or_else(|| Error::NotFound)?;
+
+        Ok(from_document::<T>(doc).map_err(|_| Error::DatabaseError {
+            operation: "from_document",
+            with: &collection,
+        })?)
+    }
+
+    pub async fn fetch_user(&self) -> Result<User> {
+        self.fetch("users").await
+    }
+
+    pub async fn fetch_channel(&self) -> Result<Channel> {
+        self.fetch("channels").await
+    }
+
+    pub async fn fetch_server(&self) -> Result<Server> {
+        self.fetch("servers").await
+    }
+
+    pub async fn fetch_invite(&self) -> Result<Invite> {
+        self.fetch("channel_invites").await
+    }
+
+    pub async fn fetch_member(&self, server: &str) -> Result<Member> {
+        let doc = get_collection("server_members")
+            .find_one(
+                doc! {
+                    "_id.user": &self.id,
+                    "_id.server": server
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "find_one",
+                with: "server_member",
+            })?
+            .ok_or_else(|| Error::NotFound)?;
+
+        Ok(
+            from_document::<Member>(doc).map_err(|_| Error::DatabaseError {
+                operation: "from_document",
+                with: "server_member",
+            })?,
+        )
+    }
+
+    pub async fn fetch_ban(&self, server: &str) -> Result<Ban> {
+        let doc = get_collection("server_bans")
+            .find_one(
+                doc! {
+                    "_id.user": &self.id,
+                    "_id.server": server
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "find_one",
+                with: "server_ban",
+            })?
+            .ok_or_else(|| Error::NotFound)?;
+
+        Ok(from_document::<Ban>(doc).map_err(|_| Error::DatabaseError {
+            operation: "from_document",
+            with: "server_ban",
+        })?)
+    }
+
+    pub async fn fetch_message(&self, channel: &Channel) -> Result<Message> {
+        let message: Message = self.fetch("messages").await?;
+        if &message.channel != channel.id() {
+            Err(Error::InvalidOperation)
+        } else {
+            Ok(message)
+        }
+    }
+}
+
+impl User {
+    pub fn as_ref(&self) -> Ref {
+        Ref {
+            id: self.id.to_string(),
+        }
+    }
+}
+
+impl<'r> FromParam<'r> for Ref {
+    type Error = &'r RawStr;
+
+    fn from_param(param: &'r RawStr) -> Result<Self, Self::Error> {
+        if let Ok(result) = Ref::from(param.to_string()) {
+            if result.validate().is_ok() {
+                return Ok(result);
+            }
+        }
+
+        Err(param)
+    }
+}

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",
+                },
+            ))
+        }
+    }
+}

src/database/guild.rs

-use super::channel::fetch_channels;
-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};
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct MemberRef {
-    pub guild: String,
-    pub user: String,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct Member {
-    #[serde(rename = "_id")]
-    pub id: MemberRef,
-    pub nickname: Option<String>,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct Invite {
-    pub code: String,
-    pub creator: String,
-    pub channel: String,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct Ban {
-    pub id: String,
-    pub reason: String,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct Guild {
-    #[serde(rename = "_id")]
-    pub id: String,
-    // pub nonce: String, used internally
-    pub name: String,
-    pub description: String,
-    pub owner: String,
-
-    pub channels: Vec<String>,
-    pub invites: Vec<Invite>,
-    pub bans: Vec<Ban>,
-
-    pub default_permissions: u32,
-}
-
-impl Guild {
-    pub fn serialise(self) -> JsonValue {
-        json!({
-            "id": self.id,
-            "name": self.name,
-            "description": self.description,
-            "owner": self.owner
-        })
-    }
-
-    pub fn fetch_channels(&self) -> Result<Vec<super::channel::Channel>, String> {
-        super::channel::fetch_channels(&self.channels)
-    }
-
-    pub fn seralise_with_channels(self) -> Result<JsonValue, String> {
-        let channels = self
-            .fetch_channels()?
-            .into_iter()
-            .map(|x| x.serialise())
-            .collect();
-
-        let mut value = self.serialise();
-        value
-            .as_object_mut()
-            .unwrap()
-            .insert("channels".to_string(), channels);
-        Ok(value)
-    }
-}
-
-#[derive(Hash, Eq, PartialEq)]
-pub struct MemberKey(pub String, pub String);
-
-lazy_static! {
-    static ref CACHE: Arc<Mutex<LruCache<String, Guild>>> =
-        Arc::new(Mutex::new(LruCache::new(4_000_000)));
-    static ref MEMBER_CACHE: Arc<Mutex<LruCache<MemberKey, Member>>> =
-        Arc::new(Mutex::new(LruCache::new(4_000_000)));
-}
-
-pub fn fetch_guild(id: &str) -> Result<Option<Guild>, String> {
-    {
-        if let Ok(mut cache) = CACHE.lock() {
-            let existing = cache.get(&id.to_string());
-
-            if let Some(guild) = existing {
-                return Ok(Some((*guild).clone()));
-            }
-        } else {
-            return Err("Failed to lock cache.".to_string());
-        }
-    }
-
-    let col = get_collection("guilds");
-    if let Ok(result) = col.find_one(doc! { "_id": id }, None) {
-        if let Some(doc) = result {
-            if let Ok(guild) = from_bson(Bson::Document(doc)) as Result<Guild, _> {
-                let mut cache = CACHE.lock().unwrap();
-                cache.put(id.to_string(), guild.clone());
-
-                Ok(Some(guild))
-            } else {
-                Err("Failed to deserialize guild!".to_string())
-            }
-        } else {
-            Ok(None)
-        }
-    } else {
-        Err("Failed to fetch guild from database.".to_string())
-    }
-}
-
-pub fn fetch_guilds(ids: &Vec<String>) -> Result<Vec<Guild>, String> {
-    let mut missing = vec![];
-    let mut guilds = vec![];
-
-    {
-        if let Ok(mut cache) = CACHE.lock() {
-            for id in ids {
-                let existing = cache.get(id);
-
-                if let Some(guild) = existing {
-                    guilds.push((*guild).clone());
-                } else {
-                    missing.push(id);
-                }
-            }
-        } else {
-            return Err("Failed to lock cache.".to_string());
-        }
-    }
-
-    if missing.len() == 0 {
-        return Ok(guilds);
-    }
-
-    let col = get_collection("guilds");
-    if let Ok(result) = col.find(doc! { "_id": { "$in": missing } }, None) {
-        for item in result {
-            let mut cache = CACHE.lock().unwrap();
-            if let Ok(doc) = item {
-                if let Ok(guild) = from_bson(Bson::Document(doc)) as Result<Guild, _> {
-                    cache.put(guild.id.clone(), guild.clone());
-                    guilds.push(guild);
-                } else {
-                    return Err("Failed to deserialize guild!".to_string());
-                }
-            } else {
-                return Err("Failed to fetch guild.".to_string());
-            }
-        }
-
-        Ok(guilds)
-    } else {
-        Err("Failed to fetch channel from database.".to_string())
-    }
-}
-
-pub fn serialise_guilds_with_channels(ids: &Vec<String>) -> Result<Vec<JsonValue>, String> {
-    let guilds = fetch_guilds(&ids)?;
-    let cids: Vec<String> = guilds.iter().flat_map(|x| x.channels.clone()).collect();
-
-    let channels = fetch_channels(&cids)?;
-    Ok(guilds
-        .into_iter()
-        .map(|x| {
-            let id = x.id.clone();
-            let mut obj = x.serialise();
-            obj.as_object_mut().unwrap().insert(
-                "channels".to_string(),
-                channels
-                    .iter()
-                    .filter(|x| x.guild.is_some() && x.guild.as_ref().unwrap() == &id)
-                    .map(|x| x.clone().serialise())
-                    .collect(),
-            );
-            obj
-        })
-        .collect())
-}
-
-pub fn fetch_member(key: MemberKey) -> Result<Option<Member>, String> {
-    {
-        if let Ok(mut cache) = MEMBER_CACHE.lock() {
-            let existing = cache.get(&key);
-
-            if let Some(member) = existing {
-                return Ok(Some((*member).clone()));
-            }
-        } else {
-            return Err("Failed to lock cache.".to_string());
-        }
-    }
-
-    let col = get_collection("members");
-    if let Ok(result) = col.find_one(
-        doc! {
-            "_id.guild": &key.0,
-            "_id.user": &key.1,
-        },
-        None,
-    ) {
-        if let Some(doc) = result {
-            if let Ok(member) = from_bson(Bson::Document(doc)) as Result<Member, _> {
-                let mut cache = MEMBER_CACHE.lock().unwrap();
-                cache.put(key, member.clone());
-
-                Ok(Some(member))
-            } else {
-                Err("Failed to deserialize member!".to_string())
-            }
-        } else {
-            Ok(None)
-        }
-    } else {
-        Err("Failed to fetch member from database.".to_string())
-    }
-}
-
-impl<'r> FromParam<'r> for Guild {
-    type Error = &'r RawStr;
-
-    fn from_param(param: &'r RawStr) -> Result<Self, Self::Error> {
-        if let Ok(result) = fetch_guild(param) {
-            if let Some(channel) = result {
-                Ok(channel)
-            } else {
-                Err(param)
-            }
-        } else {
-            Err(param)
-        }
-    }
-}
-
-pub fn get_invite<U: Into<Option<String>>>(
-    code: &String,
-    user: U,
-) -> Option<(String, String, Invite)> {
-    let mut doc = doc! {
-        "invites": {
-            "$elemMatch": {
-                "code": &code
-            }
-        }
-    };
-
-    if let Some(user_id) = user.into() {
-        doc.insert(
-            "bans",
-            doc! {
-                "$not": {
-                    "$elemMatch": {
-                        "id": user_id
-                    }
-                }
-            },
-        );
-    }
-
-    if let Ok(result) = get_collection("guilds").find_one(
-        doc,
-        mongodb::options::FindOneOptions::builder()
-            .projection(doc! {
-                "_id": 1,
-                "name": 1,
-                "invites.$": 1,
-            })
-            .build(),
-    ) {
-        if let Some(doc) = result {
-            let invite = doc
-                .get_array("invites")
-                .unwrap()
-                .iter()
-                .next()
-                .unwrap()
-                .as_document()
-                .unwrap();
-
-            Some((
-                doc.get_str("_id").unwrap().to_string(),
-                doc.get_str("name").unwrap().to_string(),
-                from_bson(Bson::Document(invite.clone())).unwrap(),
-            ))
-        } else {
-            None
-        }
-    } else {
-        None
-    }
-}
-
-use crate::notifications::events::Notification;
-
-pub fn process_event(event: &Notification) {
-    match event {
-        Notification::guild_channel_create(_ev) => {} // ? for later use
-        Notification::guild_channel_delete(_ev) => {} // ? for later use
-        Notification::guild_delete(ev) => {
-            let mut cache = CACHE.lock().unwrap();
-            cache.pop(&ev.id);
-        }
-        Notification::guild_user_join(ev) => {
-            let mut cache = MEMBER_CACHE.lock().unwrap();
-            cache.put(
-                MemberKey(ev.id.clone(), ev.user.clone()),
-                Member {
-                    id: MemberRef {
-                        guild: ev.id.clone(),
-                        user: ev.user.clone(),
-                    },
-                    nickname: None,
-                },
-            );
-        }
-        Notification::guild_user_leave(ev) => {
-            let mut cache = MEMBER_CACHE.lock().unwrap();
-            cache.pop(&MemberKey(ev.id.clone(), ev.user.clone()));
-        }
-        _ => {}
-    }
-}

src/database/message.rs

-use super::get_collection;
-use crate::database::channel::Channel;
-use crate::notifications;
-use crate::notifications::events::message::Create;
-use crate::notifications::events::Notification;
-use crate::routes::channel::ChannelType;
-
-use mongodb::bson::from_bson;
-use mongodb::bson::{doc, to_bson, Bson, DateTime};
-use rocket::http::RawStr;
-use rocket::request::FromParam;
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct PreviousEntry {
-    pub content: String,
-    pub time: DateTime,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct Message {
-    #[serde(rename = "_id")]
-    pub id: String,
-    pub nonce: Option<String>,
-    pub channel: String,
-    pub author: String,
-
-    pub content: String,
-    pub edited: Option<DateTime>,
-
-    pub previous_content: Vec<PreviousEntry>,
-}
-
-// ? TODO: write global send message
-// ? pub fn send_message();
-// ? handle websockets?
-impl Message {
-    pub fn send(&self, target: &Channel) -> bool {
-        if get_collection("messages")
-            .insert_one(to_bson(&self).unwrap().as_document().unwrap().clone(), None)
-            .is_ok()
-        {
-            notifications::send_message_given_channel(
-                Notification::message_create(Create {
-                    id: self.id.clone(),
-                    nonce: self.nonce.clone(),
-                    channel: self.channel.clone(),
-                    author: self.author.clone(),
-                    content: self.content.clone(),
-                }),
-                &target,
-            );
-
-            let short_content: String = self.content.chars().take(24).collect();
-
-            // !! this stuff can be async
-            if target.channel_type == ChannelType::DM as u8
-                || target.channel_type == ChannelType::GROUPDM as u8
-            {
-                let mut update = doc! {
-                    "$set": {
-                        "last_message": {
-                            "id": &self.id,
-                            "user_id": &self.author,
-                            "short_content": short_content,
-                        }
-                    }
-                };
-
-                if target.channel_type == ChannelType::DM as u8 {
-                    update
-                        .get_document_mut("$set")
-                        .unwrap()
-                        .insert("active", true);
-                }
-
-                if get_collection("channels")
-                    .update_one(doc! { "_id": &target.id }, update, None)
-                    .is_ok()
-                {
-                    true
-                } else {
-                    false
-                }
-            } else {
-                true
-            }
-        } else {
-            false
-        }
-    }
-}
-
-impl<'r> FromParam<'r> for Message {
-    type Error = &'r RawStr;
-
-    fn from_param(param: &'r RawStr) -> Result<Self, Self::Error> {
-        let col = get_collection("messages");
-        let result = col
-            .find_one(doc! { "_id": param.to_string() }, None)
-            .unwrap();
-
-        if let Some(message) = result {
-            Ok(from_bson(Bson::Document(message)).expect("Failed to unwrap message."))
-        } else {
-            Err(param)
-        }
-    }
-}

src/database/migrations/init.rs

@@ -5,23 +5,58 @@ use log::info;
 use mongodb::bson::doc;
 use mongodb::options::CreateCollectionOptions;
 
-pub fn create_database() {
+pub async fn create_database() {
     info!("Creating database.");
     let db = get_db();
 
+    db.create_collection("accounts", None)
+        .await
+        .expect("Failed to create accounts collection.");
+
     db.create_collection("users", None)
+        .await
         .expect("Failed to create users collection.");
+
     db.create_collection("channels", None)
+        .await
         .expect("Failed to create channels collection.");
-    db.create_collection("guilds", None)
-        .expect("Failed to create guilds collection.");
-    db.create_collection("members", None)
-        .expect("Failed to create members collection.");
+
     db.create_collection("messages", None)
+        .await
         .expect("Failed to create messages collection.");
+
+    db.create_collection("servers", None)
+        .await
+        .expect("Failed to create servers collection.");
+
+    db.create_collection("server_members", None)
+        .await
+        .expect("Failed to create server_members collection.");
+
+    db.create_collection("server_bans", None)
+        .await
+        .expect("Failed to create server_bans collection.");
+
+    db.create_collection("channel_invites", None)
+        .await
+        .expect("Failed to create channel_invites collection.");
+
+    db.create_collection("channel_unreads", None)
+        .await
+        .expect("Failed to create channel_unreads collection.");
+
     db.create_collection("migrations", None)
+        .await
         .expect("Failed to create migrations collection.");
 
+    db.create_collection("attachments", None)
+        .await
+        .expect("Failed to create attachments collection.");
+
+    db.create_collection("user_settings", None)
+        .await
+        .expect("Failed to create user_settings collection.");
+
     db.create_collection(
         "pubsub",
         CreateCollectionOptions::builder()
@@ -29,8 +64,81 @@ pub fn create_database() {
             .size(1_000_000)
             .build(),
     )
+    .await
     .expect("Failed to create pubsub collection.");
 
+    db.run_command(
+        doc! {
+            "createIndexes": "accounts",
+            "indexes": [
+                {
+                    "key": {
+                        "email": 1
+                    },
+                    "name": "email",
+                    "unique": true,
+                    "collation": {
+                        "locale": "en",
+                        "strength": 2
+                    }
+                },
+                {
+                    "key": {
+                        "email_normalised": 1
+                    },
+                    "name": "email_normalised",
+                    "unique": true,
+                    "collation": {
+                        "locale": "en",
+                        "strength": 2
+                    }
+                }
+            ]
+        },
+        None,
+    )
+    .await
+    .expect("Failed to create account index.");
+
+    db.run_command(
+        doc! {
+            "createIndexes": "users",
+            "indexes": [
+                {
+                    "key": {
+                        "username": 1
+                    },
+                    "name": "username",
+                    "unique": true,
+                    "collation": {
+                        "locale": "en",
+                        "strength": 2
+                    }
+                }
+            ]
+        },
+        None,
+    )
+    .await
+    .expect("Failed to create username index.");
+
+    db.run_command(
+        doc! {
+            "createIndexes": "messages",
+            "indexes": [
+                {
+                    "key": {
+                        "content": "text"
+                    },
+                    "name": "content"
+                }
+            ]
+        },
+        None,
+    )
+    .await
+    .expect("Failed to create message index.");
+
     db.collection("migrations")
         .insert_one(
             doc! {
@@ -39,6 +147,7 @@ pub fn create_database() {
             },
             None,
         )
+        .await
         .expect("Failed to save migration info.");
 
     info!("Created database.");