chore: bump version to 0.7.3

chore: update/create LICENSE files
closes #278
closes #277

.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
@@ -59,6 +61,9 @@ REVOLT_UNSAFE_NO_EMAIL=1
 ## Application Settings
 ##
 
+# Whether to enable staging only features
+REVOLT_IS_STAGING=1
+
 # Whether to only allow users to sign up if they have an invite code
 REVOLT_INVITE_ONLY=0
 
@@ -77,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/book.yml

@@ -0,0 +1,37 @@
+name: Build documentation
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write # To push a branch
+      pages: write # To push to a GitHub Pages site
+      id-token: write # To update the deployment status
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Install latest mdbook
+        run: |
+          tag=$(curl 'https://api.github.com/repos/rust-lang/mdbook/releases/latest' | jq -r '.tag_name')
+          url="https://github.com/rust-lang/mdbook/releases/download/${tag}/mdbook-${tag}-x86_64-unknown-linux-gnu.tar.gz"
+          mkdir mdbook
+          curl -sSL $url | tar -xz --directory=./mdbook
+          echo `pwd`/mdbook >> $GITHUB_PATH
+      - name: Build Book
+        run: |
+          cd doc
+          mdbook build
+      - name: Setup Pages
+        uses: actions/configure-pages@v4
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: "doc/book"
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4

.github/workflows/cla.yml

@@ -1,36 +0,0 @@
-name: "CLA Assistant"
-on:
-  issue_comment:
-    types: [created]
-  pull_request_target:
-    types: [opened,closed,synchronize]
-
-jobs:
-  CLAssistant:
-    runs-on: ubuntu-latest
-    steps:
-      - name: "CLA Assistant"
-        if: (github.event.comment.body == 'recheck' || github.event.comment.body == 'I have read the CLA Document and I hereby sign the CLA') || github.event_name == 'pull_request_target'
-        # Beta Release
-        uses: cla-assistant/github-action@v2.1.3-beta
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          # the below token should have repo scope and must be manually added by you in the repository's secret
-          PERSONAL_ACCESS_TOKEN : ${{ secrets.PAT }}
-        with:
-          path-to-signatures: 'signatures/version1/cla.json'
-          path-to-document: 'https://github.com/revoltchat/cla/blob/master/CLA.md' # e.g. a CLA or a DCO document
-          # branch should not be protected
-          branch: 'master'
-          allowlist: insertish,bot*
-
-         #below are the optional inputs - If the optional inputs are not given, then default values will be taken
-          remote-organization-name: revoltchat
-          remote-repository-name: cla
-          create-file-commit-message: 'cla(create): creating file for storing CLA Signatures'
-          signed-commit-message: 'cla(sign): $contributorName has signed the CLA in #$pullRequestNo'
-          #custom-notsigned-prcomment: 'pull request comment with Introductory message to ask new contributors to sign'
-          #custom-pr-sign-comment: 'The signature to be committed in order to sign the CLA'
-          #custom-allsigned-prcomment: 'pull request comment when all contributors has signed, defaults to **CLA Assistant Lite bot** All Contributors have signed the CLA.'
-          #lock-pullrequest-aftermerge: false - if you don't want this bot to automatically lock the pull request after merging (default - true)
-          #use-dco-flag: true - If you are using DCO instead of CLA

.github/workflows/docker.yaml

@@ -3,19 +3,20 @@ name: Docker Test & Publish
 on:
   push:
     branches:
-      - "master"
+      - "main"
     tags:
       - "*"
     paths-ignore:
       - ".github/**"
       - "!.github/workflows/docker.yml"
       - ".vscode/**"
+      - "doc/**"
       - ".gitignore"
       - "LICENSE"
       - "README"
   pull_request:
     branches:
-      - "master"
+      - "main"
     paths:
       - "Dockerfile"
   workflow_dispatch:

.github/workflows/rust.yaml

@@ -2,8 +2,16 @@ name: Rust build, test, and generate specification
 
 on:
   push:
+    paths-ignore:
+      - ".github/**"
+      - "!.github/workflows/rust.yaml"
+      - ".vscode/**"
+      - "doc/**"
+      - ".gitignore"
+      - "LICENSE"
+      - "README"
   pull_request:
-    branches: [master]
+    branches: [main]
 
 env:
   CARGO_TERM_COLOR: always
@@ -20,6 +28,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 +43,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 +82,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]
-members = ["crates/delta", "crates/bonfire", "crates/quark", "crates/core/*"]
+resolver = "2"
+members = ["crates/delta", "crates/bonfire", "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

@@ -1,5 +1,5 @@
 # Build Stage
-FROM --platform="${BUILDPLATFORM}" rust:slim
+FROM --platform="${BUILDPLATFORM}" rust:1.70.0-slim
 USER 0:0
 WORKDIR /home/rust/src
 
@@ -19,7 +19,7 @@ RUN sh /tmp/build-image-layer.sh tools
 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,28 @@
+# 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/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

LICENSE

@@ -1,4 +1,7 @@
-                    GNU AFFERO GENERAL PUBLIC LICENSE
+With the exception of crates that specify their own LICENSE file,
+the following license applies to the source code of this project.
+
+GNU AFFERO GENERAL PUBLIC LICENSE
                        Version 3, 19 November 2007
 
  Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>

README.md

@@ -2,30 +2,111 @@
 
 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       |
 
 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.0-rc.1"
+version = "0.7.3"
 license = "AGPL-3.0-or-later"
 edition = "2021"
 
@@ -9,15 +9,17 @@ edition = "2021"
 [dependencies]
 # util
 log = "*"
+sentry = "0.31.5"
+lru = "0.7.6"
+ulid = "0.5.0"
 once_cell = "1.9.0"
+redis-kiss = "0.1.4"
 
 # parsing
 querystring = "1.1.0"
 
-# quark
-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 +27,19 @@ 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-result = { path = "../core/result" }
+revolt-models = { path = "../core/models" }
+revolt-config = { path = "../core/config" }
+revolt-database = { path = "../core/database" }
+revolt-permissions = { version = "0.7.3", path = "../core/permissions" }
+revolt-presence = { path = "../core/presence", features = ["redis-is-patched"] }
+
+# redis
+fred = { version = "8.0.1", features = ["subscriber-client"] }

crates/bonfire/src/config.rs

@@ -1,6 +1,6 @@
 use async_tungstenite::tungstenite::{handshake, Message};
 use futures::channel::oneshot::Sender;
-use revolt_quark::{Error, Result};
+use revolt_result::{create_error, Result};
 use serde::{Deserialize, Serialize};
 
 /// Enumeration of supported protocol formats
@@ -37,16 +37,16 @@ impl ProtocolConfiguration {
         match self.format {
             ProtocolFormat::Json => {
                 if let Message::Text(text) = msg {
-                    serde_json::from_str(text).map_err(|_| Error::InternalError)
+                    serde_json::from_str(text).map_err(|_| create_error!(InternalError))
                 } else {
-                    Err(Error::InternalError)
+                    Err(create_error!(InternalError))
                 }
             }
             ProtocolFormat::Msgpack => {
                 if let Message::Binary(buf) = msg {
-                    rmp_serde::from_slice(buf).map_err(|_| Error::InternalError)
+                    rmp_serde::from_slice(buf).map_err(|_| create_error!(InternalError))
                 } else {
-                    Err(Error::InternalError)
+                    Err(create_error!(InternalError))
                 }
             }
         }

crates/bonfire/src/database.rs

@@ -1,5 +1,5 @@
 use once_cell::sync::OnceCell;
-use revolt_quark::{Database, DatabaseInfo};
+use revolt_database::{Database, DatabaseInfo};
 
 static DBCONN: OnceCell<Database> = OnceCell::new();
 
@@ -10,7 +10,9 @@ pub async fn connect() {
         .await
         .expect("Failed to connect to the database.");
 
-    DBCONN.set(database).expect("Setting `Database`");
+    if DBCONN.set(database).is_err() {
+        panic!("couldn't set database")
+    }
 }
 
 /// Get a reference to the current database.

crates/bonfire/src/events/impl.rs

@@ -1,21 +1,15 @@
 use std::collections::HashSet;
 
-use crate::{
-    get_relationship,
-    models::{
-        server_member::FieldsMember,
-        user::{PartialUser, Presence, RelationshipStatus},
-        Channel, Member, User,
-    },
-    perms, Database, Permission, Result,
+use revolt_database::{
+    events::client::EventV1, util::permissions::DatabasePermissionQuery, Channel, Database, Member,
+    MemberCompositeKey, Presence, RelationshipStatus,
 };
-
+use revolt_models::v0;
+use revolt_permissions::{calculate_channel_permissions, ChannelPermission};
 use revolt_presence::filter_online;
+use revolt_result::Result;
 
-use super::{
-    client::EventV1,
-    state::{Cache, State},
-};
+use super::state::{Cache, State};
 
 /// Cache Manager
 impl Cache {
@@ -23,23 +17,24 @@ impl Cache {
     pub async fn can_view_channel(&self, db: &Database, channel: &Channel) -> bool {
         match &channel {
             Channel::TextChannel { server, .. } | Channel::VoiceChannel { server, .. } => {
-                let member = self.members.values().find(|x| &x.id.server == server);
-
+                let member = self.members.get(server);
                 let server = self.servers.get(server);
-                let mut perms = perms(self.users.get(&self.user_id).unwrap()).channel(channel);
+                let mut query =
+                    DatabasePermissionQuery::new(db, self.users.get(&self.user_id).unwrap())
+                        .channel(&channel);
+                // let mut perms = perms(self.users.get(&self.user_id).unwrap()).channel(channel);
 
                 if let Some(member) = member {
-                    perms.member.set_ref(member);
+                    query = query.member(&member);
                 }
 
                 if let Some(server) = server {
-                    perms.server.set_ref(server);
+                    query = query.server(server);
                 }
 
-                perms
-                    .has_permission(db, Permission::ViewChannel)
+                calculate_channel_permissions(&mut query)
                     .await
-                    .unwrap_or_default()
+                    .has_channel_permission(ChannelPermission::ViewChannel)
             }
             _ => true,
         }
@@ -64,7 +59,7 @@ impl Cache {
     /// Check whether we can subscribe to another user
     pub fn can_subscribe_to_user(&self, user_id: &str) -> bool {
         if let Some(user) = self.users.get(&self.user_id) {
-            match get_relationship(user, user_id) {
+            match user.relationship_with(user_id) {
                 RelationshipStatus::Friend
                 | RelationshipStatus::Incoming
                 | RelationshipStatus::Outgoing
@@ -96,7 +91,7 @@ impl Cache {
 impl State {
     /// Generate a Ready packet for the current user
     pub async fn generate_ready_payload(&mut self, db: &Database) -> Result<EventV1> {
-        let mut user = self.clone_user();
+        let user = self.clone_user();
 
         // Find all relationships to the user.
         let mut user_ids: HashSet<String> = user
@@ -107,9 +102,15 @@ impl State {
 
         // Fetch all memberships with their corresponding servers.
         let members: Vec<Member> = db.fetch_all_memberships(&user.id).await?;
+        self.cache.members = members
+            .iter()
+            .cloned()
+            .map(|x| (x.id.server.clone(), x))
+            .collect();
 
         let server_ids: Vec<String> = members.iter().map(|x| x.id.server.clone()).collect();
         let servers = db.fetch_servers(&server_ids).await?;
+        self.cache.servers = servers.iter().cloned().map(|x| (x.id.clone(), x)).collect();
 
         // Collect channel ids from servers.
         let mut channel_ids = vec![];
@@ -136,7 +137,6 @@ impl State {
 
         // Fetch presence data for known users.
         let online_ids = filter_online(&user_ids.iter().cloned().collect::<Vec<String>>()).await;
-        user.online = Some(true);
 
         // Fetch user data.
         let users = db
@@ -149,45 +149,37 @@ impl State {
             .await?;
 
         // Fetch customisations.
-        let emojis = Some(
-            db.fetch_emoji_by_parent_ids(
+        let emojis = db
+            .fetch_emoji_by_parent_ids(
                 &servers
                     .iter()
                     .map(|x| x.id.to_string())
                     .collect::<Vec<String>>(),
             )
-            .await?,
-        );
+            .await?;
 
         // Copy data into local state cache.
         self.cache.users = users.iter().cloned().map(|x| (x.id.clone(), x)).collect();
         self.cache
             .users
             .insert(self.cache.user_id.clone(), user.clone());
-        self.cache.servers = servers.iter().cloned().map(|x| (x.id.clone(), x)).collect();
         self.cache.channels = channels
             .iter()
             .cloned()
             .map(|x| (x.id().to_string(), x))
             .collect();
-        self.cache.members = members
-            .iter()
-            .cloned()
-            .map(|x| (x.id.server.clone(), x))
-            .collect();
 
         // Make all users appear from our perspective.
-        let mut users: Vec<User> = users
+        let mut users: Vec<v0::User> = users
             .into_iter()
-            .map(|mut x| {
-                x.online = Some(online_ids.contains(&x.id));
-                x.with_relationship(&user)
+            .map(|other_user| {
+                let is_online = online_ids.contains(&other_user.id);
+                other_user.into_known(&user, is_online)
             })
             .collect();
 
         // Make sure we see our own user correctly.
-        user.relationship = Some(RelationshipStatus::User);
-        users.push(user.foreign());
+        users.push(user.into_self().await);
 
         // Set subscription state internally.
         self.reset_state();
@@ -207,10 +199,10 @@ impl State {
 
         Ok(EventV1::Ready {
             users,
-            servers,
-            channels,
-            members,
-            emojis,
+            servers: servers.into_iter().map(Into::into).collect(),
+            channels: channels.into_iter().map(Into::into).collect(),
+            members: members.into_iter().map(Into::into).collect(),
+            emojis: emojis.into_iter().map(Into::into).collect(),
         })
     }
 
@@ -272,7 +264,7 @@ impl State {
                             .insert(channel.id().to_string(), channel.clone());
 
                         self.insert_subscription(channel.id().to_string());
-                        bulk_events.push(EventV1::ChannelCreate(channel));
+                        bulk_events.push(EventV1::ChannelCreate(channel.into()));
                     }
                 }
             }
@@ -297,7 +289,7 @@ impl State {
         } {
             let event = EventV1::UserUpdate {
                 id: self.cache.user_id.clone(),
-                data: PartialUser {
+                data: v0::PartialUser {
                     online: Some(target),
                     ..Default::default()
                 },
@@ -345,7 +337,7 @@ impl State {
             EventV1::ChannelCreate(channel) => {
                 let id = channel.id().to_string();
                 self.insert_subscription(id.clone());
-                self.cache.channels.insert(id, channel.clone());
+                self.cache.channels.insert(id, channel.clone().into());
             }
             EventV1::ChannelUpdate {
                 id, data, clear, ..
@@ -353,15 +345,21 @@ impl State {
                 let could_view: bool = if let Some(channel) = self.cache.channels.get(id) {
                     self.cache.can_view_channel(db, channel).await
                 } else {
-                    true
+                    false
                 };
 
                 if let Some(channel) = self.cache.channels.get_mut(id) {
                     for field in clear {
-                        channel.remove(field);
+                        channel.remove_field(&field.clone().into());
                     }
 
-                    channel.apply_options(data.clone());
+                    channel.apply_options(data.clone().into());
+                }
+
+                if !self.cache.channels.contains_key(id) {
+                    if let Ok(channel) = db.fetch_channel(id).await {
+                        self.cache.channels.insert(id.clone(), channel);
+                    }
                 }
 
                 if let Some(channel) = self.cache.channels.get(id) {
@@ -369,7 +367,7 @@ impl State {
                     if could_view != can_view {
                         if can_view {
                             queue_add = Some(id.clone());
-                            *event = EventV1::ChannelCreate(channel.clone());
+                            *event = EventV1::ChannelCreate(channel.clone().into());
                         } else {
                             queue_remove = Some(id.clone());
                             *event = EventV1::ChannelDelete { id: id.clone() };
@@ -396,14 +394,23 @@ impl State {
                 id,
                 server,
                 channels,
+                emojis: _,
             } => {
                 self.insert_subscription(id.clone());
-                self.cache.servers.insert(id.to_string(), server.clone());
+                self.cache.servers.insert(id.clone(), server.clone().into());
+                let member = Member {
+                    id: MemberCompositeKey {
+                        server: server.id.clone(),
+                        user: self.cache.user_id.clone(),
+                    },
+                    ..Default::default()
+                };
+                self.cache.members.insert(id.clone(), member);
 
                 for channel in channels {
                     self.cache
                         .channels
-                        .insert(channel.id().to_string(), channel.clone());
+                        .insert(channel.id().to_string(), channel.clone().into());
                 }
 
                 queue_server = Some(id.clone());
@@ -413,10 +420,10 @@ impl State {
             } => {
                 if let Some(server) = self.cache.servers.get_mut(id) {
                     for field in clear {
-                        server.remove(field);
+                        server.remove_field(&field.clone().into());
                     }
 
-                    server.apply_options(data.clone());
+                    server.apply_options(data.clone().into());
                 }
 
                 if data.default_permissions.is_some() {
@@ -436,6 +443,7 @@ impl State {
                             self.cache.channels.remove(channel);
                         }
                     }
+                    self.cache.members.remove(id);
                 }
             }
             EventV1::ServerDelete { id } => {
@@ -447,18 +455,19 @@ impl State {
                         self.cache.channels.remove(channel);
                     }
                 }
+                self.cache.members.remove(id);
             }
             EventV1::ServerMemberUpdate { id, data, clear } => {
                 if id.user == self.cache.user_id {
                     if let Some(member) = self.cache.members.get_mut(&id.server) {
                         for field in &clear.clone() {
-                            member.remove(field);
+                            member.remove_field(&field.clone().into());
                         }
 
-                        member.apply_options(data.clone());
+                        member.apply_options(data.clone().into());
                     }
 
-                    if data.roles.is_some() || clear.contains(&FieldsMember::Roles) {
+                    if data.roles.is_some() || clear.contains(&v0::FieldsMember::Roles) {
                         queue_server = Some(id.server.clone());
                     }
                 }
@@ -473,10 +482,10 @@ impl State {
                 if let Some(server) = self.cache.servers.get_mut(id) {
                     if let Some(role) = server.roles.get_mut(role_id) {
                         for field in &clear.clone() {
-                            role.remove(field);
+                            role.remove_field(&field.clone().into());
                         }
 
-                        role.apply_options(data.clone());
+                        role.apply_options(data.clone().into());
                     }
                 }
 
@@ -512,7 +521,7 @@ impl State {
                 *event_id = None;
             }
             EventV1::UserRelationship { id, user, .. } => {
-                self.cache.users.insert(id.clone(), user.clone());
+                self.cache.users.insert(id.clone(), user.clone().into());
 
                 if self.cache.can_subscribe_to_user(id) {
                     self.insert_subscription(id.clone());
@@ -541,40 +550,3 @@ impl State {
         true
     }
 }
-
-impl EventV1 {
-    /// Publish helper wrapper
-    pub async fn p(self, channel: String) {
-        #[cfg(not(debug_assertions))]
-        redis_kiss::p(channel, self).await;
-
-        #[cfg(debug_assertions)]
-        info!("Publishing event to {channel}: {self:?}");
-
-        #[cfg(debug_assertions)]
-        redis_kiss::publish(channel, self).await.unwrap();
-    }
-
-    /// Publish user event
-    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
-        if let Ok(members) = db.fetch_all_memberships(&id).await {
-            for member in members {
-                self.clone().p(member.id.server).await;
-            }
-        }
-    }
-
-    /// Publish private event
-    pub async fn private(self, id: String) {
-        self.p(format!("{id}!")).await;
-    }
-
-    /// Publish internal global event
-    pub async fn global(self) {
-        self.p("global".to_string()).await;
-    }
-}

crates/bonfire/src/events/mod.rs

@@ -0,0 +1,2 @@
+pub mod r#impl;
+pub mod state;

crates/bonfire/src/events/state.rs

@@ -1,8 +1,7 @@
 use std::collections::{HashMap, HashSet};
 
 use lru::LruCache;
-
-use crate::models::{Channel, Member, Server, User};
+use revolt_database::{Channel, Member, Server, User};
 
 /// Enumeration representing some change in subscriptions
 pub enum SubscriptionStateChange {

crates/bonfire/src/main.rs

@@ -7,6 +7,7 @@ use revolt_presence::clear_region;
 extern crate log;
 
 pub mod config;
+pub mod events;
 
 mod database;
 mod websocket;
@@ -14,7 +15,7 @@ mod websocket;
 #[async_std::main]
 async fn main() {
     // Configure requirements for Bonfire.
-    revolt_quark::configure!();
+    revolt_config::configure!(events);
     database::connect().await;
 
     // Clean up the current region information.
@@ -29,6 +30,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,252 +1,280 @@
 use std::net::SocketAddr;
 
-use futures::{channel::oneshot, pin_mut, select, FutureExt, SinkExt, StreamExt, TryStreamExt};
-use revolt_presence::{create_session, delete_session};
-use revolt_quark::{
-    events::{
-        client::EventV1,
-        server::ClientMessage,
-        state::{State, SubscriptionStateChange},
-    },
-    models::{user::UserHint, User},
-    redis_kiss, Database,
+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 redis_kiss::{PayloadType, REDIS_PAYLOAD_TYPE, REDIS_URI};
+use revolt_database::{
+    events::{client::EventV1, server::ClientMessage},
+    Database, User, UserHint,
+};
+use revolt_presence::{create_session, delete_session};
 
-use async_std::{net::TcpStream, sync::Mutex, task};
+use async_std::{net::TcpStream, sync::Mutex};
+use revolt_result::create_error;
 
-use crate::config::WebsocketHandshakeCallback;
+use crate::config::{ProtocolConfiguration, WebsocketHandshakeCallback};
+use crate::events::state::{State, SubscriptionStateChange};
 
-/// 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 {
+        write.send(config.encode(&create_error!(InvalidSession))).await.ok();
+        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.3"
+edition = "2021"
+license = "MIT"
+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/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2024 Pawel Makles
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

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,71 @@
+[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]
+
+[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
+
+[sentry]
+api = ""
+events = ""

crates/core/config/src/lib.rs

@@ -0,0 +1,247 @@
+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;
+
+#[cfg(not(debug_assertions))]
+use std::env;
+
+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 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 Sentry {
+    pub api: String,
+    pub events: String,
+}
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct Settings {
+    pub database: Database,
+    pub hosts: Hosts,
+    pub api: Api,
+    pub features: Features,
+    pub sentry: Sentry,
+}
+
+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, dsn: String) -> 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}");
+
+    if dsn.is_empty() {
+        None
+    } else {
+        Some(sentry::init((
+            dsn,
+            sentry::ClientOptions {
+                release: Some(release.into()),
+                ..Default::default()
+            },
+        )))
+    }
+}
+
+#[macro_export]
+macro_rules! configure {
+    ($application: ident) => {
+        let config = $crate::config().await;
+        let _sentry = $crate::setup_logging(
+            concat!(env!("CARGO_PKG_NAME"), "@", env!("CARGO_PKG_VERSION")),
+            config.sentry.$application,
+        )
+        .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,37 +1,54 @@
 [package]
 name = "revolt-database"
-version = "0.6.0-rc.1"
+version = "0.7.3"
 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.0-rc.1", path = "../result" }
-revolt-models = { version = "0.6.0-rc.1", path = "../models" }
-revolt-presence = { version = "0.6.0-rc.1", path = "../presence" }
-revolt-permissions = { version = "0.6.0-rc.1", path = "../permissions", features = [ "serde" ] }
+revolt-config = { version = "0.7.3", path = "../config" }
+revolt-result = { version = "0.7.3", path = "../result" }
+revolt-models = { version = "0.7.3", path = "../models", features = [
+    "validator",
+] }
+revolt-presence = { version = "0.7.3", path = "../presence" }
+revolt-permissions = { version = "0.7.3", 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"
@@ -46,8 +63,13 @@ redis-kiss = { version = "0.1.4" }
 bson = { optional = true, version = "2.1.0" }
 mongodb = { optional = true, version = "2.1.0", default-features = false }
 
+# Database Migration
+unicode-segmentation = "1.10.1"
+regex = "1"
+
 # Async Language Features
 futures = "0.3.19"
+async-lock = "2.8.0"
 async-trait = "0.1.51"
 async-recursion = "1.0.4"
 
@@ -56,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, 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, ()>>>,
-        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

@@ -1,7 +1,12 @@
 use authifier::AuthifierEvent;
 use serde::{Deserialize, Serialize};
 
-use revolt_models::v0::{FieldsWebhook, PartialWebhook, Webhook};
+use revolt_models::v0::{
+    AppendMessage, Channel, Emoji, FieldsChannel, FieldsMember, FieldsRole, FieldsServer,
+    FieldsUser, FieldsWebhook, Member, MemberCompositeKey, Message, PartialChannel, PartialMember,
+    PartialMessage, PartialRole, PartialServer, PartialUser, PartialWebhook, Report, Server, User,
+    UserSettings, Webhook,
+};
 use revolt_result::Error;
 
 use crate::Database;
@@ -43,18 +48,17 @@ pub enum EventV1 {
 
     /// Successfully authenticated
     Authenticated,
-    /* /// Basic data to cache
+    /// Basic data to cache
     Ready {
         users: Vec<User>,
         servers: Vec<Server>,
         channels: Vec<Channel>,
         members: Vec<Member>,
-        emojis: Option<Vec<Emoji>>,
+        emojis: Vec<Emoji>,
     },
 
     /// Ping response
     Pong { data: Ping },
-
     /// New message
     Message(Message),
 
@@ -101,43 +105,12 @@ pub enum EventV1 {
     /// Bulk delete messages
     BulkMessageDelete { channel: String, ids: Vec<String> },
 
-    /// New channel
-    ChannelCreate(Channel),
-
-    /// Update existing channel
-    ChannelUpdate {
-        id: String,
-        data: PartialChannel,
-        clear: Vec<FieldsChannel>,
-    },
-
-    /// Delete channel
-    ChannelDelete { id: String },
-
-    /// User joins a group
-    ChannelGroupJoin { id: String, user: String },
-
-    /// User leaves a group
-    ChannelGroupLeave { id: String, user: String },
-
-    /// User started typing in a channel
-    ChannelStartTyping { id: String, user: String },
-
-    /// User stopped typing in a channel
-    ChannelStopTyping { id: String, user: String },
-
-    /// User acknowledged message in channel
-    ChannelAck {
-        id: String,
-        user: String,
-        message_id: String,
-    },
-
     /// New server
     ServerCreate {
         id: String,
         server: Server,
         channels: Vec<Channel>,
+        emojis: Vec<Emoji>,
     },
 
     /// Update existing server
@@ -183,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 },
 
@@ -203,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),
 
@@ -211,7 +177,39 @@ pub enum EventV1 {
     EmojiDelete { id: String },
 
     /// New report
-    ReportCreate(Report), */
+    ReportCreate(Report),
+    /// New channel
+    ChannelCreate(Channel),
+
+    /// Update existing channel
+    ChannelUpdate {
+        id: String,
+        data: PartialChannel,
+        clear: Vec<FieldsChannel>,
+    },
+
+    /// Delete channel
+    ChannelDelete { id: String },
+
+    /// User joins a group
+    ChannelGroupJoin { id: String, user: String },
+
+    /// User leaves a group
+    ChannelGroupLeave { id: String, user: String },
+
+    /// User started typing in a channel
+    ChannelStartTyping { id: String, user: String },
+
+    /// User stopped typing in a channel
+    ChannelStopTyping { id: String, user: String },
+
+    /// User acknowledged message in channel
+    ChannelAck {
+        id: String,
+        user: String,
+        message_id: String,
+    },
+
     /// New webhook
     WebhookCreate(Webhook),
 
@@ -246,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/events/mod.rs

@@ -1 +1,2 @@
 pub mod client;
+pub mod server;

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/init.rs

@@ -44,6 +44,10 @@ pub async fn create_database(db: &MongoDb) {
         .await
         .expect("Failed to create channel_unreads collection.");
 
+    db.create_collection("channel_webhooks", None)
+        .await
+        .expect("Failed to create channel_webhooks collection.");
+
     db.create_collection("migrations", None)
         .await
         .expect("Failed to create migrations collection.");
@@ -72,6 +76,10 @@ pub async fn create_database(db: &MongoDb) {
         .await
         .expect("Failed to create bots collection.");
 
+    db.create_collection("ratelimit_events", None)
+        .await
+        .expect("Failed to create ratelimit_events collection.");
+
     db.create_collection(
         "pubsub",
         CreateCollectionOptions::builder()
@@ -91,6 +99,18 @@ pub async fn create_database(db: &MongoDb) {
                         "username": 1_i32
                     },
                     "name": "username",
+                    "unique": false,
+                    "collation": {
+                        "locale": "en",
+                        "strength": 2_i32
+                    }
+                },
+                {
+                    "key": {
+                        "username": 1_i32,
+                        "discriminator": 1_i32
+                    },
+                    "name": "username_discriminator",
                     "unique": true,
                     "collation": {
                         "locale": "en",
@@ -193,5 +213,24 @@ pub async fn create_database(db: &MongoDb) {
         .await
         .expect("Failed to save migration info.");
 
+    db.run_command(
+        doc! {
+            "createIndexes": "ratelimit_events",
+            "indexes": [
+                {
+                    "key": {
+                        "_id": 1_i32,
+                        "target_id": 1_i32,
+                        "event_type": 1_i32,
+                    },
+                    "name": "compound_key"
+                }
+            ]
+        },
+        None,
+    )
+    .await
+    .expect("Failed to create ratelimit_events index.");
+
     info!("Created database.");
 }

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

@@ -1,14 +1,18 @@
-use std::{ops::BitXor, time::Duration};
+use std::{collections::HashSet, ops::BitXor, time::Duration};
 
 use crate::{
     mongodb::{
         bson::{doc, from_bson, from_document, to_document, Bson, DateTime, Document},
         options::FindOptions,
     },
-    MongoDb,
+    Invite, MongoDb, DISCRIMINATOR_SEARCH_SPACE,
 };
+use bson::oid::ObjectId;
 use futures::StreamExt;
+use rand::seq::SliceRandom;
+use revolt_permissions::DEFAULT_WEBHOOK_PERMISSIONS;
 use serde::{Deserialize, Serialize};
+use unicode_segmentation::UnicodeSegmentation;
 
 #[derive(Serialize, Deserialize)]
 struct MigrationInfo {
@@ -16,7 +20,7 @@ struct MigrationInfo {
     revision: i32,
 }
 
-pub const LATEST_REVISION: i32 = 23;
+pub const LATEST_REVISION: i32 = 27;
 
 pub async fn migrate_database(db: &MongoDb) {
     let migrations = db.col::<Document>("migrations");
@@ -694,7 +698,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)
@@ -705,19 +711,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 {
@@ -768,8 +761,318 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
             .expect("Failed to update server members.");
     }
 
+    if revision <= 23 {
+        info!("Running migration [revision 23 / 10-06-2023]: Generate discriminators for users.");
+
+        db.db()
+            .run_command(
+                doc! {
+                    "dropIndexes": "users",
+                    "index": "username"
+                },
+                None,
+            )
+            .await
+            .expect("Failed to drop existing username index.");
+
+        #[derive(Serialize, Deserialize)]
+        struct UserInformation {
+            #[serde(rename = "_id")]
+            id: String,
+            username: String,
+        }
+
+        let re_username = regex::Regex::new(r"^(\p{L}|[\d_.-])+$").unwrap();
+
+        let users: Vec<UserInformation> = db
+            .col::<UserInformation>("users")
+            .find(doc! {}, None)
+            .await
+            .unwrap()
+            .map(|doc| doc.expect("id and username"))
+            .collect()
+            .await;
+
+        let search_space: Vec<String> = DISCRIMINATOR_SEARCH_SPACE.iter().cloned().collect();
+        let mut claimed: HashSet<String> = HashSet::new();
+
+        for i in 0..users.len() {
+            let info = &users[i];
+            let mut discriminator = {
+                let mut rng = rand::thread_rng();
+                search_space.choose(&mut rng).unwrap()
+            };
+
+            if re_username.is_match(&info.username) {
+                while claimed.contains(&format!("{}#{}", info.username, discriminator)) {
+                    let new_discriminator = {
+                        let mut rng = rand::thread_rng();
+                        search_space.choose(&mut rng).unwrap()
+                    };
+
+                    info!(
+                        "Re-rolled {} to {new_discriminator} from {discriminator}",
+                        info.username
+                    );
+
+                    discriminator = new_discriminator;
+                }
+
+                claimed.insert(format!("{}#{}", info.username, discriminator));
+
+                info!(
+                    "({}/{}) Migrating user \"{}\" to #{} - compliant",
+                    i + 1,
+                    users.len(),
+                    info.username,
+                    discriminator
+                );
+
+                db.col::<UserInformation>("users")
+                    .update_one(
+                        doc! {
+                            "_id": &info.id
+                        },
+                        doc! {
+                            "$set": {
+                                "discriminator": discriminator
+                            }
+                        },
+                        None,
+                    )
+                    .await
+                    .unwrap();
+            } else {
+                let mut sanitised = info
+                    .username
+                    .graphemes(true)
+                    .filter(|s| re_username.is_match(s))
+                    .collect::<String>();
+
+                while sanitised.len() < 2 {
+                    sanitised += "_";
+                }
+
+                while claimed.contains(&format!("{}#{}", sanitised, discriminator)) {
+                    let new_discriminator = {
+                        let mut rng = rand::thread_rng();
+                        search_space.choose(&mut rng).unwrap()
+                    };
+
+                    info!("Re-rolled {sanitised} to {new_discriminator} from {discriminator}");
+                    discriminator = new_discriminator;
+                }
+
+                claimed.insert(format!("{}#{}", sanitised, discriminator));
+
+                info!(
+                    "({}/{}) Migrating user \"{}\" to #{} - sanitised: \"{}\"",
+                    i + 1,
+                    users.len(),
+                    info.username,
+                    discriminator,
+                    sanitised
+                );
+
+                db.col::<UserInformation>("users")
+                    .update_one(
+                        doc! {
+                            "_id": &info.id
+                        },
+                        doc! {
+                            "$set": {
+                                "username": sanitised,
+                                "discriminator": discriminator,
+                                "display_name": &info.username
+                            }
+                        },
+                        None,
+                    )
+                    .await
+                    .unwrap();
+            }
+        }
+    }
+
+    if revision <= 24 {
+        info!("Running migration [revision 24 / 09-06-2023]: Add collection `channel_webhooks` if not exists, update users index.");
+
+        db.db()
+            .create_collection("channel_webhooks", None)
+            .await
+            .ok();
+
+        db.db()
+            .run_command(
+                doc! {
+                    "createIndexes": "users",
+                    "indexes": [
+                        {
+                            "key": {
+                                "username": 1_i32
+                            },
+                            "name": "username",
+                            "unique": false,
+                            "collation": {
+                                "locale": "en",
+                                "strength": 2_i32
+                            }
+                        },
+                        {
+                            "key": {
+                                "username": 1_i32,
+                                "discriminator": 1_i32
+                            },
+                            "name": "username_discriminator",
+                            "unique": true,
+                            "collation": {
+                                "locale": "en",
+                                "strength": 2_i32
+                            }
+                        }
+                    ]
+                },
+                None,
+            )
+            .await
+            .expect("Failed to create username index.");
+    };
+
+    if revision <= 25 {
+        info!("Running migration [revision 25 / 11-06-2023]: Add permissions to webhooks.");
+
+        db.col::<Document>("webhooks")
+            .update_many(
+                doc! {},
+                doc! {
+                    "$set": {
+                        "permissions": *DEFAULT_WEBHOOK_PERMISSIONS as i64
+                    }
+                },
+                None,
+            )
+            .await
+            .expect("Failed to update webhooks.");
+    }
+
+    if revision <= 25 {
+        info!("Running migration [revision 25 / 15-06-2023]: Add collection `ratelimit_events` with index.");
+
+        db.db()
+            .create_collection("ratelimit_events", None)
+            .await
+            .ok();
+
+        db.db()
+            .run_command(
+                doc! {
+                    "createIndexes": "ratelimit_events",
+                    "indexes": [
+                        {
+                            "key": {
+                                "_id": 1_i32,
+                                "target_id": 1_i32,
+                                "event_type": 1_i32,
+                            },
+                            "name": "compound_key"
+                        }
+                    ]
+                },
+                None,
+            )
+            .await
+            .expect("Failed to create ratelimit_events index.");
+    }
+
+    if revision <= 26 {
+        info!("Running migration [revision 26 / 15-05-2024]: fix invites being incorrectly serialized with wrong enum tagging.");
+
+        auto_derived!(
+            pub enum OldInvite {
+                Server {
+                    #[serde(rename = "_id")]
+                    code: String,
+                    server: String,
+                    creator: String,
+                    channel: String,
+                },
+                Group {
+                    #[serde(rename = "_id")]
+                    code: String,
+                    creator: String,
+                    channel: String,
+                },
+            }
+        );
+
+        #[derive(serde::Serialize, serde::Deserialize)]
+        struct Outer {
+            _id: ObjectId,
+            #[serde(flatten)]
+            invite: OldInvite,
+        }
+
+        let invites = db
+            .db()
+            .collection::<Outer>("channel_invites")
+            .find(
+                doc! {
+                    "type": { "$exists": false }
+                },
+                None,
+            )
+            .await
+            .expect("failed to find invites")
+            .filter_map(|s| async { s.ok() })
+            .collect::<Vec<Outer>>()
+            .await
+            .into_iter()
+            .map(|invite| match invite.invite {
+                OldInvite::Server {
+                    code,
+                    server,
+                    creator,
+                    channel,
+                } => Invite::Server {
+                    code,
+                    server,
+                    creator,
+                    channel,
+                },
+                OldInvite::Group {
+                    code,
+                    creator,
+                    channel,
+                } => Invite::Group {
+                    code,
+                    creator,
+                    channel,
+                },
+            })
+            .collect::<Vec<Invite>>();
+
+        if !invites.is_empty() {
+            db.db()
+                .collection("channel_invites")
+                .insert_many(invites, None)
+                .await
+                .expect("failed to insert corrected invite");
+
+            db.db()
+                .collection::<Outer>("channel_invites")
+                .delete_many(
+                    doc! {
+                        "type": { "$exists": false }
+                    },
+                    None,
+                )
+                .await
+                .expect("failed to find invites");
+        }
+    }
+
     // Need to migrate fields on attachments, change `user_id`, `object_id`, etc to `parent`.
 
     // Reminder to update LATEST_REVISION when adding new migrations.
-    LATEST_REVISION
+    LATEST_REVISION.max(revision)
 }

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

@@ -1,16 +1,46 @@
-use nanoid::nanoid;
+use revolt_result::{create_error, Result};
 
-use crate::{
-    models::{Channel, Invite, User},
-    Database, 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'
+    '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
+    #[serde(tag = "type")]
+    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 {
@@ -27,9 +57,13 @@ impl Invite {
     }
 
     /// Create a new invite from given information
-    pub async fn create(db: &Database, creator: &User, target: &Channel) -> Result<Invite> {
-        let code = nanoid!(8, &ALPHABET);
-        let invite = match &target {
+    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(),
@@ -43,7 +77,7 @@ impl Invite {
                     channel: id.clone(),
                 })
             }
-            _ => Err(Error::InvalidOperation),
+            _ => Err(create_error!(InvalidOperation)),
         }?;
 
         db.insert_invite(&invite).await?;
@@ -67,6 +101,6 @@ impl Invite {
             }
         }
 
-        Err(Error::NotFound)
+        Err(create_error!(NotFound))
     }
 }

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

@@ -1,17 +1,21 @@
-use crate::models::Invite;
-use crate::Result;
-
-#[async_trait]
-pub trait AbstractChannelInvite: Sync + Send {
-    /// Fetch an invite by its id
-    async fn fetch_invite(&self, code: &str) -> Result<Invite>;
-
-    /// Insert a new invite into the database
-    async fn insert_invite(&self, invite: &Invite) -> Result<()>;
-
-    /// Delete an invite by its id
-    async fn delete_invite(&self, code: &str) -> Result<()>;
-
-    /// Fetch all invites for a server
-    async fn fetch_invites_for_server(&self, server: &str) -> Result<Vec<Invite>>;
-}
+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

@@ -1,69 +1,71 @@
 use bson::Document;
 use mongodb::options::UpdateOptions;
+use revolt_result::Result;
 use ulid::Ulid;
 
-use crate::models::channel_unread::ChannelUnread;
-use crate::{AbstractChannelUnread, Error, Result};
+use crate::ChannelUnread;
+use crate::MongoDb;
 
-use super::super::MongoDb;
+use super::AbstractChannelUnreads;
 
 static COL: &str = "channel_unreads";
 
 #[async_trait]
-impl AbstractChannelUnread for MongoDb {
-    async fn acknowledge_message(&self, channel: &str, user: &str, message: &str) -> Result<()> {
+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.user": user,
+                    "_id.channel": channel_id,
+                    "_id.user": user_id,
                 },
                 doc! {
                     "$unset": {
                         "mentions": 1_i32
                     },
                     "$set": {
-                        "last_id": message
+                        "last_id": message_id
                     }
                 },
                 UpdateOptions::builder().upsert(true).build(),
             )
             .await
             .map(|_| ())
-            .map_err(|_| Error::DatabaseError {
-                operation: "update_one",
-                with: "channel_unread",
-            })
+            .map_err(|_| create_database_error!("update_one", COL))
     }
 
-    async fn acknowledge_channels(&self, user: &str, channels: &[String]) -> Result<()> {
+    /// 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": channels
+                        "$in": channel_ids
                     },
-                    "_id.user": user
+                    "_id.user": user_id
                 },
                 None,
             )
             .await
-            .map_err(|_| Error::DatabaseError {
-                operation: "delete_many",
-                with: "channel_unreads",
-            })?;
+            .map_err(|_| create_database_error!("delete_many", COL))?;
 
         self.col::<Document>(COL)
             .insert_many(
-                channels
+                channel_ids
                     .iter()
-                    .map(|channel| {
+                    .map(|channel_id| {
                         doc! {
                             "_id": {
-                                "channel": channel,
-                                "user": user
+                                "channel": channel_id,
+                                "user": user_id
                             },
                             "last_id": &current_time
                         }
@@ -72,29 +74,27 @@ impl AbstractChannelUnread for MongoDb {
                 None,
             )
             .await
-            .map_err(|_| Error::DatabaseError {
-                operation: "update_many",
-                with: "channel_unreads",
-            })
             .map(|_| ())
+            .map_err(|_| create_database_error!("update_many", COL))
     }
 
+    /// Add a mention.
     async fn add_mention_to_unread<'a>(
         &self,
-        channel: &str,
-        user: &str,
-        ids: &[String],
+        channel_id: &str,
+        user_id: &str,
+        message_ids: &[String],
     ) -> Result<()> {
         self.col::<Document>(COL)
             .update_one(
                 doc! {
-                    "_id.channel": channel,
-                    "_id.user": user,
+                    "_id.channel": channel_id,
+                    "_id.user": user_id,
                 },
                 doc! {
                     "$push": {
                         "mentions": {
-                            "$each": ids
+                            "$each": message_ids
                         }
                     }
                 },
@@ -102,19 +102,18 @@ impl AbstractChannelUnread for MongoDb {
             )
             .await
             .map(|_| ())
-            .map_err(|_| Error::DatabaseError {
-                operation: "update_one",
-                with: "channel_unread",
-            })
+            .map_err(|_| create_database_error!("update_one", COL))
     }
 
-    async fn fetch_unreads(&self, user: &str) -> Result<Vec<ChannelUnread>> {
-        self.find(
+    /// 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.user": user_id
+            }
         )
-        .await
     }
 }

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

@@ -20,6 +20,9 @@ auto_derived_partial!(
         /// The channel this webhook belongs to
         pub channel_id: String,
 
+        /// The permissions of the webhook
+        pub permissions: u64,
+
         /// The private token for the webhook
         pub token: Option<String>,
     },
@@ -33,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<()> {
@@ -117,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/mod.rs

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

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

@@ -0,0 +1,818 @@
+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, 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 {
+            /// Unique Id
+            #[serde(rename = "_id")]
+            id: String,
+            /// Id of the user this channel belongs to
+            user: String,
+        },
+        /// Direct message channel between two users
+        DirectMessage {
+            /// Unique Id
+            #[serde(rename = "_id")]
+            id: String,
+
+            /// Whether this direct message channel is currently open on both sides
+            active: bool,
+            /// 2-tuple of user ids participating in direct message
+            recipients: Vec<String>,
+            /// Id of the last message sent in this channel
+            #[serde(skip_serializing_if = "Option::is_none")]
+            last_message_id: Option<String>,
+        },
+        /// Group channel between 1 or more participants
+        Group {
+            /// Unique Id
+            #[serde(rename = "_id")]
+            id: String,
+
+            /// Display name of the channel
+            name: String,
+            /// User id of the owner of the group
+            owner: String,
+            /// Channel description
+            #[serde(skip_serializing_if = "Option::is_none")]
+            description: Option<String>,
+            /// Array of user ids participating in channel
+            recipients: Vec<String>,
+
+            /// Custom icon attachment
+            #[serde(skip_serializing_if = "Option::is_none")]
+            icon: Option<File>,
+            /// Id of the last message sent in this channel
+            #[serde(skip_serializing_if = "Option::is_none")]
+            last_message_id: Option<String>,
+
+            /// Permissions assigned to members of this group
+            /// (does not apply to the owner of the group)
+            #[serde(skip_serializing_if = "Option::is_none")]
+            permissions: Option<i64>,
+
+            /// Whether this group is marked as not safe for work
+            #[serde(skip_serializing_if = "crate::if_false", default)]
+            nsfw: bool,
+        },
+        /// Text channel belonging to a server
+        TextChannel {
+            /// Unique Id
+            #[serde(rename = "_id")]
+            id: String,
+            /// Id of the server this channel belongs to
+            server: String,
+
+            /// Display name of the channel
+            name: String,
+            /// Channel description
+            #[serde(skip_serializing_if = "Option::is_none")]
+            description: Option<String>,
+
+            /// Custom icon attachment
+            #[serde(skip_serializing_if = "Option::is_none")]
+            icon: Option<File>,
+            /// Id of the last message sent in this channel
+            #[serde(skip_serializing_if = "Option::is_none")]
+            last_message_id: Option<String>,
+
+            /// Default permissions assigned to users in this channel
+            #[serde(skip_serializing_if = "Option::is_none")]
+            default_permissions: Option<OverrideField>,
+            /// Permissions assigned based on role to this channel
+            #[serde(
+                default = "HashMap::<String, OverrideField>::new",
+                skip_serializing_if = "HashMap::<String, OverrideField>::is_empty"
+            )]
+            role_permissions: HashMap<String, OverrideField>,
+
+            /// Whether this channel is marked as not safe for work
+            #[serde(skip_serializing_if = "crate::if_false", default)]
+            nsfw: bool,
+        },
+        /// Voice channel belonging to a server
+        VoiceChannel {
+            /// Unique Id
+            #[serde(rename = "_id")]
+            id: String,
+            /// Id of the server this channel belongs to
+            server: String,
+
+            /// Display name of the channel
+            name: String,
+            #[serde(skip_serializing_if = "Option::is_none")]
+            /// Channel description
+            description: Option<String>,
+            /// Custom icon attachment
+            #[serde(skip_serializing_if = "Option::is_none")]
+            icon: Option<File>,
+
+            /// Default permissions assigned to users in this channel
+            #[serde(skip_serializing_if = "Option::is_none")]
+            default_permissions: Option<OverrideField>,
+            /// Permissions assigned based on role to this channel
+            #[serde(
+                default = "HashMap::<String, OverrideField>::new",
+                skip_serializing_if = "HashMap::<String, OverrideField>::is_empty"
+            )]
+            role_permissions: HashMap<String, OverrideField>,
+
+            /// Whether this channel is marked as not safe for work
+            #[serde(skip_serializing_if = "crate::if_false", default)]
+            nsfw: bool,
+        },
+    }
+);
+
+auto_derived!(
+    #[derive(Default)]
+    pub struct PartialChannel {
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub name: Option<String>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub owner: Option<String>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub description: Option<String>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub icon: Option<File>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub nsfw: Option<bool>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub active: Option<bool>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub permissions: Option<i64>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub role_permissions: Option<HashMap<String, OverrideField>>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub default_permissions: Option<OverrideField>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub last_message_id: Option<String>,
+    }
+
+    /// Optional fields on channel object
+    pub enum FieldsChannel {
+        Description,
+        Icon,
+        DefaultPermissions,
+    }
+);
+
+#[allow(clippy::disallowed_methods)]
+impl 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: &User,
+        by_id: &str,
+    ) -> Result<()> {
+        if let Channel::Group { recipients, .. } = self {
+            if recipients.contains(&String::from(&user.id)) {
+                return Err(create_error!(AlreadyInGroup));
+            }
+
+            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?;
+
+                EventV1::ChannelGroupJoin {
+                    id: id.to_string(),
+                    user: user.id.to_string(),
+                }
+                .p(id.to_string())
+                .await;
+
+                SystemMessage::UserAdded {
+                    id: user.id.to_string(),
+                    by: by_id.to_string(),
+                }
+                .into_message(id.to_string())
+                .send(
+                    db,
+                    MessageAuthor::System {
+                        username: &user.username,
+                        avatar: user.avatar.as_ref().map(|file| file.id.as_ref()),
+                    },
+                    self,
+                    false,
+                )
+                .await
+                .ok();
+
+                EventV1::ChannelCreate(self.clone().into())
+                    .private(user.id.to_string())
+                    .await;
+
+                Ok(())
+            }
+            _ => Err(create_error!(InvalidOperation)),
+        }
+    }
+
+    /// Map out whether it is a direct DM
+    pub fn is_direct_dm(&self) -> bool {
+        matches!(self, Channel::DirectMessage { .. })
+    }
+
+    /// Check whether has a user as a recipient
+    pub fn contains_user(&self, user_id: &str) -> bool {
+        match self {
+            Channel::Group { recipients, .. } => recipients.contains(&String::from(user_id)),
+            _ => false,
+        }
+    }
+
+    /// Get list of recipients
+    pub fn users(&self) -> Result<Vec<String>> {
+        match self {
+            Channel::Group { recipients, .. } => Ok(recipients.to_owned()),
+            _ => Err(create_error!(NotFound)),
+        }
+    }
+
+    /// Clone this channel's id
+    pub fn id(&self) -> String {
+        match self {
+            Channel::DirectMessage { id, .. }
+            | Channel::Group { id, .. }
+            | Channel::SavedMessages { id, .. }
+            | Channel::TextChannel { id, .. }
+            | Channel::VoiceChannel { id, .. } => id.clone(),
+        }
+    }
+
+    /// Set role permission on a channel
+    pub async fn set_role_permission(
+        &mut self,
+        db: &Database,
+        role_id: &str,
+        permissions: OverrideField,
+    ) -> Result<()> {
+        match self {
+            Channel::TextChannel {
+                id,
+                server,
+                role_permissions,
+                ..
+            }
+            | Channel::VoiceChannel {
+                id,
+                server,
+                role_permissions,
+                ..
+            } => {
+                db.set_channel_role_permission(id, role_id, permissions)
+                    .await?;
+
+                role_permissions.insert(role_id.to_string(), permissions);
+
+                EventV1::ChannelUpdate {
+                    id: id.clone(),
+                    data: PartialChannel {
+                        role_permissions: Some(role_permissions.clone()),
+                        ..Default::default()
+                    }
+                    .into(),
+                    clear: vec![],
+                }
+                .p(server.clone())
+                .await;
+
+                Ok(())
+            }
+            _ => Err(create_error!(InvalidOperation)),
+        }
+    }
+
+    /// Update channel data
+    pub async fn update(
+        &mut self,
+        db: &Database,
+        partial: PartialChannel,
+        remove: Vec<FieldsChannel>,
+    ) -> Result<()> {
+        for field in &remove {
+            self.remove_field(field);
+        }
+
+        self.apply_options(partial.clone());
+
+        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(())
+    }
+
+    /// Remove a field from Channel object
+    pub fn remove_field(&mut self, field: &FieldsChannel) {
+        match field {
+            FieldsChannel::Description => match self {
+                Self::Group { description, .. }
+                | Self::TextChannel { description, .. }
+                | Self::VoiceChannel { description, .. } => {
+                    description.take();
+                }
+                _ => {}
+            },
+            FieldsChannel::Icon => match self {
+                Self::Group { icon, .. }
+                | Self::TextChannel { icon, .. }
+                | Self::VoiceChannel { icon, .. } => {
+                    icon.take();
+                }
+                _ => {}
+            },
+            FieldsChannel::DefaultPermissions => match self {
+                Self::TextChannel {
+                    default_permissions,
+                    ..
+                }
+                | Self::VoiceChannel {
+                    default_permissions,
+                    ..
+                } => {
+                    default_permissions.take();
+                }
+                _ => {}
+            },
+        }
+    }
+
+    /// Remove multiple fields from Channel object
+    pub fn remove_fields(&mut self, partial: Vec<FieldsChannel>) {
+        for field in partial {
+            self.remove_field(&field)
+        }
+    }
+
+    /// Apply partial channel to channel
+    pub fn apply_options(&mut self, partial: PartialChannel) {
+        match self {
+            Self::SavedMessages { .. } => {}
+            Self::DirectMessage { active, .. } => {
+                if let Some(v) = partial.active {
+                    *active = v;
+                }
+            }
+            Self::Group {
+                name,
+                owner,
+                description,
+                icon,
+                nsfw,
+                permissions,
+                ..
+            } => {
+                if let Some(v) = partial.name {
+                    *name = v;
+                }
+
+                if let Some(v) = partial.owner {
+                    *owner = v;
+                }
+
+                if let Some(v) = partial.description {
+                    description.replace(v);
+                }
+
+                if let Some(v) = partial.icon {
+                    icon.replace(v);
+                }
+
+                if let Some(v) = partial.nsfw {
+                    *nsfw = v;
+                }
+
+                if let Some(v) = partial.permissions {
+                    permissions.replace(v);
+                }
+            }
+            Self::TextChannel {
+                name,
+                description,
+                icon,
+                nsfw,
+                default_permissions,
+                role_permissions,
+                ..
+            }
+            | Self::VoiceChannel {
+                name,
+                description,
+                icon,
+                nsfw,
+                default_permissions,
+                role_permissions,
+                ..
+            } => {
+                if let Some(v) = partial.name {
+                    *name = v;
+                }
+
+                if let Some(v) = partial.description {
+                    description.replace(v);
+                }
+
+                if let Some(v) = partial.icon {
+                    icon.replace(v);
+                }
+
+                if let Some(v) = partial.nsfw {
+                    *nsfw = v;
+                }
+
+                if let Some(v) = partial.role_permissions {
+                    *role_permissions = v;
+                }
+
+                if let Some(v) = partial.default_permissions {
+                    default_permissions.replace(v);
+                }
+            }
+        }
+    }
+
+    /// 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: &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) {
+                        db.update_channel(
+                            id,
+                            &PartialChannel {
+                                owner: Some(new_owner.into()),
+                                ..Default::default()
+                            },
+                            vec![],
+                        )
+                        .await?;
+
+                        SystemMessage::ChannelOwnershipChanged {
+                            from: owner.to_string(),
+                            to: new_owner.to_string(),
+                        }
+                        .into_message(id.to_string())
+                        .send(
+                            db,
+                            MessageAuthor::System {
+                                username: name,
+                                avatar: None,
+                            },
+                            self,
+                            false,
+                        )
+                        .await
+                        .ok();
+                    } else {
+                        return self.delete(db).await;
+                    }
+                }
+
+                EventV1::ChannelGroupLeave {
+                    id: id.to_string(),
+                    user: user.id.to_string(),
+                }
+                .p(id.to_string())
+                .await;
+
+                if !silent {
+                    if let Some(by) = by_id {
+                        SystemMessage::UserRemove {
+                            id: user.id.to_string(),
+                            by: by.to_string(),
+                        }
+                    } else {
+                        SystemMessage::UserLeft {
+                            id: user.id.to_string(),
+                        }
+                    }
+                    .into_message(id.to_string())
+                    .send(
+                        db,
+                        MessageAuthor::System {
+                            username: &user.username,
+                            avatar: user.avatar.as_ref().map(|file| file.id.as_ref()),
+                        },
+                        self,
+                        false,
+                    )
+                    .await
+                    .ok();
+                }
+
+                Ok(())
+            }
+
+            _ => Err(create_error!(InvalidOperation)),
+        }
+    }
+
+    /// 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
+    }
+}
+
+impl IntoDocumentPath for FieldsChannel {
+    fn as_path(&self) -> Option<&'static str> {
+        Some(match self {
+            FieldsChannel::Description => "description",
+            FieldsChannel::Icon => "icon",
+            FieldsChannel::DefaultPermissions => "default_permissions",
+        })
+    }
+}
+
+#[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.rs

@@ -0,0 +1,50 @@
+use crate::{revolt_result::Result, Channel, FieldsChannel, PartialChannel};
+use revolt_permissions::OverrideField;
+mod mongodb;
+mod reference;
+
+#[async_trait]
+pub trait AbstractChannels: Sync + Send {
+    /// Insert a new channel in the database
+    async fn insert_channel(&self, channel: &Channel) -> Result<()>;
+
+    /// Fetch a channel from the database
+    async fn fetch_channel(&self, channel_id: &str) -> Result<Channel>;
+
+    /// Fetch all channels from the database
+    async fn fetch_channels<'a>(&self, ids: &'a [String]) -> Result<Vec<Channel>>;
+
+    /// Fetch all direct messages for a user
+    async fn find_direct_messages(&self, user_id: &str) -> Result<Vec<Channel>>;
+
+    // Fetch saved messages channel
+    async fn find_saved_messages_channel(&self, user_id: &str) -> Result<Channel>;
+
+    // Fetch direct message channel (DM or Saved Messages)
+    async fn find_direct_message_channel(&self, user_a: &str, user_b: &str) -> Result<Channel>;
+
+    /// Insert a user to a group
+    async fn add_user_to_group(&self, channel_id: &str, user_id: &str) -> Result<()>;
+
+    /// Insert channel role permissions
+    async fn set_channel_role_permission(
+        &self,
+        channel_id: &str,
+        role_id: &str,
+        permissions: OverrideField,
+    ) -> Result<()>;
+
+    // Update channel
+    async fn update_channel(
+        &self,
+        id: &str,
+        channel_id: &PartialChannel,
+        remove: Vec<FieldsChannel>,
+    ) -> Result<()>;
+
+    // Remove a user from a group
+    async fn remove_user_from_group(&self, channel_id: &str, user_id: &str) -> Result<()>;
+
+    // Delete a channel
+    async fn delete_channel(&self, channel_id: &Channel) -> Result<()>;
+}

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

@@ -1,102 +1,192 @@
+use super::AbstractChannels;
+use crate::{AbstractServers, Channel, FieldsChannel, IntoDocumentPath, MongoDb, PartialChannel};
 use bson::{Bson, Document};
-
-use crate::models::channel::{Channel, FieldsChannel, PartialChannel};
-use crate::r#impl::mongo::IntoDocumentPath;
-use crate::{AbstractChannel, AbstractServer, Error, OverrideField, Result};
-
-use super::super::MongoDb;
+use futures::StreamExt;
+use revolt_permissions::OverrideField;
+use revolt_result::Result;
 
 static COL: &str = "channels";
 
-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(|_| Error::DatabaseError {
-                operation: "delete_many",
-                with: "channel_invites",
-            })?;
-
-        // Delete unread message objects on channels.
-        self.col::<Document>("channel_unreads")
-            .delete_many(
-                doc! {
-                    "_id.channel": &id
-                },
-                None,
-            )
-            .await
-            .map_err(|_| Error::DatabaseError {
-                operation: "delete_many",
-                with: "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(|_| Error::DatabaseError {
-                operation: "delete_many",
-                with: "webhooks",
-            })
-            .map(|_| ())
-    }
-}
-
 #[async_trait]
-impl AbstractChannel for MongoDb {
-    async fn fetch_channel(&self, id: &str) -> Result<Channel> {
-        self.find_one_by_id(COL, id).await
+impl AbstractChannels for MongoDb {
+    /// Insert a new channel in the database
+    async fn insert_channel(&self, channel: &Channel) -> Result<()> {
+        query!(self, insert_one, COL, &channel).map(|_| ())
     }
 
+    /// Fetch a channel from the database
+    async fn fetch_channel(&self, channel_id: &str) -> Result<Channel> {
+        query!(self, find_one_by_id, COL, channel_id)?.ok_or_else(|| create_error!(NotFound))
+    }
+
+    /// Fetch all channels from the database
     async fn fetch_channels<'a>(&self, ids: &'a [String]) -> Result<Vec<Channel>> {
-        self.find(
+        Ok(self
+            .col::<Channel>(COL)
+            .find(
+                doc! {
+                    "_id": {
+                        "$in": ids
+                    }
+                },
+                None,
+            )
+            .await
+            .map_err(|_| create_database_error!("fetch", "channels"))?
+            .filter_map(|s| async {
+                if cfg!(debug_assertions) {
+                    Some(s.unwrap())
+                } else {
+                    s.ok()
+                }
+            })
+            .collect()
+            .await)
+    }
+
+    /// Fetch all direct messages for a user
+    async fn find_direct_messages(&self, user_id: &str) -> Result<Vec<Channel>> {
+        query!(
+            self,
+            find,
             COL,
             doc! {
-                "_id": {
-                    "$in": ids
-                }
-            },
+                "$or": [
+                    {
+                        "$or": [
+                            {
+                                "channel_type": "DirectMessage"
+                            },
+                            {
+                                "channel_type": "Group"
+                            }
+                        ],
+                        "recipients": user_id
+                    },
+                    {
+                        "channel_type": "SavedMessages",
+                        "user": user_id
+                    }
+                ]
+            }
         )
-        .await
     }
 
-    async fn insert_channel(&self, channel: &Channel) -> Result<()> {
-        self.insert_one(COL, channel).await.map(|_| ())
+    // Fetch saved messages channel
+    async fn find_saved_messages_channel(&self, user_id: &str) -> Result<Channel> {
+        query!(
+            self,
+            find_one,
+            COL,
+            doc! {
+                "channel_type": "SavedMessages",
+                "user": user_id
+            }
+        )?
+        .ok_or_else(|| create_error!(InternalError))
     }
 
+    // Fetch direct message channel (DM or Saved Messages)
+    async fn find_direct_message_channel(&self, user_a: &str, user_b: &str) -> Result<Channel> {
+        let doc = match (user_a, user_b) {
+            self_user if self_user.0 == self_user.1 => {
+                doc! {
+                    "channel_type": "SavedMessages",
+                    "user": self_user.0
+                }
+            }
+            users => {
+                doc! {
+                    "channel_type": "DirectMessage",
+                    "recipients": {
+                        "$all": [ users.0, users.1 ]
+                    }
+                }
+            }
+        };
+        query!(self, find_one, COL, doc)?.ok_or_else(|| create_error!(NotFound))
+    }
+
+    /// Insert a user to a group
+    async fn add_user_to_group(&self, channel: &str, user: &str) -> Result<()> {
+        self.col::<Document>(COL)
+            .update_one(
+                doc! {
+                    "_id": channel
+                },
+                doc! {
+                    "$push": {
+                        "recipients": user
+                    }
+                },
+                None,
+            )
+            .await
+            .map(|_| ())
+            .map_err(|_| create_database_error!("update_one", "channel"))
+    }
+
+    /// Insert channel role permissions
+    async fn set_channel_role_permission(
+        &self,
+        channel: &str,
+        role: &str,
+        permissions: OverrideField,
+    ) -> Result<()> {
+        self.col::<Document>(COL)
+            .update_one(
+                doc! { "_id": channel },
+                doc! {
+                "$set": {
+                    "role_permissions.".to_owned() + role: permissions
+                }
+                },
+                None,
+            )
+            .await
+            .map(|_| ())
+            .map_err(|_| create_database_error!("update_one", "channel"))
+    }
+
+    // Update channel
     async fn update_channel(
         &self,
         id: &str,
         channel: &PartialChannel,
         remove: Vec<FieldsChannel>,
     ) -> Result<()> {
-        self.update_one_by_id(
+        query!(
+            self,
+            update_one_by_id,
             COL,
             id,
             channel,
             remove.iter().map(|x| x as &dyn IntoDocumentPath).collect(),
-            None,
+            None
         )
-        .await
         .map(|_| ())
     }
 
+    // Remove a user from a group
+    async fn remove_user_from_group(&self, channel: &str, user: &str) -> Result<()> {
+        self.col::<Document>(COL)
+            .update_one(
+                doc! {
+                    "_id": channel
+                },
+                doc! {
+                    "$pull": {
+                        "recipients": user
+                    }
+                },
+                None,
+            )
+            .await
+            .map(|_| ())
+            .map_err(|_| create_database_error!("update_one", "channels"))
+    }
+
+    // Delete a channel
     async fn delete_channel(&self, channel: &Channel) -> Result<()> {
         let id = channel.id().to_string();
         let server_id = match channel {
@@ -166,10 +256,7 @@ impl AbstractChannel for MongoDb {
                     None,
                 )
                 .await
-                .map_err(|_| Error::DatabaseError {
-                    operation: "update_one",
-                    with: "servers",
-                })?;
+                .map_err(|_| create_database_error!("update_one", "servers"))?;
         }
 
         // Delete associated attachments
@@ -179,139 +266,47 @@ impl AbstractChannel for MongoDb {
         .await?;
 
         // Delete the channel itself
-        self.delete_one_by_id(COL, &id).await.map(|_| ())
-    }
-
-    async fn find_direct_messages(&self, user_id: &str) -> Result<Vec<Channel>> {
-        self.find(
-            COL,
-            doc! {
-                "$or": [
-                    {
-                        "$or": [
-                            {
-                                "channel_type": "DirectMessage"
-                            },
-                            {
-                                "channel_type": "Group"
-                            }
-                        ],
-                        "recipients": user_id
-                    },
-                    {
-                        "channel_type": "SavedMessages",
-                        "user": user_id
-                    }
-                ]
-            },
-        )
-        .await
-    }
-
-    async fn find_saved_messages_channel(&self, user_id: &str) -> Result<Channel> {
-        self.find_one(
-            COL,
-            doc! {
-                "channel_type": "SavedMessages",
-                "user": user_id
-            },
-        )
-        .await
-    }
-
-    async fn find_direct_message_channel(&self, user_a: &str, user_b: &str) -> Result<Channel> {
-        self.find_one(
-            COL,
-            if user_a == user_b {
-                doc! {
-                    "channel_type": "SavedMessages",
-                    "user": user_a
-                }
-            } else {
-                doc! {
-                    "channel_type": "DirectMessage",
-                    "recipients": {
-                        "$all": [ user_a, user_b ]
-                    }
-                }
-            },
-        )
-        .await
-    }
-
-    async fn add_user_to_group(&self, channel: &str, user: &str) -> Result<()> {
-        self.col::<Document>(COL)
-            .update_one(
-                doc! {
-                    "_id": channel
-                },
-                doc! {
-                    "$push": {
-                        "recipients": user
-                    }
-                },
-                None,
-            )
-            .await
-            .map(|_| ())
-            .map_err(|_| Error::DatabaseError {
-                operation: "update_one",
-                with: "channel",
-            })
-    }
-
-    async fn remove_user_from_group(&self, channel: &str, user: &str) -> Result<()> {
-        self.col::<Document>(COL)
-            .update_one(
-                doc! {
-                    "_id": channel
-                },
-                doc! {
-                    "$pull": {
-                        "recipients": user
-                    }
-                },
-                None,
-            )
-            .await
-            .map(|_| ())
-            .map_err(|_| Error::DatabaseError {
-                operation: "update_one",
-                with: "channel",
-            })
-    }
-
-    async fn set_channel_role_permission(
-        &self,
-        channel: &str,
-        role: &str,
-        permissions: OverrideField,
-    ) -> Result<()> {
-        self.col::<Document>(COL)
-            .update_one(
-                doc! { "_id": channel },
-                doc! {
-                    "$set": {
-                        "role_permissions.".to_owned() + role: permissions
-                    }
-                },
-                None,
-            )
-            .await
-            .map(|_| ())
-            .map_err(|_| Error::DatabaseError {
-                operation: "update_one",
-                with: "channel",
-            })
+        query!(self, delete_one_by_id, COL, &channel.id()).map(|_| ())
     }
 }
 
-impl IntoDocumentPath for FieldsChannel {
-    fn as_path(&self) -> Option<&'static str> {
-        Some(match self {
-            FieldsChannel::DefaultPermissions => "default_permissions",
-            FieldsChannel::Description => "description",
-            FieldsChannel::Icon => "icon",
-        })
+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/channels/ops/reference.rs

@@ -0,0 +1,157 @@
+use std::collections::hash_map::Entry;
+
+use super::AbstractChannels;
+use crate::ReferenceDb;
+use crate::{Channel, FieldsChannel, PartialChannel};
+use revolt_permissions::OverrideField;
+use revolt_result::Result;
+
+#[async_trait]
+impl AbstractChannels for ReferenceDb {
+    /// Insert a new channel in the database
+    async fn insert_channel(&self, channel: &Channel) -> Result<()> {
+        let mut channels = self.channels.lock().await;
+        if let Entry::Vacant(entry) = channels.entry(channel.id()) {
+            entry.insert(channel.clone());
+            Ok(())
+        } else {
+            Err(create_database_error!("insert", "channel"))
+        }
+    }
+
+    /// Fetch a channel from the database
+    async fn fetch_channel(&self, channel_id: &str) -> Result<Channel> {
+        let channels = self.channels.lock().await;
+        channels
+            .get(channel_id)
+            .cloned()
+            .ok_or_else(|| create_error!(NotFound))
+    }
+
+    /// Fetch all channels from the database
+    async fn fetch_channels<'a>(&self, ids: &'a [String]) -> Result<Vec<Channel>> {
+        let channels = self.channels.lock().await;
+        ids.iter()
+            .map(|id| {
+                channels
+                    .get(id)
+                    .cloned()
+                    .ok_or_else(|| create_error!(NotFound))
+            })
+            .collect()
+    }
+
+    /// Fetch all direct messages for a user
+    async fn find_direct_messages(&self, user_id: &str) -> Result<Vec<Channel>> {
+        let channels = self.channels.lock().await;
+        Ok(channels
+            .values()
+            .filter(|channel| channel.contains_user(user_id))
+            .cloned()
+            .collect())
+    }
+
+    // Fetch saved messages channel
+    async fn find_saved_messages_channel(&self, user_id: &str) -> Result<Channel> {
+        let channels = self.channels.lock().await;
+        channels
+            .get(user_id)
+            .cloned()
+            .ok_or_else(|| create_database_error!("fetch", "channel"))
+    }
+
+    // Fetch direct message channel (DM or Saved Messages)
+    async fn find_direct_message_channel(&self, user_a: &str, user_b: &str) -> Result<Channel> {
+        let channels = self.channels.lock().await;
+        for (_, data) in channels.iter() {
+            if data.contains_user(user_a) && data.contains_user(user_b) {
+                return Ok(data.to_owned());
+            }
+        }
+        Err(create_error!(NotFound))
+    }
+    /// Insert a user to a group
+    async fn add_user_to_group(&self, channel_id: &str, user_id: &str) -> Result<()> {
+        let mut channels = self.channels.lock().await;
+
+        if let Some(Channel::Group { recipients, .. }) = channels.get_mut(channel_id) {
+            recipients.push(String::from(user_id));
+            Ok(())
+        } else {
+            Err(create_error!(InvalidOperation))
+        }
+    }
+    /// Insert channel role permissions
+    async fn set_channel_role_permission(
+        &self,
+        channel_id: &str,
+        role_id: &str,
+        permissions: OverrideField,
+    ) -> Result<()> {
+        let mut channels = self.channels.lock().await;
+
+        if let Some(mut channel) = channels.get_mut(channel_id) {
+            match &mut channel {
+                Channel::TextChannel {
+                    role_permissions, ..
+                }
+                | Channel::VoiceChannel {
+                    role_permissions, ..
+                } => {
+                    if role_permissions.get(role_id).is_some() {
+                        role_permissions.remove(role_id);
+                        role_permissions.insert(String::from(role_id), permissions);
+
+                        Ok(())
+                    } else {
+                        Err(create_error!(NotFound))
+                    }
+                }
+                _ => Err(create_error!(NotFound)),
+            }
+        } else {
+            Err(create_error!(NotFound))
+        }
+    }
+
+    // Update channel
+    async fn update_channel(
+        &self,
+        id: &str,
+        channel: &PartialChannel,
+        remove: Vec<FieldsChannel>,
+    ) -> Result<()> {
+        let mut channels = self.channels.lock().await;
+        if let Some(channel_data) = channels.get_mut(id) {
+            channel_data.apply_options(channel.to_owned());
+            channel_data.remove_fields(remove);
+            Ok(())
+        } else {
+            Err(create_error!(NotFound))
+        }
+    }
+
+    // Remove a user from a group
+    async fn remove_user_from_group(&self, channel: &str, user: &str) -> Result<()> {
+        let mut channels = self.channels.lock().await;
+        if let Some(channel_data) = channels.get_mut(channel) {
+            if channel_data.users()?.contains(&String::from(user)) {
+                channel_data.users()?.retain(|x| x != user);
+                return Ok(());
+            } else {
+                return Err(create_error!(NotFound));
+            }
+        }
+        Err(create_error!(NotFound))
+    }
+
+    // Delete a channel
+    async fn delete_channel(&self, channel: &Channel) -> Result<()> {
+        let mut channels = self.channels.lock().await;
+        if channels.remove(&channel.id()).is_some() {
+            Ok(())
+        } else {
+            Err(create_error!(NotFound))
+        }
+    }
+}

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

@@ -1,19 +1,49 @@
-use std::{collections::HashSet, str::FromStr};
-use once_cell::sync::Lazy;
+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,
-    models::{emoji::EmojiParent, Emoji},
-    Database, Result,
-};
+use crate::events::client::EventV1;
+use crate::Database;
 
-static PERMISSIBLE_EMOJIS: Lazy<HashSet<String>> = Lazy::new(|| include_str!(crate::asset!("emojis.txt"))
-    .split('\n')
-    .map(|x| x.into())
-    .collect());
+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 {
@@ -26,7 +56,8 @@ impl Emoji {
     /// Create an emoji
     pub async fn create(&self, db: &Database) -> Result<()> {
         db.insert_emoji(self).await?;
-        EventV1::EmojiCreate(self.clone())
+
+        EventV1::EmojiCreate(self.clone().into())
             .p(self.parent().to_string())
             .await;
 

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

@@ -1,8 +1,15 @@
-use crate::models::Emoji;
-use crate::Result;
+use revolt_result::Result;
+
+use crate::Emoji;
+
+mod mongodb;
+mod reference;
 
 #[async_trait]
-pub trait AbstractEmoji: Sync + Send {
+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>;
 
@@ -12,9 +19,6 @@ pub trait AbstractEmoji: Sync + Send {
     /// Fetch emoji by their parent ids
     async fn fetch_emoji_by_parent_ids(&self, parent_ids: &[String]) -> Result<Vec<Emoji>>;
 
-    /// Insert emoji into database.
-    async fn insert_emoji(&self, emoji: &Emoji) -> Result<()>;
-
     /// Detach an emoji by its id
     async fn detach_emoji(&self, emoji: &Emoji) -> Result<()>;
 }

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

@@ -1,49 +1,52 @@
 use bson::Document;
+use revolt_result::Result;
 
-use crate::models::Emoji;
-use crate::{AbstractEmoji, Error, Result};
+use crate::Emoji;
+use crate::MongoDb;
 
-use super::super::MongoDb;
+use super::AbstractEmojis;
 
 static COL: &str = "emojis";
 
 #[async_trait]
-impl AbstractEmoji for MongoDb {
-    /// Fetch an emoji by its id
-    async fn fetch_emoji(&self, id: &str) -> Result<Emoji> {
-        self.find_one_by_id(COL, id).await
+impl AbstractEmojis for MongoDb {
+    /// Insert emoji into database.
+    async fn insert_emoji(&self, emoji: &Emoji) -> Result<()> {
+        query!(self, insert_one, COL, &emoji).map(|_| ())
     }
 
-    /// Fetch emoji by their ids
+    /// 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>> {
-        self.find(
+        query!(
+            self,
+            find,
             COL,
             doc! {
                 "parent.id": parent_id
-            },
+            }
         )
-        .await
     }
 
     /// Fetch emoji by their parent ids
     async fn fetch_emoji_by_parent_ids(&self, parent_ids: &[String]) -> Result<Vec<Emoji>> {
-        self.find(
+        query!(
+            self,
+            find,
             COL,
             doc! {
                 "parent.id": {
                     "$in": parent_ids
                 }
-            },
+            }
         )
-        .await
     }
 
-    /// Insert emoji into database.
-    async fn insert_emoji(&self, emoji: &Emoji) -> Result<()> {
-        self.insert_one(COL, emoji).await.map(|_| ())
-    }
-
-    /// Delete an emoji by its id
+    /// Detach an emoji by its id
     async fn detach_emoji(&self, emoji: &Emoji) -> Result<()> {
         self.col::<Document>(COL)
             .update_one(
@@ -61,9 +64,6 @@ impl AbstractEmoji for MongoDb {
             )
             .await
             .map(|_| ())
-            .map_err(|_| Error::DatabaseError {
-                operation: "update_one",
-                with: "emojis",
-            })
+            .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

@@ -1,13 +1,23 @@
-use crate::models::message::{AppendMessage, Message, MessageQuery, PartialMessage};
-use crate::Result;
+use revolt_result::Result;
+
+use crate::{AppendMessage, Message, MessageQuery, PartialMessage};
+
+mod mongodb;
+mod reference;
 
 #[async_trait]
-pub trait AbstractMessage: Sync + Send {
+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>;
 
-    /// Insert a new message into the database
-    async fn insert_message(&self, message: &Message) -> Result<()>;
+    /// 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<()>;
@@ -15,15 +25,6 @@ pub trait AbstractMessage: Sync + Send {
     /// Append information to a given message
     async fn append_message(&self, id: &str, append: &AppendMessage) -> 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: Vec<String>) -> Result<()>;
-
-    /// Fetch multiple messages by given query
-    async fn fetch_messages(&self, query: MessageQuery) -> Result<Vec<Message>>;
-
     /// Add a new reaction to a message
     async fn add_reaction(&self, id: &str, emoji: &str, user: &str) -> Result<()>;
 
@@ -32,4 +33,10 @@ pub trait AbstractMessage: Sync + Send {
 
     /// 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

@@ -1,146 +1,30 @@
 use bson::{to_bson, Document};
 use futures::try_join;
 use mongodb::options::FindOptions;
+use revolt_models::v0::MessageSort;
+use revolt_result::Result;
 
-use crate::models::message::{
-    AppendMessage, Message, MessageQuery, MessageSort, MessageTimePeriod, PartialMessage,
+use crate::{
+    AppendMessage, DocumentId, Message, MessageQuery, MessageTimePeriod, MongoDb, PartialMessage,
 };
-use crate::r#impl::mongo::DocumentId;
-use crate::{AbstractMessage, Error, Result};
 
-use super::super::MongoDb;
+use super::AbstractMessages;
 
 static COL: &str = "messages";
 
-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?
-            .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(|_| Error::DatabaseError {
-                    operation: "update_many",
-                    with: "attachments",
-                })?;
-        }
-
-        // And then delete said messages.
-        self.col::<Document>(COL)
-            .delete_many(projection, None)
-            .await
-            .map(|_| ())
-            .map_err(|_| Error::DatabaseError {
-                operation: "delete_many",
-                with: "messages",
-            })
-    }
-}
-
 #[async_trait]
-impl AbstractMessage for MongoDb {
-    async fn fetch_message(&self, id: &str) -> Result<Message> {
-        self.find_one_by_id(COL, id).await
-    }
-
+impl AbstractMessages for MongoDb {
+    /// Insert a new message into the database
     async fn insert_message(&self, message: &Message) -> Result<()> {
-        self.insert_one(COL, message).await.map(|_| ())
+        query!(self, insert_one, COL, &message).map(|_| ())
     }
 
-    async fn update_message(&self, id: &str, message: &PartialMessage) -> Result<()> {
-        self.update_one_by_id(COL, id, message, vec![], None)
-            .await
-            .map(|_| ())
-    }
-
-    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(|_| Error::DatabaseError {
-                                    operation: "to_bson",
-                                    with: "embeds"
-                                })?
-                        }
-                    },
-                );
-            }
-        }
-
-        if query.is_empty() {
-            return Ok(());
-        }
-
-        self.col::<Document>(COL)
-            .update_one(
-                doc! {
-                    "_id": id
-                },
-                query,
-                None,
-            )
-            .await
-            .map_err(|_| Error::DatabaseError {
-                operation: "update_one",
-                with: "message",
-            })
-            .map(|_| ())
-    }
-
-    async fn delete_message(&self, id: &str) -> Result<()> {
-        self.delete_one_by_id(COL, id).await.map(|_| ())
-    }
-
-    async fn delete_messages(&self, channel: &str, ids: Vec<String>) -> Result<()> {
-        self.delete_bulk_messages(doc! {
-            "channel": channel,
-            "_id": {
-                "$in": ids
-            }
-        })
-        .await
+    /// 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! {};
 
@@ -212,7 +96,8 @@ impl AbstractMessage for MongoDb {
                             })
                             .build(),
                     )
-                )?;
+                )
+                .map_err(|_| create_database_error!("find", COL))?;
 
                 Ok([a, b].concat())
             }
@@ -271,10 +156,66 @@ impl AbstractMessage for MongoDb {
                         .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)
@@ -291,10 +232,7 @@ impl AbstractMessage for MongoDb {
             )
             .await
             .map(|_| ())
-            .map_err(|_| Error::DatabaseError {
-                operation: "update_one",
-                with: "message",
-            })
+            .map_err(|_| create_database_error!("update_one", COL))
     }
 
     /// Remove a reaction from a message
@@ -313,10 +251,7 @@ impl AbstractMessage for MongoDb {
             )
             .await
             .map(|_| ())
-            .map_err(|_| Error::DatabaseError {
-                operation: "update_one",
-                with: "message",
-            })
+            .map_err(|_| create_database_error!("update_one", COL))
     }
 
     /// Remove reaction from a message
@@ -335,9 +270,82 @@ impl AbstractMessage for MongoDb {
             )
             .await
             .map(|_| ())
-            .map_err(|_| Error::DatabaseError {
-                operation: "update_one",
-                with: "message",
-            })
+            .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,8 +1,16 @@
 mod admin_migrations;
 mod bots;
+mod channel_invites;
+mod channel_unreads;
 mod channel_webhooks;
+mod channels;
+mod emojis;
 mod files;
-mod safety_strikes;
+mod messages;
+mod ratelimit_events;
+mod safety_reports;
+mod safety_snapshots;
+mod server_bans;
 mod server_members;
 mod servers;
 mod user_settings;
@@ -10,9 +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 safety_strikes::*;
+pub use messages::*;
+pub use ratelimit_events::*;
+pub use safety_reports::*;
+pub use safety_snapshots::*;
+pub use server_bans::*;
 pub use server_members::*;
 pub use servers::*;
 pub use user_settings::*;
@@ -25,13 +41,21 @@ pub trait AbstractDatabase:
     + Send
     + admin_migrations::AbstractMigrations
     + bots::AbstractBots
+    + channels::AbstractChannels
+    + channel_invites::AbstractChannelInvites
+    + channel_unreads::AbstractChannelUnreads
+    + channel_webhooks::AbstractWebhooks
+    + emojis::AbstractEmojis
     + files::AbstractAttachments
-    + safety_strikes::AbstractAccountStrikes
+    + messages::AbstractMessages
+    + ratelimit_events::AbstractRatelimitEvents
+    + safety_reports::AbstractReport
+    + safety_snapshots::AbstractSnapshot
+    + server_bans::AbstractServerBans
     + server_members::AbstractServerMembers
     + servers::AbstractServers
     + user_settings::AbstractUserSettings
     + users::AbstractUsers
-    + channel_webhooks::AbstractWebhooks
 {
 }
 

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

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

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

@@ -0,0 +1,47 @@
+use std::fmt;
+
+use revolt_result::Result;
+use ulid::Ulid;
+
+use crate::Database;
+
+auto_derived!(
+    /// Ratelimit Event
+    pub struct RatelimitEvent {
+        /// Id
+        #[serde(rename = "_id")]
+        pub id: String,
+        /// Relevant Object Id
+        pub target_id: String,
+        /// Type of event
+        pub event_type: RatelimitEventType,
+    }
+
+    /// Event type
+    pub enum RatelimitEventType {
+        DiscriminatorChange,
+    }
+);
+
+impl fmt::Display for RatelimitEventType {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        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.rs

@@ -0,0 +1,20 @@
+use std::time::Duration;
+
+use crate::{revolt_result::Result, RatelimitEvent, RatelimitEventType};
+mod mongodb;
+mod reference;
+
+#[async_trait]
+pub trait AbstractRatelimitEvents: Sync + Send {
+    /// Insert a new ratelimit event
+    async fn insert_ratelimit_event(&self, event: &RatelimitEvent) -> Result<()>;
+
+    /// 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,
+    ) -> Result<bool>;
+}

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

@@ -0,0 +1,40 @@
+use std::time::{Duration, SystemTime};
+
+use super::AbstractRatelimitEvents;
+use crate::{MongoDb, RatelimitEvent, RatelimitEventType};
+use revolt_result::Result;
+use ulid::Ulid;
+
+static COL: &str = "ratelimit_events";
+
+#[async_trait]
+impl AbstractRatelimitEvents for MongoDb {
+    /// Insert a new ratelimit event
+    async fn insert_ratelimit_event(&self, event: &RatelimitEvent) -> Result<()> {
+        query!(self, insert_one, COL, &event).map(|_| ())
+    }
+
+    /// 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,
+    ) -> Result<bool> {
+        self.col::<RatelimitEvent>(COL)
+            .count_documents(
+                doc! {
+                    "_id": {
+                        "$gte": Ulid::from_datetime(SystemTime::now() - period).to_string()
+                    },
+                    "target_id": target_id,
+                    "event_type": event_type.to_string()
+                },
+                None,
+            )
+            .await
+            .map(|c| c as usize >= count)
+            .map_err(|_| create_database_error!("count_documents", COL))
+    }
+}

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

@@ -0,0 +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<()> {
+        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,
+    ) -> Result<bool> {
+        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

@@ -1,13 +1,44 @@
-use crate::{
-    models::{
-        message::{MessageFilter, MessageQuery, MessageSort, MessageTimePeriod},
-        snapshot::SnapshotContent,
-        Message, Server, User,
-    },
-    Database, Result,
-};
+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,
@@ -54,13 +85,14 @@ impl SnapshotContent {
         Ok((
             SnapshotContent::Message {
                 message,
-                prior_context,
-                leading_context,
+                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]
@@ -71,6 +103,7 @@ impl SnapshotContent {
         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 = [

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

@@ -1,11 +1,12 @@
-use crate::models::Snapshot;
-use crate::Result;
+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<()>;
-
-    /// Fetch a snapshots by a report's id
-    async fn fetch_snapshots(&self, report_id: &str) -> Result<Vec<Snapshot>>;
 }

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(|strike| strike.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

@@ -1,18 +1,21 @@
-use crate::models::server_member::MemberCompositeKey;
-use crate::models::ServerBan;
-use crate::Result;
-
-#[async_trait]
-pub trait AbstractServerBan: Sync + Send {
-    /// Fetch a server ban by server and user id
-    async fn fetch_ban(&self, server: &str, user: &str) -> Result<ServerBan>;
-
-    /// Fetch all bans in a server
-    async fn fetch_bans(&self, server: &str) -> Result<Vec<ServerBan>>;
-
-    /// Insert new ban into database
-    async fn insert_ban(&self, ban: &ServerBan) -> Result<()>;
-
-    /// Delete a ban from the database
-    async fn delete_ban(&self, id: &MemberCompositeKey) -> Result<()>;
-}
+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));
+        });
+    }
+}