Fix docker run.sh

Caching and other small changes.

See merge request revolt/delta!1

.dockerignore

@@ -0,0 +1,3 @@
+assets
+target
+.env

.gitignore

@@ -1,3 +1,4 @@
+Rocket.toml
 /target
 **/*.rs.bk
 .env

.gitlab-ci.yml

@@ -0,0 +1,20 @@
+stages:
+  - build
+
+# Rocket does not currently compile on stable Rust.
+# Once it does, we can uncomment this, and instead
+# put `allow-failure: true` on the nightly build.
+#
+# rust-latest:
+#   stage: build
+#   image: rust:latest
+#   script:
+#     - cargo build --verbose
+#     - cargo test --verbose
+
+rust-nightly:
+  stage: build
+  image: rustlang/rust:nightly
+  script:
+    - cargo build --verbose
+    - cargo test --verbose

Cargo.toml

@@ -1,29 +1,33 @@
 [package]
 name = "revolt"
-version = "0.1.0"
+version = "0.2.10"
 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"
-bson = "0.14.1"
-rocket = { version = "0.4.4", default-features = false }
-once_cell = "1.3.1"
+mongodb = { version = "1.1.0", default-features = false, features = ["sync"] } # FIXME: rewrite database with async API
+rocket = { version = "0.4.5", default-features = false }
+once_cell = "1.4.1"
 dotenv = "0.15.0"
-ulid = "0.3.1"
-serde = { version = "1.0", features = ["derive"] }
-rocket_contrib = "0.4.4"
-validator = "0.10.0"
-bcrypt = "0.7.0"
-chrono = "0.4.11"
+ulid = "0.4.0"
+serde = { version = "1.0.115", features = ["derive"] }
+rocket_contrib = "0.4.5"
+validator = "0.10.1"
+bcrypt = "0.8.2"
+chrono = "0.4.15"
 rand = "0.7.3"
-time = "0.2.9"
-reqwest = { version = "0.10.4", features = ["blocking", "json"] }
-num_enum = "0.4.3"
+time = "0.2.16"
+reqwest = { version = "0.10.8", features = ["blocking", "json"] }
+num_enum = "0.5.1"
 ws = "0.9.1"
-hashbrown = "0.7.1"
-serde_json = "1.0.51"
+hashbrown = "0.8.2"
+serde_json = "1.0.57"
 rocket_cors = "0.5.2"
 bitfield = "0.13.2"
+lru = "0.6.0"
+lazy_static = "1.4.0"
+log = "0.4.11"
+env_logger = "0.7.1"
+lettre = "0.10.0-alpha.1"

Dockerfile

@@ -0,0 +1,16 @@
+# Build Stage
+FROM ekidd/rust-musl-builder:nightly-2020-08-26 AS builder
+WORKDIR /home/rust/src
+
+RUN USER=root cargo new --bin revolt
+WORKDIR ./revolt
+COPY Cargo.toml Cargo.lock ./
+COPY src ./src
+RUN cargo build --release
+
+# Bundle Stage
+FROM scratch
+COPY --from=builder /home/rust/src/revolt/target/x86_64-unknown-linux-musl/release/revolt ./
+EXPOSE 8000
+EXPOSE 9000
+CMD ["./revolt"]

README.md

@@ -0,0 +1,20 @@
+![](assets/banner.png)
+
+Delta is a **blazing fast API server** built with Rust for the REVOLT platform.
+
+Features:
+- Robust and efficient API routes for running a chat platform.
+- Distributed notification system, allowing any node to be seamlessly connected.
+- Simple deployment, based mostly on pure Rust code and libraries.
+- Hooks up to a MongoDB deployment, provide URI and no extra work needed.
+
+## Docker Helper Scripts
+
+If you have Docker installed, you can use the helper scripts to deploy Revolt in your development environment.
+
+```bash
+./build.sh   # build Docker image
+./run.sh     # run Docker container
+./monitor.sh # view container logs
+./remove.sh  # kill and remove container
+```

Rocket.toml

@@ -1,7 +0,0 @@
-[development]
-address = "192.168.0.10"
-port = 5500
-
-[production]
-address = "192.168.0.10"
-port = 5500

build.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+docker build -t revolt --progress plain .

monitor.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+docker logs -f revolt

remove.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+echo "Removing Revolt container."
+docker kill revolt
+docker rm revolt

run.sh

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

src/database/channel.rs

@@ -1,33 +1,215 @@
+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)]
+#[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>,
-
-    // for DMs / GDMs
+    // DM + GDM: last message in channel
     pub last_message: Option<LastMessage>,
+    // DM + GDM: recipients for channel
     pub recipients: Option<Vec<String>>,
-
-    // for GDMs
+    // GDM: owner of group
     pub owner: Option<String>,
-
-    // for Guilds
+    // GUILD: channel parent
     pub guild: Option<String>,
-
-    // for Guilds and Group DMs
+    // 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/guild.rs

@@ -1,20 +1,28 @@
-use bson::doc;
-use serde::{Deserialize, Serialize};
+use super::channel::fetch_channels;
+use super::get_collection;
 
-#[derive(Serialize, Deserialize, Debug)]
+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)]
+#[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 +35,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,
@@ -36,8 +44,293 @@ pub struct Guild {
     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

@@ -1,26 +1,109 @@
-use bson::UtcDateTime;
+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: UtcDateTime,
+    pub time: DateTime,
 }
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct Message {
     #[serde(rename = "_id")]
     pub id: String,
-    // pub nonce: String, used internally
+    pub nonce: Option<String>,
     pub channel: String,
     pub author: String,
 
     pub content: String,
-    pub edited: Option<UtcDateTime>,
+    pub edited: Option<DateTime>,
 
-    pub previous_content: Option<Vec<PreviousEntry>>,
+    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

@@ -0,0 +1,45 @@
+use super::super::get_db;
+use super::scripts::LATEST_REVISION;
+
+use log::info;
+use mongodb::bson::doc;
+use mongodb::options::CreateCollectionOptions;
+
+pub fn create_database() {
+    info!("Creating database.");
+    let db = get_db();
+
+    db.create_collection("users", None)
+        .expect("Failed to create users collection.");
+    db.create_collection("channels", None)
+        .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)
+        .expect("Failed to create messages collection.");
+    db.create_collection("migrations", None)
+        .expect("Failed to create migrations collection.");
+
+    db.create_collection(
+        "pubsub",
+        CreateCollectionOptions::builder()
+            .capped(true)
+            .size(1_000_000)
+            .build(),
+    )
+    .expect("Failed to create pubsub collection.");
+
+    db.collection("migrations")
+        .insert_one(
+            doc! {
+                "_id": 0,
+                "revision": LATEST_REVISION
+            },
+            None,
+        )
+        .expect("Failed to save migration info.");
+
+    info!("Created database.");
+}

src/database/migrations/mod.rs

@@ -0,0 +1,18 @@
+use super::get_connection;
+
+pub mod init;
+pub mod scripts;
+
+pub fn run_migrations() {
+    let client = get_connection();
+
+    let list = client
+        .list_database_names(None, None)
+        .expect("Failed to fetch database names.");
+
+    if list.iter().position(|x| x == "revolt").is_none() {
+        init::create_database();
+    } else {
+        scripts::migrate_database();
+    }
+}

src/database/migrations/scripts.rs

@@ -0,0 +1,119 @@
+use super::super::get_collection;
+
+use log::info;
+use mongodb::bson::{doc, from_bson, Bson};
+use mongodb::options::FindOptions;
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize)]
+struct MigrationInfo {
+    _id: i32,
+    revision: i32,
+}
+
+pub const LATEST_REVISION: i32 = 2;
+
+pub fn migrate_database() {
+    let migrations = get_collection("migrations");
+    let data = migrations
+        .find_one(None, None)
+        .expect("Failed to fetch migration data.");
+
+    if let Some(doc) = data {
+        let info: MigrationInfo =
+            from_bson(Bson::Document(doc)).expect("Failed to read migration information.");
+
+        let revision = run_migrations(info.revision);
+
+        migrations
+            .update_one(
+                doc! {
+                    "_id": info._id
+                },
+                doc! {
+                    "$set": {
+                        "revision": revision
+                    }
+                },
+                None,
+            )
+            .expect("Failed to commit migration information.");
+
+        info!("Migration complete. Currently at revision {}.", revision);
+    } else {
+        panic!("Database was configured incorrectly, possibly because initalization failed.")
+    }
+}
+
+pub fn run_migrations(revision: i32) -> i32 {
+    info!("Starting database migration.");
+
+    if revision <= 0 {
+        info!("Running migration [revision 0]: Test migration system.");
+    }
+
+    if revision <= 1 {
+        info!("Running migration [revision 1]: Add channels to guild object.");
+
+        let col = get_collection("guilds");
+        let guilds = col
+            .find(
+                None,
+                FindOptions::builder().projection(doc! { "_id": 1 }).build(),
+            )
+            .expect("Failed to fetch guilds.");
+
+        let result = get_collection("channels")
+            .find(
+                doc! {
+                    "type": 2
+                },
+                FindOptions::builder()
+                    .projection(doc! { "_id": 1, "guild": 1 })
+                    .build(),
+            )
+            .expect("Failed to fetch channels.");
+
+        let mut channels = vec![];
+        for doc in result {
+            let channel = doc.expect("Failed to fetch channel.");
+            let id = channel
+                .get_str("_id")
+                .expect("Failed to get channel id.")
+                .to_string();
+            let gid = channel
+                .get_str("guild")
+                .expect("Failed to get guild id.")
+                .to_string();
+
+            channels.push((id, gid));
+        }
+
+        for doc in guilds {
+            let guild = doc.expect("Failed to fetch guild.");
+            let id = guild.get_str("_id").expect("Failed to get guild id.");
+
+            let list: Vec<String> = channels
+                .iter()
+                .filter(|x| x.1 == id)
+                .map(|x| x.0.clone())
+                .collect();
+
+            col.update_one(
+                doc! {
+                    "_id": id
+                },
+                doc! {
+                    "$set": {
+                        "channels": list
+                    }
+                },
+                None,
+            )
+            .expect("Failed to update guild.");
+        }
+    }
+
+    // Reminder to update LATEST_REVISION when adding new migrations.
+    LATEST_REVISION
+}

src/database/mod.rs

@@ -1,15 +1,15 @@
-use mongodb::{Client, Collection, Database};
-use std::env;
+use crate::util::variables::MONGO_URI;
 
+use mongodb::sync::{Client, Collection, Database};
 use once_cell::sync::OnceCell;
+
 static DBCONN: OnceCell<Client> = OnceCell::new();
 
 pub fn connect() {
-    let client =
-        Client::with_uri_str(&env::var("DB_URI").expect("DB_URI not in environment variables!"))
-            .expect("Failed to init db connection.");
+    let client = Client::with_uri_str(&MONGO_URI).expect("Failed to init db connection.");
 
     DBCONN.set(client).unwrap();
+    migrations::run_migrations();
 }
 
 pub fn get_connection() -> &'static Client {
@@ -24,6 +24,8 @@ pub fn get_collection(collection: &str) -> Collection {
     get_db().collection(collection)
 }
 
+pub mod migrations;
+
 pub mod channel;
 pub mod guild;
 pub mod message;

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> {
@@ -111,19 +111,17 @@ pub fn has_mutual_connection(user_id: &str, target_id: &str, with_permission: bo
 
                     let permissions = guild.get_i32("default_permissions").unwrap() as u32;
 
-                    if MemberPermissions([ permissions ]).get_send_direct_messages() {
+                    if MemberPermissions([permissions]).get_send_direct_messages() {
                         return true;
                     }
                 }
             }
 
             false
+        } else if result.count() > 0 {
+            true
         } else {
-            if result.count() > 0 {
-                true
-            } else {
-                false
-            }
+            false
         }
     } else {
         false

src/database/permissions.rs

@@ -1,9 +1,7 @@
 use super::mutual::has_mutual_connection;
-use crate::database::guild::Member;
-use crate::database::user::UserRelationship;
-use crate::guards::auth::UserRef;
-use crate::guards::channel::ChannelRef;
-use crate::guards::guild::{get_member, GuildRef};
+use crate::database::channel::Channel;
+use crate::database::guild::{fetch_guild, fetch_member, Guild, Member, MemberKey};
+use crate::database::user::{User, UserRelationship};
 
 use num_enum::TryFromPrimitive;
 
@@ -78,23 +76,23 @@ pub fn get_relationship_internal(
     Relationship::NONE
 }
 
-pub fn get_relationship(a: &UserRef, b: &UserRef) -> Relationship {
+pub fn get_relationship(a: &User, b: &User) -> Relationship {
     if a.id == b.id {
         return Relationship::SELF;
     }
 
-    get_relationship_internal(&a.id, &b.id, &a.fetch_relationships())
+    get_relationship_internal(&a.id, &b.id, &a.relations)
 }
 
 pub struct PermissionCalculator {
-    pub user: UserRef,
-    pub channel: Option<ChannelRef>,
-    pub guild: Option<GuildRef>,
+    pub user: User,
+    pub channel: Option<Channel>,
+    pub guild: Option<Guild>,
     pub member: Option<Member>,
 }
 
 impl PermissionCalculator {
-    pub fn new(user: UserRef) -> PermissionCalculator {
+    pub fn new(user: User) -> PermissionCalculator {
         PermissionCalculator {
             user,
             channel: None,
@@ -103,14 +101,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 +123,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 +139,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,27 +165,34 @@ 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);
                             }
                         }
 
-                        let relationships = self.user.fetch_relationships();
-                        let relationship =
-                            get_relationship_internal(&self.user.id, &other_user, &relationships);
+                        if let Some(other) = other_user {
+                            let relationship = get_relationship_internal(
+                                &self.user.id,
+                                &other,
+                                &self.user.relations,
+                            );
 
-                        if relationship == Relationship::Friend {
-                            permissions = 177;
-                        } else if relationship == Relationship::Blocked
-                            || relationship == Relationship::BlockedOther
-                        {
-                            permissions = 1;
-                        } else if has_mutual_connection(&self.user.id, other_user, true) {
-                            permissions = 177;
+                            if relationship == Relationship::Friend {
+                                permissions = 1024 + 128 + 32 + 16 + 1;
+                            } else if relationship == Relationship::Blocked
+                                || relationship == Relationship::BlockedOther
+                            {
+                                permissions = 1;
+                            } else if has_mutual_connection(&self.user.id, other, true) {
+                                permissions = 1024 + 128 + 32 + 16 + 1;
+                            } else {
+                                permissions = 1;
+                            }
                         } else {
-                            permissions = 1;
+                            // ? In this case, it is a "self DM".
+                            return 1024 + 128 + 32 + 16 + 1;
                         }
                     }
                 }

src/database/user.rs

@@ -1,12 +1,23 @@
-use bson::UtcDateTime;
+use super::channel::fetch_channels;
+use super::get_collection;
+use super::guild::serialise_guilds_with_channels;
+
+use lru::LruCache;
+use mongodb::bson::{doc, from_bson, Bson, DateTime};
+use mongodb::options::FindOptions;
+use rocket::http::{RawStr, Status};
+use rocket::request::{self, FromParam, FromRequest, Request};
+use rocket::Outcome;
+use rocket_contrib::json::JsonValue;
 use serde::{Deserialize, Serialize};
+use std::sync::{Arc, Mutex};
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct UserEmailVerification {
     pub verified: bool,
     pub target: Option<String>,
-    pub expiry: Option<UtcDateTime>,
-    pub rate_limit: Option<UtcDateTime>,
+    pub expiry: Option<DateTime>,
+    pub rate_limit: Option<DateTime>,
     pub code: Option<String>,
 }
 
@@ -23,7 +34,267 @@ pub struct User {
     pub email: String,
     pub username: String,
     pub password: String,
+    pub display_name: String,
     pub access_token: Option<String>,
     pub email_verification: UserEmailVerification,
     pub relations: Option<Vec<UserRelationship>>,
 }
+
+impl User {
+    pub fn serialise(self, relationship: i32) -> JsonValue {
+        if relationship == super::Relationship::SELF as i32 {
+            json!({
+                "id": self.id,
+                "username": self.username,
+                "display_name": self.display_name,
+                "email": self.email,
+                "verified": self.email_verification.verified,
+            })
+        } else {
+            json!({
+                "id": self.id,
+                "username": self.username,
+                "display_name": self.display_name,
+                "relationship": relationship
+            })
+        }
+    }
+
+    pub fn find_guilds(&self) -> Result<Vec<String>, String> {
+        let members = get_collection("members")
+            .find(
+                doc! {
+                    "_id.user": &self.id
+                },
+                None,
+            )
+            .map_err(|_| "Failed to fetch members.")?;
+
+        Ok(members
+            .into_iter()
+            .filter_map(|x| match x {
+                Ok(doc) => match doc.get_document("_id") {
+                    Ok(id) => match id.get_str("guild") {
+                        Ok(value) => Some(value.to_string()),
+                        Err(_) => None,
+                    },
+                    Err(_) => None,
+                },
+                Err(_) => None,
+            })
+            .collect())
+    }
+
+    pub fn find_dms(&self) -> Result<Vec<String>, String> {
+        let channels = get_collection("channels")
+            .find(
+                doc! {
+                    "recipients": &self.id
+                },
+                FindOptions::builder().projection(doc! { "_id": 1 }).build(),
+            )
+            .map_err(|_| "Failed to fetch channel ids.")?;
+
+        Ok(channels
+            .into_iter()
+            .filter_map(|x| x.ok())
+            .filter_map(|x| match x.get_str("_id") {
+                Ok(value) => Some(value.to_string()),
+                Err(_) => None,
+            })
+            .collect())
+    }
+
+    pub fn create_payload(self) -> Result<JsonValue, String> {
+        let v = vec![];
+        let relations = self.relations.as_ref().unwrap_or(&v);
+
+        let users: Vec<JsonValue> = fetch_users(&relations.iter().map(|x| x.id.clone()).collect())?
+            .into_iter()
+            .map(|x| {
+                let id = x.id.clone();
+                x.serialise(relations.iter().find(|y| y.id == id).unwrap().status as i32)
+            })
+            .collect();
+
+        let channels: Vec<JsonValue> = fetch_channels(&self.find_dms()?)?
+            .into_iter()
+            .map(|x| x.serialise())
+            .collect();
+
+        Ok(json!({
+            "users": users,
+            "channels": channels,
+            "guilds": serialise_guilds_with_channels(&self.find_guilds()?)?,
+            "user": self.serialise(super::Relationship::SELF as i32)
+        }))
+    }
+}
+
+lazy_static! {
+    static ref CACHE: Arc<Mutex<LruCache<String, User>>> =
+        Arc::new(Mutex::new(LruCache::new(4_000_000)));
+}
+
+pub fn fetch_user(id: &str) -> Result<Option<User>, String> {
+    {
+        if let Ok(mut cache) = CACHE.lock() {
+            let existing = cache.get(&id.to_string());
+
+            if let Some(user) = existing {
+                return Ok(Some((*user).clone()));
+            }
+        } else {
+            return Err("Failed to lock cache.".to_string());
+        }
+    }
+
+    let col = get_collection("users");
+    if let Ok(result) = col.find_one(doc! { "_id": id }, None) {
+        if let Some(doc) = result {
+            if let Ok(user) = from_bson(Bson::Document(doc)) as Result<User, _> {
+                let mut cache = CACHE.lock().unwrap();
+                cache.put(id.to_string(), user.clone());
+
+                Ok(Some(user))
+            } else {
+                Err("Failed to deserialize user!".to_string())
+            }
+        } else {
+            Ok(None)
+        }
+    } else {
+        Err("Failed to fetch user from database.".to_string())
+    }
+}
+
+pub fn fetch_users(ids: &Vec<String>) -> Result<Vec<User>, String> {
+    let mut missing = vec![];
+    let mut users = vec![];
+
+    {
+        if let Ok(mut cache) = CACHE.lock() {
+            for id in ids {
+                let existing = cache.get(id);
+
+                if let Some(user) = existing {
+                    users.push((*user).clone());
+                } else {
+                    missing.push(id);
+                }
+            }
+        } else {
+            return Err("Failed to lock cache.".to_string());
+        }
+    }
+
+    if missing.len() == 0 {
+        return Ok(users);
+    }
+
+    let col = get_collection("users");
+    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(user) = from_bson(Bson::Document(doc)) as Result<User, _> {
+                    cache.put(user.id.clone(), user.clone());
+                    users.push(user);
+                } else {
+                    return Err("Failed to deserialize user!".to_string());
+                }
+            } else {
+                return Err("Failed to fetch user.".to_string());
+            }
+        }
+
+        Ok(users)
+    } else {
+        Err("Failed to fetch user from database.".to_string())
+    }
+}
+
+#[derive(Debug)]
+pub enum AuthError {
+    Failed,
+    Missing,
+    Invalid,
+}
+
+impl<'a, 'r> FromRequest<'a, 'r> for User {
+    type Error = AuthError;
+
+    fn from_request(request: &'a Request<'r>) -> request::Outcome<Self, Self::Error> {
+        let u = request.headers().get("x-user").next();
+        let t = request.headers().get("x-auth-token").next();
+
+        if let Some(uid) = u {
+            if let Some(token) = t {
+                if let Ok(result) = fetch_user(uid) {
+                    if let Some(user) = result {
+                        if let Some(access_token) = &user.access_token {
+                            if access_token == token {
+                                Outcome::Success(user)
+                            } else {
+                                Outcome::Failure((Status::Forbidden, AuthError::Invalid))
+                            }
+                        } else {
+                            Outcome::Failure((Status::Forbidden, AuthError::Invalid))
+                        }
+                    } else {
+                        Outcome::Failure((Status::Forbidden, AuthError::Invalid))
+                    }
+                } else {
+                    Outcome::Failure((Status::Forbidden, AuthError::Failed))
+                }
+            } else {
+                Outcome::Failure((Status::Forbidden, AuthError::Missing))
+            }
+        } else {
+            Outcome::Failure((Status::Forbidden, AuthError::Missing))
+        }
+    }
+}
+
+impl<'r> FromParam<'r> for User {
+    type Error = &'r RawStr;
+
+    fn from_param(param: &'r RawStr) -> Result<Self, Self::Error> {
+        if let Ok(result) = fetch_user(&param.to_string()) {
+            if let Some(user) = result {
+                Ok(user)
+            } else {
+                Err(param)
+            }
+        } else {
+            Err(param)
+        }
+    }
+}
+
+use crate::notifications::events::Notification;
+
+pub fn process_event(event: &Notification) {
+    match event {
+        Notification::user_friend_status(ev) => {
+            let mut cache = CACHE.lock().unwrap();
+            if let Some(user) = cache.peek_mut(&ev.id) {
+                if let Some(relations) = user.relations.as_mut() {
+                    if ev.status == 0 {
+                        if let Some(pos) = relations.iter().position(|x| x.id == ev.user) {
+                            relations.remove(pos);
+                        }
+                    } else if let Some(entry) = relations.iter_mut().find(|x| x.id == ev.user) {
+                        entry.status = ev.status as u8;
+                    } else {
+                        relations.push(UserRelationship {
+                            id: ev.id.clone(),
+                            status: ev.status as u8,
+                        });
+                    }
+                }
+            }
+        }
+        _ => {}
+    }
+}

src/email.rs

@@ -1,50 +0,0 @@
-use reqwest::blocking::Client;
-use std::collections::HashMap;
-use std::env;
-
-pub fn send_email(target: String, subject: String, body: String, html: String) -> Result<(), ()> {
-    let mut map = HashMap::new();
-    map.insert("target", target.clone());
-    map.insert("subject", subject);
-    map.insert("body", body);
-    map.insert("html", html);
-
-    let client = Client::new();
-    match client
-        .post("http://192.168.0.26:3838/send")
-        .json(&map)
-        .send()
-    {
-        Ok(_) => Ok(()),
-        Err(_) => Err(()),
-    }
-}
-
-fn public_uri() -> String {
-    env::var("PUBLIC_URI").expect("PUBLIC_URI not in environment variables!")
-}
-
-pub fn send_verification_email(email: String, code: String) -> bool {
-    let url = format!("{}/api/account/verify/{}", public_uri(), code);
-    send_email(
-        email,
-        "Verify your email!".to_string(),
-        format!("Verify your email here: {}", url),
-        format!("<a href=\"{}\">Click to verify your email!</a>", url),
-    )
-    .is_ok()
-}
-
-pub fn send_welcome_email(email: String, username: String) -> bool {
-    send_email(
-        email,
-        "Welcome to REVOLT!".to_string(),
-        format!("Welcome, {}! You can now use REVOLT.", username.clone()),
-        format!(
-            "<b>Welcome, {}!</b><br/>You can now use REVOLT.<br/><a href=\"{}\">Go to REVOLT</a>",
-            username.clone(),
-            public_uri()
-        ),
-    )
-    .is_ok()
-}

src/guards/auth.rs

@@ -1,162 +0,0 @@
-use bson::{doc, from_bson, Document};
-use mongodb::options::FindOneOptions;
-use rocket::http::{RawStr, Status};
-use rocket::request::{self, FromParam, FromRequest, Request};
-use rocket::Outcome;
-use serde::{Deserialize, Serialize};
-
-use crate::database;
-use database::user::{User, UserRelationship};
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct UserRef {
-    pub id: String,
-    pub username: String,
-    pub email_verified: bool,
-}
-
-impl UserRef {
-    pub fn from(id: String) -> Option<UserRef> {
-        match database::get_collection("users").find_one(
-            doc! { "_id": id },
-            FindOneOptions::builder()
-                .projection(doc! {
-                    "_id": 1,
-                    "username": 1,
-                    "email_verification.verified": 1,
-                })
-                .build(),
-        ) {
-            Ok(result) => match result {
-                Some(doc) => Some(UserRef {
-                    id: doc.get_str("_id").unwrap().to_string(),
-                    username: doc.get_str("username").unwrap().to_string(),
-                    email_verified: doc
-                        .get_document("email_verification")
-                        .unwrap()
-                        .get_bool("verified")
-                        .unwrap(),
-                }),
-                None => None,
-            },
-            Err(_) => None,
-        }
-    }
-
-    pub fn fetch_data(&self, projection: Document) -> Option<Document> {
-        database::get_collection("users")
-            .find_one(
-                doc! { "_id": &self.id },
-                FindOneOptions::builder().projection(projection).build(),
-            )
-            .expect("Failed to fetch user from database.")
-    }
-
-    pub fn fetch_relationships(&self) -> Option<Vec<UserRelationship>> {
-        let user = database::get_collection("users")
-            .find_one(
-                doc! { "_id": &self.id },
-                FindOneOptions::builder()
-                    .projection(doc! { "relations": 1 })
-                    .build(),
-            )
-            .expect("Failed to fetch user relationships from database.")
-            .expect("Missing user document.");
-
-        if let Ok(arr) = user.get_array("relations") {
-            let mut relationships = vec![];
-            for item in arr {
-                relationships.push(from_bson(item.clone()).unwrap());
-            }
-
-            Some(relationships)
-        } else {
-            None
-        }
-    }
-}
-
-#[derive(Debug)]
-pub enum AuthError {
-    BadCount,
-    Missing,
-    Invalid,
-}
-
-impl<'a, 'r> FromRequest<'a, 'r> for UserRef {
-    type Error = AuthError;
-
-    fn from_request(request: &'a Request<'r>) -> request::Outcome<Self, Self::Error> {
-        let keys: Vec<_> = request.headers().get("x-auth-token").collect();
-        match keys.len() {
-            0 => Outcome::Failure((Status::Forbidden, AuthError::Missing)),
-            1 => {
-                let key = keys[0];
-                let result = database::get_collection("users")
-                    .find_one(
-                        doc! { "access_token": key },
-                        FindOneOptions::builder()
-                            .projection(doc! {
-                                "_id": 1,
-                                "username": 1,
-                                "email_verification.verified": 1,
-                            })
-                            .build(),
-                    )
-                    .unwrap();
-
-                if let Some(user) = result {
-                    Outcome::Success(UserRef {
-                        id: user.get_str("_id").unwrap().to_string(),
-                        username: user.get_str("username").unwrap().to_string(),
-                        email_verified: user
-                            .get_document("email_verification")
-                            .unwrap()
-                            .get_bool("verified")
-                            .unwrap(),
-                    })
-                } else {
-                    Outcome::Failure((Status::Forbidden, AuthError::Invalid))
-                }
-            }
-            _ => Outcome::Failure((Status::BadRequest, AuthError::BadCount)),
-        }
-    }
-}
-
-impl<'a, 'r> FromRequest<'a, 'r> for User {
-    type Error = AuthError;
-
-    fn from_request(request: &'a Request<'r>) -> request::Outcome<Self, Self::Error> {
-        let keys: Vec<_> = request.headers().get("x-auth-token").collect();
-        match keys.len() {
-            0 => Outcome::Failure((Status::Forbidden, AuthError::Missing)),
-            1 => {
-                let key = keys[0];
-                let col = database::get_collection("users");
-                let result = col.find_one(doc! { "access_token": key }, None).unwrap();
-
-                if let Some(user) = result {
-                    Outcome::Success(
-                        from_bson(bson::Bson::Document(user)).expect("Failed to unwrap user."),
-                    )
-                } else {
-                    Outcome::Failure((Status::Forbidden, AuthError::Invalid))
-                }
-            }
-            _ => Outcome::Failure((Status::BadRequest, AuthError::BadCount)),
-        }
-    }
-}
-
-impl<'r> FromParam<'r> for UserRef {
-    type Error = &'r RawStr;
-
-    fn from_param(param: &'r RawStr) -> Result<Self, Self::Error> {
-        if let Some(user) = UserRef::from(param.to_string()) {
-            Ok(user)
-        } else {
-            Err(param)
-        }
-    }
-}

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 +0,0 @@
-pub mod auth;
-pub mod channel;
-pub mod guild;

src/main.rs

@@ -1,28 +1,42 @@
 #![feature(proc_macro_hygiene, decl_macro)]
+
 #[macro_use]
 extern crate rocket;
 #[macro_use]
 extern crate rocket_contrib;
 #[macro_use]
 extern crate bitfield;
+#[macro_use]
+extern crate lazy_static;
 
 pub mod database;
-pub mod email;
-pub mod guards;
+pub mod notifications;
 pub mod routes;
 pub mod util;
-pub mod websocket;
 
-use dotenv;
 use rocket_cors::AllowedOrigins;
 use std::thread;
+use log::info;
 
 fn main() {
     dotenv::dotenv().ok();
+    env_logger::init_from_env(
+        env_logger::Env::default()
+            .filter_or("RUST_LOG", "info")
+    );
+
+    info!("Starting REVOLT server.");
+
+    util::variables::preflight_checks();
     database::connect();
+    notifications::start_worker();
 
     thread::spawn(|| {
-        websocket::launch_server();
+        notifications::pubsub::launch_subscriber();
+    });
+
+    thread::spawn(|| {
+        notifications::ws::launch_server();
     });
 
     let cors = rocket_cors::CorsOptions {

src/notifications/events/groups.rs

@@ -0,0 +1,13 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct UserJoin {
+    pub id: String,
+    pub user: String,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct UserLeave {
+    pub id: String,
+    pub user: String,
+}

src/notifications/events/guilds.rs

@@ -0,0 +1,33 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct UserJoin {
+    pub id: String,
+    pub user: String,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct UserLeave {
+    pub id: String,
+    pub user: String,
+    pub banned: bool,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct ChannelCreate {
+    pub id: String,
+    pub channel: String,
+    pub name: String,
+    pub description: String,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct ChannelDelete {
+    pub id: String,
+    pub channel: String,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Delete {
+    pub id: String,
+}

src/notifications/events/message.rs

@@ -0,0 +1,23 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Create {
+    pub id: String,
+    pub nonce: Option<String>,
+    pub channel: String,
+    pub author: String,
+    pub content: String,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Edit {
+    pub id: String,
+    pub channel: String,
+    pub author: String,
+    pub content: String,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Delete {
+    pub id: String,
+}

src/notifications/events/mod.rs

@@ -0,0 +1,47 @@
+use serde::{Deserialize, Serialize};
+use serde_json::{json, Value};
+
+pub mod groups;
+pub mod guilds;
+pub mod message;
+pub mod users;
+
+#[allow(non_camel_case_types)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub enum Notification {
+    message_create(message::Create),
+    message_edit(message::Edit),
+    message_delete(message::Delete),
+    group_user_join(groups::UserJoin),
+    group_user_leave(groups::UserLeave),
+    guild_user_join(guilds::UserJoin),
+    guild_user_leave(guilds::UserLeave),
+    guild_channel_create(guilds::ChannelCreate),
+    guild_channel_delete(guilds::ChannelDelete),
+    guild_delete(guilds::Delete),
+    user_friend_status(users::FriendStatus),
+}
+
+impl Notification {
+    pub fn serialize(self) -> String {
+        if let Value::Object(obj) = json!(self) {
+            let (key, value) = obj.iter().next().unwrap();
+
+            if let Value::Object(data) = value {
+                let mut data = data.clone();
+                data.insert("type".to_string(), Value::String(key.to_string()));
+                json!(data).to_string()
+            } else {
+                unreachable!()
+            }
+        } else {
+            unreachable!()
+        }
+    }
+
+    pub fn push_to_cache(&self) {
+        crate::database::channel::process_event(&self);
+        crate::database::guild::process_event(&self);
+        crate::database::user::process_event(&self);
+    }
+}

src/notifications/events/users.rs

@@ -0,0 +1,8 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct FriendStatus {
+    pub id: String,
+    pub user: String,
+    pub status: i32,
+}

src/notifications/mod.rs

@@ -0,0 +1,76 @@
+use crate::database::channel::Channel;
+
+use once_cell::sync::OnceCell;
+use std::sync::mpsc::{channel, Sender};
+use std::thread;
+
+pub mod events;
+pub mod pubsub;
+pub mod state;
+pub mod ws;
+
+pub fn send_message<U: Into<Option<Vec<String>>>, G: Into<Option<String>>>(
+    users: U,
+    guild: G,
+    data: events::Notification,
+) -> bool {
+    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());
+
+        true
+    } else {
+        false
+    }
+}
+
+struct NotificationArguments {
+    users: Option<Vec<String>>,
+    guild: Option<String>,
+    data: events::Notification,
+}
+
+static mut SENDER: OnceCell<Sender<NotificationArguments>> = OnceCell::new();
+
+pub fn start_worker() {
+    let (sender, receiver) = channel();
+    unsafe {
+        SENDER.set(sender).unwrap();
+    }
+
+    thread::spawn(move || {
+        while let Ok(data) = receiver.recv() {
+            send_message(data.users, data.guild, data.data);
+        }
+    });
+}
+
+pub fn send_message_threaded<U: Into<Option<Vec<String>>>, G: Into<Option<String>>>(
+    users: U,
+    guild: G,
+    data: events::Notification,
+) -> bool {
+    unsafe {
+        SENDER
+            .get()
+            .unwrap()
+            .send(NotificationArguments {
+                users: users.into(),
+                guild: guild.into(),
+                data,
+            })
+            .is_ok()
+    }
+}
+
+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),
+        _ => unreachable!(),
+    };
+}

src/notifications/pubsub.rs

@@ -0,0 +1,102 @@
+use super::events::Notification;
+use crate::database::get_collection;
+
+use mongodb::bson::{doc, from_bson, to_bson, Bson};
+use mongodb::options::{CursorType, FindOneOptions, FindOptions};
+use serde::{Deserialize, Serialize};
+use std::time::Duration;
+use ulid::Ulid;
+
+use once_cell::sync::OnceCell;
+static SOURCEID: OnceCell<String> = OnceCell::new();
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct PubSubMessage {
+    #[serde(rename = "_id")]
+    id: String,
+    source: String,
+
+    user_recipients: Option<Vec<String>>,
+    target_guild: Option<String>,
+    data: Notification,
+}
+
+pub fn send_message(users: Option<Vec<String>>, guild: Option<String>, data: Notification) -> bool {
+    let message = PubSubMessage {
+        id: Ulid::new().to_string(),
+        source: SOURCEID.get().unwrap().to_string(),
+        user_recipients: users.into(),
+        target_guild: guild.into(),
+        data,
+    };
+
+    if get_collection("pubsub")
+        .insert_one(
+            to_bson(&message)
+                .expect("Failed to serialize pubsub message.")
+                .as_document()
+                .expect("Failed to convert to a document.")
+                .clone(),
+            None,
+        )
+        .is_ok()
+    {
+        true
+    } else {
+        false
+    }
+}
+
+pub fn launch_subscriber() {
+    let source = Ulid::new().to_string();
+    SOURCEID
+        .set(source.clone())
+        .expect("Failed to create and set source ID.");
+
+    let pubsub = get_collection("pubsub");
+    if let Ok(result) = pubsub.find_one(
+        doc! {},
+        FindOneOptions::builder().sort(doc! { "_id": -1 }).build(),
+    ) {
+        let query = if let Some(doc) = result {
+            doc! { "_id": { "$gt": doc.get_str("_id").unwrap() } }
+        } else {
+            doc! {}
+        };
+
+        if let Ok(mut cursor) = pubsub.find(
+            query,
+            FindOptions::builder()
+                .cursor_type(CursorType::TailableAwait)
+                .no_cursor_timeout(true)
+                .max_await_time(Duration::from_secs(1200))
+                .build(),
+        ) {
+            loop {
+                while let Some(item) = cursor.next() {
+                    if let Ok(doc) = item {
+                        if let Ok(message) =
+                            from_bson(Bson::Document(doc)) as Result<PubSubMessage, _>
+                        {
+                            if &message.source != &source {
+                                super::state::send_message(
+                                    message.user_recipients,
+                                    message.target_guild,
+                                    message.data.serialize(),
+                                );
+                            }
+                        } else {
+                            eprintln!("Failed to deserialize pubsub message.");
+                        }
+                    } else {
+                        eprintln!("Failed to unwrap a document from pubsub.");
+                    }
+                }
+            }
+        } else {
+            eprintln!("Failed to open subscriber cursor.");
+        }
+    } else {
+        eprintln!("Failed to fetch latest document from pubsub collection.");
+    }
+}

src/notifications/state.rs

@@ -0,0 +1,205 @@
+use crate::database;
+use crate::util::vec_to_set;
+
+use hashbrown::{HashMap, HashSet};
+use mongodb::bson::doc;
+use mongodb::options::FindOneOptions;
+use once_cell::sync::OnceCell;
+use std::sync::RwLock;
+use ws::Sender;
+
+pub enum StateResult {
+    DatabaseError,
+    InvalidToken,
+    Success(String),
+}
+
+static mut CONNECTIONS: OnceCell<RwLock<HashMap<String, Sender>>> = OnceCell::new();
+
+pub fn add_connection(id: String, sender: Sender) {
+    unsafe {
+        CONNECTIONS
+            .get()
+            .unwrap()
+            .write()
+            .unwrap()
+            .insert(id, sender);
+    }
+}
+
+pub struct User {
+    connections: HashSet<String>,
+    guilds: HashSet<String>,
+}
+
+impl User {
+    pub fn new() -> User {
+        User {
+            connections: HashSet::new(),
+            guilds: HashSet::new(),
+        }
+    }
+}
+
+pub struct Guild {
+    users: HashSet<String>,
+}
+
+impl Guild {
+    pub fn new() -> Guild {
+        Guild {
+            users: HashSet::new(),
+        }
+    }
+}
+
+pub struct GlobalState {
+    users: HashMap<String, User>,
+    guilds: HashMap<String, Guild>,
+}
+
+impl GlobalState {
+    pub fn new() -> GlobalState {
+        GlobalState {
+            users: HashMap::new(),
+            guilds: HashMap::new(),
+        }
+    }
+
+    pub fn push_to_guild(&mut self, guild: String, user: String) {
+        if !self.guilds.contains_key(&guild) {
+            self.guilds.insert(guild.clone(), Guild::new());
+        }
+
+        self.guilds.get_mut(&guild).unwrap().users.insert(user);
+    }
+
+    pub fn try_authenticate(&mut self, connection: String, access_token: String) -> StateResult {
+        if let Ok(result) = database::get_collection("users").find_one(
+            doc! {
+                "access_token": access_token,
+            },
+            FindOneOptions::builder()
+                .projection(doc! { "_id": 1 })
+                .build(),
+        ) {
+            if let Some(user) = result {
+                let user_id = user.get_str("_id").unwrap();
+
+                if self.users.contains_key(user_id) {
+                    self.users
+                        .get_mut(user_id)
+                        .unwrap()
+                        .connections
+                        .insert(connection);
+
+                    return StateResult::Success(user_id.to_string());
+                }
+
+                if let Ok(results) =
+                    database::get_collection("members").find(doc! { "_id.user": &user_id }, None)
+                {
+                    let mut guilds = vec![];
+                    for result in results {
+                        if let Ok(entry) = result {
+                            guilds.push(
+                                entry
+                                    .get_document("_id")
+                                    .unwrap()
+                                    .get_str("guild")
+                                    .unwrap()
+                                    .to_string(),
+                            );
+                        }
+                    }
+
+                    let mut user = User::new();
+                    for guild in guilds {
+                        user.guilds.insert(guild.clone());
+                        self.push_to_guild(guild, user_id.to_string());
+                    }
+
+                    user.connections.insert(connection);
+                    self.users.insert(user_id.to_string(), user);
+
+                    StateResult::Success(user_id.to_string())
+                } else {
+                    StateResult::DatabaseError
+                }
+            } else {
+                StateResult::InvalidToken
+            }
+        } else {
+            StateResult::DatabaseError
+        }
+    }
+
+    pub fn disconnect<U: Into<Option<String>>>(&mut self, user_id: U, connection: String) {
+        if let Some(user_id) = user_id.into() {
+            let user = self.users.get_mut(&user_id).unwrap();
+            user.connections.remove(&connection);
+
+            if user.connections.len() == 0 {
+                for guild in &user.guilds {
+                    self.guilds.get_mut(guild).unwrap().users.remove(&user_id);
+                }
+
+                self.users.remove(&user_id);
+            }
+        }
+
+        unsafe {
+            CONNECTIONS
+                .get()
+                .unwrap()
+                .write()
+                .unwrap()
+                .remove(&connection);
+        }
+    }
+}
+
+pub static mut DATA: OnceCell<RwLock<GlobalState>> = OnceCell::new();
+
+pub fn init() {
+    unsafe {
+        if CONNECTIONS.set(RwLock::new(HashMap::new())).is_err() {
+            panic!("Failed to set global connections map.");
+        }
+
+        if DATA.set(RwLock::new(GlobalState::new())).is_err() {
+            panic!("Failed to set global state.");
+        }
+    }
+}
+
+pub fn send_message(users: Option<Vec<String>>, guild: Option<String>, data: String) {
+    let state = unsafe { DATA.get().unwrap().read().unwrap() };
+    let mut connections = HashSet::new();
+
+    let mut users = vec_to_set(&users.unwrap_or(vec![]));
+    if let Some(guild) = guild {
+        if let Some(entry) = state.guilds.get(&guild) {
+            for user in &entry.users {
+                users.insert(user.to_string());
+            }
+        }
+    }
+
+    for user in users {
+        if let Some(entry) = state.users.get(&user) {
+            for connection in &entry.connections {
+                connections.insert(connection.clone());
+            }
+        }
+    }
+
+    let targets = unsafe { CONNECTIONS.get().unwrap().read().unwrap() };
+    for conn in connections {
+        if let Some(sender) = targets.get(&conn) {
+            if sender.send(data.clone()).is_err() {
+                eprintln!("Failed to send a notification to a websocket. [{}]", &conn);
+            }
+        }
+    }
+}

src/notifications/ws.rs

@@ -0,0 +1,135 @@
+use super::state::{self, StateResult};
+use crate::util::variables::WS_HOST;
+
+use serde_json::{from_str, json, Value};
+use ulid::Ulid;
+use ws::{listen, CloseCode, Error, Handler, Handshake, Message, Result, Sender};
+
+struct Server {
+    sender: Sender,
+    user_id: Option<String>,
+    id: String,
+}
+
+impl Handler for Server {
+    fn on_open(&mut self, _: Handshake) -> Result<()> {
+        state::add_connection(self.id.clone(), self.sender.clone());
+        Ok(())
+    }
+
+    fn on_message(&mut self, msg: Message) -> Result<()> {
+        if let Message::Text(text) = msg {
+            if let Ok(data) = from_str(&text) as std::result::Result<Value, _> {
+                if let Value::String(packet_type) = &data["type"] {
+                    if packet_type == "authenticate" {
+                        if self.user_id.is_some() {
+                            self.sender.send(
+                                json!({
+                                    "type": "authenticate",
+                                    "success": false,
+                                    "error": "Already authenticated!"
+                                })
+                                .to_string(),
+                            )
+                        } else if let Value::String(token) = &data["token"] {
+                            let mut state = unsafe { state::DATA.get().unwrap().write().unwrap() };
+
+                            match state.try_authenticate(self.id.clone(), token.to_string()) {
+                                StateResult::Success(user_id) => {
+                                    let user = crate::database::user::fetch_user(&user_id)
+                                        .unwrap()
+                                        .unwrap();
+                                    self.user_id = Some(user_id);
+
+                                    self.sender.send(
+                                        json!({
+                                            "type": "authenticate",
+                                            "success": true,
+                                        })
+                                        .to_string(),
+                                    )?;
+
+                                    if let Ok(payload) = user.create_payload() {
+                                        self.sender.send(
+                                            json!({
+                                                "type": "ready",
+                                                "data": payload
+                                            })
+                                            .to_string(),
+                                        )
+                                    } else {
+                                        // ! TODO: FIXME: ALL THE NOTIFICATIONS CODE NEEDS TO BE
+                                        // ! RESTRUCTURED, IT IS UTTER GARBAGE. :)))))
+
+                                        Ok(())
+                                    }
+                                }
+                                StateResult::DatabaseError => self.sender.send(
+                                    json!({
+                                        "type": "authenticate",
+                                        "success": false,
+                                        "error": "Had database error."
+                                    })
+                                    .to_string(),
+                                ),
+                                StateResult::InvalidToken => self.sender.send(
+                                    json!({
+                                        "type": "authenticate",
+                                        "success": false,
+                                        "error": "Invalid token."
+                                    })
+                                    .to_string(),
+                                ),
+                            }
+                        } else {
+                            self.sender.send(
+                                json!({
+                                    "type": "authenticate",
+                                    "success": false,
+                                    "error": "Token not present."
+                                })
+                                .to_string(),
+                            )
+                        }
+                    } else {
+                        Ok(())
+                    }
+                } else {
+                    Ok(())
+                }
+            } else {
+                Ok(())
+            }
+        } else {
+            Ok(())
+        }
+    }
+
+    fn on_close(&mut self, _code: CloseCode, _reason: &str) {
+        unsafe {
+            state::DATA
+                .get()
+                .unwrap()
+                .write()
+                .unwrap()
+                .disconnect(self.user_id.clone(), self.id.clone());
+        }
+
+        println!("User disconnected. [{}]", self.id);
+    }
+
+    fn on_error(&mut self, err: Error) {
+        println!("The server encountered an error: {:?}", err);
+    }
+}
+
+pub fn launch_server() {
+    state::init();
+
+    listen(WS_HOST.to_string(), |sender| Server {
+        sender,
+        user_id: None,
+        id: Ulid::new().to_string(),
+    })
+    .unwrap()
+}

src/routes/account.rs

@@ -1,12 +1,13 @@
 use super::Response;
 use crate::database;
-use crate::email;
-use crate::util::gen_token;
+use crate::util::{captcha, email, gen_token};
+use crate::util::variables::{DISABLE_REGISTRATION, USE_EMAIL};
 
 use bcrypt::{hash, verify};
-use bson::{doc, from_bson, Bson::UtcDatetime};
 use chrono::prelude::*;
 use database::user::User;
+use log::error;
+use mongodb::bson::{doc, from_bson, Bson};
 use rocket_contrib::json::Json;
 use serde::{Deserialize, Serialize};
 use ulid::Ulid;
@@ -17,6 +18,7 @@ pub struct Create {
     username: String,
     password: String,
     email: String,
+    captcha: Option<String>,
 }
 
 /// create a new Revolt account
@@ -28,6 +30,14 @@ pub struct Create {
 /// (3) add user and send email verification
 #[post("/create", data = "<info>")]
 pub fn create(info: Json<Create>) -> Response {
+    if let Err(error) = captcha::verify(&info.captcha) {
+        return Response::BadRequest(json!({ "error": error }));
+    }
+
+    if *DISABLE_REGISTRATION {
+        return Response::BadRequest(json!({ "error": "Registration disabled." }));
+    }
+
     let col = database::get_collection("users");
 
     if info.username.len() < 2 || info.username.len() > 32 {
@@ -53,34 +63,56 @@ pub fn create(info: Json<Create>) -> Response {
         return Response::Conflict(json!({ "error": "Email already in use!" }));
     }
 
+    if let Some(_) = col
+        .find_one(doc! { "username": info.username.clone() }, None)
+        .expect("Failed user lookup")
+    {
+        return Response::Conflict(json!({ "error": "Username already in use!" }));
+    }
+
     if let Ok(hashed) = hash(info.password.clone(), 10) {
         let access_token = gen_token(92);
         let code = gen_token(48);
 
+        let email_verification = match *USE_EMAIL {
+            true => doc! {
+                "verified": false,
+                "target": info.email.clone(),
+                "expiry": Bson::DateTime(Utc::now() + chrono::Duration::days(1)),
+                "rate_limit": Bson::DateTime(Utc::now() + chrono::Duration::minutes(1)),
+                "code": code.clone(),
+            },
+            false => doc! {
+                "verified": true
+            }
+        };
+
+        let id = Ulid::new().to_string();
         match col.insert_one(
             doc! {
-                "_id": Ulid::new().to_string(),
+                "_id": &id,
                 "email": info.email.clone(),
                 "username": info.username.clone(),
+                "display_name": info.username.clone(),
                 "password": hashed,
-                "access_token": access_token,
-                "email_verification": {
-                    "verified": false,
-                    "target": info.email.clone(),
-                    "expiry": UtcDatetime(Utc::now() + chrono::Duration::days(1)),
-                    "rate_limit": UtcDatetime(Utc::now() + chrono::Duration::minutes(1)),
-                    "code": code.clone(),
-                }
+                "access_token": &access_token,
+                "email_verification": email_verification
             },
             None,
         ) {
             Ok(_) => {
-                let sent = email::send_verification_email(info.email.clone(), code);
+                if *USE_EMAIL {
+                    let sent = email::send_verification_email(info.email.clone(), code);
 
-                Response::Success(json!({
-                    "success": true,
-                    "email_sent": sent,
-                }))
+                    Response::Success(json!({
+                        "email_sent": sent,
+                    }))
+                } else {
+                    Response::Success(json!({
+                        "id": id,
+                        "access_token": access_token
+                    }))
+                }
             }
             Err(_) => {
                 Response::InternalServerError(json!({ "error": "Failed to create account." }))
@@ -103,7 +135,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() {
@@ -131,11 +163,13 @@ pub fn verify_email(code: String) -> Response {
             )
             .expect("Failed to update user!");
 
-            email::send_welcome_email(target.to_string(), user.username);
+            if *USE_EMAIL {
+                if let Err(err) = email::send_welcome_email(target.to_string(), user.username) {
+                    error!("Failed to send welcome email! {}", err);
+                }
+            }
 
-            Response::Redirect(
-                super::Redirect::to("https://example.com"), // ! FIXME; redirect to landing page
-            )
+            Response::Redirect(super::Redirect::to("https://app.revolt.chat"))
         }
     } else {
         Response::BadRequest(json!({ "error": "Invalid code." }))
@@ -145,6 +179,7 @@ pub fn verify_email(code: String) -> Response {
 #[derive(Serialize, Deserialize)]
 pub struct Resend {
     email: String,
+    captcha: Option<String>,
 }
 
 /// resend a verification email
@@ -153,6 +188,10 @@ pub struct Resend {
 /// (3) resend the email
 #[post("/resend", data = "<info>")]
 pub fn resend_email(info: Json<Resend>) -> Response {
+    if let Err(error) = captcha::verify(&info.captcha) {
+        return Response::BadRequest(json!({ "error": error }));
+    }
+
     let col = database::get_collection("users");
 
     if let Some(u) = col
@@ -162,7 +201,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();
@@ -173,7 +212,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(
@@ -181,7 +220,7 @@ pub fn resend_email(info: Json<Resend>) -> Response {
                     );
                 }
 
-                new_expiry = UtcDatetime(*expiry);
+                new_expiry = Bson::DateTime(*expiry);
             }
 
             let code = gen_token(48);
@@ -191,23 +230,20 @@ 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,
 				).expect("Failed to update user!");
 
-            match email::send_verification_email(info.email.to_string(), code) {
-                true => Response::Result(super::Status::Ok),
-                false => Response::InternalServerError(
-                    json!({ "success": false, "error": "Failed to send email! Likely an issue with the backend API." }),
-                ),
+            if let Err(err) = email::send_verification_email(info.email.clone(), code) {
+                return Response::InternalServerError(json!({ "error": err }));
             }
+
+            Response::Result(super::Status::Ok)
         }
     } else {
-        Response::NotFound(
-            json!({ "success": false, "error": "Email not found or pending verification!" }),
-        )
+        Response::NotFound(json!({ "error": "Email not found or pending verification!" }))
     }
 }
 
@@ -215,6 +251,7 @@ pub fn resend_email(info: Json<Resend>) -> Response {
 pub struct Login {
     email: String,
     password: String,
+    captcha: Option<String>,
 }
 
 /// login to a Revolt account
@@ -223,13 +260,17 @@ pub struct Login {
 /// (3) return access token
 #[post("/login", data = "<info>")]
 pub fn login(info: Json<Login>) -> Response {
+    if let Err(error) = captcha::verify(&info.captcha) {
+        return Response::BadRequest(json!({ "error": error }));
+    }
+
     let col = database::get_collection("users");
 
     if let Some(u) = col
         .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.")
@@ -291,3 +332,24 @@ pub fn token(info: Json<Token>) -> Response {
         }))
     }
 }
+
+#[options("/create")]
+pub fn create_preflight() -> Response {
+    Response::Result(super::Status::Ok)
+}
+#[options("/verify/<_code>")]
+pub fn verify_email_preflight(_code: String) -> Response {
+    Response::Result(super::Status::Ok)
+}
+#[options("/resend")]
+pub fn resend_email_preflight() -> Response {
+    Response::Result(super::Status::Ok)
+}
+#[options("/login")]
+pub fn login_preflight() -> Response {
+    Response::Result(super::Status::Ok)
+}
+#[options("/token")]
+pub fn token_preflight() -> Response {
+    Response::Result(super::Status::Ok)
+}

src/routes/channel.rs

@@ -1,16 +1,19 @@
 use super::Response;
 use crate::database::{
-    self, get_relationship, get_relationship_internal, message::Message, Permission,
-    PermissionCalculator, Relationship,
+    self, channel::Channel, get_relationship, get_relationship_internal, message::Message,
+    user::User, Permission, PermissionCalculator, Relationship,
+};
+use crate::notifications::{
+    self,
+    events::{groups::*, guilds::ChannelDelete, message::*, Notification},
 };
-use crate::guards::auth::UserRef;
-use crate::guards::channel::ChannelRef;
 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;
 use rocket_contrib::json::Json;
 use serde::{Deserialize, Serialize};
 use ulid::Ulid;
@@ -49,7 +52,7 @@ pub struct CreateGroup {
 
 /// create a new group
 #[post("/create", data = "<info>")]
-pub fn create_group(user: UserRef, info: Json<CreateGroup>) -> Response {
+pub fn create_group(user: User, info: Json<CreateGroup>) -> Response {
     let name: String = info.name.chars().take(32).collect();
     let nonce: String = info.nonce.chars().take(32).collect();
 
@@ -86,13 +89,12 @@ pub fn create_group(user: UserRef, info: Json<CreateGroup>) -> Response {
             return Response::BadRequest(json!({ "error": "Specified non-existant user(s)." }));
         }
 
-        let relationships = user.fetch_relationships();
         for item in set {
             if item == user.id {
                 continue;
             }
 
-            if get_relationship_internal(&user.id, &item, &relationships) != Relationship::Friend {
+            if get_relationship_internal(&user.id, &item, &user.relations) != Relationship::Friend {
                 return Response::BadRequest(json!({ "error": "Not friends with user(s)." }));
             }
         }
@@ -125,65 +127,21 @@ 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: User, target: Channel) -> Option<Response> {
     with_permissions!(user, target);
-
-    match target.channel_type {
-        0 => Some(Response::Success(json!({
-            "id": target.id,
-            "type": target.channel_type,
-            "last_message": target.last_message,
-            "recipients": target.recipients,
-        }))),
-        1 => {
-            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(),
-                    "owner": info.get_str("owner").unwrap(),
-                    "description": info.get_str("description").unwrap_or(""),
-                })))
-            } else {
-                None
-            }
-        }
-        2 => {
-            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(),
-                    "description": info.get_str("description").unwrap_or(""),
-                })))
-            } else {
-                None
-            }
-        }
-        _ => unreachable!(),
-    }
+    Some(Response::Success(target.serialise()))
 }
 
 /// [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: User, target: Channel, member: User) -> Option<Response> {
     if target.channel_type != 1 {
         return Some(Response::BadRequest(json!({ "error": "Not a group DM." })));
     }
 
     with_permissions!(user, target);
 
-    let recp = target.recipients.unwrap();
+    let recp = target.recipients.as_ref().unwrap();
     if recp.len() == 50 {
         return Some(Response::BadRequest(
             json!({ "error": "Maximum group size is 50." }),
@@ -201,7 +159,7 @@ pub fn add_member(user: UserRef, target: ChannelRef, member: UserRef) -> Option<
         Relationship::Friend => {
             if database::get_collection("channels")
                 .update_one(
-                    doc! { "_id": &target.id },
+                    doc! { "_id": target.id.clone() },
                     doc! {
                         "$push": {
                             "recipients": &member.id
@@ -211,7 +169,31 @@ pub fn add_member(user: UserRef, target: ChannelRef, member: UserRef) -> Option<
                 )
                 .is_ok()
             {
-                Some(Response::Result(super::Status::Ok))
+                if (Message {
+                    id: Ulid::new().to_string(),
+                    nonce: None,
+                    channel: target.id.clone(),
+                    author: "system".to_string(),
+                    content: format!("<@{}> added <@{}> to the group.", &user.id, &member.id),
+                    edited: None,
+                    previous_content: vec![],
+                })
+                .send(&target)
+                {
+                    notifications::send_message_given_channel(
+                        Notification::group_user_join(UserJoin {
+                            id: target.id.clone(),
+                            user: member.id.clone(),
+                        }),
+                        &target,
+                    );
+
+                    Some(Response::Result(super::Status::Ok))
+                } else {
+                    Some(Response::PartialStatus(
+                        json!({ "error": "Failed to send join message, but user has been added." }),
+                    ))
+                }
             } else {
                 Some(Response::InternalServerError(
                     json!({ "error": "Failed to add user to group." }),
@@ -226,7 +208,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: User, target: Channel, member: User) -> Option<Response> {
     if target.channel_type != 1 {
         return Some(Response::BadRequest(json!({ "error": "Not a group DM." })));
     }
@@ -243,7 +225,7 @@ pub fn remove_member(user: UserRef, target: ChannelRef, member: UserRef) -> Opti
         return Some(Response::LackingPermission(Permission::KickMembers));
     }
 
-    let set = vec_to_set(&target.recipients.unwrap());
+    let set = vec_to_set(target.recipients.as_ref().unwrap());
     if set.get(&member.id).is_none() {
         return Some(Response::BadRequest(
             json!({ "error": "User not in group!" }),
@@ -262,7 +244,31 @@ pub fn remove_member(user: UserRef, target: ChannelRef, member: UserRef) -> Opti
         )
         .is_ok()
     {
-        Some(Response::Result(super::Status::Ok))
+        if (Message {
+            id: Ulid::new().to_string(),
+            nonce: None,
+            channel: target.id.clone(),
+            author: "system".to_string(),
+            content: format!("<@{}> removed <@{}> from the group.", &user.id, &member.id),
+            edited: None,
+            previous_content: vec![],
+        })
+        .send(&target)
+        {
+            notifications::send_message_given_channel(
+                Notification::group_user_leave(UserLeave {
+                    id: target.id.clone(),
+                    user: member.id.clone(),
+                }),
+                &target,
+            );
+
+            Some(Response::Result(super::Status::Ok))
+        } else {
+            Some(Response::PartialStatus(
+                json!({ "error": "Failed to send join message, but user has been removed." }),
+            ))
+        }
     } else {
         Some(Response::InternalServerError(
             json!({ "error": "Failed to add user to group." }),
@@ -274,7 +280,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: User, target: Channel) -> Option<Response> {
     let permissions = with_permissions!(user, target);
 
     if !permissions.get_manage_channels() {
@@ -295,7 +301,7 @@ pub fn delete(user: UserRef, target: ChannelRef) -> Option<Response> {
                 Some(Response::Result(super::Status::Ok))
             } else {
                 Some(Response::InternalServerError(
-                    json!({ "error": "Failed to delete group." }),
+                    json!({ "error": "Failed to delete channel." }),
                 ))
             }
         } else {
@@ -323,15 +329,19 @@ pub fn delete(user: UserRef, target: ChannelRef) -> Option<Response> {
             }
         }
         1 => {
-            let mut recipients =
-                vec_to_set(&target.recipients.expect("Missing recipients on Group DM."));
-            let owner = target.owner.expect("Missing owner on Group DM.");
+            let mut recipients = vec_to_set(
+                target
+                    .recipients
+                    .as_ref()
+                    .expect("Missing recipients on Group DM."),
+            );
+            let owner = target.owner.as_ref().expect("Missing owner on Group DM.");
 
             if recipients.len() == 1 {
                 try_delete()
             } else {
                 recipients.remove(&user.id);
-                let new_owner = if owner == user.id {
+                let new_owner = if owner == &user.id {
                     recipients.iter().next().unwrap()
                 } else {
                     &owner
@@ -352,7 +362,31 @@ pub fn delete(user: UserRef, target: ChannelRef) -> Option<Response> {
                     )
                     .is_ok()
                 {
-                    Some(Response::Result(super::Status::Ok))
+                    if (Message {
+                        id: Ulid::new().to_string(),
+                        nonce: None,
+                        channel: target.id.clone(),
+                        author: "system".to_string(),
+                        content: format!("<@{}> left the group.", &user.id),
+                        edited: None,
+                        previous_content: vec![],
+                    })
+                    .send(&target)
+                    {
+                        notifications::send_message_given_channel(
+                            Notification::group_user_leave(UserLeave {
+                                id: target.id.clone(),
+                                user: user.id.clone(),
+                            }),
+                            &target,
+                        );
+
+                        Some(Response::Result(super::Status::Ok))
+                    } else {
+                        Some(Response::PartialStatus(
+                            json!({ "error": "Failed to send leave message, but you have left the group." }),
+                        ))
+                    }
                 } else {
                     Some(Response::InternalServerError(
                         json!({ "error": "Failed to remove you from the group." }),
@@ -361,20 +395,31 @@ pub fn delete(user: UserRef, target: ChannelRef) -> Option<Response> {
             }
         }
         2 => {
+            let guild_id = target.guild.unwrap();
             if database::get_collection("guilds")
                 .update_one(
-                    doc! { "_id": target.guild.unwrap() },
+                    doc! { "_id": &guild_id },
                     doc! {
                         "$pull": {
                             "invites": {
                                 "channel": &target.id
-                            }
+                            },
+                            "channels": &target.id
                         }
                     },
                     None,
                 )
                 .is_ok()
             {
+                notifications::send_message_threaded(
+                    None,
+                    guild_id.clone(),
+                    Notification::guild_channel_delete(ChannelDelete {
+                        id: guild_id.clone(),
+                        channel: target.id.clone(),
+                    }),
+                );
+
                 try_delete()
             } else {
                 Some(Response::InternalServerError(
@@ -388,22 +433,60 @@ pub fn delete(user: UserRef, target: ChannelRef) -> Option<Response> {
     }
 }
 
+#[derive(Serialize, Deserialize, FromForm)]
+pub struct MessageFetchOptions {
+    limit: Option<i64>,
+    before: Option<String>,
+    after: Option<String>,
+}
+
 /// fetch channel messages
-#[get("/<target>/messages")]
-pub fn messages(user: UserRef, target: ChannelRef) -> Option<Response> {
+#[get("/<target>/messages?<options..>")]
+pub fn messages(
+    user: User,
+    target: Channel,
+    options: Form<MessageFetchOptions>,
+) -> Option<Response> {
     let permissions = with_permissions!(user, target);
 
     if !permissions.get_read_messages() {
         return Some(Response::LackingPermission(Permission::ReadMessages));
     }
 
+    // ! FIXME: update wiki to reflect changes
+    let mut query = doc! { "channel": target.id };
+
+    if let Some(before) = &options.before {
+        query.insert("_id", doc! { "$lt": before });
+    }
+
+    if let Some(after) = &options.after {
+        query.insert("_id", doc! { "$gt": after });
+    }
+
+    let limit = if let Some(limit) = options.limit {
+        limit.min(100).max(0)
+    } else {
+        50
+    };
+
     let col = database::get_collection("messages");
-    let result = col.find(doc! { "channel": target.id }, None).unwrap();
+    let result = col
+        .find(
+            query,
+            FindOptions::builder()
+                .limit(limit)
+                .sort(doc! {
+                    "_id": -1
+                })
+                .build(),
+        )
+        .unwrap();
 
     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,
@@ -423,11 +506,7 @@ pub struct SendMessage {
 
 /// send a message to a channel
 #[post("/<target>/messages", data = "<message>")]
-pub fn send_message(
-    user: UserRef,
-    target: ChannelRef,
-    message: Json<SendMessage>,
-) -> Option<Response> {
+pub fn send_message(user: User, target: Channel, message: Json<SendMessage>) -> Option<Response> {
     let permissions = with_permissions!(user, target);
 
     if !permissions.get_send_messages() {
@@ -441,6 +520,12 @@ pub fn send_message(
     let content: String = message.content.chars().take(2000).collect();
     let nonce: String = message.nonce.chars().take(32).collect();
 
+    if content.len() == 0 {
+        return Some(Response::NotAcceptable(
+            json!({ "error": "No message content!" }),
+        ));
+    }
+
     let col = database::get_collection("messages");
     if col
         .find_one(doc! { "nonce": nonce.clone() }, None)
@@ -453,109 +538,49 @@ pub fn send_message(
     }
 
     let id = Ulid::new().to_string();
-    Some(
-        if col
-            .insert_one(
-                doc! {
-                    "_id": &id,
-                    "nonce": nonce,
-                    "channel": &target.id,
-                    "author": &user.id,
-                    "content": &content,
-                },
-                None,
-            )
-            .is_ok()
-        {
-            let short_content: String = content.chars().take(24).collect();
-            let col = database::get_collection("channels");
+    let message = Message {
+        id: id.clone(),
+        nonce: Some(nonce),
+        channel: target.id.clone(),
+        author: user.id,
+        content,
+        edited: None,
+        previous_content: vec![],
+    };
 
-            // !! 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": &id,
-                            "user_id": &user.id,
-                            "short_content": short_content,
-                        }
-                    }
-                };
-
-                if target.channel_type == ChannelType::DM as u8 {
-                    update
-                        .get_document_mut("$set")
-                        .unwrap()
-                        .insert("active", true);
-                }
-
-                if col
-                    .update_one(doc! { "_id": &target.id }, update, None)
-                    .is_ok()
-                {
-                    Response::Success(json!({ "id": id }))
-                } else {
-                    Response::InternalServerError(json!({ "error": "Failed to update channel." }))
-                }
-            } else {
-                Response::Success(json!({ "id": id }))
-            }
-
-        /*websocket::queue_message(
-            get_recipients(&target),
-            json!({
-                "type": "message",
-                "data": {
-                    "id": id.clone(),
-                    "nonce": nonce,
-                    "channel": target.id,
-                    "author": user.id,
-                    "content": content,
-                },
-            })
-            .to_string(),
-        );*/
-        } else {
-            Response::InternalServerError(json!({
-                "error": "Failed database query."
-            }))
-        },
-    )
+    if message.send(&target) {
+        Some(Response::Success(json!({ "id": id })))
+    } else {
+        Some(Response::BadRequest(
+            json!({ "error": "Failed to 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: User, target: Channel, message: Message) -> Option<Response> {
     let permissions = with_permissions!(user, target);
 
     if !permissions.get_read_messages() {
         return Some(Response::LackingPermission(Permission::ReadMessages));
     }
 
-    let prev =
-        // ! CHECK IF USER HAS PERMISSION TO VIEW EDITS OF MESSAGES
-        if let Some(previous) = message.previous_content {
-            let mut entries = vec![];
-            for entry in previous {
-                entries.push(json!({
-                    "content": entry.content,
-                    "time": entry.time.timestamp(),
-                }));
-            }
-
-            Some(entries)
-        } else {
-            None
-        };
+    // ! CHECK IF USER HAS PERMISSION TO VIEW EDITS OF MESSAGES
+    let mut entries = vec![];
+    for entry in message.previous_content {
+        entries.push(json!({
+            "content": entry.content,
+            "time": entry.time.timestamp(),
+        }));
+    }
 
     Some(Response::Success(json!({
         "id": message.id,
         "author": message.author,
         "content": message.content,
         "edited": if let Some(t) = message.edited { Some(t.timestamp()) } else { None },
-        "previous_content": prev,
+        "previous_content": entries,
     })))
 }
 
@@ -567,8 +592,8 @@ pub struct EditMessage {
 /// edit a message
 #[patch("/<target>/messages/<message>", data = "<edit>")]
 pub fn edit_message(
-    user: UserRef,
-    target: ChannelRef,
+    user: User,
+    target: Channel,
     message: Message,
     edit: Json<EditMessage>,
 ) -> Option<Response> {
@@ -592,12 +617,12 @@ pub fn edit_message(
         doc! { "_id": message.id.clone() },
         doc! {
             "$set": {
-                "content": edit.content.clone(),
-                "edited": UtcDatetime(edited)
+                "content": &edit.content,
+                "edited": Bson::DateTime(edited)
             },
             "$push": {
                 "previous_content": {
-                    "content": message.content,
+                    "content": &message.content,
                     "time": time,
                 }
             },
@@ -605,19 +630,15 @@ pub fn edit_message(
         None,
     ) {
         Ok(_) => {
-            /*websocket::queue_message(
-                get_recipients(&target),
-                json!({
-                    "type": "message_update",
-                    "data": {
-                        "id": message.id,
-                        "channel": target.id,
-                        "content": edit.content.clone(),
-                        "edited": edited.timestamp()
-                    },
-                })
-                .to_string(),
-            );*/
+            notifications::send_message_given_channel(
+                Notification::message_edit(Edit {
+                    id: message.id.clone(),
+                    channel: target.id.clone(),
+                    author: message.author.clone(),
+                    content: edit.content.clone(),
+                }),
+                &target,
+            );
 
             Some(Response::Result(super::Status::Ok))
         }
@@ -629,30 +650,23 @@ 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: User, target: Channel, message: Message) -> Option<Response> {
     let permissions = with_permissions!(user, target);
 
-    if !permissions.get_manage_messages() {
-        if message.author != user.id {
-            return Some(Response::LackingPermission(Permission::ManageMessages));
-        }
+    if !permissions.get_manage_messages() && message.author != user.id {
+        return Some(Response::LackingPermission(Permission::ManageMessages));
     }
 
     let col = database::get_collection("messages");
 
     match col.delete_one(doc! { "_id": &message.id }, None) {
         Ok(_) => {
-            /*websocket::queue_message(
-                get_recipients(&target),
-                json!({
-                    "type": "message_delete",
-                    "data": {
-                        "id": message.id,
-                        "channel": target.id
-                    },
-                })
-                .to_string(),
-            );*/
+            notifications::send_message_given_channel(
+                Notification::message_delete(Delete {
+                    id: message.id.clone(),
+                }),
+                &target,
+            );
 
             Some(Response::Result(super::Status::Ok))
         }
@@ -661,3 +675,24 @@ pub fn delete_message(user: UserRef, target: ChannelRef, message: Message) -> Op
         )),
     }
 }
+
+#[options("/create")]
+pub fn create_group_preflight() -> Response {
+    Response::Result(super::Status::Ok)
+}
+#[options("/<_target>")]
+pub fn channel_preflight(_target: String) -> Response {
+    Response::Result(super::Status::Ok)
+}
+#[options("/<_target>/recipients/<_member>")]
+pub fn member_preflight(_target: String, _member: String) -> Response {
+    Response::Result(super::Status::Ok)
+}
+#[options("/<_target>/messages")]
+pub fn messages_preflight(_target: String) -> Response {
+    Response::Result(super::Status::Ok)
+}
+#[options("/<_target>/messages/<_message>")]
+pub fn message_preflight(_target: String, _message: String) -> Response {
+    Response::Result(super::Status::Ok)
+}

src/routes/guild.rs

@@ -1,18 +1,24 @@
 use super::channel::ChannelType;
 use super::Response;
-use crate::database::{self, 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::database::guild::{fetch_member as get_member, get_invite, Guild, MemberKey};
+use crate::database::{
+    self, channel::fetch_channel, channel::Channel, guild::serialise_guilds_with_channels,
+    user::User, Permission, PermissionCalculator,
+};
+use crate::notifications::{
+    self,
+    events::{guilds::*, Notification},
+};
 use crate::util::gen_token;
 
-use bson::{doc, from_bson, Bson};
+use mongodb::bson::{doc, Bson};
 use mongodb::options::{FindOneOptions, FindOptions};
 use rocket::request::Form;
 use rocket_contrib::json::Json;
 use serde::{Deserialize, Serialize};
 use ulid::Ulid;
 
+// ! FIXME: GET RID OF THIS
 macro_rules! with_permissions {
     ($user: expr, $target: expr) => {{
         let permissions = PermissionCalculator::new($user.clone())
@@ -30,54 +36,10 @@ macro_rules! with_permissions {
 
 /// fetch your guilds
 #[get("/@me")]
-pub fn my_guilds(user: UserRef) -> Response {
-    if let Ok(result) = database::get_collection("members").find(
-        doc! {
-            "_id.user": &user.id
-        },
-        None,
-    ) {
-        let mut guilds = vec![];
-        for item in result {
-            if let Ok(entry) = item {
-                guilds.push(Bson::String(
-                    entry
-                        .get_document("_id")
-                        .unwrap()
-                        .get_str("guild")
-                        .unwrap()
-                        .to_string(),
-                ));
-            }
-        }
-
-        if let Ok(result) = database::get_collection("guilds").find(
-            doc! {
-                "_id": {
-                    "$in": guilds
-                }
-            },
-            FindOptions::builder()
-                .projection(doc! {
-                    "_id": 1,
-                    "name": 1,
-                    "description": 1,
-                    "owner": 1,
-                })
-                .build(),
-        ) {
-            let mut parsed = vec![];
-            for item in result {
-                let doc = item.unwrap();
-                parsed.push(json!({
-                    "id": doc.get_str("_id").unwrap(),
-                    "name": doc.get_str("name").unwrap(),
-                    "description": doc.get_str("description").unwrap(),
-                    "owner": doc.get_str("owner").unwrap(),
-                }));
-            }
-
-            Response::Success(json!(parsed))
+pub fn my_guilds(user: User) -> Response {
+    if let Ok(gids) = user.find_guilds() {
+        if let Ok(data) = serialise_guilds_with_channels(&gids) {
+            Response::Success(json!(data))
         } else {
             Response::InternalServerError(json!({ "error": "Failed to fetch guilds." }))
         }
@@ -88,50 +50,21 @@ 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: User, target: Guild) -> Option<Response> {
     with_permissions!(user, target);
 
-    let col = database::get_collection("channels");
-    match col.find(
-        doc! {
-            "type": 2,
-            "guild": &target.id,
-        },
-        None,
-    ) {
-        Ok(results) => {
-            let mut channels = vec![];
-            for item in results {
-                if let Ok(entry) = item {
-                    if let Ok(channel) =
-                        from_bson(bson::Bson::Document(entry)) as Result<Channel, _>
-                    {
-                        channels.push(json!({
-                            "id": channel.id,
-                            "name": channel.name,
-                            "description": channel.description,
-                        }));
-                    }
-                }
-            }
-
-            Some(Response::Success(json!({
-                "id": target.id,
-                "name": target.name,
-                "description": target.description,
-                "owner": target.owner,
-                "channels": channels,
-            })))
-        }
-        Err(_) => Some(Response::InternalServerError(
-            json!({ "error": "Failed to fetch channels." }),
-        )),
+    if let Ok(result) = target.seralise_with_channels() {
+        Some(Response::Success(result))
+    } else {
+        Some(Response::InternalServerError(
+            json!({ "error": "Failed to fetch channels!" }),
+        ))
     }
 }
 
 /// delete or leave a guild
 #[delete("/<target>")]
-pub fn remove_guild(user: UserRef, target: GuildRef) -> Option<Response> {
+pub fn remove_guild(user: User, target: Guild) -> Option<Response> {
     with_permissions!(user, target);
 
     if user.id == target.owner {
@@ -171,19 +104,41 @@ pub fn remove_guild(user: UserRef, target: GuildRef) -> Option<Response> {
                     )
                     .is_ok()
                 {
-                    if database::get_collection("guilds")
-                        .delete_one(
+                    if database::get_collection("members")
+                        .delete_many(
                             doc! {
-                                "_id": &target.id
+                                "_id.guild": &target.id,
                             },
                             None,
                         )
                         .is_ok()
                     {
-                        Some(Response::Result(super::Status::Ok))
+                        if database::get_collection("guilds")
+                            .delete_one(
+                                doc! {
+                                    "_id": &target.id
+                                },
+                                None,
+                            )
+                            .is_ok()
+                        {
+                            notifications::send_message_threaded(
+                                None,
+                                target.id.clone(),
+                                Notification::guild_delete(Delete {
+                                    id: target.id.clone(),
+                                }),
+                            );
+
+                            Some(Response::Result(super::Status::Ok))
+                        } else {
+                            Some(Response::InternalServerError(
+                                json!({ "error": "Failed to delete guild." }),
+                            ))
+                        }
                     } else {
                         Some(Response::InternalServerError(
-                            json!({ "error": "Failed to delete guild." }),
+                            json!({ "error": "Failed to delete guild members." }),
                         ))
                     }
                 } else {
@@ -201,23 +156,31 @@ pub fn remove_guild(user: UserRef, target: GuildRef) -> Option<Response> {
                 json!({ "error": "Could not fetch channels." }),
             ))
         }
+    } else if database::get_collection("members")
+        .delete_one(
+            doc! {
+                "_id.guild": &target.id,
+                "_id.user": &user.id,
+            },
+            None,
+        )
+        .is_ok()
+    {
+        notifications::send_message_threaded(
+            None,
+            target.id.clone(),
+            Notification::guild_user_leave(UserLeave {
+                id: target.id.clone(),
+                user: user.id.clone(),
+                banned: false,
+            }),
+        );
+
+        Some(Response::Result(super::Status::Ok))
     } else {
-        if database::get_collection("members")
-            .delete_one(
-                doc! {
-                    "_id.guild": &target.id,
-                    "_id.user": &user.id,
-                },
-                None,
-            )
-            .is_ok()
-        {
-            Some(Response::Result(super::Status::Ok))
-        } else {
-            Some(Response::InternalServerError(
-                json!({ "error": "Failed to remove you from the guild." }),
-            ))
-        }
+        Some(Response::InternalServerError(
+            json!({ "error": "Failed to remove you from the guild." }),
+        ))
     }
 }
 
@@ -230,11 +193,7 @@ pub struct CreateChannel {
 
 /// create a new channel
 #[post("/<target>/channels", data = "<info>")]
-pub fn create_channel(
-    user: UserRef,
-    target: GuildRef,
-    info: Json<CreateChannel>,
-) -> Option<Response> {
+pub fn create_channel(user: User, target: Guild, info: Json<CreateChannel>) -> Option<Response> {
     let (permissions, _) = with_permissions!(user, target);
 
     if !permissions.get_manage_channels() {
@@ -268,16 +227,46 @@ pub fn create_channel(
                     "nonce": &nonce,
                     "type": 2,
                     "guild": &target.id,
-                    "name": name,
-                    "description": description,
+                    "name": &name,
+                    "description": &description,
                 },
                 None,
             )
             .is_ok()
         {
-            Some(Response::Success(json!({ "id": &id })))
+            if database::get_collection("guilds")
+                .update_one(
+                    doc! {
+                        "_id": &target.id
+                    },
+                    doc! {
+                        "$addToSet": {
+                            "channels": &id
+                        }
+                    },
+                    None,
+                )
+                .is_ok()
+            {
+                notifications::send_message_threaded(
+                    None,
+                    target.id.clone(),
+                    Notification::guild_channel_create(ChannelCreate {
+                        id: target.id.clone(),
+                        channel: id.clone(),
+                        name: name.clone(),
+                        description: description.clone(),
+                    }),
+                );
+
+                Some(Response::Success(json!({ "id": &id })))
+            } else {
+                Some(Response::InternalServerError(
+                    json!({ "error": "Couldn't save channel list." }),
+                ))
+            }
         } else {
-            Some(Response::BadRequest(
+            Some(Response::InternalServerError(
                 json!({ "error": "Couldn't create channel." }),
             ))
         }
@@ -296,9 +285,9 @@ pub struct InviteOptions {
 /// create a new invite
 #[post("/<target>/channels/<channel>/invite", data = "<_options>")]
 pub fn create_invite(
-    user: UserRef,
-    target: GuildRef,
-    channel: ChannelRef,
+    user: User,
+    target: Guild,
+    channel: Channel,
     _options: Json<InviteOptions>,
 ) -> Option<Response> {
     let (permissions, _) = with_permissions!(user, target);
@@ -334,14 +323,12 @@ 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: User, target: Guild, code: String) -> Option<Response> {
     let (permissions, _) = with_permissions!(user, target);
 
     if let Some((guild_id, _, invite)) = get_invite(&code, None) {
-        if invite.creator != user.id {
-            if !permissions.get_manage_server() {
-                return Some(Response::LackingPermission(Permission::ManageServer));
-            }
+        if invite.creator != user.id && !permissions.get_manage_server() {
+            return Some(Response::LackingPermission(Permission::ManageServer));
         }
 
         if database::get_collection("guilds")
@@ -375,41 +362,38 @@ 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: User, 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! {
-        "invites": 1,
-    }) {
-        Some(Response::Success(json!(doc.get_array("invites").unwrap())))
-    } else {
-        Some(Response::InternalServerError(
-            json!({ "error": "Failed to fetch invites." }),
-        ))
-    }
+    Some(Response::Success(json!(target.invites)))
 }
 
 /// view an invite before joining
 #[get("/join/<code>", rank = 1)]
-pub fn fetch_invite(user: UserRef, code: String) -> Response {
+pub fn fetch_invite(user: User, code: String) -> Response {
     if let Some((guild_id, name, invite)) = get_invite(&code, user.id) {
-        if let Some(channel) = ChannelRef::from(invite.channel) {
-            Response::Success(json!({
-                "guild": {
-                    "id": guild_id,
-                    "name": name,
-                },
-                "channel": {
-                    "id": channel.id,
-                    "name": channel.name,
+        match fetch_channel(&invite.channel) {
+            Ok(result) => {
+                if let Some(channel) = result {
+                    Response::Success(json!({
+                        "guild": {
+                            "id": guild_id,
+                            "name": name,
+                        },
+                        "channel": {
+                            "id": channel.id,
+                            "name": channel.name,
+                        }
+                    }))
+                } else {
+                    Response::NotFound(json!({ "error": "Channel does not exist." }))
                 }
-            }))
-        } else {
-            Response::BadRequest(json!({ "error": "Failed to fetch channel." }))
+            }
+            Err(err) => Response::InternalServerError(json!({ "error": err })),
         }
     } else {
         Response::NotFound(json!({ "error": "Failed to fetch invite or code is invalid." }))
@@ -418,7 +402,7 @@ pub fn fetch_invite(user: UserRef, code: String) -> Response {
 
 /// join a guild using an invite
 #[post("/join/<code>", rank = 1)]
-pub fn use_invite(user: UserRef, code: String) -> Response {
+pub fn use_invite(user: User, code: String) -> Response {
     if let Some((guild_id, _, invite)) = get_invite(&code, Some(user.id.clone())) {
         if let Ok(result) = database::get_collection("members").find_one(
             doc! {
@@ -442,6 +426,15 @@ pub fn use_invite(user: UserRef, code: String) -> Response {
                     )
                     .is_ok()
                 {
+                    notifications::send_message_threaded(
+                        None,
+                        guild_id.clone(),
+                        Notification::guild_user_join(UserJoin {
+                            id: guild_id.clone(),
+                            user: user.id.clone(),
+                        }),
+                    );
+
                     Response::Success(json!({
                         "guild": &guild_id,
                         "channel": &invite.channel,
@@ -473,8 +466,8 @@ pub struct CreateGuild {
 
 /// create a new guild
 #[post("/create", data = "<info>")]
-pub fn create_guild(user: UserRef, info: Json<CreateGuild>) -> Response {
-    if !user.email_verified {
+pub fn create_guild(user: User, info: Json<CreateGuild>) -> Response {
+    if !user.email_verification.verified {
         return Response::Unauthorized(json!({ "error": "Email not verified!" }));
     }
 
@@ -543,6 +536,7 @@ pub fn create_guild(user: UserRef, info: Json<CreateGuild>) -> Response {
                 "name": name,
                 "description": description,
                 "owner": &user.id,
+                "channels": [ channel_id.clone() ],
                 "invites": [],
                 "bans": [],
                 "default_permissions": 51,
@@ -563,7 +557,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: User, target: Guild) -> Option<Response> {
     with_permissions!(user, target);
 
     if let Ok(result) =
@@ -590,24 +584,30 @@ 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: User, target: Guild, other: String) -> Option<Response> {
     with_permissions!(user, target);
 
-    if let Some(member) = get_member(&target.id, &other) {
-        Some(Response::Success(json!({
-            "id": member.id.user,
-            "nickname": member.nickname,
-        })))
+    if let Ok(result) = get_member(MemberKey(target.id, other)) {
+        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." }),
+            json!({ "error": "Failed to fetch member." }),
         ))
     }
 }
 
 /// 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: User, target: Guild, other: String) -> Option<Response> {
     let (permissions, _) = with_permissions!(user, target);
 
     if user.id == other {
@@ -620,9 +620,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() {
-        return Some(Response::BadRequest(
-            json!({ "error": "User not part of guild." }),
+    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." }),
         ));
     }
 
@@ -636,6 +642,16 @@ pub fn kick_member(user: UserRef, target: GuildRef, other: String) -> Option<Res
         )
         .is_ok()
     {
+        notifications::send_message_threaded(
+            None,
+            target.id.clone(),
+            Notification::guild_user_leave(UserLeave {
+                id: target.id.clone(),
+                user: other.clone(),
+                banned: false,
+            }),
+        );
+
         Some(Response::Result(super::Status::Ok))
     } else {
         Some(Response::InternalServerError(
@@ -652,8 +668,8 @@ pub struct BanOptions {
 /// ban a guild member
 #[put("/<target>/members/<other>/ban?<options..>")]
 pub fn ban_member(
-    user: UserRef,
-    target: GuildRef,
+    user: User,
+    target: Guild,
     other: String,
     options: Form<BanOptions>,
 ) -> Option<Response> {
@@ -676,9 +692,15 @@ pub fn ban_member(
         return Some(Response::LackingPermission(Permission::BanMembers));
     }
 
-    if get_member(&target.id, &other).is_none() {
-        return Some(Response::BadRequest(
-            json!({ "error": "User not part of guild." }),
+    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." }),
         ));
     }
 
@@ -712,6 +734,16 @@ pub fn ban_member(
         )
         .is_ok()
     {
+        notifications::send_message_threaded(
+            None,
+            target.id.clone(),
+            Notification::guild_user_leave(UserLeave {
+                id: target.id.clone(),
+                user: other.clone(),
+                banned: true,
+            }),
+        );
+
         Some(Response::Result(super::Status::Ok))
     } else {
         Some(Response::InternalServerError(
@@ -722,7 +754,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: User, target: Guild, other: String) -> Option<Response> {
     let (permissions, _) = with_permissions!(user, target);
 
     if user.id == other {
@@ -735,19 +767,7 @@ pub fn unban_member(user: UserRef, target: GuildRef, other: String) -> Option<Re
         return Some(Response::LackingPermission(Permission::BanMembers));
     }
 
-    if target
-        .fetch_data_given(
-            doc! {
-                "bans": {
-                    "$elemMatch": {
-                        "id": &other
-                    }
-                }
-            },
-            doc! {},
-        )
-        .is_none()
-    {
+    if target.bans.iter().any(|v| v.id == other) {
         return Some(Response::BadRequest(json!({ "error": "User not banned." })));
     }
 
@@ -776,3 +796,44 @@ pub fn unban_member(user: UserRef, target: GuildRef, other: String) -> Option<Re
         ))
     }
 }
+
+#[options("/<_target>")]
+pub fn guild_preflight(_target: String) -> Response {
+    Response::Result(super::Status::Ok)
+}
+#[options("/<_target>/channels")]
+pub fn create_channel_preflight(_target: String) -> Response {
+    Response::Result(super::Status::Ok)
+}
+#[options("/<_target>/channels/<_channel>/invite")]
+pub fn create_invite_preflight(_target: String, _channel: String) -> Response {
+    Response::Result(super::Status::Ok)
+}
+#[options("/<_target>/invites/<_code>")]
+pub fn remove_invite_preflight(_target: String, _code: String) -> Response {
+    Response::Result(super::Status::Ok)
+}
+#[options("/<_target>/invites")]
+pub fn fetch_invites_preflight(_target: String) -> Response {
+    Response::Result(super::Status::Ok)
+}
+#[options("/join/<_code>", rank = 1)]
+pub fn invite_preflight(_code: String) -> Response {
+    Response::Result(super::Status::Ok)
+}
+#[options("/create")]
+pub fn create_guild_preflight() -> Response {
+    Response::Result(super::Status::Ok)
+}
+#[options("/<_target>/members")]
+pub fn fetch_members_preflight(_target: String) -> Response {
+    Response::Result(super::Status::Ok)
+}
+#[options("/<_target>/members/<_other>")]
+pub fn fetch_member_preflight(_target: String, _other: String) -> Response {
+    Response::Result(super::Status::Ok)
+}
+#[options("/<_target>/members/<_other>/ban")]
+pub fn ban_member_preflight(_target: String, _other: String) -> Response {
+    Response::Result(super::Status::Ok)
+}

src/routes/mod.rs

@@ -19,6 +19,8 @@ pub enum Response {
     Success(JsonValue),
     #[response()]
     Redirect(Redirect),
+    #[response(status = 207)]
+    PartialStatus(JsonValue),
     #[response(status = 400)]
     BadRequest(JsonValue),
     #[response(status = 401)]
@@ -33,6 +35,8 @@ pub enum Response {
     Conflict(JsonValue),
     #[response(status = 410)]
     Gone(JsonValue),
+    #[response(status = 418)]
+    Teapot(JsonValue),
     #[response(status = 422)]
     UnprocessableEntity(JsonValue),
     #[response(status = 429)]
@@ -51,8 +55,7 @@ impl<'a> rocket::response::Responder<'a> for Permission {
             .header(ContentType::JSON)
             .sized_body(Cursor::new(format!(
                 "{{\"error\":\"Lacking permission: {:?}.\",\"permission\":{}}}",
-                self,
-                self as u32,
+                self, self as u32,
             )))
             .ok()
     }
@@ -60,23 +63,28 @@ impl<'a> rocket::response::Responder<'a> for Permission {
 
 pub fn mount(rocket: Rocket) -> Rocket {
     rocket
-        .mount("/api", routes![root::root])
+        .mount("/", routes![root::root, root::root_preflight, root::teapot])
         .mount(
-            "/api/account",
+            "/account",
             routes![
                 account::create,
                 account::verify_email,
                 account::resend_email,
                 account::login,
-                account::token
+                account::token,
+                account::create_preflight,
+                account::verify_email_preflight,
+                account::resend_email_preflight,
+                account::login_preflight,
+                account::token_preflight,
             ],
         )
         .mount(
-            "/api/users",
+            "/users",
             routes![
                 user::me,
                 user::user,
-                user::lookup,
+                user::query,
                 user::dms,
                 user::dm,
                 user::get_friends,
@@ -84,11 +92,17 @@ pub fn mount(rocket: Rocket) -> Rocket {
                 user::add_friend,
                 user::remove_friend,
                 user::block_user,
-                user::unblock_user
+                user::unblock_user,
+                user::user_preflight,
+                user::query_preflight,
+                user::dms_preflight,
+                user::dm_preflight,
+                user::friend_preflight,
+                user::block_user_preflight,
             ],
         )
         .mount(
-            "/api/channels",
+            "/channels",
             routes![
                 channel::create_group,
                 channel::channel,
@@ -99,11 +113,16 @@ pub fn mount(rocket: Rocket) -> Rocket {
                 channel::get_message,
                 channel::send_message,
                 channel::edit_message,
-                channel::delete_message
+                channel::delete_message,
+                channel::create_group_preflight,
+                channel::channel_preflight,
+                channel::member_preflight,
+                channel::messages_preflight,
+                channel::message_preflight,
             ],
         )
         .mount(
-            "/api/guild",
+            "/guild",
             routes![
                 guild::my_guilds,
                 guild::guild,
@@ -119,7 +138,17 @@ pub fn mount(rocket: Rocket) -> Rocket {
                 guild::fetch_member,
                 guild::kick_member,
                 guild::ban_member,
-                guild::unban_member
+                guild::unban_member,
+                guild::guild_preflight,
+                guild::create_channel_preflight,
+                guild::create_invite_preflight,
+                guild::remove_invite_preflight,
+                guild::fetch_invites_preflight,
+                guild::invite_preflight,
+                guild::create_guild_preflight,
+                guild::fetch_members_preflight,
+                guild::fetch_member_preflight,
+                guild::ban_member_preflight,
             ],
         )
 }

src/routes/root.rs

@@ -1,11 +1,36 @@
 use super::Response;
+use crate::util::variables::{USE_EMAIL, DISABLE_REGISTRATION, USE_HCAPTCHA};
 
-use bson::doc;
+use mongodb::bson::doc;
 
 /// root
 #[get("/")]
 pub fn root() -> Response {
     Response::Success(json!({
-        "revolt": "0.0.1"
+        "revolt": "0.2.10",
+        "version": {
+            "major": 0,
+            "minor": 2,
+            "patch": 10
+        },
+        "features": {
+            "registration": !*DISABLE_REGISTRATION,
+            "captcha": *USE_HCAPTCHA,
+            "email": *USE_EMAIL,
+        }
+    }))
+}
+
+#[options("/")]
+pub fn root_preflight() -> Response {
+    Response::Result(super::Status::Ok)
+}
+
+/// I'm a teapot.
+#[delete("/")]
+pub fn teapot() -> Response {
+    Response::Teapot(json!({
+        "teapot": true,
+        "can_delete": false
     }))
 }

src/routes/user.rs

@@ -1,47 +1,67 @@
 use super::Response;
-use crate::database::{self, get_relationship, get_relationship_internal, mutual, Relationship};
-use crate::guards::auth::UserRef;
+use crate::database::{
+    self, get_relationship, get_relationship_internal, user::User, Relationship,
+};
+use crate::notifications::{
+    self,
+    events::{users::*, Notification},
+};
 use crate::routes::channel;
 
-use bson::doc;
-use mongodb::options::FindOptions;
+use mongodb::bson::doc;
+use mongodb::options::{Collation, FindOneOptions, FindOptions};
 use rocket_contrib::json::Json;
 use serde::{Deserialize, Serialize};
 use ulid::Ulid;
 
 /// retrieve your user information
 #[get("/@me")]
-pub fn me(user: UserRef) -> Response {
-    if let Some(info) = user.fetch_data(doc! { "email": 1 }) {
-        Response::Success(json!({
-            "id": user.id,
-            "username": user.username,
-            "email": info.get_str("email").unwrap(),
-            "verified": user.email_verified,
-        }))
-    } else {
-        Response::InternalServerError(
-            json!({ "error": "Failed to fetch information from database." }),
-        )
-    }
+pub fn me(user: User) -> Response {
+    Response::Success(user.serialise(Relationship::SELF as i32))
 }
 
 /// retrieve another user's information
 #[get("/<target>")]
-pub fn user(user: UserRef, target: UserRef) -> Response {
-    Response::Success(json!({
-        "id": target.id,
-        "username": target.username,
-        "relationship": get_relationship(&user, &target) as u8,
-        "mutual": {
-            "guilds": mutual::find_mutual_guilds(&user.id, &target.id),
-            "friends": mutual::find_mutual_friends(&user.id, &target.id),
-            "groups": mutual::find_mutual_groups(&user.id, &target.id),
-        }
-    }))
+pub fn user(user: User, target: User) -> Response {
+    let relationship = get_relationship(&user, &target) as i32;
+    Response::Success(user.serialise(relationship))
 }
 
 #[derive(Serialize, Deserialize)]
+pub struct UserQuery {
+    username: String,
+}
+
+/// find a user by their username
+#[post("/query", data = "<query>")]
+pub fn query(user: User, query: Json<UserQuery>) -> Response {
+    let col = database::get_collection("users");
+
+    if let Ok(result) = col.find_one(
+        doc! { "username": query.username.clone() },
+        FindOneOptions::builder()
+            .collation(Collation::builder().locale("en").strength(2).build())
+            .build(),
+    ) {
+        if let Some(doc) = result {
+            let id = doc.get_str("_id").unwrap();
+            Response::Success(json!({
+                "id": id,
+                "username": doc.get_str("username").unwrap(),
+                "display_name": doc.get_str("display_name").unwrap(),
+                "relationship": get_relationship_internal(&user.id, &id, &user.relations) as i32
+            }))
+        } else {
+            Response::NotFound(json!({
+                "error": "User not found!"
+            }))
+        }
+    } else {
+        Response::InternalServerError(json!({ "error": "Failed database query." }))
+    }
+}
+
+/*#[derive(Serialize, Deserialize)]
 pub struct LookupQuery {
     username: String,
 }
@@ -49,7 +69,7 @@ pub struct LookupQuery {
 /// lookup a user on Revolt
 /// currently only supports exact username searches
 #[post("/lookup", data = "<query>")]
-pub fn lookup(user: UserRef, query: Json<LookupQuery>) -> Response {
+pub fn lookup(user: User, query: Json<LookupQuery>) -> Response {
     let relationships = user.fetch_relationships();
     let col = database::get_collection("users");
 
@@ -67,7 +87,7 @@ pub fn lookup(user: UserRef, query: Json<LookupQuery>) -> Response {
                 results.push(json!({
                     "id": id,
                     "username": doc.get_str("username").unwrap(),
-                    "relationship": get_relationship_internal(&user.id, &id, &relationships) as u8
+                    "relationship": get_relationship_internal(&user.id, &id, &relationships) as i32
                 }));
             }
         }
@@ -76,18 +96,19 @@ pub fn lookup(user: UserRef, query: Json<LookupQuery>) -> Response {
     } else {
         Response::InternalServerError(json!({ "error": "Failed database query." }))
     }
-}
+}*/
 
 /// retrieve all of your DMs
 #[get("/@me/dms")]
-pub fn dms(user: UserRef) -> Response {
+pub fn dms(user: User) -> Response {
     let col = database::get_collection("channels");
 
     if let Ok(results) = col.find(
         doc! {
             "$or": [
                 {
-                    "type": channel::ChannelType::DM as i32
+                    "type": channel::ChannelType::DM as i32,
+                    "active": true
                 },
                 {
                     "type": channel::ChannelType::GROUPDM as i32
@@ -101,6 +122,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() {
@@ -108,6 +130,7 @@ pub fn dms(user: UserRef) -> Response {
                         channels.push(json!({
                             "id": id,
                             "type": 0,
+                            "last_message": last_message,
                             "recipients": recipients,
                         }));
                     }
@@ -134,7 +157,7 @@ pub fn dms(user: UserRef) -> Response {
 
 /// open a DM with a user
 #[get("/<target>/dm")]
-pub fn dm(user: UserRef, target: UserRef) -> Response {
+pub fn dm(user: User, target: User) -> Response {
     let col = database::get_collection("channels");
 
     if let Ok(result) = col.find_one(
@@ -167,11 +190,9 @@ pub fn dm(user: UserRef, target: UserRef) -> Response {
 
 /// retrieve all of your friends
 #[get("/@me/friend")]
-pub fn get_friends(user: UserRef) -> Response {
-    let relationships = user.fetch_relationships();
-
+pub fn get_friends(user: User) -> Response {
     let mut results = Vec::new();
-    if let Some(arr) = relationships {
+    if let Some(arr) = user.relations {
         for item in arr {
             results.push(json!({
                 "id": item.id,
@@ -185,13 +206,13 @@ pub fn get_friends(user: UserRef) -> Response {
 
 /// retrieve friend status with user
 #[get("/<target>/friend")]
-pub fn get_friend(user: UserRef, target: UserRef) -> Response {
-    Response::Success(json!({ "status": get_relationship(&user, &target) as u8 }))
+pub fn get_friend(user: User, target: User) -> Response {
+    Response::Success(json!({ "status": get_relationship(&user, &target) as i32 }))
 }
 
 /// create or accept a friend request
 #[put("/<target>/friend")]
-pub fn add_friend(user: UserRef, target: UserRef) -> Response {
+pub fn add_friend(user: User, target: User) -> Response {
     let col = database::get_collection("users");
 
     match get_relationship(&user, &target) {
@@ -218,8 +239,8 @@ pub fn add_friend(user: UserRef, target: UserRef) -> Response {
                 if col
                     .update_one(
                         doc! {
-                            "_id": target.id,
-                            "relations.id": user.id
+                            "_id": target.id.clone(),
+                            "relations.id": user.id.clone()
                         },
                         doc! {
                             "$set": {
@@ -230,7 +251,27 @@ pub fn add_friend(user: UserRef, target: UserRef) -> Response {
                     )
                     .is_ok()
                 {
-                    Response::Success(json!({ "status": Relationship::Friend as u8 }))
+                    notifications::send_message_threaded(
+                        vec![target.id.clone()],
+                        None,
+                        Notification::user_friend_status(FriendStatus {
+                            id: target.id.clone(),
+                            user: user.id.clone(),
+                            status: Relationship::Friend as i32,
+                        }),
+                    );
+
+                    notifications::send_message_threaded(
+                        vec![user.id.clone()],
+                        None,
+                        Notification::user_friend_status(FriendStatus {
+                            id: user.id.clone(),
+                            user: target.id.clone(),
+                            status: Relationship::Friend as i32,
+                        }),
+                    );
+
+                    Response::Success(json!({ "status": Relationship::Friend as i32 }))
                 } else {
                     Response::InternalServerError(
                         json!({ "error": "Failed to commit! Try re-adding them as a friend." }),
@@ -269,12 +310,12 @@ pub fn add_friend(user: UserRef, target: UserRef) -> Response {
                 if col
                     .update_one(
                         doc! {
-                            "_id": target.id
+                            "_id": target.id.clone()
                         },
                         doc! {
                             "$push": {
                                 "relations": {
-                                    "id": user.id,
+                                    "id": user.id.clone(),
                                     "status": Relationship::Incoming as i32
                                 }
                             }
@@ -283,7 +324,27 @@ pub fn add_friend(user: UserRef, target: UserRef) -> Response {
                     )
                     .is_ok()
                 {
-                    Response::Success(json!({ "status": Relationship::Outgoing as u8 }))
+                    notifications::send_message_threaded(
+                        vec![user.id.clone()],
+                        None,
+                        Notification::user_friend_status(FriendStatus {
+                            id: user.id.clone(),
+                            user: target.id.clone(),
+                            status: Relationship::Outgoing as i32,
+                        }),
+                    );
+
+                    notifications::send_message_threaded(
+                        vec![target.id.clone()],
+                        None,
+                        Notification::user_friend_status(FriendStatus {
+                            id: target.id.clone(),
+                            user: user.id.clone(),
+                            status: Relationship::Incoming as i32,
+                        }),
+                    );
+
+                    Response::Success(json!({ "status": Relationship::Outgoing as i32 }))
                 } else {
                     Response::InternalServerError(
                         json!({ "error": "Failed to commit! Try re-adding them as a friend." }),
@@ -303,7 +364,7 @@ pub fn add_friend(user: UserRef, target: UserRef) -> Response {
 
 /// remove a friend or deny a request
 #[delete("/<target>/friend")]
-pub fn remove_friend(user: UserRef, target: UserRef) -> Response {
+pub fn remove_friend(user: User, target: User) -> Response {
     let col = database::get_collection("users");
 
     match get_relationship(&user, &target) {
@@ -327,12 +388,12 @@ pub fn remove_friend(user: UserRef, target: UserRef) -> Response {
                 if col
                     .update_one(
                         doc! {
-                            "_id": target.id
+                            "_id": target.id.clone()
                         },
                         doc! {
                             "$pull": {
                                 "relations": {
-                                    "id": user.id
+                                    "id": user.id.clone()
                                 }
                             }
                         },
@@ -340,7 +401,27 @@ pub fn remove_friend(user: UserRef, target: UserRef) -> Response {
                     )
                     .is_ok()
                 {
-                    Response::Success(json!({ "status": Relationship::NONE as u8 }))
+                    notifications::send_message_threaded(
+                        vec![user.id.clone()],
+                        None,
+                        Notification::user_friend_status(FriendStatus {
+                            id: user.id.clone(),
+                            user: target.id.clone(),
+                            status: Relationship::NONE as i32,
+                        }),
+                    );
+
+                    notifications::send_message_threaded(
+                        vec![target.id.clone()],
+                        None,
+                        Notification::user_friend_status(FriendStatus {
+                            id: target.id.clone(),
+                            user: user.id.clone(),
+                            status: Relationship::NONE as i32,
+                        }),
+                    );
+
+                    Response::Success(json!({ "status": Relationship::NONE as i32 }))
                 } else {
                     Response::InternalServerError(
                         json!({ "error": "Failed to commit! Target remains in same state." }),
@@ -361,7 +442,7 @@ pub fn remove_friend(user: UserRef, target: UserRef) -> Response {
 
 /// block a user
 #[put("/<target>/block")]
-pub fn block_user(user: UserRef, target: UserRef) -> Response {
+pub fn block_user(user: User, target: User) -> Response {
     let col = database::get_collection("users");
 
     match get_relationship(&user, &target) {
@@ -384,8 +465,8 @@ pub fn block_user(user: UserRef, target: UserRef) -> Response {
                 if col
                     .update_one(
                         doc! {
-                            "_id": target.id,
-                            "relations.id": user.id
+                            "_id": target.id.clone(),
+                            "relations.id": user.id.clone()
                         },
                         doc! {
                             "$set": {
@@ -396,7 +477,95 @@ pub fn block_user(user: UserRef, target: UserRef) -> Response {
                     )
                     .is_ok()
                 {
-                    Response::Success(json!({ "status": Relationship::Blocked as u8 }))
+                    notifications::send_message_threaded(
+                        vec![user.id.clone()],
+                        None,
+                        Notification::user_friend_status(FriendStatus {
+                            id: user.id.clone(),
+                            user: target.id.clone(),
+                            status: Relationship::Blocked as i32,
+                        }),
+                    );
+
+                    notifications::send_message_threaded(
+                        vec![target.id.clone()],
+                        None,
+                        Notification::user_friend_status(FriendStatus {
+                            id: target.id.clone(),
+                            user: user.id.clone(),
+                            status: Relationship::BlockedOther as i32,
+                        }),
+                    );
+
+                    Response::Success(json!({ "status": Relationship::Blocked as i32 }))
+                } else {
+                    Response::InternalServerError(
+                        json!({ "error": "Failed to commit! Try blocking the user again, remove it first." }),
+                    )
+                }
+            } else {
+                Response::InternalServerError(
+                    json!({ "error": "Failed to commit to database, try again." }),
+                )
+            }
+        }
+
+        Relationship::NONE => {
+            if col
+                .update_one(
+                    doc! {
+                        "_id": user.id.clone(),
+                    },
+                    doc! {
+                        "$push": {
+                            "relations": {
+                                "id": target.id.clone(),
+                                "status": Relationship::Blocked as i32,
+                            }
+                        }
+                    },
+                    None,
+                )
+                .is_ok()
+            {
+                if col
+                    .update_one(
+                        doc! {
+                            "_id": target.id.clone(),
+                        },
+                        doc! {
+                            "$push": {
+                                "relations": {
+                                    "id": user.id.clone(),
+                                    "status": Relationship::BlockedOther as i32,
+                                }
+                            }
+                        },
+                        None,
+                    )
+                    .is_ok()
+                {
+                    notifications::send_message_threaded(
+                        vec![user.id.clone()],
+                        None,
+                        Notification::user_friend_status(FriendStatus {
+                            id: user.id.clone(),
+                            user: target.id.clone(),
+                            status: Relationship::Blocked as i32,
+                        }),
+                    );
+
+                    notifications::send_message_threaded(
+                        vec![target.id.clone()],
+                        None,
+                        Notification::user_friend_status(FriendStatus {
+                            id: target.id.clone(),
+                            user: user.id.clone(),
+                            status: Relationship::BlockedOther as i32,
+                        }),
+                    );
+
+                    Response::Success(json!({ "status": Relationship::Blocked as i32 }))
                 } else {
                     Response::InternalServerError(
                         json!({ "error": "Failed to commit! Try blocking the user again, remove it first." }),
@@ -427,22 +596,30 @@ pub fn block_user(user: UserRef, target: UserRef) -> Response {
                 )
                 .is_ok()
             {
-                Response::Success(json!({ "status": Relationship::Blocked as u8 }))
+                notifications::send_message_threaded(
+                    vec![user.id.clone()],
+                    None,
+                    Notification::user_friend_status(FriendStatus {
+                        id: user.id.clone(),
+                        user: target.id.clone(),
+                        status: Relationship::Blocked as i32,
+                    }),
+                );
+
+                Response::Success(json!({ "status": Relationship::Blocked as i32 }))
             } else {
                 Response::InternalServerError(
                     json!({ "error": "Failed to commit to database, try again." }),
                 )
             }
         }
-        Relationship::SELF | Relationship::NONE => {
-            Response::BadRequest(json!({ "error": "This has no effect." }))
-        }
+        Relationship::SELF => Response::BadRequest(json!({ "error": "This has no effect." })),
     }
 }
 
 /// unblock a user
 #[delete("/<target>/block")]
-pub fn unblock_user(user: UserRef, target: UserRef) -> Response {
+pub fn unblock_user(user: User, target: User) -> Response {
     let col = database::get_collection("users");
 
     match get_relationship(&user, &target) {
@@ -463,7 +640,17 @@ pub fn unblock_user(user: UserRef, target: UserRef) -> Response {
                     )
                     .is_ok()
                 {
-                    Response::Success(json!({ "status": Relationship::BlockedOther as u8 }))
+                    notifications::send_message_threaded(
+                        vec![user.id.clone()],
+                        None,
+                        Notification::user_friend_status(FriendStatus {
+                            id: user.id.clone(),
+                            user: target.id.clone(),
+                            status: Relationship::BlockedOther as i32,
+                        }),
+                    );
+
+                    Response::Success(json!({ "status": Relationship::BlockedOther as i32 }))
                 } else {
                     Response::InternalServerError(
                         json!({ "error": "Failed to commit to database, try again." }),
@@ -490,12 +677,12 @@ pub fn unblock_user(user: UserRef, target: UserRef) -> Response {
                     if col
                         .update_one(
                             doc! {
-                                "_id": target.id
+                                "_id": target.id.clone()
                             },
                             doc! {
                                 "$pull": {
                                     "relations": {
-                                        "id": user.id
+                                        "id": user.id.clone()
                                     }
                                 }
                             },
@@ -503,7 +690,27 @@ pub fn unblock_user(user: UserRef, target: UserRef) -> Response {
                         )
                         .is_ok()
                     {
-                        Response::Success(json!({ "status": Relationship::NONE as u8 }))
+                        notifications::send_message_threaded(
+                            vec![user.id.clone()],
+                            None,
+                            Notification::user_friend_status(FriendStatus {
+                                id: user.id.clone(),
+                                user: target.id.clone(),
+                                status: Relationship::NONE as i32,
+                            }),
+                        );
+
+                        notifications::send_message_threaded(
+                            vec![target.id.clone()],
+                            None,
+                            Notification::user_friend_status(FriendStatus {
+                                id: target.id.clone(),
+                                user: user.id.clone(),
+                                status: Relationship::NONE as i32,
+                            }),
+                        );
+
+                        Response::Success(json!({ "status": Relationship::NONE as i32 }))
                     } else {
                         Response::InternalServerError(
                             json!({ "error": "Failed to commit! Target remains in same state." }),
@@ -527,3 +734,28 @@ pub fn unblock_user(user: UserRef, target: UserRef) -> Response {
         | Relationship::NONE => Response::BadRequest(json!({ "error": "This has no effect." })),
     }
 }
+
+#[options("/<_target>")]
+pub fn user_preflight(_target: String) -> Response {
+    Response::Result(super::Status::Ok)
+}
+#[options("/query")]
+pub fn query_preflight() -> Response {
+    Response::Result(super::Status::Ok)
+}
+#[options("/@me/dms")]
+pub fn dms_preflight() -> Response {
+    Response::Result(super::Status::Ok)
+}
+#[options("/<_target>/dm")]
+pub fn dm_preflight(_target: String) -> Response {
+    Response::Result(super::Status::Ok)
+}
+#[options("/<_target>/friend")]
+pub fn friend_preflight(_target: String) -> Response {
+    Response::Result(super::Status::Ok)
+}
+#[options("/<_target>/block")]
+pub fn block_user_preflight(_target: String) -> Response {
+    Response::Result(super::Status::Ok)
+}

src/util/captcha.rs

@@ -0,0 +1,43 @@
+use crate::util::variables::{HCAPTCHA_KEY, USE_HCAPTCHA};
+
+use reqwest::blocking::Client;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+#[derive(Serialize, Deserialize)]
+struct CaptchaResponse {
+    success: bool,
+}
+
+pub fn verify(user_token: &Option<String>) -> Result<(), String> {
+    if *USE_HCAPTCHA {
+        if let Some(token) = user_token {
+            let mut map = HashMap::new();
+            map.insert("secret", HCAPTCHA_KEY.to_string());
+            map.insert("response", token.to_string());
+
+            let client = Client::new();
+            if let Ok(response) = client
+                .post("https://hcaptcha.com/siteverify")
+                .form(&map)
+                .send()
+            {
+                let result: CaptchaResponse = response
+                    .json()
+                    .map_err(|_| "Failed to deserialise captcha result.".to_string())?;
+
+                if result.success {
+                    Ok(())
+                } else {
+                    Err("Unsuccessful captcha verification".to_string())
+                }
+            } else {
+                Err("Failed to verify with hCaptcha".to_string())
+            }
+        } else {
+            Err("Missing hCaptcha token!".to_string())
+        }
+    } else {
+        Ok(())
+    }
+}

src/util/email.rs

@@ -0,0 +1,96 @@
+use lettre::message::{header, MultiPart, SinglePart};
+use lettre::transport::smtp::authentication::Credentials;
+use lettre::{Message, SmtpTransport, Transport};
+
+use super::variables::{PUBLIC_URL, SMTP_FROM, SMTP_HOST, SMTP_PASSWORD, SMTP_USERNAME};
+
+lazy_static! {
+    static ref MAILER: lettre::transport::smtp::SmtpTransport =
+        SmtpTransport::relay(SMTP_HOST.as_ref())
+            .unwrap()
+            .credentials(Credentials::new(
+                SMTP_USERNAME.to_string(),
+                SMTP_PASSWORD.to_string()
+            ))
+            .build();
+}
+
+fn send(message: Message) -> Result<(), String> {
+    MAILER
+        .send(&message)
+        .map_err(|err| format!("Failed to send email! {}", err.to_string()))?;
+
+    Ok(())
+}
+
+fn generate_multipart(text: &str, html: &str) -> MultiPart {
+    MultiPart::mixed().multipart(
+        MultiPart::alternative()
+            .singlepart(
+                SinglePart::quoted_printable()
+                    .header(header::ContentType(
+                        "text/plain; charset=utf8".parse().unwrap(),
+                    ))
+                    .body(text),
+            )
+            .multipart(
+                MultiPart::related().singlepart(
+                    SinglePart::eight_bit()
+                        .header(header::ContentType(
+                            "text/html; charset=utf8".parse().unwrap(),
+                        ))
+                        .body(html),
+                ),
+            ),
+    )
+}
+
+pub fn send_verification_email(email: String, code: String) -> Result<(), String> {
+    let url = format!("{}/api/account/verify/{}", PUBLIC_URL.to_string(), code);
+    let email = Message::builder()
+        .from(SMTP_FROM.to_string().parse().unwrap())
+        .to(email.parse().unwrap())
+        .subject("Verify your email!")
+        .multipart(generate_multipart(
+            &format!("Verify your email here: {}", url),
+            &format!("<a href=\"{}\">Click to verify your email!</a>", url),
+        ))
+        .unwrap();
+
+    send(email)
+}
+
+pub fn send_password_reset(email: String, code: String) -> Result<(), String> {
+    let url = format!("{}/api/account/reset/{}", PUBLIC_URL.to_string(), code);
+    let email = Message::builder()
+        .from(SMTP_FROM.to_string().parse().unwrap())
+        .to(email.parse().unwrap())
+        .subject("Reset your password.")
+        .multipart(generate_multipart(
+            &format!("Reset your password here: {}", url),
+            &format!("<a href=\"{}\">Click to reset your password!</a>", url),
+        ))
+        .unwrap();
+
+    send(email)
+}
+
+pub fn send_welcome_email(email: String, username: String) -> Result<(), String> {
+    let email = Message::builder()
+        .from(SMTP_FROM.to_string().parse().unwrap())
+        .to(email.parse().unwrap())
+        .subject("Welcome to REVOLT!")
+        .multipart(
+        generate_multipart(
+            &format!("Welcome, {}! You can now use REVOLT.", username),
+            &format!(
+                    "<b>Welcome, {}!</b><br/>You can now use REVOLT.<br/><a href=\"{}\">Go to REVOLT</a>",
+                    username,
+                    PUBLIC_URL.to_string()
+                )
+            )
+        )
+        .unwrap();
+
+    send(email)
+}

src/util/mod.rs

@@ -2,6 +2,10 @@ use hashbrown::HashSet;
 use rand::{distributions::Alphanumeric, Rng};
 use std::iter::FromIterator;
 
+pub mod captcha;
+pub mod email;
+pub mod variables;
+
 pub fn vec_to_set<T: Clone + Eq + std::hash::Hash>(data: &[T]) -> HashSet<T> {
     HashSet::from_iter(data.iter().cloned())
 }

src/util/variables.rs

@@ -0,0 +1,66 @@
+use std::env;
+
+#[cfg(debug_assertions)]
+use log::warn;
+
+lazy_static! {
+    // Application Settings
+    pub static ref MONGO_URI: String =
+        env::var("REVOLT_MONGO_URI").expect("Missing REVOLT_MONGO_URI environment variable.");
+    pub static ref PUBLIC_URL: String =
+        env::var("REVOLT_PUBLIC_URL").expect("Missing REVOLT_PUBLIC_URL environment variable.");
+    pub static ref HCAPTCHA_KEY: String =
+        env::var("REVOLT_HCAPTCHA_KEY").unwrap_or_else(|_| "".to_string());
+    pub static ref WS_HOST: String =
+        env::var("REVOLT_WS_HOST").unwrap_or_else(|_| "0.0.0.0:9999".to_string());
+    
+    // Application Flags
+    pub static ref DISABLE_REGISTRATION: bool = env::var("REVOLT_DISABLE_REGISTRATION").map_or(false, |v| v == "*1");
+    pub static ref USE_EMAIL: bool = env::var("REVOLT_USE_EMAIL_VERIFICATION").map_or(
+        env::var("REVOLT_SMTP_HOST").is_ok()
+            && env::var("REVOLT_SMTP_USERNAME").is_ok()
+            && env::var("REVOLT_SMTP_PASSWORD").is_ok()
+            && env::var("REVOLT_SMTP_FROM").is_ok(),
+        |v| v == *"1"
+    );
+    pub static ref USE_HCAPTCHA: bool = env::var("REVOLT_HCAPTCHA_KEY").is_ok();
+
+    // SMTP Settings
+    pub static ref SMTP_HOST: String =
+        env::var("REVOLT_SMTP_HOST").unwrap_or_else(|_| "".to_string());
+    pub static ref SMTP_USERNAME: String =
+        env::var("SMTP_USERNAME").unwrap_or_else(|_| "".to_string());
+    pub static ref SMTP_PASSWORD: String =
+        env::var("SMTP_PASSWORD").unwrap_or_else(|_| "".to_string());
+    pub static ref SMTP_FROM: String = env::var("SMTP_FROM").unwrap_or_else(|_| "".to_string());
+}
+
+pub fn preflight_checks() {
+    if *USE_EMAIL == false {
+        #[cfg(not(debug_assertions))]
+        {
+            if !env::var("REVOLT_UNSAFE_NO_EMAIL")
+                .map_or(false, |v| v == *"1") {
+                panic!(
+                    "Not letting you run this in production, set REVOLT_UNSAFE_NO_EMAIL=1 to run."
+                );
+            }
+        }
+
+        #[cfg(debug_assertions)]
+        warn!("No SMTP settings specified! Remember to configure email.");
+    }
+
+    if *USE_HCAPTCHA == false {
+        #[cfg(not(debug_assertions))]
+        {
+            if !env::var("REVOLT_UNSAFE_NO_CAPTCHA")
+                .map_or(false, |v| v == *"1") {
+                panic!("Not letting you run this in production, set REVOLT_UNSAFE_NO_CAPTCHA=1 to run.");
+            }
+        }
+
+        #[cfg(debug_assertions)]
+        warn!("No Captcha key specified! Remember to add hCaptcha key.");
+    }
+}

src/websocket/mod.rs

@@ -1,193 +0,0 @@
-extern crate ws;
-
-use crate::database;
-
-use hashbrown::HashMap;
-use std::sync::RwLock;
-use ulid::Ulid;
-
-use bson::doc;
-use serde_json::{from_str, json, Value};
-
-use ws::{listen, CloseCode, Error, Handler, Handshake, Message, Result, Sender};
-
-struct Cell {
-    id: String,
-    out: Sender,
-}
-
-use once_cell::sync::OnceCell;
-static mut CLIENTS: OnceCell<RwLock<HashMap<String, Vec<Cell>>>> = OnceCell::new();
-
-struct Server {
-    out: Sender,
-    id: Option<String>,
-    internal: String,
-}
-
-impl Handler for Server {
-    fn on_open(&mut self, _: Handshake) -> Result<()> {
-        Ok(())
-    }
-
-    fn on_message(&mut self, msg: Message) -> Result<()> {
-        if let Message::Text(text) = msg {
-            let data: Value = from_str(&text).unwrap();
-
-            if let Value::String(packet_type) = &data["type"] {
-                match packet_type.as_str() {
-                    "authenticate" => {
-                        if self.id.is_some() {
-                            self.out.send(
-                                json!({
-                                    "type": "authenticate",
-                                    "success": false,
-                                    "error": "Already authenticated!"
-                                })
-                                .to_string(),
-                            )
-                        } else if let Value::String(token) = &data["token"] {
-                            let col = database::get_collection("users");
-
-                            match col.find_one(doc! { "access_token": token }, None).unwrap() {
-                                Some(u) => {
-                                    let id = u.get_str("_id").expect("Missing id.");
-
-                                    unsafe {
-                                        let mut map = CLIENTS.get_mut().unwrap().write().unwrap();
-                                        let cell = Cell {
-                                            id: self.internal.clone(),
-                                            out: self.out.clone(),
-                                        };
-                                        if map.contains_key(&id.to_string()) {
-                                            map.get_mut(&id.to_string()).unwrap().push(cell);
-                                        } else {
-                                            map.insert(id.to_string(), vec![cell]);
-                                        }
-                                    }
-
-                                    println!(
-                                        "Websocket client connected. [ID: {} // {}]",
-                                        id.to_string(),
-                                        self.internal
-                                    );
-
-                                    self.id = Some(id.to_string());
-                                    self.out.send(
-                                        json!({
-                                            "type": "authenticate",
-                                            "success": true
-                                        })
-                                        .to_string(),
-                                    )
-                                }
-                                None => self.out.send(
-                                    json!({
-                                        "type": "authenticate",
-                                        "success": false,
-                                        "error": "Invalid authentication token."
-                                    })
-                                    .to_string(),
-                                ),
-                            }
-                        } else {
-                            self.out.send(
-                                json!({
-                                    "type": "authenticate",
-                                    "success": false,
-                                    "error": "Missing authentication token."
-                                })
-                                .to_string(),
-                            )
-                        }
-                    }
-                    _ => Ok(()),
-                }
-            } else {
-                Ok(())
-            }
-        } else {
-            Ok(())
-        }
-    }
-
-    fn on_close(&mut self, code: CloseCode, reason: &str) {
-        match code {
-            CloseCode::Normal => println!("The client is done with the connection."),
-            CloseCode::Away => println!("The client is leaving the site."),
-            CloseCode::Abnormal => {
-                println!("Closing handshake failed! Unable to obtain closing status from client.")
-            }
-            _ => println!("The client encountered an error: {}", reason),
-        }
-
-        if let Some(id) = &self.id {
-            println!(
-                "Websocket client disconnected. [ID: {} // {}]",
-                id, self.internal
-            );
-            unsafe {
-                let mut map = CLIENTS.get_mut().unwrap().write().unwrap();
-                let arr = map.get_mut(&id.clone()).unwrap();
-
-                if arr.len() == 1 {
-                    map.remove(&id.clone());
-                } else {
-                    let index = arr.iter().position(|x| x.id == self.internal).unwrap();
-                    arr.remove(index);
-                    println!(
-                        "User [{}] is still connected {} times",
-                        self.id.as_ref().unwrap(),
-                        arr.len()
-                    );
-                }
-            }
-        }
-    }
-
-    fn on_error(&mut self, err: Error) {
-        println!("The server encountered an error: {:?}", err);
-    }
-}
-
-pub fn launch_server() {
-    unsafe {
-        if CLIENTS.set(RwLock::new(HashMap::new())).is_err() {
-            panic!("Failed to set CLIENTS map!");
-        }
-    }
-
-    listen("192.168.0.10:9999", |out| Server {
-        out: out,
-        id: None,
-        internal: Ulid::new().to_string(),
-    })
-    .unwrap()
-}
-
-pub fn send_message(id: String, message: String) -> std::result::Result<(), ()> {
-    unsafe {
-        let map = CLIENTS.get().unwrap().read().unwrap();
-        if map.contains_key(&id) {
-            let arr = map.get(&id).unwrap();
-
-            for item in arr {
-                if item.out.send(message.clone()).is_err() {
-                    return Err(());
-                }
-            }
-        }
-
-        Ok(())
-    }
-}
-
-// ! TODO: WRITE THREADED QUEUE SYSTEM
-// ! FETCH RECIPIENTS HERE INSTEAD OF IN METHOD
-
-pub fn queue_message(ids: Vec<String>, message: String) {
-    for id in ids {
-        send_message(id, message.clone())
-            .expect("uhhhhhhhhhh can i get uhhhhhhhhhhhhhhhhhh mcdonald cheese burger with fries");
-    }
-}