Merge branch 'caching' into 'master'

Caching and other small changes.

See merge request revolt/delta!1

Cargo.toml

@@ -1,14 +1,13 @@
 [package]
 name = "revolt"
-version = "0.2.2"
+version = "0.2.5"
 authors = ["Paul Makles <paulmakles@gmail.com>"]
 edition = "2018"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-mongodb = "0.9.2"
+mongodb = { version = "1.1.0-beta", default-features = false, features = ["sync"] } # FIXME: rewrite database with async API
-bson = "0.14.1"
 rocket = { version = "0.4.4", default-features = false }
 once_cell = "1.3.1"
 dotenv = "0.15.0"
@@ -27,3 +26,5 @@ hashbrown = "0.7.1"
 serde_json = "1.0.51"
 rocket_cors = "0.5.2"
 bitfield = "0.13.2"
+lru = "0.5.3"
+lazy_static = "1.4.0"

src/database/channel.rs

@@ -1,33 +1,192 @@
+use super::get_collection;
+
+use lru::LruCache;
+use mongodb::bson::{doc, from_bson, Bson};
+use rocket::http::RawStr;
+use rocket::request::FromParam;
 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)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct Channel {
     #[serde(rename = "_id")]
     pub id: String,
     #[serde(rename = "type")]
     pub channel_type: u8,
 
-    // for Direct Messages
+    // DM: whether the DM is active
     pub active: Option<bool>,
-
+    // DM + GDM: last message in channel
-    // for DMs / GDMs
     pub last_message: Option<LastMessage>,
+    // DM + GDM: recipients for channel
     pub recipients: Option<Vec<String>>,
-
+    // GDM: owner of group
-    // for GDMs
     pub owner: Option<String>,
-
+    // GUILD: channel parent
-    // for Guilds
     pub guild: Option<String>,
-
+    // GUILD + GDM: channel name
-    // for Guilds and Group DMs
     pub name: Option<String>,
+    // GUILD + GDM: channel description
     pub description: Option<String>,
 }
+
+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<Option<Vec<Channel>>, String> {
+    let mut missing = vec![];
+    let mut channels = vec![];
+
+    {
+        if let Ok(mut cache) = CACHE.lock() {
+            for gid in ids {
+                let existing = cache.get(gid);
+
+                if let Some(channel) = existing {
+                    channels.push((*channel).clone());
+                } else {
+                    missing.push(gid);
+                }
+            }
+        } else {
+            return Err("Failed to lock cache.".to_string());
+        }
+    }
+
+    if missing.len() == 0 {
+        return Ok(Some(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(Some(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();
+            let entry = cache.pop(&ev.id);
+
+            if entry.is_some() {
+                let mut channel = entry.unwrap();
+                channel.recipients.as_mut().unwrap().push(ev.user.clone());
+                cache.put(ev.id.clone(), channel);
+            }
+        }
+        Notification::group_user_leave(ev) => {
+            let mut cache = CACHE.lock().unwrap();
+            let entry = cache.pop(&ev.id);
+
+            if entry.is_some() {
+                let mut channel = entry.unwrap();
+                let recipients = channel.recipients.as_mut().unwrap();
+                if let Some(pos) = recipients.iter().position(|x| *x == ev.user) {
+                    recipients.remove(pos);
+                }
+                cache.put(ev.id.clone(), channel);
+            }
+        }
+        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/guild.rs

@@ -1,20 +1,26 @@
-use bson::doc;
+use super::get_collection;
-use serde::{Deserialize, Serialize};
 
-#[derive(Serialize, Deserialize, Debug)]
+use lru::LruCache;
+use mongodb::bson::{doc, from_bson, Bson};
+use rocket::http::RawStr;
+use rocket::request::FromParam;
+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)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct Member {
     #[serde(rename = "_id")]
     pub id: MemberRef,
     pub nickname: Option<String>,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct Invite {
     pub code: String,
     pub creator: String,
@@ -27,7 +33,7 @@ pub struct Ban {
     pub reason: String,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct Guild {
     #[serde(rename = "_id")]
     pub id: String,
@@ -41,3 +47,188 @@ pub struct Guild {
 
     pub default_permissions: u32,
 }
+
+#[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_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

@@ -1,17 +1,20 @@
 use super::get_collection;
-use crate::guards::channel::ChannelRef;
+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 bson::{doc, to_bson, UtcDateTime};
+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: UtcDateTime,
+    pub time: DateTime,
 }
 
 #[derive(Serialize, Deserialize, Debug)]
@@ -23,7 +26,7 @@ pub struct Message {
     pub author: String,
 
     pub content: String,
-    pub edited: Option<UtcDateTime>,
+    pub edited: Option<DateTime>,
 
     pub previous_content: Vec<PreviousEntry>,
 }
@@ -32,7 +35,7 @@ pub struct Message {
 // ? pub fn send_message();
 // ? handle websockets?
 impl Message {
-    pub fn send(&self, target: &ChannelRef) -> bool {
+    pub fn send(&self, target: &Channel) -> bool {
         if get_collection("messages")
             .insert_one(to_bson(&self).unwrap().as_document().unwrap().clone(), None)
             .is_ok()
@@ -87,3 +90,20 @@ impl Message {
         }
     }
 }
+
+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/mod.rs

@@ -1,4 +1,5 @@
-use mongodb::{Client, Collection, Database};
+use mongodb::bson::doc;
+use mongodb::sync::{Client, Collection, Database};
 use std::env;
 
 use once_cell::sync::OnceCell;
@@ -9,6 +10,12 @@ pub fn connect() {
         Client::with_uri_str(&env::var("DB_URI").expect("DB_URI not in environment variables!"))
             .expect("Failed to init db connection.");
 
+    client
+        .database("revolt")
+        .collection("migrations")
+        .find(doc! {}, None)
+        .expect("Failed to get migration data from database.");
+
     DBCONN.set(client).unwrap();
 }
 

src/database/mutual.rs

@@ -1,6 +1,6 @@
 use super::{get_collection, MemberPermissions};
 
-use bson::doc;
+use mongodb::bson::doc;
 use mongodb::options::FindOptions;
 
 pub fn find_mutual_guilds(user_id: &str, target_id: &str) -> Vec<String> {

src/database/permissions.rs

@@ -1,9 +1,8 @@
 use super::mutual::has_mutual_connection;
-use crate::database::guild::Member;
+use crate::database::channel::Channel;
+use crate::database::guild::{fetch_guild, fetch_member, Guild, Member, MemberKey};
 use crate::database::user::UserRelationship;
 use crate::guards::auth::UserRef;
-use crate::guards::channel::ChannelRef;
-use crate::guards::guild::{get_member, GuildRef};
 
 use num_enum::TryFromPrimitive;
 
@@ -88,8 +87,8 @@ pub fn get_relationship(a: &UserRef, b: &UserRef) -> Relationship {
 
 pub struct PermissionCalculator {
     pub user: UserRef,
-    pub channel: Option<ChannelRef>,
+    pub channel: Option<Channel>,
-    pub guild: Option<GuildRef>,
+    pub guild: Option<Guild>,
     pub member: Option<Member>,
 }
 
@@ -103,14 +102,14 @@ impl PermissionCalculator {
         }
     }
 
-    pub fn channel(self, channel: ChannelRef) -> PermissionCalculator {
+    pub fn channel(self, channel: Channel) -> PermissionCalculator {
         PermissionCalculator {
             channel: Some(channel),
             ..self
         }
     }
 
-    pub fn guild(self, guild: GuildRef) -> PermissionCalculator {
+    pub fn guild(self, guild: Guild) -> PermissionCalculator {
         PermissionCalculator {
             guild: Some(guild),
             ..self
@@ -125,7 +124,11 @@ impl PermissionCalculator {
                 0..=1 => None,
                 2 => {
                     if let Some(id) = &channel.guild {
-                        GuildRef::from(id.clone())
+                        if let Ok(result) = fetch_guild(id) {
+                            result
+                        } else {
+                            None
+                        }
                     } else {
                         None
                     }
@@ -137,7 +140,9 @@ impl PermissionCalculator {
         };
 
         if let Some(guild) = &guild {
-            self.member = get_member(&guild.id, &self.user.id);
+            if let Ok(result) = fetch_member(MemberKey(guild.id.clone(), self.user.id.clone())) {
+                self.member = result;
+            }
         }
 
         self.guild = guild;
@@ -161,21 +166,17 @@ impl PermissionCalculator {
             match channel.channel_type {
                 0 => {
                     if let Some(arr) = &channel.recipients {
-                        let mut other_user = "";
+                        let mut other_user = None;
                         for item in arr {
                             if item != &self.user.id {
-                                other_user = item;
+                                other_user = Some(item);
                             }
                         }
 
-                        // ? In this case, it is a "self DM".
+                        if let Some(other) = other_user {
-                        if other_user == "" {
-                            return 1024 + 128 + 32 + 16 + 1;
-                        }
-
                             let relationships = self.user.fetch_relationships();
                             let relationship =
-                            get_relationship_internal(&self.user.id, &other_user, &relationships);
+                                get_relationship_internal(&self.user.id, &other, &relationships);
     
                             if relationship == Relationship::Friend {
                                 permissions = 1024 + 128 + 32 + 16 + 1;
@@ -183,11 +184,15 @@ impl PermissionCalculator {
                                 || relationship == Relationship::BlockedOther
                             {
                                 permissions = 1;
-                        } else if has_mutual_connection(&self.user.id, other_user, true) {
+                            } else if has_mutual_connection(&self.user.id, other, true) {
                                 permissions = 1024 + 128 + 32 + 16 + 1;
                             } else {
                                 permissions = 1;
                             }
+                        } else {
+                            // ? In this case, it is a "self DM".
+                            return 1024 + 128 + 32 + 16 + 1;
+                        }
                     }
                 }
                 1 => {

src/database/user.rs

@@ -1,12 +1,12 @@
-use bson::UtcDateTime;
+use mongodb::bson::DateTime;
 use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct UserEmailVerification {
     pub verified: bool,
     pub target: Option<String>,
-    pub expiry: Option<UtcDateTime>,
+    pub expiry: Option<DateTime>,
-    pub rate_limit: Option<UtcDateTime>,
+    pub rate_limit: Option<DateTime>,
     pub code: Option<String>,
 }
 

src/email.rs

@@ -35,6 +35,17 @@ pub fn send_verification_email(email: String, code: String) -> bool {
     .is_ok()
 }
 
+pub fn send_password_reset(email: String, code: String) -> bool {
+    let url = format!("{}/api/account/reset/{}", public_uri(), code);
+    send_email(
+        email,
+        "Reset your password.".to_string(),
+        format!("Reset your password here: {}", url),
+        format!("<a href=\"{}\">Click to reset your password!</a>", url),
+    )
+    .is_ok()
+}
+
 pub fn send_welcome_email(email: String, username: String) -> bool {
     send_email(
         email,

src/guards/auth.rs

@@ -1,4 +1,4 @@
-use bson::{doc, from_bson, Document};
+use mongodb::bson::{doc, from_bson, Bson, Document};
 use mongodb::options::FindOneOptions;
 use rocket::http::{RawStr, Status};
 use rocket::request::{self, FromParam, FromRequest, Request};
@@ -143,7 +143,7 @@ impl<'a, 'r> FromRequest<'a, 'r> for User {
 
                 if let Some(user) = result {
                     Outcome::Success(
-                        from_bson(bson::Bson::Document(user)).expect("Failed to unwrap user."),
+                        from_bson(Bson::Document(user)).expect("Failed to unwrap user."),
                     )
                 } else {
                     Outcome::Failure((Status::Forbidden, AuthError::Invalid))

src/guards/channel.rs

@@ -1,91 +0,0 @@
-use bson::{doc, from_bson, Document};
-use mongodb::options::FindOneOptions;
-use rocket::http::RawStr;
-use rocket::request::FromParam;
-use serde::{Deserialize, Serialize};
-
-use crate::database;
-
-use database::channel::LastMessage;
-use database::message::Message;
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct ChannelRef {
-    #[serde(rename = "_id")]
-    pub id: String,
-    #[serde(rename = "type")]
-    pub channel_type: u8,
-
-    pub name: Option<String>,
-    pub last_message: Option<LastMessage>,
-
-    // information required for permission calculations
-    pub recipients: Option<Vec<String>>,
-    pub guild: Option<String>,
-    pub owner: Option<String>,
-}
-
-impl ChannelRef {
-    pub fn from(id: String) -> Option<ChannelRef> {
-        match database::get_collection("channels").find_one(
-            doc! { "_id": id },
-            FindOneOptions::builder()
-                .projection(doc! {
-                    "_id": 1,
-                    "type": 1,
-                    "name": 1,
-                    "last_message": 1,
-                    "recipients": 1,
-                    "guild": 1,
-                    "owner": 1,
-                })
-                .build(),
-        ) {
-            Ok(result) => match result {
-                Some(doc) => {
-                    Some(from_bson(bson::Bson::Document(doc)).expect("Failed to unwrap channel."))
-                }
-                None => None,
-            },
-            Err(_) => None,
-        }
-    }
-
-    pub fn fetch_data(&self, projection: Document) -> Option<Document> {
-        database::get_collection("channels")
-            .find_one(
-                doc! { "_id": &self.id },
-                FindOneOptions::builder().projection(projection).build(),
-            )
-            .expect("Failed to fetch channel from database.")
-    }
-}
-
-impl<'r> FromParam<'r> for ChannelRef {
-    type Error = &'r RawStr;
-
-    fn from_param(param: &'r RawStr) -> Result<Self, Self::Error> {
-        if let Some(channel) = ChannelRef::from(param.to_string()) {
-            Ok(channel)
-        } else {
-            Err(param)
-        }
-    }
-}
-
-impl<'r> FromParam<'r> for Message {
-    type Error = &'r RawStr;
-
-    fn from_param(param: &'r RawStr) -> Result<Self, Self::Error> {
-        let col = database::get_collection("messages");
-        let result = col
-            .find_one(doc! { "_id": param.to_string() }, None)
-            .unwrap();
-
-        if let Some(message) = result {
-            Ok(from_bson(bson::Bson::Document(message)).expect("Failed to unwrap message."))
-        } else {
-            Err(param)
-        }
-    }
-}

src/guards/guild.rs

@@ -1,153 +0,0 @@
-use bson::{doc, from_bson, Bson, Document};
-use mongodb::options::FindOneOptions;
-use rocket::http::RawStr;
-use rocket::request::FromParam;
-use serde::{Deserialize, Serialize};
-
-use crate::database;
-use crate::database::guild::{Ban, Invite, Member};
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct GuildRef {
-    #[serde(rename = "_id")]
-    pub id: String,
-    pub name: String,
-    pub description: String,
-    pub owner: String,
-
-    pub bans: Vec<Ban>,
-
-    pub default_permissions: i32,
-}
-
-impl GuildRef {
-    pub fn from(id: String) -> Option<GuildRef> {
-        match database::get_collection("guilds").find_one(
-            doc! { "_id": id },
-            FindOneOptions::builder()
-                .projection(doc! {
-                    "name": 1,
-                    "description": 1,
-                    "owner": 1,
-                    "bans": 1,
-                    "default_permissions": 1
-                })
-                .build(),
-        ) {
-            Ok(result) => match result {
-                Some(doc) => {
-                    Some(from_bson(bson::Bson::Document(doc)).expect("Failed to unwrap guild."))
-                }
-                None => None,
-            },
-            Err(_) => None,
-        }
-    }
-
-    pub fn fetch_data(&self, projection: Document) -> Option<Document> {
-        database::get_collection("guilds")
-            .find_one(
-                doc! { "_id": &self.id },
-                FindOneOptions::builder().projection(projection).build(),
-            )
-            .expect("Failed to fetch guild from database.")
-    }
-
-    pub fn fetch_data_given(&self, mut filter: Document, projection: Document) -> Option<Document> {
-        filter.insert("_id", self.id.clone());
-        database::get_collection("guilds")
-            .find_one(
-                filter,
-                FindOneOptions::builder().projection(projection).build(),
-            )
-            .expect("Failed to fetch guild from database.")
-    }
-}
-
-impl<'r> FromParam<'r> for GuildRef {
-    type Error = &'r RawStr;
-
-    fn from_param(param: &'r RawStr) -> Result<Self, Self::Error> {
-        if let Some(guild) = GuildRef::from(param.to_string()) {
-            Ok(guild)
-        } else {
-            Err(param)
-        }
-    }
-}
-
-pub fn get_member(guild_id: &String, member: &String) -> Option<Member> {
-    if let Ok(result) = database::get_collection("members").find_one(
-        doc! {
-            "_id.guild": &guild_id,
-            "_id.user": &member,
-        },
-        None,
-    ) {
-        if let Some(doc) = result {
-            Some(from_bson(Bson::Document(doc)).expect("Failed to unwrap member."))
-        } else {
-            None
-        }
-    } else {
-        None
-    }
-}
-
-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) = database::get_collection("guilds").find_one(
-        doc,
-        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
-    }
-}

src/guards/mod.rs

@@ -1,3 +1 @@
 pub mod auth;
-pub mod channel;
-pub mod guild;

src/main.rs

@@ -6,6 +6,8 @@ extern crate rocket;
 extern crate rocket_contrib;
 #[macro_use]
 extern crate bitfield;
+#[macro_use]
+extern crate lazy_static;
 
 pub mod database;
 pub mod email;

src/notifications/events/mod.rs

@@ -38,4 +38,8 @@ impl Notification {
             unreachable!()
         }
     }
+
+    pub fn push_to_cache(&self) {
+        crate::database::channel::process_event(&self);
+    }
 }

src/notifications/mod.rs

@@ -1,4 +1,4 @@
-use crate::guards::channel::ChannelRef;
+use crate::database::channel::Channel;
 
 use once_cell::sync::OnceCell;
 use std::sync::mpsc::{channel, Sender};
@@ -17,6 +17,8 @@ pub fn send_message<U: Into<Option<Vec<String>>>, G: Into<Option<String>>>(
     let users = users.into();
     let guild = guild.into();
 
+    data.push_to_cache();
+
     if pubsub::send_message(users.clone(), guild.clone(), data.clone()) {
         state::send_message(users, guild, data.serialize());
 
@@ -65,7 +67,7 @@ pub fn send_message_threaded<U: Into<Option<Vec<String>>>, G: Into<Option<String
     }
 }
 
-pub fn send_message_given_channel(data: events::Notification, channel: &ChannelRef) {
+pub fn send_message_given_channel(data: events::Notification, channel: &Channel) {
     match channel.channel_type {
         0..=1 => send_message_threaded(channel.recipients.clone(), None, data),
         2 => send_message_threaded(None, channel.guild.clone(), data),

src/notifications/pubsub.rs

@@ -1,7 +1,7 @@
 use super::events::Notification;
 use crate::database::get_collection;
 
-use bson::{doc, from_bson, to_bson, Bson};
+use mongodb::bson::{doc, from_bson, to_bson, Bson};
 use mongodb::options::{CursorType, FindOneOptions, FindOptions};
 use serde::{Deserialize, Serialize};
 use std::time::Duration;

src/notifications/state.rs

@@ -1,8 +1,8 @@
 use crate::database;
 use crate::util::vec_to_set;
 
-use bson::doc;
 use hashbrown::{HashMap, HashSet};
+use mongodb::bson::doc;
 use mongodb::options::FindOneOptions;
 use once_cell::sync::OnceCell;
 use std::sync::RwLock;

src/routes/account.rs

@@ -4,9 +4,9 @@ use crate::email;
 use crate::util::gen_token;
 
 use bcrypt::{hash, verify};
-use bson::{doc, from_bson, Bson::UtcDatetime};
 use chrono::prelude::*;
 use database::user::User;
+use mongodb::bson::{doc, from_bson, Bson};
 use rocket_contrib::json::Json;
 use serde::{Deserialize, Serialize};
 use ulid::Ulid;
@@ -75,8 +75,8 @@ pub fn create(info: Json<Create>) -> Response {
                 "email_verification": {
                     "verified": false,
                     "target": info.email.clone(),
-                    "expiry": UtcDatetime(Utc::now() + chrono::Duration::days(1)),
+                    "expiry": Bson::DateTime(Utc::now() + chrono::Duration::days(1)),
-                    "rate_limit": UtcDatetime(Utc::now() + chrono::Duration::minutes(1)),
+                    "rate_limit": Bson::DateTime(Utc::now() + chrono::Duration::minutes(1)),
                     "code": code.clone(),
                 }
             },
@@ -110,7 +110,7 @@ pub fn verify_email(code: String) -> Response {
         .find_one(doc! { "email_verification.code": code.clone() }, None)
         .expect("Failed user lookup")
     {
-        let user: User = from_bson(bson::Bson::Document(u)).expect("Failed to unwrap user.");
+        let user: User = from_bson(Bson::Document(u)).expect("Failed to unwrap user.");
         let ev = user.email_verification;
 
         if Utc::now() > *ev.expiry.unwrap() {
@@ -140,9 +140,7 @@ pub fn verify_email(code: String) -> Response {
 
             email::send_welcome_email(target.to_string(), user.username);
 
-            Response::Redirect(
+            Response::Redirect(super::Redirect::to("https://app.revolt.chat"))
-                super::Redirect::to("https://app.revolt.chat"),
-            )
         }
     } else {
         Response::BadRequest(json!({ "error": "Invalid code." }))
@@ -169,7 +167,7 @@ pub fn resend_email(info: Json<Resend>) -> Response {
         )
         .expect("Failed user lookup.")
     {
-        let user: User = from_bson(bson::Bson::Document(u)).expect("Failed to unwrap user.");
+        let user: User = from_bson(Bson::Document(u)).expect("Failed to unwrap user.");
         let ev = user.email_verification;
 
         let expiry = ev.expiry.unwrap();
@@ -180,7 +178,7 @@ pub fn resend_email(info: Json<Resend>) -> Response {
                 json!({ "error": "You are being rate limited, please try again in a while." }),
             )
         } else {
-            let mut new_expiry = UtcDatetime(Utc::now() + chrono::Duration::days(1));
+            let mut new_expiry = Bson::DateTime(Utc::now() + chrono::Duration::days(1));
             if info.email.clone() != user.email {
                 if Utc::now() > *expiry {
                     return Response::Gone(
@@ -188,7 +186,7 @@ pub fn resend_email(info: Json<Resend>) -> Response {
                     );
                 }
 
-                new_expiry = UtcDatetime(*expiry);
+                new_expiry = Bson::DateTime(*expiry);
             }
 
             let code = gen_token(48);
@@ -198,7 +196,7 @@ pub fn resend_email(info: Json<Resend>) -> Response {
 						"$set": {
 							"email_verification.code": code.clone(),
 							"email_verification.expiry": new_expiry,
-							"email_verification.rate_limit": UtcDatetime(Utc::now() + chrono::Duration::minutes(1)),
+							"email_verification.rate_limit": Bson::DateTime(Utc::now() + chrono::Duration::minutes(1)),
 						},
 					},
 					None,
@@ -234,7 +232,7 @@ pub fn login(info: Json<Login>) -> Response {
         .find_one(doc! { "email": info.email.clone() }, None)
         .expect("Failed user lookup")
     {
-        let user: User = from_bson(bson::Bson::Document(u)).expect("Failed to unwrap user.");
+        let user: User = from_bson(Bson::Document(u)).expect("Failed to unwrap user.");
 
         match verify(info.password.clone(), &user.password)
             .expect("Failed to check hash of password.")

src/routes/channel.rs

@@ -1,18 +1,17 @@
 use super::Response;
 use crate::database::{
-    self, get_relationship, get_relationship_internal, message::Message, Permission,
+    self, channel::Channel, get_relationship, get_relationship_internal, message::Message,
-    PermissionCalculator, Relationship,
+    Permission, PermissionCalculator, Relationship,
 };
 use crate::guards::auth::UserRef;
-use crate::guards::channel::ChannelRef;
 use crate::notifications::{
     self,
     events::{groups::*, guilds::ChannelDelete, message::*, Notification},
 };
 use crate::util::vec_to_set;
 
-use bson::{doc, from_bson, Bson, Bson::UtcDatetime};
 use chrono::prelude::*;
+use mongodb::bson::{doc, from_bson, Bson};
 use mongodb::options::FindOptions;
 use num_enum::TryFromPrimitive;
 use rocket::request::Form;
@@ -130,7 +129,7 @@ pub fn create_group(user: UserRef, info: Json<CreateGroup>) -> Response {
 
 /// fetch channel information
 #[get("/<target>")]
-pub fn channel(user: UserRef, target: ChannelRef) -> Option<Response> {
+pub fn channel(user: UserRef, target: Channel) -> Option<Response> {
     with_permissions!(user, target);
 
     match target.channel_type {
@@ -141,39 +140,39 @@ pub fn channel(user: UserRef, target: ChannelRef) -> Option<Response> {
             "recipients": target.recipients,
         }))),
         1 => {
-            if let Some(info) = target.fetch_data(doc! {
+            /*if let Some(info) = target.fetch_data(doc! {
                 "name": 1,
                 "description": 1,
                 "owner": 1,
-            }) {
+            }) {*/
             Some(Response::Success(json!({
                 "id": target.id,
                 "type": target.channel_type,
                 "last_message": target.last_message,
                 "recipients": target.recipients,
-                    "name": info.get_str("name").unwrap(),
+                "name": target.name,
-                    "owner": info.get_str("owner").unwrap(),
+                "owner": target.owner,
-                    "description": info.get_str("description").unwrap_or(""),
+                "description": target.description,
             })))
-            } else {
+            /*} else {
                 None
-            }
+            }*/
         }
         2 => {
-            if let Some(info) = target.fetch_data(doc! {
+            /*if let Some(info) = target.fetch_data(doc! {
                 "name": 1,
                 "description": 1,
-            }) {
+            }) {*/
             Some(Response::Success(json!({
                 "id": target.id,
                 "type": target.channel_type,
                 "guild": target.guild,
-                    "name": info.get_str("name").unwrap(),
+                "name": target.name,
-                    "description": info.get_str("description").unwrap_or(""),
+                "description": target.description,
             })))
-            } else {
+            /*} else {
                 None
-            }
+            }*/
         }
         _ => unreachable!(),
     }
@@ -181,7 +180,7 @@ pub fn channel(user: UserRef, target: ChannelRef) -> Option<Response> {
 
 /// [groups] add user to channel
 #[put("/<target>/recipients/<member>")]
-pub fn add_member(user: UserRef, target: ChannelRef, member: UserRef) -> Option<Response> {
+pub fn add_member(user: UserRef, target: Channel, member: UserRef) -> Option<Response> {
     if target.channel_type != 1 {
         return Some(Response::BadRequest(json!({ "error": "Not a group DM." })));
     }
@@ -255,7 +254,7 @@ pub fn add_member(user: UserRef, target: ChannelRef, member: UserRef) -> Option<
 
 /// [groups] remove user from channel
 #[delete("/<target>/recipients/<member>")]
-pub fn remove_member(user: UserRef, target: ChannelRef, member: UserRef) -> Option<Response> {
+pub fn remove_member(user: UserRef, target: Channel, member: UserRef) -> Option<Response> {
     if target.channel_type != 1 {
         return Some(Response::BadRequest(json!({ "error": "Not a group DM." })));
     }
@@ -327,7 +326,7 @@ pub fn remove_member(user: UserRef, target: ChannelRef, member: UserRef) -> Opti
 /// or leave group DM
 /// or close DM conversation
 #[delete("/<target>")]
-pub fn delete(user: UserRef, target: ChannelRef) -> Option<Response> {
+pub fn delete(user: UserRef, target: Channel) -> Option<Response> {
     let permissions = with_permissions!(user, target);
 
     if !permissions.get_manage_channels() {
@@ -490,7 +489,7 @@ pub struct MessageFetchOptions {
 #[get("/<target>/messages?<options..>")]
 pub fn messages(
     user: UserRef,
-    target: ChannelRef,
+    target: Channel,
     options: Form<MessageFetchOptions>,
 ) -> Option<Response> {
     let permissions = with_permissions!(user, target);
@@ -532,7 +531,7 @@ pub fn messages(
     let mut messages = Vec::new();
     for item in result {
         let message: Message =
-            from_bson(bson::Bson::Document(item.unwrap())).expect("Failed to unwrap message.");
+            from_bson(Bson::Document(item.unwrap())).expect("Failed to unwrap message.");
         messages.push(json!({
             "id": message.id,
             "author": message.author,
@@ -554,7 +553,7 @@ pub struct SendMessage {
 #[post("/<target>/messages", data = "<message>")]
 pub fn send_message(
     user: UserRef,
-    target: ChannelRef,
+    target: Channel,
     message: Json<SendMessage>,
 ) -> Option<Response> {
     let permissions = with_permissions!(user, target);
@@ -609,7 +608,7 @@ pub fn send_message(
 
 /// get a message
 #[get("/<target>/messages/<message>")]
-pub fn get_message(user: UserRef, target: ChannelRef, message: Message) -> Option<Response> {
+pub fn get_message(user: UserRef, target: Channel, message: Message) -> Option<Response> {
     let permissions = with_permissions!(user, target);
 
     if !permissions.get_read_messages() {
@@ -643,7 +642,7 @@ pub struct EditMessage {
 #[patch("/<target>/messages/<message>", data = "<edit>")]
 pub fn edit_message(
     user: UserRef,
-    target: ChannelRef,
+    target: Channel,
     message: Message,
     edit: Json<EditMessage>,
 ) -> Option<Response> {
@@ -668,7 +667,7 @@ pub fn edit_message(
         doc! {
             "$set": {
                 "content": &edit.content,
-                "edited": UtcDatetime(edited)
+                "edited": Bson::DateTime(edited)
             },
             "$push": {
                 "previous_content": {
@@ -700,7 +699,7 @@ pub fn edit_message(
 
 /// delete a message
 #[delete("/<target>/messages/<message>")]
-pub fn delete_message(user: UserRef, target: ChannelRef, message: Message) -> Option<Response> {
+pub fn delete_message(user: UserRef, target: Channel, message: Message) -> Option<Response> {
     let permissions = with_permissions!(user, target);
 
     if !permissions.get_manage_messages() {

src/routes/guild.rs

@@ -1,16 +1,17 @@
 use super::channel::ChannelType;
 use super::Response;
-use crate::database::{self, channel::Channel, Permission, PermissionCalculator};
+use crate::database::guild::{fetch_member as get_member, get_invite, Guild, MemberKey};
+use crate::database::{
+    self, channel::fetch_channel, channel::Channel, Permission, PermissionCalculator,
+};
 use crate::guards::auth::UserRef;
-use crate::guards::channel::ChannelRef;
-use crate::guards::guild::{get_invite, get_member, GuildRef};
 use crate::notifications::{
     self,
     events::{guilds::*, Notification},
 };
 use crate::util::gen_token;
 
-use bson::{doc, from_bson, Bson};
+use mongodb::bson::{doc, from_bson, Bson};
 use mongodb::options::{FindOneOptions, FindOptions};
 use rocket::request::Form;
 use rocket_contrib::json::Json;
@@ -92,7 +93,7 @@ pub fn my_guilds(user: UserRef) -> Response {
 
 /// fetch a guild
 #[get("/<target>")]
-pub fn guild(user: UserRef, target: GuildRef) -> Option<Response> {
+pub fn guild(user: UserRef, target: Guild) -> Option<Response> {
     with_permissions!(user, target);
 
     let col = database::get_collection("channels");
@@ -107,9 +108,7 @@ pub fn guild(user: UserRef, target: GuildRef) -> Option<Response> {
             let mut channels = vec![];
             for item in results {
                 if let Ok(entry) = item {
-                    if let Ok(channel) =
+                    if let Ok(channel) = from_bson(Bson::Document(entry)) as Result<Channel, _> {
-                        from_bson(bson::Bson::Document(entry)) as Result<Channel, _>
-                    {
                         channels.push(json!({
                             "id": channel.id,
                             "name": channel.name,
@@ -135,7 +134,7 @@ pub fn guild(user: UserRef, target: GuildRef) -> Option<Response> {
 
 /// delete or leave a guild
 #[delete("/<target>")]
-pub fn remove_guild(user: UserRef, target: GuildRef) -> Option<Response> {
+pub fn remove_guild(user: UserRef, target: Guild) -> Option<Response> {
     with_permissions!(user, target);
 
     if user.id == target.owner {
@@ -174,6 +173,15 @@ pub fn remove_guild(user: UserRef, target: GuildRef) -> Option<Response> {
                         None,
                     )
                     .is_ok()
+                {
+                    if database::get_collection("members")
+                        .delete_many(
+                            doc! {
+                                "_id.guild": &target.id,
+                            },
+                            None,
+                        )
+                        .is_ok()
                     {
                         if database::get_collection("guilds")
                             .delete_one(
@@ -198,6 +206,11 @@ pub fn remove_guild(user: UserRef, target: GuildRef) -> Option<Response> {
                                 json!({ "error": "Failed to delete guild." }),
                             ))
                         }
+                    } else {
+                        Some(Response::InternalServerError(
+                            json!({ "error": "Failed to delete guild members." }),
+                        ))
+                    }
                 } else {
                     Some(Response::InternalServerError(
                         json!({ "error": "Failed to delete guild channels." }),
@@ -252,11 +265,7 @@ pub struct CreateChannel {
 
 /// create a new channel
 #[post("/<target>/channels", data = "<info>")]
-pub fn create_channel(
+pub fn create_channel(user: UserRef, target: Guild, info: Json<CreateChannel>) -> Option<Response> {
-    user: UserRef,
-    target: GuildRef,
-    info: Json<CreateChannel>,
-) -> Option<Response> {
     let (permissions, _) = with_permissions!(user, target);
 
     if !permissions.get_manage_channels() {
@@ -330,8 +339,8 @@ pub struct InviteOptions {
 #[post("/<target>/channels/<channel>/invite", data = "<_options>")]
 pub fn create_invite(
     user: UserRef,
-    target: GuildRef,
+    target: Guild,
-    channel: ChannelRef,
+    channel: Channel,
     _options: Json<InviteOptions>,
 ) -> Option<Response> {
     let (permissions, _) = with_permissions!(user, target);
@@ -367,7 +376,7 @@ pub fn create_invite(
 
 /// remove an invite
 #[delete("/<target>/invites/<code>")]
-pub fn remove_invite(user: UserRef, target: GuildRef, code: String) -> Option<Response> {
+pub fn remove_invite(user: UserRef, target: Guild, code: String) -> Option<Response> {
     let (permissions, _) = with_permissions!(user, target);
 
     if let Some((guild_id, _, invite)) = get_invite(&code, None) {
@@ -408,29 +417,23 @@ pub fn remove_invite(user: UserRef, target: GuildRef, code: String) -> Option<Re
 
 /// fetch all guild invites
 #[get("/<target>/invites")]
-pub fn fetch_invites(user: UserRef, target: GuildRef) -> Option<Response> {
+pub fn fetch_invites(user: UserRef, target: Guild) -> Option<Response> {
     let (permissions, _) = with_permissions!(user, target);
 
     if !permissions.get_manage_server() {
         return Some(Response::LackingPermission(Permission::ManageServer));
     }
 
-    if let Some(doc) = target.fetch_data(doc! {
+    Some(Response::Success(json!(target.invites)))
-        "invites": 1,
-    }) {
-        Some(Response::Success(json!(doc.get_array("invites").unwrap())))
-    } else {
-        Some(Response::InternalServerError(
-            json!({ "error": "Failed to fetch invites." }),
-        ))
-    }
 }
 
 /// view an invite before joining
 #[get("/join/<code>", rank = 1)]
 pub fn fetch_invite(user: UserRef, code: String) -> Response {
     if let Some((guild_id, name, invite)) = get_invite(&code, user.id) {
-        if let Some(channel) = ChannelRef::from(invite.channel) {
+        match fetch_channel(&invite.channel) {
+            Ok(result) => {
+                if let Some(channel) = result {
                     Response::Success(json!({
                         "guild": {
                             "id": guild_id,
@@ -442,7 +445,10 @@ pub fn fetch_invite(user: UserRef, code: String) -> Response {
                         }
                     }))
                 } else {
-            Response::BadRequest(json!({ "error": "Failed to fetch channel." }))
+                    Response::NotFound(json!({ "error": "Channel does not exist." }))
+                }
+            }
+            Err(err) => Response::InternalServerError(json!({ "error": err })),
         }
     } else {
         Response::NotFound(json!({ "error": "Failed to fetch invite or code is invalid." }))
@@ -605,7 +611,7 @@ pub fn create_guild(user: UserRef, info: Json<CreateGuild>) -> Response {
 
 /// fetch a guild's member
 #[get("/<target>/members")]
-pub fn fetch_members(user: UserRef, target: GuildRef) -> Option<Response> {
+pub fn fetch_members(user: UserRef, target: Guild) -> Option<Response> {
     with_permissions!(user, target);
 
     if let Ok(result) =
@@ -632,14 +638,20 @@ pub fn fetch_members(user: UserRef, target: GuildRef) -> Option<Response> {
 
 /// fetch a guild member
 #[get("/<target>/members/<other>")]
-pub fn fetch_member(user: UserRef, target: GuildRef, other: String) -> Option<Response> {
+pub fn fetch_member(user: UserRef, target: Guild, other: String) -> Option<Response> {
     with_permissions!(user, target);
 
-    if let Some(member) = get_member(&target.id, &other) {
+    if let Ok(result) = get_member(MemberKey(target.id, user.id)) {
+        if let Some(member) = result {
             Some(Response::Success(json!({
                 "id": member.id.user,
                 "nickname": member.nickname,
             })))
+        } else {
+            Some(Response::NotFound(
+                json!({ "error": "Member does not exist!" }),
+            ))
+        }
     } else {
         Some(Response::InternalServerError(
             json!({ "error": "Failed to fetch member or user does not exist." }),
@@ -649,7 +661,7 @@ pub fn fetch_member(user: UserRef, target: GuildRef, other: String) -> Option<Re
 
 /// kick a guild member
 #[delete("/<target>/members/<other>")]
-pub fn kick_member(user: UserRef, target: GuildRef, other: String) -> Option<Response> {
+pub fn kick_member(user: UserRef, target: Guild, other: String) -> Option<Response> {
     let (permissions, _) = with_permissions!(user, target);
 
     if user.id == other {
@@ -662,11 +674,15 @@ pub fn kick_member(user: UserRef, target: GuildRef, other: String) -> Option<Res
         return Some(Response::LackingPermission(Permission::KickMembers));
     }
 
-    if get_member(&target.id, &other).is_none() {
+    if let Ok(result) = get_member(MemberKey( target.id.clone(), other.clone() )) {
+        if result.is_none() {
             return Some(Response::BadRequest(
                 json!({ "error": "User not part of guild." }),
             ));
         }
+    } else {
+        return Some(Response::InternalServerError(json!({ "error": "Failed to fetch member." })))
+    }
 
     if database::get_collection("members")
         .delete_one(
@@ -705,7 +721,7 @@ pub struct BanOptions {
 #[put("/<target>/members/<other>/ban?<options..>")]
 pub fn ban_member(
     user: UserRef,
-    target: GuildRef,
+    target: Guild,
     other: String,
     options: Form<BanOptions>,
 ) -> Option<Response> {
@@ -728,11 +744,15 @@ pub fn ban_member(
         return Some(Response::LackingPermission(Permission::BanMembers));
     }
 
-    if get_member(&target.id, &other).is_none() {
+    if let Ok(result) = get_member(MemberKey( target.id.clone(), other.clone() )) {
+        if result.is_none() {
             return Some(Response::BadRequest(
                 json!({ "error": "User not part of guild." }),
             ));
         }
+    } else {
+        return Some(Response::InternalServerError(json!({ "error": "Failed to fetch member." })))
+    }
 
     if database::get_collection("guilds")
         .update_one(
@@ -784,7 +804,7 @@ pub fn ban_member(
 
 /// unban a guild member
 #[delete("/<target>/members/<other>/ban")]
-pub fn unban_member(user: UserRef, target: GuildRef, other: String) -> Option<Response> {
+pub fn unban_member(user: UserRef, target: Guild, other: String) -> Option<Response> {
     let (permissions, _) = with_permissions!(user, target);
 
     if user.id == other {
@@ -797,19 +817,7 @@ pub fn unban_member(user: UserRef, target: GuildRef, other: String) -> Option<Re
         return Some(Response::LackingPermission(Permission::BanMembers));
     }
 
-    if target
+    if target.bans.iter().any(|v| v.id == other) {
-        .fetch_data_given(
-            doc! {
-                "bans": {
-                    "$elemMatch": {
-                        "id": &other
-                    }
-                }
-            },
-            doc! {},
-        )
-        .is_none()
-    {
         return Some(Response::BadRequest(json!({ "error": "User not banned." })));
     }
 

src/routes/mod.rs

@@ -63,7 +63,7 @@ impl<'a> rocket::response::Responder<'a> for Permission {
 
 pub fn mount(rocket: Rocket) -> Rocket {
     rocket
-        .mount("/", routes![root::root, root::teapot])
+        .mount("/", routes![root::root, root::root_preflight, root::teapot])
         .mount(
             "/account",
             routes![

src/routes/root.rs

@@ -1,15 +1,20 @@
 use super::Response;
 
-use bson::doc;
+use mongodb::bson::doc;
 
 /// root
 #[get("/")]
 pub fn root() -> Response {
     Response::Success(json!({
-        "revolt": "0.2.2"
+        "revolt": "0.2.5"
     }))
 }
 
+#[options("/")]
+pub fn root_preflight() -> Response {
+    Response::Result(super::Status::Ok)
+}
+
 /// I'm a teapot.
 #[delete("/")]
 pub fn teapot() -> Response {

src/routes/user.rs

@@ -7,8 +7,8 @@ use crate::notifications::{
 };
 use crate::routes::channel;
 
-use bson::doc;
+use mongodb::bson::doc;
-use mongodb::options::{Collation, FindOptions, FindOneOptions};
+use mongodb::options::{Collation, FindOneOptions, FindOptions};
 use rocket_contrib::json::Json;
 use serde::{Deserialize, Serialize};
 use ulid::Ulid;
@@ -61,13 +61,8 @@ pub fn query(user: UserRef, query: Json<UserQuery>) -> Response {
     if let Ok(result) = col.find_one(
         doc! { "username": query.username.clone() },
         FindOneOptions::builder()
-            .collation(
+            .collation(Collation::builder().locale("en").strength(2).build())
-                Collation::builder()
+            .build(),
-                    .locale("en")
-                    .strength(2)
-                    .build()
-            )
-            .build()
     ) {
         if let Some(doc) = result {
             let id = doc.get_str("_id").unwrap();
@@ -148,6 +143,7 @@ pub fn dms(user: UserRef) -> Response {
         for item in results {
             if let Ok(doc) = item {
                 let id = doc.get_str("_id").unwrap();
+                let last_message = doc.get_document("last_message").unwrap();
                 let recipients = doc.get_array("recipients").unwrap();
 
                 match doc.get_i32("type").unwrap() {
@@ -155,6 +151,7 @@ pub fn dms(user: UserRef) -> Response {
                         channels.push(json!({
                             "id": id,
                             "type": 0,
+                            "last_message": last_message,
                             "recipients": recipients,
                         }));
                     }