fix: add validator dependency to database

closes #283

fix: allow setting port and use_tls from config
closes #143

.config/nextest.toml

@@ -0,0 +1,2 @@
+[profile.default]
+slow-timeout = { period = "3s", terminate-after = 2 }

.env.example

@@ -1,5 +1,7 @@
 # MongoDB URI
 MONGODB=mongodb://localhost
+AUTUMN_MONGO_URI=mongodb://database
+REDIS_URI=redis://localhost/
 
 # URL to where the Revolt app is publicly accessible
 REVOLT_APP_URL=http://local.revolt.chat:5000
@@ -80,3 +82,26 @@ REVOLT_VAPID_PUBLIC_KEY=BGcvgR-i2z4IQ5Mw841vJvkLjt8wY-FjmWrw83jOLCY52qcGZS0OF7nf
 ##
 
 # VOSO_MANAGE_TOKEN=CHANGEME
+
+
+##
+## Autumn configuration
+##
+
+# S3 Region
+AUTUMN_S3_REGION=minio
+
+# S3 Endpoint
+AUTUMN_S3_ENDPOINT=http://minio:9000
+
+# MinIO Root User
+MINIO_ROOT_USER=minioautumn
+
+# MinIO Root Password
+MINIO_ROOT_PASSWORD=minioautumn
+
+# AWS Access Key ID
+AWS_ACCESS_KEY_ID=minioautumn
+
+# AWS Secret Key
+AWS_SECRET_ACCESS_KEY=minioautumn

.github/workflows/docker.yaml

@@ -3,7 +3,7 @@ name: Docker Test & Publish
 on:
   push:
     branches:
-      - "master"
+      - "main"
     tags:
       - "*"
     paths-ignore:
@@ -15,7 +15,7 @@ on:
       - "README"
   pull_request:
     branches:
-      - "master"
+      - "main"
     paths:
       - "Dockerfile"
   workflow_dispatch:

.github/workflows/rust.yaml

@@ -3,7 +3,7 @@ name: Rust build, test, and generate specification
 on:
   push:
   pull_request:
-    branches: [master]
+    branches: [main]
 
 env:
   CARGO_TERM_COLOR: always
@@ -20,6 +20,11 @@ jobs:
           toolchain: stable
           override: true
           components: rustfmt, clippy
+      - name: Install cargo-nextest
+        uses: baptiste0928/cargo-install@v1
+        with:
+          crate: cargo-nextest
+          locked: true
 
       - name: Run cargo build
         uses: actions-rs/cargo@v1
@@ -30,36 +35,38 @@ jobs:
         run: |
           docker-compose -f docker-compose.db.yml up -d
 
-      - name: Run cargo test
-        uses: actions-rs/cargo@v1
-        with:
-          command: test
-
-      - name: Run cargo test (with MongoDB)
-        uses: actions-rs/cargo@v1
-        env:
-          MONGODB: mongodb://localhost
-        with:
-          command: test
-
       - name: Copy .env.example
-        if: github.event_name != 'pull_request' && github.ref_name == 'master'
         run: |
           cp .env.example .env
 
-      - name: Start API in background
-        if: github.event_name != 'pull_request' && github.ref_name == 'master'
+      - name: Run cargo test
+        env:
+          TEST_DB: REFERENCE
         run: |
-          cargo run --bin revolt-delta &
+          cargo nextest run
+
+      - name: Run cargo test (with MongoDB)
+        env:
+          TEST_DB: MONGODB
+          MONGODB: mongodb://localhost
+        run: |
+          cargo nextest run
+
+      - name: Start API in background
+        if: github.event_name != 'pull_request' && github.ref_name == 'main'
+        env:
+          TEST_DB: REFERENCE
+        run: |
+          cargo build --bin revolt-delta && (cargo run --bin revolt-delta &)
 
       - name: Wait for API to go up
-        if: github.event_name != 'pull_request' && github.ref_name == 'master'
+        if: github.event_name != 'pull_request' && github.ref_name == 'main'
         uses: nev7n/wait_for_response@v1
         with:
           url: "http://localhost:8000/"
 
       - name: Checkout API repository
-        if: github.event_name != 'pull_request' && github.ref_name == 'master'
+        if: github.event_name != 'pull_request' && github.ref_name == 'main'
         uses: actions/checkout@v3
         with:
           repository: revoltchat/api
@@ -67,11 +74,11 @@ jobs:
           token: ${{ secrets.PAT }}
 
       - name: Download OpenAPI specification
-        if: github.event_name != 'pull_request' && github.ref_name == 'master'
+        if: github.event_name != 'pull_request' && github.ref_name == 'main'
         run: curl http://localhost:8000/openapi.json -o api/OpenAPI.json
 
       - name: Commit changes
-        if: github.event_name != 'pull_request' && github.ref_name == 'master'
+        if: github.event_name != 'pull_request' && github.ref_name == 'main'
         uses: EndBug/add-and-commit@v4
         with:
           cwd: "api"

.github/workflows/triage_pr.yml

@@ -15,7 +15,7 @@ jobs:
           gh api graphql -f query='
             query {
               organization(login: "revoltchat"){
-                projectV2(number: 3) {
+                projectV2(number: 5) {
                   id
                   fields(first:20) {
                     nodes {
@@ -35,7 +35,7 @@ jobs:
 
           echo 'PROJECT_ID='$(jq '.data.organization.projectV2.id' project_data.json) >> $GITHUB_ENV
           echo 'STATUS_FIELD_ID='$(jq '.data.organization.projectV2.fields.nodes[] | select(.name== "Status") | .id' project_data.json) >> $GITHUB_ENV
-          echo 'INCOMING_OPTION_ID='$(jq '.data.organization.projectV2.fields.nodes[] | select(.name== "Status") | .options[] | select(.name=="Incoming PRs") |.id' project_data.json) >> $GITHUB_ENV
+          echo 'INCOMING_OPTION_ID='$(jq '.data.organization.projectV2.fields.nodes[] | select(.name== "Status") | .options[] | select(.name=="🆕 Untriaged") |.id' project_data.json) >> $GITHUB_ENV
 
       - name: Add PR to project
         env:

.gitignore

@@ -1,6 +1,9 @@
 Rocket.toml
+Revolt.toml
+
 target
 .data
 .env
 
 .vercel
+.DS_Store

.vscode/settings.json

@@ -1,4 +1,6 @@
 {
-    "editor.formatOnSave": true,
-    "rust-analyzer.checkOnSave.command": "clippy"
-}
+  "editor.formatOnSave": true,
+  "rust-analyzer.checkOnSave.command": "clippy",
+  "nixEnvSelector.suggestion": false,
+  "nixEnvSelector.nixFile": "${workspaceRoot}/default.nix"
+}

Cargo.toml

@@ -1,6 +1,10 @@
 [workspace]
+resolver = "2"
 members = ["crates/delta", "crates/bonfire", "crates/quark", "crates/core/*"]
 
 [patch.crates-io]
 # mobc-redis = { git = "https://github.com/insertish/mobc", rev = "8b880bb59f2ba80b4c7bc40c649c113d8857a186" }
-redis = { git = "https://github.com/insertish/redis-rs", rev = "1a41faf356fd21aebba71cea7eb7eb2653e5f0ef" }
+redis22 = { package = "redis", version = "0.22.3", git = "https://github.com/revoltchat/redis-rs", rev = "1a41faf356fd21aebba71cea7eb7eb2653e5f0ef" }
+redis23 = { package = "redis", version = "0.23.1", git = "https://github.com/revoltchat/redis-rs", rev = "f8ca28ab85da59d2ccde526b4d2fb390eff5a5f9" }
+# authifier = { package = "authifier", version = "1.0.8", path = "../authifier/crates/authifier" }
+# rocket_authifier = { package = "rocket_authifier", version = "1.0.8", path = "../authifier/crates/rocket_authifier" }

Dockerfile

@@ -20,6 +20,7 @@ COPY Cargo.toml Cargo.lock ./
 COPY crates/bonfire/Cargo.toml ./crates/bonfire/
 COPY crates/delta/Cargo.toml ./crates/delta/
 COPY crates/quark/Cargo.toml ./crates/quark/
+COPY crates/core/config/Cargo.toml ./crates/core/config/
 COPY crates/core/database/Cargo.toml ./crates/core/database/
 COPY crates/core/models/Cargo.toml ./crates/core/models/
 COPY crates/core/permissions/Cargo.toml ./crates/core/permissions/

Dockerfile.useCurrentArch

@@ -0,0 +1,29 @@
+# Build Stage
+FROM rust:1.70.0-slim
+USER 0:0
+WORKDIR /home/rust/src
+
+# Install build requirements
+RUN apt-get update && \
+    apt-get install -y \
+    make \
+    pkg-config \
+    libssl-dev
+COPY scripts/build-image-layer.sh /tmp/
+
+# Build all dependencies
+COPY Cargo.toml Cargo.lock ./
+COPY crates/bonfire/Cargo.toml ./crates/bonfire/
+COPY crates/delta/Cargo.toml ./crates/delta/
+COPY crates/quark/Cargo.toml ./crates/quark/
+COPY crates/core/config/Cargo.toml ./crates/core/config/
+COPY crates/core/database/Cargo.toml ./crates/core/database/
+COPY crates/core/models/Cargo.toml ./crates/core/models/
+COPY crates/core/permissions/Cargo.toml ./crates/core/permissions/
+COPY crates/core/presence/Cargo.toml ./crates/core/presence/
+COPY crates/core/result/Cargo.toml ./crates/core/result/
+RUN sh /tmp/build-image-layer.sh deps
+
+# Build all apps
+COPY crates ./crates
+RUN sh /tmp/build-image-layer.sh apps

README.md

@@ -2,30 +2,112 @@
 
 This is a monorepo for the Revolt backend.
 
-| Crate            | Path                                           | Description                          |
-| ---------------- | ---------------------------------------------- | ------------------------------------ |
-| `delta`          | [crates/delta](crates/delta)                   | REST API server                      |
-| `bonfire`        | [crates/bonfire](crates/bonfire)               | WebSocket events server              |
-| `quark`          | [crates/quark](crates/quark)                   | Models and logic                     |
-<!--| `revcord/api`    | [crates/revcord/api](crates/revcord/api)       | Discord REST translation layer       |
-| `revcord/ws`     | [crates/revcord/ws](crates/revcord/ws)         | Discord gateway translation layer    |
-| `revcord/models` | [crates/revcord/models](crates/revcord/models) | Discord models and quark translation |-->
+| Crate              | Path                                               | Description                       |
+| ------------------ | -------------------------------------------------- | --------------------------------- |
+| `core/config`      | [crates/core/config](crates/core/config)           | Core: Configuration               |
+| `core/database`    | [crates/core/database](crates/core/database)       | Core: Database Implementation     |
+| `core/models`      | [crates/core/models](crates/core/models)           | Core: API Models                  |
+| `core/permissions` | [crates/core/permissions](crates/core/permissions) | Core: Permission Logic            |
+| `core/presence`    | [crates/core/presence](crates/core/presence)       | Core: User Presence               |
+| `core/result`      | [crates/core/result](crates/core/result)           | Core: Result and Error types      |
+| `delta`            | [crates/delta](crates/delta)                       | REST API server                   |
+| `bonfire`          | [crates/bonfire](crates/bonfire)                   | WebSocket events server           |
+| `quark`            | [crates/quark](crates/quark)                       | Models and logic (**DEPRECATED**) |
 
 Note: `january`, `autumn`, and `vortex` are yet to be moved into this monorepo.
 
-## Resources
+## Minimum Supported Rust Version
 
-### Revolt
+Rust 1.70 or higher.
 
-- [Revolt Project Board](https://github.com/revoltchat/revolt/discussions) (Submit feature requests here)
-- [Revolt Testers Server](https://app.revolt.chat/invite/Testers)
-- [Contribution Guide](https://developers.revolt.chat/contributing)
+## Development Guide
 
-## Contributing
+Before getting started, you'll want to install:
 
-The contribution guide is located at [developers.revolt.chat/contributing](https://developers.revolt.chat/contributing).
-Please note that a pull request should only take care of one issue so that we can review it quickly.
+- Rust toolchain (rustup recommended)
+- Docker
+- Git
+- mold (optional, faster compilation)
+
+> A **default.nix** is available for Nix users!
+> Just run `nix-shell` and continue.
+
+Now you can clone and build the project:
+
+```bash
+git clone https://github.com/revoltchat/backend revolt-backend
+cd revolt-backend
+cargo build
+```
+
+If you want to run the API and event servers:
+
+```bash
+# create environment file (will be deprecated in future)
+cp .env.example .env
+
+# (optionally) copy the default configuration file
+cp crates/core/config/Revolt.toml Revolt.toml
+# configure as necessary...
+
+# start other necessary services
+docker compose up -d
+
+# run the API server
+cargo run --bin revolt-delta
+# run the events server
+cargo run --bin revolt-bonfire
+
+# hint:
+# mold -run <cargo build, cargo run, etc...>
+```
+
+You can start a web client by doing the following:
+
+```bash
+# if you do not have yarn yet and have a modern Node.js:
+corepack enable
+
+# clone the web client and run it:
+git clone --recursive https://github.com/revoltchat/revite
+cd revite
+yarn
+yarn build:deps
+yarn dev --port 3001
+```
+
+Then go to https://local.revolt.chat:3001
+
+## Deployment Guide
+
+### Cutting new crate releases
+
+Begin by bumping crate versions:
+
+```bash
+just patch # 0.0.X
+just minor # 0.X.0
+just major # X.0.0
+```
+
+Then commit the changes to package files.
+
+Proceed to publish all the new crates:
+
+```bash
+just publish
+```
+
+### Cutting new binary releases
+
+Tag and push a new release by running:
+
+```bash
+just release
+```
 
 ## License
 
-The Revolt backend is generally licensed under the [GNU Affero General Public License v3.0](https://github.com/revoltchat/backend/blob/master/LICENSE). Please check individual crates for further license information.
+The Revolt backend is generally licensed under the [GNU Affero General Public License v3.0](https://github.com/revoltchat/backend/blob/master/LICENSE).
+
+**Individual crates may supply their own licenses!**

STYLE_GUIDE.md

@@ -2,6 +2,10 @@
 
 Beyond using Cargo format and Clippy, there are some specific code style guidelines laid out in this document for different parts of the project.
 
+## Writing Style
+
+- Shorten "identifier" to "Id" with that exact casing, i.e. Server Id.
+
 ## `core/database` crate
 
 w.r.t. `model.rs` files
@@ -22,6 +26,7 @@ w.r.t. `model.rs` files
   );
   ```
 - `auto_derived!` macro accepts multiple entries and should be used as such:
+
   ```rust
   auto_derived!(
     /// Optional fields on server object
@@ -31,6 +36,7 @@ w.r.t. `model.rs` files
     pub enum FieldsRole { .. }
   );
   ```
+
 - If special serialisation conditions are required, such as checking if a boolean is false, use the existing definitions for these functions from the crate root:
   ```rust
   #[serde(skip_serializing_if = "crate::if_false", default)]

clippy.toml

@@ -1,15 +1,28 @@
 disallowed-methods = [
     # Shouldn't need to access these directly
     "revolt_database::models::bots::model::Bot::remove_field",
+    "revolt_database::models::messages::model::Message::attach_sendable_embed",
+    "revolt_database::models::users::model::User::set_relationship",
+    "revolt_database::models::users::model::User::apply_relationship",
 
     # Prefer to use Object::create()
-    "revolt_database::models::safety_strikes::ops::AbstractAccountStrikes::insert_account_strike",
+    "revolt_database::models::bots::ops::AbstractBots::insert_bot",
+    "revolt_database::models::channel_invites::ops::AbstractChannelInvites::insert_invite",
+    "revolt_database::models::channel_unreads::ops::AbstractChannelUnreads::acknowledge_message",
+    "revolt_database::models::channel_webhooks::ops::AbstractWebhooks::insert_webhook",
+    "revolt_database::models::channels::ops::AbstractChannels::insert_channel",
+    "revolt_database::models::emojis::ops::AbstractEmojis::insert_emoji",
+    "revolt_database::models::files::ops::AbstractAttachments::insert_attachment",
+    "revolt_database::models::messages::ops::AbstractMessages::insert_message",
+    "revolt_database::models::ratelimit_events::ops::AbstractRatelimitEvents::insert_ratelimit_event",
+    "revolt_database::models::server_bans::ops::AbstractServerBans::insert_ban",
+    "revolt_database::models::server_members::ops::AbstractServerMembers::insert_member",
+    "revolt_database::models::servers::ops::AbstractServers::insert_server",
+    "revolt_database::models::users::ops::AbstractUsers::insert_user",
 
     # Prefer to use Object::update(&self)
     "revolt_database::models::bots::ops::AbstractBots::update_bot",
-    "revolt_database::models::safety_strikes::ops::AbstractAccountStrikes::update_account_strike",
 
     # Prefer to use Object::delete(&self)
     "revolt_database::models::bots::ops::AbstractBots::delete_bot",
-    "revolt_database::models::safety_strikes::ops::AbstractAccountStrikes::delete_account_strike",
 ]

crates/bonfire/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-bonfire"
-version = "0.6.4"
+version = "0.7.0"
 license = "AGPL-3.0-or-later"
 edition = "2021"
 
@@ -18,6 +18,7 @@ querystring = "1.1.0"
 revolt-quark = { path = "../quark" }
 
 # serde
+bincode = "1.3.3"
 serde_json = "1.0.79"
 rmp-serde = "1.0.0"
 serde = "1.0.136"
@@ -25,7 +26,15 @@ serde = "1.0.136"
 # async
 futures = "0.3.21"
 async-tungstenite = { version = "0.17.0", features = ["async-std-runtime"] }
-async-std = { version = "1.8.0", features = ["tokio1", "tokio02", "attributes"] }
+async-std = { version = "1.8.0", features = [
+    "tokio1",
+    "tokio02",
+    "attributes",
+] }
 
 # core
-revolt-presence = { path = "../core/presence", features = [ "redis-is-patched" ] }
+revolt-presence = { path = "../core/presence", features = ["redis-is-patched"] }
+sentry = "0.31.5"
+
+# redis
+fred = { version = "8.0.1", features = ["subscriber-client"] }

crates/bonfire/src/main.rs

@@ -29,6 +29,10 @@ async fn main() {
 
     // Start accepting new connections and spawn a client for each connection.
     while let Ok((stream, addr)) = listener.accept().await {
-        websocket::spawn_client(database::get_db(), stream, addr);
+        async_std::task::spawn(async move {
+            info!("User connected from {addr:?}");
+            websocket::client(database::get_db(), stream, addr).await;
+            info!("User disconnected from {addr:?}");
+        });
     }
 }

crates/bonfire/src/websocket.rs

@@ -1,6 +1,16 @@
 use std::net::SocketAddr;
 
-use futures::{channel::oneshot, pin_mut, select, FutureExt, SinkExt, StreamExt, TryStreamExt};
+use async_tungstenite::WebSocketStream;
+use fred::{
+    interfaces::{ClientLike, EventInterface, PubsubInterface},
+    types::RedisConfig,
+};
+use futures::{
+    channel::oneshot,
+    pin_mut, select,
+    stream::{SplitSink, SplitStream},
+    FutureExt, SinkExt, StreamExt, TryStreamExt,
+};
 use revolt_presence::{create_session, delete_session};
 use revolt_quark::{
     events::{
@@ -9,244 +19,264 @@ use revolt_quark::{
         state::{State, SubscriptionStateChange},
     },
     models::{user::UserHint, User},
-    redis_kiss, Database,
+    redis_kiss::{PayloadType, REDIS_PAYLOAD_TYPE, REDIS_URI},
+    Database,
 };
 
-use async_std::{net::TcpStream, sync::Mutex, task};
+use async_std::{net::TcpStream, sync::Mutex};
 
-use crate::config::WebsocketHandshakeCallback;
+use crate::config::{ProtocolConfiguration, WebsocketHandshakeCallback};
 
-/// Spawn a new WebSocket client worker given access to the database,
+type WsReader = SplitStream<WebSocketStream<TcpStream>>;
+type WsWriter = SplitSink<WebSocketStream<TcpStream>, async_tungstenite::tungstenite::Message>;
+
+/// Start a new WebSocket client worker given access to the database,
 /// the relevant TCP stream and the remote address of the client.
-pub fn spawn_client(db: &'static Database, stream: TcpStream, addr: SocketAddr) {
-    // Spawn a new Async task to work on.
-    task::spawn(async move {
-        info!("User connected from {addr:?}");
+pub async fn client(db: &'static Database, stream: TcpStream, addr: SocketAddr) {
+    // Upgrade the TCP connection to a WebSocket connection.
+    // In this process, we also parse any additional parameters given.
+    // e.g. wss://example.com?format=json&version=1
+    let (sender, receiver) = oneshot::channel();
+    let Ok(ws) = async_tungstenite::accept_hdr_async_with_config(
+        stream,
+        WebsocketHandshakeCallback::from(sender),
+        None,
+    )
+    .await
+    else {
+        return;
+    };
+    // Verify we've received a valid config, otherwise we should just drop the connection.
+    let Ok(mut config) = receiver.await else {
+        return;
+    };
+    info!(
+        "User {addr:?} provided protocol configuration (version = {}, format = {:?})",
+        config.get_protocol_version(),
+        config.get_protocol_format()
+    );
 
-        // Upgrade the TCP connection to a WebSocket connection.
-        // In this process, we also parse any additional parameters given.
-        // e.g. wss://example.com?format=json&version=1
-        let (sender, receiver) = oneshot::channel();
-        if let Ok(ws) = async_tungstenite::accept_hdr_async_with_config(
-            stream,
-            WebsocketHandshakeCallback::from(sender),
-            None,
-        )
+    // Split the socket for simultaneously read and write.
+    let (mut write, mut read) = ws.split();
+
+    // If the user has not provided authentication, request information.
+    if config.get_session_token().is_none() {
+        while let Ok(message) = read.try_next().await {
+            if let Ok(ClientMessage::Authenticate { token }) =
+                config.decode(message.as_ref().unwrap())
+            {
+                config.set_session_token(token);
+                break;
+            }
+        }
+    }
+
+    // Try to authenticate the user.
+    let Some(token) = config.get_session_token().as_ref() else {
+        return;
+    };
+    let user = match User::from_token(db, token, UserHint::Any).await {
+        Ok(user) => user,
+        Err(err) => {
+            write.send(config.encode(&err)).await.ok();
+            return;
+        }
+    };
+    info!("User {addr:?} authenticated as @{}", user.username);
+
+    // Create local state.
+    let mut state = State::from(user);
+    let user_id = state.cache.user_id.clone();
+
+    // Notify socket we have authenticated.
+    if write
+        .send(config.encode(&EventV1::Authenticated))
         .await
-        {
-            // Verify we've received a valid config, otherwise we should just drop the connection.
-            if let Ok(mut config) = receiver.await {
-                info!(
-                    "User {addr:?} provided protocol configuration (version = {}, format = {:?})",
-                    config.get_protocol_version(),
-                    config.get_protocol_format()
-                );
+        .is_err()
+    {
+        return;
+    }
 
-                // Split the socket for simultaneously read and write.
-                let (write, mut read) = ws.split();
-                let write = Mutex::new(write);
+    // Download required data to local cache and send Ready payload.
+    let Ok(ready_payload) = state.generate_ready_payload(db).await else {
+        return;
+    };
+    if write.send(config.encode(&ready_payload)).await.is_err() {
+        return;
+    }
 
-                // If the user has not provided authentication, request information.
-                if config.get_session_token().is_none() {
-                    'outer: while let Ok(message) = read.try_next().await {
-                        if let Ok(ClientMessage::Authenticate { token }) =
-                            config.decode(message.as_ref().unwrap())
-                        {
-                            config.set_session_token(token);
-                            break 'outer;
-                        }
-                    }
+    // Create presence session.
+    let (first_session, session_id) = create_session(&user_id, 0).await;
+
+    // If this was the first session, notify other users that we just went online.
+    if first_session {
+        state.broadcast_presence_change(true).await;
+    }
+
+    {
+        let write = Mutex::new(write);
+        // Create a PubSub connection to poll on.
+        let listener = listener(db, &mut state, addr, &config, &write).fuse();
+        // Read from WebSocket stream.
+        let worker = worker(addr, user_id.clone(), &config, read, &write).fuse();
+
+        // Pin both tasks.
+        pin_mut!(listener, worker);
+
+        // Wait for either disconnect or for listener to die.
+        select!(
+            () = listener => {},
+            () = worker => {}
+        );
+    }
+    // Clean up presence session.
+    let last_session = delete_session(&user_id, session_id).await;
+
+    // If this was the last session, notify other users that we just went offline.
+    if last_session {
+        state.broadcast_presence_change(false).await;
+    }
+}
+
+async fn listener(
+    db: &'static Database,
+    state: &mut State,
+    addr: SocketAddr,
+    config: &ProtocolConfiguration,
+    write: &Mutex<WsWriter>,
+) {
+    let redis_config = RedisConfig::from_url(&REDIS_URI).unwrap();
+    let Ok(subscriber) = fred::types::Builder::from_config(redis_config).build_subscriber_client()
+    else {
+        return;
+    };
+    if subscriber.init().await.is_err() {
+        return;
+    };
+    let mut message_rx = subscriber.message_rx();
+    loop {
+        // Check for state changes for subscriptions.
+        match state.apply_state() {
+            SubscriptionStateChange::Reset => {
+                subscriber.unsubscribe_all().await.unwrap();
+                for id in state.iter_subscriptions() {
+                    subscriber.subscribe(id).await.unwrap();
                 }
 
-                // Try to authenticate the user.
-                if let Some(token) = config.get_session_token().as_ref() {
-                    match User::from_token(db, token, UserHint::Any).await {
-                        Ok(user) => {
-                            info!("User {addr:?} authenticated as @{}", user.username);
+                #[cfg(debug_assertions)]
+                info!("{addr:?} has reset their subscriptions");
+            }
+            SubscriptionStateChange::Change { add, remove } => {
+                for id in remove {
+                    #[cfg(debug_assertions)]
+                    info!("{addr:?} unsubscribing from {id}");
 
-                            // Create local state.
-                            let mut state = State::from(user);
-                            let user_id = state.cache.user_id.clone();
+                    subscriber.unsubscribe(id).await.unwrap();
+                }
 
-                            // Create presence session.
-                            let (first_session, session_id) = create_session(&user_id, 0).await;
+                for id in add {
+                    #[cfg(debug_assertions)]
+                    info!("{addr:?} subscribing to {id}");
 
-                            // Notify socket we have authenticated.
-                            write
-                                .lock()
-                                .await
-                                .send(config.encode(&EventV1::Authenticated))
-                                .await
-                                .ok();
-
-                            // Download required data to local cache and send Ready payload.
-                            if let Ok(ready_payload) = state.generate_ready_payload(db).await {
-                                write
-                                    .lock()
-                                    .await
-                                    .send(config.encode(&ready_payload))
-                                    .await
-                                    .ok();
-
-                                // If this was the first session, notify other users that we just went online.
-                                if first_session {
-                                    state.broadcast_presence_change(true).await;
-                                }
-
-                                // Create a PubSub connection to poll on.
-                                let listener = async {
-                                    if let Ok(mut conn) = redis_kiss::open_pubsub_connection().await
-                                    {
-                                        loop {
-                                            // Check for state changes for subscriptions.
-                                            match state.apply_state() {
-                                                SubscriptionStateChange::Reset => {
-                                                    for id in state.iter_subscriptions() {
-                                                        conn.subscribe(id).await.unwrap();
-                                                    }
-
-                                                    #[cfg(debug_assertions)]
-                                                    info!("{addr:?} has reset their subscriptions");
-                                                }
-                                                SubscriptionStateChange::Change { add, remove } => {
-                                                    for id in remove {
-                                                        #[cfg(debug_assertions)]
-                                                        info!("{addr:?} unsubscribing from {id}");
-
-                                                        conn.unsubscribe(id).await.unwrap();
-                                                    }
-
-                                                    for id in add {
-                                                        #[cfg(debug_assertions)]
-                                                        info!("{addr:?} subscribing to {id}");
-
-                                                        conn.subscribe(id).await.unwrap();
-                                                    }
-                                                }
-                                                SubscriptionStateChange::None => {}
-                                            }
-
-                                            // * Debug logging of current subscriptions.
-                                            /*#[cfg(debug_assertions)]
-                                            info!(
-                                                "User {addr:?} is subscribed to {:?}",
-                                                state
-                                                    .iter_subscriptions()
-                                                    .collect::<Vec<&String>>()
-                                            );*/
-
-                                            // Handle incoming events.
-                                            match conn.on_message().next().await.map(|item| {
-                                                (
-                                                    item.get_channel_name().to_string(),
-                                                    redis_kiss::decode_payload::<EventV1>(&item),
-                                                )
-                                            }) {
-                                                Some((channel, item)) => {
-                                                    if let Ok(mut event) = item {
-                                                        if state
-                                                            .handle_incoming_event_v1(
-                                                                db, &mut event,
-                                                            )
-                                                            .await
-                                                            && write.lock().await
-                                                                .send(config.encode(&event))
-                                                                .await
-                                                                .is_err()
-                                                        {
-                                                            break;
-                                                        }
-                                                    } else {
-                                                        warn!("Failed to deserialise an event for {channel}!");
-                                                    }
-                                                }
-                                                // No more data, assume we disconnected or otherwise
-                                                // something bad occurred, so disconnect user.
-                                                None => break,
-                                            }
-                                        }
-                                    }
-                                }
-                                .fuse();
-
-                                // Read from WebSocket stream.
-                                let worker =
-                                    async {
-                                        while let Ok(Some(msg)) = read.try_next().await {
-                                            if let Ok(payload) = config.decode(&msg) {
-                                                match payload {
-                                                    ClientMessage::BeginTyping { channel } => {
-                                                        EventV1::ChannelStartTyping {
-                                                            id: channel.clone(),
-                                                            user: user_id.clone(),
-                                                        }
-                                                        .p(channel.clone())
-                                                        .await;
-                                                    }
-                                                    ClientMessage::EndTyping { channel } => {
-                                                        EventV1::ChannelStopTyping {
-                                                            id: channel.clone(),
-                                                            user: user_id.clone(),
-                                                        }
-                                                        .p(channel.clone())
-                                                        .await;
-                                                    }
-                                                    ClientMessage::Ping { data, responded } => {
-                                                        if responded.is_none() {
-                                                            write
-                                                                .lock()
-                                                                .await
-                                                                .send(config.encode(
-                                                                    &EventV1::Pong { data },
-                                                                ))
-                                                                .await
-                                                                .ok();
-                                                        }
-                                                    }
-                                                    _ => {}
-                                                }
-                                            }
-                                        }
-                                    }
-                                    .fuse();
-
-                                // Pin both tasks.
-                                pin_mut!(listener, worker);
-
-                                // Wait for either disconnect or for listener to die.
-                                select!(
-                                    () = listener => {},
-                                    () = worker => {}
-                                );
-
-                                // * Combine the streams back once we are ready to disconnect.
-                                /* ws = read.reunite(write).unwrap(); */
-                            }
-
-                            // Clean up presence session.
-                            let last_session = delete_session(&user_id, session_id).await;
-
-                            // If this was the last session, notify other users that we just went offline.
-                            if last_session {
-                                state.broadcast_presence_change(false).await;
-                            }
-                        }
-                        Err(err) => {
-                            write.lock().await.send(config.encode(&err)).await.ok();
-                        }
-                    }
+                    subscriber.subscribe(id).await.unwrap();
                 }
             }
-
-            // * Disconnect the WebSocket if it isn't already.
-            /*ws.close(Some(CloseFrame {
-                code: CloseCode::Normal,
-                reason: std::borrow::Cow::from(""),
-            }))
-            .await
-            .unwrap();*/
+            SubscriptionStateChange::None => {}
         }
 
-        info!("User disconnected from {addr:?}");
-    });
+        // Handle incoming events.
+        let Ok(message) = message_rx.recv().await.map_err(|e| {
+            warn!("Error while consuming pub/sub messages: {e:?}");
+            sentry::capture_error(&e);
+        }) else {
+            return;
+        };
+        let event = match *REDIS_PAYLOAD_TYPE {
+            PayloadType::Json => message
+                .value
+                .as_str()
+                .and_then(|s| serde_json::from_str::<EventV1>(s.as_ref()).ok()),
+            PayloadType::Msgpack => message
+                .value
+                .as_bytes()
+                .and_then(|b| rmp_serde::from_slice::<EventV1>(b).ok()),
+            PayloadType::Bincode => message
+                .value
+                .as_bytes()
+                .and_then(|b| bincode::deserialize::<EventV1>(b).ok()),
+        };
+        let Some(mut event) = event else {
+            warn!("Failed to deserialise an event for {}!", message.channel);
+            return;
+        };
+        let should_send = state.handle_incoming_event_v1(db, &mut event).await;
+        if !should_send {
+            continue;
+        }
+
+        let result = write.lock().await.send(config.encode(&event)).await;
+        if let Err(e) = result {
+            use async_tungstenite::tungstenite::Error;
+            if !matches!(e, Error::AlreadyClosed | Error::ConnectionClosed) {
+                warn!("Error while sending an event to {addr:?}: {e:?}");
+            }
+            return;
+        }
+    }
+}
+
+async fn worker(
+    addr: SocketAddr,
+    user_id: String,
+    config: &ProtocolConfiguration,
+    mut read: WsReader,
+    write: &Mutex<WsWriter>,
+) {
+    loop {
+        let result = read.try_next().await;
+        let msg = match result {
+            Ok(Some(msg)) => msg,
+            Ok(None) => return,
+            Err(e) => {
+                use async_tungstenite::tungstenite::Error;
+                if !matches!(e, Error::AlreadyClosed | Error::ConnectionClosed) {
+                    warn!("Error while reading an event from {addr:?}: {e:?}");
+                }
+                return;
+            }
+        };
+
+        let Ok(payload) = config.decode(&msg) else {
+            continue;
+        };
+        match payload {
+            ClientMessage::BeginTyping { channel } => {
+                EventV1::ChannelStartTyping {
+                    id: channel.clone(),
+                    user: user_id.clone(),
+                }
+                .p(channel.clone())
+                .await;
+            }
+            ClientMessage::EndTyping { channel } => {
+                EventV1::ChannelStopTyping {
+                    id: channel.clone(),
+                    user: user_id.clone(),
+                }
+                .p(channel.clone())
+                .await;
+            }
+            ClientMessage::Ping { data, responded } => {
+                if responded.is_none() {
+                    write
+                        .lock()
+                        .await
+                        .send(config.encode(&EventV1::Pong { data }))
+                        .await
+                        .ok();
+                }
+            }
+            _ => {}
+        }
+    }
 }

crates/core/config/Cargo.toml

@@ -0,0 +1,34 @@
+[package]
+name = "revolt-config"
+version = "0.7.0"
+edition = "2021"
+license = "AGPL-3.0-or-later"
+authors = ["Paul Makles <me@insrt.uk>"]
+description = "Revolt Backend: Configuration"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[features]
+test = ["async-std"]
+default = ["test"]
+
+[dependencies]
+# Utility
+dotenv = "0.15.0"
+config = "0.13.3"
+cached = "0.44.0"
+once_cell = "1.18.0"
+
+# Serde
+serde = { version = "1", features = ["derive"] }
+
+# Async
+futures-locks = "0.7.1"
+async-std = { version = "1.8.0", features = ["attributes"], optional = true }
+
+# Logging
+log = "0.4.14"
+pretty_env_logger = "0.4.0"
+
+# Sentry
+sentry = "0.31.5"

crates/core/config/Revolt.test.toml

@@ -0,0 +1,3 @@
+[database]
+mongodb = "mongodb://localhost"
+redis = "redis://localhost/"

crates/core/config/Revolt.toml

@@ -0,0 +1,70 @@
+sentry_dsn = ""
+
+[database]
+mongodb = "mongodb://database"
+redis = "redis://redis/"
+
+[hosts]
+app = "http://local.revolt.chat"
+api = "http://local.revolt.chat/api"
+events = "ws://local.revolt.chat/ws"
+autumn = "http://local.revolt.chat/autumn"
+january = "http://local.revolt.chat/january"
+voso_legacy = ""
+voso_legacy_ws = ""
+
+[api]
+staging = false
+
+[api.registration]
+invite_only = false
+
+[api.smtp]
+host = ""
+username = ""
+password = ""
+from_address = ""
+
+[api.vapid]
+private_key = "LS0tLS1CRUdJTiBFQyBQUklWQVRFIEtFWS0tLS0tCk1IY0NBUUVFSUJSUWpyTWxLRnBiVWhsUHpUbERvcEliYk1yeVNrNXpKYzVYVzIxSjJDS3hvQW9HQ0NxR1NNNDkKQXdFSG9VUURRZ0FFWnkrQkg2TGJQZ2hEa3pEempXOG0rUXVPM3pCajRXT1phdkR6ZU00c0pqbmFwd1psTFE0WAp1ZDh2TzVodU94QWhMQlU3WWRldVovWHlBdFpWZmNyQi9BPT0KLS0tLS1FTkQgRUMgUFJJVkFURSBLRVktLS0tLQo"
+public_key = "BGcvgR-i2z4IQ5Mw841vJvkLjt8wY-FjmWrw83jOLCY52qcGZS0OF7nfLzuYbjsQISwVO2HXrmf18gLWVX3Kwfw="
+
+[api.fcm]
+api_key = ""
+
+[api.security]
+authifier_shield_key = ""
+voso_legacy_token = ""
+trust_cloudflare = false
+
+[api.security.captcha]
+hcaptcha_key = ""
+hcaptcha_sitekey = ""
+
+[api.workers]
+max_concurrent_connections = 50
+
+[features]
+webhooks_enabled = false
+
+[features.limits]
+
+[features.limits.default]
+group_size = 100
+bots = 5
+message_length = 2000
+message_embeds = 5
+message_replies = 5
+message_attachments = 5
+message_reactions = 20
+servers = 100
+server_emoji = 100
+server_roles = 200
+server_channels = 200
+
+attachment_size = 20000000
+avatar_size = 4000000
+background_size = 6000000
+icon_size = 2500000
+banner_size = 6000000
+emoji_size = 500000

crates/core/config/src/lib.rs

@@ -0,0 +1,240 @@
+use std::collections::HashMap;
+
+use cached::proc_macro::cached;
+use config::{Config, File, FileFormat};
+use futures_locks::RwLock;
+use once_cell::sync::Lazy;
+use serde::Deserialize;
+
+static CONFIG_BUILDER: Lazy<RwLock<Config>> = Lazy::new(|| {
+    RwLock::new({
+        let mut builder = Config::builder().add_source(File::from_str(
+            include_str!("../Revolt.toml"),
+            FileFormat::Toml,
+        ));
+
+        if std::env::var("TEST_DB").is_ok() {
+            builder = builder.add_source(File::from_str(
+                include_str!("../Revolt.test.toml"),
+                FileFormat::Toml,
+            ));
+        } else if std::path::Path::new("Revolt.toml").exists() {
+            builder = builder.add_source(File::new("Revolt.toml", FileFormat::Toml));
+        }
+
+        builder.build().unwrap()
+    })
+});
+
+// https://gifbox.me/view/gT5mqxYKCZv-twilight-meow
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct Database {
+    pub mongodb: String,
+    pub redis: String,
+}
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct Hosts {
+    pub app: String,
+    pub api: String,
+    pub events: String,
+    pub autumn: String,
+    pub january: String,
+    pub voso_legacy: String,
+    pub voso_legacy_ws: String,
+}
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct ApiRegistration {
+    pub invite_only: bool,
+}
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct ApiSmtp {
+    pub host: String,
+    pub username: String,
+    pub password: String,
+    pub from_address: String,
+    pub reply_to: Option<String>,
+    pub port: Option<i32>,
+    pub use_tls: Option<bool>,
+}
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct ApiVapid {
+    pub private_key: String,
+    pub public_key: String,
+}
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct ApiFcm {
+    pub api_key: String,
+}
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct ApiSecurityCaptcha {
+    pub hcaptcha_key: String,
+    pub hcaptcha_sitekey: String,
+}
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct ApiSecurity {
+    pub authifier_shield_key: String,
+    pub voso_legacy_token: String,
+    pub captcha: ApiSecurityCaptcha,
+    pub trust_cloudflare: bool,
+}
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct ApiWorkers {
+    pub max_concurrent_connections: usize,
+}
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct Api {
+    pub staging: bool,
+    pub registration: ApiRegistration,
+    pub smtp: ApiSmtp,
+    pub vapid: ApiVapid,
+    pub fcm: ApiFcm,
+    pub security: ApiSecurity,
+    pub workers: ApiWorkers,
+}
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct FeaturesLimits {
+    pub group_size: usize,
+    pub bots: usize,
+    pub message_length: usize,
+    pub message_replies: usize,
+    pub message_attachments: usize,
+    pub message_embeds: usize,
+    pub message_reactions: usize,
+    pub servers: usize,
+    pub server_emoji: usize,
+    pub server_roles: usize,
+    pub server_channels: usize,
+
+    pub attachment_size: usize,
+    pub avatar_size: usize,
+    pub background_size: usize,
+    pub icon_size: usize,
+    pub banner_size: usize,
+    pub emoji_size: usize,
+}
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct FeaturesLimitsCollection {
+    pub default: FeaturesLimits,
+
+    #[serde(flatten)]
+    pub roles: HashMap<String, FeaturesLimits>,
+}
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct Features {
+    pub limits: FeaturesLimitsCollection,
+    pub webhooks_enabled: bool,
+}
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct Settings {
+    pub database: Database,
+    pub hosts: Hosts,
+    pub api: Api,
+    pub features: Features,
+    pub sentry_dsn: String,
+}
+
+impl Settings {
+    pub fn preflight_checks(&self) {
+        if self.api.smtp.host.is_empty() {
+            #[cfg(not(debug_assertions))]
+            if !env::var("REVOLT_UNSAFE_NO_EMAIL").map_or(false, |v| v == *"1") {
+                panic!("Running in production without email is not recommended, set REVOLT_UNSAFE_NO_EMAIL=1 to override.");
+            }
+
+            #[cfg(debug_assertions)]
+            log::warn!("No SMTP settings specified! Remember to configure email.");
+        }
+
+        if self.api.security.captcha.hcaptcha_key.is_empty() {
+            #[cfg(not(debug_assertions))]
+            if !env::var("REVOLT_UNSAFE_NO_CAPTCHA").map_or(false, |v| v == *"1") {
+                panic!("Running in production without CAPTCHA is not recommended, set REVOLT_UNSAFE_NO_CAPTCHA=1 to override.");
+            }
+
+            #[cfg(debug_assertions)]
+            log::warn!("No Captcha key specified! Remember to add hCaptcha key.");
+        }
+    }
+}
+
+pub async fn init() {
+    println!(
+        ":: Revolt Configuration ::\n\x1b[32m{:?}\x1b[0m",
+        config().await
+    );
+}
+
+pub async fn read() -> Config {
+    CONFIG_BUILDER.read().await.clone()
+}
+
+#[cached(time = 30)]
+pub async fn config() -> Settings {
+    read().await.try_deserialize::<Settings>().unwrap()
+}
+
+/// Configure logging and common Rust variables
+pub async fn setup_logging(release: &'static str) -> Option<sentry::ClientInitGuard> {
+    dotenv::dotenv().ok();
+
+    if std::env::var("RUST_LOG").is_err() {
+        std::env::set_var("RUST_LOG", "info");
+    }
+
+    if std::env::var("ROCKET_ADDRESS").is_err() {
+        std::env::set_var("ROCKET_ADDRESS", "0.0.0.0");
+    }
+
+    pretty_env_logger::init();
+    log::info!("Starting {release}");
+
+    let config = config().await;
+    if config.sentry_dsn.is_empty() {
+        None
+    } else {
+        Some(sentry::init((
+            config.sentry_dsn,
+            sentry::ClientOptions {
+                release: Some(release.into()),
+                ..Default::default()
+            },
+        )))
+    }
+}
+
+#[macro_export]
+macro_rules! configure {
+    () => {
+        let _sentry = $crate::setup_logging(concat!(
+            env!("CARGO_PKG_NAME"),
+            "@",
+            env!("CARGO_PKG_VERSION")
+        ))
+        .await;
+    };
+}
+
+#[cfg(feature = "test")]
+#[cfg(test)]
+mod tests {
+    use crate::init;
+
+    #[async_std::test]
+    async fn it_works() {
+        init().await;
+    }
+}

crates/core/database/Cargo.toml

@@ -1,38 +1,54 @@
 [package]
 name = "revolt-database"
-version = "0.6.4"
+version = "0.7.0"
 edition = "2021"
 license = "AGPL-3.0-or-later"
-authors = [ "Paul Makles <me@insrt.uk>" ]
+authors = ["Paul Makles <me@insrt.uk>"]
 description = "Revolt Backend: Database Implementation"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [features]
 # Databases
-mongodb = [ "dep:mongodb", "bson" ]
+mongodb = ["dep:mongodb", "bson"]
 
 # ... Other
-async-std-runtime = [ "async-std" ]
-rocket-impl = [ "rocket", "schemars" ]
-redis-is-patched = [ "revolt-presence/redis-is-patched" ]
+tasks = ["isahc", "linkify", "url-escape"]
+async-std-runtime = ["async-std"]
+rocket-impl = ["rocket", "schemars", "revolt_okapi", "revolt_rocket_okapi"]
+redis-is-patched = ["revolt-presence/redis-is-patched"]
 
 # Default Features
-default = [ "mongodb", "async-std-runtime" ]
+default = ["mongodb", "async-std-runtime", "tasks"]
 
 [dependencies]
 # Core
-revolt-result = { version = "0.6.4", path = "../result" }
-revolt-models = { version = "0.6.4", path = "../models" }
-revolt-presence = { version = "0.6.4", path = "../presence" }
-revolt-permissions = { version = "0.6.4", path = "../permissions", features = [ "serde", "bson" ] }
+revolt-config = { version = "0.7.0", path = "../config" }
+revolt-result = { version = "0.7.0", path = "../result" }
+revolt-models = { version = "0.7.0", path = "../models", features = [
+    "validator",
+] }
+revolt-presence = { version = "0.7.0", path = "../presence" }
+revolt-permissions = { version = "0.7.0", path = "../permissions", features = [
+    "serde",
+    "bson",
+] }
 
 # Utility
 log = "0.4"
+lru = "0.11.0"
 rand = "0.8.5"
 ulid = "1.0.0"
 nanoid = "0.4.0"
+base64 = "0.21.3"
 once_cell = "1.17"
+indexmap = "1.9.1"
+decancer = "1.6.2"
+deadqueue = "0.2.4"
+linkify = { optional = true, version = "0.8.1" }
+url-escape = { optional = true, version = "0.1.1" }
+validator = { version = "0.16", features = ["derive"] }
+isahc = { optional = true, version = "1.7", features = ["json"] }
 
 # Serialisation
 serde_json = "1"
@@ -53,6 +69,7 @@ regex = "1"
 
 # Async Language Features
 futures = "0.3.19"
+async-lock = "2.8.0"
 async-trait = "0.1.51"
 async-recursion = "1.0.4"
 
@@ -61,7 +78,15 @@ async-std = { version = "1.8.0", features = ["attributes"], optional = true }
 
 # Rocket Impl
 schemars = { version = "0.8.8", optional = true }
-rocket = { version = "0.5.0-rc.2", default-features = false, features = ["json"], optional = true }
+rocket = { version = "0.5.0-rc.2", default-features = false, features = [
+    "json",
+], optional = true }
+revolt_okapi = { version = "0.9.1", optional = true }
+revolt_rocket_okapi = { version = "0.9.1", optional = true }
+
+# Notifications
+fcm = "0.9.2"
+web-push = "0.10.0"
 
 # Authifier
-authifier = { version = "1.0" }
+authifier = { version = "1.0.8" }

crates/core/database/fixtures/group_with_members.json

@@ -0,0 +1,28 @@
+[
+  {
+    "_object_type": "User",
+    "_id": "__ID:0__",
+    "username": "Owner",
+    "discriminator": "0001"
+  },
+  {
+    "_object_type": "User",
+    "_id": "__ID:1__",
+    "username": "Member",
+    "discriminator": "0001"
+  },
+  {
+    "_object_type": "User",
+    "_id": "__ID:2__",
+    "username": "Member",
+    "discriminator": "0002"
+  },
+  {
+    "_object_type": "Channel",
+    "_id": "__ID:3__",
+    "channel_type": "Group",
+    "name": "My Group",
+    "owner": "__ID:0__",
+    "recipients": ["__ID:0__", "__ID:1__"]
+  }
+]

crates/core/database/fixtures/server_with_roles.json

@@ -0,0 +1,89 @@
+[
+  {
+    "_object_type": "User",
+    "_id": "__ID:0__",
+    "username": "Owner",
+    "discriminator": "0001"
+  },
+  {
+    "_object_type": "User",
+    "_id": "__ID:1__",
+    "username": "Moderator",
+    "discriminator": "0001"
+  },
+  {
+    "_object_type": "User",
+    "_id": "__ID:2__",
+    "username": "User",
+    "discriminator": "0001"
+  },
+  {
+    "_object_type": "Channel",
+    "_id": "__ID:3__",
+    "channel_type": "TextChannel",
+    "name": "General",
+    "server": "__ID:4__",
+    "default_permissions": {
+      "a": 0,
+      "d": 1048576
+    },
+    "role_permissions": {
+      "__ID:5__": {
+        "a": 1048576,
+        "d": 0
+      }
+    }
+  },
+  {
+    "_object_type": "Server",
+    "_id": "__ID:4__",
+    "owner": "__ID:0__",
+    "name": "Server",
+    "channels": ["__ID:3__"],
+    "roles": {
+      "__ID:5__": {
+        "name": "Moderator",
+        "permissions": {
+          "a": 545270208,
+          "d": 0
+        },
+        "rank": 3
+      },
+      "__ID:6__": {
+        "name": "Owner",
+        "permissions": {
+          "a": 0,
+          "d": 0
+        },
+        "rank": 0
+      }
+    },
+    "default_permissions": 4000322560
+  },
+  {
+    "_object_type": "ServerMember",
+    "_id": {
+      "user": "__ID:0__",
+      "server": "__ID:4__"
+    },
+    "roles": ["__ID:6__"],
+    "joined_at": 1698318340195
+  },
+  {
+    "_object_type": "ServerMember",
+    "_id": {
+      "user": "__ID:1__",
+      "server": "__ID:4__"
+    },
+    "roles": ["__ID:5__"],
+    "joined_at": 1698318340195
+  },
+  {
+    "_object_type": "ServerMember",
+    "_id": {
+      "user": "__ID:2__",
+      "server": "__ID:4__"
+    },
+    "joined_at": 1698318340195
+  }
+]

crates/core/database/src/drivers/mod.rs

@@ -1,6 +1,9 @@
 mod mongodb;
 mod reference;
 
+use rand::Rng;
+use revolt_config::config;
+
 pub use self::mongodb::*;
 pub use self::reference::*;
 
@@ -31,25 +34,44 @@ impl DatabaseInfo {
     /// Create a database client from the given database information
     #[async_recursion]
     pub async fn connect(self) -> Result<Database, String> {
+        let config = config().await;
+
         Ok(match self {
             DatabaseInfo::Auto => {
-                if let Ok(uri) = std::env::var("MONGODB") {
-                    return DatabaseInfo::MongoDb {
-                        uri,
+                if std::env::var("TEST_DB").is_ok() {
+                    DatabaseInfo::Test(format!(
+                        "revolt_test_{}",
+                        rand::thread_rng().gen_range(1_000_000..10_000_000)
+                    ))
+                    .connect()
+                    .await?
+                } else if !config.database.mongodb.is_empty() {
+                    DatabaseInfo::MongoDb {
+                        uri: config.database.mongodb,
                         database_name: "revolt".to_string(),
                     }
                     .connect()
-                    .await;
+                    .await?
+                } else {
+                    DatabaseInfo::Reference.connect().await?
                 }
-
-                DatabaseInfo::Reference.connect().await?
             }
             DatabaseInfo::Test(database_name) => {
-                if let Ok(uri) = std::env::var("MONGODB") {
-                    return DatabaseInfo::MongoDb { uri, database_name }.connect().await;
+                match std::env::var("TEST_DB")
+                    .expect("`TEST_DB` environment variable should be set to REFERENCE or MONGODB")
+                    .as_str()
+                {
+                    "REFERENCE" => DatabaseInfo::Reference.connect().await?,
+                    "MONGODB" => {
+                        DatabaseInfo::MongoDb {
+                            uri: config.database.mongodb,
+                            database_name,
+                        }
+                        .connect()
+                        .await?
+                    }
+                    _ => unreachable!("must specify REFERENCE or MONGODB"),
                 }
-
-                DatabaseInfo::Reference.connect().await?
             }
             DatabaseInfo::Reference => Database::Reference(Default::default()),
             DatabaseInfo::MongoDb { uri, database_name } => {

crates/core/database/src/drivers/mongodb.rs

@@ -238,6 +238,6 @@ pub fn prefix_keys<T: Serialize>(t: &T, prefix: &str) -> HashMap<String, serde_j
     let v: HashMap<String, serde_json::Value> = serde_json::from_str(&v).unwrap();
     v.into_iter()
         .filter(|(_k, v)| !v.is_null())
-        .map(|(k, v)| (prefix.to_owned() + &k, v))
+        .map(|(k, v)| (format!("{}{}", prefix.to_owned(), k), v))
         .collect()
 }

crates/core/database/src/drivers/reference.rs

@@ -3,29 +3,30 @@ use std::{collections::HashMap, sync::Arc};
 use futures::lock::Mutex;
 
 use crate::{
-    AccountStrike, Bot, Channel, File, Member, MemberCompositeKey, Server, User, UserSettings,
-    Webhook,
+    Bot, Channel, ChannelCompositeKey, ChannelUnread, Emoji, File, Invite, Member,
+    MemberCompositeKey, Message, RatelimitEvent, Report, Server, ServerBan, Snapshot, User,
+    UserSettings, Webhook,
 };
 
 database_derived!(
     /// Reference implementation
     #[derive(Default)]
     pub struct ReferenceDb {
-        pub account_strikes: Arc<Mutex<HashMap<String, AccountStrike>>>,
         pub bots: Arc<Mutex<HashMap<String, Bot>>>,
+        pub channels: Arc<Mutex<HashMap<String, Channel>>>,
+        pub channel_invites: Arc<Mutex<HashMap<String, Invite>>>,
+        pub channel_unreads: Arc<Mutex<HashMap<ChannelCompositeKey, ChannelUnread>>>,
         pub channel_webhooks: Arc<Mutex<HashMap<String, Webhook>>>,
+        pub emojis: Arc<Mutex<HashMap<String, Emoji>>>,
+        pub files: Arc<Mutex<HashMap<String, File>>>,
+        pub messages: Arc<Mutex<HashMap<String, Message>>>,
+        pub ratelimit_events: Arc<Mutex<HashMap<String, RatelimitEvent>>>,
         pub user_settings: Arc<Mutex<HashMap<String, UserSettings>>>,
         pub users: Arc<Mutex<HashMap<String, User>>>,
+        pub server_bans: Arc<Mutex<HashMap<MemberCompositeKey, ServerBan>>>,
         pub server_members: Arc<Mutex<HashMap<MemberCompositeKey, Member>>>,
         pub servers: Arc<Mutex<HashMap<String, Server>>>,
-        pub files: Arc<Mutex<HashMap<String, File>>>,
-        pub server_bans: Arc<Mutex<HashMap<String, ()>>>,
-        pub safety_reports: Arc<Mutex<HashMap<String, ()>>>,
-        pub safety_snapshots: Arc<Mutex<HashMap<String, ()>>>,
-        pub emoji: Arc<Mutex<HashMap<String, ()>>>,
-        pub messages: Arc<Mutex<HashMap<String, ()>>>,
-        pub channels: Arc<Mutex<HashMap<String, Channel>>>,
-        pub channel_invites: Arc<Mutex<HashMap<String, ()>>>,
-        pub channel_unreads: Arc<Mutex<HashMap<String, ()>>>,
+        pub safety_reports: Arc<Mutex<HashMap<String, Report>>>,
+        pub safety_snapshots: Arc<Mutex<HashMap<String, Snapshot>>>,
     }
 );

crates/core/database/src/events/client.rs

@@ -2,7 +2,10 @@ use authifier::AuthifierEvent;
 use serde::{Deserialize, Serialize};
 
 use revolt_models::v0::{
-    Channel, FieldsChannel, FieldsWebhook, PartialChannel, PartialWebhook, Webhook,
+    AppendMessage, Channel, Emoji, FieldsChannel, FieldsMember, FieldsRole, FieldsServer,
+    FieldsUser, FieldsWebhook, MemberCompositeKey, Message, PartialChannel, PartialMember,
+    PartialMessage, PartialRole, PartialServer, PartialUser, PartialWebhook, Report, Server, User,
+    UserSettings, Webhook,
 };
 use revolt_result::Error;
 
@@ -55,8 +58,7 @@ pub enum EventV1 {
     },
 
     /// Ping response
-    Pong { data: Ping },
-
+    Pong { data: Ping }, */
     /// New message
     Message(Message),
 
@@ -108,6 +110,7 @@ pub enum EventV1 {
         id: String,
         server: Server,
         channels: Vec<Channel>,
+        emojis: Vec<Emoji>,
     },
 
     /// Update existing server
@@ -153,13 +156,7 @@ pub enum EventV1 {
     },
 
     /// Relationship with another user changed
-    UserRelationship {
-        id: String,
-        user: User,
-        // ! this field can be deprecated
-        status: RelationshipStatus,
-    },
-
+    UserRelationship { id: String, user: User },
     /// Settings updated remotely
     UserSettingsUpdate { id: String, update: UserSettings },
 
@@ -173,7 +170,6 @@ pub enum EventV1 {
     ///
     /// User flags are specified to explain why a wipe is occurring though not all reasons will necessarily ever appear.
     UserPlatformWipe { user_id: String, flags: i32 },
-
     /// New emoji
     EmojiCreate(Emoji),
 
@@ -181,7 +177,7 @@ pub enum EventV1 {
     EmojiDelete { id: String },
 
     /// New report
-    ReportCreate(Report), */
+    ReportCreate(Report),
     /// New channel
     ChannelCreate(Channel),
 
@@ -248,8 +244,7 @@ impl EventV1 {
     pub async fn p_user(self, id: String, db: &Database) {
         self.clone().p(id.clone()).await;
 
-        // ! FIXME: this should be captured by member list in the future
-        // ! and not immediately fanned out to users
+        // TODO: this should be captured by member list in the future and not immediately fanned out to users
         if let Ok(members) = db.fetch_all_memberships(&id).await {
             for member in members {
                 self.clone().p(member.id.server).await;

crates/core/database/src/lib.rs

@@ -43,7 +43,7 @@ macro_rules! auto_derived {
 
 macro_rules! auto_derived_partial {
     ( $item:item, $name:expr ) => {
-        #[derive(OptionalStruct, Serialize, Deserialize, Debug, Clone, Default, Eq, PartialEq)]
+        #[derive(OptionalStruct, Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
         #[optional_derive(Serialize, Deserialize, Debug, Clone, Default, Eq, PartialEq)]
         #[optional_name = $name]
         #[opt_skip_serializing_none]
@@ -81,6 +81,7 @@ pub mod util;
 pub use models::*;
 
 pub mod events;
+pub mod tasks;
 
 /// Utility function to check if a boolean value is false
 pub fn if_false(t: &bool) -> bool {

crates/core/database/src/models/admin_migrations/model.rs

@@ -18,7 +18,7 @@ mod tests {
             db.migrate_database().await.unwrap();
 
             // Migrate the existing database
-            db.migrate_database().await.unwrap()
+            db.migrate_database().await.unwrap();
         });
     }
 }

crates/core/database/src/models/admin_migrations/ops/mongodb/scripts.rs

@@ -697,7 +697,9 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
     }
 
     if revision <= 19 {
-        info!("Running migration [revision 19 / 27-02-2023]: Create report / snapshot collections, migrate to new model if applicable.");
+        info!(
+            "Running migration [revision 19 / 27-02-2023]: Create report / snapshot collections."
+        );
 
         db.db()
             .create_collection("safety_reports", None)
@@ -708,19 +710,6 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
             .create_collection("safety_snapshots", None)
             .await
             .unwrap();
-
-        db.col::<Document>("safety_reports")
-            .update_many(
-                doc! {},
-                doc! {
-                    "$set": {
-                        "status": "Created"
-                    }
-                },
-                None,
-            )
-            .await
-            .unwrap();
     }
 
     if revision <= 20 {

crates/core/database/src/models/bots/model.rs

@@ -1,6 +1,8 @@
+use revolt_config::config;
 use revolt_result::Result;
+use ulid::Ulid;
 
-use crate::Database;
+use crate::{BotInformation, Database, PartialUser, User};
 
 auto_derived_partial!(
     /// Bot
@@ -49,8 +51,70 @@ auto_derived!(
     }
 );
 
+#[allow(clippy::derivable_impls)]
+impl Default for Bot {
+    fn default() -> Self {
+        Self {
+            id: Default::default(),
+            owner: Default::default(),
+            token: Default::default(),
+            public: Default::default(),
+            analytics: Default::default(),
+            discoverable: Default::default(),
+            interactions_url: Default::default(),
+            terms_of_service_url: Default::default(),
+            privacy_policy_url: Default::default(),
+            flags: Default::default(),
+        }
+    }
+}
+
 #[allow(clippy::disallowed_methods)]
 impl Bot {
+    /// Create a new bot
+    pub async fn create<D>(db: &Database, username: String, owner: &User, data: D) -> Result<Bot>
+    where
+        D: Into<Option<PartialBot>>,
+    {
+        if owner.bot.is_some() {
+            return Err(create_error!(IsBot));
+        }
+
+        let config = config().await;
+        if db.get_number_of_bots_by_user(&owner.id).await? >= config.features.limits.default.bots {
+            return Err(create_error!(ReachedMaximumBots));
+        }
+
+        let id = Ulid::new().to_string();
+
+        User::create(
+            db,
+            username,
+            Some(id.to_string()),
+            Some(PartialUser {
+                bot: Some(BotInformation {
+                    owner: owner.id.to_string(),
+                }),
+                ..Default::default()
+            }),
+        )
+        .await?;
+
+        let mut bot = Bot {
+            id,
+            owner: owner.id.to_string(),
+            token: nanoid::nanoid!(64),
+            ..Default::default()
+        };
+
+        if let Some(data) = data.into() {
+            bot.apply_options(data);
+        }
+
+        db.insert_bot(&bot).await?;
+        Ok(bot)
+    }
+
     /// Remove a field from this object
     pub fn remove_field(&mut self, field: &FieldsBot) {
         match field {
@@ -96,27 +160,24 @@ mod tests {
     #[async_std::test]
     async fn crud() {
         database_test!(|db| async move {
-            let bot_id = "bot";
-            let user_id = "user";
-            let token = "my_token";
+            let owner = User::create(&db, "Owner".to_string(), None, None)
+                .await
+                .unwrap();
 
-            let user = User {
-                id: bot_id.to_string(),
-                username: "Bot Name".to_string(),
-                ..Default::default()
-            };
+            let bot = Bot::create(
+                &db,
+                "Bot Name".to_string(),
+                &owner,
+                PartialBot {
+                    token: Some("my token".to_string()),
+                    interactions_url: Some("some url".to_string()),
+                    ..Default::default()
+                },
+            )
+            .await
+            .unwrap();
 
-            db.insert_user(&user).await.unwrap();
-
-            let bot = Bot {
-                id: bot_id.to_string(),
-                owner: user_id.to_string(),
-                token: token.to_string(),
-                interactions_url: "some url".to_string(),
-                ..Default::default()
-            };
-
-            db.insert_bot(&bot).await.unwrap();
+            assert!(!bot.interactions_url.is_empty());
 
             let mut updated_bot = bot.clone();
             updated_bot
@@ -131,9 +192,9 @@ mod tests {
                 .await
                 .unwrap();
 
-            let fetched_bot1 = db.fetch_bot(bot_id).await.unwrap();
+            let fetched_bot1 = db.fetch_bot(&bot.id).await.unwrap();
             let fetched_bot2 = db.fetch_bot_by_token(&fetched_bot1.token).await.unwrap();
-            let fetched_bots = db.fetch_bots_by_user(user_id).await.unwrap();
+            let fetched_bots = db.fetch_bots_by_user(&owner.id).await.unwrap();
 
             assert!(!bot.public);
             assert!(fetched_bot1.public);
@@ -143,12 +204,12 @@ mod tests {
             assert_eq!(updated_bot, fetched_bot1);
             assert_eq!(fetched_bot1, fetched_bot2);
             assert_eq!(fetched_bot1, fetched_bots[0]);
-            assert_eq!(1, db.get_number_of_bots_by_user(user_id).await.unwrap());
+            assert_eq!(1, db.get_number_of_bots_by_user(&owner.id).await.unwrap());
 
             bot.delete(&db).await.unwrap();
-            assert!(db.fetch_bot(bot_id).await.is_err());
-            assert_eq!(0, db.get_number_of_bots_by_user(user_id).await.unwrap());
-            assert_eq!(db.fetch_user(bot_id).await.unwrap().flags, Some(2))
+            assert!(db.fetch_bot(&bot.id).await.is_err());
+            assert_eq!(0, db.get_number_of_bots_by_user(&owner.id).await.unwrap());
+            assert_eq!(db.fetch_user(&bot.id).await.unwrap().flags, Some(2))
         });
     }
 }

crates/core/database/src/models/channel_invites/model.rs

@@ -0,0 +1,105 @@
+use revolt_result::{create_error, Result};
+
+use crate::{Channel, Database, User};
+
+static ALPHABET: [char; 54] = [
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J',
+    'K', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
+    'g', 'h', 'j', 'k', 'm', 'n', 'p', 'q', 'r', 's', 't', 'v', 'w', 'x', 'y', 'z',
+];
+
+auto_derived!(
+    /// Invite
+    pub enum Invite {
+        /// Invite to a specific server channel
+        Server {
+            /// Invite code
+            #[serde(rename = "_id")]
+            code: String,
+            /// Id of the server this invite points to
+            server: String,
+            /// Id of user who created this invite
+            creator: String,
+            /// Id of the server channel this invite points to
+            channel: String,
+        },
+        /// Invite to a group channel
+        Group {
+            /// Invite code
+            #[serde(rename = "_id")]
+            code: String,
+            /// Id of user who created this invite
+            creator: String,
+            /// Id of the group channel this invite points to
+            channel: String,
+        }, /* User {
+               code: String,
+               user: String
+           } */
+    }
+);
+
+#[allow(clippy::disallowed_methods)]
+impl Invite {
+    /// Get the invite code for this invite
+    pub fn code(&'_ self) -> &'_ str {
+        match self {
+            Invite::Server { code, .. } | Invite::Group { code, .. } => code,
+        }
+    }
+
+    /// Get the ID of the user who created this invite
+    pub fn creator(&'_ self) -> &'_ str {
+        match self {
+            Invite::Server { creator, .. } | Invite::Group { creator, .. } => creator,
+        }
+    }
+
+    /// Create a new invite from given information
+    pub async fn create_channel_invite(
+        db: &Database,
+        creator: &User,
+        channel: &Channel,
+    ) -> Result<Invite> {
+        let code = nanoid::nanoid!(8, &ALPHABET);
+        let invite = match &channel {
+            Channel::Group { id, .. } => Ok(Invite::Group {
+                code,
+                creator: creator.id.clone(),
+                channel: id.clone(),
+            }),
+            Channel::TextChannel { id, server, .. } | Channel::VoiceChannel { id, server, .. } => {
+                Ok(Invite::Server {
+                    code,
+                    creator: creator.id.clone(),
+                    server: server.clone(),
+                    channel: id.clone(),
+                })
+            }
+            _ => Err(create_error!(InvalidOperation)),
+        }?;
+
+        db.insert_invite(&invite).await?;
+        Ok(invite)
+    }
+
+    /// Resolve an invite by its ID or by a public server ID
+    pub async fn find(db: &Database, code: &str) -> Result<Invite> {
+        if let Ok(invite) = db.fetch_invite(code).await {
+            return Ok(invite);
+        } else if let Ok(server) = db.fetch_server(code).await {
+            if server.discoverable {
+                if let Some(channel) = server.channels.into_iter().next() {
+                    return Ok(Invite::Server {
+                        code: code.to_string(),
+                        server: server.id,
+                        creator: server.owner,
+                        channel,
+                    });
+                }
+            }
+        }
+
+        Err(create_error!(NotFound))
+    }
+}

crates/core/database/src/models/channel_invites/ops.rs

@@ -0,0 +1,21 @@
+use revolt_result::Result;
+
+use crate::Invite;
+
+mod mongodb;
+mod reference;
+
+#[async_trait]
+pub trait AbstractChannelInvites: Sync + Send {
+    /// Insert a new invite into the database
+    async fn insert_invite(&self, invite: &Invite) -> Result<()>;
+
+    /// Fetch an invite by its id
+    async fn fetch_invite(&self, code: &str) -> Result<Invite>;
+
+    /// Fetch all invites for a server
+    async fn fetch_invites_for_server(&self, server_id: &str) -> Result<Vec<Invite>>;
+
+    /// Delete an invite by its id
+    async fn delete_invite(&self, code: &str) -> Result<()>;
+}

crates/core/database/src/models/channel_invites/ops/mongodb.rs

@@ -0,0 +1,50 @@
+use futures::StreamExt;
+use revolt_result::Result;
+
+use crate::Invite;
+use crate::MongoDb;
+
+use super::AbstractChannelInvites;
+
+static COL: &str = "channel_invites";
+
+#[async_trait]
+impl AbstractChannelInvites for MongoDb {
+    /// Insert a new invite into the database
+    async fn insert_invite(&self, invite: &Invite) -> Result<()> {
+        query!(self, insert_one, COL, &invite).map(|_| ())
+    }
+
+    /// Fetch an invite by the code
+    async fn fetch_invite(&self, code: &str) -> Result<Invite> {
+        query!(self, find_one_by_id, COL, code)?.ok_or_else(|| create_error!(NotFound))
+    }
+
+    /// Fetch all invites for a server
+    async fn fetch_invites_for_server(&self, server_id: &str) -> Result<Vec<Invite>> {
+        Ok(self
+            .col::<Invite>(COL)
+            .find(
+                doc! {
+                    "server": server_id,
+                },
+                None,
+            )
+            .await
+            .map_err(|_| create_database_error!("find", COL))?
+            .filter_map(|s| async {
+                if cfg!(debug_assertions) {
+                    Some(s.unwrap())
+                } else {
+                    s.ok()
+                }
+            })
+            .collect()
+            .await)
+    }
+
+    /// Delete an invite by its code
+    async fn delete_invite(&self, code: &str) -> Result<()> {
+        query!(self, delete_one_by_id, COL, code).map(|_| ())
+    }
+}

crates/core/database/src/models/channel_invites/ops/reference.rs

@@ -0,0 +1,52 @@
+use revolt_result::Result;
+
+use crate::Invite;
+use crate::ReferenceDb;
+
+use super::AbstractChannelInvites;
+
+#[async_trait]
+impl AbstractChannelInvites for ReferenceDb {
+    /// Insert a new invite into the database
+    async fn insert_invite(&self, invite: &Invite) -> Result<()> {
+        let mut invites = self.channel_invites.lock().await;
+        if invites.contains_key(invite.code()) {
+            Err(create_database_error!("insert", "invite"))
+        } else {
+            invites.insert(invite.code().to_string(), invite.clone());
+            Ok(())
+        }
+    }
+
+    /// Fetch an invite by the code
+    async fn fetch_invite(&self, code: &str) -> Result<Invite> {
+        let invites = self.channel_invites.lock().await;
+        invites
+            .get(code)
+            .cloned()
+            .ok_or_else(|| create_error!(NotFound))
+    }
+
+    /// Fetch all invites for a server
+    async fn fetch_invites_for_server(&self, server_id: &str) -> Result<Vec<Invite>> {
+        let invites = self.channel_invites.lock().await;
+        Ok(invites
+            .values()
+            .filter(|invite| match invite {
+                Invite::Server { server, .. } => server == server_id,
+                _ => false,
+            })
+            .cloned()
+            .collect())
+    }
+
+    /// Delete an invite by its code
+    async fn delete_invite(&self, code: &str) -> Result<()> {
+        let mut invites = self.channel_invites.lock().await;
+        if invites.remove(code).is_some() {
+            Ok(())
+        } else {
+            Err(create_error!(NotFound))
+        }
+    }
+}

crates/core/database/src/models/channel_unreads/mod.rs

@@ -0,0 +1,5 @@
+mod model;
+mod ops;
+
+pub use model::*;
+pub use ops::*;

crates/core/database/src/models/channel_unreads/model.rs

@@ -0,0 +1,24 @@
+auto_derived!(
+    /// Channel Unread
+    pub struct ChannelUnread {
+        /// Composite key pointing to a user's view of a channel
+        #[serde(rename = "_id")]
+        pub id: ChannelCompositeKey,
+
+        /// Id of the last message read in this channel by a user
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub last_id: Option<String>,
+        /// Array of message ids that mention the user
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub mentions: Option<Vec<String>>,
+    }
+
+    /// Composite primary key consisting of channel and user id
+    #[derive(Hash)]
+    pub struct ChannelCompositeKey {
+        /// Channel Id
+        pub channel: String,
+        /// User Id
+        pub user: String,
+    }
+);

crates/core/database/src/models/channel_unreads/ops.rs

@@ -0,0 +1,31 @@
+use revolt_result::Result;
+
+use crate::ChannelUnread;
+
+mod mongodb;
+mod reference;
+
+#[async_trait]
+pub trait AbstractChannelUnreads: Sync + Send {
+    /// Acknowledge a message.
+    async fn acknowledge_message(
+        &self,
+        channel_id: &str,
+        user_id: &str,
+        message_id: &str,
+    ) -> Result<()>;
+
+    /// Acknowledge many channels.
+    async fn acknowledge_channels(&self, user_id: &str, channel_ids: &[String]) -> Result<()>;
+
+    /// Add a mention.
+    async fn add_mention_to_unread<'a>(
+        &self,
+        channel_id: &str,
+        user_id: &str,
+        message_ids: &[String],
+    ) -> Result<()>;
+
+    /// Fetch all channel unreads for a user.
+    async fn fetch_unreads(&self, user_id: &str) -> Result<Vec<ChannelUnread>>;
+}

crates/core/database/src/models/channel_unreads/ops/mongodb.rs

@@ -0,0 +1,119 @@
+use bson::Document;
+use mongodb::options::UpdateOptions;
+use revolt_result::Result;
+use ulid::Ulid;
+
+use crate::ChannelUnread;
+use crate::MongoDb;
+
+use super::AbstractChannelUnreads;
+
+static COL: &str = "channel_unreads";
+
+#[async_trait]
+impl AbstractChannelUnreads for MongoDb {
+    /// Acknowledge a message.
+    async fn acknowledge_message(
+        &self,
+        channel_id: &str,
+        user_id: &str,
+        message_id: &str,
+    ) -> Result<()> {
+        self.col::<Document>(COL)
+            .update_one(
+                doc! {
+                    "_id.channel": channel_id,
+                    "_id.user": user_id,
+                },
+                doc! {
+                    "$unset": {
+                        "mentions": 1_i32
+                    },
+                    "$set": {
+                        "last_id": message_id
+                    }
+                },
+                UpdateOptions::builder().upsert(true).build(),
+            )
+            .await
+            .map(|_| ())
+            .map_err(|_| create_database_error!("update_one", COL))
+    }
+
+    /// Acknowledge many channels.
+    async fn acknowledge_channels(&self, user_id: &str, channel_ids: &[String]) -> Result<()> {
+        let current_time = Ulid::new().to_string();
+
+        self.col::<Document>(COL)
+            .delete_many(
+                doc! {
+                    "_id.channel": {
+                        "$in": channel_ids
+                    },
+                    "_id.user": user_id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| create_database_error!("delete_many", COL))?;
+
+        self.col::<Document>(COL)
+            .insert_many(
+                channel_ids
+                    .iter()
+                    .map(|channel_id| {
+                        doc! {
+                            "_id": {
+                                "channel": channel_id,
+                                "user": user_id
+                            },
+                            "last_id": &current_time
+                        }
+                    })
+                    .collect::<Vec<Document>>(),
+                None,
+            )
+            .await
+            .map(|_| ())
+            .map_err(|_| create_database_error!("update_many", COL))
+    }
+
+    /// Add a mention.
+    async fn add_mention_to_unread<'a>(
+        &self,
+        channel_id: &str,
+        user_id: &str,
+        message_ids: &[String],
+    ) -> Result<()> {
+        self.col::<Document>(COL)
+            .update_one(
+                doc! {
+                    "_id.channel": channel_id,
+                    "_id.user": user_id,
+                },
+                doc! {
+                    "$push": {
+                        "mentions": {
+                            "$each": message_ids
+                        }
+                    }
+                },
+                UpdateOptions::builder().upsert(true).build(),
+            )
+            .await
+            .map(|_| ())
+            .map_err(|_| create_database_error!("update_one", COL))
+    }
+
+    /// Fetch all channel unreads for a user.
+    async fn fetch_unreads(&self, user_id: &str) -> Result<Vec<ChannelUnread>> {
+        query!(
+            self,
+            find,
+            COL,
+            doc! {
+                "_id.user": user_id
+            }
+        )
+    }
+}

crates/core/database/src/models/channel_unreads/ops/reference.rs

@@ -0,0 +1,90 @@
+use revolt_result::Result;
+use ulid::Ulid;
+
+use crate::{ChannelCompositeKey, ChannelUnread, ReferenceDb};
+
+use super::AbstractChannelUnreads;
+
+#[async_trait]
+impl AbstractChannelUnreads for ReferenceDb {
+    /// Acknowledge a message.
+    async fn acknowledge_message(
+        &self,
+        channel_id: &str,
+        user_id: &str,
+        message_id: &str,
+    ) -> Result<()> {
+        let mut unreads = self.channel_unreads.lock().await;
+        let key = ChannelCompositeKey {
+            channel: channel_id.to_string(),
+            user: user_id.to_string(),
+        };
+
+        if let Some(unread) = unreads.get_mut(&key) {
+            unread.mentions = None;
+            unread.last_id.replace(message_id.to_string());
+        } else {
+            unreads.insert(
+                key.clone(),
+                ChannelUnread {
+                    id: key,
+                    last_id: Some(message_id.to_string()),
+                    mentions: None,
+                },
+            );
+        }
+
+        Ok(())
+    }
+
+    /// Acknowledge many channels.
+    async fn acknowledge_channels(&self, user_id: &str, channel_ids: &[String]) -> Result<()> {
+        let current_time = Ulid::new().to_string();
+        for channel_id in channel_ids {
+            #[allow(clippy::disallowed_methods)]
+            self.acknowledge_message(channel_id, user_id, &current_time)
+                .await?;
+        }
+
+        Ok(())
+    }
+
+    /// Add a mention.
+    async fn add_mention_to_unread<'a>(
+        &self,
+        channel_id: &str,
+        user_id: &str,
+        message_ids: &[String],
+    ) -> Result<()> {
+        let mut unreads = self.channel_unreads.lock().await;
+        let key = ChannelCompositeKey {
+            channel: channel_id.to_string(),
+            user: user_id.to_string(),
+        };
+
+        if let Some(unread) = unreads.get_mut(&key) {
+            unread.mentions.replace(message_ids.to_vec());
+        } else {
+            unreads.insert(
+                key.clone(),
+                ChannelUnread {
+                    id: key,
+                    last_id: None,
+                    mentions: Some(message_ids.to_vec()),
+                },
+            );
+        }
+
+        Ok(())
+    }
+
+    /// Fetch all channel unreads for a user.
+    async fn fetch_unreads(&self, user_id: &str) -> Result<Vec<ChannelUnread>> {
+        let unreads = self.channel_unreads.lock().await;
+        Ok(unreads
+            .values()
+            .filter(|unread| unread.id.user == user_id)
+            .cloned()
+            .collect())
+    }
+}

crates/core/database/src/models/channel_webhooks/model.rs

@@ -36,6 +36,20 @@ auto_derived!(
     }
 );
 
+#[allow(clippy::derivable_impls)]
+impl Default for Webhook {
+    fn default() -> Self {
+        Self {
+            id: Default::default(),
+            name: Default::default(),
+            avatar: None,
+            channel_id: Default::default(),
+            permissions: Default::default(),
+            token: Default::default(),
+        }
+    }
+}
+
 #[allow(clippy::disallowed_methods)]
 impl Webhook {
     pub async fn create(&self, db: &Database) -> Result<()> {
@@ -120,7 +134,7 @@ mod tests {
                 id: webhook_id.to_string(),
                 name: "Webhook Name".to_string(),
                 channel_id: channel_id.to_string(),
-                avatar: Some(Default::default()),
+                avatar: None,
                 ..Default::default()
             };
 

crates/core/database/src/models/channels/model.rs

@@ -1,12 +1,19 @@
 use std::collections::HashMap;
 
+use revolt_config::config;
+use revolt_models::v0::{self, MessageAuthor};
 use revolt_permissions::OverrideField;
 use revolt_result::Result;
 use serde::{Deserialize, Serialize};
+use ulid::Ulid;
 
-use crate::{events::client::EventV1, Database, File, IntoDocumentPath};
+use crate::{
+    events::client::EventV1, tasks::ack::AckEvent, Database, File, IntoDocumentPath, PartialServer,
+    Server, SystemMessage, User,
+};
 
 auto_derived!(
+    #[serde(tag = "channel_type")]
     pub enum Channel {
         /// Personal "Saved Notes" channel which allows users to save messages
         SavedMessages {
@@ -164,52 +171,221 @@ auto_derived!(
     }
 );
 
+#[allow(clippy::disallowed_methods)]
 impl Channel {
-    /// Create a channel
+    /* /// Create a channel
     pub async fn create(&self, db: &Database) -> Result<()> {
         db.insert_channel(self).await?;
 
+        let event = EventV1::ChannelCreate(self.clone().into());
+        match self {
+            Self::SavedMessages { user, .. } => event.private(user.clone()).await,
+            Self::DirectMessage { recipients, .. } | Self::Group { recipients, .. } => {
+                for recipient in recipients {
+                    event.clone().private(recipient.clone()).await;
+                }
+            }
+            Self::TextChannel { server, .. } | Self::VoiceChannel { server, .. } => {
+                event.p(server.clone()).await;
+            }
+        }
+
         Ok(())
+    }*/
+
+    /// Create a new server channel
+    pub async fn create_server_channel(
+        db: &Database,
+        server: &mut Server,
+        data: v0::DataCreateServerChannel,
+        update_server: bool,
+    ) -> Result<Channel> {
+        let config = config().await;
+        if server.channels.len() > config.features.limits.default.server_channels {
+            return Err(create_error!(TooManyChannels {
+                max: config.features.limits.default.server_channels,
+            }));
+        };
+
+        let id = ulid::Ulid::new().to_string();
+        let channel = match data.channel_type {
+            v0::LegacyServerChannelType::Text => Channel::TextChannel {
+                id: id.clone(),
+                server: server.id.to_owned(),
+                name: data.name,
+                description: data.description,
+                icon: None,
+                last_message_id: None,
+                default_permissions: None,
+                role_permissions: HashMap::new(),
+                nsfw: data.nsfw.unwrap_or(false),
+            },
+            v0::LegacyServerChannelType::Voice => Channel::VoiceChannel {
+                id: id.clone(),
+                server: server.id.to_owned(),
+                name: data.name,
+                description: data.description,
+                icon: None,
+                default_permissions: None,
+                role_permissions: HashMap::new(),
+                nsfw: data.nsfw.unwrap_or(false),
+            },
+        };
+
+        db.insert_channel(&channel).await?;
+
+        if update_server {
+            server
+                .update(
+                    db,
+                    PartialServer {
+                        channels: Some([server.channels.clone(), [id].into()].concat()),
+                        ..Default::default()
+                    },
+                    vec![],
+                )
+                .await?;
+
+            EventV1::ChannelCreate(channel.clone().into())
+                .p(server.id.clone())
+                .await;
+        }
+
+        Ok(channel)
+    }
+
+    /// Create a group
+    pub async fn create_group(
+        db: &Database,
+        mut data: v0::DataCreateGroup,
+        owner_id: String,
+    ) -> Result<Channel> {
+        data.users.insert(owner_id.to_string());
+
+        let config = config().await;
+        if data.users.len() > config.features.limits.default.group_size {
+            return Err(create_error!(GroupTooLarge {
+                max: config.features.limits.default.group_size,
+            }));
+        }
+
+        let recipients = data.users.into_iter().collect::<Vec<String>>();
+        let channel = Channel::Group {
+            id: ulid::Ulid::new().to_string(),
+
+            name: data.name,
+            owner: owner_id,
+            description: data.description,
+            recipients: recipients.clone(),
+
+            icon: None,
+            last_message_id: None,
+
+            permissions: None,
+
+            nsfw: data.nsfw.unwrap_or(false),
+        };
+
+        db.insert_channel(&channel).await?;
+
+        let event = EventV1::ChannelCreate(channel.clone().into());
+        for recipient in recipients {
+            event.clone().private(recipient).await;
+        }
+
+        Ok(channel)
+    }
+
+    /// Create a DM (or return the existing one / saved messages)
+    pub async fn create_dm(db: &Database, user_a: &User, user_b: &User) -> Result<Channel> {
+        // Try to find existing channel
+        if let Ok(channel) = db.find_direct_message_channel(&user_a.id, &user_b.id).await {
+            Ok(channel)
+        } else {
+            let channel = if user_a.id == user_b.id {
+                // Create a new saved messages channel
+                Channel::SavedMessages {
+                    id: Ulid::new().to_string(),
+                    user: user_a.id.to_string(),
+                }
+            } else {
+                // Create a new DM channel
+                Channel::DirectMessage {
+                    id: Ulid::new().to_string(),
+                    active: true, // show by default
+                    recipients: vec![user_a.id.clone(), user_b.id.clone()],
+                    last_message_id: None,
+                }
+            };
+
+            db.insert_channel(&channel).await?;
+
+            match &channel {
+                Channel::DirectMessage { .. } => {
+                    let event = EventV1::ChannelCreate(channel.clone().into());
+                    event.clone().private(user_a.id.clone()).await;
+                    event.private(user_b.id.clone()).await;
+                }
+                _ => {}
+            };
+
+            Ok(channel)
+        }
     }
 
     /// Add user to a group
     pub async fn add_user_to_group(
         &mut self,
         db: &Database,
-        user_id: &str,
-        _by_id: &str,
+        user: &User,
+        by_id: &str,
     ) -> Result<()> {
         if let Channel::Group { recipients, .. } = self {
-            if recipients.contains(&String::from(user_id)) {
+            if recipients.contains(&String::from(&user.id)) {
                 return Err(create_error!(AlreadyInGroup));
             }
 
-            recipients.push(String::from(user_id));
+            let config = config().await;
+            if recipients.len() >= config.features.limits.default.group_size {
+                return Err(create_error!(GroupTooLarge {
+                    max: config.features.limits.default.group_size
+                }));
+            }
+
+            recipients.push(String::from(&user.id));
         }
 
         match &self {
             Channel::Group { id, .. } => {
-                db.add_user_to_group(id, user_id).await?;
+                db.add_user_to_group(id, &user.id).await?;
 
                 EventV1::ChannelGroupJoin {
                     id: id.to_string(),
-                    user: user_id.to_string(),
+                    user: user.id.to_string(),
                 }
                 .p(id.to_string())
                 .await;
 
-                EventV1::ChannelCreate(self.clone().into())
-                    .private(user_id.to_string())
-                    .await;
-
-                /* TODO: SystemMessage::UserAdded {
-                    id: user.to_string(),
-                    by: by.to_string(),
+                SystemMessage::UserAdded {
+                    id: user.id.to_string(),
+                    by: by_id.to_string(),
                 }
                 .into_message(id.to_string())
-                .create(db, self, None)
+                .send(
+                    db,
+                    MessageAuthor::System {
+                        username: &user.username,
+                        avatar: user.avatar.as_ref().map(|file| file.id.as_ref()),
+                    },
+                    self,
+                    false,
+                )
                 .await
-                .ok(); */
+                .ok();
+
+                EventV1::ChannelCreate(self.clone().into())
+                    .private(user.id.to_string())
+                    .await;
 
                 Ok(())
             }
@@ -238,7 +414,7 @@ impl Channel {
         }
     }
 
-    /// Get a reference to this channel's id
+    /// Clone this channel's id
     pub fn id(&self) -> String {
         match self {
             Channel::DirectMessage { id, .. }
@@ -293,7 +469,7 @@ impl Channel {
     }
 
     /// Update channel data
-    pub async fn update<'a>(
+    pub async fn update(
         &mut self,
         db: &Database,
         partial: PartialChannel,
@@ -305,8 +481,19 @@ impl Channel {
 
         self.apply_options(partial.clone());
 
-        db.update_channel(&self.id(), &partial, remove.clone())
-            .await?;
+        let id = self.id().to_string();
+        db.update_channel(&id, &partial, remove.clone()).await?;
+
+        EventV1::ChannelUpdate {
+            id: id.clone(),
+            data: partial.into(),
+            clear: remove.into_iter().map(|v| v.into()).collect(),
+        }
+        .p(match self {
+            Self::TextChannel { server, .. } | Self::VoiceChannel { server, .. } => server.clone(),
+            _ => id,
+        })
+        .await;
 
         Ok(())
     }
@@ -440,23 +627,46 @@ impl Channel {
         }
     }
 
+    /// Acknowledge a message
+    pub async fn ack(&self, user: &str, message: &str) -> Result<()> {
+        EventV1::ChannelAck {
+            id: self.id().to_string(),
+            user: user.to_string(),
+            message_id: message.to_string(),
+        }
+        .private(user.to_string())
+        .await;
+
+        crate::tasks::ack::queue(
+            self.id().to_string(),
+            user.to_string(),
+            AckEvent::AckMessage {
+                id: message.to_string(),
+            },
+        )
+        .await;
+
+        Ok(())
+    }
+
     /// Remove user from a group
     pub async fn remove_user_from_group(
         &self,
         db: &Database,
-        user_id: &str,
-        _by_id: Option<&str>,
+        user: &User,
+        by_id: Option<&str>,
         silent: bool,
     ) -> Result<()> {
         match &self {
             Channel::Group {
                 id,
+                name,
                 owner,
                 recipients,
                 ..
             } => {
-                if user_id == owner {
-                    if let Some(new_owner) = recipients.iter().find(|x| *x != user_id) {
+                if &user.id == owner {
+                    if let Some(new_owner) = recipients.iter().find(|x| *x != &user.id) {
                         db.update_channel(
                             id,
                             &PartialChannel {
@@ -467,42 +677,57 @@ impl Channel {
                         )
                         .await?;
 
-                        /* TODO: SystemMessage::ChannelOwnershipChanged {
+                        SystemMessage::ChannelOwnershipChanged {
                             from: owner.to_string(),
-                            to: new_owner.into(),
+                            to: new_owner.to_string(),
                         }
                         .into_message(id.to_string())
-                        .create(db, self, None)
+                        .send(
+                            db,
+                            MessageAuthor::System {
+                                username: name,
+                                avatar: None,
+                            },
+                            self,
+                            false,
+                        )
                         .await
-                        .ok(); */
+                        .ok();
                     } else {
-                        db.delete_channel(self).await?;
-                        return Ok(());
+                        return self.delete(db).await;
                     }
                 }
 
                 EventV1::ChannelGroupLeave {
                     id: id.to_string(),
-                    user: user_id.to_string(),
+                    user: user.id.to_string(),
                 }
                 .p(id.to_string())
                 .await;
 
                 if !silent {
-                    /* TODO: if let Some(_by) = by_id {
+                    if let Some(by) = by_id {
                         SystemMessage::UserRemove {
-                            id: user_id.to_string(),
+                            id: user.id.to_string(),
                             by: by.to_string(),
                         }
                     } else {
                         SystemMessage::UserLeft {
-                            id: user_id.to_string(),
+                            id: user.id.to_string(),
                         }
                     }
                     .into_message(id.to_string())
-                    .create(db, self, None)
+                    .send(
+                        db,
+                        MessageAuthor::System {
+                            username: &user.username,
+                            avatar: user.avatar.as_ref().map(|file| file.id.as_ref()),
+                        },
+                        self,
+                        false,
+                    )
                     .await
-                    .ok(); */
+                    .ok();
                 }
 
                 Ok(())
@@ -514,6 +739,11 @@ impl Channel {
 
     /// Delete a channel
     pub async fn delete(&self, db: &Database) -> Result<()> {
+        let id = self.id().to_string();
+        EventV1::ChannelDelete { id: id.clone() }.p(id).await;
+        // TODO: missing functionality:
+        // - group invites
+        // - channels list / categories list on server
         db.delete_channel(self).await
     }
 }
@@ -527,3 +757,62 @@ impl IntoDocumentPath for FieldsChannel {
         })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use revolt_permissions::{calculate_channel_permissions, ChannelPermission};
+
+    use crate::{fixture, util::permissions::DatabasePermissionQuery};
+
+    #[async_std::test]
+    async fn permissions_group_channel() {
+        database_test!(|db| async move {
+            fixture!(db, "group_with_members",
+                owner user 0
+                member1 user 1
+                member2 user 2
+                channel channel 3);
+
+            let mut query = DatabasePermissionQuery::new(&db, &owner).channel(&channel);
+            assert!(calculate_channel_permissions(&mut query)
+                .await
+                .has_channel_permission(ChannelPermission::SendMessage));
+
+            let mut query = DatabasePermissionQuery::new(&db, &member1).channel(&channel);
+            assert!(calculate_channel_permissions(&mut query)
+                .await
+                .has_channel_permission(ChannelPermission::SendMessage));
+
+            let mut query = DatabasePermissionQuery::new(&db, &member2).channel(&channel);
+            assert!(!calculate_channel_permissions(&mut query)
+                .await
+                .has_channel_permission(ChannelPermission::SendMessage));
+        });
+    }
+
+    #[async_std::test]
+    async fn permissions_text_channel() {
+        database_test!(|db| async move {
+            fixture!(db, "server_with_roles",
+                owner user 0
+                moderator user 1
+                user user 2
+                channel channel 3);
+
+            let mut query = DatabasePermissionQuery::new(&db, &owner).channel(&channel);
+            assert!(calculate_channel_permissions(&mut query)
+                .await
+                .has_channel_permission(ChannelPermission::SendMessage));
+
+            let mut query = DatabasePermissionQuery::new(&db, &moderator).channel(&channel);
+            assert!(calculate_channel_permissions(&mut query)
+                .await
+                .has_channel_permission(ChannelPermission::SendMessage));
+
+            let mut query = DatabasePermissionQuery::new(&db, &user).channel(&channel);
+            assert!(!calculate_channel_permissions(&mut query)
+                .await
+                .has_channel_permission(ChannelPermission::SendMessage));
+        });
+    }
+}

crates/core/database/src/models/channels/ops/mongodb.rs

@@ -1,6 +1,6 @@
 use super::AbstractChannels;
-use crate::{Channel, FieldsChannel, IntoDocumentPath, MongoDb, PartialChannel};
-use bson::Document;
+use crate::{AbstractServers, Channel, FieldsChannel, IntoDocumentPath, MongoDb, PartialChannel};
+use bson::{Bson, Document};
 use futures::StreamExt;
 use revolt_permissions::OverrideField;
 use revolt_result::Result;
@@ -188,6 +188,125 @@ impl AbstractChannels for MongoDb {
 
     // Delete a channel
     async fn delete_channel(&self, channel: &Channel) -> Result<()> {
+        let id = channel.id().to_string();
+        let server_id = match channel {
+            Channel::TextChannel { server, .. } | Channel::VoiceChannel { server, .. } => {
+                Some(server)
+            }
+            _ => None,
+        };
+
+        // Delete invites and unreads.
+        self.delete_associated_channel_objects(Bson::String(id.to_string()))
+            .await?;
+
+        // Delete messages.
+        self.delete_bulk_messages(doc! {
+            "channel": &id
+        })
+        .await?;
+
+        // Remove from server object.
+        if let Some(server) = server_id {
+            let server = self.fetch_server(server).await?;
+            let mut update = doc! {
+                "$pull": {
+                    "channels": &id
+                }
+            };
+
+            if let Some(sys) = &server.system_messages {
+                let mut unset = doc! {};
+
+                if let Some(cid) = &sys.user_joined {
+                    if &id == cid {
+                        unset.insert("system_messages.user_joined", 1_i32);
+                    }
+                }
+
+                if let Some(cid) = &sys.user_left {
+                    if &id == cid {
+                        unset.insert("system_messages.user_left", 1_i32);
+                    }
+                }
+
+                if let Some(cid) = &sys.user_kicked {
+                    if &id == cid {
+                        unset.insert("system_messages.user_kicked", 1_i32);
+                    }
+                }
+
+                if let Some(cid) = &sys.user_banned {
+                    if &id == cid {
+                        unset.insert("system_messages.user_banned", 1_i32);
+                    }
+                }
+
+                if !unset.is_empty() {
+                    update.insert("$unset", unset);
+                }
+            }
+
+            self.col::<Document>("servers")
+                .update_one(
+                    doc! {
+                        "_id": server.id
+                    },
+                    update,
+                    None,
+                )
+                .await
+                .map_err(|_| create_database_error!("update_one", "servers"))?;
+        }
+
+        // Delete associated attachments
+        self.delete_many_attachments(doc! {
+            "object_id": &id
+        })
+        .await?;
+
+        // Delete the channel itself
         query!(self, delete_one_by_id, COL, &channel.id()).map(|_| ())
     }
 }
+
+impl MongoDb {
+    pub async fn delete_associated_channel_objects(&self, id: Bson) -> Result<()> {
+        // Delete all invites to these channels.
+        self.col::<Document>("channel_invites")
+            .delete_many(
+                doc! {
+                    "channel": &id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| create_database_error!("delete_many", "channel_invites"))?;
+
+        // Delete unread message objects on channels.
+        self.col::<Document>("channel_unreads")
+            .delete_many(
+                doc! {
+                    "_id.channel": &id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| create_database_error!("delete_many", "channel_unreads"))
+            .map(|_| ())?;
+
+        // update many attachments with parent id
+
+        // Delete all webhooks on this channel.
+        self.col::<Document>("webhooks")
+            .delete_many(
+                doc! {
+                    "channel": &id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| create_database_error!("delete_many", "webhooks"))
+            .map(|_| ())
+    }
+}

crates/core/database/src/models/emojis/mod.rs

@@ -0,0 +1,5 @@
+mod model;
+mod ops;
+
+pub use model::*;
+pub use ops::*;

crates/core/database/src/models/emojis/model.rs

@@ -0,0 +1,87 @@
+use std::collections::HashSet;
+use std::str::FromStr;
+
+use once_cell::sync::Lazy;
+use revolt_result::Result;
+use ulid::Ulid;
+
+use crate::events::client::EventV1;
+use crate::Database;
+
+static PERMISSIBLE_EMOJIS: Lazy<HashSet<String>> = Lazy::new(|| {
+    include_str!("unicode_emoji.txt")
+        .split('\n')
+        .map(|x| x.into())
+        .collect()
+});
+
+auto_derived!(
+    /// Emoji
+    pub struct Emoji {
+        /// Unique Id
+        #[serde(rename = "_id")]
+        pub id: String,
+        /// What owns this emoji
+        pub parent: EmojiParent,
+        /// Uploader user id
+        pub creator_id: String,
+        /// Emoji name
+        pub name: String,
+        /// Whether the emoji is animated
+        #[serde(skip_serializing_if = "crate::if_false", default)]
+        pub animated: bool,
+        /// Whether the emoji is marked as nsfw
+        #[serde(skip_serializing_if = "crate::if_false", default)]
+        pub nsfw: bool,
+    }
+
+    /// Parent Id of the emoji
+    #[serde(tag = "type")]
+    pub enum EmojiParent {
+        Server { id: String },
+        Detached,
+    }
+);
+
+#[allow(clippy::disallowed_methods)]
+impl Emoji {
+    /// Get parent id
+    fn parent(&self) -> &str {
+        match &self.parent {
+            EmojiParent::Server { id } => id,
+            EmojiParent::Detached => "",
+        }
+    }
+
+    /// Create an emoji
+    pub async fn create(&self, db: &Database) -> Result<()> {
+        db.insert_emoji(self).await?;
+
+        EventV1::EmojiCreate(self.clone().into())
+            .p(self.parent().to_string())
+            .await;
+
+        Ok(())
+    }
+
+    /// Delete an emoji
+    pub async fn delete(self, db: &Database) -> Result<()> {
+        EventV1::EmojiDelete {
+            id: self.id.to_string(),
+        }
+        .p(self.parent().to_string())
+        .await;
+
+        db.detach_emoji(&self).await
+    }
+
+    /// Check whether we can use a given emoji
+    pub async fn can_use(db: &Database, emoji: &str) -> Result<bool> {
+        if Ulid::from_str(emoji).is_ok() {
+            db.fetch_emoji(emoji).await?;
+            Ok(true)
+        } else {
+            Ok(PERMISSIBLE_EMOJIS.contains(emoji))
+        }
+    }
+}

crates/core/database/src/models/emojis/ops.rs

@@ -0,0 +1,24 @@
+use revolt_result::Result;
+
+use crate::Emoji;
+
+mod mongodb;
+mod reference;
+
+#[async_trait]
+pub trait AbstractEmojis: Sync + Send {
+    /// Insert emoji into database.
+    async fn insert_emoji(&self, emoji: &Emoji) -> Result<()>;
+
+    /// Fetch an emoji by its id
+    async fn fetch_emoji(&self, id: &str) -> Result<Emoji>;
+
+    /// Fetch emoji by their parent id
+    async fn fetch_emoji_by_parent_id(&self, parent_id: &str) -> Result<Vec<Emoji>>;
+
+    /// Fetch emoji by their parent ids
+    async fn fetch_emoji_by_parent_ids(&self, parent_ids: &[String]) -> Result<Vec<Emoji>>;
+
+    /// Detach an emoji by its id
+    async fn detach_emoji(&self, emoji: &Emoji) -> Result<()>;
+}

crates/core/database/src/models/emojis/ops/mongodb.rs

@@ -0,0 +1,69 @@
+use bson::Document;
+use revolt_result::Result;
+
+use crate::Emoji;
+use crate::MongoDb;
+
+use super::AbstractEmojis;
+
+static COL: &str = "emojis";
+
+#[async_trait]
+impl AbstractEmojis for MongoDb {
+    /// Insert emoji into database.
+    async fn insert_emoji(&self, emoji: &Emoji) -> Result<()> {
+        query!(self, insert_one, COL, &emoji).map(|_| ())
+    }
+
+    /// Fetch an emoji by its id
+    async fn fetch_emoji(&self, id: &str) -> Result<Emoji> {
+        query!(self, find_one_by_id, COL, id)?.ok_or_else(|| create_error!(NotFound))
+    }
+
+    /// Fetch emoji by their parent id
+    async fn fetch_emoji_by_parent_id(&self, parent_id: &str) -> Result<Vec<Emoji>> {
+        query!(
+            self,
+            find,
+            COL,
+            doc! {
+                "parent.id": parent_id
+            }
+        )
+    }
+
+    /// Fetch emoji by their parent ids
+    async fn fetch_emoji_by_parent_ids(&self, parent_ids: &[String]) -> Result<Vec<Emoji>> {
+        query!(
+            self,
+            find,
+            COL,
+            doc! {
+                "parent.id": {
+                    "$in": parent_ids
+                }
+            }
+        )
+    }
+
+    /// Detach an emoji by its id
+    async fn detach_emoji(&self, emoji: &Emoji) -> Result<()> {
+        self.col::<Document>(COL)
+            .update_one(
+                doc! {
+                    "_id": &emoji.id
+                },
+                doc! {
+                    "$set": {
+                        "parent": {
+                            "type": "Detached"
+                        }
+                    }
+                },
+                None,
+            )
+            .await
+            .map(|_| ())
+            .map_err(|_| create_database_error!("update_one", COL))
+    }
+}

crates/core/database/src/models/emojis/ops/reference.rs

@@ -0,0 +1,67 @@
+use revolt_result::Result;
+
+use crate::Emoji;
+use crate::EmojiParent;
+use crate::ReferenceDb;
+
+use super::AbstractEmojis;
+
+#[async_trait]
+impl AbstractEmojis for ReferenceDb {
+    /// Insert emoji into database.
+    async fn insert_emoji(&self, emoji: &Emoji) -> Result<()> {
+        let mut emojis = self.emojis.lock().await;
+        if emojis.contains_key(&emoji.id) {
+            Err(create_database_error!("insert", "emoji"))
+        } else {
+            emojis.insert(emoji.id.to_string(), emoji.clone());
+            Ok(())
+        }
+    }
+
+    /// Fetch an emoji by its id
+    async fn fetch_emoji(&self, id: &str) -> Result<Emoji> {
+        let emojis = self.emojis.lock().await;
+        emojis
+            .get(id)
+            .cloned()
+            .ok_or_else(|| create_error!(NotFound))
+    }
+
+    /// Fetch emoji by their parent id
+    async fn fetch_emoji_by_parent_id(&self, parent_id: &str) -> Result<Vec<Emoji>> {
+        let emojis = self.emojis.lock().await;
+        Ok(emojis
+            .values()
+            .filter(|emoji| match &emoji.parent {
+                EmojiParent::Server { id } => id == parent_id,
+                _ => false,
+            })
+            .cloned()
+            .collect())
+    }
+
+    /// Fetch emoji by their parent ids
+    async fn fetch_emoji_by_parent_ids(&self, parent_ids: &[String]) -> Result<Vec<Emoji>> {
+        let emojis = self.emojis.lock().await;
+        Ok(emojis
+            .values()
+            .filter(|emoji| match &emoji.parent {
+                EmojiParent::Server { id } => parent_ids.contains(id),
+                _ => false,
+            })
+            .cloned()
+            .collect())
+    }
+
+    /// Detach an emoji by its id
+    async fn detach_emoji(&self, emoji: &Emoji) -> Result<()> {
+        let mut emojis = self.emojis.lock().await;
+        if let Some(bot) = emojis.get_mut(&emoji.id) {
+            bot.parent = EmojiParent::Detached;
+            Ok(())
+        } else {
+            Err(create_error!(NotFound))
+        }
+    }
+}

crates/core/database/src/models/files/ops/mongodb.rs

@@ -6,7 +6,7 @@ use crate::MongoDb;
 
 use super::AbstractAttachments;
 
-static COL: &str = "bots";
+static COL: &str = "attachments";
 
 #[async_trait]
 impl AbstractAttachments for MongoDb {
@@ -115,3 +115,21 @@ impl AbstractAttachments for MongoDb {
             .map_err(|_| create_database_error!("update_one", COL))
     }
 }
+
+impl MongoDb {
+    pub async fn delete_many_attachments(&self, projection: Document) -> Result<()> {
+        self.col::<Document>(COL)
+            .update_many(
+                projection,
+                doc! {
+                    "$set": {
+                        "deleted": true
+                    }
+                },
+                None,
+            )
+            .await
+            .map(|_| ())
+            .map_err(|_| create_database_error!("update_many", COL))
+    }
+}

crates/core/database/src/models/files/ops/reference.rs

@@ -22,15 +22,25 @@ impl AbstractAttachments for ReferenceDb {
     async fn find_and_use_attachment(
         &self,
         id: &str,
-        _tag: &str,
-        _parent_type: &str,
-        _parent_id: &str,
+        tag: &str,
+        parent_type: &str,
+        parent_id: &str,
     ) -> Result<File> {
         let mut files = self.files.lock().await;
         if let Some(file) = files.get_mut(id) {
-            // TODO: check tag
-            // TODO: set parent ID
-            Ok(file.clone())
+            if file.tag == tag {
+                match parent_type {
+                    "message" => file.message_id = Some(parent_id.to_owned()),
+                    "user" => file.user_id = Some(parent_id.to_owned()),
+                    "object" => file.object_id = Some(parent_id.to_owned()),
+                    "server" => file.server_id = Some(parent_id.to_owned()),
+                    _ => unreachable!(),
+                }
+
+                Ok(file.clone())
+            } else {
+                Err(create_error!(NotFound))
+            }
         } else {
             Err(create_error!(NotFound))
         }

crates/core/database/src/models/messages/mod.rs

@@ -0,0 +1,5 @@
+mod model;
+mod ops;
+
+pub use model::*;
+pub use ops::*;

crates/core/database/src/models/messages/model.rs

@@ -0,0 +1,787 @@
+use std::collections::HashSet;
+
+use indexmap::{IndexMap, IndexSet};
+use iso8601_timestamp::Timestamp;
+use revolt_config::config;
+use revolt_models::v0::{
+    self, BulkMessageResponse, DataMessageSend, Embed, MessageAuthor, MessageSort, MessageWebhook,
+    PushNotification, ReplyIntent, SendableEmbed, Text, RE_MENTION,
+};
+use revolt_permissions::{ChannelPermission, PermissionValue};
+use revolt_result::Result;
+use ulid::Ulid;
+use validator::Validate;
+
+use crate::{
+    events::client::EventV1,
+    tasks::{self, ack::AckEvent},
+    util::idempotency::IdempotencyKey,
+    Channel, Database, Emoji, File, User,
+};
+
+auto_derived_partial!(
+    /// Message
+    pub struct Message {
+        /// Unique Id
+        #[serde(rename = "_id")]
+        pub id: String,
+        /// Unique value generated by client sending this message
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub nonce: Option<String>,
+        /// Id of the channel this message was sent in
+        pub channel: String,
+        /// Id of the user or webhook that sent this message
+        pub author: String,
+        /// The webhook that sent this message
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub webhook: Option<MessageWebhook>,
+        /// Message content
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub content: Option<String>,
+        /// System message
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub system: Option<SystemMessage>,
+        /// Array of attachments
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub attachments: Option<Vec<File>>,
+        /// Time at which this message was last edited
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub edited: Option<Timestamp>,
+        /// Attached embeds to this message
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub embeds: Option<Vec<Embed>>,
+        /// Array of user ids mentioned in this message
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub mentions: Option<Vec<String>>,
+        /// Array of message ids this message is replying to
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub replies: Option<Vec<String>>,
+        /// Hashmap of emoji IDs to array of user IDs
+        #[serde(skip_serializing_if = "IndexMap::is_empty", default)]
+        pub reactions: IndexMap<String, IndexSet<String>>,
+        /// Information about how this message should be interacted with
+        #[serde(skip_serializing_if = "Interactions::is_default", default)]
+        pub interactions: Interactions,
+        /// Name and / or avatar overrides for this message
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub masquerade: Option<Masquerade>,
+    },
+    "PartialMessage"
+);
+
+auto_derived!(
+    /// System Event
+    #[serde(tag = "type")]
+    pub enum SystemMessage {
+        #[serde(rename = "text")]
+        Text { content: String },
+        #[serde(rename = "user_added")]
+        UserAdded { id: String, by: String },
+        #[serde(rename = "user_remove")]
+        UserRemove { id: String, by: String },
+        #[serde(rename = "user_joined")]
+        UserJoined { id: String },
+        #[serde(rename = "user_left")]
+        UserLeft { id: String },
+        #[serde(rename = "user_kicked")]
+        UserKicked { id: String },
+        #[serde(rename = "user_banned")]
+        UserBanned { id: String },
+        #[serde(rename = "channel_renamed")]
+        ChannelRenamed { name: String, by: String },
+        #[serde(rename = "channel_description_changed")]
+        ChannelDescriptionChanged { by: String },
+        #[serde(rename = "channel_icon_changed")]
+        ChannelIconChanged { by: String },
+        #[serde(rename = "channel_ownership_changed")]
+        ChannelOwnershipChanged { from: String, to: String },
+    }
+
+    /// Name and / or avatar override information
+    pub struct Masquerade {
+        /// Replace the display name shown on this message
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub name: Option<String>,
+        /// Replace the avatar shown on this message (URL to image file)
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub avatar: Option<String>,
+        /// Replace the display role colour shown on this message
+        ///
+        /// Must have `ManageRole` permission to use
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub colour: Option<String>,
+    }
+
+    /// Information to guide interactions on this message
+    #[derive(Default)]
+    pub struct Interactions {
+        /// Reactions which should always appear and be distinct
+        #[serde(skip_serializing_if = "Option::is_none", default)]
+        pub reactions: Option<IndexSet<String>>,
+        /// Whether reactions should be restricted to the given list
+        ///
+        /// Can only be set to true if reactions list is of at least length 1
+        #[serde(skip_serializing_if = "crate::if_false", default)]
+        pub restrict_reactions: bool,
+    }
+
+    /// Appended Information
+    pub struct AppendMessage {
+        /// Additional embeds to include in this message
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub embeds: Option<Vec<Embed>>,
+    }
+
+    /// Message Time Period
+    ///
+    /// Filter and sort messages by time
+    #[serde(untagged)]
+    pub enum MessageTimePeriod {
+        Relative {
+            /// Message id to search around
+            ///
+            /// Specifying 'nearby' ignores 'before', 'after' and 'sort'.
+            /// It will also take half of limit rounded as the limits to each side.
+            /// It also fetches the message ID specified.
+            nearby: String,
+        },
+        Absolute {
+            /// Message id before which messages should be fetched
+            before: Option<String>,
+            /// Message id after which messages should be fetched
+            after: Option<String>,
+            /// Message sort direction
+            sort: Option<MessageSort>,
+        },
+    }
+
+    /// Message Filter
+    #[derive(Default)]
+    pub struct MessageFilter {
+        /// Parent channel ID
+        pub channel: Option<String>,
+        /// Message author ID
+        pub author: Option<String>,
+        /// Search query
+        pub query: Option<String>,
+    }
+
+    /// Message Query
+    pub struct MessageQuery {
+        /// Maximum number of messages to fetch
+        ///
+        /// For fetching nearby messages, this is \`(limit + 1)\`.
+        pub limit: Option<i64>,
+        /// Filter to apply
+        #[serde(flatten)]
+        pub filter: MessageFilter,
+        /// Time period to fetch
+        #[serde(flatten)]
+        pub time_period: MessageTimePeriod,
+    }
+);
+
+#[allow(clippy::derivable_impls)]
+impl Default for Message {
+    fn default() -> Self {
+        Self {
+            id: Default::default(),
+            nonce: None,
+            channel: Default::default(),
+            author: Default::default(),
+            webhook: None,
+            content: None,
+            system: None,
+            attachments: None,
+            edited: None,
+            embeds: None,
+            mentions: None,
+            replies: None,
+            reactions: Default::default(),
+            interactions: Default::default(),
+            masquerade: None,
+        }
+    }
+}
+
+#[allow(clippy::disallowed_methods)]
+impl Message {
+    /// Create message from API data
+    pub async fn create_from_api(
+        db: &Database,
+        channel: Channel,
+        data: DataMessageSend,
+        author: MessageAuthor<'_>,
+        mut idempotency: IdempotencyKey,
+        generate_embeds: bool,
+        allow_mentions: bool,
+    ) -> Result<Message> {
+        let config = config().await;
+
+        Message::validate_sum(
+            &data.content,
+            data.embeds.as_deref().unwrap_or_default(),
+            config.features.limits.default.message_length,
+        )?;
+
+        idempotency
+            .consume_nonce(data.nonce)
+            .await
+            .map_err(|_| create_error!(InvalidOperation))?;
+
+        // Check the message is not empty
+        if (data.content.as_ref().map_or(true, |v| v.is_empty()))
+            && (data.attachments.as_ref().map_or(true, |v| v.is_empty()))
+            && (data.embeds.as_ref().map_or(true, |v| v.is_empty()))
+        {
+            return Err(create_error!(EmptyMessage));
+        }
+
+        // Ensure restrict_reactions is not specified without reactions list
+        if let Some(interactions) = &data.interactions {
+            if interactions.restrict_reactions {
+                let disallowed = if let Some(list) = &interactions.reactions {
+                    list.is_empty()
+                } else {
+                    true
+                };
+
+                if disallowed {
+                    return Err(create_error!(InvalidProperty));
+                }
+            }
+        }
+
+        let (author_id, webhook) = match &author {
+            MessageAuthor::User(user) => (user.id.clone(), None),
+            MessageAuthor::Webhook(webhook) => (webhook.id.clone(), Some((*webhook).clone())),
+            MessageAuthor::System { .. } => ("00000000000000000000000000".to_string(), None),
+        };
+
+        // Start constructing the message
+        let message_id = Ulid::new().to_string();
+        let mut message = Message {
+            id: message_id.clone(),
+            channel: channel.id(),
+            masquerade: data.masquerade.map(|masquerade| masquerade.into()),
+            interactions: data
+                .interactions
+                .map(|interactions| interactions.into())
+                .unwrap_or_default(),
+            author: author_id,
+            webhook: webhook.map(|w| w.into()),
+            ..Default::default()
+        };
+
+        // Parse mentions in message.
+        let mut mentions = HashSet::new();
+        if allow_mentions {
+            if let Some(content) = &data.content {
+                for capture in RE_MENTION.captures_iter(content) {
+                    if let Some(mention) = capture.get(1) {
+                        mentions.insert(mention.as_str().to_string());
+                    }
+                }
+            }
+        }
+
+        // Verify replies are valid.
+        let mut replies = HashSet::new();
+        if let Some(entries) = data.replies {
+            if entries.len() > config.features.limits.default.message_replies {
+                return Err(create_error!(TooManyReplies {
+                    max: config.features.limits.default.message_replies,
+                }));
+            }
+
+            for ReplyIntent { id, mention } in entries {
+                let message = db.fetch_message(&id).await?;
+
+                if mention && allow_mentions {
+                    mentions.insert(message.author.to_owned());
+                }
+
+                replies.insert(message.id);
+            }
+        }
+
+        if !mentions.is_empty() {
+            message.mentions.replace(mentions.into_iter().collect());
+        }
+
+        if !replies.is_empty() {
+            message
+                .replies
+                .replace(replies.into_iter().collect::<Vec<String>>());
+        }
+
+        // Add attachments to message.
+        let mut attachments = vec![];
+        if data
+            .attachments
+            .as_ref()
+            .is_some_and(|v| v.len() > config.features.limits.default.message_attachments)
+        {
+            return Err(create_error!(TooManyAttachments {
+                max: config.features.limits.default.message_attachments,
+            }));
+        }
+
+        if data
+            .embeds
+            .as_ref()
+            .is_some_and(|v| v.len() > config.features.limits.default.message_embeds)
+        {
+            return Err(create_error!(TooManyEmbeds {
+                max: config.features.limits.default.message_embeds,
+            }));
+        }
+
+        for attachment_id in data.attachments.as_deref().unwrap_or_default() {
+            attachments.push(
+                db.find_and_use_attachment(attachment_id, "attachments", "message", &message_id)
+                    .await?,
+            );
+        }
+
+        if !attachments.is_empty() {
+            message.attachments.replace(attachments);
+        }
+
+        // Process included embeds.
+        for sendable_embed in data.embeds.unwrap_or_default() {
+            message.attach_sendable_embed(db, sendable_embed).await?;
+        }
+
+        // Set content
+        message.content = data.content;
+
+        // Pass-through nonce value for clients
+        message.nonce = Some(idempotency.into_key());
+
+        // Send the message
+        message.send(db, author, &channel, generate_embeds).await?;
+
+        Ok(message)
+    }
+
+    /// Send a message without any notifications
+    pub async fn send_without_notifications(
+        &mut self,
+        db: &Database,
+        is_dm: bool,
+        generate_embeds: bool,
+    ) -> Result<()> {
+        db.insert_message(self).await?;
+
+        // Fan out events
+        EventV1::Message(self.clone().into())
+            .p(self.channel.to_string())
+            .await;
+
+        // Update last_message_id
+        tasks::last_message_id::queue(self.channel.to_string(), self.id.to_string(), is_dm).await;
+
+        // Add mentions for affected users
+        if let Some(mentions) = &self.mentions {
+            for user in mentions {
+                tasks::ack::queue(
+                    self.channel.to_string(),
+                    user.to_string(),
+                    AckEvent::AddMention {
+                        ids: vec![self.id.to_string()],
+                    },
+                )
+                .await;
+            }
+        }
+
+        // Generate embeds
+        if generate_embeds {
+            if let Some(content) = &self.content {
+                tasks::process_embeds::queue(
+                    self.channel.to_string(),
+                    self.id.to_string(),
+                    content.clone(),
+                )
+                .await;
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Send a message
+    pub async fn send(
+        &mut self,
+        db: &Database,
+        author: MessageAuthor<'_>,
+        channel: &Channel,
+        generate_embeds: bool,
+    ) -> Result<()> {
+        self.send_without_notifications(
+            db,
+            matches!(channel, Channel::DirectMessage { .. }),
+            generate_embeds,
+        )
+        .await?;
+
+        // Push out Web Push notifications
+        crate::tasks::web_push::queue(
+            {
+                match channel {
+                    Channel::DirectMessage { recipients, .. }
+                    | Channel::Group { recipients, .. } => recipients.clone(),
+                    Channel::TextChannel { .. } => self.mentions.clone().unwrap_or_default(),
+                    _ => vec![],
+                }
+            },
+            PushNotification::from(self.clone().into(), Some(author), &channel.id()).await,
+        )
+        .await;
+
+        Ok(())
+    }
+
+    /// Create text embed from sendable embed
+    pub async fn create_embed(&self, db: &Database, embed: SendableEmbed) -> Result<Embed> {
+        embed.validate().map_err(|error| {
+            create_error!(FailedValidation {
+                error: error.to_string()
+            })
+        })?;
+
+        let media = if let Some(id) = embed.media {
+            Some(
+                db.find_and_use_attachment(&id, "attachments", "message", &self.id)
+                    .await?,
+            )
+        } else {
+            None
+        };
+
+        Ok(Embed::Text(Text {
+            icon_url: embed.icon_url,
+            url: embed.url,
+            title: embed.title,
+            description: embed.description,
+            media: media.map(|m| m.into()),
+            colour: embed.colour,
+        }))
+    }
+
+    /// Update message data
+    pub async fn update(&mut self, db: &Database, partial: PartialMessage) -> Result<()> {
+        self.apply_options(partial.clone());
+        db.update_message(&self.id, &partial).await?;
+
+        EventV1::MessageUpdate {
+            id: self.id.clone(),
+            channel: self.channel.clone(),
+            data: partial.into(),
+        }
+        .p(self.channel.clone())
+        .await;
+
+        Ok(())
+    }
+
+    /// Helper function to fetch many messages with users
+    pub async fn fetch_with_users(
+        db: &Database,
+        query: MessageQuery,
+        perspective: &User,
+        include_users: Option<bool>,
+        server_id: Option<String>,
+    ) -> Result<BulkMessageResponse> {
+        let messages: Vec<v0::Message> = db
+            .fetch_messages(query)
+            .await?
+            .into_iter()
+            .map(Into::into)
+            .collect();
+
+        if let Some(true) = include_users {
+            let user_ids = messages
+                .iter()
+                .map(|m| m.author.clone())
+                .collect::<HashSet<String>>()
+                .into_iter()
+                .collect::<Vec<String>>();
+            let users = User::fetch_many_ids_as_mutuals(db, perspective, &user_ids).await?;
+
+            Ok(BulkMessageResponse::MessagesAndUsers {
+                messages,
+                users,
+                members: if let Some(server_id) = server_id {
+                    Some(
+                        db.fetch_members(&server_id, &user_ids)
+                            .await?
+                            .into_iter()
+                            .map(Into::into)
+                            .collect(),
+                    )
+                } else {
+                    None
+                },
+            })
+        } else {
+            Ok(BulkMessageResponse::JustMessages(messages))
+        }
+    }
+
+    /// Append content to message
+    pub async fn append(
+        db: &Database,
+        id: String,
+        channel: String,
+        append: AppendMessage,
+    ) -> Result<()> {
+        db.append_message(&id, &append).await?;
+
+        EventV1::MessageAppend {
+            id,
+            channel: channel.to_string(),
+            append: append.into(),
+        }
+        .p(channel)
+        .await;
+
+        Ok(())
+    }
+
+    /// Convert sendable embed to text embed and attach to message
+    pub async fn attach_sendable_embed(
+        &mut self,
+        db: &Database,
+        embed: v0::SendableEmbed,
+    ) -> Result<()> {
+        let media: Option<v0::File> = if let Some(id) = embed.media {
+            Some(
+                db.find_and_use_attachment(&id, "attachments", "message", &self.id)
+                    .await?
+                    .into(),
+            )
+        } else {
+            None
+        };
+
+        let embed = v0::Embed::Text(v0::Text {
+            icon_url: embed.icon_url,
+            url: embed.url,
+            title: embed.title,
+            description: embed.description,
+            media,
+            colour: embed.colour,
+        });
+
+        if let Some(embeds) = &mut self.embeds {
+            embeds.push(embed);
+        } else {
+            self.embeds = Some(vec![embed]);
+        }
+
+        Ok(())
+    }
+
+    /// Add a reaction to a message
+    pub async fn add_reaction(&self, db: &Database, user: &User, emoji: &str) -> Result<()> {
+        // Check how many reactions are already on the message
+        let config = config().await;
+        if self.reactions.len() >= config.features.limits.default.message_reactions
+            && !self.reactions.contains_key(emoji)
+        {
+            return Err(create_error!(InvalidOperation));
+        }
+
+        // Check if the emoji is whitelisted
+        if !self.interactions.can_use(emoji) {
+            return Err(create_error!(InvalidOperation));
+        }
+
+        // Check if the emoji is usable by us
+        if !Emoji::can_use(db, emoji).await? {
+            return Err(create_error!(InvalidOperation));
+        }
+
+        // Send reaction event
+        EventV1::MessageReact {
+            id: self.id.to_string(),
+            channel_id: self.channel.to_string(),
+            user_id: user.id.to_string(),
+            emoji_id: emoji.to_string(),
+        }
+        .p(self.channel.to_string())
+        .await;
+
+        // Add emoji
+        db.add_reaction(&self.id, emoji, &user.id).await
+    }
+
+    /// Validate the sum of content of a message is under threshold
+    pub fn validate_sum(
+        content: &Option<String>,
+        embeds: &[SendableEmbed],
+        max_length: usize,
+    ) -> Result<()> {
+        let mut running_total = 0;
+        if let Some(content) = content {
+            running_total += content.len();
+        }
+
+        for embed in embeds {
+            if let Some(desc) = &embed.description {
+                running_total += desc.len();
+            }
+        }
+
+        if running_total <= max_length {
+            Ok(())
+        } else {
+            Err(create_error!(PayloadTooLarge))
+        }
+    }
+
+    /// Delete a message
+    pub async fn delete(self, db: &Database) -> Result<()> {
+        let file_ids: Vec<String> = self
+            .attachments
+            .map(|files| files.iter().map(|file| file.id.to_string()).collect())
+            .unwrap_or_default();
+
+        if !file_ids.is_empty() {
+            db.mark_attachments_as_deleted(&file_ids).await?;
+        }
+
+        db.delete_message(&self.id).await?;
+
+        EventV1::MessageDelete {
+            id: self.id,
+            channel: self.channel.clone(),
+        }
+        .p(self.channel)
+        .await;
+        Ok(())
+    }
+
+    /// Bulk delete messages
+    pub async fn bulk_delete(db: &Database, channel: &str, ids: Vec<String>) -> Result<()> {
+        let valid_ids = db
+            .fetch_messages_by_id(&ids)
+            .await?
+            .into_iter()
+            .filter(|msg| msg.channel == channel)
+            .map(|msg| msg.id)
+            .collect::<Vec<String>>();
+
+        db.delete_messages(channel, &valid_ids).await?;
+        EventV1::BulkMessageDelete {
+            channel: channel.to_string(),
+            ids: valid_ids,
+        }
+        .p(channel.to_string())
+        .await;
+        Ok(())
+    }
+
+    /// Remove a reaction from a message
+    pub async fn remove_reaction(&self, db: &Database, user: &str, emoji: &str) -> Result<()> {
+        // Check if it actually exists
+        let empty = if let Some(users) = self.reactions.get(emoji) {
+            if !users.contains(user) {
+                return Err(create_error!(NotFound));
+            }
+
+            users.len() == 1
+        } else {
+            return Err(create_error!(NotFound));
+        };
+
+        // Send reaction event
+        EventV1::MessageUnreact {
+            id: self.id.to_string(),
+            channel_id: self.channel.to_string(),
+            user_id: user.to_string(),
+            emoji_id: emoji.to_string(),
+        }
+        .p(self.channel.to_string())
+        .await;
+
+        if empty {
+            // If empty, remove the reaction entirely
+            db.clear_reaction(&self.id, emoji).await
+        } else {
+            // Otherwise only remove that one reaction
+            db.remove_reaction(&self.id, emoji, user).await
+        }
+    }
+
+    /// Remove a reaction from a message
+    pub async fn clear_reaction(&self, db: &Database, emoji: &str) -> Result<()> {
+        // Send reaction event
+        EventV1::MessageRemoveReaction {
+            id: self.id.to_string(),
+            channel_id: self.channel.to_string(),
+            emoji_id: emoji.to_string(),
+        }
+        .p(self.channel.to_string())
+        .await;
+
+        // Write to database
+        db.clear_reaction(&self.id, emoji).await
+    }
+}
+
+impl SystemMessage {
+    pub fn into_message(self, channel: String) -> Message {
+        Message {
+            id: Ulid::new().to_string(),
+            channel,
+            author: "00000000000000000000000000".to_string(),
+            system: Some(self),
+
+            ..Default::default()
+        }
+    }
+}
+
+impl Interactions {
+    /// Validate interactions info is correct
+    pub async fn validate(&self, db: &Database, permissions: &PermissionValue) -> Result<()> {
+        let config = config().await;
+
+        if let Some(reactions) = &self.reactions {
+            permissions.throw_if_lacking_channel_permission(ChannelPermission::React)?;
+
+            if reactions.len() > config.features.limits.default.message_reactions {
+                return Err(create_error!(InvalidOperation));
+            }
+
+            for reaction in reactions {
+                if !Emoji::can_use(db, reaction).await? {
+                    return Err(create_error!(InvalidOperation));
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Check if we can use a given emoji to react
+    pub fn can_use(&self, emoji: &str) -> bool {
+        if self.restrict_reactions {
+            if let Some(reactions) = &self.reactions {
+                reactions.contains(emoji)
+            } else {
+                false
+            }
+        } else {
+            true
+        }
+    }
+
+    /// Check if default initialisation of fields
+    pub fn is_default(&self) -> bool {
+        !self.restrict_reactions && self.reactions.is_none()
+    }
+}

crates/core/database/src/models/messages/ops.rs

@@ -0,0 +1,42 @@
+use revolt_result::Result;
+
+use crate::{AppendMessage, Message, MessageQuery, PartialMessage};
+
+mod mongodb;
+mod reference;
+
+#[async_trait]
+pub trait AbstractMessages: Sync + Send {
+    /// Insert a new message into the database
+    async fn insert_message(&self, message: &Message) -> Result<()>;
+
+    /// Fetch a message by its id
+    async fn fetch_message(&self, id: &str) -> Result<Message>;
+
+    /// Fetch multiple messages by given query
+    async fn fetch_messages(&self, query: MessageQuery) -> Result<Vec<Message>>;
+
+    /// Fetch multiple messages by given IDs
+    async fn fetch_messages_by_id(&self, ids: &[String]) -> Result<Vec<Message>>;
+
+    /// Update a given message with new information
+    async fn update_message(&self, id: &str, message: &PartialMessage) -> Result<()>;
+
+    /// Append information to a given message
+    async fn append_message(&self, id: &str, append: &AppendMessage) -> Result<()>;
+
+    /// Add a new reaction to a message
+    async fn add_reaction(&self, id: &str, emoji: &str, user: &str) -> Result<()>;
+
+    /// Remove a reaction from a message
+    async fn remove_reaction(&self, id: &str, emoji: &str, user: &str) -> Result<()>;
+
+    /// Remove reaction from a message
+    async fn clear_reaction(&self, id: &str, emoji: &str) -> Result<()>;
+
+    /// Delete a message from the database by its id
+    async fn delete_message(&self, id: &str) -> Result<()>;
+
+    /// Delete messages from a channel by their ids and corresponding channel id
+    async fn delete_messages(&self, channel: &str, ids: &[String]) -> Result<()>;
+}

crates/core/database/src/models/messages/ops/mongodb.rs

@@ -0,0 +1,351 @@
+use bson::{to_bson, Document};
+use futures::try_join;
+use mongodb::options::FindOptions;
+use revolt_models::v0::MessageSort;
+use revolt_result::Result;
+
+use crate::{
+    AppendMessage, DocumentId, Message, MessageQuery, MessageTimePeriod, MongoDb, PartialMessage,
+};
+
+use super::AbstractMessages;
+
+static COL: &str = "messages";
+
+#[async_trait]
+impl AbstractMessages for MongoDb {
+    /// Insert a new message into the database
+    async fn insert_message(&self, message: &Message) -> Result<()> {
+        query!(self, insert_one, COL, &message).map(|_| ())
+    }
+
+    /// Fetch a message by its id
+    async fn fetch_message(&self, id: &str) -> Result<Message> {
+        query!(self, find_one_by_id, COL, id)?.ok_or_else(|| create_error!(NotFound))
+    }
+
+    /// Fetch multiple messages by given query
+    async fn fetch_messages(&self, query: MessageQuery) -> Result<Vec<Message>> {
+        let mut filter = doc! {};
+
+        // 1. Apply message filters
+        if let Some(channel) = query.filter.channel {
+            filter.insert("channel", channel);
+        }
+
+        if let Some(author) = query.filter.author {
+            filter.insert("author", author);
+        }
+
+        let is_search_query = if let Some(query) = query.filter.query {
+            filter.insert(
+                "$text",
+                doc! {
+                    "$search": query
+                },
+            );
+
+            true
+        } else {
+            false
+        };
+
+        // 2. Find query limit
+        let limit = query.limit.unwrap_or(50);
+
+        // 3. Apply message time period
+        match query.time_period {
+            MessageTimePeriod::Relative { nearby } => {
+                // 3.1. Prepare filters
+                let mut older_message_filter = filter.clone();
+                let mut newer_message_filter = filter;
+
+                older_message_filter.insert(
+                    "_id",
+                    doc! {
+                        "$lt": &nearby
+                    },
+                );
+
+                newer_message_filter.insert(
+                    "_id",
+                    doc! {
+                        "$gte": &nearby
+                    },
+                );
+
+                // 3.2. Execute in both directions
+                let (a, b) = try_join!(
+                    self.find_with_options::<_, Message>(
+                        COL,
+                        newer_message_filter,
+                        FindOptions::builder()
+                            .limit(limit / 2 + 1)
+                            .sort(doc! {
+                                "_id": 1_i32
+                            })
+                            .build(),
+                    ),
+                    self.find_with_options::<_, Message>(
+                        COL,
+                        older_message_filter,
+                        FindOptions::builder()
+                            .limit(limit / 2)
+                            .sort(doc! {
+                                "_id": -1_i32
+                            })
+                            .build(),
+                    )
+                )
+                .map_err(|_| create_database_error!("find", COL))?;
+
+                Ok([a, b].concat())
+            }
+            MessageTimePeriod::Absolute {
+                before,
+                after,
+                sort,
+            } => {
+                // 3.1. Apply message ID filter
+                if let Some(doc) = match (before, after) {
+                    (Some(before), Some(after)) => Some(doc! {
+                        "$lt": before,
+                        "$gt": after
+                    }),
+                    (Some(before), _) => Some(doc! {
+                        "$lt": before
+                    }),
+                    (_, Some(after)) => Some(doc! {
+                        "$gt": after
+                    }),
+                    _ => None,
+                } {
+                    filter.insert("_id", doc);
+                }
+
+                // 3.2. Execute with given message sort
+                self.find_with_options(
+                    COL,
+                    filter,
+                    FindOptions::builder()
+                        .limit(limit)
+                        .sort(match sort.unwrap_or(MessageSort::Latest) {
+                            // Sort by relevance, fallback to latest
+                            MessageSort::Relevance => {
+                                if is_search_query {
+                                    doc! {
+                                        "score": {
+                                            "$meta": "textScore"
+                                        }
+                                    }
+                                } else {
+                                    doc! {
+                                        "_id": -1_i32
+                                    }
+                                }
+                            }
+                            // Sort by latest first
+                            MessageSort::Latest => doc! {
+                                "_id": -1_i32
+                            },
+                            // Sort by oldest first
+                            MessageSort::Oldest => doc! {
+                                "_id": 1_i32
+                            },
+                        })
+                        .build(),
+                )
+                .await
+                .map_err(|_| create_database_error!("find", COL))
+            }
+        }
+    }
+
+    /// Fetch multiple messages by given IDs
+    async fn fetch_messages_by_id(&self, ids: &[String]) -> Result<Vec<Message>> {
+        self.find_with_options(
+            COL,
+            doc! {
+                "ids": {
+                    "$in": ids
+                }
+            },
+            None,
+        )
+        .await
+        .map_err(|_| create_database_error!("find", COL))
+    }
+
+    /// Update a given message with new information
+    async fn update_message(&self, id: &str, message: &PartialMessage) -> Result<()> {
+        query!(self, update_one_by_id, COL, id, message, vec![], None).map(|_| ())
+    }
+
+    /// Append information to a given message
+    async fn append_message(&self, id: &str, append: &AppendMessage) -> Result<()> {
+        let mut query = doc! {};
+
+        if let Some(embeds) = &append.embeds {
+            if !embeds.is_empty() {
+                query.insert(
+                    "$push",
+                    doc! {
+                        "embeds": {
+                            "$each": to_bson(embeds)
+                                .map_err(|_| create_database_error!("to_bson", "embeds"))?
+                        }
+                    },
+                );
+            }
+        }
+
+        if query.is_empty() {
+            return Ok(());
+        }
+
+        self.col::<Document>(COL)
+            .update_one(
+                doc! {
+                    "_id": id
+                },
+                query,
+                None,
+            )
+            .await
+            .map(|_| ())
+            .map_err(|_| create_database_error!("update_one", COL))
+    }
+
+    /// Add a new reaction to a message
+    async fn add_reaction(&self, id: &str, emoji: &str, user: &str) -> Result<()> {
+        self.col::<Document>(COL)
+            .update_one(
+                doc! {
+                    "_id": id
+                },
+                doc! {
+                    "$addToSet": {
+                        format!("reactions.{emoji}"): user
+                    }
+                },
+                None,
+            )
+            .await
+            .map(|_| ())
+            .map_err(|_| create_database_error!("update_one", COL))
+    }
+
+    /// Remove a reaction from a message
+    async fn remove_reaction(&self, id: &str, emoji: &str, user: &str) -> Result<()> {
+        self.col::<Document>(COL)
+            .update_one(
+                doc! {
+                    "_id": id
+                },
+                doc! {
+                    "$pull": {
+                        format!("reactions.{emoji}"): user
+                    }
+                },
+                None,
+            )
+            .await
+            .map(|_| ())
+            .map_err(|_| create_database_error!("update_one", COL))
+    }
+
+    /// Remove reaction from a message
+    async fn clear_reaction(&self, id: &str, emoji: &str) -> Result<()> {
+        self.col::<Document>(COL)
+            .update_one(
+                doc! {
+                    "_id": id
+                },
+                doc! {
+                    "$unset": {
+                        format!("reactions.{emoji}"): 1
+                    }
+                },
+                None,
+            )
+            .await
+            .map(|_| ())
+            .map_err(|_| create_database_error!("update_one", COL))
+    }
+
+    /// Delete a message from the database by its id
+    async fn delete_message(&self, id: &str) -> Result<()> {
+        query!(self, delete_one_by_id, COL, id).map(|_| ())
+    }
+
+    /// Delete messages from a channel by their ids and corresponding channel id
+    async fn delete_messages(&self, channel: &str, ids: &[String]) -> Result<()> {
+        self.col::<Document>(COL)
+            .delete_many(
+                doc! {
+                    "channel": channel,
+                    "_id": {
+                        "$in": ids
+                    }
+                },
+                None,
+            )
+            .await
+            .map(|_| ())
+            .map_err(|_| create_database_error!("delete_many", COL))
+    }
+}
+
+impl MongoDb {
+    pub async fn delete_bulk_messages(&self, projection: Document) -> Result<()> {
+        let mut for_attachments = projection.clone();
+        for_attachments.insert(
+            "attachments",
+            doc! {
+                "$exists": 1_i32
+            },
+        );
+
+        // Check if there are any attachments we need to delete.
+        let message_ids_with_attachments = self
+            .find_with_options::<_, DocumentId>(
+                COL,
+                for_attachments,
+                FindOptions::builder()
+                    .projection(doc! { "_id": 1_i32 })
+                    .build(),
+            )
+            .await
+            .map_err(|_| create_database_error!("find_many", "attachments"))?
+            .into_iter()
+            .map(|x| x.id)
+            .collect::<Vec<String>>();
+
+        // If we found any, mark them as deleted.
+        if !message_ids_with_attachments.is_empty() {
+            self.col::<Document>("attachments")
+                .update_many(
+                    doc! {
+                        "message_id": {
+                            "$in": message_ids_with_attachments
+                        }
+                    },
+                    doc! {
+                        "$set": {
+                            "deleted": true
+                        }
+                    },
+                    None,
+                )
+                .await
+                .map_err(|_| create_database_error!("update_many", "attachments"))?;
+        }
+
+        // And then delete said messages.
+        self.col::<Document>(COL)
+            .delete_many(projection, None)
+            .await
+            .map(|_| ())
+            .map_err(|_| create_database_error!("delete_many", COL))
+    }
+}

crates/core/database/src/models/messages/ops/reference.rs

@@ -0,0 +1,278 @@
+use futures::future::try_join_all;
+use indexmap::IndexSet;
+use revolt_result::Result;
+
+use crate::{AppendMessage, Message, MessageQuery, PartialMessage, ReferenceDb};
+
+use super::AbstractMessages;
+
+#[async_trait]
+impl AbstractMessages for ReferenceDb {
+    /// Insert a new message into the database
+    async fn insert_message(&self, message: &Message) -> Result<()> {
+        let mut messages = self.messages.lock().await;
+        if messages.contains_key(&message.id) {
+            Err(create_database_error!("insert", "message"))
+        } else {
+            messages.insert(message.id.to_string(), message.clone());
+            Ok(())
+        }
+    }
+
+    /// Fetch a message by its id
+    async fn fetch_message(&self, id: &str) -> Result<Message> {
+        let messages = self.messages.lock().await;
+        messages
+            .get(id)
+            .cloned()
+            .ok_or_else(|| create_error!(NotFound))
+    }
+
+    /// Fetch multiple messages by given query
+    async fn fetch_messages(&self, query: MessageQuery) -> Result<Vec<Message>> {
+        let messages = self.messages.lock().await;
+        let matched_messages = messages
+            .values()
+            .filter(|message| {
+                if let Some(channel) = &query.filter.channel {
+                    if &message.channel != channel {
+                        return false;
+                    }
+                }
+
+                if let Some(author) = &query.filter.author {
+                    if &message.author != author {
+                        return false;
+                    }
+                }
+
+                if let Some(query) = &query.filter.query {
+                    if let Some(content) = &message.content {
+                        if !content.to_lowercase().contains(query) {
+                            return false;
+                        }
+                    } else {
+                        return false;
+                    }
+                }
+
+                true
+            })
+            .cloned()
+            .collect();
+
+        // FIXME: sorting, etc (will be required for tests)
+
+        Ok(matched_messages)
+
+        /*
+        // 2. Find query limit
+        let limit = query.limit.unwrap_or(50);
+
+        // 3. Apply message time period
+        match query.time_period {
+            MessageTimePeriod::Relative { nearby } => {
+                // 3.1. Prepare filters
+                let mut older_message_filter = filter.clone();
+                let mut newer_message_filter = filter;
+
+                older_message_filter.insert(
+                    "_id",
+                    doc! {
+                        "$lt": &nearby
+                    },
+                );
+
+                newer_message_filter.insert(
+                    "_id",
+                    doc! {
+                        "$gte": &nearby
+                    },
+                );
+
+                // 3.2. Execute in both directions
+                let (a, b) = try_join!(
+                    self.find_with_options::<_, Message>(
+                        COL,
+                        newer_message_filter,
+                        FindOptions::builder()
+                            .limit(limit / 2 + 1)
+                            .sort(doc! {
+                                "_id": 1_i32
+                            })
+                            .build(),
+                    ),
+                    self.find_with_options::<_, Message>(
+                        COL,
+                        older_message_filter,
+                        FindOptions::builder()
+                            .limit(limit / 2)
+                            .sort(doc! {
+                                "_id": -1_i32
+                            })
+                            .build(),
+                    )
+                )
+                .map_err(|_| create_database_error!("find", COL))?;
+
+                Ok([a, b].concat())
+            }
+            MessageTimePeriod::Absolute {
+                before,
+                after,
+                sort,
+            } => {
+                // 3.1. Apply message ID filter
+                if let Some(doc) = match (before, after) {
+                    (Some(before), Some(after)) => Some(doc! {
+                        "$lt": before,
+                        "$gt": after
+                    }),
+                    (Some(before), _) => Some(doc! {
+                        "$lt": before
+                    }),
+                    (_, Some(after)) => Some(doc! {
+                        "$gt": after
+                    }),
+                    _ => None,
+                } {
+                    filter.insert("_id", doc);
+                }
+
+                // 3.2. Execute with given message sort
+                self.find_with_options(
+                    COL,
+                    filter,
+                    FindOptions::builder()
+                        .limit(limit)
+                        .sort(match sort.unwrap_or(MessageSort::Latest) {
+                            // Sort by relevance, fallback to latest
+                            MessageSort::Relevance => {
+                                if is_search_query {
+                                    doc! {
+                                        "score": {
+                                            "$meta": "textScore"
+                                        }
+                                    }
+                                } else {
+                                    doc! {
+                                        "_id": -1_i32
+                                    }
+                                }
+                            }
+                            // Sort by latest first
+                            MessageSort::Latest => doc! {
+                                "_id": -1_i32
+                            },
+                            // Sort by oldest first
+                            MessageSort::Oldest => doc! {
+                                "_id": 1_i32
+                            },
+                        })
+                        .build(),
+                )
+                .await
+                .map_err(|_| create_database_error!("find", COL))
+            }
+        }*/
+    }
+
+    /// Fetch multiple messages by given IDs
+    async fn fetch_messages_by_id(&self, ids: &[String]) -> Result<Vec<Message>> {
+        try_join_all(ids.iter().map(|id| self.fetch_message(id))).await
+    }
+
+    /// Update a given message with new information
+    async fn update_message(&self, id: &str, message: &PartialMessage) -> Result<()> {
+        let mut messages = self.messages.lock().await;
+        if let Some(message_data) = messages.get_mut(id) {
+            message_data.apply_options(message.to_owned());
+            Ok(())
+        } else {
+            Err(create_error!(NotFound))
+        }
+    }
+
+    /// Append information to a given message
+    async fn append_message(&self, id: &str, append: &AppendMessage) -> Result<()> {
+        let mut messages = self.messages.lock().await;
+        if let Some(message_data) = messages.get_mut(id) {
+            if let Some(embeds) = &append.embeds {
+                if !embeds.is_empty() {
+                    if let Some(embeds_data) = &mut message_data.embeds {
+                        embeds_data.extend(embeds.clone());
+                    } else {
+                        message_data.embeds = Some(embeds.clone());
+                    }
+                }
+            }
+
+            Ok(())
+        } else {
+            Err(create_error!(NotFound))
+        }
+    }
+
+    /// Add a new reaction to a message
+    async fn add_reaction(&self, id: &str, emoji: &str, user: &str) -> Result<()> {
+        let mut messages = self.messages.lock().await;
+        if let Some(message) = messages.get_mut(id) {
+            if let Some(users) = message.reactions.get_mut(emoji) {
+                users.insert(user.to_string());
+            } else {
+                message
+                    .reactions
+                    .insert(emoji.to_string(), IndexSet::from([user.to_string()]));
+            }
+
+            Ok(())
+        } else {
+            Err(create_error!(NotFound))
+        }
+    }
+
+    /// Remove a reaction from a message
+    async fn remove_reaction(&self, id: &str, emoji: &str, user: &str) -> Result<()> {
+        let mut messages = self.messages.lock().await;
+        if let Some(message) = messages.get_mut(id) {
+            if let Some(users) = message.reactions.get_mut(emoji) {
+                users.remove(&user.to_string());
+            }
+
+            Ok(())
+        } else {
+            Err(create_error!(NotFound))
+        }
+    }
+
+    /// Remove reaction from a message
+    async fn clear_reaction(&self, id: &str, emoji: &str) -> Result<()> {
+        let mut messages = self.messages.lock().await;
+        if let Some(message) = messages.get_mut(id) {
+            message.reactions.remove(emoji);
+            Ok(())
+        } else {
+            Err(create_error!(NotFound))
+        }
+    }
+
+    /// Delete a message from the database by its id
+    async fn delete_message(&self, id: &str) -> Result<()> {
+        let mut messages = self.messages.lock().await;
+        if messages.remove(id).is_some() {
+            Ok(())
+        } else {
+            Err(create_error!(NotFound))
+        }
+    }
+
+    /// Delete messages from a channel by their ids and corresponding channel id
+    async fn delete_messages(&self, channel: &str, ids: &[String]) -> Result<()> {
+        self.messages
+            .lock()
+            .await
+            .retain(|id, message| message.channel != channel && !ids.contains(id));
+
+        Ok(())
+    }
+}

crates/core/database/src/models/mod.rs

@@ -1,10 +1,16 @@
 mod admin_migrations;
 mod bots;
+mod channel_invites;
+mod channel_unreads;
 mod channel_webhooks;
 mod channels;
+mod emojis;
 mod files;
+mod messages;
 mod ratelimit_events;
-mod safety_strikes;
+mod safety_reports;
+mod safety_snapshots;
+mod server_bans;
 mod server_members;
 mod servers;
 mod user_settings;
@@ -12,11 +18,17 @@ mod users;
 
 pub use admin_migrations::*;
 pub use bots::*;
+pub use channel_invites::*;
+pub use channel_unreads::*;
 pub use channel_webhooks::*;
 pub use channels::*;
+pub use emojis::*;
 pub use files::*;
+pub use messages::*;
 pub use ratelimit_events::*;
-pub use safety_strikes::*;
+pub use safety_reports::*;
+pub use safety_snapshots::*;
+pub use server_bans::*;
 pub use server_members::*;
 pub use servers::*;
 pub use user_settings::*;
@@ -30,10 +42,16 @@ pub trait AbstractDatabase:
     + admin_migrations::AbstractMigrations
     + bots::AbstractBots
     + channels::AbstractChannels
+    + channel_invites::AbstractChannelInvites
+    + channel_unreads::AbstractChannelUnreads
     + channel_webhooks::AbstractWebhooks
+    + emojis::AbstractEmojis
     + files::AbstractAttachments
+    + messages::AbstractMessages
     + ratelimit_events::AbstractRatelimitEvents
-    + safety_strikes::AbstractAccountStrikes
+    + safety_reports::AbstractReport
+    + safety_snapshots::AbstractSnapshot
+    + server_bans::AbstractServerBans
     + server_members::AbstractServerMembers
     + servers::AbstractServers
     + user_settings::AbstractUserSettings

crates/core/database/src/models/ratelimit_events/model.rs

@@ -1,5 +1,10 @@
 use std::fmt;
 
+use revolt_result::Result;
+use ulid::Ulid;
+
+use crate::Database;
+
 auto_derived!(
     /// Ratelimit Event
     pub struct RatelimitEvent {
@@ -23,3 +28,20 @@ impl fmt::Display for RatelimitEventType {
         fmt::Debug::fmt(self, f)
     }
 }
+
+#[allow(clippy::disallowed_methods)]
+impl RatelimitEvent {
+    /// Create ratelimit event
+    pub async fn create(
+        db: &Database,
+        target_id: String,
+        event_type: RatelimitEventType,
+    ) -> Result<()> {
+        db.insert_ratelimit_event(&RatelimitEvent {
+            id: Ulid::new().to_string(),
+            target_id,
+            event_type,
+        })
+        .await
+    }
+}

crates/core/database/src/models/ratelimit_events/ops/reference.rs

@@ -1,28 +1,46 @@
+use std::cmp::Ordering;
 use std::time::Duration;
+use std::time::SystemTime;
 
 use super::AbstractRatelimitEvents;
 use crate::RatelimitEvent;
 use crate::RatelimitEventType;
 use crate::ReferenceDb;
 use revolt_result::Result;
+use ulid::Ulid;
 
 #[async_trait]
 impl AbstractRatelimitEvents for ReferenceDb {
     /// Insert a new ratelimit event
-    async fn insert_ratelimit_event(&self, _event: &RatelimitEvent) -> Result<()> {
-        // TODO: implement
-        unimplemented!()
+    async fn insert_ratelimit_event(&self, event: &RatelimitEvent) -> Result<()> {
+        let mut ratelimit_events = self.ratelimit_events.lock().await;
+        if ratelimit_events.contains_key(&event.id) {
+            Err(create_database_error!("insert", "message"))
+        } else {
+            ratelimit_events.insert(event.id.to_string(), event.clone());
+            Ok(())
+        }
     }
 
     /// Count number of events in given duration and check if we've hit the limit
     async fn has_ratelimited(
         &self,
-        _target_id: &str,
-        _event_type: RatelimitEventType,
-        _period: Duration,
-        _count: usize,
+        target_id: &str,
+        event_type: RatelimitEventType,
+        period: Duration,
+        count: usize,
     ) -> Result<bool> {
-        // TODO: implement
-        unimplemented!()
+        let ratelimit_events = self.ratelimit_events.lock().await;
+        let gte_cmp_id = Ulid::from_datetime(SystemTime::now() - period).to_string();
+
+        Ok(ratelimit_events
+            .iter()
+            .filter(|(id, event)| {
+                id.cmp(&&gte_cmp_id) == Ordering::Greater
+                    && event.target_id == target_id
+                    && event.event_type == event_type
+            })
+            .count()
+            >= count)
     }
 }

crates/core/database/src/models/safety_reports/mod.rs

@@ -0,0 +1,5 @@
+mod model;
+mod ops;
+
+pub use model::*;
+pub use ops::*;

crates/core/database/src/models/safety_reports/model.rs

@@ -0,0 +1,22 @@
+use revolt_models::v0::{ReportStatus, ReportedContent};
+
+auto_derived!(
+    /// User-generated platform moderation report
+    pub struct Report {
+        /// Unique Id
+        #[serde(rename = "_id")]
+        pub id: String,
+        /// Id of the user creating this report
+        pub author_id: String,
+        /// Reported content
+        pub content: ReportedContent,
+        /// Additional report context
+        pub additional_context: String,
+        /// Status of the report
+        #[serde(flatten)]
+        pub status: ReportStatus,
+        /// Additional notes included on the report
+        #[serde(default)]
+        pub notes: String,
+    }
+);

crates/core/database/src/models/safety_reports/ops.rs

@@ -0,0 +1,12 @@
+use revolt_result::Result;
+
+use crate::Report;
+
+mod mongodb;
+mod reference;
+
+#[async_trait]
+pub trait AbstractReport: Sync + Send {
+    /// Insert a new report into the database
+    async fn insert_report(&self, report: &Report) -> Result<()>;
+}

crates/core/database/src/models/safety_reports/ops/mongodb.rs

@@ -0,0 +1,16 @@
+use revolt_result::Result;
+
+use crate::MongoDb;
+use crate::Report;
+
+use super::AbstractReport;
+
+static COL: &str = "safety_reports";
+
+#[async_trait]
+impl AbstractReport for MongoDb {
+    /// Insert a new report into the database
+    async fn insert_report(&self, report: &Report) -> Result<()> {
+        query!(self, insert_one, COL, &report).map(|_| ())
+    }
+}

crates/core/database/src/models/safety_reports/ops/reference.rs

@@ -0,0 +1,20 @@
+use revolt_result::Result;
+
+use crate::ReferenceDb;
+use crate::Report;
+
+use super::AbstractReport;
+
+#[async_trait]
+impl AbstractReport for ReferenceDb {
+    /// Insert a new report into the database
+    async fn insert_report(&self, report: &Report) -> Result<()> {
+        let mut reports = self.safety_reports.lock().await;
+        if reports.contains_key(&report.id) {
+            Err(create_database_error!("insert", "report"))
+        } else {
+            reports.insert(report.id.to_string(), report.clone());
+            Ok(())
+        }
+    }
+}

crates/core/database/src/models/safety_snapshots/mod.rs

@@ -0,0 +1,5 @@
+mod model;
+mod ops;
+
+pub use model::*;
+pub use ops::*;

crates/core/database/src/models/safety_snapshots/model.rs

@@ -0,0 +1,121 @@
+use revolt_models::v0::MessageSort;
+use revolt_result::Result;
+
+use crate::{Database, Message, MessageFilter, MessageQuery, MessageTimePeriod, Server, User};
+
+auto_derived!(
+    /// Snapshot of some content
+    pub struct Snapshot {
+        /// Unique Id
+        #[serde(rename = "_id")]
+        pub id: String,
+        /// Report parent Id
+        pub report_id: String,
+        /// Snapshot of content
+        pub content: SnapshotContent,
+    }
+
+    /// Enum to map into different models
+    /// that can be saved in a snapshot
+    #[serde(tag = "_type")]
+    pub enum SnapshotContent {
+        Message {
+            /// Context before the message
+            #[serde(rename = "_prior_context", default)]
+            prior_context: Vec<Message>,
+
+            /// Context after the message
+            #[serde(rename = "_leading_context", default)]
+            leading_context: Vec<Message>,
+
+            /// Message
+            #[serde(flatten)]
+            message: Message,
+        },
+        Server(Server),
+        User(User),
+    }
+);
+
+impl SnapshotContent {
+    /// Generate snapshot from a given message
+    pub async fn generate_from_message(
+        db: &Database,
+        message: Message,
+    ) -> Result<(SnapshotContent, Vec<String>)> {
+        // Collect message attachments
+        let files = message
+            .attachments
+            .as_ref()
+            .map(|attachments| attachments.iter().map(|x| x.id.to_string()).collect())
+            .unwrap_or_default();
+
+        // Collect prior context
+        let prior_context = db
+            .fetch_messages(MessageQuery {
+                filter: MessageFilter {
+                    channel: Some(message.channel.to_string()),
+                    ..Default::default()
+                },
+                limit: Some(15),
+                time_period: MessageTimePeriod::Absolute {
+                    before: Some(message.id.to_string()),
+                    after: None,
+                    sort: Some(MessageSort::Latest),
+                },
+            })
+            .await?;
+
+        // Collect leading context
+        let leading_context = db
+            .fetch_messages(MessageQuery {
+                filter: MessageFilter {
+                    channel: Some(message.channel.to_string()),
+                    ..Default::default()
+                },
+                limit: Some(15),
+                time_period: MessageTimePeriod::Absolute {
+                    before: None,
+                    after: Some(message.id.to_string()),
+                    sort: Some(MessageSort::Oldest),
+                },
+            })
+            .await?;
+
+        Ok((
+            SnapshotContent::Message {
+                message,
+                prior_context: prior_context.into_iter().map(Into::into).collect(),
+                leading_context: leading_context.into_iter().map(Into::into).collect(),
+            },
+            files,
+        ))
+    }
+
+    /// Generate snapshot from a given server
+    pub fn generate_from_server(server: Server) -> Result<(SnapshotContent, Vec<String>)> {
+        // Collect server's icon and banner
+        let files = [&server.icon, &server.banner]
+            .iter()
+            .filter_map(|x| x.as_ref().map(|x| x.id.to_string()))
+            .collect();
+
+        Ok((SnapshotContent::Server(server), files))
+    }
+
+    /// Generate snapshot from a given user
+    pub fn generate_from_user(user: User) -> Result<(SnapshotContent, Vec<String>)> {
+        // Collect user's avatar and profile background
+        let files = [
+            user.avatar.as_ref(),
+            user.profile
+                .as_ref()
+                .and_then(|profile| profile.background.as_ref()),
+        ]
+        .iter()
+        .filter_map(|x| x.as_ref().map(|x| x.id.to_string()))
+        .collect();
+
+        Ok((SnapshotContent::User(user), files))
+    }
+}

crates/core/database/src/models/safety_snapshots/ops.rs

@@ -0,0 +1,12 @@
+use revolt_result::Result;
+
+use crate::Snapshot;
+
+mod mongodb;
+mod reference;
+
+#[async_trait]
+pub trait AbstractSnapshot: Sync + Send {
+    /// Insert a new snapshot into the database
+    async fn insert_snapshot(&self, snapshot: &Snapshot) -> Result<()>;
+}

crates/core/database/src/models/safety_snapshots/ops/mongodb.rs

@@ -0,0 +1,16 @@
+use revolt_result::Result;
+
+use crate::MongoDb;
+use crate::Snapshot;
+
+use super::AbstractSnapshot;
+
+static COL: &str = "safety_snapshots";
+
+#[async_trait]
+impl AbstractSnapshot for MongoDb {
+    /// Insert a new snapshot into the database
+    async fn insert_snapshot(&self, snapshot: &Snapshot) -> Result<()> {
+        query!(self, insert_one, COL, &snapshot).map(|_| ())
+    }
+}

crates/core/database/src/models/safety_snapshots/ops/reference.rs

@@ -0,0 +1,20 @@
+use revolt_result::Result;
+
+use crate::ReferenceDb;
+use crate::Snapshot;
+
+use super::AbstractSnapshot;
+
+#[async_trait]
+impl AbstractSnapshot for ReferenceDb {
+    /// Insert a new report into the database
+    async fn insert_snapshot(&self, snapshot: &Snapshot) -> Result<()> {
+        let mut snapshots = self.safety_snapshots.lock().await;
+        if snapshots.contains_key(&snapshot.id) {
+            Err(create_database_error!("insert", "snapshot"))
+        } else {
+            snapshots.insert(snapshot.id.to_string(), snapshot.clone());
+            Ok(())
+        }
+    }
+}

crates/core/database/src/models/safety_strikes/model.rs

@@ -1,124 +0,0 @@
-use revolt_result::Result;
-
-use crate::Database;
-
-auto_derived_partial!(
-    /// Account Strike
-    pub struct AccountStrike {
-        /// Strike Id
-        #[serde(rename = "_id")]
-        pub id: String,
-        /// Id of reported user
-        pub user_id: String,
-        /// Id of moderator
-        pub moderator_id: String,
-
-        /// Attached reason
-        pub reason: String,
-    },
-    "PartialAccountStrike"
-);
-
-#[allow(clippy::disallowed_methods)]
-impl AccountStrike {
-    pub async fn create(
-        db: &Database,
-        user_id: String,
-        reason: String,
-        moderator_id: String,
-    ) -> Result<AccountStrike> {
-        let strike = AccountStrike {
-            id: ulid::Ulid::new().to_string(),
-            user_id,
-            moderator_id,
-            reason,
-        };
-
-        db.insert_account_strike(&strike).await?;
-        Ok(strike)
-    }
-
-    /// Update this strike
-    pub async fn update(&mut self, db: &Database, partial: PartialAccountStrike) -> Result<()> {
-        db.update_account_strike(&self.id, &partial).await?;
-        self.apply_options(partial);
-        Ok(())
-    }
-
-    /// Delete this strike
-    pub async fn delete(&self, db: &Database) -> Result<()> {
-        db.delete_account_strike(&self.id).await
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::collections::HashSet;
-
-    use crate::{AccountStrike, PartialAccountStrike};
-
-    #[async_std::test]
-    async fn crud() {
-        database_test!(|db| async move {
-            let user_id = "user";
-
-            let strike = AccountStrike::create(
-                &db,
-                user_id.to_string(),
-                "reason 1".to_string(),
-                "moderator_id".to_string(),
-            )
-            .await
-            .unwrap();
-
-            let mut updated_strike = strike.clone();
-            updated_strike
-                .update(
-                    &db,
-                    PartialAccountStrike {
-                        reason: Some("new reason".to_string()),
-                        ..Default::default()
-                    },
-                )
-                .await
-                .unwrap();
-
-            let strike2 = AccountStrike::create(
-                &db,
-                user_id.to_string(),
-                "reason 2".to_string(),
-                "moderator_id".to_string(),
-            )
-            .await
-            .unwrap();
-
-            let strikes = db.fetch_account_strikes_by_user(user_id).await.unwrap();
-
-            let ids = strikes
-                .iter()
-                .cloned()
-                .map(|strike| strike.id)
-                .collect::<HashSet<String>>();
-
-            assert!(ids.contains(&strike.id));
-            assert!(ids.contains(&strike2.id));
-
-            let fetched_strike = strikes
-                .into_iter()
-                .find(|entry| entry.id == strike.id)
-                .unwrap();
-
-            assert_eq!(fetched_strike, updated_strike);
-            assert_ne!(fetched_strike, strike);
-
-            strike.delete(&db).await.unwrap();
-            assert_eq!(
-                1,
-                db.fetch_account_strikes_by_user(user_id)
-                    .await
-                    .unwrap()
-                    .len()
-            )
-        });
-    }
-}

crates/core/database/src/models/safety_strikes/ops.rs

@@ -1,24 +0,0 @@
-use revolt_result::Result;
-
-use crate::{AccountStrike, PartialAccountStrike};
-
-mod mongodb;
-mod reference;
-
-#[async_trait]
-pub trait AbstractAccountStrikes: Sync + Send {
-    /// Insert new strike into the database
-    async fn insert_account_strike(&self, strike: &AccountStrike) -> Result<()>;
-
-    /// Fetch strike by id
-    async fn fetch_account_strike(&self, id: &str) -> Result<AccountStrike>;
-
-    /// Fetch strikes by user id
-    async fn fetch_account_strikes_by_user(&self, user_id: &str) -> Result<Vec<AccountStrike>>;
-
-    /// Update strike with new information
-    async fn update_account_strike(&self, id: &str, partial: &PartialAccountStrike) -> Result<()>;
-
-    /// Delete a strike from the database
-    async fn delete_account_strike(&self, id: &str) -> Result<()>;
-}

crates/core/database/src/models/safety_strikes/ops/mongodb.rs

@@ -1,55 +0,0 @@
-use futures::StreamExt;
-use revolt_result::Result;
-
-use crate::MongoDb;
-use crate::{AccountStrike, PartialAccountStrike};
-
-use super::AbstractAccountStrikes;
-
-static COL: &str = "safety_strikes";
-
-#[async_trait]
-impl AbstractAccountStrikes for MongoDb {
-    /// Insert new strike into the database
-    async fn insert_account_strike(&self, strike: &AccountStrike) -> Result<()> {
-        query!(self, insert_one, COL, &strike).map(|_| ())
-    }
-
-    /// Fetch strike by id
-    async fn fetch_account_strike(&self, id: &str) -> Result<AccountStrike> {
-        query!(self, find_one_by_id, COL, id)?.ok_or_else(|| create_error!(NotFound))
-    }
-
-    /// Fetch strikes by user id
-    async fn fetch_account_strikes_by_user(&self, user_id: &str) -> Result<Vec<AccountStrike>> {
-        Ok(self
-            .col::<AccountStrike>(COL)
-            .find(
-                doc! {
-                    "user_id": user_id,
-                },
-                None,
-            )
-            .await
-            .map_err(|_| create_database_error!("find", COL))?
-            .filter_map(|s| async {
-                if cfg!(debug_assertions) {
-                    Some(s.unwrap())
-                } else {
-                    s.ok()
-                }
-            })
-            .collect()
-            .await)
-    }
-
-    /// Update strike with new information
-    async fn update_account_strike(&self, id: &str, partial: &PartialAccountStrike) -> Result<()> {
-        query!(self, update_one_by_id, COL, id, partial, vec![], None).map(|_| ())
-    }
-
-    /// Delete a strike from the database
-    async fn delete_account_strike(&self, id: &str) -> Result<()> {
-        query!(self, delete_one_by_id, COL, id).map(|_| ())
-    }
-}

crates/core/database/src/models/safety_strikes/ops/reference.rs

@@ -1,60 +0,0 @@
-use revolt_result::Result;
-
-use crate::ReferenceDb;
-use crate::{AccountStrike, PartialAccountStrike};
-
-use super::AbstractAccountStrikes;
-
-#[async_trait]
-impl AbstractAccountStrikes for ReferenceDb {
-    /// Insert new strike into the database
-    async fn insert_account_strike(&self, strike: &AccountStrike) -> Result<()> {
-        let mut strikes = self.account_strikes.lock().await;
-        if strikes.contains_key(&strike.id) {
-            Err(create_database_error!("insert", "strike"))
-        } else {
-            strikes.insert(strike.id.to_string(), strike.clone());
-            Ok(())
-        }
-    }
-
-    /// Fetch strike by id
-    async fn fetch_account_strike(&self, id: &str) -> Result<AccountStrike> {
-        let strikes = self.account_strikes.lock().await;
-        strikes
-            .get(id)
-            .cloned()
-            .ok_or_else(|| create_error!(NotFound))
-    }
-
-    /// Fetch strikes by user id
-    async fn fetch_account_strikes_by_user(&self, user_id: &str) -> Result<Vec<AccountStrike>> {
-        let strikes = self.account_strikes.lock().await;
-        Ok(strikes
-            .values()
-            .filter(|strike| strike.user_id == user_id)
-            .cloned()
-            .collect())
-    }
-
-    /// Update strike with new information
-    async fn update_account_strike(&self, id: &str, partial: &PartialAccountStrike) -> Result<()> {
-        let mut strikes = self.account_strikes.lock().await;
-        if let Some(strike) = strikes.get_mut(id) {
-            strike.apply_options(partial.clone());
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-
-    /// Delete a strike from the database
-    async fn delete_account_strike(&self, id: &str) -> Result<()> {
-        let mut strikes = self.account_strikes.lock().await;
-        if strikes.remove(id).is_some() {
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-}

crates/core/database/src/models/server_bans/mod.rs

@@ -0,0 +1,5 @@
+mod model;
+mod ops;
+
+pub use model::*;
+pub use ops::*;

crates/core/database/src/models/server_bans/model.rs

@@ -0,0 +1,35 @@
+use revolt_result::Result;
+
+use crate::{Database, MemberCompositeKey, Server};
+
+auto_derived!(
+    /// Server Ban
+    pub struct ServerBan {
+        /// Unique member id
+        #[serde(rename = "_id")]
+        pub id: MemberCompositeKey,
+        /// Reason for ban creation
+        pub reason: Option<String>,
+    }
+);
+
+impl ServerBan {
+    /// Create ban
+    pub async fn create(
+        db: &Database,
+        server: &Server,
+        user_id: &str,
+        reason: Option<String>,
+    ) -> Result<ServerBan> {
+        let ban = ServerBan {
+            id: MemberCompositeKey {
+                server: server.id.to_string(),
+                user: user_id.to_string(),
+            },
+            reason,
+        };
+
+        db.insert_ban(&ban).await?;
+        Ok(ban)
+    }
+}

crates/core/database/src/models/server_bans/ops.rs

@@ -0,0 +1,21 @@
+use revolt_result::Result;
+
+use crate::{MemberCompositeKey, ServerBan};
+
+mod mongodb;
+mod reference;
+
+#[async_trait]
+pub trait AbstractServerBans: Sync + Send {
+    /// Insert new ban into database
+    async fn insert_ban(&self, ban: &ServerBan) -> Result<()>;
+
+    /// Fetch a server ban by server and user id
+    async fn fetch_ban(&self, server_id: &str, user_id: &str) -> Result<ServerBan>;
+
+    /// Fetch all bans in a server
+    async fn fetch_bans(&self, server_id: &str) -> Result<Vec<ServerBan>>;
+
+    /// Delete a ban from the database
+    async fn delete_ban(&self, id: &MemberCompositeKey) -> Result<()>;
+}

crates/core/database/src/models/server_bans/ops/mongodb.rs

@@ -0,0 +1,56 @@
+use revolt_result::Result;
+
+use crate::MongoDb;
+use crate::{MemberCompositeKey, ServerBan};
+
+use super::AbstractServerBans;
+
+static COL: &str = "server_bans";
+
+#[async_trait]
+impl AbstractServerBans for MongoDb {
+    /// Insert new ban into database
+    async fn insert_ban(&self, ban: &ServerBan) -> Result<()> {
+        query!(self, insert_one, COL, &ban).map(|_| ())
+    }
+
+    /// Fetch a server ban by server and user id
+    async fn fetch_ban(&self, server_id: &str, user_id: &str) -> Result<ServerBan> {
+        query!(
+            self,
+            find_one,
+            COL,
+            doc! {
+                "_id.server": server_id,
+                "_id.user": user_id
+            }
+        )?
+        .ok_or_else(|| create_error!(NotFound))
+    }
+
+    /// Fetch all bans in a server
+    async fn fetch_bans(&self, server_id: &str) -> Result<Vec<ServerBan>> {
+        query!(
+            self,
+            find,
+            COL,
+            doc! {
+                "_id.server": server_id
+            }
+        )
+    }
+
+    /// Delete a ban from the database
+    async fn delete_ban(&self, id: &MemberCompositeKey) -> Result<()> {
+        query!(
+            self,
+            delete_one,
+            COL,
+            doc! {
+                "_id.server": &id.server,
+                "_id.user": &id.user
+            }
+        )
+        .map(|_| ())
+    }
+}

crates/core/database/src/models/server_bans/ops/reference.rs

@@ -0,0 +1,52 @@
+use revolt_result::Result;
+
+use crate::ReferenceDb;
+use crate::{MemberCompositeKey, ServerBan};
+
+use super::AbstractServerBans;
+
+#[async_trait]
+impl AbstractServerBans for ReferenceDb {
+    /// Insert new ban into database
+    async fn insert_ban(&self, ban: &ServerBan) -> Result<()> {
+        let mut server_bans = self.server_bans.lock().await;
+        if server_bans.contains_key(&ban.id) {
+            Err(create_database_error!("insert", "ban"))
+        } else {
+            server_bans.insert(ban.id.clone(), ban.clone());
+            Ok(())
+        }
+    }
+
+    /// Fetch a server ban by server and user id
+    async fn fetch_ban(&self, server_id: &str, user_id: &str) -> Result<ServerBan> {
+        let server_bans = self.server_bans.lock().await;
+        server_bans
+            .get(&MemberCompositeKey {
+                server: server_id.to_string(),
+                user: user_id.to_string(),
+            })
+            .cloned()
+            .ok_or_else(|| create_error!(NotFound))
+    }
+
+    /// Fetch all bans in a server
+    async fn fetch_bans(&self, server_id: &str) -> Result<Vec<ServerBan>> {
+        let server_bans = self.server_bans.lock().await;
+        Ok(server_bans
+            .values()
+            .filter(|member| member.id.server == server_id)
+            .cloned()
+            .collect())
+    }
+
+    /// Delete a ban from the database
+    async fn delete_ban(&self, id: &MemberCompositeKey) -> Result<()> {
+        let mut server_bans = self.server_bans.lock().await;
+        if server_bans.remove(id).is_some() {
+            Ok(())
+        } else {
+            Err(create_error!(NotFound))
+        }
+    }
+}

crates/core/database/src/models/server_members/model.rs

@@ -1,7 +1,11 @@
 use iso8601_timestamp::Timestamp;
-use revolt_result::Result;
+use revolt_permissions::{calculate_channel_permissions, ChannelPermission};
+use revolt_result::{create_error, Result};
 
-use crate::{Database, File, Server};
+use crate::{
+    events::client::EventV1, util::permissions::DatabasePermissionQuery, Channel, Database, File,
+    Server, SystemMessage, User,
+};
 
 auto_derived_partial!(
     /// Server Member
@@ -11,8 +15,7 @@ auto_derived_partial!(
         pub id: MemberCompositeKey,
 
         /// Time at which this user joined the server
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub joined_at: Option<Timestamp>,
+        pub joined_at: Timestamp,
 
         /// Member's nickname
         #[serde(skip_serializing_if = "Option::is_none")]
@@ -57,7 +60,104 @@ auto_derived!(
     }
 );
 
+impl Default for Member {
+    fn default() -> Self {
+        Self {
+            id: Default::default(),
+            joined_at: Timestamp::now_utc(),
+            nickname: None,
+            avatar: None,
+            roles: vec![],
+            timeout: None,
+        }
+    }
+}
+
+#[allow(clippy::disallowed_methods)]
 impl Member {
+    /// Create a new member in a server
+    pub async fn create(
+        db: &Database,
+        server: &Server,
+        user: &User,
+        channels: Option<Vec<Channel>>,
+    ) -> Result<Vec<Channel>> {
+        if db.fetch_ban(&server.id, &user.id).await.is_ok() {
+            return Err(create_error!(Banned));
+        }
+
+        if db.fetch_member(&server.id, &user.id).await.is_ok() {
+            return Err(create_error!(AlreadyInServer));
+        }
+
+        let member = Member {
+            id: MemberCompositeKey {
+                server: server.id.to_string(),
+                user: user.id.to_string(),
+            },
+            ..Default::default()
+        };
+
+        db.insert_member(&member).await?;
+
+        let should_fetch = channels.is_none();
+        let mut channels = channels.unwrap_or_default();
+
+        if should_fetch {
+            let query = DatabasePermissionQuery::new(db, user).server(server);
+            let existing_channels = db.fetch_channels(&server.channels).await?;
+
+            for channel in existing_channels {
+                let mut channel_query = query.clone().channel(&channel);
+
+                if calculate_channel_permissions(&mut channel_query)
+                    .await
+                    .has_channel_permission(ChannelPermission::ViewChannel)
+                {
+                    channels.push(channel);
+                }
+            }
+        }
+
+        let emojis = db.fetch_emoji_by_parent_id(&server.id).await?;
+
+        EventV1::ServerMemberJoin {
+            id: server.id.clone(),
+            user: user.id.clone(),
+        }
+        .p(server.id.clone())
+        .await;
+
+        EventV1::ServerCreate {
+            id: server.id.clone(),
+            server: server.clone().into(),
+            channels: channels
+                .clone()
+                .into_iter()
+                .map(|channel| channel.into())
+                .collect(),
+            emojis: emojis.into_iter().map(|emoji| emoji.into()).collect(),
+        }
+        .private(user.id.clone())
+        .await;
+
+        if let Some(id) = server
+            .system_messages
+            .as_ref()
+            .and_then(|x| x.user_joined.as_ref())
+        {
+            SystemMessage::UserJoined {
+                id: user.id.clone(),
+            }
+            .into_message(id.to_string())
+            .send_without_notifications(db, false, false)
+            .await
+            .ok();
+        }
+
+        Ok(channels)
+    }
+
     /// Update member data
     pub async fn update<'a>(
         &mut self,
@@ -73,13 +173,13 @@ impl Member {
 
         db.update_member(&self.id, &partial, remove.clone()).await?;
 
-        /* // TODO: EventV1::ServerMemberUpdate {
-            id: self.id.clone(),
-            data: partial,
-            clear: remove,
+        EventV1::ServerMemberUpdate {
+            id: self.id.clone().into(),
+            data: partial.into(),
+            clear: remove.into_iter().map(|field| field.into()).collect(),
         }
         .p(self.id.server.clone())
-        .await; */
+        .await;
 
         Ok(())
     }
@@ -115,4 +215,47 @@ impl Member {
             false
         }
     }
+
+    /// Remove member from server
+    pub async fn remove(
+        self,
+        db: &Database,
+        server: &Server,
+        intention: RemovalIntention,
+        silent: bool,
+    ) -> Result<()> {
+        db.delete_member(&self.id).await?;
+
+        EventV1::ServerMemberLeave {
+            id: self.id.server.to_string(),
+            user: self.id.user.to_string(),
+        }
+        .p(self.id.server.to_string())
+        .await;
+
+        if !silent {
+            if let Some(id) = server
+                .system_messages
+                .as_ref()
+                .and_then(|x| match intention {
+                    RemovalIntention::Leave => x.user_left.as_ref(),
+                    RemovalIntention::Kick => x.user_kicked.as_ref(),
+                    RemovalIntention::Ban => x.user_banned.as_ref(),
+                })
+            {
+                match intention {
+                    RemovalIntention::Leave => SystemMessage::UserLeft { id: self.id.user },
+                    RemovalIntention::Kick => SystemMessage::UserKicked { id: self.id.user },
+                    RemovalIntention::Ban => SystemMessage::UserBanned { id: self.id.user },
+                }
+                .into_message(id.to_string())
+                // TODO: support notifications here in the future?
+                .send_without_notifications(db, false, false)
+                .await
+                .ok();
+            }
+        }
+
+        Ok(())
+    }
 }

crates/core/database/src/models/servers/model.rs

@@ -1,10 +1,11 @@
 use std::collections::{HashMap, HashSet};
 
-use revolt_permissions::OverrideField;
+use revolt_models::v0::{self, DataCreateServerChannel};
+use revolt_permissions::{OverrideField, DEFAULT_PERMISSION_SERVER};
 use revolt_result::Result;
 use ulid::Ulid;
 
-use crate::{Database, File};
+use crate::{events::client::EventV1, Channel, Database, File, User};
 
 auto_derived_partial!(
     /// Server
@@ -22,7 +23,7 @@ auto_derived_partial!(
         pub description: Option<String>,
 
         /// Channels within this server
-        // ! FIXME: this may be redundant
+        // TODO: investigate if this is redundant and can be removed
         pub channels: Vec<String>,
         /// Categories for this server
         #[serde(skip_serializing_if = "Option::is_none")]
@@ -128,10 +129,55 @@ auto_derived!(
     }
 );
 
+#[allow(clippy::disallowed_methods)]
 impl Server {
     /// Create a server
-    pub async fn create(&self, db: &Database) -> Result<()> {
-        db.insert_server(self).await
+    pub async fn create(
+        db: &Database,
+        data: v0::DataCreateServer,
+        owner: &User,
+        create_default_channels: bool,
+    ) -> Result<(Server, Vec<Channel>)> {
+        let mut server = Server {
+            id: ulid::Ulid::new().to_string(),
+            owner: owner.id.to_string(),
+            name: data.name,
+            description: data.description,
+            channels: vec![],
+            nsfw: data.nsfw.unwrap_or(false),
+            default_permissions: *DEFAULT_PERMISSION_SERVER as i64,
+
+            analytics: false,
+            banner: None,
+            categories: None,
+            discoverable: false,
+            flags: None,
+            icon: None,
+            roles: HashMap::new(),
+            system_messages: None,
+        };
+
+        let channels: Vec<Channel> = if create_default_channels {
+            vec![
+                Channel::create_server_channel(
+                    db,
+                    &mut server,
+                    DataCreateServerChannel {
+                        channel_type: v0::LegacyServerChannelType::Text,
+                        name: "General".to_string(),
+                        ..Default::default()
+                    },
+                    false,
+                )
+                .await?,
+            ]
+        } else {
+            vec![]
+        };
+
+        server.channels = channels.iter().map(|c| c.id()).collect();
+        db.insert_server(&server).await?;
+        Ok((server, channels))
     }
 
     /// Update server data
@@ -149,24 +195,24 @@ impl Server {
 
         db.update_server(&self.id, &partial, remove.clone()).await?;
 
-        /* // TODO: EventV1::ServerUpdate {
+        EventV1::ServerUpdate {
             id: self.id.clone(),
-            data: partial,
-            clear: remove,
+            data: partial.into(),
+            clear: remove.into_iter().map(|v| v.into()).collect(),
         }
         .p(self.id.clone())
-        .await; */
+        .await;
 
         Ok(())
     }
 
     /// Delete a server
     pub async fn delete(self, db: &Database) -> Result<()> {
-        /* // TODO: EventV1::ServerDelete {
+        EventV1::ServerDelete {
             id: self.id.clone(),
         }
         .p(self.id.clone())
-        .await; */
+        .await;
 
         db.delete_server(&self.id).await
     }
@@ -207,144 +253,6 @@ impl Server {
             Err(create_error!(NotFound))
         }
     }
-
-    /* /// Create a new member in a server
-    pub async fn create_member(
-        &self,
-        db: &Database,
-        user: User,
-        channels: Option<Vec<Channel>>,
-    ) -> Result<Vec<Channel>> {
-        if db.fetch_ban(&self.id, &user.id).await.is_ok() {
-            return Err(Error::Banned);
-        }
-
-        let member = Member {
-            id: MemberCompositeKey {
-                server: self.id.clone(),
-                user: user.id.clone(),
-            },
-            joined_at: Timestamp::now_utc(),
-            nickname: None,
-            avatar: None,
-            roles: vec![],
-            timeout: None,
-        };
-
-        db.insert_member(&member).await?;
-
-        let should_fetch = channels.is_none();
-        let mut channels = channels.unwrap_or_default();
-
-        if should_fetch {
-            let perm = perms(&user).server(self).member(&member);
-            let existing_channels = db.fetch_channels(&self.channels).await?;
-            for channel in existing_channels {
-                if perm
-                    .clone()
-                    .channel(&channel)
-                    .has_permission(db, Permission::ViewChannel)
-                    .await?
-                {
-                    channels.push(channel);
-                }
-            }
-        }
-
-        /* // TODO: EventV1::ServerMemberJoin {
-            id: self.id.clone(),
-            user: user.id.clone(),
-        }
-        .p(self.id.clone())
-        .await;
-
-        EventV1::ServerCreate {
-            id: self.id.clone(),
-            server: self.clone(),
-            channels: channels.clone(),
-        }
-        .private(user.id.clone())
-        .await; */
-
-        if let Some(id) = self
-            .system_messages
-            .as_ref()
-            .and_then(|x| x.user_joined.as_ref())
-        {
-            SystemMessage::UserJoined {
-                id: user.id.clone(),
-            }
-            .into_message(id.to_string())
-            .create_no_web_push(db, id, false)
-            .await
-            .ok();
-        }
-
-        Ok(channels)
-    }
-
-    /// Remove a member from a server
-    pub async fn remove_member(
-        &self,
-        db: &Database,
-        member: Member,
-        intention: RemovalIntention,
-        silent: bool,
-    ) -> Result<()> {
-        db.delete_member(&member.id).await?;
-
-        /* // TODO: EventV1::ServerMemberLeave {
-            id: self.id.to_string(),
-            user: member.id.user.clone(),
-        }
-        .p(member.id.server)
-        .await; */
-
-        if !silent {
-            if let Some(id) = self.system_messages.as_ref().and_then(|x| match intention {
-                RemovalIntention::Leave => x.user_left.as_ref(),
-                RemovalIntention::Kick => x.user_kicked.as_ref(),
-                RemovalIntention::Ban => x.user_banned.as_ref(),
-            }) {
-                match intention {
-                    RemovalIntention::Leave => SystemMessage::UserLeft { id: member.id.user },
-                    RemovalIntention::Kick => SystemMessage::UserKicked { id: member.id.user },
-                    RemovalIntention::Ban => SystemMessage::UserBanned { id: member.id.user },
-                }
-                .into_message(id.to_string())
-                .create_no_web_push(db, id, false)
-                .await
-                .ok();
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Create ban
-    pub async fn ban_user(
-        self,
-        db: &Database,
-        id: MemberCompositeKey,
-        reason: Option<String>,
-    ) -> Result<ServerBan> {
-        let ban = ServerBan { id, reason };
-        db.insert_ban(&ban).await?;
-        Ok(ban)
-    }
-
-    /// Ban a member from a server
-    pub async fn ban_member(
-        self,
-        db: &Database,
-        member: Member,
-        reason: Option<String>,
-    ) -> Result<ServerBan> {
-        self.remove_member(db, member.clone(), RemovalIntention::Ban, false)
-            .await?;
-
-        self.ban_user(db, member.id, reason).await
-    } */
 }
 
 impl Role {
@@ -364,14 +272,14 @@ impl Role {
         let role_id = Ulid::new().to_string();
         db.insert_role(server_id, &role_id, self).await?;
 
-        /* // TODO: EventV1::ServerRoleUpdate {
+        EventV1::ServerRoleUpdate {
             id: server_id.to_string(),
             role_id: role_id.to_string(),
-            data: self.clone().into_optional(),
+            data: self.clone().into_optional().into(),
             clear: vec![],
         }
         .p(server_id.to_string())
-        .await; */
+        .await;
 
         Ok(role_id)
     }
@@ -394,14 +302,14 @@ impl Role {
         db.update_role(server_id, role_id, &partial, remove.clone())
             .await?;
 
-        /* // TODO: EventV1::ServerRoleUpdate {
+        EventV1::ServerRoleUpdate {
             id: server_id.to_string(),
             role_id: role_id.to_string(),
-            data: partial,
+            data: partial.into(),
             clear: vec![],
         }
         .p(server_id.to_string())
-        .await; */
+        .await;
 
         Ok(())
     }
@@ -415,12 +323,12 @@ impl Role {
 
     /// Delete a role
     pub async fn delete(self, db: &Database, server_id: &str, role_id: &str) -> Result<()> {
-        /* // TODO: EventV1::ServerRoleDelete {
+        EventV1::ServerRoleDelete {
             id: server_id.to_string(),
             role_id: role_id.to_string(),
         }
         .p(server_id.to_string())
-        .await; */
+        .await;
 
         db.delete_role(server_id, role_id).await
     }
@@ -449,3 +357,36 @@ impl SystemMessageChannels {
         ids
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use revolt_permissions::{calculate_server_permissions, ChannelPermission};
+
+    use crate::{fixture, util::permissions::DatabasePermissionQuery};
+
+    #[async_std::test]
+    async fn permissions() {
+        database_test!(|db| async move {
+            fixture!(db, "server_with_roles",
+                owner user 0
+                moderator user 1
+                user user 2
+                server server 4);
+
+            let mut query = DatabasePermissionQuery::new(&db, &owner).server(&server);
+            assert!(calculate_server_permissions(&mut query)
+                .await
+                .has_channel_permission(ChannelPermission::GrantAllSafe));
+
+            let mut query = DatabasePermissionQuery::new(&db, &moderator).server(&server);
+            assert!(calculate_server_permissions(&mut query)
+                .await
+                .has_channel_permission(ChannelPermission::BanMembers));
+
+            let mut query = DatabasePermissionQuery::new(&db, &user).server(&server);
+            assert!(!calculate_server_permissions(&mut query)
+                .await
+                .has_channel_permission(ChannelPermission::BanMembers));
+        });
+    }
+}

crates/core/database/src/models/servers/ops/mongodb.rs

@@ -1,4 +1,4 @@
-use bson::{to_document, Document};
+use bson::{to_document, Bson, Document};
 use futures::StreamExt;
 use revolt_result::Result;
 
@@ -67,6 +67,7 @@ impl AbstractServers for MongoDb {
 
     /// Delete a server by its id
     async fn delete_server(&self, id: &str) -> Result<()> {
+        self.delete_associated_server_objects(id).await?;
         query!(self, delete_one_by_id, COL, id).map(|_| ())
     }
 
@@ -181,3 +182,81 @@ impl IntoDocumentPath for FieldsRole {
         })
     }
 }
+
+impl MongoDb {
+    pub async fn delete_associated_server_objects(&self, server_id: &str) -> Result<()> {
+        // Find all channels
+        let channels: Vec<String> = self
+            .col::<Document>("channels")
+            .find(
+                doc! {
+                    "server": server_id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| create_database_error!("find", "channels"))?
+            .filter_map(|s| async {
+                s.map(|d| d.get_str("_id").map(|s| s.to_string()).ok())
+                    .ok()
+                    .flatten()
+            })
+            .collect()
+            .await;
+
+        // Check if there are any attachments we need to delete.
+        self.delete_bulk_messages(doc! {
+            "channel": {
+                "$in": &channels
+            }
+        })
+        .await?;
+
+        // Delete all emoji.
+        self.col::<Document>("emojis")
+            .delete_many(
+                doc! {
+                    "parent.id": &server_id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| create_database_error!("delete_many", "emojis"))?;
+
+        // Delete all channels.
+        self.col::<Document>("channels")
+            .delete_many(
+                doc! {
+                    "server": &server_id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| create_database_error!("delete_many", "channels"))?;
+
+        // Delete any associated objects, e.g. unreads and invites.
+        self.delete_associated_channel_objects(Bson::Document(doc! { "$in": &channels }))
+            .await?;
+
+        // Delete members and bans.
+        for with in &["server_members", "server_bans"] {
+            self.col::<Document>(with)
+                .delete_many(
+                    doc! {
+                        "_id.server": &server_id
+                    },
+                    None,
+                )
+                .await
+                .map_err(|_| create_database_error!("delete_many", with))?;
+        }
+
+        // Update many attachments with parent id.
+        self.delete_many_attachments(doc! {
+            "object_id": &server_id
+        })
+        .await?;
+
+        Ok(())
+    }
+}

crates/core/database/src/models/user_settings/model.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use crate::Database;
+use crate::{events::client::EventV1, Database};
 
 use revolt_result::Result;
 
@@ -16,12 +16,12 @@ impl UserSettingsImpl for UserSettings {
     async fn set(self, db: &Database, user: &str) -> Result<()> {
         db.set_user_settings(user, &self).await?;
 
-        /* // TODO: EventV1::UserSettingsUpdate {
+        EventV1::UserSettingsUpdate {
             id: user.to_string(),
             update: self,
         }
         .private(user.to_string())
-        .await; */
+        .await;
 
         Ok(())
     }

crates/core/database/src/models/users/mod.rs

@@ -2,8 +2,12 @@ mod model;
 mod ops;
 #[cfg(feature = "rocket-impl")]
 mod rocket;
+#[cfg(feature = "rocket-impl")]
+mod schema;
 
 #[cfg(feature = "rocket-impl")]
 pub use self::rocket::*;
+#[cfg(feature = "rocket-impl")]
+pub use self::schema::*;
 pub use model::*;
 pub use ops::*;

crates/core/database/src/models/users/model.rs

@@ -1,9 +1,14 @@
-use std::collections::HashSet;
+use std::{collections::HashSet, time::Duration};
 
-use crate::{Database, File};
+use crate::{events::client::EventV1, Database, File, RatelimitEvent};
 
 use once_cell::sync::Lazy;
-use revolt_result::{Error, ErrorType, Result};
+use rand::seq::SliceRandom;
+use revolt_config::config;
+use revolt_models::v0;
+use revolt_presence::filter_online;
+use revolt_result::{create_error, Result};
+use ulid::Ulid;
 
 auto_derived_partial!(
     /// # User
@@ -49,6 +54,15 @@ auto_derived_partial!(
 );
 
 auto_derived!(
+    /// Optional fields on user object
+    pub enum FieldsUser {
+        Avatar,
+        StatusText,
+        StatusPresence,
+        ProfileContent,
+        ProfileBackground,
+    }
+
     /// User's relationship with another user (or themselves)
     pub enum RelationshipStatus {
         None,
@@ -82,20 +96,22 @@ auto_derived!(
     }
 
     /// User's active status
+    #[derive(Default)]
     pub struct UserStatus {
         /// Custom status text
-        #[serde(skip_serializing_if = "String::is_empty", default)]
-        pub text: String,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub text: Option<String>,
         /// Current presence option
         #[serde(skip_serializing_if = "Option::is_none")]
         pub presence: Option<Presence>,
     }
 
     /// User's profile
+    #[derive(Default)]
     pub struct UserProfile {
         /// Text content on user's profile
-        #[serde(skip_serializing_if = "String::is_empty", default)]
-        pub content: String,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub content: Option<String>,
         /// Background visible on user's profile
         #[serde(skip_serializing_if = "Option::is_none")]
         pub background: Option<File>,
@@ -106,28 +122,414 @@ auto_derived!(
         /// Id of the owner of this bot
         pub owner: String,
     }
-
-    /// Optional fields on user object
-    pub enum FieldsUser {
-        Avatar,
-        StatusText,
-        StatusPresence,
-        ProfileContent,
-        ProfileBackground,
-    }
 );
 
+pub static DISCRIMINATOR_SEARCH_SPACE: Lazy<HashSet<String>> = Lazy::new(|| {
+    let mut set = (2..9999)
+        .map(|v| format!("{:0>4}", v))
+        .collect::<HashSet<String>>();
+
+    for discrim in [
+        123, 1234, 1111, 2222, 3333, 4444, 5555, 6666, 7777, 8888, 9999,
+    ] {
+        set.remove(&format!("{:0>4}", discrim));
+    }
+
+    set.into_iter().collect()
+});
+
+#[allow(clippy::derivable_impls)]
+impl Default for User {
+    fn default() -> Self {
+        Self {
+            id: Default::default(),
+            username: Default::default(),
+            discriminator: Default::default(),
+            display_name: Default::default(),
+            avatar: Default::default(),
+            relations: Default::default(),
+            badges: Default::default(),
+            status: Default::default(),
+            profile: Default::default(),
+            flags: Default::default(),
+            privileged: Default::default(),
+            bot: Default::default(),
+        }
+    }
+}
+
+#[allow(clippy::disallowed_methods)]
 impl User {
-    /// Check whether a username is already in use by another user
-    #[allow(dead_code)]
-    async fn is_username_taken(db: &Database, username: &str) -> Result<bool> {
-        match db.fetch_user_by_username(username).await {
-            Ok(_) => Ok(true),
-            Err(Error {
-                error_type: ErrorType::NotFound,
-                ..
-            }) => Ok(false),
-            Err(error) => Err(error),
+    /// Create a new user
+    pub async fn create<I, D>(
+        db: &Database,
+        username: String,
+        account_id: I,
+        data: D,
+    ) -> Result<User>
+    where
+        I: Into<Option<String>>,
+        D: Into<Option<PartialUser>>,
+    {
+        let username = User::validate_username(username)?;
+        let mut user = User {
+            id: account_id.into().unwrap_or_else(|| Ulid::new().to_string()),
+            discriminator: User::find_discriminator(db, &username, None).await?,
+            username,
+            ..Default::default()
+        };
+
+        if let Some(data) = data.into() {
+            user.apply_options(data);
+        }
+
+        db.insert_user(&user).await?;
+        Ok(user)
+    }
+
+    /// Get the relationship with another user
+    pub fn relationship_with(&self, user_b: &str) -> RelationshipStatus {
+        if self.id == user_b {
+            return RelationshipStatus::User;
+        }
+
+        if let Some(relations) = &self.relations {
+            if let Some(relationship) = relations.iter().find(|x| x.id == user_b) {
+                return relationship.status.clone();
+            }
+        }
+
+        RelationshipStatus::None
+    }
+
+    pub fn is_friends_with(&self, user_b: &str) -> bool {
+        matches!(
+            self.relationship_with(user_b),
+            RelationshipStatus::Friend | RelationshipStatus::User
+        )
+    }
+
+    /// Check whether two users have a mutual connection
+    ///
+    /// This will check if user and user_b share a server or a group.
+    pub async fn has_mutual_connection(&self, db: &Database, user_b: &str) -> Result<bool> {
+        Ok(!db
+            .fetch_mutual_server_ids(&self.id, user_b)
+            .await?
+            .is_empty()
+            || !db
+                .fetch_mutual_channel_ids(&self.id, user_b)
+                .await?
+                .is_empty())
+    }
+
+    /// Check if this user can acquire another server
+    pub async fn can_acquire_server(&self, db: &Database) -> Result<()> {
+        let config = config().await;
+        if db.fetch_server_count(&self.id).await? <= config.features.limits.default.servers {
+            Ok(())
+        } else {
+            Err(create_error!(TooManyServers {
+                max: config.features.limits.default.servers
+            }))
+        }
+    }
+
+    /// Sanitise and validate a username can be used
+    pub fn validate_username(username: String) -> Result<String> {
+        // Copy the username for validation
+        let username_lowercase = username.to_lowercase();
+
+        // Block homoglyphs
+        if decancer::cure(&username_lowercase).into_str() != username_lowercase {
+            return Err(create_error!(InvalidUsername));
+        }
+
+        // Ensure the username itself isn't blocked
+        const BLOCKED_USERNAMES: &[&str] = &["admin", "revolt"];
+
+        for username in BLOCKED_USERNAMES {
+            if username_lowercase == *username {
+                return Err(create_error!(InvalidUsername));
+            }
+        }
+
+        // Ensure none of the following substrings show up in the username
+        const BLOCKED_SUBSTRINGS: &[&str] = &["```"];
+
+        for substr in BLOCKED_SUBSTRINGS {
+            if username_lowercase.contains(substr) {
+                return Err(create_error!(InvalidUsername));
+            }
+        }
+
+        Ok(username)
+    }
+
+    /// Helper function to fetch many users as a mutually connected user
+    /// (while optimising the online ID query)
+    pub async fn fetch_many_ids_as_mutuals(
+        db: &Database,
+        perspective: &User,
+        ids: &[String],
+    ) -> Result<Vec<v0::User>> {
+        let online_ids = filter_online(ids).await;
+
+        Ok(db
+            .fetch_users(ids)
+            .await?
+            .into_iter()
+            .map(|user| {
+                let is_online = online_ids.contains(&user.id);
+                user.into_known(perspective, is_online)
+            })
+            .collect())
+    }
+
+    /// Find a free discriminator for a given username
+    pub async fn find_discriminator(
+        db: &Database,
+        username: &str,
+        preferred: Option<(String, String)>,
+    ) -> Result<String> {
+        let search_space: &HashSet<String> = &DISCRIMINATOR_SEARCH_SPACE;
+        let used_discriminators: HashSet<String> = db
+            .fetch_discriminators_in_use(username)
+            .await?
+            .into_iter()
+            .collect();
+
+        let available_discriminators: Vec<&String> =
+            search_space.difference(&used_discriminators).collect();
+
+        if available_discriminators.is_empty() {
+            return Err(create_error!(UsernameTaken));
+        }
+
+        if let Some((preferred, target_id)) = preferred {
+            if available_discriminators.contains(&&preferred) {
+                return Ok(preferred);
+            } else {
+                if db
+                    .has_ratelimited(
+                        &target_id,
+                        crate::RatelimitEventType::DiscriminatorChange,
+                        Duration::from_secs(60 * 60 * 24),
+                        1,
+                    )
+                    .await?
+                {
+                    return Err(create_error!(DiscriminatorChangeRatelimited));
+                }
+
+                RatelimitEvent::create(
+                    db,
+                    target_id,
+                    crate::RatelimitEventType::DiscriminatorChange,
+                )
+                .await?;
+            }
+        }
+
+        let mut rng = rand::thread_rng();
+        Ok(available_discriminators
+            .choose(&mut rng)
+            .expect("we can assert this has an element")
+            .to_string())
+    }
+
+    /// Update a user's username
+    pub async fn update_username(&mut self, db: &Database, username: String) -> Result<()> {
+        let username = User::validate_username(username)?;
+        if self.username.to_lowercase() == username.to_lowercase() {
+            self.update(
+                db,
+                PartialUser {
+                    username: Some(username),
+                    ..Default::default()
+                },
+                vec![],
+            )
+            .await
+        } else {
+            self.update(
+                db,
+                PartialUser {
+                    discriminator: Some(
+                        User::find_discriminator(
+                            db,
+                            &username,
+                            Some((self.discriminator.to_string(), self.id.clone())),
+                        )
+                        .await?,
+                    ),
+                    username: Some(username),
+                    ..Default::default()
+                },
+                vec![],
+            )
+            .await
+        }
+    }
+
+    /// Set a relationship to another user
+    pub async fn set_relationship(
+        &mut self,
+        db: &Database,
+        user_b: &User,
+        status: RelationshipStatus,
+    ) -> Result<()> {
+        db.set_relationship(&self.id, &user_b.id, &status).await?;
+
+        if let RelationshipStatus::None | RelationshipStatus::User = status {
+            if let Some(relations) = &mut self.relations {
+                relations.retain(|relation| relation.id != user_b.id);
+            }
+        } else {
+            let relation = Relationship {
+                id: user_b.id.to_string(),
+                status,
+            };
+
+            if let Some(relations) = &mut self.relations {
+                relations.retain(|relation| relation.id != user_b.id);
+                relations.push(relation);
+            } else {
+                self.relations = Some(vec![relation]);
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Apply a certain relationship between two users
+    pub async fn apply_relationship(
+        &mut self,
+        db: &Database,
+        target: &mut User,
+        local: RelationshipStatus,
+        remote: RelationshipStatus,
+    ) -> Result<()> {
+        target.set_relationship(db, self, remote).await?;
+        self.set_relationship(db, target, local).await?;
+
+        EventV1::UserRelationship {
+            id: target.id.clone(),
+            user: self.clone().into(db, Some(&*target)).await,
+        }
+        .private(target.id.clone())
+        .await;
+
+        EventV1::UserRelationship {
+            id: self.id.clone(),
+            user: target.clone().into(db, Some(&*self)).await,
+        }
+        .private(self.id.clone())
+        .await;
+
+        Ok(())
+    }
+
+    /// Add another user as a friend
+    pub async fn add_friend(&mut self, db: &Database, target: &mut User) -> Result<()> {
+        match self.relationship_with(&target.id) {
+            RelationshipStatus::User => Err(create_error!(NoEffect)),
+            RelationshipStatus::Friend => Err(create_error!(AlreadyFriends)),
+            RelationshipStatus::Outgoing => Err(create_error!(AlreadySentRequest)),
+            RelationshipStatus::Blocked => Err(create_error!(Blocked)),
+            RelationshipStatus::BlockedOther => Err(create_error!(BlockedByOther)),
+            RelationshipStatus::Incoming => {
+                self.apply_relationship(
+                    db,
+                    target,
+                    RelationshipStatus::Friend,
+                    RelationshipStatus::Friend,
+                )
+                .await
+            }
+            RelationshipStatus::None => {
+                self.apply_relationship(
+                    db,
+                    target,
+                    RelationshipStatus::Outgoing,
+                    RelationshipStatus::Incoming,
+                )
+                .await
+            }
+        }
+    }
+
+    /// Remove another user as a friend
+    pub async fn remove_friend(&mut self, db: &Database, target: &mut User) -> Result<()> {
+        match self.relationship_with(&target.id) {
+            RelationshipStatus::Friend
+            | RelationshipStatus::Outgoing
+            | RelationshipStatus::Incoming => {
+                self.apply_relationship(
+                    db,
+                    target,
+                    RelationshipStatus::None,
+                    RelationshipStatus::None,
+                )
+                .await
+            }
+            _ => Err(create_error!(NoEffect)),
+        }
+    }
+
+    /// Block another user
+    pub async fn block_user(&mut self, db: &Database, target: &mut User) -> Result<()> {
+        match self.relationship_with(&target.id) {
+            RelationshipStatus::User | RelationshipStatus::Blocked => Err(create_error!(NoEffect)),
+            RelationshipStatus::BlockedOther => {
+                self.apply_relationship(
+                    db,
+                    target,
+                    RelationshipStatus::Blocked,
+                    RelationshipStatus::Blocked,
+                )
+                .await
+            }
+            RelationshipStatus::None
+            | RelationshipStatus::Friend
+            | RelationshipStatus::Incoming
+            | RelationshipStatus::Outgoing => {
+                self.apply_relationship(
+                    db,
+                    target,
+                    RelationshipStatus::Blocked,
+                    RelationshipStatus::BlockedOther,
+                )
+                .await
+            }
+        }
+    }
+
+    /// Unblock another user
+    pub async fn unblock_user(&mut self, db: &Database, target: &mut User) -> Result<()> {
+        match self.relationship_with(&target.id) {
+            RelationshipStatus::Blocked => match target.relationship_with(&self.id) {
+                RelationshipStatus::Blocked => {
+                    self.apply_relationship(
+                        db,
+                        target,
+                        RelationshipStatus::BlockedOther,
+                        RelationshipStatus::Blocked,
+                    )
+                    .await
+                }
+                RelationshipStatus::BlockedOther => {
+                    self.apply_relationship(
+                        db,
+                        target,
+                        RelationshipStatus::None,
+                        RelationshipStatus::None,
+                    )
+                    .await
+                }
+                _ => Err(create_error!(InternalError)),
+            },
+            _ => Err(create_error!(NoEffect)),
         }
     }
 
@@ -145,13 +547,14 @@ impl User {
         self.apply_options(partial.clone());
         db.update_user(&self.id, &partial, remove.clone()).await?;
 
-        /* // TODO: EventV1::UserUpdate {
+        EventV1::UserUpdate {
             id: self.id.clone(),
-            data: partial,
-            clear: remove,
+            data: partial.into(),
+            clear: remove.into_iter().map(|v| v.into()).collect(),
+            event_id: Some(Ulid::new().to_string()),
         }
         .p_user(self.id.clone(), db)
-        .await; */
+        .await;
 
         Ok(())
     }
@@ -162,7 +565,7 @@ impl User {
             FieldsUser::Avatar => self.avatar = None,
             FieldsUser::StatusText => {
                 if let Some(x) = self.status.as_mut() {
-                    x.text = String::new();
+                    x.text = None;
                 }
             }
             FieldsUser::StatusPresence => {
@@ -172,7 +575,7 @@ impl User {
             }
             FieldsUser::ProfileContent => {
                 if let Some(x) = self.profile.as_mut() {
-                    x.content = String::new();
+                    x.content = None;
                 }
             }
             FieldsUser::ProfileBackground => {
@@ -203,17 +606,3 @@ impl User {
         .await
     }
 }
-
-pub static DISCRIMINATOR_SEARCH_SPACE: Lazy<HashSet<String>> = Lazy::new(|| {
-    let mut set = (2..9999)
-        .map(|v| format!("{:0>4}", v))
-        .collect::<HashSet<String>>();
-
-    for discrim in [
-        123, 1234, 1111, 2222, 3333, 4444, 5555, 6666, 7777, 8888, 9999,
-    ] {
-        set.remove(&format!("{:0>4}", discrim));
-    }
-
-    set.into_iter().collect()
-});

crates/core/database/src/models/users/ops.rs

@@ -14,7 +14,7 @@ pub trait AbstractUsers: Sync + Send {
     async fn fetch_user(&self, id: &str) -> Result<User>;
 
     /// Fetch a user from the database by their username
-    async fn fetch_user_by_username(&self, username: &str) -> Result<User>;
+    async fn fetch_user_by_username(&self, username: &str, discriminator: &str) -> Result<User>;
 
     /// Fetch a user from the database by their session token
     async fn fetch_user_by_token(&self, token: &str) -> Result<User>;
@@ -22,6 +22,9 @@ pub trait AbstractUsers: Sync + Send {
     /// Fetch multiple users by their ids
     async fn fetch_users<'a>(&self, ids: &'a [String]) -> Result<Vec<User>>;
 
+    /// Fetch all discriminators in use for a username
+    async fn fetch_discriminators_in_use(&self, username: &str) -> Result<Vec<String>>;
+
     /// Fetch ids of users that both users are friends with
     async fn fetch_mutual_user_ids(&self, user_a: &str, user_b: &str) -> Result<Vec<String>>;
 

crates/core/database/src/models/users/ops/mongodb.rs

@@ -25,13 +25,14 @@ impl AbstractUsers for MongoDb {
     }
 
     /// Fetch a user from the database by their username
-    async fn fetch_user_by_username(&self, username: &str) -> Result<User> {
+    async fn fetch_user_by_username(&self, username: &str, discriminator: &str) -> Result<User> {
         query!(
             self,
             find_one_with_options,
             COL,
             doc! {
-                "username": username
+                "username": username,
+                "discriminator": discriminator
             },
             FindOneOptions::builder()
                 .collation(
@@ -87,6 +88,39 @@ impl AbstractUsers for MongoDb {
             .await)
     }
 
+    /// Fetch all discriminators in use for a username
+    async fn fetch_discriminators_in_use(&self, username: &str) -> Result<Vec<String>> {
+        #[derive(Deserialize)]
+        struct UserDocument {
+            discriminator: String,
+        }
+
+        Ok(self
+            .col::<UserDocument>(COL)
+            .find(
+                doc! {
+                    "username": username
+                },
+                FindOptions::builder()
+                    .collation(
+                        Collation::builder()
+                            .locale("en")
+                            .strength(CollationStrength::Secondary)
+                            .build(),
+                    )
+                    .projection(doc! { "_id": 0, "discriminator": 1 })
+                    .build(),
+            )
+            .await
+            .map_err(|_| create_database_error!("find", COL))?
+            .filter_map(|s| async { s.ok() })
+            .collect::<Vec<UserDocument>>()
+            .await
+            .into_iter()
+            .map(|user| user.discriminator)
+            .collect::<Vec<String>>())
+    }
+
     /// Fetch ids of users that both users are friends with
     async fn fetch_mutual_user_ids(&self, user_a: &str, user_b: &str) -> Result<Vec<String>> {
         Ok(self

crates/core/database/src/models/users/ops/reference.rs

@@ -1,7 +1,7 @@
 use revolt_result::Result;
 
-use crate::ReferenceDb;
 use crate::{FieldsUser, PartialUser, RelationshipStatus, User};
+use crate::{ReferenceDb, Relationship};
 
 use super::AbstractUsers;
 
@@ -28,12 +28,14 @@ impl AbstractUsers for ReferenceDb {
     }
 
     /// Fetch a user from the database by their username
-    async fn fetch_user_by_username(&self, username: &str) -> Result<User> {
+    async fn fetch_user_by_username(&self, username: &str, discriminator: &str) -> Result<User> {
         let users = self.users.lock().await;
         let lowercase = username.to_lowercase();
         users
             .values()
-            .find(|user| user.username.to_lowercase() == lowercase)
+            .find(|user| {
+                user.username.to_lowercase() == lowercase && user.discriminator == discriminator
+            })
             .cloned()
             .ok_or_else(|| create_error!(NotFound))
     }
@@ -56,6 +58,18 @@ impl AbstractUsers for ReferenceDb {
             .collect()
     }
 
+    /// Fetch all discriminators in use for a username
+    async fn fetch_discriminators_in_use(&self, username: &str) -> Result<Vec<String>> {
+        let users = self.users.lock().await;
+        let lowercase = username.to_lowercase();
+        Ok(users
+            .values()
+            .filter(|user| user.username.to_lowercase() == lowercase)
+            .map(|user| &user.discriminator)
+            .cloned()
+            .collect())
+    }
+
     /// Fetch ids of users that both users are friends with
     async fn fetch_mutual_user_ids(&self, _user_a: &str, _user_b: &str) -> Result<Vec<String>> {
         todo!()
@@ -94,19 +108,49 @@ impl AbstractUsers for ReferenceDb {
 
     /// Set relationship with another user
     ///
-    /// This should use pull_relationship if relationship is None.
+    /// This should use pull_relationship if relationship is None or User.
     async fn set_relationship(
         &self,
-        _user_id: &str,
-        _target_id: &str,
-        _relationship: &RelationshipStatus,
+        user_id: &str,
+        target_id: &str,
+        relationship: &RelationshipStatus,
     ) -> Result<()> {
-        todo!()
+        if let RelationshipStatus::User | RelationshipStatus::None = &relationship {
+            self.pull_relationship(user_id, target_id).await
+        } else {
+            let mut users = self.users.lock().await;
+            let user = users
+                .get_mut(user_id)
+                .ok_or_else(|| create_error!(NotFound))?;
+
+            let relation = Relationship {
+                id: target_id.to_string(),
+                status: relationship.clone(),
+            };
+
+            if let Some(relations) = &mut user.relations {
+                relations.retain(|relation| relation.id != target_id);
+                relations.push(relation);
+            } else {
+                user.relations = Some(vec![relation]);
+            }
+
+            Ok(())
+        }
     }
 
     /// Remove relationship with another user
-    async fn pull_relationship(&self, _user_id: &str, _target_id: &str) -> Result<()> {
-        todo!()
+    async fn pull_relationship(&self, user_id: &str, target_id: &str) -> Result<()> {
+        let mut users = self.users.lock().await;
+        let user = users
+            .get_mut(user_id)
+            .ok_or_else(|| create_error!(NotFound))?;
+
+        if let Some(relations) = &mut user.relations {
+            relations.retain(|relation| relation.id != target_id);
+        }
+
+        Ok(())
     }
 
     /// Delete a user by their id

crates/core/database/src/models/users/rocket.rs

@@ -13,19 +13,19 @@ impl<'r> FromRequest<'r> for User {
             .local_cache_async(async {
                 let db = request.rocket().state::<Database>().expect("`Database`");
 
-                let _header_bot_token = request
+                let header_bot_token = request
                     .headers()
                     .get("x-bot-token")
                     .next()
                     .map(|x| x.to_string());
 
-                /* if let Some(bot_token) = header_bot_token {
-                    if let Ok(user) = User::from_token(db, &bot_token, UserHint::Bot).await {
-                        return Some(user);
+                if let Some(bot_token) = header_bot_token {
+                    if let Ok(bot) = db.fetch_bot_by_token(&bot_token).await {
+                        if let Ok(user) = db.fetch_user(&bot.id).await {
+                            return Some(user);
+                        }
                     }
-                } else */
-                if let Outcome::Success(session) = request.guard::<Session>().await {
-                    // This uses a guard so can't really easily be refactored into from_token at this stage.
+                } else if let Outcome::Success(session) = request.guard::<Session>().await {
                     if let Ok(user) = db.fetch_user(&session.user_id).await {
                         return Some(user);
                     }

crates/core/database/src/models/users/schema.rs

@@ -0,0 +1,31 @@
+use revolt_okapi::openapi3::{SecurityScheme, SecuritySchemeData};
+use revolt_rocket_okapi::{
+    gen::OpenApiGenerator,
+    request::{OpenApiFromRequest, RequestHeaderInput},
+};
+
+use crate::User;
+
+impl<'r> OpenApiFromRequest<'r> for User {
+    fn from_request_input(
+        _gen: &mut OpenApiGenerator,
+        _name: String,
+        _required: bool,
+    ) -> revolt_rocket_okapi::Result<RequestHeaderInput> {
+        let mut requirements = schemars::Map::new();
+        requirements.insert("Session Token".to_owned(), vec![]);
+
+        Ok(RequestHeaderInput::Security(
+            "Session Token".to_owned(),
+            SecurityScheme {
+                data: SecuritySchemeData::ApiKey {
+                    name: "x-session-token".to_owned(),
+                    location: "header".to_owned(),
+                },
+                description: Some("Used to authenticate as a user.".to_owned()),
+                extensions: schemars::Map::new(),
+            },
+            requirements,
+        ))
+    }
+}

crates/core/database/src/tasks/ack.rs

@@ -0,0 +1,122 @@
+// Queue Type: Debounced
+use crate::Database;
+
+use deadqueue::limited::Queue;
+use once_cell::sync::Lazy;
+use std::{collections::HashMap, time::Duration};
+
+use super::DelayedTask;
+
+/// Enumeration of possible events
+#[derive(Debug, Eq, PartialEq)]
+pub enum AckEvent {
+    /// Add mentions for a user in a channel
+    AddMention {
+        /// Message IDs
+        ids: Vec<String>,
+    },
+
+    /// Acknowledge message in a channel for a user
+    AckMessage {
+        /// Message ID
+        id: String,
+    },
+}
+
+/// Task information
+struct Data {
+    /// Channel to ack
+    channel: String,
+    /// User to ack for
+    user: String,
+    /// Event
+    event: AckEvent,
+}
+
+#[derive(Debug)]
+struct Task {
+    event: AckEvent,
+}
+
+static Q: Lazy<Queue<Data>> = Lazy::new(|| Queue::new(10_000));
+
+/// Queue a new task for a worker
+pub async fn queue(channel: String, user: String, event: AckEvent) {
+    Q.try_push(Data {
+        channel,
+        user,
+        event,
+    })
+    .ok();
+
+    info!("Queue is using {} slots from {}.", Q.len(), Q.capacity());
+}
+
+/// Start a new worker
+pub async fn worker(db: Database) {
+    let mut tasks = HashMap::<(String, String), DelayedTask<Task>>::new();
+    let mut keys = vec![];
+
+    loop {
+        // Find due tasks.
+        for (key, task) in &tasks {
+            if task.should_run() {
+                keys.push(key.clone());
+            }
+        }
+
+        // Commit any due tasks to the database.
+        for key in &keys {
+            if let Some(task) = tasks.remove(key) {
+                let Task { event } = task.data;
+                let (user, channel) = key;
+
+                if let Err(err) = match &event {
+                    #[allow(clippy::disallowed_methods)] // event is sent by higher level function
+                    AckEvent::AckMessage { id } => db.acknowledge_message(channel, user, id).await,
+                    AckEvent::AddMention { ids } => {
+                        db.add_mention_to_unread(channel, user, ids).await
+                    }
+                } {
+                    error!("{err:?} for {event:?}. ({user}, {channel})");
+                } else {
+                    info!("User {user} ack in {channel} with {event:?}");
+                }
+            }
+        }
+
+        // Clear keys
+        keys.clear();
+
+        // Queue incoming tasks.
+        while let Some(Data {
+            channel,
+            user,
+            mut event,
+        }) = Q.try_pop()
+        {
+            let key = (user, channel);
+            if let Some(task) = tasks.get_mut(&key) {
+                task.delay();
+
+                match &mut event {
+                    AckEvent::AddMention { ids } => {
+                        if let AckEvent::AddMention { ids: existing } = &mut task.data.event {
+                            existing.append(ids);
+                        } else {
+                            task.data.event = event;
+                        }
+                    }
+                    AckEvent::AckMessage { .. } => {
+                        task.data.event = event;
+                    }
+                }
+            } else {
+                tasks.insert(key, DelayedTask::new(Task { event }));
+            }
+        }
+
+        // Sleep for an arbitrary amount of time.
+        async_std::task::sleep(Duration::from_secs(1)).await;
+    }
+}

crates/core/database/src/tasks/last_message_id.rs

@@ -0,0 +1,87 @@
+// Queue Type: Debounced
+use deadqueue::limited::Queue;
+use once_cell::sync::Lazy;
+use std::{collections::HashMap, time::Duration};
+
+use crate::{Database, PartialChannel};
+
+use super::DelayedTask;
+
+/// Task information
+struct Data {
+    /// Channel to update
+    channel: String,
+    /// Latest message ID
+    id: String,
+    /// Whether the channel is a DM
+    is_dm: bool,
+}
+
+/// Task information
+#[derive(Debug)]
+struct Task {
+    /// Latest message ID
+    id: String,
+    /// Whether the channel is a DM
+    is_dm: bool,
+}
+
+static Q: Lazy<Queue<Data>> = Lazy::new(|| Queue::new(10_000));
+
+/// Queue a new task for a worker
+pub async fn queue(channel: String, id: String, is_dm: bool) {
+    Q.try_push(Data { channel, id, is_dm }).ok();
+    info!("Queue is using {} slots from {}.", Q.len(), Q.capacity());
+}
+
+/// Start a new worker
+pub async fn worker(db: Database) {
+    let mut tasks = HashMap::<String, DelayedTask<Task>>::new();
+    let mut keys = vec![];
+
+    loop {
+        // Find due tasks.
+        for (key, task) in &tasks {
+            if task.should_run() {
+                keys.push(key.clone());
+            }
+        }
+
+        // Commit any due tasks to the database.
+        for key in &keys {
+            if let Some(task) = tasks.remove(key) {
+                let Task { id, is_dm, .. } = task.data;
+
+                let mut channel = PartialChannel {
+                    last_message_id: Some(id.to_string()),
+                    ..Default::default()
+                };
+
+                if is_dm {
+                    channel.active = Some(true);
+                }
+
+                match db.update_channel(key, &channel, vec![]).await {
+                    Ok(_) => info!("Updated last_message_id for {key} to {id}."),
+                    Err(err) => error!("Failed to update last_message_id with {err:?}!"),
+                }
+            }
+        }
+
+        // Clear keys
+        keys.clear();
+
+        // Queue incoming tasks.
+        while let Some(Data { channel, id, is_dm }) = Q.try_pop() {
+            if let Some(task) = tasks.get_mut(&channel) {
+                task.data.id = id;
+                task.delay();
+            } else {
+                tasks.insert(channel, DelayedTask::new(Task { id, is_dm }));
+            }
+        }
+
+        // Sleep for an arbitrary amount of time.
+        async_std::task::sleep(Duration::from_secs(1)).await;
+    }
+}

crates/core/database/src/tasks/mod.rs

@@ -0,0 +1,58 @@
+//! Semi-important background task management
+
+use crate::Database;
+
+use async_std::task;
+use std::time::Instant;
+
+const WORKER_COUNT: usize = 5;
+
+pub mod ack;
+pub mod last_message_id;
+pub mod process_embeds;
+pub mod web_push;
+
+/// Spawn background workers
+pub async fn start_workers(db: Database, authifier_db: authifier::Database) {
+    for _ in 0..WORKER_COUNT {
+        task::spawn(ack::worker(db.clone()));
+        task::spawn(last_message_id::worker(db.clone()));
+        task::spawn(process_embeds::worker(db.clone()));
+        task::spawn(web_push::worker(authifier_db.clone()));
+    }
+}
+
+/// Task with additional information on when it should run
+pub struct DelayedTask<T> {
+    pub data: T,
+    last_updated: Instant,
+    first_seen: Instant,
+}
+
+/// Commit to database every 30 seconds if the task is particularly active.
+static EXPIRE_CONSTANT: u64 = 30;
+
+/// Otherwise, commit to database after 5 seconds.
+static SAVE_CONSTANT: u64 = 5;
+
+impl<T> DelayedTask<T> {
+    /// Create a new delayed task
+    pub fn new(data: T) -> Self {
+        DelayedTask {
+            data,
+            last_updated: Instant::now(),
+            first_seen: Instant::now(),
+        }
+    }
+
+    /// Push a task further back in time
+    pub fn delay(&mut self) {
+        self.last_updated = Instant::now()
+    }
+
+    /// Check if a task should run yet
+    pub fn should_run(&self) -> bool {
+        self.first_seen.elapsed().as_secs() > EXPIRE_CONSTANT
+            || self.last_updated.elapsed().as_secs() > SAVE_CONSTANT
+    }
+}

crates/core/database/src/tasks/process_embeds.rs

@@ -0,0 +1,170 @@
+use crate::{models::Message, AppendMessage, Database};
+
+use futures::future::join_all;
+use linkify::{LinkFinder, LinkKind};
+use regex::Regex;
+use revolt_config::config;
+use revolt_result::Result;
+
+use async_lock::Semaphore;
+use async_std::task::spawn;
+use deadqueue::limited::Queue;
+use once_cell::sync::Lazy;
+use revolt_models::v0::Embed;
+use std::{collections::HashSet, sync::Arc};
+
+use isahc::prelude::*;
+
+/// Task information
+#[derive(Debug)]
+struct EmbedTask {
+    /// Channel we're processing the event in
+    channel: String,
+    /// ID of the message we're processing
+    id: String,
+    /// Content of the message
+    content: String,
+}
+
+static Q: Lazy<Queue<EmbedTask>> = Lazy::new(|| Queue::new(10_000));
+
+/// Queue a new task for a worker
+pub async fn queue(channel: String, id: String, content: String) {
+    Q.try_push(EmbedTask {
+        channel,
+        id,
+        content,
+    })
+    .ok();
+
+    info!("Queue is using {} slots from {}.", Q.len(), Q.capacity());
+}
+
+/// Start a new worker
+pub async fn worker(db: Database) {
+    let semaphore = Arc::new(Semaphore::new(
+        config().await.api.workers.max_concurrent_connections,
+    ));
+
+    loop {
+        let task = Q.pop().await;
+        let db = db.clone();
+        let semaphore = semaphore.clone();
+
+        spawn(async move {
+            let config = config().await;
+            let embeds = generate(
+                task.content,
+                &config.hosts.january,
+                config.features.limits.default.message_embeds,
+                semaphore,
+            )
+            .await;
+
+            if let Ok(embeds) = embeds {
+                if let Err(err) = Message::append(
+                    &db,
+                    task.id,
+                    task.channel,
+                    AppendMessage {
+                        embeds: Some(embeds),
+                    },
+                )
+                .await
+                {
+                    error!("Encountered an error appending to message: {:?}", err);
+                }
+            }
+        });
+    }
+}
+
+static RE_CODE: Lazy<Regex> = Lazy::new(|| Regex::new("```(?:.|\n)+?```|`(?:.|\n)+?`").unwrap());
+static RE_IGNORED: Lazy<Regex> = Lazy::new(|| Regex::new("(<http.+>)").unwrap());
+
+pub async fn generate(
+    content: String,
+    host: &str,
+    max_embeds: usize,
+    semaphore: Arc<Semaphore>,
+) -> Result<Vec<Embed>> {
+    // Ignore code blocks.
+    let content = RE_CODE.replace_all(&content, "");
+
+    // Ignore all content between angle brackets starting with http.
+    let content = RE_IGNORED.replace_all(&content, "");
+
+    let content = content
+        // Ignore quoted lines.
+        .split('\n')
+        .map(|v| {
+            if let Some(c) = v.chars().next() {
+                if c == '>' {
+                    return "";
+                }
+            }
+
+            v
+        })
+        .collect::<Vec<&str>>()
+        .join("\n");
+
+    let mut finder = LinkFinder::new();
+    finder.kinds(&[LinkKind::Url]);
+
+    // Process all links, stripping anchors and
+    // only taking up to `max_embeds` of links.
+    let links: Vec<String> = finder
+        .links(&content)
+        .map(|x| {
+            x.as_str()
+                .chars()
+                .take_while(|&ch| ch != '#')
+                .collect::<String>()
+        })
+        .collect::<HashSet<String>>()
+        .into_iter()
+        .take(max_embeds)
+        .collect();
+
+    // If no links, fail out.
+    if links.is_empty() {
+        return Err(create_error!(LabelMe));
+    }
+
+    // TODO: batch request to january
+    let mut tasks = Vec::new();
+
+    for link in links {
+        let semaphore = semaphore.clone();
+        let host = host.to_string();
+        tasks.push(spawn(async move {
+            let guard = semaphore.acquire().await;
+
+            if let Ok(mut response) = isahc::get_async(format!(
+                "{host}/embed?url={}",
+                url_escape::encode_component(&link)
+            ))
+            .await
+            {
+                drop(guard);
+                response.json::<Embed>().await.ok()
+            } else {
+                None
+            }
+        }));
+    }
+
+    let embeds = join_all(tasks)
+        .await
+        .into_iter()
+        .flatten()
+        .collect::<Vec<Embed>>();
+
+    // Prevent database update when no embeds are found.
+    if !embeds.is_empty() {
+        Ok(embeds)
+    } else {
+        Err(create_error!(LabelMe))
+    }
+}

crates/core/database/src/tasks/web_push.rs

@@ -0,0 +1,162 @@
+use std::collections::HashSet;
+
+use authifier::Database;
+use base64::{
+    engine::{self},
+    Engine as _,
+};
+use deadqueue::limited::Queue;
+use once_cell::sync::Lazy;
+use revolt_config::config;
+use revolt_models::v0::PushNotification;
+use revolt_presence::filter_online;
+use serde_json::json;
+use web_push::{
+    ContentEncoding, IsahcWebPushClient, SubscriptionInfo, SubscriptionKeys, VapidSignatureBuilder,
+    WebPushClient, WebPushMessageBuilder,
+};
+
+/// Task information
+#[derive(Debug)]
+struct PushTask {
+    /// User IDs of the targets that are to receive this notification
+    recipients: Vec<String>,
+    /// Push Notification
+    payload: PushNotification,
+}
+
+static Q: Lazy<Queue<PushTask>> = Lazy::new(|| Queue::new(10_000));
+
+/// Queue a new task for a worker
+pub async fn queue(recipients: Vec<String>, payload: PushNotification) {
+    if recipients.is_empty() {
+        return;
+    }
+
+    let online_ids = filter_online(&recipients).await;
+    let recipients = (&recipients.into_iter().collect::<HashSet<String>>() - &online_ids)
+        .into_iter()
+        .collect::<Vec<String>>();
+
+    Q.try_push(PushTask {
+        recipients,
+        payload,
+    })
+    .ok();
+
+    info!("Queue is using {} slots from {}.", Q.len(), Q.capacity());
+}
+
+/// Start a new worker
+pub async fn worker(db: Database) {
+    let config = config().await;
+
+    let web_push_client = IsahcWebPushClient::new().unwrap();
+    let fcm_client = if config.api.fcm.api_key.is_empty() {
+        None
+    } else {
+        Some(fcm::Client::new())
+    };
+
+    let web_push_private_key = engine::general_purpose::URL_SAFE_NO_PAD
+        .decode(config.api.vapid.private_key)
+        .expect("valid `VAPID_PRIVATE_KEY`");
+
+    loop {
+        let task = Q.pop().await;
+
+        if let Ok(sessions) = db.find_sessions_with_subscription(&task.recipients).await {
+            for session in sessions {
+                if let Some(sub) = session.subscription {
+                    if sub.endpoint == "fcm" {
+                        // Use Firebase Cloud Messaging
+                        if let Some(client) = &fcm_client {
+                            let PushNotification {
+                                author,
+                                icon,
+                                image: _,
+                                body,
+                                tag,
+                                timestamp: _,
+                                url: _,
+                            } = &task.payload;
+
+                            let mut notification = fcm::NotificationBuilder::new();
+                            notification.title(author);
+                            notification.icon(icon);
+                            notification.body(body);
+                            notification.tag(tag);
+                            // TODO: expand support for fields
+                            let notification = notification.finalize();
+
+                            let mut message_builder =
+                                fcm::MessageBuilder::new(&config.api.fcm.api_key, &sub.auth);
+                            message_builder.notification(notification);
+
+                            if let Err(err) = client.send(message_builder.finalize()).await {
+                                error!("Failed to send FCM notification! {:?}", err);
+                            } else {
+                                info!("Sent FCM notification to {:?}.", session.id);
+                            }
+                        } else {
+                            info!("No FCM token was specified!");
+                        }
+                    } else {
+                        // Use Web Push Standard
+                        let subscription = SubscriptionInfo {
+                            endpoint: sub.endpoint,
+                            keys: SubscriptionKeys {
+                                auth: sub.auth,
+                                p256dh: sub.p256dh,
+                            },
+                        };
+
+                        match VapidSignatureBuilder::from_pem(
+                            std::io::Cursor::new(&web_push_private_key),
+                            &subscription,
+                        ) {
+                            Ok(sig_builder) => match sig_builder.build() {
+                                Ok(signature) => {
+                                    let mut builder = WebPushMessageBuilder::new(&subscription);
+                                    builder.set_vapid_signature(signature);
+
+                                    let payload = json!(task.payload).to_string();
+                                    builder
+                                        .set_payload(ContentEncoding::AesGcm, payload.as_bytes());
+
+                                    match builder.build() {
+                                        Ok(msg) => match web_push_client.send(msg).await {
+                                            Ok(_) => {
+                                                info!(
+                                                    "Sent Web Push notification to {:?}.",
+                                                    session.id
+                                                )
+                                            }
+                                            Err(err) => {
+                                                error!("Hit error sending Web Push! {:?}", err)
+                                            }
+                                        },
+                                        Err(err) => {
+                                            error!(
+                                                "Failed to build message for {}! {:?}",
+                                                session.user_id, err
+                                            )
+                                        }
+                                    }
+                                }
+                                Err(err) => error!(
+                                    "Failed to build signature for {}! {:?}",
+                                    session.user_id, err
+                                ),
+                            },
+                            Err(err) => error!(
+                                "Failed to create signature builder for {}! {:?}",
+                                session.user_id, err
+                            ),
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

crates/core/database/src/util/bridge/v0.rs

@@ -1,14 +1,7 @@
 use revolt_models::v0::*;
+use revolt_permissions::{calculate_user_permissions, UserPermission};
 
-impl From<crate::AccountStrike> for AccountStrike {
-    fn from(value: crate::AccountStrike) -> Self {
-        AccountStrike {
-            id: value.id,
-            user_id: value.user_id,
-            reason: value.reason,
-        }
-    }
-}
+use crate::{util::permissions::DatabasePermissionQuery, Database};
 
 impl crate::Bot {
     pub fn into_public_bot(self, user: crate::User) -> PublicBot {
@@ -22,6 +15,7 @@ impl crate::Bot {
             description: user
                 .profile
                 .map(|profile| profile.content)
+                .flatten()
                 .unwrap_or_default(),
         }
     }
@@ -44,6 +38,70 @@ impl From<crate::Bot> for Bot {
     }
 }
 
+impl From<FieldsBot> for crate::FieldsBot {
+    fn from(value: FieldsBot) -> Self {
+        match value {
+            FieldsBot::InteractionsURL => crate::FieldsBot::InteractionsURL,
+            FieldsBot::Token => crate::FieldsBot::Token,
+        }
+    }
+}
+
+impl From<crate::FieldsBot> for FieldsBot {
+    fn from(value: crate::FieldsBot) -> Self {
+        match value {
+            crate::FieldsBot::InteractionsURL => FieldsBot::InteractionsURL,
+            crate::FieldsBot::Token => FieldsBot::Token,
+        }
+    }
+}
+
+impl From<crate::Invite> for Invite {
+    fn from(value: crate::Invite) -> Self {
+        match value {
+            crate::Invite::Group {
+                code,
+                creator,
+                channel,
+            } => Invite::Group {
+                code,
+                creator,
+                channel,
+            },
+            crate::Invite::Server {
+                code,
+                server,
+                creator,
+                channel,
+            } => Invite::Server {
+                code,
+                server,
+                creator,
+                channel,
+            },
+        }
+    }
+}
+
+impl From<crate::ChannelUnread> for ChannelUnread {
+    fn from(value: crate::ChannelUnread) -> Self {
+        ChannelUnread {
+            id: value.id.into(),
+            last_id: value.last_id,
+            mentions: value.mentions.unwrap_or_default(),
+        }
+    }
+}
+
+impl From<crate::ChannelCompositeKey> for ChannelCompositeKey {
+    fn from(value: crate::ChannelCompositeKey) -> Self {
+        ChannelCompositeKey {
+            channel: value.channel,
+            user: value.user,
+        }
+    }
+}
+
 impl From<crate::Webhook> for Webhook {
     fn from(value: crate::Webhook) -> Self {
         Webhook {
@@ -52,7 +110,7 @@ impl From<crate::Webhook> for Webhook {
             avatar: value.avatar.map(|file| file.into()),
             channel_id: value.channel_id,
             token: value.token,
-            permissions: value.permissions
+            permissions: value.permissions,
         }
     }
 }
@@ -65,7 +123,7 @@ impl From<crate::PartialWebhook> for PartialWebhook {
             avatar: value.avatar.map(|file| file.into()),
             channel_id: value.channel_id,
             token: value.token,
-            permissions: value.permissions
+            permissions: value.permissions,
         }
     }
 }
@@ -199,6 +257,37 @@ impl From<crate::FieldsChannel> for FieldsChannel {
     }
 }
 
+impl From<crate::Emoji> for Emoji {
+    fn from(value: crate::Emoji) -> Self {
+        Emoji {
+            id: value.id,
+            parent: value.parent.into(),
+            creator_id: value.creator_id,
+            name: value.name,
+            animated: value.animated,
+            nsfw: value.nsfw,
+        }
+    }
+}
+
+impl From<crate::EmojiParent> for EmojiParent {
+    fn from(value: crate::EmojiParent) -> Self {
+        match value {
+            crate::EmojiParent::Detached => EmojiParent::Detached,
+            crate::EmojiParent::Server { id } => EmojiParent::Server { id },
+        }
+    }
+}
+
+impl From<EmojiParent> for crate::EmojiParent {
+    fn from(value: EmojiParent) -> Self {
+        match value {
+            EmojiParent::Detached => crate::EmojiParent::Detached,
+            EmojiParent::Server { id } => crate::EmojiParent::Server { id },
+        }
+    }
+}
+
 impl From<crate::File> for File {
     fn from(value: crate::File) -> Self {
         File {
@@ -236,36 +325,439 @@ impl From<crate::Metadata> for Metadata {
     }
 }
 
-impl crate::User {
-    pub async fn into<P>(self, perspective: P) -> User
-    where
-        P: Into<Option<crate::User>>,
-    {
-        let relationship = if let Some(perspective) = perspective.into() {
-            perspective
-                .relations
-                .unwrap_or_default()
-                .into_iter()
-                .find(|relationship| relationship.id == self.id)
-                .map(|relationship| relationship.status.into())
-                .unwrap_or_default()
-        } else {
-            RelationshipStatus::None
-        };
+impl From<crate::Message> for Message {
+    fn from(value: crate::Message) -> Self {
+        Message {
+            id: value.id,
+            nonce: value.nonce,
+            channel: value.channel,
+            author: value.author,
+            webhook: value.webhook,
+            content: value.content,
+            system: value.system.map(|system| system.into()),
+            attachments: value
+                .attachments
+                .map(|v| v.into_iter().map(|f| f.into()).collect()),
+            edited: value.edited,
+            embeds: value.embeds,
+            mentions: value.mentions,
+            replies: value.replies,
+            reactions: value.reactions,
+            interactions: value.interactions.into(),
+            masquerade: value.masquerade.map(|masq| masq.into()),
+        }
+    }
+}
 
-        // do permission stuff here
-        // TODO: implement permissions =)
-        let can_see_profile = false;
+impl From<crate::PartialMessage> for PartialMessage {
+    fn from(value: crate::PartialMessage) -> Self {
+        PartialMessage {
+            id: value.id,
+            nonce: value.nonce,
+            channel: value.channel,
+            author: value.author,
+            webhook: value.webhook,
+            content: value.content,
+            system: value.system.map(|system| system.into()),
+            attachments: value
+                .attachments
+                .map(|v| v.into_iter().map(|f| f.into()).collect()),
+            edited: value.edited,
+            embeds: value.embeds,
+            mentions: value.mentions,
+            replies: value.replies,
+            reactions: value.reactions,
+            interactions: value.interactions.map(|interactions| interactions.into()),
+            masquerade: value.masquerade.map(|masq| masq.into()),
+        }
+    }
+}
+
+impl From<crate::SystemMessage> for SystemMessage {
+    fn from(value: crate::SystemMessage) -> Self {
+        match value {
+            crate::SystemMessage::ChannelDescriptionChanged { by } => {
+                Self::ChannelDescriptionChanged { by }
+            }
+            crate::SystemMessage::ChannelIconChanged { by } => Self::ChannelIconChanged { by },
+            crate::SystemMessage::ChannelOwnershipChanged { from, to } => {
+                Self::ChannelOwnershipChanged { from, to }
+            }
+            crate::SystemMessage::ChannelRenamed { name, by } => Self::ChannelRenamed { name, by },
+            crate::SystemMessage::Text { content } => Self::Text { content },
+            crate::SystemMessage::UserAdded { id, by } => Self::UserAdded { id, by },
+            crate::SystemMessage::UserBanned { id } => Self::UserBanned { id },
+            crate::SystemMessage::UserJoined { id } => Self::UserJoined { id },
+            crate::SystemMessage::UserKicked { id } => Self::UserKicked { id },
+            crate::SystemMessage::UserLeft { id } => Self::UserLeft { id },
+            crate::SystemMessage::UserRemove { id, by } => Self::UserRemove { id, by },
+        }
+    }
+}
+
+impl From<crate::Interactions> for Interactions {
+    fn from(value: crate::Interactions) -> Self {
+        Interactions {
+            reactions: value
+                .reactions
+                .map(|reactions| reactions.into_iter().collect()),
+            restrict_reactions: value.restrict_reactions,
+        }
+    }
+}
+
+impl From<Interactions> for crate::Interactions {
+    fn from(value: Interactions) -> Self {
+        crate::Interactions {
+            reactions: value
+                .reactions
+                .map(|reactions| reactions.into_iter().collect()),
+            restrict_reactions: value.restrict_reactions,
+        }
+    }
+}
+
+impl From<crate::AppendMessage> for AppendMessage {
+    fn from(value: crate::AppendMessage) -> Self {
+        AppendMessage {
+            embeds: value.embeds,
+        }
+    }
+}
+
+impl From<crate::Masquerade> for Masquerade {
+    fn from(value: crate::Masquerade) -> Self {
+        Masquerade {
+            name: value.name,
+            avatar: value.avatar,
+            colour: value.colour,
+        }
+    }
+}
+
+impl From<Masquerade> for crate::Masquerade {
+    fn from(value: Masquerade) -> Self {
+        crate::Masquerade {
+            name: value.name,
+            avatar: value.avatar,
+            colour: value.colour,
+        }
+    }
+}
+
+impl From<crate::Report> for Report {
+    fn from(value: crate::Report) -> Self {
+        Report {
+            id: value.id,
+            author_id: value.author_id,
+            content: value.content,
+            additional_context: value.additional_context,
+            status: value.status,
+            notes: value.notes,
+        }
+    }
+}
+
+impl From<crate::ServerBan> for ServerBan {
+    fn from(value: crate::ServerBan) -> Self {
+        ServerBan {
+            id: value.id.into(),
+            reason: value.reason,
+        }
+    }
+}
+
+impl From<crate::Member> for Member {
+    fn from(value: crate::Member) -> Self {
+        Member {
+            id: value.id.into(),
+            joined_at: value.joined_at,
+            nickname: value.nickname,
+            avatar: value.avatar.map(|f| f.into()),
+            roles: value.roles,
+            timeout: value.timeout,
+        }
+    }
+}
+
+impl From<crate::PartialMember> for PartialMember {
+    fn from(value: crate::PartialMember) -> Self {
+        PartialMember {
+            id: value.id.map(|id| id.into()),
+            joined_at: value.joined_at,
+            nickname: value.nickname,
+            avatar: value.avatar.map(|f| f.into()),
+            roles: value.roles,
+            timeout: value.timeout,
+        }
+    }
+}
+
+impl From<crate::MemberCompositeKey> for MemberCompositeKey {
+    fn from(value: crate::MemberCompositeKey) -> Self {
+        MemberCompositeKey {
+            server: value.server,
+            user: value.user,
+        }
+    }
+}
+
+impl From<crate::FieldsMember> for FieldsMember {
+    fn from(value: crate::FieldsMember) -> Self {
+        match value {
+            crate::FieldsMember::Avatar => FieldsMember::Avatar,
+            crate::FieldsMember::Nickname => FieldsMember::Nickname,
+            crate::FieldsMember::Roles => FieldsMember::Roles,
+            crate::FieldsMember::Timeout => FieldsMember::Timeout,
+        }
+    }
+}
+
+impl From<FieldsMember> for crate::FieldsMember {
+    fn from(value: FieldsMember) -> crate::FieldsMember {
+        match value {
+            FieldsMember::Avatar => crate::FieldsMember::Avatar,
+            FieldsMember::Nickname => crate::FieldsMember::Nickname,
+            FieldsMember::Roles => crate::FieldsMember::Roles,
+            FieldsMember::Timeout => crate::FieldsMember::Timeout,
+        }
+    }
+}
+
+impl From<crate::RemovalIntention> for RemovalIntention {
+    fn from(value: crate::RemovalIntention) -> Self {
+        match value {
+            crate::RemovalIntention::Ban => RemovalIntention::Ban,
+            crate::RemovalIntention::Kick => RemovalIntention::Kick,
+            crate::RemovalIntention::Leave => RemovalIntention::Leave,
+        }
+    }
+}
+
+impl From<crate::Server> for Server {
+    fn from(value: crate::Server) -> Self {
+        Server {
+            id: value.id,
+            owner: value.owner,
+            name: value.name,
+            description: value.description,
+            channels: value.channels,
+            categories: value
+                .categories
+                .map(|categories| categories.into_iter().map(|v| v.into()).collect()),
+            system_messages: value.system_messages.map(|v| v.into()),
+            roles: value
+                .roles
+                .into_iter()
+                .map(|(k, v)| (k, v.into()))
+                .collect(),
+            default_permissions: value.default_permissions,
+            icon: value.icon.map(|f| f.into()),
+            banner: value.banner.map(|f| f.into()),
+            flags: value.flags.unwrap_or_default() as u32,
+            nsfw: value.nsfw,
+            analytics: value.analytics,
+            discoverable: value.discoverable,
+        }
+    }
+}
+
+impl From<crate::PartialServer> for PartialServer {
+    fn from(value: crate::PartialServer) -> Self {
+        PartialServer {
+            id: value.id,
+            owner: value.owner,
+            name: value.name,
+            description: value.description,
+            channels: value.channels,
+            categories: value
+                .categories
+                .map(|categories| categories.into_iter().map(|v| v.into()).collect()),
+            system_messages: value.system_messages.map(|v| v.into()),
+            roles: value
+                .roles
+                .map(|roles| roles.into_iter().map(|(k, v)| (k, v.into())).collect()),
+            default_permissions: value.default_permissions,
+            icon: value.icon.map(|f| f.into()),
+            banner: value.banner.map(|f| f.into()),
+            flags: value.flags.map(|v| v as u32),
+            nsfw: value.nsfw,
+            analytics: value.analytics,
+            discoverable: value.discoverable,
+        }
+    }
+}
+
+impl From<crate::FieldsServer> for FieldsServer {
+    fn from(value: crate::FieldsServer) -> Self {
+        match value {
+            crate::FieldsServer::Banner => FieldsServer::Banner,
+            crate::FieldsServer::Categories => FieldsServer::Categories,
+            crate::FieldsServer::Description => FieldsServer::Description,
+            crate::FieldsServer::Icon => FieldsServer::Icon,
+            crate::FieldsServer::SystemMessages => FieldsServer::SystemMessages,
+        }
+    }
+}
+
+impl From<FieldsServer> for crate::FieldsServer {
+    fn from(value: FieldsServer) -> crate::FieldsServer {
+        match value {
+            FieldsServer::Banner => crate::FieldsServer::Banner,
+            FieldsServer::Categories => crate::FieldsServer::Categories,
+            FieldsServer::Description => crate::FieldsServer::Description,
+            FieldsServer::Icon => crate::FieldsServer::Icon,
+            FieldsServer::SystemMessages => crate::FieldsServer::SystemMessages,
+        }
+    }
+}
+
+impl From<crate::Category> for Category {
+    fn from(value: crate::Category) -> Self {
+        Category {
+            id: value.id,
+            title: value.title,
+            channels: value.channels,
+        }
+    }
+}
+
+impl From<Category> for crate::Category {
+    fn from(value: Category) -> Self {
+        crate::Category {
+            id: value.id,
+            title: value.title,
+            channels: value.channels,
+        }
+    }
+}
+
+impl From<crate::SystemMessageChannels> for SystemMessageChannels {
+    fn from(value: crate::SystemMessageChannels) -> Self {
+        SystemMessageChannels {
+            user_joined: value.user_joined,
+            user_left: value.user_left,
+            user_kicked: value.user_kicked,
+            user_banned: value.user_banned,
+        }
+    }
+}
+
+impl From<SystemMessageChannels> for crate::SystemMessageChannels {
+    fn from(value: SystemMessageChannels) -> Self {
+        crate::SystemMessageChannels {
+            user_joined: value.user_joined,
+            user_left: value.user_left,
+            user_kicked: value.user_kicked,
+            user_banned: value.user_banned,
+        }
+    }
+}
+
+impl From<crate::Role> for Role {
+    fn from(value: crate::Role) -> Self {
+        Role {
+            name: value.name,
+            permissions: value.permissions,
+            colour: value.colour,
+            hoist: value.hoist,
+            rank: value.rank,
+        }
+    }
+}
+
+impl From<crate::PartialRole> for PartialRole {
+    fn from(value: crate::PartialRole) -> Self {
+        PartialRole {
+            name: value.name,
+            permissions: value.permissions,
+            colour: value.colour,
+            hoist: value.hoist,
+            rank: value.rank,
+        }
+    }
+}
+
+impl From<crate::FieldsRole> for FieldsRole {
+    fn from(value: crate::FieldsRole) -> Self {
+        match value {
+            crate::FieldsRole::Colour => FieldsRole::Colour,
+        }
+    }
+}
+
+impl From<FieldsRole> for crate::FieldsRole {
+    fn from(value: FieldsRole) -> Self {
+        match value {
+            FieldsRole::Colour => crate::FieldsRole::Colour,
+        }
+    }
+}
+
+impl crate::User {
+    pub async fn into<'a, P>(self, db: &Database, perspective: P) -> User
+    where
+        P: Into<Option<&'a crate::User>>,
+    {
+        let perspective = perspective.into();
+        let (relationship, can_see_profile) = if self.bot.is_some() {
+            (RelationshipStatus::None, true)
+        } else if let Some(perspective) = perspective {
+            let mut query = DatabasePermissionQuery::new(db, perspective).user(&self);
+
+            if perspective.id == self.id {
+                (RelationshipStatus::User, true)
+            } else {
+                (
+                    perspective
+                        .relations
+                        .as_ref()
+                        .map(|relations| {
+                            relations
+                                .iter()
+                                .find(|relationship| relationship.id == self.id)
+                                .map(|relationship| relationship.status.clone().into())
+                                .unwrap_or_default()
+                        })
+                        .unwrap_or_default(),
+                    calculate_user_permissions(&mut query)
+                        .await
+                        .has_user_permission(UserPermission::ViewProfile),
+                )
+            }
+        } else {
+            (RelationshipStatus::None, false)
+        };
 
         User {
             username: self.username,
             discriminator: self.discriminator,
             display_name: self.display_name,
             avatar: self.avatar.map(|file| file.into()),
-            relations: vec![],
+            relations: if let Some(crate::User { id, .. }) = perspective {
+                if id == &self.id {
+                    self.relations
+                        .unwrap_or_default()
+                        .into_iter()
+                        .map(|relation| relation.into())
+                        .collect()
+                } else {
+                    vec![]
+                }
+            } else {
+                vec![]
+            },
             badges: self.badges.unwrap_or_default() as u32,
-            status: None,
-            profile: None,
+            status: if can_see_profile {
+                self.status.map(|status| status.into())
+            } else {
+                None
+            },
+            profile: if can_see_profile {
+                self.profile.map(|profile| profile.into())
+            } else {
+                None
+            },
             flags: self.flags.unwrap_or_default() as u32,
             privileged: self.privileged,
             bot: self.bot.map(|bot| bot.into()),
@@ -274,6 +766,159 @@ impl crate::User {
             id: self.id,
         }
     }
+
+    /// Convert user object into user model assuming mutual connection
+    pub fn into_known<'a, P>(self, perspective: P, is_online: bool) -> User
+    where
+        P: Into<Option<&'a crate::User>>,
+    {
+        let perspective = perspective.into();
+        let (relationship, can_see_profile) = if self.bot.is_some() {
+            (RelationshipStatus::None, true)
+        } else if let Some(perspective) = perspective {
+            if perspective.id == self.id {
+                (RelationshipStatus::User, true)
+            } else {
+                let relationship = perspective
+                    .relations
+                    .as_ref()
+                    .map(|relations| {
+                        relations
+                            .iter()
+                            .find(|relationship| relationship.id == self.id)
+                            .map(|relationship| relationship.status.clone().into())
+                            .unwrap_or_default()
+                    })
+                    .unwrap_or_default();
+
+                let can_see_profile = relationship != RelationshipStatus::BlockedOther;
+                (relationship, can_see_profile)
+            }
+        } else {
+            (RelationshipStatus::None, false)
+        };
+
+        User {
+            username: self.username,
+            discriminator: self.discriminator,
+            display_name: self.display_name,
+            avatar: self.avatar.map(|file| file.into()),
+            relations: if let Some(crate::User { id, .. }) = perspective {
+                if id == &self.id {
+                    self.relations
+                        .unwrap_or_default()
+                        .into_iter()
+                        .map(|relation| relation.into())
+                        .collect()
+                } else {
+                    vec![]
+                }
+            } else {
+                vec![]
+            },
+            badges: self.badges.unwrap_or_default() as u32,
+            status: if can_see_profile {
+                self.status.map(|status| status.into())
+            } else {
+                None
+            },
+            profile: if can_see_profile {
+                self.profile.map(|profile| profile.into())
+            } else {
+                None
+            },
+            flags: self.flags.unwrap_or_default() as u32,
+            privileged: self.privileged,
+            bot: self.bot.map(|bot| bot.into()),
+            relationship,
+            online: can_see_profile && is_online,
+            id: self.id,
+        }
+    }
+
+    pub async fn into_self(self) -> User {
+        User {
+            username: self.username,
+            discriminator: self.discriminator,
+            display_name: self.display_name,
+            avatar: self.avatar.map(|file| file.into()),
+            relations: self
+                .relations
+                .map(|relationships| {
+                    relationships
+                        .into_iter()
+                        .map(|relationship| relationship.into())
+                        .collect()
+                })
+                .unwrap_or_default(),
+            badges: self.badges.unwrap_or_default() as u32,
+            status: self.status.map(|status| status.into()),
+            profile: self.profile.map(|profile| profile.into()),
+            flags: self.flags.unwrap_or_default() as u32,
+            privileged: self.privileged,
+            bot: self.bot.map(|bot| bot.into()),
+            relationship: RelationshipStatus::User,
+            online: revolt_presence::is_online(&self.id).await,
+            id: self.id,
+        }
+    }
+
+    pub fn as_author_for_system(&self) -> MessageAuthor {
+        MessageAuthor::System {
+            username: &self.username,
+            avatar: self.avatar.as_ref().map(|file| file.id.as_ref()),
+        }
+    }
+}
+
+impl From<crate::PartialUser> for PartialUser {
+    fn from(value: crate::PartialUser) -> Self {
+        PartialUser {
+            username: value.username,
+            discriminator: value.discriminator,
+            display_name: value.display_name,
+            avatar: value.avatar.map(|file| file.into()),
+            relations: value.relations.map(|relationships| {
+                relationships
+                    .into_iter()
+                    .map(|relationship| relationship.into())
+                    .collect()
+            }),
+            badges: value.badges.map(|badges| badges as u32),
+            status: value.status.map(|status| status.into()),
+            profile: value.profile.map(|profile| profile.into()),
+            flags: value.flags.map(|flags| flags as u32),
+            privileged: value.privileged,
+            bot: value.bot.map(|bot| bot.into()),
+            relationship: None,
+            online: None,
+            id: value.id,
+        }
+    }
+}
+
+impl From<FieldsUser> for crate::FieldsUser {
+    fn from(value: FieldsUser) -> Self {
+        match value {
+            FieldsUser::Avatar => crate::FieldsUser::Avatar,
+            FieldsUser::ProfileBackground => crate::FieldsUser::ProfileBackground,
+            FieldsUser::ProfileContent => crate::FieldsUser::ProfileContent,
+            FieldsUser::StatusPresence => crate::FieldsUser::StatusPresence,
+            FieldsUser::StatusText => crate::FieldsUser::StatusText,
+        }
+    }
+}
+
+impl From<crate::FieldsUser> for FieldsUser {
+    fn from(value: crate::FieldsUser) -> Self {
+        match value {
+            crate::FieldsUser::Avatar => FieldsUser::Avatar,
+            crate::FieldsUser::ProfileBackground => FieldsUser::ProfileBackground,
+            crate::FieldsUser::ProfileContent => FieldsUser::ProfileContent,
+            crate::FieldsUser::StatusPresence => FieldsUser::StatusPresence,
+            crate::FieldsUser::StatusText => FieldsUser::StatusText,
+        }
+    }
 }
 
 impl From<crate::RelationshipStatus> for RelationshipStatus {
@@ -311,6 +956,18 @@ impl From<crate::Presence> for Presence {
     }
 }
 
+impl From<Presence> for crate::Presence {
+    fn from(value: Presence) -> crate::Presence {
+        match value {
+            Presence::Online => crate::Presence::Online,
+            Presence::Idle => crate::Presence::Idle,
+            Presence::Focus => crate::Presence::Focus,
+            Presence::Busy => crate::Presence::Busy,
+            Presence::Invisible => crate::Presence::Invisible,
+        }
+    }
+}
+
 impl From<crate::UserStatus> for UserStatus {
     fn from(value: crate::UserStatus) -> Self {
         UserStatus {

crates/core/database/src/util/idempotency.rs

@@ -1,23 +1,21 @@
-use crate::{Error, Result};
+use std::num::NonZeroUsize;
+
+use revolt_result::{create_error, Result};
+
+#[cfg(feature = "rocket-impl")]
+use revolt_result::Error;
 
 use async_std::sync::Mutex;
-use revolt_rocket_okapi::gen::OpenApiGenerator;
-use revolt_rocket_okapi::request::{OpenApiFromRequest, RequestHeaderInput};
-use revolt_rocket_okapi::revolt_okapi::openapi3::{Parameter, ParameterValue};
-use rocket::http::Status;
-use rocket::request::{FromRequest, Outcome};
-use schemars::schema::{InstanceType, SchemaObject, SingleOrVec};
-use serde::{Deserialize, Serialize};
-use validator::Validate;
 use once_cell::sync::Lazy;
+use serde::{Deserialize, Serialize};
 
-#[derive(Validate, Serialize, Deserialize)]
+#[derive(Serialize, Deserialize)]
 pub struct IdempotencyKey {
-    #[validate(length(min = 1, max = 64))]
     key: String,
 }
 
-static TOKEN_CACHE: Lazy<Mutex<lru::LruCache<String, ()>>> = Lazy::new(|| Mutex::new(lru::LruCache::new(100)));
+static TOKEN_CACHE: Lazy<Mutex<lru::LruCache<String, ()>>> =
+    Lazy::new(|| Mutex::new(lru::LruCache::new(NonZeroUsize::new(1000).unwrap())));
 
 impl IdempotencyKey {
     // Backwards compatibility.
@@ -26,7 +24,7 @@ impl IdempotencyKey {
         if let Some(v) = v {
             let mut cache = TOKEN_CACHE.lock().await;
             if cache.get(&v).is_some() {
-                return Err(Error::DuplicateNonce);
+                return Err(create_error!(DuplicateNonce));
             }
 
             cache.put(v.clone(), ());
@@ -41,6 +39,17 @@ impl IdempotencyKey {
     }
 }
 
+#[cfg(feature = "rocket-impl")]
+use revolt_rocket_okapi::{
+    gen::OpenApiGenerator,
+    request::{OpenApiFromRequest, RequestHeaderInput},
+    revolt_okapi::openapi3::{Parameter, ParameterValue},
+};
+
+#[cfg(feature = "rocket-impl")]
+use schemars::schema::{InstanceType, SchemaObject, SingleOrVec};
+
+#[cfg(feature = "rocket-impl")]
 impl<'r> OpenApiFromRequest<'r> for IdempotencyKey {
     fn from_request_input(
         _gen: &mut OpenApiGenerator,
@@ -70,6 +79,13 @@ impl<'r> OpenApiFromRequest<'r> for IdempotencyKey {
     }
 }
 
+#[cfg(feature = "rocket-impl")]
+use rocket::{
+    http::Status,
+    request::{FromRequest, Outcome},
+};
+
+#[cfg(feature = "rocket-impl")]
 #[async_trait]
 impl<'r> FromRequest<'r> for IdempotencyKey {
     type Error = Error;
@@ -81,14 +97,19 @@ impl<'r> FromRequest<'r> for IdempotencyKey {
             .next()
             .map(|k| k.to_string())
         {
-            let idempotency = IdempotencyKey { key };
-            if let Err(error) = idempotency.validate() {
-                return Outcome::Failure((Status::BadRequest, Error::FailedValidation { error }));
+            if key.len() > 64 {
+                return Outcome::Failure((
+                    Status::BadRequest,
+                    create_error!(FailedValidation {
+                        error: "idempotency key too long".to_string(),
+                    }),
+                ));
             }
 
+            let idempotency = IdempotencyKey { key };
             let mut cache = TOKEN_CACHE.lock().await;
             if cache.get(&idempotency.key).is_some() {
-                return Outcome::Failure((Status::Conflict, Error::DuplicateNonce));
+                return Outcome::Failure((Status::Conflict, create_error!(DuplicateNonce)));
             }
 
             cache.put(idempotency.key.clone(), ());

crates/core/database/src/util/mod.rs

@@ -1,3 +1,5 @@
 pub mod bridge;
+pub mod idempotency;
 pub mod permissions;
 pub mod reference;
+pub mod test_fixtures;

crates/core/database/src/util/permissions.rs

@@ -1,29 +1,32 @@
 use std::borrow::Cow;
 
 use revolt_permissions::{
-    calculate_user_permissions, ChannelType, Override, PermissionQuery, RelationshipStatus,
+    calculate_user_permissions, ChannelType, Override, PermissionQuery, PermissionValue,
+    RelationshipStatus, DEFAULT_PERMISSION_DIRECT_MESSAGE,
 };
 
-use crate::{Database, User};
+use crate::{Channel, Database, Member, Server, User};
 
 /// Permissions calculator
-pub struct PermissionCalculator<'a> {
+#[derive(Clone)]
+pub struct DatabasePermissionQuery<'a> {
     #[allow(dead_code)]
     database: &'a Database,
 
     perspective: &'a User,
     user: Option<Cow<'a, User>>,
-    // pub channel: Cow<'a, Channel>,
-    // pub server: Cow<'a, Server>,
-    // pub member: Cow<'a, Member>,
+    channel: Option<Cow<'a, Channel>>,
+    server: Option<Cow<'a, Server>>,
+    member: Option<Cow<'a, Member>>,
 
     // flag_known_relationship: Option<&'a RelationshipStatus>,
-    cached_user_permission: Option<u32>,
+    cached_user_permission: Option<PermissionValue>,
+    cached_mutual_connection: Option<bool>,
     cached_permission: Option<u64>,
 }
 
 #[async_trait]
-impl PermissionQuery for PermissionCalculator<'_> {
+impl PermissionQuery for DatabasePermissionQuery<'_> {
     // * For calculating user permission
 
     /// Is our perspective user privileged?
@@ -48,6 +51,10 @@ impl PermissionQuery for PermissionCalculator<'_> {
     /// Get the relationship with have with the currently selected user
     async fn user_relationship(&mut self) -> RelationshipStatus {
         if let Some(other_user) = &self.user {
+            if self.perspective.id == other_user.id {
+                return RelationshipStatus::User;
+            }
+
             if let Some(relations) = &self.perspective.relations {
                 for entry in relations {
                     if entry.id == other_user.id {
@@ -81,93 +88,308 @@ impl PermissionQuery for PermissionCalculator<'_> {
 
     /// Do we have a mutual connection with the currently selected user?
     async fn have_mutual_connection(&mut self) -> bool {
-        // TODO: User::has_mutual_connection
-        false
+        if let Some(value) = self.cached_mutual_connection {
+            value
+        } else if let Some(user) = &self.user {
+            let value = self
+                .perspective
+                .has_mutual_connection(self.database, &user.id)
+                .await
+                .unwrap_or_default();
+
+            self.cached_mutual_connection = Some(value);
+            matches!(value, true)
+        } else {
+            false
+        }
     }
 
     // * For calculating server permission
 
     /// Is our perspective user the server's owner?
     async fn are_we_server_owner(&mut self) -> bool {
-        todo!()
+        if let Some(server) = &self.server {
+            server.owner == self.perspective.id
+        } else {
+            false
+        }
     }
 
     /// Is our perspective user a member of the server?
     async fn are_we_a_member(&mut self) -> bool {
-        todo!()
+        if let Some(server) = &self.server {
+            if self.member.is_some() {
+                true
+            } else if let Ok(member) = self
+                .database
+                .fetch_member(&server.id, &self.perspective.id)
+                .await
+            {
+                self.member = Some(Cow::Owned(member));
+                true
+            } else {
+                false
+            }
+        } else {
+            false
+        }
     }
 
     /// Get default server permission
     async fn get_default_server_permissions(&mut self) -> u64 {
-        todo!()
+        if let Some(server) = &self.server {
+            server.default_permissions as u64
+        } else {
+            0
+        }
     }
 
     /// Get the ordered role overrides (from lowest to highest) for this member in this server
     async fn get_our_server_role_overrides(&mut self) -> Vec<Override> {
-        todo!()
+        if let Some(server) = &self.server {
+            let member_roles = self
+                .member
+                .as_ref()
+                .map(|member| member.roles.clone())
+                .unwrap_or_default();
+
+            let mut roles = server
+                .roles
+                .iter()
+                .filter(|(id, _)| member_roles.contains(id))
+                .map(|(_, role)| {
+                    let v: Override = role.permissions.into();
+                    (role.rank, v)
+                })
+                .collect::<Vec<(i64, Override)>>();
+
+            roles.sort_by(|a, b| b.0.cmp(&a.0));
+            roles.into_iter().map(|(_, v)| v).collect()
+        } else {
+            vec![]
+        }
     }
 
     /// Is our perspective user timed out on this server?
     async fn are_we_timed_out(&mut self) -> bool {
-        todo!()
+        if let Some(member) = &self.member {
+            member.in_timeout()
+        } else {
+            false
+        }
     }
 
     // * For calculating channel permission
 
     /// Get the type of the channel
     async fn get_channel_type(&mut self) -> ChannelType {
-        todo!()
+        if let Some(channel) = &self.channel {
+            match channel {
+                Cow::Borrowed(Channel::DirectMessage { .. })
+                | Cow::Owned(Channel::DirectMessage { .. }) => ChannelType::DirectMessage,
+                Cow::Borrowed(Channel::Group { .. }) | Cow::Owned(Channel::Group { .. }) => {
+                    ChannelType::Group
+                }
+                Cow::Borrowed(Channel::SavedMessages { .. })
+                | Cow::Owned(Channel::SavedMessages { .. }) => ChannelType::SavedMessages,
+                Cow::Borrowed(Channel::TextChannel { .. })
+                | Cow::Owned(Channel::TextChannel { .. })
+                | Cow::Borrowed(Channel::VoiceChannel { .. })
+                | Cow::Owned(Channel::VoiceChannel { .. }) => ChannelType::ServerChannel,
+            }
+        } else {
+            ChannelType::Unknown
+        }
     }
 
     /// Get the default channel permissions
     /// Group channel defaults should be mapped to an allow-only override
     async fn get_default_channel_permissions(&mut self) -> Override {
-        todo!()
+        if let Some(channel) = &self.channel {
+            match channel {
+                Cow::Borrowed(Channel::Group { permissions, .. })
+                | Cow::Owned(Channel::Group { permissions, .. }) => Override {
+                    allow: permissions.unwrap_or(*DEFAULT_PERMISSION_DIRECT_MESSAGE as i64) as u64,
+                    deny: 0,
+                },
+                Cow::Borrowed(Channel::TextChannel {
+                    default_permissions,
+                    ..
+                })
+                | Cow::Owned(Channel::TextChannel {
+                    default_permissions,
+                    ..
+                })
+                | Cow::Borrowed(Channel::VoiceChannel {
+                    default_permissions,
+                    ..
+                })
+                | Cow::Owned(Channel::VoiceChannel {
+                    default_permissions,
+                    ..
+                }) => default_permissions.unwrap_or_default().into(),
+                _ => Default::default(),
+            }
+        } else {
+            Default::default()
+        }
     }
 
     /// Get the ordered role overrides (from lowest to highest) for this member in this channel
     async fn get_our_channel_role_overrides(&mut self) -> Vec<Override> {
-        todo!()
+        if let Some(channel) = &self.channel {
+            match channel {
+                Cow::Borrowed(Channel::TextChannel {
+                    role_permissions, ..
+                })
+                | Cow::Owned(Channel::TextChannel {
+                    role_permissions, ..
+                })
+                | Cow::Borrowed(Channel::VoiceChannel {
+                    role_permissions, ..
+                })
+                | Cow::Owned(Channel::VoiceChannel {
+                    role_permissions, ..
+                }) => {
+                    if let Some(server) = &self.server {
+                        let member_roles = self
+                            .member
+                            .as_ref()
+                            .map(|member| member.roles.clone())
+                            .unwrap_or_default();
+
+                        let mut roles = role_permissions
+                            .iter()
+                            .filter(|(id, _)| member_roles.contains(id))
+                            .filter_map(|(id, permission)| {
+                                server.roles.get(id).map(|role| {
+                                    let v: Override = (*permission).into();
+                                    (role.rank, v)
+                                })
+                            })
+                            .collect::<Vec<(i64, Override)>>();
+
+                        roles.sort_by(|a, b| b.0.cmp(&a.0));
+                        roles.into_iter().map(|(_, v)| v).collect()
+                    } else {
+                        vec![]
+                    }
+                }
+                _ => vec![],
+            }
+        } else {
+            vec![]
+        }
     }
 
     /// Do we own this group or saved messages channel if it is one of those?
     async fn do_we_own_the_channel(&mut self) -> bool {
-        todo!()
+        if let Some(channel) = &self.channel {
+            match channel {
+                Cow::Borrowed(Channel::Group { owner, .. })
+                | Cow::Owned(Channel::Group { owner, .. }) => owner == &self.perspective.id,
+                Cow::Borrowed(Channel::SavedMessages { user, .. })
+                | Cow::Owned(Channel::SavedMessages { user, .. }) => user == &self.perspective.id,
+                _ => false,
+            }
+        } else {
+            false
+        }
     }
 
     /// Are we a recipient of this channel?
     async fn are_we_part_of_the_channel(&mut self) -> bool {
-        todo!()
+        if let Some(channel) = &self.channel {
+            match channel {
+                Cow::Borrowed(Channel::DirectMessage { recipients, .. })
+                | Cow::Owned(Channel::DirectMessage { recipients, .. })
+                | Cow::Borrowed(Channel::Group { recipients, .. })
+                | Cow::Owned(Channel::Group { recipients, .. }) => {
+                    recipients.contains(&self.perspective.id)
+                }
+                _ => false,
+            }
+        } else {
+            false
+        }
     }
 
     /// Set the current user as the recipient of this channel
     /// (this will only ever be called for DirectMessage channels, use unimplemented!() for other code paths)
     async fn set_recipient_as_user(&mut self) {
-        todo!()
+        if let Some(channel) = &self.channel {
+            match channel {
+                Cow::Borrowed(Channel::DirectMessage { recipients, .. })
+                | Cow::Owned(Channel::DirectMessage { recipients, .. }) => {
+                    let recipient_id = recipients
+                        .iter()
+                        .find(|recipient| recipient != &&self.perspective.id)
+                        .expect("Missing recipient for DM");
+
+                    if let Ok(user) = self.database.fetch_user(recipient_id).await {
+                        self.user.replace(Cow::Owned(user));
+                    }
+                }
+                _ => unimplemented!(),
+            }
+        }
     }
 
     /// Set the current server as the server owning this channel
     /// (this will only ever be called for server channels, use unimplemented!() for other code paths)
     async fn set_server_from_channel(&mut self) {
-        todo!()
+        if let Some(channel) = &self.channel {
+            match channel {
+                Cow::Borrowed(Channel::TextChannel { server, .. })
+                | Cow::Owned(Channel::TextChannel { server, .. })
+                | Cow::Borrowed(Channel::VoiceChannel { server, .. })
+                | Cow::Owned(Channel::VoiceChannel { server, .. }) => {
+                    if let Some(known_server) =
+                        // I'm not sure why I can't just pattern match both at once here?
+                        // It throws some weird error and the provided fix doesn't work :/
+                        if let Some(Cow::Borrowed(known_server)) = self.server {
+                                Some(known_server)
+                            } else if let Some(Cow::Owned(ref known_server)) = self.server {
+                                Some(known_server)
+                            } else {
+                                None
+                            }
+                    {
+                        if server == &known_server.id {
+                            // Already cached, return early.
+                            return;
+                        }
+                    }
+
+                    if let Ok(server) = self.database.fetch_server(server).await {
+                        self.server.replace(Cow::Owned(server));
+                    }
+                }
+                _ => unimplemented!(),
+            }
+        }
     }
 }
 
-impl<'a> PermissionCalculator<'a> {
+impl<'a> DatabasePermissionQuery<'a> {
     /// Create a new permission calculator
-    pub fn new(database: &'a Database, perspective: &'a User) -> PermissionCalculator<'a> {
-        PermissionCalculator {
+    pub fn new(database: &'a Database, perspective: &'a User) -> DatabasePermissionQuery<'a> {
+        DatabasePermissionQuery {
             database,
             perspective,
             user: None,
+            channel: None,
+            server: None,
+            member: None,
 
+            cached_mutual_connection: None,
             cached_user_permission: None,
             cached_permission: None,
         }
     }
 
     /// Calculate the user permission value
-    pub async fn calc_user(mut self) -> PermissionCalculator<'a> {
+    pub async fn calc_user(mut self) -> DatabasePermissionQuery<'a> {
         if self.cached_user_permission.is_some() {
             return self;
         }
@@ -176,14 +398,14 @@ impl<'a> PermissionCalculator<'a> {
             panic!("Expected `PermissionCalculator.user to exist.");
         }
 
-        PermissionCalculator {
+        DatabasePermissionQuery {
             cached_user_permission: Some(calculate_user_permissions(&mut self).await),
             ..self
         }
     }
 
     /// Calculate the permission value
-    pub async fn calc(self) -> PermissionCalculator<'a> {
+    pub async fn calc(self) -> DatabasePermissionQuery<'a> {
         if self.cached_permission.is_some() {
             return self;
         }
@@ -192,15 +414,66 @@ impl<'a> PermissionCalculator<'a> {
     }
 
     /// Use user
-    pub fn user(self, user: Cow<'a, User>) -> PermissionCalculator {
-        PermissionCalculator {
-            user: Some(user),
+    pub fn user(self, user: &'a User) -> DatabasePermissionQuery {
+        DatabasePermissionQuery {
+            user: Some(Cow::Borrowed(user)),
             ..self
         }
     }
+
+    /// Use channel
+    pub fn channel(self, channel: &'a Channel) -> DatabasePermissionQuery {
+        DatabasePermissionQuery {
+            channel: Some(Cow::Borrowed(channel)),
+            ..self
+        }
+    }
+
+    /// Use server
+    pub fn server(self, server: &'a Server) -> DatabasePermissionQuery {
+        DatabasePermissionQuery {
+            server: Some(Cow::Borrowed(server)),
+            ..self
+        }
+    }
+
+    /// Use member
+    pub fn member(self, member: &'a Member) -> DatabasePermissionQuery {
+        DatabasePermissionQuery {
+            member: Some(Cow::Borrowed(member)),
+            ..self
+        }
+    }
+
+    /// Access the underlying user
+    pub fn user_ref(&self) -> &Option<Cow<User>> {
+        &self.user
+    }
+
+    /// Access the underlying server
+    pub fn channel_ref(&self) -> &Option<Cow<Channel>> {
+        &self.channel
+    }
+
+    /// Access the underlying server
+    pub fn server_ref(&self) -> &Option<Cow<Server>> {
+        &self.server
+    }
+
+    /// Access the underlying member
+    pub fn member_ref(&self) -> &Option<Cow<Member>> {
+        &self.member
+    }
+
+    /// Get the known member's current ranking
+    pub fn get_member_rank(&self) -> Option<i64> {
+        self.member
+            .as_ref()
+            .map(|member| member.get_ranking(self.server.as_ref().unwrap()))
+    }
 }
 
 /// Short-hand for creating a permission calculator
-pub fn perms<'a>(database: &'a Database, perspective: &'a User) -> PermissionCalculator<'a> {
-    PermissionCalculator::new(database, perspective)
+pub fn perms<'a>(database: &'a Database, perspective: &'a User) -> DatabasePermissionQuery<'a> {
+    DatabasePermissionQuery::new(database, perspective)
 }