feat: initialise Discord bridge crate

2023-04-21 22:29:17 +01:00
501 changed files with 14371 additions and 35607 deletions
@@ -1,2 +0,0 @@
-[profile.default]
-slow-timeout = { period = "3s", terminate-after = 2 }
@@ -0,0 +1,79 @@
+# MongoDB URI
+MONGODB=mongodb://localhost
+
+# URL to where the Revolt app is publicly accessible
+REVOLT_APP_URL=http://local.revolt.chat:5000
+
+# URL to where the API is publicly accessible
+REVOLT_PUBLIC_URL=http://local.revolt.chat:8000
+VITE_API_URL=http://local.revolt.chat:8000
+
+# URL to where the WebSocket server is publicly accessible
+REVOLT_EXTERNAL_WS_URL=ws://local.revolt.chat:9000
+
+# URL to where Autumn is publicly available
+AUTUMN_PUBLIC_URL=http://local.revolt.chat:3000
+
+# URL to where January is publicly available
+JANUARY_PUBLIC_URL=http://local.revolt.chat:7000
+
+# URL to where Vortex is publicly available
+# VOSO_PUBLIC_URL=https://voso.revolt.chat
+
+
+##
+## hCaptcha Settings
+##
+
+# If you are sure that you don't want to use hCaptcha, set to 1.
+REVOLT_UNSAFE_NO_CAPTCHA=1
+
+# hCaptcha API key
+# REVOLT_HCAPTCHA_KEY=0x0000000000000000000000000000000000000000
+
+# hCaptcha site key
+# REVOLT_HCAPTCHA_SITEKEY=10000000-ffff-ffff-ffff-000000000001
+
+
+##
+## Email Settings
+##
+
+# If you are sure that you don't want to use email verification, set to 1.
+REVOLT_UNSAFE_NO_EMAIL=1
+
+# SMTP host
+# REVOLT_SMTP_HOST=smtp.example.com
+
+# SMTP username
+# REVOLT_SMTP_USERNAME=noreply@example.com
+
+# SMTP password
+# REVOLT_SMTP_PASSWORD=CHANGEME
+
+# SMTP From header
+# REVOLT_SMTP_FROM=Revolt <noreply@example.com>
+
+
+##
+## Application Settings
+##
+
+# Whether to only allow users to sign up if they have an invite code
+REVOLT_INVITE_ONLY=0
+
+# Maximum number of people that can be in a group chat
+REVOLT_MAX_GROUP_SIZE=150
+
+# VAPID keys for push notifications
+# Generate using this guide: https://gitlab.insrt.uk/revolt/delta/-/wikis/vapid
+# --> Please replace these keys before going into production! <--
+REVOLT_VAPID_PRIVATE_KEY=LS0tLS1CRUdJTiBFQyBQUklWQVRFIEtFWS0tLS0tCk1IY0NBUUVFSUJSUWpyTWxLRnBiVWhsUHpUbERvcEliYk1yeVNrNXpKYzVYVzIxSjJDS3hvQW9HQ0NxR1NNNDkKQXdFSG9VUURRZ0FFWnkrQkg2TGJQZ2hEa3pEempXOG0rUXVPM3pCajRXT1phdkR6ZU00c0pqbmFwd1psTFE0WAp1ZDh2TzVodU94QWhMQlU3WWRldVovWHlBdFpWZmNyQi9BPT0KLS0tLS1FTkQgRUMgUFJJVkFURSBLRVktLS0tLQo=
+REVOLT_VAPID_PUBLIC_KEY=BGcvgR-i2z4IQ5Mw841vJvkLjt8wY-FjmWrw83jOLCY52qcGZS0OF7nfLzuYbjsQISwVO2HXrmf18gLWVX3Kwfw=
+
+
+##
+## Vortex configuration
+##
+
+# VOSO_MANAGE_TOKEN=CHANGEME
@@ -1,37 +0,0 @@
-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
@@ -0,0 +1,36 @@
+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
@@ -2,21 +2,20 @@ name: Docker Test & Publish

 on:
  push:
-    # branches:
-    #   - "main"
+    branches:
+      - "master"
    tags:
      - "*"
    paths-ignore:
      - ".github/**"
      - "!.github/workflows/docker.yml"
      - ".vscode/**"
-      - "doc/**"
      - ".gitignore"
      - "LICENSE"
      - "README"
  pull_request:
    branches:
-      - "main"
+      - "master"
    paths:
      - "Dockerfile"
  workflow_dispatch:
@@ -61,7 +60,7 @@ jobs:
    if: github.event_name != 'pull_request'
    strategy:
      matrix:
-        project: [delta, bonfire, autumn, january, pushd]
+        project: [delta, bonfire]
    name: Build ${{ matrix.project }} image
    steps:
      # Configure build environment
@@ -98,22 +97,6 @@ jobs:
              "bonfire": {
                "path": "crates/bonfire",
                "tag": "${{ github.repository_owner }}/bonfire"
-              },
-              "autumn": {
-                "path": "crates/services/autumn",
-                "tag": "${{ github.repository_owner }}/autumn"
-              },
-              "january": {
-                "path": "crates/services/january",
-                "tag": "${{ github.repository_owner }}/january"
-              },
-              "pushd": {
-                "path": "crates/daemons/pushd",
-                "tag": "${{ github.repository_owner }}/pushd"
-              },
-              "crond": {
-                "path": "crates/daemons/crond",
-                "tag": "${{ github.repository_owner }}/crond"
              }
            }
          export_to: output
@@ -2,16 +2,9 @@ name: Rust build, test, and generate specification

 on:
  push:
-    paths-ignore:
-      - ".github/**"
-      - "!.github/workflows/rust.yaml"
-      - ".vscode/**"
-      - "doc/**"
-      - ".gitignore"
-      - "LICENSE"
-      - "README"
+    branches: [master]
  pull_request:
-    branches: [main]
+    branches: [master]

 env:
  CARGO_TERM_COLOR: always
@@ -28,49 +21,40 @@ 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
        with:
          command: build

-      - name: Run services in background
-        run: |
-          docker compose -f compose.yml up -d
-
      - name: Run cargo test
-        env:
-          TEST_DB: REFERENCE
-        run: |
-          cargo nextest run
+        uses: actions-rs/cargo@v1
+        with:
+          command: test

-      - name: Run cargo test (with MongoDB)
-        env:
-          TEST_DB: MONGODB
-          MONGODB: mongodb://localhost
+      - name: Copy .env.example
+        if: github.event_name != 'pull_request'
        run: |
-          cargo nextest run
+          cp .env.example .env
+
+      - name: Run services in background
+        if: github.event_name != 'pull_request'
+        run: |
+          docker-compose -f docker-compose.db.yml up -d

      - name: Start API in background
-        if: github.event_name != 'pull_request' && github.ref_name == 'main'
-        env:
-          TEST_DB: REFERENCE
+        if: github.event_name != 'pull_request'
        run: |
-          cargo build --bin revolt-delta && (cargo run --bin revolt-delta &)
+          cargo run --bin revolt-delta &

      - name: Wait for API to go up
-        if: github.event_name != 'pull_request' && github.ref_name == 'main'
+        if: github.event_name != 'pull_request'
        uses: nev7n/wait_for_response@v1
        with:
-          url: "http://localhost:14702/"
+          url: "http://localhost:8000/"

      - name: Checkout API repository
-        if: github.event_name != 'pull_request' && github.ref_name == 'main'
+        if: github.event_name != 'pull_request'
        uses: actions/checkout@v3
        with:
          repository: revoltchat/api
@@ -78,11 +62,11 @@ jobs:
          token: ${{ secrets.PAT }}

      - name: Download OpenAPI specification
-        if: github.event_name != 'pull_request' && github.ref_name == 'main'
-        run: curl http://localhost:14702/openapi.json -o api/OpenAPI.json
+        if: github.event_name != 'pull_request'
+        run: curl http://localhost:8000/openapi.json -o api/OpenAPI.json

      - name: Commit changes
-        if: github.event_name != 'pull_request' && github.ref_name == 'main'
+        if: github.event_name != 'pull_request'
        uses: EndBug/add-and-commit@v4
        with:
          cwd: "api"
@@ -15,7 +15,7 @@ jobs:
          gh api graphql -f query='
            query {
              organization(login: "revoltchat"){
-                projectV2(number: 5) {
+                projectV2(number: 3) {
                  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=="🆕 Untriaged") |.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

      - name: Add PR to project
        env:
@@ -1,12 +1,6 @@
 Rocket.toml
-Revolt.*.toml
-compose.override.yml
-
 target
 .data
 .env

 .vercel
-.DS_Store
-
-.idea
@@ -1,6 +1,4 @@
 {
-  "editor.formatOnSave": true,
-  "rust-analyzer.checkOnSave.command": "clippy",
-  "nixEnvSelector.suggestion": false,
-  "nixEnvSelector.nixFile": "${workspaceFolder}/default.nix"
+    "editor.formatOnSave": true,
+    "rust-analyzer.checkOnSave.command": "clippy"
 }
@@ -1,24 +1,7 @@
 [workspace]
-resolver = "2"
-
-members = [
-    "crates/delta",
-    "crates/bonfire",
-    "crates/core/*",
-    "crates/services/*",
-    "crates/bindings/*",
-    "crates/daemons/*",
-]
+members = ["crates/*", "crates/bridges/*"]
+exclude = ["crates/bridges"]

 [patch.crates-io]
-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" }
-
-# I'm 99% sure this is overloading the GitHub worker
-# hence builds have been failing since, let's just
-# disable it for now. In the future, we could use this
-# if we were rolling our own CI.
-# [profile.release]
-# lto = true
+# mobc-redis = { git = "https://github.com/insertish/mobc", rev = "8b880bb59f2ba80b4c7bc40c649c113d8857a186" }
+redis = { git = "https://github.com/insertish/redis-rs", rev = "6575a6b1c09eb8c9cc7f0082d95fe6b8f903c4d7" }
@@ -1,5 +1,5 @@
 # Build Stage
-FROM --platform="${BUILDPLATFORM}" rust:1.77.2-slim-bookworm
+FROM --platform="${BUILDPLATFORM}" rustlang/rust:nightly-slim
 USER 0:0
 WORKDIR /home/rust/src

@@ -17,20 +17,9 @@ RUN sh /tmp/build-image-layer.sh tools

 # Build all dependencies
 COPY Cargo.toml Cargo.lock ./
-COPY crates/bindings/node/Cargo.toml ./crates/bindings/node/
 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/files/Cargo.toml ./crates/core/files/
-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/
-COPY crates/services/autumn/Cargo.toml ./crates/services/autumn/
-COPY crates/services/january/Cargo.toml ./crates/services/january/
-COPY crates/daemons/crond/Cargo.toml ./crates/daemons/crond/
-COPY crates/daemons/pushd/Cargo.toml ./crates/daemons/pushd/
+COPY crates/quark/Cargo.toml ./crates/quark/
 RUN sh /tmp/build-image-layer.sh deps

 # Build all apps
@@ -1,34 +0,0 @@
-# Build Stage
-FROM rust:1.77.2-slim-bookworm
-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/bindings/node/Cargo.toml ./crates/bindings/node/
-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/files/Cargo.toml ./crates/core/files/
-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/
-COPY crates/services/autumn/Cargo.toml ./crates/services/autumn/
-COPY crates/services/january/Cargo.toml ./crates/services/january/
-COPY crates/daemons/crond/Cargo.toml ./crates/daemons/crond/
-COPY crates/daemons/pushd/Cargo.toml ./crates/daemons/pushd/
-RUN sh /tmp/build-image-layer.sh deps
-
-# Build all apps
-COPY crates ./crates
-RUN sh /tmp/build-image-layer.sh apps
@@ -1,7 +1,4 @@
-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
+                    GNU AFFERO GENERAL PUBLIC LICENSE
                       Version 3, 19 November 2007

 Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
@@ -1,220 +1,31 @@
-<div align="center">
-<h1>
-  Revolt Backend
-  
-  [![Stars](https://img.shields.io/github/stars/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/stargazers)
-  [![Forks](https://img.shields.io/github/forks/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/network/members)
-  [![Pull Requests](https://img.shields.io/github/issues-pr/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/pulls)
-  [![Issues](https://img.shields.io/github/issues/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/issues)
-  [![Contributors](https://img.shields.io/github/contributors/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/graphs/contributors)
-  [![License](https://img.shields.io/github/license/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/blob/main/LICENSE)
-</h1>
-The services and libraries that power the Revolt service.<br/>
-<br/>
+# Revolt Backend

-| Crate              | Path                                               | Description                              |                                                                                                                                                                                                                                                                                                           |
-| ------------------ | -------------------------------------------------- | ---------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `core/config`      | [crates/core/config](crates/core/config)           | Core: Configuration                      | ![Crates.io Version](https://img.shields.io/crates/v/revolt-config) ![Crates.io Version](https://img.shields.io/crates/msrv/revolt-config) ![Crates.io Version](https://img.shields.io/crates/size/revolt-config) ![Crates.io License](https://img.shields.io/crates/l/revolt-config)                     |
-| `core/database`    | [crates/core/database](crates/core/database)       | Core: Database Implementation            | ![Crates.io Version](https://img.shields.io/crates/v/revolt-database) ![Crates.io Version](https://img.shields.io/crates/msrv/revolt-database) ![Crates.io Version](https://img.shields.io/crates/size/revolt-database) ![Crates.io License](https://img.shields.io/crates/l/revolt-database)             |
-| `core/files`       | [crates/core/files](crates/core/files)             | Core: S3 and encryption subroutines      | ![Crates.io Version](https://img.shields.io/crates/v/revolt-files) ![Crates.io Version](https://img.shields.io/crates/msrv/revolt-files) ![Crates.io Version](https://img.shields.io/crates/size/revolt-files) ![Crates.io License](https://img.shields.io/crates/l/revolt-files)                         |
-| `core/models`      | [crates/core/models](crates/core/models)           | Core: API Models                         | ![Crates.io Version](https://img.shields.io/crates/v/revolt-models) ![Crates.io Version](https://img.shields.io/crates/msrv/revolt-models) ![Crates.io Version](https://img.shields.io/crates/size/revolt-models) ![Crates.io License](https://img.shields.io/crates/l/revolt-models)                     |
-| `core/permissions` | [crates/core/permissions](crates/core/permissions) | Core: Permission Logic                   | ![Crates.io Version](https://img.shields.io/crates/v/revolt-permissions) ![Crates.io Version](https://img.shields.io/crates/msrv/revolt-permissions) ![Crates.io Version](https://img.shields.io/crates/size/revolt-permissions) ![Crates.io License](https://img.shields.io/crates/l/revolt-permissions) |
-| `core/presence`    | [crates/core/presence](crates/core/presence)       | Core: User Presence                      | ![Crates.io Version](https://img.shields.io/crates/v/revolt-presence) ![Crates.io Version](https://img.shields.io/crates/msrv/revolt-presence) ![Crates.io Version](https://img.shields.io/crates/size/revolt-presence) ![Crates.io License](https://img.shields.io/crates/l/revolt-presence)             |
-| `core/result`      | [crates/core/result](crates/core/result)           | Core: Result and Error types             | ![Crates.io Version](https://img.shields.io/crates/v/revolt-result) ![Crates.io Version](https://img.shields.io/crates/msrv/revolt-result) ![Crates.io Version](https://img.shields.io/crates/size/revolt-result) ![Crates.io License](https://img.shields.io/crates/l/revolt-result)                     |
-| `delta`            | [crates/delta](crates/delta)                       | REST API server                          | ![License](https://img.shields.io/badge/license-AGPL--3.0--or--later-blue)                                                                                                                                                                                                                                |
-| `bonfire`          | [crates/bonfire](crates/bonfire)                   | WebSocket events server                  | ![License](https://img.shields.io/badge/license-AGPL--3.0--or--later-blue)                                                                                                                                                                                                                                |
-| `services/january` | [crates/services/january](crates/services/january) | Proxy server                             | ![License](https://img.shields.io/badge/license-AGPL--3.0--or--later-blue)                                                                                                                                                                                                                                |
-| `services/autumn`  | [crates/services/autumn](crates/services/autumn)   | File server                              | ![License](https://img.shields.io/badge/license-AGPL--3.0--or--later-blue)                                                                                                                                                                                                                                |
-| `bindings/node`    | [crates/bindings/node](crates/bindings/node)       | Node.js bindings for the Revolt software | ![License](https://img.shields.io/badge/license-AGPL--3.0--or--later-blue)                                                                                                                                                                                                                                |
-| `daemons/crond`    | [crates/daemons/crond](crates/daemons/crond)       | Timed data clean up daemon server        | ![License](https://img.shields.io/badge/license-AGPL--3.0--or--later-blue)                                                                                                                                                                                                                                |
-| `daemons/pushd`    | [crates/daemons/pushd](crates/daemons/pushd)       | Push notification daemon server          | ![License](https://img.shields.io/badge/license-AGPL--3.0--or--later-blue)                                                                                                                                                                                                                                |
+This is a monorepo for the Revolt backend.

-</div>
-<br/>
+| 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 |-->

-## Minimum Supported Rust Version
+Note: `january`, `autumn`, and `vortex` are yet to be moved into this monorepo.

-Rust 1.76 or higher.
+## Resources

-> [!CAUTION]
-> The events server has a significant performance regression between Rust 1.77.2 and 1.78.0 onwards, see [issue #341](https://github.com/revoltchat/backend/issues/341).
+### Revolt

-## Development Guide
+- [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)

-Before contributing, make yourself familiar with [our contribution guidelines](https://developers.revolt.chat/contrib.html) and the [technical documentation for this project](https://revoltchat.github.io/backend/).
+## Contributing

-Before getting started, you'll want to install:
-
- Rust toolchain (rustup recommended)
- Docker
- Git
- mold (optional, faster compilation)
-
-> A **default.nix** is available for Nix users!
-> Just run `nix-shell` and continue.
-
-As a heads-up, the development environment uses the following ports:
-
-| Service                   |      Port      |
-| ------------------------- | :------------: |
-| MongoDB                   |     27017      |
-| Redis                     |      6379      |
-| MinIO                     |     14009      |
-| Maildev                   | 14025<br>14080 |
-| Revolt Web App            |     14701      |
-| RabbitMQ                  | 5672<br>15672  |
-| `crates/delta`            |     14702      |
-| `crates/bonfire`          |     14703      |
-| `crates/services/autumn`  |     14704      |
-| `crates/services/january` |     14705      |
-
-Now you can clone and build the project:
-
-```bash
-git clone https://github.com/revoltchat/backend revolt-backend
-cd revolt-backend
-cargo build
-```
-
-A default configuration `Revolt.toml` is present in this project that is suited for development.
-
-If you'd like to change anything, create a `Revolt.overrides.toml` file and specify relevant variables.
-
-> [!TIP]
-> Use Sentry to catch unexpected service errors:
->
-> ```toml
-> # Revolt.overrides.toml
-> [sentry]
-> api = "https://abc@your.sentry/1"
-> events = "https://abc@your.sentry/1"
-> files = "https://abc@your.sentry/1"
-> proxy = "https://abc@your.sentry/1"
-> ```
-
-> [!TIP]
-> If you have port conflicts on common services, you can try the following:
->
-> ```yaml
-> # compose.override.yml
-> services:
->   redis:
->     ports: !override
->       - "14079:6379"
->
->   database:
->     ports: !override
->       - "14017:27017"
->
->   rabbit:
->     ports: !override
->       - "14072:5672"
->       - "14672:15672"
-> ```
->
-> And corresponding Revolt configuration:
->
-> ```toml
-> # Revolt.overrides.toml
-> [database]
-> mongodb = "mongodb://127.0.0.1:14017"
-> redis = "redis://127.0.0.1:14079/"
->
-> [rabbit]
-> port = 14072
-> ```
-
-Then continue:
-
-```bash
-# start other necessary services
-docker compose up -d
-
-# run everything together
-./scripts/start.sh
-# .. or individually
-# run the API server
-cargo run --bin revolt-delta
-# run the events server
-cargo run --bin revolt-bonfire
-# run the file server
-cargo run --bin revolt-autumn
-# run the proxy server
-cargo run --bin revolt-january
-# run the push daemon (not usually needed in regular development)
-cargo run --bin revolt-pushd
-
-# hint:
-# mold -run <cargo build, cargo run, etc...>
-# mold -run ./scripts/start.sh
-```
-
-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
-echo "VITE_API_URL=http://local.revolt.chat:14702" > .env.local
-yarn dev --port 14701
-```
-
-Then go to http://local.revolt.chat:14701 to create an account/login.
-
-When signing up, go to http://localhost:14080 to find confirmation/password reset emails.
-
-## 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
-```
-
-If you have bumped the crate versions, proceed to [GitHub releases](https://github.com/revoltchat/backend/releases/new) to create a changelog.
-
-## Testing
-
-First, start the required services:
-
-```sh
-docker compose -f docker-compose.db.yml up -d
-```
-
-Now run tests for whichever database:
-
-```sh
-TEST_DB=REFERENCE cargo nextest run
-TEST_DB=MONGODB cargo nextest run
-```
+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.

 ## License

-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!**
+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.
@@ -1,52 +0,0 @@
-# ⚠️ This configuration is intended for development environment.
-# If you'd like to override anything, create a Revolt.override.toml
-
-[database]
-# MongoDB connection URL
-# Defaults to the container name specified in self-hosted
-mongodb = "mongodb://127.0.0.1:27017"
-# Redis connection URL
-# Defaults to the container name specified in self-hosted
-redis = "redis://127.0.0.1:6379/"
-
-[rabbit]
-host = "127.0.0.1"
-
-[hosts]
-# Web locations of various services
-# Defaults assume all services are reverse-proxied
-# See https://github.com/revoltchat/self-hosted/blob/master/Caddyfile
-#
-# Remember to change these to https/wss where appropriate in production!
-app = "http://local.revolt.chat:14701"
-api = "http://local.revolt.chat:14702"
-events = "ws://local.revolt.chat:14703"
-autumn = "http://local.revolt.chat:14704"
-january = "http://local.revolt.chat:14705"
-voso_legacy = ""
-voso_legacy_ws = ""
-
-[api]
-
-[api.smtp]
-# Email server configuration for verification
-# Defaults to no email verification (host field is empty)
-host = "localhost"
-username = "smtp"
-password = "smtp"
-from_address = "development@revolt.chat"
-reply_to = "support@revolt.chat"
-port = 14025
-use_tls = false
-
-[files.s3]
-# S3 protocol endpoint
-endpoint = "http://127.0.0.1:14009"
-# S3 region name
-region = "minio"
-# S3 protocol key ID
-access_key_id = "minioautumn"
-# S3 protocol access key
-secret_access_key = "minioautumn"
-# Bucket to upload to by default
-default_bucket = "revolt-uploads"
@@ -1,73 +0,0 @@
-# Code Style Guide
-
-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
-
- All struct definitions must be commented.
-  ```rust
-  /// Server
-  pub struct Server {
-    /// Name of the server
-    pub name: String,
-  ```
- Struct definitions should not include derives unless necessary (if additional traits such as Hash are required) and instead use `auto_derived!` and `auto_derived_partial!`.
-  ```rust
-  auto_derived_partial!(
-    /// Server
-    pub struct Server { .. },
-    "PartialServer"
-  );
-  ```
- `auto_derived!` macro accepts multiple entries and should be used as such:
-
-  ```rust
-  auto_derived!(
-    /// Optional fields on server object
-    pub enum FieldsServer { .. }
-
-    /// Optional fields on server object
-    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)]
-  ```
- `impl` blocks may be defined below the struct definitions and should be ordered in the same order of definition. Methods in the block must follow the same guidelines as traits where-in: methods are ordered in terms of CRUD, there are empty line breaks, and methods are commented.
-
-w.r.t. `ops` module for models
-
- All traits must use a the name format `AbstractPlural` where Plural is the plural form of the collection. e.g. Servers
- Traits defined must follow these guidelines:
-
-  - Methods are ordered in terms of CRUD, create-read-update-delete ordering.
-
-    ```rust
-    #[async_trait]
-    pub trait AbstractServerMembers: Sync + Send {
-      /// Insert a new server member into the database
-      async fn insert_member(&self, member: &Member) -> Result<()>;
-
-      /// Fetch a server member by their id
-      async fn fetch_member(&self, server_id: &str, user_id: &str) -> Result<Member>;
-
-      /// Update information for a server member
-      async fn update_member(&self, .. ) -> Result<()>;
-
-      /// Delete a server member by their id
-      async fn delete_member(&self, id: &MemberCompositeKey) -> Result<()>;
-    }
-    ```
-
-  - There should be an empty line break between each method declaration.
-  - All methods must have an appropriate comment.
-
- When implementing the trait defined in `ops.rs` with each driver, the method declaration style should be the same for ease of searching: same ordering, same comments, same line breaks.
@@ -1,28 +0,0 @@
-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::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",
-
-    # Prefer to use Object::delete(&self)
-    "revolt_database::models::bots::ops::AbstractBots::delete_bot",
-]
@@ -1,66 +0,0 @@
-services:
-  # Redis
-  redis:
-    image: eqalpha/keydb
-    ports:
-      - "6379:6379"
-
-  # MongoDB
-  database:
-    image: mongo
-    ports:
-      - "27017:27017"
-    volumes:
-      - ./.data/db:/data/db
-
-  # MinIO
-  minio:
-    image: minio/minio
-    command: server /data
-    environment:
-      MINIO_ROOT_USER: minioautumn
-      MINIO_ROOT_PASSWORD: minioautumn
-    volumes:
-      - ./.data/minio:/data
-    ports:
-      - "14009:9000"
-      - "14010:9001"
-    restart: always
-
-  # Create buckets for minio.
-  createbuckets:
-    image: minio/mc
-    depends_on:
-      - minio
-    entrypoint: >
-      /bin/sh -c "while ! /usr/bin/mc ready minio; do
-        /usr/bin/mc config host add minio http://minio:9000 minioautumn minioautumn;
-        echo 'Waiting minio...' && sleep 1;
-      done; /usr/bin/mc mb minio/revolt-uploads; exit 0;"
-
-  # Rabbit
-  rabbit:
-    image: rabbitmq:3-management
-    environment:
-      RABBITMQ_DEFAULT_USER: rabbituser
-      RABBITMQ_DEFAULT_PASS: rabbitpass
-    volumes:
-      - ./.data/rabbit:/var/lib/rabbitmq
-      #- ./rabbit_plugins:/opt/rabbitmq/plugins/
-      #- ./rabbit_enabled_plugins:/etc/rabbitmq/enabled_plugins
-      # uncomment this if you need to enable other plugins
-    ports:
-      - "5672:5672"
-      - "15672:15672" # management UI, for development
-
-  # Mock SMTP server
-  maildev:
-    image: soulteary/maildev
-    ports:
-      - "14025:25"
-      - "14080:8080"
-    environment:
-      MAILDEV_SMTP_PORT: 25
-      MAILDEV_WEB_PORT: 8080
-      MAILDEV_INCOMING_USER: smtp
-      MAILDEV_INCOMING_PASS: smtp
@@ -1,7 +0,0 @@
-target
-index.node
-**/node_modules
-**/.DS_Store
-npm-debug.log*
-cargo.log
-cross.log
@@ -1,25 +0,0 @@
-[package]
-name = "revolt-nodejs-bindings"
-version = "0.8.3"
-description = "Node.js bindings for the Revolt software"
-authors = ["Paul Makles <me@insrt.uk>"]
-license = "MIT"
-edition = "2021"
-exclude = ["index.node"]
-
-[lib]
-crate-type = ["cdylib"]
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-neon = "1.0.0"
-neon-serde4 = "1.0.0"
-
-serde = { version = "1", features = ["derive"] }
-
-async-std = "1.12.0"
-
-revolt-config = { version = "0.8.3", path = "../../core/config" }
-revolt-result = { version = "0.8.3", path = "../../core/result" }
-revolt-database = { version = "0.8.3", path = "../../core/database" }
@@ -1,92 +0,0 @@
-# revolt.node
-
-**revolt.node:** Node.js bindings for the Revolt software
-
-This project was bootstrapped by [create-neon](https://www.npmjs.com/package/create-neon).
-
-## Building revolt.node
-
-Building revolt.node requires a [supported version of Node and Rust](https://github.com/neon-bindings/neon#platform-support).
-
-To run the build, run:
-
-```sh
-$ npm run build
-```
-
-This command uses the [@neon-rs/cli](https://www.npmjs.com/package/@neon-rs/cli) utility to assemble the binary Node addon from the output of `cargo`.
-
-## Exploring revolt.node
-
-After building revolt.node, you can explore its exports at the Node console:
-
-```sh
-$ npm i
-$ npm run build
-$ node
-> require('.').hello()
-'hello node'
-```
-
-## Available Scripts
-
-In the project directory, you can run:
-
-#### `npm install`
-
-Installs the project, including running `npm run build`.
-
-#### `npm run build`
-
-Builds the Node addon (`index.node`) from source, generating a release build with `cargo --release`.
-
-Additional [`cargo build`](https://doc.rust-lang.org/cargo/commands/cargo-build.html) arguments may be passed to `npm run build` and similar commands. For example, to enable a [cargo feature](https://doc.rust-lang.org/cargo/reference/features.html):
-
-```
-npm run build -- --feature=beetle
-```
-
-#### `npm run debug`
-
-Similar to `npm run build` but generates a debug build with `cargo`.
-
-#### `npm run cross`
-
-Similar to `npm run build` but uses [cross-rs](https://github.com/cross-rs/cross) to cross-compile for another platform. Use the [`CARGO_BUILD_TARGET`](https://doc.rust-lang.org/cargo/reference/config.html#buildtarget) environment variable to select the build target.
-
-#### `npm test`
-
-Runs the unit tests by calling `cargo test`. You can learn more about [adding tests to your Rust code](https://doc.rust-lang.org/book/ch11-01-writing-tests.html) from the [Rust book](https://doc.rust-lang.org/book/).
-
-## Project Layout
-
-The directory structure of this project is:
-
-```
-revolt.node/
-├── Cargo.toml
-├── README.md
-├── src/
-|   └── lib.rs
-├── index.node
-├── package.json
-└── target/
-```
-
-| Entry          | Purpose                                                                                                                                  |
-|----------------|------------------------------------------------------------------------------------------------------------------------------------------|
-| `Cargo.toml`   | The Cargo [manifest file](https://doc.rust-lang.org/cargo/reference/manifest.html), which informs the `cargo` command.                   |
-| `README.md`    | This file.                                                                                                                               |
-| `src/`         | The directory tree containing the Rust source code for the project.                                                                      |
-| `lib.rs`       | Entry point for the Rust source code.                                                                                                          |
-| `index.node`   | The main module, a [Node addon](https://nodejs.org/api/addons.html) generated by the build and pointed to by `"main"` in `package.json`. |
-| `package.json` | The npm [manifest file](https://docs.npmjs.com/cli/v7/configuring-npm/package-json), which informs the `npm` command.                    |
-| `target/`      | Binary artifacts generated by the Rust build.                                                                                            |
-
-## Learn More
-
-Learn more about:
-
- [Neon](https://neon-bindings.com).
- [Rust](https://www.rust-lang.org).
- [Node](https://nodejs.org).
@@ -1,84 +0,0 @@
-import { Channel, User } from "revolt-api";
-
-/**
- * Opaque type for Revolt database
- */
-export declare interface Database {}
-
-/**
- * Opaque type for Revolt database
- */
-export declare interface OpaqueUser {}
-
-/**
- * Error type from Revolt backend
- */
-export declare interface Err {
-  type: string;
-  location: string;
-}
-
-/**
- * Initialises background tasks and logging, must be called before anything else!
- * Can be called multiple times!
- */
-export declare function init();
-
-/**
- * Gets a new handle to the Revolt database
- * @returns {Database} Handle
- */
-export declare function database(): Database;
-
-/**
- * Fetch user from database
- * @param {string} userId User's ID
- * @this {Database}
- */
-export declare function database_fetch_user(userId: string): OpaqueUser;
-
-/**
- * Fetch user from database
- * @param {string} username Username
- * @param {string} discriminator Discriminator
- * @this {Database}
- */
-export declare function database_fetch_user_by_username(
-  username: string,
-  discriminator: string
-): OpaqueUser;
-
-/**
- * Gets model data as JSON
- * @this {OpaqueUser}
- */
-export declare function model_data(): User;
-
-/**
- * Gets error if the model failed to fetch
- * @this {OpaqueUser}
- */
-export declare function model_error(): Err;
-
-/**
- * Open a direct message channel between two users
- * @param {string} userA User A ID
- * @param {string} userB User B ID
- * @returns Existing or newly created channel
- */
-export declare function proc_channels_create_dm(
-  userA: string,
-  userB: string
-): Promise<Channel & { error: Err }>;
-
-/**
- * Suspend a user
- * @param {string} user User
- * @param {number} duration Duration (in days), set to 0 for indefinite
- * @param {string} reason Pipe-separated list of reasons (e.g. reason1|reason2|reason3)
- */
-export declare function proc_users_suspend(
-  user: OpaqueUser,
-  duration: number,
-  reason: string
-): Promise<{ error: Err }>;
@@ -1,36 +0,0 @@
-{
-  "name": "revolt-nodejs-bindings",
-  "version": "0.7.15-rev0.0.3",
-  "description": "Node.js bindings for the Revolt software",
-  "main": "index.node",
-  "scripts": {
-    "test": "cargo test",
-    "cargo-build": "cargo build --message-format=json > cargo.log",
-    "cross-build": "cross build --message-format=json > cross.log",
-    "postcargo-build": "neon dist < cargo.log",
-    "postcross-build": "neon dist -m /target < cross.log",
-    "debug": "npm run cargo-build --",
-    "build": "npm run cargo-build -- --release",
-    "cross": "npm run cross-build -- --release"
-  },
-  "author": "Paul Makles",
-  "license": "AGPL-3.0",
-  "devDependencies": {
-    "@neon-rs/cli": "0.1.73"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/revoltchat/backend"
-  },
-  "keywords": [
-    "revolt",
-    "chat"
-  ],
-  "bugs": {
-    "url": "https://github.com/revoltchat/backend/issues"
-  },
-  "homepage": "https://github.com/revoltchat/backend#readme",
-  "dependencies": {
-    "revolt-api": "^0.7.15"
-  }
-}
@@ -1,117 +0,0 @@
-lockfileVersion: '6.0'
-
-settings:
-  autoInstallPeers: true
-  excludeLinksFromLockfile: false
-
-dependencies:
-  revolt-api:
-    specifier: ^0.7.15
-    version: 0.7.15
-
-devDependencies:
-  '@neon-rs/cli':
-    specifier: 0.1.73
-    version: 0.1.73
-
-packages:
-
-  /@cargo-messages/android-arm-eabi@0.1.72:
-    resolution: {integrity: sha512-gGZxIM1mj+Y5x+ULND6ZCNr7f70OJi9wDlycSK8hGONy9wrChN6JAIHryddC5cqcwlYAoQ6IDcDFElnhAYbybA==}
-    cpu: [arm]
-    os: [android]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@cargo-messages/darwin-arm64@0.1.72:
-    resolution: {integrity: sha512-EAzN5MLaXPljZKZDO5qR+aBs44eSq2ZbEnS7AI/FziE3MzeXbrGOS3fLba5+7yWPFXJyZolXzePm8N1EBv8ovg==}
-    cpu: [arm64]
-    os: [darwin]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@cargo-messages/darwin-x64@0.1.72:
-    resolution: {integrity: sha512-RLo6j8s3nYbjdd1LDct4wamfChyRit7zokUuxtIYCu9XOlltkN5vnj1vwnrPvoqCMZ/7CbbuHFwSTn9A71de/w==}
-    cpu: [x64]
-    os: [darwin]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@cargo-messages/linux-arm-gnueabihf@0.1.72:
-    resolution: {integrity: sha512-tHsRshuzfjrX6SDW3jg6al8vMNLTMgczGnVYl5RuBZf/yrAUuwe30KxA9ge6w6mW6Ox797DyBchzAc9OLgTgmQ==}
-    cpu: [arm]
-    os: [linux]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@cargo-messages/linux-x64-gnu@0.1.72:
-    resolution: {integrity: sha512-VGtL6CCnUbhsP4aYuBNT5kfrAL7o0qjrxw97a+ax13t+nJd26tVEEIKHMu5drvvS/Nm/hn7sLT8zMnnCv0pvHg==}
-    cpu: [x64]
-    os: [linux]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@cargo-messages/win32-arm64-msvc@0.1.72:
-    resolution: {integrity: sha512-V93Cgz39K+yqa3MveNbhh29pYCp8izK5uEavjPoxlNxAbsMCWH+s0verGDdUcfGxjR1H2V7oZ4FszPqR2SqMRQ==}
-    cpu: [arm64]
-    os: [win32]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@cargo-messages/win32-x64-msvc@0.1.72:
-    resolution: {integrity: sha512-knz3uSrO0OSbq3U5VWfCY8FB4NsM43BOWLZ7x4sfaMOC1XWv+IyvDdkLe6DhJx8KUw46KIAimYs9YROrp6l46Q==}
-    cpu: [x64]
-    os: [win32]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@neon-rs/cli@0.1.73:
-    resolution: {integrity: sha512-1kv8S/feB6UQWQQwsnGfkSkEBOtlFDNExnioL81E2BwvUWgjQPaseHgpi2EpWVgsPUgur5eBm4QowmlpWkD4/w==}
-    hasBin: true
-    optionalDependencies:
-      '@cargo-messages/android-arm-eabi': 0.1.72
-      '@cargo-messages/darwin-arm64': 0.1.72
-      '@cargo-messages/darwin-x64': 0.1.72
-      '@cargo-messages/linux-arm-gnueabihf': 0.1.72
-      '@cargo-messages/linux-x64-gnu': 0.1.72
-      '@cargo-messages/win32-arm64-msvc': 0.1.72
-      '@cargo-messages/win32-x64-msvc': 0.1.72
-    dev: true
-
-  /axios@0.26.1:
-    resolution: {integrity: sha512-fPwcX4EvnSHuInCMItEhAGnaSEXRBjtzh9fOtsE6E1G6p7vl7edEeZe11QHf18+6+9gR5PbKV/sGKNaD8YaMeA==}
-    dependencies:
-      follow-redirects: 1.15.6
-    transitivePeerDependencies:
-      - debug
-    dev: false
-
-  /follow-redirects@1.15.6:
-    resolution: {integrity: sha512-wWN62YITEaOpSK584EZXJafH1AGpO8RVgElfkuXbTOrPX4fIfOyEpW/CsiNd8JdYrAoOvafRTOEnvsO++qCqFA==}
-    engines: {node: '>=4.0'}
-    peerDependencies:
-      debug: '*'
-    peerDependenciesMeta:
-      debug:
-        optional: true
-    dev: false
-
-  /lodash.defaultsdeep@4.6.1:
-    resolution: {integrity: sha512-3j8wdDzYuWO3lM3Reg03MuQR957t287Rpcxp1njpEa8oDrikb+FwGdW3n+FELh/A6qib6yPit0j/pv9G/yeAqA==}
-    dev: false
-
-  /revolt-api@0.7.15:
-    resolution: {integrity: sha512-rWRnjBFvoXt/RHRxHg9KuP+x1Jk61KdsOpKOczVJg5tIqGDmqp/6QZHw5rJTtG+wCH3Ah3YKwY+MM5NHfg1W3Q==}
-    dependencies:
-      axios: 0.26.1
-      lodash.defaultsdeep: 4.6.1
-    transitivePeerDependencies:
-      - debug
-    dev: false
@@ -1,221 +0,0 @@
-#[macro_use]
-extern crate serde;
-
-use std::sync::OnceLock;
-
-use neon::prelude::*;
-use revolt_database::{Database, DatabaseInfo};
-
-fn js_init(mut cx: FunctionContext) -> JsResult<JsUndefined> {
-    // static INIT: OnceLock<()> = OnceLock::new();
-    // if INIT.get().is_none() {
-    //     INIT.get_or_init(|| {
-    //         async_std::task::block_on(async {
-    //             revolt_config::configure!(api);
-
-    //             match DatabaseInfo::Auto.connect().await {
-    //                 Ok(db) => {
-    //                     let authifier_db = db.clone().to_authifier().await.database;
-    //                     revolt_database::tasks::start_workers(db, authifier_db);
-    //                     Ok(())
-    //                 }
-    //                 Err(err) => Err(err),
-    //             }
-    //         })
-    //         .or_else(|err| cx.throw_error(err))
-    //         .unwrap();
-    //     });
-    // }
-
-    Ok(cx.undefined())
-}
-
-struct DatabaseBinding(Database, Channel);
-impl Finalize for DatabaseBinding {}
-impl DatabaseBinding {
-    fn take(&self) -> (Database, Channel) {
-        (self.0.clone(), self.1.clone())
-    }
-}
-
-fn js_database(mut cx: FunctionContext) -> JsResult<JsBox<DatabaseBinding>> {
-    let db = async_std::task::block_on(DatabaseInfo::Auto.connect())
-        .or_else(|err| cx.throw_error(err))?;
-
-    let channel = cx.channel();
-    Ok(cx.boxed(DatabaseBinding(db, channel)))
-}
-
-// Implementations for models
-#[derive(Clone)]
-#[allow(clippy::large_enum_variant)]
-enum Model {
-    User(revolt_database::User),
-    Error(revolt_result::Error),
-}
-
-impl Model {
-    fn give(&self) -> Model {
-        self.clone()
-    }
-}
-
-impl Finalize for Model {}
-
-macro_rules! shim_boxed {
-    ($cx: ident, $name: ident, $model: ident, $( $variable: ident $type: ident $id: expr )+, $cmd: ident, $( $arg: expr, )+) => {
-        fn $name(mut cx: FunctionContext) -> JsResult<JsPromise> {
-            $(
-                let $variable = cx.argument::<$type>($id)?.value(&mut cx);
-            )+
-
-            let (db, channel) = cx.this::<JsBox<DatabaseBinding>>()?.take();
-            let (deferred, promise) = cx.promise();
-
-            async_std::task::spawn(async move {
-                let result = db.$cmd($($arg,)+).await;
-                deferred.settle_with(&channel, move |mut cx| {
-                    Ok(cx.boxed(match result {
-                        Ok(value) => Model::$model(value),
-                        Err(error) => Model::Error(error)
-                    }))
-                })
-            });
-
-            Ok(promise)
-        }
-
-        $cx.export_function(stringify!($name), $name)?;
-    };
-}
-
-fn js_data(mut cx: FunctionContext) -> JsResult<JsValue> {
-    match cx.this::<JsBox<Model>>()?.give() {
-        Model::Error(_) => neon_serde4::to_value(&mut cx, &None::<()>),
-        Model::User(user) => neon_serde4::to_value(&mut cx, &user),
-    }
-    .or_else(|e| cx.throw_error(e.to_string()))
-}
-
-fn js_error(mut cx: FunctionContext) -> JsResult<JsValue> {
-    let value = match cx.this::<JsBox<Model>>()?.give() {
-        Model::Error(err) => Some(err),
-        _ => None,
-    };
-
-    neon_serde4::to_value(&mut cx, &value).or_else(|e| cx.throw_error(e.to_string()))
-}
-
-// Basic data implementation
-#[derive(Serialize, Deserialize)]
-struct ResultBinding<T> {
-    #[serde(flatten)]
-    value: Option<T>,
-    error: Option<revolt_result::Error>,
-}
-
-macro_rules! shim {
-    ($cx: ident, $name: ident, $( $variable: ident $type: ident $id: expr )*, $( $model: ident $modelType: ident $modelId: expr )*, | $db: ident | $closure: expr, $( $arg: expr, )+) => {
-        fn $name(mut cx: FunctionContext) -> JsResult<JsPromise> {
-            $(
-                let $variable = cx.argument::<$type>($id)?.value(&mut cx);
-            )*
-
-            $(
-                let mut $model = if let Model::$modelType(value) = cx.argument::<JsBox<Model>>($modelId)?.give() {
-                    value
-                } else {
-                    unreachable!()
-                };
-            )*
-
-            let (db, channel) = cx.this::<JsBox<DatabaseBinding>>()?.take();
-            let (deferred, promise) = cx.promise();
-
-            async_std::task::spawn(async move {
-                #[allow(clippy::redundant_closure_call)]
-                let result = (|$db: $crate::Database| $closure)(db.clone()).await;
-                deferred.settle_with(&channel, move |mut cx| {
-                    neon_serde4::to_value(
-                        &mut cx,
-                        &match result {
-                            Ok(value) => ResultBinding {
-                                value: Some(value),
-                                error: None,
-                            },
-                            Err(error) => ResultBinding {
-                                value: None,
-                                error: Some(error),
-                            },
-                        },
-                    )
-                    .or_else(|e| cx.throw_error(e.to_string()))
-                })
-            });
-
-            Ok(promise)
-        }
-
-        $cx.export_function(stringify!($name), $name)?;
-    };
-}
-
-#[neon::main]
-fn main(mut cx: ModuleContext) -> NeonResult<()> {
-    // initialise required background stuff
-    cx.export_function("init", js_init)?;
-
-    // database & model stuff
-    cx.export_function("database", js_database)?;
-    cx.export_function("model_data", js_data)?;
-    cx.export_function("model_error", js_error)?;
-
-    shim_boxed!(
-        cx,
-        database_fetch_user,
-        User,
-        user_id JsString 0,
-        fetch_user,
-        &user_id,
-    );
-
-    shim_boxed!(
-        cx,
-        database_fetch_user_by_username,
-        User,
-        username JsString 0
-        discriminator JsString 1,
-        fetch_user_by_username,
-        &username, &discriminator,
-    );
-
-    // procedure calls
-    shim!(
-        cx,
-        proc_channels_create_dm,
-        user_a JsString 0
-        user_b JsString 1,
-        ,
-        |db| async move {
-            let user_a = db.fetch_user(&user_a).await?;
-            let user_b = db.fetch_user(&user_b).await?;
-            revolt_database::Channel::create_dm(&db, &user_a, &user_b).await
-        },
-        &userA, &userB,
-    );
-
-    shim!(
-        cx,
-        proc_users_suspend,
-        duration JsNumber 1
-        reason JsString 2,
-        user User 0,
-        |db| async move {
-            let duration = duration as usize;
-            user.suspend(&db, if duration == 0 { None } else { Some(duration) }, Some(reason.split('|').map(|x| x.to_owned()).collect())).await
-        },
-        &user,
-    );
-
-    Ok(())
-}
@@ -1,53 +0,0 @@
-const Internal = require(".");
-
-// playing around with class wrapper, not practical
-class Model {
-  constructor(model) {
-    this.model = model;
-  }
-
-  data() {
-    return Internal.model_data.bind(this.model)();
-  }
-
-  error() {
-    return Internal.model_error.bind(this.model)();
-  }
-}
-
-class User extends Model {
-  constructor(db, user) {
-    super(user);
-    this.db = db;
-  }
-}
-
-class Database {
-  constructor() {
-    this.db = Internal.database();
-  }
-
-  async fetchUser(userId) {
-    return new User(
-      this,
-      await Internal.database_fetch_user.bind(this.db)(userId)
-    );
-  }
-
-  async fetchUserByUsername(username, discriminator) {
-    return new User(
-      this,
-      await Internal.database_fetch_user_by_username.bind(this.db)(
-        username,
-        discriminator
-      )
-    );
-  }
-}
-
-const db = new Database();
-db.fetchUserByUsername("dos", "7624").then((user) => console.info(user.data()));
-db.fetchUserByUsername("dos", "1111").then((user) => console.info(user.data()));
-db.fetchUserByUsername("dos", "1111").then((user) =>
-  console.info(user.error())
-);
@@ -1,6 +0,0 @@
-{
-  "name": "bindings",
-  "lockfileVersion": 3,
-  "requires": true,
-  "packages": {}
-}
@@ -1,6 +1,6 @@
 [package]
 name = "revolt-bonfire"
-version = "0.8.3"
+version = "0.5.19"
 license = "AGPL-3.0-or-later"
 edition = "2021"

@@ -9,19 +9,15 @@ 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"
-lru_time_cache = "0.11.11"
-async-channel = "2.3.1"

 # 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"
@@ -29,20 +25,4 @@ 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",
-] }
-
-# core
-authifier = { version = "1.0.9" }
-revolt-result = { path = "../core/result" }
-revolt-models = { path = "../core/models" }
-revolt-config = { path = "../core/config" }
-revolt-database = { path = "../core/database" }
-revolt-permissions = { version = "0.8.3", path = "../core/permissions" }
-revolt-presence = { path = "../core/presence", features = ["redis-is-patched"] }
-
-# redis
-fred = { version = "8.0.1", features = ["subscriber-client"] }
+async-std = { version = "1.8.0", features = ["tokio1", "tokio02", "attributes"] }
@@ -1,12 +1,11 @@
 # Build Stage
 FROM ghcr.io/revoltchat/base:latest AS builder
-FROM debian:12 AS debian

 # Bundle Stage
-FROM gcr.io/distroless/cc-debian12:nonroot
+FROM debian:bullseye-slim
+RUN apt-get update && \
+    apt-get install -y ca-certificates && \
+    apt-get clean
 COPY --from=builder /home/rust/src/target/release/revolt-bonfire ./
-COPY --from=debian /usr/bin/uname /usr/bin/uname
-
-EXPOSE 14703
-USER nonroot
+EXPOSE 9000
 CMD ["./revolt-bonfire"]
@@ -1,7 +1,6 @@
 use async_tungstenite::tungstenite::{handshake, Message};
 use futures::channel::oneshot::Sender;
-use revolt_database::events::client::ReadyPayloadFields;
-use revolt_result::{create_error, Result};
+use revolt_quark::{Error, Result};
 use serde::{Deserialize, Serialize};

 /// Enumeration of supported protocol formats
@@ -38,16 +37,16 @@ impl ProtocolConfiguration {
        match self.format {
            ProtocolFormat::Json => {
                if let Message::Text(text) = msg {
-                    serde_json::from_str(text).map_err(|_| create_error!(InternalError))
+                    serde_json::from_str(text).map_err(|_| Error::InternalError)
                } else {
-                    Err(create_error!(InternalError))
+                    Err(Error::InternalError)
                }
            }
            ProtocolFormat::Msgpack => {
                if let Message::Binary(buf) = msg {
-                    rmp_serde::from_slice(buf).map_err(|_| create_error!(InternalError))
+                    rmp_serde::from_slice(buf).map_err(|_| Error::InternalError)
                } else {
-                    Err(create_error!(InternalError))
+                    Err(Error::InternalError)
                }
            }
        }
@@ -84,17 +83,6 @@ impl ProtocolConfiguration {
    pub fn get_protocol_format(&self) -> &ProtocolFormat {
        &self.format
    }
-
-    /// Get ready payload fields
-    pub fn get_ready_payload_fields(&self) -> Vec<ReadyPayloadFields> {
-        vec![
-            ReadyPayloadFields::Users,
-            ReadyPayloadFields::Servers,
-            ReadyPayloadFields::Channels,
-            ReadyPayloadFields::Members,
-            ReadyPayloadFields::Emoji,
-        ]
-    }
 }

 /// Object holding one side of a channel for receiving the parsed information
@@ -1,5 +1,5 @@
 use once_cell::sync::OnceCell;
-use revolt_database::{Database, DatabaseInfo};
+use revolt_quark::{Database, DatabaseInfo};

 static DBCONN: OnceCell<Database> = OnceCell::new();

@@ -10,9 +10,7 @@ pub async fn connect() {
        .await
        .expect("Failed to connect to the database.");

-    if DBCONN.set(database).is_err() {
-        panic!("couldn't set database")
-    }
+    DBCONN.set(database).expect("Setting `Database`");
 }

 /// Get a reference to the current database.
@@ -1,2 +0,0 @@
-pub mod r#impl;
-pub mod state;
@@ -1,211 +0,0 @@
-use std::{
-    collections::{HashMap, HashSet},
-    sync::Arc,
-    time::Duration,
-};
-
-use async_std::sync::{Mutex, RwLock};
-use lru::LruCache;
-use lru_time_cache::{LruCache as LruTimeCache, TimedEntry};
-use revolt_database::{Channel, Member, Server, User};
-
-/// Enumeration representing some change in subscriptions
-pub enum SubscriptionStateChange {
-    /// No change
-    None,
-    /// Clear all subscriptions
-    Reset,
-    /// Append or remove subscriptions
-    Change {
-        add: Vec<String>,
-        remove: Vec<String>,
-    },
-}
-
-/// Dumb per-state cache implementation
-///
-/// Ideally this would use a global cache that
-/// allows for mutations and could use Rc<> to
-/// track usage. If Rc<> == 1, then it only
-/// remains in global cache, hence should be
-/// dropped.
-///
-/// ------------------------------------------------
-/// We can strip these objects to core information!!
-/// ------------------------------------------------
-#[derive(Debug)]
-pub struct Cache {
-    pub user_id: String,
-    pub is_bot: bool,
-
-    pub users: HashMap<String, User>,
-    pub channels: HashMap<String, Channel>,
-    pub members: HashMap<String, Member>,
-    pub servers: HashMap<String, Server>,
-
-    pub seen_events: LruCache<String, ()>,
-}
-
-impl Default for Cache {
-    fn default() -> Self {
-        Cache {
-            user_id: Default::default(),
-            is_bot: false,
-
-            users: Default::default(),
-            channels: Default::default(),
-            members: Default::default(),
-            servers: Default::default(),
-
-            seen_events: LruCache::new(20),
-        }
-    }
-}
-
-/// Client state
-pub struct State {
-    pub cache: Cache,
-
-    pub session_id: String,
-    pub private_topic: String,
-    pub state: SubscriptionStateChange,
-
-    pub subscribed: Arc<RwLock<HashSet<String>>>,
-    pub active_servers: Arc<Mutex<LruTimeCache<String, ()>>>,
-}
-
-impl State {
-    /// Create state from User
-    pub fn from(user: User, session_id: String) -> State {
-        let mut subscribed = HashSet::new();
-        let private_topic = format!("{}!", user.id);
-        subscribed.insert(private_topic.clone());
-        subscribed.insert(user.id.clone());
-
-        let mut cache: Cache = Cache {
-            user_id: user.id.clone(),
-            ..Default::default()
-        };
-
-        cache.users.insert(user.id.clone(), user);
-
-        State {
-            cache,
-            subscribed: Arc::new(RwLock::new(subscribed)),
-            active_servers: Arc::new(Mutex::new(LruTimeCache::with_expiry_duration_and_capacity(
-                Duration::from_secs(900),
-                5,
-            ))),
-            session_id,
-            private_topic,
-            state: SubscriptionStateChange::Reset,
-        }
-    }
-
-    /// Apply currently queued state
-    pub async fn apply_state(&mut self) -> SubscriptionStateChange {
-        // Check if we need to change subscriptions to member event topics
-        if !self.cache.is_bot {
-            enum Server {
-                Subscribe(String),
-                Unsubscribe(String),
-            }
-
-            let active_server_changes: Vec<Server> = {
-                let mut active_servers = self.active_servers.lock().await;
-                active_servers
-                    .notify_iter()
-                    .map(|e| match e {
-                        TimedEntry::Valid(k, _) => Server::Subscribe(format!("{}u", k)),
-                        TimedEntry::Expired(k, _) => Server::Unsubscribe(format!("{}u", k)),
-                    })
-                    .collect()
-                // It is bad practice to open more than one Mutex at once and could
-                // lead to a deadlock, so instead we choose to collect the changes.
-            };
-
-            for entry in active_server_changes {
-                match entry {
-                    Server::Subscribe(k) => {
-                        self.insert_subscription(k).await;
-                    }
-                    Server::Unsubscribe(k) => {
-                        self.remove_subscription(&k).await;
-                    }
-                }
-            }
-        }
-
-        // Flush changes to subscriptions
-        let state = std::mem::replace(&mut self.state, SubscriptionStateChange::None);
-        let mut subscribed = self.subscribed.write().await;
-        if let SubscriptionStateChange::Change { add, remove } = &state {
-            for id in add {
-                subscribed.insert(id.clone());
-            }
-
-            for id in remove {
-                subscribed.remove(id);
-            }
-        }
-
-        state
-    }
-
-    /// Clone the active user
-    pub fn clone_user(&self) -> User {
-        self.cache.users.get(&self.cache.user_id).unwrap().clone()
-    }
-
-    /// Reset the current state
-    pub async fn reset_state(&mut self) {
-        self.state = SubscriptionStateChange::Reset;
-        self.subscribed.write().await.clear();
-    }
-
-    /// Add a new subscription
-    pub async fn insert_subscription(&mut self, subscription: String) {
-        let mut subscribed = self.subscribed.write().await;
-        if subscribed.contains(&subscription) {
-            return;
-        }
-
-        match &mut self.state {
-            SubscriptionStateChange::None => {
-                self.state = SubscriptionStateChange::Change {
-                    add: vec![subscription.clone()],
-                    remove: vec![],
-                };
-            }
-            SubscriptionStateChange::Change { add, .. } => {
-                add.push(subscription.clone());
-            }
-            SubscriptionStateChange::Reset => {}
-        }
-
-        subscribed.insert(subscription);
-    }
-
-    /// Remove existing subscription
-    pub async fn remove_subscription(&mut self, subscription: &str) {
-        let mut subscribed = self.subscribed.write().await;
-        if !subscribed.contains(&subscription.to_string()) {
-            return;
-        }
-
-        match &mut self.state {
-            SubscriptionStateChange::None => {
-                self.state = SubscriptionStateChange::Change {
-                    add: vec![],
-                    remove: vec![subscription.to_string()],
-                };
-            }
-            SubscriptionStateChange::Change { remove, .. } => {
-                remove.push(subscription.to_string());
-            }
-            SubscriptionStateChange::Reset => panic!("Should not remove during a reset!"),
-        }
-
-        subscribed.remove(subscription);
-    }
-}
@@ -1,13 +1,12 @@
 use std::env;

 use async_std::net::TcpListener;
-use revolt_presence::clear_region;
+use revolt_quark::presence::presence_clear_region;

 #[macro_use]
 extern crate log;

 pub mod config;
-pub mod events;

 mod database;
 mod websocket;
@@ -15,28 +14,21 @@ mod websocket;
 #[async_std::main]
 async fn main() {
    // Configure requirements for Bonfire.
-    revolt_config::configure!(events);
+    revolt_quark::configure!();
    database::connect().await;

    // Clean up the current region information.
-    let no_clear_region = env::var("NO_CLEAR_PRESENCE").unwrap_or_else(|_| "0".into()) == "1";
-    if !no_clear_region {
-        clear_region(None).await;
-    }
+    presence_clear_region(None).await;

    // Setup a TCP listener to accept WebSocket connections on.
-    // By default, we bind to port 14703 on all interfaces.
-    let bind = env::var("HOST").unwrap_or_else(|_| "0.0.0.0:14703".into());
+    // By default, we bind to port 9000 on all interfaces.
+    let bind = env::var("HOST").unwrap_or_else(|_| "0.0.0.0:9000".into());
    info!("Listening on host {bind}");
    let try_socket = TcpListener::bind(bind).await;
    let listener = try_socket.expect("Failed to bind");

    // Start accepting new connections and spawn a client for each connection.
    while let Ok((stream, addr)) = listener.accept().await {
-        async_std::task::spawn(async move {
-            info!("User connected from {addr:?}");
-            websocket::client(database::get_db(), stream, addr).await;
-            info!("User disconnected from {addr:?}");
-        });
+        websocket::spawn_client(database::get_db(), stream, addr);
    }
 }
@@ -1,504 +1,253 @@
-use std::{collections::HashSet, net::SocketAddr, sync::Arc};
+use std::net::SocketAddr;

-use async_tungstenite::WebSocketStream;
-use authifier::AuthifierEvent;
-use fred::{
-    error::{RedisError, RedisErrorKind},
-    interfaces::{ClientLike, EventInterface, PubsubInterface},
-    types::RedisConfig,
+use futures::{channel::oneshot, pin_mut, select, FutureExt, SinkExt, StreamExt, TryStreamExt};
+use revolt_quark::{
+    events::{
+        client::EventV1,
+        server::ClientMessage,
+        state::{State, SubscriptionStateChange},
+    },
+    models::{user::UserHint, User},
+    presence::{presence_create_session, presence_delete_session},
+    redis_kiss, Database,
 };
-use futures::{
-    channel::oneshot,
-    join, pin_mut, select,
-    stream::{SplitSink, SplitStream},
-    FutureExt, SinkExt, StreamExt, TryStreamExt,
-};
-use redis_kiss::{PayloadType, REDIS_PAYLOAD_TYPE, REDIS_URI};
-use revolt_config::report_internal_error;
-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, RwLock},
-    task::spawn,
-};
-use revolt_result::create_error;
-use sentry::Level;
+use async_std::{net::TcpStream, sync::Mutex, task};

-use crate::config::{ProtocolConfiguration, WebsocketHandshakeCallback};
-use crate::events::state::{State, SubscriptionStateChange};
+use crate::config::WebsocketHandshakeCallback;

-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,
+/// Spawn a new WebSocket client worker given access to the database,
 /// the relevant TCP stream and the remote address of the client.
-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;
-    };
+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:?}");

-    // Verify we've received a valid config, otherwise we should just drop the connection.
-    let Ok(mut config) = receiver.await else {
-        return;
-    };
+        // 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,
+        )
+        .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()
+                );

-    info!(
-        "User {addr:?} provided protocol configuration (version = {}, format = {:?})",
-        config.get_protocol_version(),
-        config.get_protocol_format()
-    );
+                // Split the socket for simultaneously read and write.
+                let (write, mut read) = ws.split();
+                let write = Mutex::new(write);

-    // 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(Some(message)) = read.try_next().await {
-            if let Ok(ClientMessage::Authenticate { token }) = config.decode(&message) {
-                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(&EventV1::Error {
-                data: create_error!(InvalidSession),
-            }))
-            .await
-            .ok();
-        return;
-    };
-
-    let (user, session_id) = match User::from_token(db, token, UserHint::Any).await {
-        Ok(user) => user,
-        Err(err) => {
-            write
-                .send(config.encode(&EventV1::Error { data: err }))
-                .await
-                .ok();
-            return;
-        }
-    };
-
-    info!("User {addr:?} authenticated as @{}", user.username);
-
-    // Create local state.
-    let mut state = State::from(user, session_id);
-    let user_id = state.cache.user_id.clone();
-
-    // Notify socket we have authenticated.
-    if report_internal_error!(write.send(config.encode(&EventV1::Authenticated)).await).is_err() {
-        return;
-    }
-
-    // Download required data to local cache and send Ready payload.
-    let ready_payload = match report_internal_error!(
-        state
-            .generate_ready_payload(db, config.get_ready_payload_fields())
-            .await
-    ) {
-        Ok(ready_payload) => ready_payload,
-        Err(_) => return,
-    };
-
-    if report_internal_error!(write.send(config.encode(&ready_payload)).await).is_err() {
-        return;
-    }
-
-    // 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;
-    }
-
-    {
-        // Setup channels and mutexes
-        let write = Mutex::new(write);
-        let subscribed = state.subscribed.clone();
-        let active_servers = state.active_servers.clone();
-        let (topic_signal_s, topic_signal_r) = async_channel::unbounded();
-
-        // TODO: this needs to be rewritten
-        // Create channels through which the tasks can signal to each other they need to clean up
-        let (kill_signal_1_s, kill_signal_1_r) = async_channel::bounded(1);
-        let (kill_signal_2_s, kill_signal_2_r) = async_channel::bounded(1);
-
-        // Create a PubSub connection to poll on.
-        let listener = listener_with_kill_signal(
-            db,
-            &mut state,
-            addr,
-            &config,
-            topic_signal_r,
-            kill_signal_1_r,
-            &write,
-            kill_signal_2_s,
-        );
-
-        // Read from WebSocket stream.
-        let worker = worker_with_kill_signal(
-            addr,
-            subscribed,
-            active_servers,
-            user_id.clone(),
-            &config,
-            topic_signal_s,
-            kill_signal_2_r,
-            read,
-            &write,
-            kill_signal_1_s,
-        );
-
-        join!(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;
-    }
-}
-
-#[allow(clippy::too_many_arguments)]
-async fn listener_with_kill_signal(
-    db: &'static Database,
-    state: &mut State,
-    addr: SocketAddr,
-    config: &ProtocolConfiguration,
-    topic_signal_r: async_channel::Receiver<()>,
-    kill_signal_r: async_channel::Receiver<()>,
-    write: &Mutex<WsWriter>,
-    kill_signal_s: async_channel::Sender<()>,
-) {
-    listener(
-        db,
-        state,
-        addr,
-        config,
-        topic_signal_r,
-        kill_signal_r,
-        write,
-    )
-    .await;
-    kill_signal_s.send(()).await.ok();
-}
-
-async fn listener(
-    db: &'static Database,
-    state: &mut State,
-    addr: SocketAddr,
-    config: &ProtocolConfiguration,
-    topic_signal_r: async_channel::Receiver<()>,
-    kill_signal_r: async_channel::Receiver<()>,
-    write: &Mutex<WsWriter>,
-) {
-    let redis_config = RedisConfig::from_url(&REDIS_URI).unwrap();
-    let subscriber = match report_internal_error!(
-        fred::types::Builder::from_config(redis_config).build_subscriber_client()
-    ) {
-        Ok(subscriber) => subscriber,
-        Err(_) => return,
-    };
-
-    if report_internal_error!(subscriber.init().await).is_err() {
-        return;
-    }
-
-    // Handle Redis connection dropping
-    let (clean_up_s, clean_up_r) = async_channel::bounded(1);
-    let clean_up_s = Arc::new(Mutex::new(clean_up_s));
-    subscriber.on_error(move |err| {
-        if let RedisErrorKind::Canceled = err.kind() {
-            let clean_up_s = clean_up_s.clone();
-            spawn(async move {
-                clean_up_s.lock().await.send(()).await.ok();
-            });
-        }
-
-        Ok(())
-    });
-
-    let mut message_rx = subscriber.message_rx();
-    'out: loop {
-        // Check for state changes for subscriptions.
-        match state.apply_state().await {
-            SubscriptionStateChange::Reset => {
-                if report_internal_error!(subscriber.unsubscribe_all().await).is_err() {
-                    break 'out;
-                }
-
-                let subscribed = state.subscribed.read().await;
-                for id in subscribed.iter() {
-                    if report_internal_error!(subscriber.subscribe(id).await).is_err() {
-                        break 'out;
+                // 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;
+                        }
                    }
                }

-                #[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}");
+                // 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);

-                    if report_internal_error!(subscriber.unsubscribe(id).await).is_err() {
-                        break 'out;
-                    }
-                }
+                            // Create local state.
+                            let mut state = State::from(user);
+                            let user_id = state.cache.user_id.clone();

-                for id in add {
-                    #[cfg(debug_assertions)]
-                    info!("{addr:?} subscribing to {id}");
+                            // Create presence session.
+                            let (first_session, session_id) =
+                                presence_create_session(&user_id, 0).await;

-                    if report_internal_error!(subscriber.subscribe(id).await).is_err() {
-                        break 'out;
-                    }
-                }
-            }
-            SubscriptionStateChange::None => {}
-        }
-
-        let t1 = message_rx.recv().fuse();
-        let t2 = topic_signal_r.recv().fuse();
-        let t3 = kill_signal_r.recv().fuse();
-        let t4 = clean_up_r.recv().fuse();
-
-        pin_mut!(t1, t2, t3, t4);
-
-        select! {
-            _ = t4 => {
-                break 'out;
-            },
-            _ = t3 => {
-                break 'out;
-            },
-            _ = t2 => {},
-            message = t1 => {
-                // Handle incoming events.
-                let message = match report_internal_error!(message) {
-                    Ok(message) => message,
-                    Err(_) => break 'out
-                };
-
-                let event = match *REDIS_PAYLOAD_TYPE {
-                    PayloadType::Json => message
-                        .value
-                        .as_str()
-                        .and_then(|s| report_internal_error!(serde_json::from_str::<EventV1>(s.as_ref())).ok()),
-                    PayloadType::Msgpack => message
-                        .value
-                        .as_bytes()
-                        .and_then(|b| report_internal_error!(rmp_serde::from_slice::<EventV1>(b)).ok()),
-                    PayloadType::Bincode => message
-                        .value
-                        .as_bytes()
-                        .and_then(|b| report_internal_error!(bincode::deserialize::<EventV1>(b)).ok()),
-                };
-
-                let Some(mut event) = event else {
-                    let err = format!(
-                        "Failed to deserialise event for {}: `{:?}`",
-                        message.channel,
-                        message
-                            .value
-                    );
-
-                    error!("{}", err);
-                    sentry::capture_message(&err, Level::Error);
-                    break 'out;
-                };
-
-                if let EventV1::Auth(auth) = &event {
-                    if let AuthifierEvent::DeleteSession { session_id, .. } = auth {
-                        if &state.session_id == session_id {
-                            event = EventV1::Logout;
-                        }
-                    } else if let AuthifierEvent::DeleteAllSessions {
-                        exclude_session_id, ..
-                    } = auth
-                    {
-                        if let Some(excluded) = exclude_session_id {
-                            if &state.session_id != excluded {
-                                event = EventV1::Logout;
-                            }
-                        } else {
-                            event = EventV1::Logout;
-                        }
-                    }
-                } else {
-                    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) {
-                        let err = format!("Error while sending an event to {addr:?}: {e:?}");
-                        warn!("{}", err);
-                        sentry::capture_message(&err, Level::Warning);
-                    }
-
-                    break 'out;
-                }
-
-                if let EventV1::Logout = event {
-                    info!("User {addr:?} received log out event!");
-                    break 'out;
-                }
-            }
-        }
-    }
-
-    report_internal_error!(subscriber.quit().await).ok();
-}
-
-#[allow(clippy::too_many_arguments)]
-async fn worker_with_kill_signal(
-    addr: SocketAddr,
-    subscribed: Arc<RwLock<HashSet<String>>>,
-    active_servers: Arc<Mutex<lru_time_cache::LruCache<String, ()>>>,
-    user_id: String,
-    config: &ProtocolConfiguration,
-    topic_signal_s: async_channel::Sender<()>,
-    kill_signal_r: async_channel::Receiver<()>,
-    read: WsReader,
-    write: &Mutex<WsWriter>,
-    kill_signal_s: async_channel::Sender<()>,
-) {
-    worker(
-        addr,
-        subscribed,
-        active_servers,
-        user_id,
-        config,
-        topic_signal_s,
-        kill_signal_r,
-        read,
-        write,
-    )
-    .await;
-    kill_signal_s.send(()).await.ok();
-}
-
-#[allow(clippy::too_many_arguments)]
-async fn worker(
-    addr: SocketAddr,
-    subscribed: Arc<RwLock<HashSet<String>>>,
-    active_servers: Arc<Mutex<lru_time_cache::LruCache<String, ()>>>,
-    user_id: String,
-    config: &ProtocolConfiguration,
-    topic_signal_s: async_channel::Sender<()>,
-    kill_signal_r: async_channel::Receiver<()>,
-    mut read: WsReader,
-    write: &Mutex<WsWriter>,
-) {
-    loop {
-        let t1 = read.try_next().fuse();
-        let t2 = kill_signal_r.recv().fuse();
-
-        pin_mut!(t1, t2);
-
-        select! {
-            _ = t2 => {
-                return;
-            },
-            result = t1 => {
-                let msg = match result {
-                    Ok(Some(msg)) => msg,
-                    Ok(None) => {
-                        warn!("Received a None message!");
-                        sentry::capture_message("Received a None message!", Level::Warning);
-                        return;
-                    }
-                    Err(e) => {
-                        use async_tungstenite::tungstenite::Error;
-                        if !matches!(e, Error::AlreadyClosed | Error::ConnectionClosed) {
-                            let err = format!("Error while reading an event from {addr:?}: {e:?}");
-                            warn!("{}", err);
-                            sentry::capture_message(&err, Level::Warning);
-                        }
-
-                        return;
-                    }
-                };
-
-                let Ok(payload) = config.decode(&msg) else {
-                    continue;
-                };
-
-                match payload {
-                    ClientMessage::BeginTyping { channel } => {
-                        if !subscribed.read().await.contains(&channel) {
-                            continue;
-                        }
-
-                        EventV1::ChannelStartTyping {
-                            id: channel.clone(),
-                            user: user_id.clone(),
-                        }
-                        .p(channel.clone())
-                        .await;
-                    }
-                    ClientMessage::EndTyping { channel } => {
-                        if !subscribed.read().await.contains(&channel) {
-                            continue;
-                        }
-
-                        EventV1::ChannelStopTyping {
-                            id: channel.clone(),
-                            user: user_id.clone(),
-                        }
-                        .p(channel.clone())
-                        .await;
-                    }
-                    ClientMessage::Subscribe { server_id } => {
-                        let mut servers = active_servers.lock().await;
-                        let has_item = servers.contains_key(&server_id);
-                        servers.insert(server_id, ());
-
-                        if !has_item {
-                            // Poke the listener to adjust subscriptions
-                            topic_signal_s.send(()).await.ok();
-                        }
-                    }
-                    ClientMessage::Ping { data, responded } => {
-                        if responded.is_none() {
+                            // Notify socket we have authenticated.
                            write
                                .lock()
                                .await
-                                .send(config.encode(&EventV1::Pong { data }))
+                                .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 = presence_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();
                        }
                    }
-                    _ => {}
                }
            }
+
+            // * Disconnect the WebSocket if it isn't already.
+            /*ws.close(Some(CloseFrame {
+                code: CloseCode::Normal,
+                reason: std::borrow::Cow::from(""),
+            }))
+            .await
+            .unwrap();*/
        }
-    }
+
+        info!("User disconnected from {addr:?}");
+    });
 }
@@ -0,0 +1,10 @@
+[package]
+name = "revolt-discord-bridge"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+serenity = { version = "0.11.5", default-features = false, features = ["client", "gateway", "rustls_backend", "model"] }
+tokio = { version = "1.0", features = ["macros", "rt-multi-thread"] }
@@ -0,0 +1,45 @@
+use std::env;
+
+use serenity::async_trait;
+use serenity::model::channel::Message;
+use serenity::model::channel::Channel;
+use serenity::model::gateway::{GatewayIntents, Ready};
+use serenity::prelude::*;
+
+struct Handler;
+
+#[async_trait]
+impl EventHandler for Handler {
+    async fn message(&self, ctx: Context, msg: Message) {
+        println!("Received message: {}", msg.content);
+
+        if msg.content == "deez" {
+            if let Ok(Channel::Guild(channel)) = msg.channel(&ctx).await {
+                channel.send_message(&ctx, |m| {
+                    m.content("this is where a message would usually go")
+                }).await.unwrap();
+            }
+        }
+    }
+
+    async fn ready(&self, _: Context, ready: Ready) {
+        println!("{} is connected!", ready.user.name);
+    }
+}
+
+#[tokio::main]
+async fn main() {
+    let token = env::var("DISCORD_TOKEN").expect("Expected a token in the environment");
+
+    let intents =
+        GatewayIntents::GUILDS | GatewayIntents::GUILD_MESSAGES | GatewayIntents::MESSAGE_CONTENT;
+    
+    let mut client = Client::builder(token, intents)
+        .event_handler(Handler)
+        .await
+        .expect("Error creating client");
+
+    if let Err(why) = client.start().await {
+        println!("Client error: {:?}", why);
+    }
+}
@@ -1,37 +0,0 @@
-[package]
-name = "revolt-config"
-version = "0.8.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]
-report-macros = ["revolt-result"]
-test = ["async-std"]
-default = ["test"]
-
-[dependencies]
-# Utility
-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"
-
-# Core
-revolt-result = { version = "0.8.3", path = "../result", optional = true }
@@ -1,9 +0,0 @@
-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.
@@ -1,9 +0,0 @@
-[database]
-mongodb = "mongodb://localhost"
-redis = "redis://localhost/"
-
-[rabbit]
-host = "127.0.0.1"
-port = 5672
-username = "rabbituser"
-password = "rabbitpass"
@@ -1,263 +0,0 @@
-production = false
-
-[database]
-# MongoDB connection URL
-# Defaults to the container name specified in self-hosted
-mongodb = "mongodb://database"
-# Redis connection URL
-# Defaults to the container name specified in self-hosted
-redis = "redis://redis/"
-
-[hosts]
-# Web locations of various services
-# Defaults assume all services are reverse-proxied
-# See https://github.com/revoltchat/self-hosted/blob/master/Caddyfile
-#
-# Remember to change these to https/wss where appropriate in production!
-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 = ""
-
-[rabbit]
-host = "rabbit"
-port = 5672
-username = "rabbituser"
-password = "rabbitpass"
-
-[api]
-
-[api.registration]
-# Whether an invite should be required for registration
-# See https://github.com/revoltchat/self-hosted#making-your-instance-invite-only
-invite_only = false
-
-[api.smtp]
-# Email server configuration for verification
-# Defaults to no email verification (host field is empty)
-host = ""
-username = ""
-password = ""
-from_address = "noreply@example.com"
-# reply_to = "noreply@example.com"
-# port = 587
-# use_tls = true
-
-
-[api.security]
-# Authifier Shield API key
-authifier_shield_key = ""
-# Legacy voice server management token
-voso_legacy_token = ""
-# Whether services are behind the Cloudflare network
-trust_cloudflare = false
-
-[api.security.captcha]
-# hCaptcha configuration
-hcaptcha_key = ""
-hcaptcha_sitekey = ""
-
-[api.workers]
-# Maximum concurrent connections (to proxy server)
-max_concurrent_connections = 50
-
-[pushd]
-# this changes the names of the queues to not overlap 
-# prod/beta if they happen to be on the same exchange/instance.
-# Usually they have to be, so that messages sent from one or the other get sent to everyone
-production = true
-
-# none of these should need changing
-exchange = "revolt.notifications"
-message_queue = "notifications.origin.message"
-fr_accepted_queue = "notifications.ingest.fr_accepted" # friend request accepted
-fr_received_queue = "notifications.ingest.fr_received" # friend request received
-generic_queue = "notifications.ingest.generic"         # generic messages (title + body)
-ack_queue = "notifications.process.ack"                # updates badges for apple devices
-
-[pushd.vapid]
-queue = "notifications.outbound.vapid"
-private_key = "LS0tLS1CRUdJTiBFQyBQUklWQVRFIEtFWS0tLS0tCk1IY0NBUUVFSUJSUWpyTWxLRnBiVWhsUHpUbERvcEliYk1yeVNrNXpKYzVYVzIxSjJDS3hvQW9HQ0NxR1NNNDkKQXdFSG9VUURRZ0FFWnkrQkg2TGJQZ2hEa3pEempXOG0rUXVPM3pCajRXT1phdkR6ZU00c0pqbmFwd1psTFE0WAp1ZDh2TzVodU94QWhMQlU3WWRldVovWHlBdFpWZmNyQi9BPT0KLS0tLS1FTkQgRUMgUFJJVkFURSBLRVktLS0tLQo"
-public_key = "BGcvgR-i2z4IQ5Mw841vJvkLjt8wY-FjmWrw83jOLCY52qcGZS0OF7nfLzuYbjsQISwVO2HXrmf18gLWVX3Kwfw="
-
-[pushd.fcm]
-queue = "notifications.outbound.fcm"
-key_type = ""
-project_id = ""
-private_key_id = ""
-private_key = ""
-client_email = ""
-client_id = ""
-auth_uri = ""
-token_uri = ""
-auth_provider_x509_cert_url = ""
-client_x509_cert_url = ""
-
-[pushd.apn]
-sandbox = false
-queue = "notifications.outbound.apn"
-pkcs8 = ""
-key_id = ""
-team_id = ""
-
-
-[files]
-# Encryption key for stored files
-# Generate your own key using `openssl rand -base64 32`
-encryption_key = "qcuMA+ssxhMyKaNAKBGFfryfFtUH8NDlamQyDwGW6fU="
-# Quality used for lossy WebP previews (set to 100 for lossless)
-webp_quality = 80.0
-# Mime types that cannot be uploaded or served
-#
-# Example for Windows executables and Android installation files:
-# ["application/vnd.microsoft.portable-executable", "application/vnd.android.package-archive"]
-blocked_mime_types = []
-# ClamAV service
-# hostname:port
-clamd_host = ""
-# Mime types that should be virus scanned
-#
-# Leave empty to scan all file types
-scan_mime_types = [
-    "application/vnd.microsoft.portable-executable",
-    "application/vnd.android.package-archive",
-    "application/zip",
-]
-
-[files.limit]
-# Minimum file size (in bytes)
-min_file_size = 1
-# Minimum image resolution
-min_resolution = [1, 1]
-# Maximum MP of images
-max_mega_pixels = 40
-# Maximum pixel side of an image
-max_pixel_side = 10_000
-
-[files.preview]
-# Maximum image resolution
-attachments = [1280, 1280]
-avatars = [128, 128]
-backgrounds = [1280, 720]
-icons = [128, 128]
-banners = [480, 480]
-emojis = [128, 128]
-
-[files.s3]
-# Configuration for S3
-# Defaults included for MinIO + self-hosted setup
-#
-# Backblaze B2:
-# - endpoint is listed on the "Buckets" page
-# - path_style_buckets is set to true
-# - region is `eu-central-003` string from endpoint URL
-# - access_key_id is keyID generated on the "Application Keys" page
-# - secret_access_key is token generated on the "Application Keys" page
-# - default_bucket matches the name of the bucket you've created
-
-# S3 protocol endpoint
-endpoint = "http://minio:9000"
-# Whether to use path-style buckets
-# Generally true, except for MinIO
-path_style_buckets = false
-# S3 region name
-region = "minio"
-# S3 protocol key ID
-access_key_id = "minioautumn"
-# S3 protocol access key
-secret_access_key = "minioautumn"
-default_bucket = "revolt-uploads"
-
-
-[features]
-# Bucket to upload to by default
-# Feature gate options
-webhooks_enabled = false
-
-[features.limits]
-
-[features.limits.global]
-group_size = 100
-message_embeds = 5
-message_replies = 5
-message_reactions = 20
-server_emoji = 100
-server_roles = 200
-server_channels = 200
-
-# How many hours since creation a user is considered new
-new_user_hours = 72
-
-# Maximum permissible body size in bytes for uploads
-# (should be greater than any one file upload limit)
-body_limit_size = 20_000_000
-
-[features.limits.new_user]
-# Limits imposed on new users
-
-# Number of outgoing friend requests permitted at any time
-outgoing_friend_requests = 5
-
-# Maximum number of owned bots
-bots = 2
-
-# Message content length
-message_length = 2000
-
-# Number of attachments that can be included
-message_attachments = 5
-
-# Maximum number of servers the user can create/join
-servers = 50
-
-[features.limits.new_user.file_upload_size_limit]
-# Maximum file size limits (in bytes)
-attachments = 20_000_000
-avatars = 4_000_000
-backgrounds = 6_000_000
-icons = 2_500_000
-banners = 6_000_000
-emojis = 500_000
-
-[features.limits.default]
-# Limits imposed on users by default
-
-# Number of outgoing friend requests permitted at any time
-outgoing_friend_requests = 10
-
-# Maximum number of owned bots
-bots = 5
-
-# Message content length
-message_length = 2000
-
-# Number of attachments that can be included
-message_attachments = 5
-
-# Maximum number of servers the user can create/join
-servers = 100
-
-[features.limits.default.file_upload_size_limit]
-# Maximum file size limits (in bytes)
-attachments = 20_000_000
-avatars = 4_000_000
-backgrounds = 6_000_000
-icons = 2_500_000
-banners = 6_000_000
-emojis = 500_000
-
-[features.advanced]
-# The max amount of messages the rabbitmq provider/db mention adder job will delay for before forcing handling of a channel.
-# default: 5
-process_message_delay_limit = 5
-
-[sentry]
-# Configuration for Sentry error reporting
-api = ""
-events = ""
-files = ""
-proxy = ""
-crond = ""
@@ -1,431 +0,0 @@
-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;
-
-pub use sentry::{capture_error, capture_message, Level};
-
-#[cfg(feature = "report-macros")]
-#[macro_export]
-macro_rules! report_error {
-    ( $expr: expr, $error: ident $( $tt:tt )? ) => {
-        $expr
-            .inspect_err(|err| {
-                $crate::capture_message(
-                    &format!("{err:?} ({}:{}:{})", file!(), line!(), column!()),
-                    $crate::Level::Error,
-                );
-            })
-            .map_err(|_| ::revolt_result::create_error!($error))
-    };
-}
-
-#[cfg(feature = "report-macros")]
-#[macro_export]
-macro_rules! capture_internal_error {
-    ( $expr: expr ) => {
-        $crate::capture_message(
-            &format!("{:?} ({}:{}:{})", $expr, file!(), line!(), column!()),
-            $crate::Level::Error,
-        );
-    };
-}
-
-#[cfg(feature = "report-macros")]
-#[macro_export]
-macro_rules! report_internal_error {
-    ( $expr: expr ) => {
-        $expr
-            .inspect_err(|err| {
-                $crate::capture_message(
-                    &format!("{err:?} ({}:{}:{})", file!(), line!(), column!()),
-                    $crate::Level::Error,
-                );
-            })
-            .map_err(|_| ::revolt_result::create_error!(InternalError))
-    };
-}
-
-/// Paths to search for configuration
-static CONFIG_SEARCH_PATHS: [&str; 3] = [
-    // current working directory
-    "Revolt.toml",
-    // current working directory - overrides file
-    "Revolt.overrides.toml",
-    // root directory, for Docker containers
-    "/Revolt.toml",
-];
-
-/// Configuration builder
-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,
-            ));
-        }
-
-        for path in CONFIG_SEARCH_PATHS {
-            if std::path::Path::new(path).exists() {
-                builder = builder.add_source(File::new(path, FileFormat::Toml));
-            }
-        }
-
-        builder.build().unwrap()
-    })
-});
-
-#[derive(Deserialize, Debug, Clone)]
-pub struct Database {
-    pub mongodb: String,
-    pub redis: String,
-}
-
-#[derive(Deserialize, Debug, Clone)]
-pub struct Rabbit {
-    pub host: String,
-    pub port: u16,
-    pub username: String,
-    pub password: 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 PushVapid {
-    pub queue: String,
-    pub private_key: String,
-    pub public_key: String,
-}
-
-#[derive(Deserialize, Debug, Clone)]
-pub struct PushFcm {
-    pub queue: String,
-    pub key_type: String,
-    pub project_id: String,
-    pub private_key_id: String,
-    pub private_key: String,
-    pub client_email: String,
-    pub client_id: String,
-    pub auth_uri: String,
-    pub token_uri: String,
-    pub auth_provider_x509_cert_url: String,
-    pub client_x509_cert_url: String,
-}
-
-#[derive(Deserialize, Debug, Clone)]
-pub struct PushApn {
-    pub queue: String,
-    pub sandbox: bool,
-    pub pkcs8: String,
-    pub key_id: String,
-    pub team_id: 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 security: ApiSecurity,
-    pub workers: ApiWorkers,
-}
-
-#[derive(Deserialize, Debug, Clone)]
-pub struct Pushd {
-    pub production: bool,
-    pub exchange: String,
-    pub message_queue: String,
-    pub fr_accepted_queue: String,
-    pub fr_received_queue: String,
-    pub generic_queue: String,
-    pub ack_queue: String,
-
-    pub vapid: PushVapid,
-    pub fcm: PushFcm,
-    pub apn: PushApn,
-}
-
-impl Pushd {
-    fn get_routing_key(&self, key: String) -> String {
-        match self.production {
-            true => key + "-prd",
-            false => key + "-tst",
-        }
-    }
-
-    pub fn get_ack_routing_key(&self) -> String {
-        self.get_routing_key(self.ack_queue.clone())
-    }
-
-    pub fn get_message_routing_key(&self) -> String {
-        self.get_routing_key(self.message_queue.clone())
-    }
-
-    pub fn get_fr_accepted_routing_key(&self) -> String {
-        self.get_routing_key(self.fr_accepted_queue.clone())
-    }
-
-    pub fn get_fr_received_routing_key(&self) -> String {
-        self.get_routing_key(self.fr_received_queue.clone())
-    }
-
-    pub fn get_generic_routing_key(&self) -> String {
-        self.get_routing_key(self.generic_queue.clone())
-    }
-}
-
-#[derive(Deserialize, Debug, Clone)]
-pub struct FilesLimit {
-    pub min_file_size: usize,
-    pub min_resolution: [usize; 2],
-    pub max_mega_pixels: usize,
-    pub max_pixel_side: usize,
-}
-
-#[derive(Deserialize, Debug, Clone)]
-pub struct FilesS3 {
-    pub endpoint: String,
-    pub path_style_buckets: bool,
-    pub region: String,
-    pub access_key_id: String,
-    pub secret_access_key: String,
-    pub default_bucket: String,
-}
-
-#[derive(Deserialize, Debug, Clone)]
-pub struct Files {
-    pub encryption_key: String,
-    pub webp_quality: f32,
-    pub blocked_mime_types: Vec<String>,
-    pub clamd_host: String,
-    pub scan_mime_types: Vec<String>,
-
-    pub limit: FilesLimit,
-    pub preview: HashMap<String, [usize; 2]>,
-    pub s3: FilesS3,
-}
-
-#[derive(Deserialize, Debug, Clone)]
-pub struct GlobalLimits {
-    pub group_size: usize,
-    pub message_embeds: usize,
-    pub message_replies: usize,
-    pub message_reactions: usize,
-    pub server_emoji: usize,
-    pub server_roles: usize,
-    pub server_channels: usize,
-
-    pub new_user_hours: usize,
-
-    pub body_limit_size: usize,
-}
-
-#[derive(Deserialize, Debug, Clone)]
-pub struct FeaturesLimits {
-    pub outgoing_friend_requests: usize,
-
-    pub bots: usize,
-    pub message_length: usize,
-    pub message_attachments: usize,
-    pub servers: usize,
-
-    pub file_upload_size_limit: HashMap<String, usize>,
-}
-
-#[derive(Deserialize, Debug, Clone)]
-pub struct FeaturesLimitsCollection {
-    pub global: GlobalLimits,
-
-    pub new_user: FeaturesLimits,
-    pub default: FeaturesLimits,
-
-    #[serde(flatten)]
-    pub roles: HashMap<String, FeaturesLimits>,
-}
-
-#[derive(Deserialize, Debug, Clone)]
-pub struct FeaturesAdvanced {
-    #[serde(default)]
-    pub process_message_delay_limit: u16,
-}
-
-impl Default for FeaturesAdvanced {
-    fn default() -> Self {
-        Self {
-            process_message_delay_limit: 5,
-        }
-    }
-}
-
-#[derive(Deserialize, Debug, Clone)]
-pub struct Features {
-    pub limits: FeaturesLimitsCollection,
-    pub webhooks_enabled: bool,
-    #[serde(default)]
-    pub advanced: FeaturesAdvanced,
-}
-
-#[derive(Deserialize, Debug, Clone)]
-pub struct Sentry {
-    pub api: String,
-    pub events: String,
-    pub files: String,
-    pub proxy: String,
-    pub crond: String,
-}
-
-#[derive(Deserialize, Debug, Clone)]
-pub struct Settings {
-    pub database: Database,
-    pub rabbit: Rabbit,
-    pub hosts: Hosts,
-    pub api: Api,
-    pub pushd: Pushd,
-    pub files: Files,
-    pub features: Features,
-    pub sentry: Sentry,
-    pub production: bool,
-}
-
-impl Settings {
-    pub fn preflight_checks(&self) {
-        if self.api.smtp.host.is_empty() {
-            log::warn!("No SMTP settings specified! Remember to configure email.");
-        }
-
-        if self.api.security.captcha.hcaptcha_key.is_empty() {
-            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 {
-    let mut config = read().await.try_deserialize::<Settings>().unwrap();
-
-    // auto-detect production nodes
-    if config.hosts.api.contains("https") && config.hosts.api.contains("revolt.chat") {
-        config.production = true;
-    }
-
-    config
-}
-
-/// Configure logging and common Rust variables
-pub async fn setup_logging(release: &'static str, dsn: String) -> Option<sentry::ClientInitGuard> {
-    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");
-    }
-
-    if std::env::var("REDIS_URL").is_err() {
-        // Configure redis-kiss library
-        let config = config().await;
-        std::env::set_var("REDIS_URI", config.database.redis);
-    }
-
-    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;
-    }
-}
@@ -1,102 +0,0 @@
-[package]
-name = "revolt-database"
-version = "0.8.3"
-edition = "2021"
-license = "AGPL-3.0-or-later"
-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"]
-
-# ... Other
-tasks = ["isahc", "linkify", "url-escape"]
-async-std-runtime = ["async-std"]
-rocket-impl = ["rocket", "schemars", "revolt_okapi", "revolt_rocket_okapi"]
-axum-impl = ["axum"]
-redis-is-patched = ["revolt-presence/redis-is-patched"]
-
-# Default Features
-default = ["mongodb", "async-std-runtime", "tasks"]
-
-[dependencies]
-# Core
-revolt-config = { version = "0.8.3", path = "../config", features = [
-    "report-macros",
-] }
-revolt-result = { version = "0.8.3", path = "../result" }
-revolt-models = { version = "0.8.3", path = "../models", features = [
-    "validator",
-] }
-revolt-presence = { version = "0.8.3", path = "../presence" }
-revolt-permissions = { version = "0.8.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"
-revolt_optional_struct = "0.2.0"
-serde = { version = "1", features = ["derive"] }
-iso8601-timestamp = { version = "0.2.10", features = ["serde", "bson"] }
-
-# Events
-redis-kiss = { version = "0.1.4" }
-
-# Database
-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"
-
-# Async
-async-std = { version = "1.8.0", features = ["attributes"], optional = true }
-
-# Axum Impl
-axum = { version = "0.7.5", optional = true }
-
-# Rocket Impl
-schemars = { version = "0.8.8", optional = true }
-rocket = { version = "0.5.1", default-features = false, features = [
-    "json",
-], optional = true }
-revolt_okapi = { version = "0.9.1", optional = true }
-revolt_rocket_okapi = { version = "0.10.0", optional = true }
-
-# Notifications
-fcm_v1 = "0.3.0"
-web-push = "0.10.0"
-revolt_a2 = { version = "0.10", default-features = false, features = ["ring"] }
-
-# Authifier
-authifier = { version = "1.0.9", features = ["rocket_impl"] }
-
-# RabbitMQ
-amqprs = { version = "1.7.0" }
@@ -1,28 +0,0 @@
-[
-  {
-    "_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__"]
-  }
-]
@@ -1,89 +0,0 @@
-[
-  {
-    "_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
-  }
-]
@@ -1,211 +0,0 @@
-use std::collections::HashSet;
-
-use crate::events::rabbit::*;
-use crate::User;
-use amqprs::channel::BasicPublishArguments;
-use amqprs::{channel::Channel, connection::Connection, error::Error as AMQPError};
-use amqprs::{BasicProperties, FieldTable};
-use revolt_models::v0::PushNotification;
-use revolt_presence::filter_online;
-
-use serde_json::to_string;
-
-#[derive(Clone)]
-pub struct AMQP {
-    #[allow(unused)]
-    connection: Connection,
-    channel: Channel,
-}
-
-impl AMQP {
-    pub fn new(connection: Connection, channel: Channel) -> AMQP {
-        AMQP {
-            connection,
-            channel,
-        }
-    }
-
-    pub async fn friend_request_accepted(
-        &self,
-        accepted_request_user: &User,
-        sent_request_user: &User,
-    ) -> Result<(), AMQPError> {
-        let config = revolt_config::config().await;
-        let payload = FRAcceptedPayload {
-            accepted_user: accepted_request_user.to_owned(),
-            user: sent_request_user.id.clone(),
-        };
-        let payload = to_string(&payload).unwrap();
-
-        debug!(
-            "Sending friend request accept payload on channel {}: {}",
-            config.pushd.get_fr_accepted_routing_key(),
-            payload
-        );
-        self.channel
-            .basic_publish(
-                BasicProperties::default()
-                    .with_content_type("application/json")
-                    .with_persistence(true)
-                    .finish(),
-                payload.into(),
-                BasicPublishArguments::new(
-                    &config.pushd.exchange,
-                    &config.pushd.get_fr_accepted_routing_key(),
-                ),
-            )
-            .await
-    }
-
-    pub async fn friend_request_received(
-        &self,
-        received_request_user: &User,
-        sent_request_user: &User,
-    ) -> Result<(), AMQPError> {
-        let config = revolt_config::config().await;
-        let payload = FRReceivedPayload {
-            from_user: sent_request_user.to_owned(),
-            user: received_request_user.id.clone(),
-        };
-        let payload = to_string(&payload).unwrap();
-
-        debug!(
-            "Sending friend request received payload on channel {}: {}",
-            config.pushd.get_fr_received_routing_key(),
-            payload
-        );
-
-        self.channel
-            .basic_publish(
-                BasicProperties::default()
-                    .with_content_type("application/json")
-                    .with_persistence(true)
-                    .finish(),
-                payload.into(),
-                BasicPublishArguments::new(
-                    &config.pushd.exchange,
-                    &config.pushd.get_fr_received_routing_key(),
-                ),
-            )
-            .await
-    }
-
-    pub async fn generic_message(
-        &self,
-        user: &User,
-        title: String,
-        body: String,
-        icon: Option<String>,
-    ) -> Result<(), AMQPError> {
-        let config = revolt_config::config().await;
-        let payload = GenericPayload {
-            title,
-            body,
-            icon,
-            user: user.to_owned(),
-        };
-        let payload = to_string(&payload).unwrap();
-
-        debug!(
-            "Sending generic payload on channel {}: {}",
-            config.pushd.get_generic_routing_key(),
-            payload
-        );
-
-        self.channel
-            .basic_publish(
-                BasicProperties::default()
-                    .with_content_type("application/json")
-                    .with_persistence(true)
-                    .finish(),
-                payload.into(),
-                BasicPublishArguments::new(
-                    &config.pushd.exchange,
-                    &config.pushd.get_generic_routing_key(),
-                ),
-            )
-            .await
-    }
-
-    pub async fn message_sent(
-        &self,
-        recipients: Vec<String>,
-        payload: PushNotification,
-    ) -> Result<(), AMQPError> {
-        if recipients.is_empty() {
-            return Ok(());
-        }
-
-        let config = revolt_config::config().await;
-
-        let online_ids = filter_online(&recipients).await;
-        let recipients = (&recipients.into_iter().collect::<HashSet<String>>() - &online_ids)
-            .into_iter()
-            .collect::<Vec<String>>();
-
-        let payload = MessageSentPayload {
-            notification: payload,
-            users: recipients,
-        };
-        let payload = to_string(&payload).unwrap();
-
-        debug!(
-            "Sending message payload on channel {}: {}",
-            config.pushd.get_message_routing_key(),
-            payload
-        );
-
-        self.channel
-            .basic_publish(
-                BasicProperties::default()
-                    .with_content_type("application/json")
-                    .with_persistence(true)
-                    .finish(),
-                payload.into(),
-                BasicPublishArguments::new(
-                    &config.pushd.exchange,
-                    &config.pushd.get_message_routing_key(),
-                ),
-            )
-            .await
-    }
-
-    pub async fn ack_message(
-        &self,
-        user_id: String,
-        channel_id: String,
-        message_id: String,
-    ) -> Result<(), AMQPError> {
-        let config = revolt_config::config().await;
-
-        let payload = AckPayload {
-            user_id: user_id.clone(),
-            channel_id: channel_id.clone(),
-            message_id,
-        };
-        let payload = to_string(&payload).unwrap();
-
-        info!(
-            "Sending ack payload on channel {}: {}",
-            config.pushd.ack_queue, payload
-        );
-
-        let mut headers = FieldTable::new();
-        headers.insert(
-            "x-deduplication-header".try_into().unwrap(),
-            format!("{}-{}", &user_id, &channel_id).into(),
-        );
-
-        self.channel
-            .basic_publish(
-                BasicProperties::default()
-                    .with_content_type("application/json")
-                    .with_persistence(true)
-                    //.with_headers(headers)
-                    .finish(),
-                payload.into(),
-                BasicPublishArguments::new(&config.pushd.exchange, &config.pushd.ack_queue),
-            )
-            .await
-    }
-}
@@ -1,2 +0,0 @@
-#[allow(clippy::module_inception)]
-pub mod amqp;
@@ -1,205 +0,0 @@
-mod mongodb;
-mod reference;
-
-use authifier::config::Captcha;
-use authifier::config::EmailVerificationConfig;
-use authifier::config::ResolveIp;
-use authifier::config::SMTPSettings;
-use authifier::config::Shield;
-use authifier::config::Template;
-use authifier::config::Templates;
-use authifier::Authifier;
-use rand::Rng;
-use revolt_config::config;
-
-pub use self::mongodb::*;
-pub use self::reference::*;
-
-/// Database information to use to create a client
-pub enum DatabaseInfo {
-    /// Auto-detect the database in use
-    Auto,
-    /// Auto-detect the database in use and create an empty testing database
-    Test(String),
-    /// Use the mock database
-    Reference,
-    /// Connect to MongoDB
-    MongoDb { uri: String, database_name: String },
-    /// Use existing MongoDB connection
-    MongoDbFromClient(::mongodb::Client, String),
-}
-
-/// Database
-#[derive(Clone)]
-pub enum Database {
-    /// Mock database
-    Reference(ReferenceDb),
-    /// MongoDB database
-    MongoDb(MongoDb),
-}
-
-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 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?
-                } else {
-                    DatabaseInfo::Reference.connect().await?
-                }
-            }
-            DatabaseInfo::Test(database_name) => {
-                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 => Database::Reference(Default::default()),
-            DatabaseInfo::MongoDb { uri, database_name } => {
-                let client = ::mongodb::Client::with_uri_str(uri)
-                    .await
-                    .map_err(|_| "Failed to init db connection.".to_string())?;
-
-                Database::MongoDb(MongoDb(client, database_name))
-            }
-            DatabaseInfo::MongoDbFromClient(client, database_name) => {
-                Database::MongoDb(MongoDb(client, database_name))
-            }
-        })
-    }
-}
-
-impl Database {
-    /// Create an Authifier reference
-    pub async fn to_authifier(self) -> Authifier {
-        let config = config().await;
-
-        let mut auth_config = authifier::Config {
-            email_verification: if !config.api.smtp.host.is_empty() {
-                EmailVerificationConfig::Enabled {
-                    smtp: SMTPSettings {
-                        from: config.api.smtp.from_address,
-                        host: config.api.smtp.host,
-                        username: config.api.smtp.username,
-                        password: config.api.smtp.password,
-                        reply_to: Some(
-                            config
-                                .api
-                                .smtp
-                                .reply_to
-                                .unwrap_or("support@revolt.chat".into()),
-                        ),
-                        port: config.api.smtp.port,
-                        use_tls: config.api.smtp.use_tls,
-                    },
-                    expiry: Default::default(),
-                    templates: if config.production {
-                        Templates {
-                            verify: Template {
-                                title: "Verify your Revolt account.".into(),
-                                text: include_str!("../../templates/verify.txt").into(),
-                                url: format!("{}/login/verify/", config.hosts.app),
-                                html: Some(include_str!("../../templates/verify.html").into()),
-                            },
-                            reset: Template {
-                                title: "Reset your Revolt password.".into(),
-                                text: include_str!("../../templates/reset.txt").into(),
-                                url: format!("{}/login/reset/", config.hosts.app),
-                                html: Some(include_str!("../../templates/reset.html").into()),
-                            },
-                            deletion: Template {
-                                title: "Confirm account deletion.".into(),
-                                text: include_str!("../../templates/deletion.txt").into(),
-                                url: format!("{}/delete/", config.hosts.app),
-                                html: Some(include_str!("../../templates/deletion.html").into()),
-                            },
-                            welcome: None,
-                        }
-                    } else {
-                        Templates {
-                            verify: Template {
-                                title: "Verify your account.".into(),
-                                text: include_str!("../../templates/verify.whitelabel.txt").into(),
-                                url: format!("{}/login/verify/", config.hosts.app),
-                                html: None,
-                            },
-                            reset: Template {
-                                title: "Reset your password.".into(),
-                                text: include_str!("../../templates/reset.whitelabel.txt").into(),
-                                url: format!("{}/login/reset/", config.hosts.app),
-                                html: None,
-                            },
-                            deletion: Template {
-                                title: "Confirm account deletion.".into(),
-                                text: include_str!("../../templates/deletion.whitelabel.txt").into(),
-                                url: format!("{}/delete/", config.hosts.app),
-                                html: None,
-                            },
-                            welcome: None,
-                        }
-                    },
-                }
-            } else {
-                EmailVerificationConfig::Disabled
-            },
-            ..Default::default()
-        };
-
-        auth_config.invite_only = config.api.registration.invite_only;
-
-        if !config.api.security.captcha.hcaptcha_key.is_empty() {
-            auth_config.captcha = Captcha::HCaptcha {
-                secret: config.api.security.captcha.hcaptcha_key,
-            };
-        }
-
-        if !config.api.security.authifier_shield_key.is_empty() {
-            auth_config.shield = Shield::Enabled {
-                api_key: config.api.security.authifier_shield_key,
-                strict: false,
-            };
-        }
-
-        if config.api.security.trust_cloudflare {
-            auth_config.resolve_ip = ResolveIp::Cloudflare;
-        }
-
-        Authifier {
-            database: match self {
-                Database::Reference(_) => Default::default(),
-                Database::MongoDb(MongoDb(client, _)) => authifier::Database::MongoDb(
-                    authifier::database::MongoDb(client.database("revolt")),
-                ),
-            },
-            config: auth_config,
-            event_channel: Some(crate::tasks::authifier_relay::sender()),
-        }
-    }
-}
@@ -1,33 +0,0 @@
-use std::{collections::HashMap, sync::Arc};
-
-use futures::lock::Mutex;
-
-use crate::{
-    Bot, Channel, ChannelCompositeKey, ChannelUnread, Emoji, File, FileHash, Invite, Member,
-    MemberCompositeKey, Message, RatelimitEvent, Report, Server, ServerBan, Snapshot, User,
-    UserSettings, Webhook,
-};
-
-database_derived!(
-    /// Reference implementation
-    #[derive(Default)]
-    pub struct ReferenceDb {
-        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 file_hashes: Arc<Mutex<HashMap<String, FileHash>>>,
-        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 safety_reports: Arc<Mutex<HashMap<String, Report>>>,
-        pub safety_snapshots: Arc<Mutex<HashMap<String, Snapshot>>>,
-    }
-);
@@ -1,59 +0,0 @@
-use std::collections::HashMap;
-
-use revolt_models::v0::PushNotification;
-use serde::{Deserialize, Serialize};
-
-use crate::User;
-
-#[derive(Serialize, Deserialize)]
-pub struct MessageSentPayload {
-    pub notification: PushNotification,
-    pub users: Vec<String>,
-}
-
-#[derive(Serialize, Deserialize, Clone)]
-pub struct FRAcceptedPayload {
-    pub accepted_user: User,
-    pub user: String,
-}
-
-#[derive(Serialize, Deserialize, Clone)]
-pub struct FRReceivedPayload {
-    pub from_user: User,
-    pub user: String,
-}
-
-#[derive(Serialize, Deserialize, Clone)]
-pub struct GenericPayload {
-    pub title: String,
-    pub body: String,
-    pub icon: Option<String>,
-    pub user: User,
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(tag = "type", content = "data")]
-#[allow(clippy::large_enum_variant)]
-pub enum PayloadKind {
-    MessageNotification(PushNotification),
-    FRAccepted(FRAcceptedPayload),
-    FRReceived(FRReceivedPayload),
-    BadgeUpdate(usize),
-    Generic(GenericPayload),
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct PayloadToService {
-    pub notification: PayloadKind,
-    pub user_id: String,
-    pub session_id: String,
-    pub token: String,
-    pub extras: HashMap<String, String>,
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct AckPayload {
-    pub user_id: String,
-    pub channel_id: String,
-    pub message_id: String,
-}
@@ -1,119 +0,0 @@
-#[macro_use]
-extern crate serde;
-
-#[macro_use]
-extern crate async_recursion;
-
-#[macro_use]
-extern crate async_trait;
-
-#[macro_use]
-extern crate log;
-
-#[macro_use]
-extern crate revolt_optional_struct;
-
-#[macro_use]
-extern crate revolt_result;
-
-pub use iso8601_timestamp;
-
-#[cfg(feature = "mongodb")]
-pub use mongodb;
-
-#[cfg(feature = "mongodb")]
-#[macro_use]
-extern crate bson;
-
-#[macro_export]
-#[cfg(debug_assertions)]
-macro_rules! query {
-    ( $self: ident, $type: ident, $collection: expr, $($rest:expr),+ ) => {
-        Ok($self.$type($collection, $($rest),+).await.unwrap())
-    };
-}
-
-#[macro_export]
-#[cfg(not(debug_assertions))]
-macro_rules! query {
-    ( $self: ident, $type: ident, $collection: expr, $($rest:expr),+ ) => {
-        $self.$type($collection, $($rest),+).await
-            .map_err(|err| {
-                revolt_config::capture_internal_error!(err);
-                create_database_error!(stringify!($type), $collection)
-            })
-    };
-}
-
-macro_rules! database_derived {
-    ( $( $item:item )+ ) => {
-        $(
-            #[derive(Clone)]
-            $item
-        )+
-    };
-}
-
-macro_rules! auto_derived {
-    ( $( $item:item )+ ) => {
-        $(
-            #[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
-            $item
-        )+
-    };
-}
-
-macro_rules! auto_derived_partial {
-    ( $item:item, $name:expr ) => {
-        #[derive(OptionalStruct, Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
-        #[optional_derive(Serialize, Deserialize, Debug, Clone, Default, Eq, PartialEq)]
-        #[optional_name = $name]
-        #[opt_skip_serializing_none]
-        #[opt_some_priority]
-        $item
-    };
-}
-
-mod drivers;
-pub use drivers::*;
-
-#[cfg(test)]
-macro_rules! database_test {
-    ( | $db: ident | $test:expr ) => {
-        let db = $crate::DatabaseInfo::Test(format!(
-            "{}:{}",
-            file!().replace('/', "_").replace(".rs", ""),
-            line!()
-        ))
-        .connect()
-        .await
-        .expect("Database connection failed.");
-
-        db.drop_database().await;
-
-        #[allow(clippy::redundant_closure_call)]
-        (|$db: $crate::Database| $test)(db.clone()).await;
-
-        db.drop_database().await
-    };
-}
-
-mod models;
-pub mod util;
-pub use models::*;
-
-pub mod events;
-pub mod tasks;
-
-mod amqp;
-pub use amqp::amqp::AMQP;
-
-/// Utility function to check if a boolean value is false
-pub fn if_false(t: &bool) -> bool {
-    !t
-}
-
-/// Utility function to check if an option doesnt contain true
-pub fn if_option_false(t: &Option<bool>) -> bool {
-    t != &Some(true)
-}
@@ -1,5 +0,0 @@
-mod model;
-mod ops;
-
-pub use model::*;
-pub use ops::*;
@@ -1,24 +0,0 @@
-auto_derived!(
-    /// Document representing migration information
-    pub struct MigrationInfo {
-        /// Unique Id
-        #[serde(rename = "_id")]
-        pub id: i32,
-        /// Current database revision
-        pub revision: i32,
-    }
-);
-
-#[cfg(test)]
-mod tests {
-    #[async_std::test]
-    async fn migrate() {
-        database_test!(|db| async move {
-            // Initialise the database
-            db.migrate_database().await.unwrap();
-
-            // Migrate the existing database
-            db.migrate_database().await.unwrap();
-        });
-    }
-}
@@ -1,12 +0,0 @@
-mod mongodb;
-mod reference;
-
-#[async_trait]
-pub trait AbstractMigrations: Sync + Send {
-    #[cfg(test)]
-    /// Drop the database
-    async fn drop_database(&self);
-
-    /// Migrate the database
-    async fn migrate_database(&self) -> Result<(), ()>;
-}
@@ -1,16 +0,0 @@
-use crate::ReferenceDb;
-
-use super::AbstractMigrations;
-
-#[async_trait]
-impl AbstractMigrations for ReferenceDb {
-    #[cfg(test)]
-    /// Drop the database
-    async fn drop_database(&self) {}
-
-    /// Migrate the database
-    async fn migrate_database(&self) -> Result<(), ()> {
-        // Here you would do your typical migrations if this was a real database.
-        Ok(())
-    }
-}
@@ -1,5 +0,0 @@
-mod model;
-mod ops;
-
-pub use model::*;
-pub use ops::*;
@@ -1,223 +0,0 @@
-use revolt_config::config;
-use revolt_result::Result;
-use ulid::Ulid;
-
-use crate::{events::client::EventV1, BotInformation, Database, PartialUser, User};
-
-auto_derived_partial!(
-    /// Bot
-    pub struct Bot {
-        /// Bot Id
-        ///
-        /// This equals the associated bot user's id.
-        #[serde(rename = "_id")]
-        pub id: String,
-        /// User Id of the bot owner
-        pub owner: String,
-        /// Token used to authenticate requests for this bot
-        pub token: String,
-        /// Whether the bot is public
-        /// (may be invited by anyone)
-        pub public: bool,
-
-        /// Whether to enable analytics
-        #[serde(skip_serializing_if = "crate::if_false", default)]
-        pub analytics: bool,
-        /// Whether this bot should be publicly discoverable
-        #[serde(skip_serializing_if = "crate::if_false", default)]
-        pub discoverable: bool,
-        /// Reserved; URL for handling interactions
-        #[serde(skip_serializing_if = "String::is_empty", default)]
-        pub interactions_url: String,
-        /// URL for terms of service
-        #[serde(skip_serializing_if = "String::is_empty", default)]
-        pub terms_of_service_url: String,
-        /// URL for privacy policy
-        #[serde(skip_serializing_if = "String::is_empty", default)]
-        pub privacy_policy_url: String,
-
-        /// Enum of bot flags
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub flags: Option<i32>,
-    },
-    "PartialBot"
-);
-
-auto_derived!(
-    /// Optional fields on bot object
-    pub enum FieldsBot {
-        Token,
-        InteractionsURL,
-    }
-);
-
-#[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, User)>
-    where
-        D: Into<Option<PartialBot>>,
-    {
-        if owner.bot.is_some() {
-            return Err(create_error!(IsBot));
-        }
-
-        if db.get_number_of_bots_by_user(&owner.id).await? >= owner.limits().await.bots {
-            return Err(create_error!(ReachedMaximumBots));
-        }
-
-        let id = Ulid::new().to_string();
-
-        let user = 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, user))
-    }
-
-    /// Remove a field from this object
-    pub fn remove_field(&mut self, field: &FieldsBot) {
-        match field {
-            FieldsBot::Token => self.token = nanoid::nanoid!(64),
-            FieldsBot::InteractionsURL => {
-                self.interactions_url = String::new();
-            }
-        }
-    }
-
-    /// Update this bot
-    pub async fn update(
-        &mut self,
-        db: &Database,
-        mut partial: PartialBot,
-        remove: Vec<FieldsBot>,
-    ) -> Result<()> {
-        if remove.contains(&FieldsBot::Token) {
-            partial.token = Some(nanoid::nanoid!(64));
-        }
-
-        for field in &remove {
-            self.remove_field(field);
-        }
-
-        db.update_bot(&self.id, &partial, remove).await?;
-
-        if partial.token.is_some() {
-            EventV1::Logout.private(self.id.clone()).await;
-        }
-
-        self.apply_options(partial);
-        Ok(())
-    }
-
-    /// Delete this bot
-    pub async fn delete(&self, db: &Database) -> Result<()> {
-        db.fetch_user(&self.id).await?.mark_deleted(db).await?;
-        db.delete_bot(&self.id).await
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::{Bot, FieldsBot, PartialBot, User};
-
-    #[async_std::test]
-    async fn crud() {
-        database_test!(|db| async move {
-            let owner = User::create(&db, "Owner".to_string(), None, None)
-                .await
-                .unwrap();
-
-            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();
-
-            assert!(!bot.interactions_url.is_empty());
-
-            let mut updated_bot = bot.clone();
-            updated_bot
-                .update(
-                    &db,
-                    PartialBot {
-                        public: Some(true),
-                        ..Default::default()
-                    },
-                    vec![FieldsBot::Token, FieldsBot::InteractionsURL],
-                )
-                .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(&owner.id).await.unwrap();
-
-            assert!(!bot.public);
-            assert!(fetched_bot1.public);
-            assert!(!bot.interactions_url.is_empty());
-            assert!(fetched_bot1.interactions_url.is_empty());
-            assert_ne!(bot.token, fetched_bot1.token);
-            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(&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(&owner.id).await.unwrap());
-            assert_eq!(db.fetch_user(&bot.id).await.unwrap().flags, Some(2))
-        });
-    }
-}
@@ -1,92 +0,0 @@
-use revolt_result::Result;
-
-use crate::{Bot, FieldsBot, PartialBot};
-use crate::{IntoDocumentPath, MongoDb};
-
-use super::AbstractBots;
-
-static COL: &str = "bots";
-
-#[async_trait]
-impl AbstractBots for MongoDb {
-    /// Insert new bot into the database
-    async fn insert_bot(&self, bot: &Bot) -> Result<()> {
-        query!(self, insert_one, COL, &bot).map(|_| ())
-    }
-
-    /// Fetch a bot by its id
-    async fn fetch_bot(&self, id: &str) -> Result<Bot> {
-        query!(self, find_one_by_id, COL, id)?.ok_or_else(|| create_error!(NotFound))
-    }
-
-    /// Fetch a bot by its token
-    async fn fetch_bot_by_token(&self, token: &str) -> Result<Bot> {
-        query!(
-            self,
-            find_one,
-            COL,
-            doc! {
-                "token": token
-            }
-        )?
-        .ok_or_else(|| create_error!(NotFound))
-    }
-
-    /// Fetch bots owned by a user
-    async fn fetch_bots_by_user(&self, user_id: &str) -> Result<Vec<Bot>> {
-        query!(
-            self,
-            find,
-            COL,
-            doc! {
-                "owner": user_id
-            }
-        )
-    }
-
-    /// Get the number of bots owned by a user
-    async fn get_number_of_bots_by_user(&self, user_id: &str) -> Result<usize> {
-        query!(
-            self,
-            count_documents,
-            COL,
-            doc! {
-                "owner": user_id
-            }
-        )
-        .map(|v| v as usize)
-    }
-
-    /// Update bot with new information
-    async fn update_bot(
-        &self,
-        id: &str,
-        partial: &PartialBot,
-        remove: Vec<FieldsBot>,
-    ) -> Result<()> {
-        query!(
-            self,
-            update_one_by_id,
-            COL,
-            id,
-            partial,
-            remove.iter().map(|x| x as &dyn IntoDocumentPath).collect(),
-            None
-        )
-        .map(|_| ())
-    }
-
-    /// Delete a bot from the database
-    async fn delete_bot(&self, id: &str) -> Result<()> {
-        query!(self, delete_one_by_id, COL, id).map(|_| ())
-    }
-}
-
-impl IntoDocumentPath for FieldsBot {
-    fn as_path(&self) -> Option<&'static str> {
-        match self {
-            FieldsBot::InteractionsURL => Some("interactions_url"),
-            FieldsBot::Token => None,
-        }
-    }
-}
@@ -1,82 +0,0 @@
-use revolt_result::Result;
-
-use crate::ReferenceDb;
-use crate::{Bot, FieldsBot, PartialBot};
-
-use super::AbstractBots;
-
-#[async_trait]
-impl AbstractBots for ReferenceDb {
-    /// Insert new bot into the database
-    async fn insert_bot(&self, bot: &Bot) -> Result<()> {
-        let mut bots = self.bots.lock().await;
-        if bots.contains_key(&bot.id) {
-            Err(create_database_error!("insert", "bot"))
-        } else {
-            bots.insert(bot.id.to_string(), bot.clone());
-            Ok(())
-        }
-    }
-
-    /// Fetch a bot by its id
-    async fn fetch_bot(&self, id: &str) -> Result<Bot> {
-        let bots = self.bots.lock().await;
-        bots.get(id).cloned().ok_or_else(|| create_error!(NotFound))
-    }
-
-    /// Fetch a bot by its token
-    async fn fetch_bot_by_token(&self, token: &str) -> Result<Bot> {
-        let bots = self.bots.lock().await;
-        bots.values()
-            .find(|bot| bot.token == token)
-            .cloned()
-            .ok_or_else(|| create_error!(NotFound))
-    }
-
-    /// Fetch bots owned by a user
-    async fn fetch_bots_by_user(&self, user_id: &str) -> Result<Vec<Bot>> {
-        let bots = self.bots.lock().await;
-        Ok(bots
-            .values()
-            .filter(|bot| bot.owner == user_id)
-            .cloned()
-            .collect())
-    }
-
-    /// Get the number of bots owned by a user
-    async fn get_number_of_bots_by_user(&self, user_id: &str) -> Result<usize> {
-        let bots = self.bots.lock().await;
-        Ok(bots.values().filter(|bot| bot.owner == user_id).count())
-    }
-
-    /// Update bot with new information
-    async fn update_bot(
-        &self,
-        id: &str,
-        partial: &PartialBot,
-        remove: Vec<FieldsBot>,
-    ) -> Result<()> {
-        let mut bots = self.bots.lock().await;
-        if let Some(bot) = bots.get_mut(id) {
-            for field in remove {
-                #[allow(clippy::disallowed_methods)]
-                bot.remove_field(&field);
-            }
-
-            bot.apply_options(partial.clone());
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-
-    /// Delete a bot from the database
-    async fn delete_bot(&self, id: &str) -> Result<()> {
-        let mut bots = self.bots.lock().await;
-        if bots.remove(id).is_some() {
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-}
@@ -1,5 +0,0 @@
-mod model;
-mod ops;
-
-pub use model::*;
-pub use ops::*;
@@ -1,50 +0,0 @@
-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(|_| ())
-    }
-}
@@ -1,52 +0,0 @@
-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))
-        }
-    }
-}
@@ -1,5 +0,0 @@
-mod model;
-mod ops;
-
-pub use model::*;
-pub use ops::*;
@@ -1,24 +0,0 @@
-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,
-    }
-);
@@ -1,37 +0,0 @@
-use revolt_result::Result;
-
-use crate::ChannelUnread;
-
-mod mongodb;
-mod reference;
-
-#[async_trait]
-pub trait AbstractChannelUnreads: Sync + Send {
-    /// Acknowledge a message, and returns updated channel unread.
-    async fn acknowledge_message(
-        &self,
-        channel_id: &str,
-        user_id: &str,
-        message_id: &str,
-    ) -> Result<Option<ChannelUnread>>;
-
-    /// 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 unreads with mentions for a user.
-    async fn fetch_unread_mentions(&self, user_id: &str) -> Result<Vec<ChannelUnread>>;
-
-    /// Fetch all channel unreads for a user.
-    async fn fetch_unreads(&self, user_id: &str) -> Result<Vec<ChannelUnread>>;
-
-    /// Fetch unread for a specific user in a channel.
-    async fn fetch_unread(&self, user_id: &str, channel_id: &str) -> Result<Option<ChannelUnread>>;
-}
@@ -1,150 +0,0 @@
-use bson::Document;
-use mongodb::options::FindOneAndUpdateOptions;
-use mongodb::options::ReturnDocument;
-use mongodb::options::UpdateOptions;
-use revolt_result::Result;
-use ulid::Ulid;
-
-use crate::ChannelUnread;
-use crate::MongoDb;
-
-use super::AbstractChannelUnreads;
-
-static COL: &str = "channel_unreads";
-
-#[async_trait]
-impl AbstractChannelUnreads for MongoDb {
-    /// Acknowledge a message, and returns updated channel unread.
-    async fn acknowledge_message(
-        &self,
-        channel_id: &str,
-        user_id: &str,
-        message_id: &str,
-    ) -> Result<Option<ChannelUnread>> {
-        self.col::<ChannelUnread>(COL)
-            .find_one_and_update(
-                doc! {
-                    "_id.channel": channel_id,
-                    "_id.user": user_id,
-                },
-                doc! {
-                    "$pull": {
-                        "mentions": {
-                            "$lte": message_id
-                        }
-                    },
-                    "$set": {
-                        "last_id": message_id
-                    }
-                },
-                FindOneAndUpdateOptions::builder()
-                    .upsert(true)
-                    .return_document(ReturnDocument::After)
-                    .build(),
-            )
-            .await
-            .map_err(|_| create_database_error!("update_one", COL))
-    }
-
-    /// Acknowledge many channels.
-    async fn acknowledge_channels(&self, user_id: &str, channel_ids: &[String]) -> Result<()> {
-        let current_time = Ulid::new().to_string();
-
-        self.col::<Document>(COL)
-            .delete_many(
-                doc! {
-                    "_id.channel": {
-                        "$in": channel_ids
-                    },
-                    "_id.user": user_id
-                },
-                None,
-            )
-            .await
-            .map_err(|_| create_database_error!("delete_many", COL))?;
-
-        self.col::<Document>(COL)
-            .insert_many(
-                channel_ids
-                    .iter()
-                    .map(|channel_id| {
-                        doc! {
-                            "_id": {
-                                "channel": channel_id,
-                                "user": user_id
-                            },
-                            "last_id": &current_time
-                        }
-                    })
-                    .collect::<Vec<Document>>(),
-                None,
-            )
-            .await
-            .map(|_| ())
-            .map_err(|_| create_database_error!("update_many", COL))
-    }
-
-    /// Add a mention.
-    async fn add_mention_to_unread<'a>(
-        &self,
-        channel_id: &str,
-        user_id: &str,
-        message_ids: &[String],
-    ) -> Result<()> {
-        self.col::<Document>(COL)
-            .update_one(
-                doc! {
-                    "_id.channel": channel_id,
-                    "_id.user": user_id,
-                },
-                doc! {
-                    "$push": {
-                        "mentions": {
-                            "$each": message_ids
-                        }
-                    }
-                },
-                UpdateOptions::builder().upsert(true).build(),
-            )
-            .await
-            .map(|_| ())
-            .map_err(|_| create_database_error!("update_one", COL))
-    }
-
-    /// Fetch all channel unreads for a user.
-    async fn fetch_unreads(&self, user_id: &str) -> Result<Vec<ChannelUnread>> {
-        query!(
-            self,
-            find,
-            COL,
-            doc! {
-                "_id.user": user_id
-            }
-        )
-    }
-
-    async fn fetch_unread_mentions(&self, user_id: &str) -> Result<Vec<ChannelUnread>> {
-        query! {
-            self,
-            find,
-            COL,
-            doc! {
-                "_id.user": user_id,
-                "mentions": {"$ne": null}
-            }
-        }
-    }
-
-    /// Fetch unread for a specific user in a channel.
-    async fn fetch_unread(&self, user_id: &str, channel_id: &str) -> Result<Option<ChannelUnread>> {
-        query!(
-            self,
-            find_one,
-            COL,
-            doc! {
-                "_id.user": user_id,
-                "_id.channel": channel_id
-            }
-        )
-    }
-}
@@ -1,111 +0,0 @@
-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<Option<ChannelUnread>> {
-        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.clone(),
-                    last_id: Some(message_id.to_string()),
-                    mentions: None,
-                },
-            );
-        }
-
-        Ok(unreads.get(&key).cloned())
-    }
-
-    /// 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(())
-    }
-
-    async fn fetch_unread_mentions(&self, user_id: &str) -> Result<Vec<ChannelUnread>> {
-        let unreads = self.channel_unreads.lock().await;
-        Ok(unreads
-            .values()
-            .filter(|unread| unread.id.user == user_id && unread.mentions.is_some())
-            .cloned()
-            .collect())
-    }
-
-    /// 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())
-    }
-
-    /// Fetch unread for a specific user in a channel.
-    async fn fetch_unread(&self, user_id: &str, channel_id: &str) -> Result<Option<ChannelUnread>> {
-        let unreads = self.channel_unreads.lock().await;
-
-        Ok(unreads
-            .get(&ChannelCompositeKey {
-                channel: channel_id.to_string(),
-                user: user_id.to_string(),
-            })
-            .cloned())
-    }
-}
@@ -1,5 +0,0 @@
-mod model;
-mod ops;
-
-pub use model::*;
-pub use ops::*;
@@ -1,179 +0,0 @@
-use revolt_result::Result;
-
-use crate::events::client::EventV1;
-use crate::{Database, File};
-
-auto_derived_partial!(
-    /// Webhook
-    pub struct Webhook {
-        /// Webhook Id
-        #[serde(rename = "_id")]
-        pub id: String,
-
-        /// The name of the webhook
-        pub name: String,
-
-        /// The avatar of the webhook
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub avatar: Option<File>,
-
-        /// User that created this webhook
-        pub creator_id: String,
-
-        /// 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>,
-    },
-    "PartialWebhook"
-);
-
-auto_derived!(
-    /// Optional fields on webhook object
-    pub enum FieldsWebhook {
-        Avatar,
-    }
-);
-
-#[allow(clippy::derivable_impls)]
-impl Default for Webhook {
-    fn default() -> Self {
-        Self {
-            id: Default::default(),
-            name: Default::default(),
-            avatar: None,
-            creator_id: Default::default(),
-            channel_id: Default::default(),
-            permissions: Default::default(),
-            token: Default::default(),
-        }
-    }
-}
-
-#[allow(clippy::disallowed_methods)]
-impl Webhook {
-    pub async fn create(&self, db: &Database) -> Result<()> {
-        db.insert_webhook(self).await?;
-
-        // Avoid leaking the token to people who receive the event
-        let mut webhook = self.clone();
-        webhook.token = None;
-
-        EventV1::WebhookCreate(webhook.into())
-            .p(self.channel_id.clone())
-            .await;
-
-        Ok(())
-    }
-
-    pub fn assert_token(&self, token: &str) -> Result<()> {
-        if self.token.as_deref() == Some(token) {
-            Ok(())
-        } else {
-            Err(create_error!(NotAuthenticated))
-        }
-    }
-
-    pub async fn update(
-        &mut self,
-        db: &Database,
-        mut partial: PartialWebhook,
-        remove: Vec<FieldsWebhook>,
-    ) -> Result<()> {
-        for field in &remove {
-            self.remove_field(field)
-        }
-
-        self.apply_options(partial.clone());
-
-        db.update_webhook(&self.id, &partial, &remove).await?;
-
-        partial.token = None; // Avoid leaking the token to people who receive the event
-
-        EventV1::WebhookUpdate {
-            id: self.id.clone(),
-            data: partial.into(),
-            remove: remove.into_iter().map(|v| v.into()).collect(),
-        }
-        .p(self.channel_id.clone())
-        .await;
-
-        Ok(())
-    }
-
-    pub fn remove_field(&mut self, field: &FieldsWebhook) {
-        match field {
-            FieldsWebhook::Avatar => self.avatar = None,
-        }
-    }
-
-    pub async fn delete(&self, db: &Database) -> Result<()> {
-        db.delete_webhook(&self.id).await?;
-
-        EventV1::WebhookDelete {
-            id: self.id.clone(),
-        }
-        .p(self.channel_id.clone())
-        .await;
-
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::{FieldsWebhook, PartialWebhook, Webhook};
-
-    #[async_std::test]
-    async fn crud() {
-        database_test!(|db| async move {
-            let webhook_id = "webhook";
-            let channel_id = "channel";
-
-            let webhook = Webhook {
-                id: webhook_id.to_string(),
-                name: "Webhook Name".to_string(),
-                channel_id: channel_id.to_string(),
-                avatar: None,
-                ..Default::default()
-            };
-
-            db.insert_webhook(&webhook).await.unwrap();
-
-            let mut updated_webhook = webhook.clone();
-            updated_webhook
-                .update(
-                    &db,
-                    PartialWebhook {
-                        name: Some("New Name".to_string()),
-                        ..Default::default()
-                    },
-                    vec![FieldsWebhook::Avatar],
-                )
-                .await
-                .unwrap();
-
-            let fetched_webhook = db.fetch_webhook(webhook_id).await.unwrap();
-            let fetched_webhooks = db.fetch_webhooks_for_channel(channel_id).await.unwrap();
-
-            assert_eq!(updated_webhook, fetched_webhook);
-            assert_ne!(webhook, fetched_webhook);
-            assert_eq!(1, fetched_webhooks.len());
-            assert_eq!(fetched_webhook, fetched_webhooks[0]);
-
-            webhook.delete(&db).await.unwrap();
-            assert!(db.fetch_webhook(webhook_id).await.is_err());
-            assert_eq!(
-                0,
-                db.fetch_webhooks_for_channel(channel_id)
-                    .await
-                    .unwrap()
-                    .len()
-            )
-        });
-    }
-}
@@ -1,29 +0,0 @@
-use revolt_result::Result;
-
-use crate::{FieldsWebhook, PartialWebhook, Webhook};
-
-mod mongodb;
-mod reference;
-
-#[async_trait]
-pub trait AbstractWebhooks: Sync + Send {
-    /// Insert new webhook into the database
-    async fn insert_webhook(&self, webhook: &Webhook) -> Result<()>;
-
-    /// Fetch webhook by id
-    async fn fetch_webhook(&self, webhook_id: &str) -> Result<Webhook>;
-
-    /// Fetch webhooks for channel
-    async fn fetch_webhooks_for_channel(&self, channel_id: &str) -> Result<Vec<Webhook>>;
-
-    /// Update webhook with new information
-    async fn update_webhook(
-        &self,
-        webhook_id: &str,
-        partial: &PartialWebhook,
-        remove: &[FieldsWebhook],
-    ) -> Result<()>;
-
-    /// Delete webhook by id
-    async fn delete_webhook(&self, webhook_id: &str) -> Result<()>;
-}
@@ -1,77 +0,0 @@
-use futures::StreamExt;
-use revolt_result::Result;
-
-use crate::{FieldsWebhook, PartialWebhook, Webhook};
-use crate::{IntoDocumentPath, MongoDb};
-
-use super::AbstractWebhooks;
-
-static COL: &str = "channel_webhooks";
-
-#[async_trait]
-impl AbstractWebhooks for MongoDb {
-    /// Insert new webhook into the database
-    async fn insert_webhook(&self, webhook: &Webhook) -> Result<()> {
-        query!(self, insert_one, COL, &webhook).map(|_| ())
-    }
-
-    /// Fetch webhook by id
-    async fn fetch_webhook(&self, webhook_id: &str) -> Result<Webhook> {
-        query!(self, find_one_by_id, COL, webhook_id)?.ok_or_else(|| create_error!(NotFound))
-    }
-
-    /// Fetch webhooks for channel
-    async fn fetch_webhooks_for_channel(&self, channel_id: &str) -> Result<Vec<Webhook>> {
-        Ok(self
-            .col::<Webhook>(COL)
-            .find(
-                doc! {
-                    "channel_id": channel_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 webhook with new information
-    async fn update_webhook(
-        &self,
-        webhook_id: &str,
-        partial: &PartialWebhook,
-        remove: &[FieldsWebhook],
-    ) -> Result<()> {
-        query!(
-            self,
-            update_one_by_id,
-            COL,
-            webhook_id,
-            partial,
-            remove.iter().map(|x| x as &dyn IntoDocumentPath).collect(),
-            None
-        )
-        .map(|_| ())
-    }
-
-    /// Delete webhook by id
-    async fn delete_webhook(&self, webhook_id: &str) -> Result<()> {
-        query!(self, delete_one_by_id, COL, webhook_id).map(|_| ())
-    }
-}
-
-impl IntoDocumentPath for FieldsWebhook {
-    fn as_path(&self) -> Option<&'static str> {
-        Some(match self {
-            FieldsWebhook::Avatar => "avatar",
-        })
-    }
-}
@@ -1,70 +0,0 @@
-use revolt_result::Result;
-
-use crate::ReferenceDb;
-use crate::{FieldsWebhook, PartialWebhook, Webhook};
-
-use super::AbstractWebhooks;
-
-#[async_trait]
-impl AbstractWebhooks for ReferenceDb {
-    /// Insert new webhook into the database
-    async fn insert_webhook(&self, webhook: &Webhook) -> Result<()> {
-        let mut webhooks = self.channel_webhooks.lock().await;
-        if webhooks.contains_key(&webhook.id) {
-            Err(create_database_error!("insert", "webhook"))
-        } else {
-            webhooks.insert(webhook.id.to_string(), webhook.clone());
-            Ok(())
-        }
-    }
-
-    /// Fetch webhook by id
-    async fn fetch_webhook(&self, webhook_id: &str) -> Result<Webhook> {
-        let webhooks = self.channel_webhooks.lock().await;
-        webhooks
-            .get(webhook_id)
-            .cloned()
-            .ok_or_else(|| create_error!(NotFound))
-    }
-
-    /// Fetch webhooks for channel
-    async fn fetch_webhooks_for_channel(&self, channel_id: &str) -> Result<Vec<Webhook>> {
-        let webhooks = self.channel_webhooks.lock().await;
-        Ok(webhooks
-            .values()
-            .filter(|webhook| webhook.channel_id == channel_id)
-            .cloned()
-            .collect())
-    }
-
-    /// Update webhook with new information
-    async fn update_webhook(
-        &self,
-        webhook_id: &str,
-        partial: &PartialWebhook,
-        remove: &[FieldsWebhook],
-    ) -> Result<()> {
-        let mut webhooks = self.channel_webhooks.lock().await;
-        if let Some(webhook) = webhooks.get_mut(webhook_id) {
-            for field in remove {
-                #[allow(clippy::disallowed_methods)]
-                webhook.remove_field(field);
-            }
-
-            webhook.apply_options(partial.clone());
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-
-    /// Delete webhook by id
-    async fn delete_webhook(&self, webhook_id: &str) -> Result<()> {
-        let mut webhooks = self.channel_webhooks.lock().await;
-        if webhooks.remove(webhook_id).is_some() {
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-}
@@ -1,5 +0,0 @@
-mod model;
-mod ops;
-
-pub use model::*;
-pub use ops::*;
@@ -1,831 +0,0 @@
-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, AMQP,
-};
-
-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.global.server_channels {
-            return Err(create_error!(TooManyChannels {
-                max: config.features.limits.global.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.global.group_size {
-            return Err(create_error!(GroupTooLarge {
-                max: config.features.limits.global.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,
-        amqp: &AMQP,
-        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.global.group_size {
-                return Err(create_error!(GroupTooLarge {
-                    max: config.features.limits.global.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,
-                    Some(amqp),
-                    MessageAuthor::System {
-                        username: &user.username,
-                        avatar: user.avatar.as_ref().map(|file| file.id.as_ref()),
-                    },
-                    None,
-                    None,
-                    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) -> &str {
-        match self {
-            Channel::DirectMessage { id, .. }
-            | Channel::Group { id, .. }
-            | Channel::SavedMessages { id, .. }
-            | Channel::TextChannel { id, .. }
-            | Channel::VoiceChannel { id, .. } => id,
-        }
-    }
-
-    /// 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_ack(
-            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,
-        amqp: &AMQP,
-        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,
-                            Some(amqp),
-                            MessageAuthor::System {
-                                username: name,
-                                avatar: None,
-                            },
-                            None,
-                            None,
-                            self,
-                            false,
-                        )
-                        .await
-                        .ok();
-                    } else {
-                        return self.delete(db).await;
-                    }
-                }
-
-                db.remove_user_from_group(id, &user.id).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,
-                        Some(amqp),
-                        MessageAuthor::System {
-                            username: &user.username,
-                            avatar: user.avatar.as_ref().map(|file| file.id.as_ref()),
-                        },
-                        None,
-                        None,
-                        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));
-        });
-    }
-}
@@ -1,50 +0,0 @@
-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<()>;
-}
@@ -1,157 +0,0 @@
-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().to_string()) {
-            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))
-        }
-    }
-}
@@ -1,5 +0,0 @@
-mod model;
-mod ops;
-
-pub use model::*;
-pub use ops::*;
@@ -1,67 +0,0 @@
-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))
-        }
-    }
-}
@@ -1,5 +0,0 @@
-mod model;
-mod ops;
-
-pub use model::*;
-pub use ops::*;
@@ -1,92 +0,0 @@
-use iso8601_timestamp::Timestamp;
-
-use crate::File;
-
-auto_derived_partial!(
-    /// File hash
-    pub struct FileHash {
-        /// Sha256 hash of the file
-        #[serde(rename = "_id")]
-        pub id: String,
-        /// Sha256 hash of file after it has been processed
-        pub processed_hash: String,
-
-        /// When this file was created in system
-        pub created_at: Timestamp,
-
-        /// The bucket this file is stored in
-        pub bucket_id: String,
-        /// The path at which this file exists in
-        pub path: String,
-        /// Cryptographic nonce used to encrypt this file
-        pub iv: String,
-
-        /// Parsed metadata of this file
-        pub metadata: Metadata,
-        /// Raw content type of this file
-        pub content_type: String,
-        /// Size of this file (in bytes)
-        pub size: isize,
-    },
-    "PartialFile"
-);
-
-auto_derived!(
-    /// Metadata associated with a file
-    #[serde(tag = "type")]
-    #[derive(Default)]
-    pub enum Metadata {
-        /// File is just a generic uncategorised file
-        #[default]
-        File,
-        /// File contains textual data and should be displayed as such
-        Text,
-        /// File is an image with specific dimensions
-        Image {
-            width: isize,
-            height: isize,
-            // animated: bool // TODO: https://docs.rs/image/latest/image/trait.AnimationDecoder.html for APNG support
-        },
-        /// File is a video with specific dimensions
-        Video { width: isize, height: isize },
-        /// File is audio
-        Audio,
-    }
-);
-
-impl FileHash {
-    /// Create a file from a file hash
-    pub fn into_file(
-        &self,
-        id: String,
-        tag: String,
-        filename: String,
-        uploader_id: String,
-    ) -> File {
-        File {
-            id,
-            tag,
-            filename,
-            hash: Some(self.id.clone()),
-
-            uploaded_at: Some(Timestamp::now_utc()),
-            uploader_id: Some(uploader_id),
-
-            used_for: None,
-
-            deleted: None,
-            reported: None,
-
-            // TODO: remove this data
-            metadata: self.metadata.clone(),
-            content_type: self.content_type.clone(),
-            size: self.size,
-
-            // TODO: superseded by "used_for"
-            message_id: None,
-            object_id: None,
-            server_id: None,
-            user_id: None,
-        }
-    }
-}
@@ -1,21 +0,0 @@
-use revolt_result::Result;
-
-use crate::FileHash;
-
-mod mongodb;
-mod reference;
-
-#[async_trait]
-pub trait AbstractAttachmentHashes: Sync + Send {
-    /// Insert a new attachment hash into the database.
-    async fn insert_attachment_hash(&self, hash: &FileHash) -> Result<()>;
-
-    /// Fetch an attachment hash entry by sha256 hash.
-    async fn fetch_attachment_hash(&self, hash: &str) -> Result<FileHash>;
-
-    /// Update an attachment hash nonce value.
-    async fn set_attachment_hash_nonce(&self, hash: &str, nonce: &str) -> Result<()>;
-
-    /// Delete attachment hash by id.
-    async fn delete_attachment_hash(&self, id: &str) -> Result<()>;
-}
@@ -1,56 +0,0 @@
-use revolt_result::Result;
-
-use crate::FileHash;
-use crate::MongoDb;
-
-use super::AbstractAttachmentHashes;
-
-static COL: &str = "attachment_hashes";
-
-#[async_trait]
-impl AbstractAttachmentHashes for MongoDb {
-    /// Insert a new attachment hash into the database.
-    async fn insert_attachment_hash(&self, hash: &FileHash) -> Result<()> {
-        query!(self, insert_one, COL, &hash).map(|_| ())
-    }
-
-    /// Fetch an attachment hash entry by sha256 hash.
-    async fn fetch_attachment_hash(&self, hash: &str) -> Result<FileHash> {
-        query!(
-            self,
-            find_one,
-            COL,
-            doc! {
-                "$or": [
-                    {"_id": hash},
-                    {"processed_hash": hash}
-                ]
-            }
-        )?
-        .ok_or_else(|| create_error!(NotFound))
-    }
-
-    /// Update an attachment hash nonce value.
-    async fn set_attachment_hash_nonce(&self, hash: &str, nonce: &str) -> Result<()> {
-        self.col::<FileHash>(COL)
-            .update_one(
-                doc! {
-                    "_id": hash
-                },
-                doc! {
-                    "$set": {
-                        "iv": nonce
-                    }
-                },
-                None,
-            )
-            .await
-            .map(|_| ())
-            .map_err(|_| create_database_error!("update_one", COL))
-    }
-
-    /// Delete attachment hash by id.
-    async fn delete_attachment_hash(&self, id: &str) -> Result<()> {
-        query!(self, delete_one_by_id, COL, id).map(|_| ())
-    }
-}
@@ -1,51 +0,0 @@
-use revolt_result::Result;
-
-use crate::FileHash;
-use crate::ReferenceDb;
-
-use super::AbstractAttachmentHashes;
-
-#[async_trait]
-impl AbstractAttachmentHashes for ReferenceDb {
-    /// Insert a new attachment hash into the database.
-    async fn insert_attachment_hash(&self, hash: &FileHash) -> Result<()> {
-        let mut hashes = self.file_hashes.lock().await;
-        if hashes.contains_key(&hash.id) {
-            Err(create_database_error!("insert", "attachment"))
-        } else {
-            hashes.insert(hash.id.to_string(), hash.clone());
-            Ok(())
-        }
-    }
-
-    /// Fetch an attachment hash entry by sha256 hash.
-    async fn fetch_attachment_hash(&self, hash_value: &str) -> Result<FileHash> {
-        let hashes = self.file_hashes.lock().await;
-        hashes
-            .values()
-            .find(|&hash| hash.id == hash_value || hash.processed_hash == hash_value)
-            .cloned()
-            .ok_or(create_error!(NotFound))
-    }
-
-    /// Update an attachment hash nonce value.
-    async fn set_attachment_hash_nonce(&self, hash: &str, nonce: &str) -> Result<()> {
-        let mut hashes = self.file_hashes.lock().await;
-        if let Some(file) = hashes.get_mut(hash) {
-            file.iv = nonce.to_owned();
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-
-    /// Delete attachment hash by id.
-    async fn delete_attachment_hash(&self, id: &str) -> Result<()> {
-        let mut file_hashes = self.file_hashes.lock().await;
-        if file_hashes.remove(id).is_some() {
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-}
@@ -1,5 +0,0 @@
-mod model;
-mod ops;
-
-pub use model::*;
-pub use ops::*;
@@ -1,242 +0,0 @@
-use crate::{Database, FileHash, Metadata};
-
-use iso8601_timestamp::Timestamp;
-use revolt_result::Result;
-
-auto_derived_partial!(
-    /// File
-    pub struct File {
-        /// Unique Id
-        #[serde(rename = "_id")]
-        pub id: String,
-        /// Tag / bucket this file was uploaded to
-        pub tag: String,
-        /// Original filename
-        pub filename: String,
-        /// Hash of this file
-        pub hash: Option<String>, // these are Option<>s to not break file uploads on legacy Autumn
-
-        /// When this file was uploaded
-        pub uploaded_at: Option<Timestamp>, // these are Option<>s to not break file uploads on legacy Autumn
-        /// ID of user who uploaded this file
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub uploader_id: Option<String>, // these are Option<>s to not break file uploads on legacy Autumn
-
-        /// What the file was used for
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub used_for: Option<FileUsedFor>,
-
-        /// Whether this file was deleted
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub deleted: Option<bool>,
-        /// Whether this file was reported
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub reported: Option<bool>,
-
-        // !!! DEPRECATED:
-        /// Parsed metadata of this file
-        pub metadata: Metadata,
-        /// Raw content type of this file
-        pub content_type: String,
-        /// Size of this file (in bytes)
-        pub size: isize,
-
-        // TODO: migrate this mess to having:
-        // - author_id
-        // - parent: Parent { Message(id), User(id), etc }
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub message_id: Option<String>,
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub user_id: Option<String>,
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub server_id: Option<String>,
-
-        /// Id of the object this file is associated with
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub object_id: Option<String>,
-    },
-    "PartialFile"
-);
-
-auto_derived!(
-    /// Type of object file was used for
-    pub enum FileUsedForType {
-        Message,
-        ServerBanner,
-        Emoji,
-        UserAvatar,
-        WebhookAvatar,
-        UserProfileBackground,
-        LegacyGroupIcon,
-        ChannelIcon,
-        ServerIcon,
-    }
-
-    /// Information about what the file was used for
-    pub struct FileUsedFor {
-        /// Type of the object
-        #[serde(rename = "type")]
-        pub object_type: FileUsedForType,
-        /// ID of the object
-        pub id: String,
-    }
-);
-
-impl File {
-    /// Get the hash entry for this file
-    pub async fn as_hash(&self, db: &Database) -> Result<FileHash> {
-        db.fetch_attachment_hash(self.hash.as_ref().unwrap()).await
-    }
-
-    /// Use a file for a message attachment
-    pub async fn use_attachment(
-        db: &Database,
-        id: &str,
-        parent: &str,
-        uploader_id: &str,
-    ) -> Result<File> {
-        db.find_and_use_attachment(
-            id,
-            "attachments",
-            FileUsedFor {
-                id: parent.to_owned(),
-                object_type: FileUsedForType::Message,
-            },
-            uploader_id.to_owned(),
-        )
-        .await
-    }
-
-    /// Use a file for a user profile background
-    pub async fn use_background(
-        db: &Database,
-        id: &str,
-        parent: &str,
-        uploader_id: &str,
-    ) -> Result<File> {
-        db.find_and_use_attachment(
-            id,
-            "backgrounds",
-            FileUsedFor {
-                id: parent.to_owned(),
-                object_type: FileUsedForType::UserProfileBackground,
-            },
-            uploader_id.to_owned(),
-        )
-        .await
-    }
-
-    /// Use a file for a user avatar
-    pub async fn use_user_avatar(
-        db: &Database,
-        id: &str,
-        parent: &str,
-        uploader_id: &str,
-    ) -> Result<File> {
-        db.find_and_use_attachment(
-            id,
-            "avatars",
-            FileUsedFor {
-                id: parent.to_owned(),
-                object_type: FileUsedForType::UserAvatar,
-            },
-            uploader_id.to_owned(),
-        )
-        .await
-    }
-
-    /// Use a file for a webhook avatar
-    pub async fn use_webhook_avatar(
-        db: &Database,
-        id: &str,
-        parent: &str,
-        uploader_id: &str,
-    ) -> Result<File> {
-        db.find_and_use_attachment(
-            id,
-            "avatars",
-            FileUsedFor {
-                id: parent.to_owned(),
-                object_type: FileUsedForType::WebhookAvatar,
-            },
-            uploader_id.to_owned(),
-        )
-        .await
-    }
-
-    /// Use a file for a server icon
-    pub async fn use_server_icon(
-        db: &Database,
-        id: &str,
-        parent: &str,
-        uploader_id: &str,
-    ) -> Result<File> {
-        db.find_and_use_attachment(
-            id,
-            "icons",
-            FileUsedFor {
-                id: parent.to_owned(),
-                object_type: FileUsedForType::ServerIcon,
-            },
-            uploader_id.to_owned(),
-        )
-        .await
-    }
-
-    /// Use a file for a channel icon
-    pub async fn use_channel_icon(
-        db: &Database,
-        id: &str,
-        parent: &str,
-        uploader_id: &str,
-    ) -> Result<File> {
-        db.find_and_use_attachment(
-            id,
-            "icons",
-            FileUsedFor {
-                id: parent.to_owned(),
-                object_type: FileUsedForType::ChannelIcon,
-            },
-            uploader_id.to_owned(),
-        )
-        .await
-    }
-
-    /// Use a file for a server banner
-    pub async fn use_server_banner(
-        db: &Database,
-        id: &str,
-        parent: &str,
-        uploader_id: &str,
-    ) -> Result<File> {
-        db.find_and_use_attachment(
-            id,
-            "banners",
-            FileUsedFor {
-                id: parent.to_owned(),
-                object_type: FileUsedForType::ServerBanner,
-            },
-            uploader_id.to_owned(),
-        )
-        .await
-    }
-
-    /// Use a file for an emoji
-    pub async fn use_emoji(
-        db: &Database,
-        id: &str,
-        parent: &str,
-        uploader_id: &str,
-    ) -> Result<File> {
-        db.find_and_use_attachment(
-            id,
-            "emojis",
-            FileUsedFor {
-                id: parent.to_owned(),
-                object_type: FileUsedForType::Emoji,
-            },
-            uploader_id.to_owned(),
-        )
-        .await
-    }
-}
@@ -1,47 +0,0 @@
-use revolt_result::Result;
-
-use crate::File;
-
-use super::FileUsedFor;
-
-mod mongodb;
-mod reference;
-
-#[async_trait]
-pub trait AbstractAttachments: Sync + Send {
-    /// Insert attachment into database.
-    async fn insert_attachment(&self, attachment: &File) -> Result<()>;
-
-    /// Fetch an attachment by its id.
-    async fn fetch_attachment(&self, tag: &str, file_id: &str) -> Result<File>;
-
-    /// Fetch all deleted attachments.
-    async fn fetch_deleted_attachments(&self) -> Result<Vec<File>>;
-
-    /// Fetch all dangling attachments.
-    async fn fetch_dangling_files(&self) -> Result<Vec<File>>;
-
-    /// Count references to a given hash.
-    async fn count_file_hash_references(&self, hash: &str) -> Result<usize>;
-
-    /// Find an attachment by its details and mark it as used by a given parent.
-    async fn find_and_use_attachment(
-        &self,
-        id: &str,
-        tag: &str,
-        used_for: FileUsedFor,
-        uploader_id: String,
-    ) -> Result<File>;
-
-    /// Mark an attachment as having been reported.
-    async fn mark_attachment_as_reported(&self, id: &str) -> Result<()>;
-
-    /// Mark an attachment as having been deleted.
-    async fn mark_attachment_as_deleted(&self, id: &str) -> Result<()>;
-
-    /// Mark multiple attachments as having been deleted.
-    async fn mark_attachments_as_deleted(&self, ids: &[String]) -> Result<()>;
-
-    /// Delete the attachment entry.
-    async fn delete_attachment(&self, id: &str) -> Result<()>;
-}
@@ -1,202 +0,0 @@
-use bson::to_document;
-use bson::Document;
-use revolt_config::report_internal_error;
-use revolt_result::Result;
-
-use crate::File;
-use crate::FileUsedFor;
-use crate::MongoDb;
-
-use super::AbstractAttachments;
-
-static COL: &str = "attachments";
-
-#[async_trait]
-impl AbstractAttachments for MongoDb {
-    /// Insert attachment into database.
-    async fn insert_attachment(&self, attachment: &File) -> Result<()> {
-        query!(self, insert_one, COL, &attachment).map(|_| ())
-    }
-
-    /// Fetch an attachment by its id.
-    async fn fetch_attachment(&self, tag: &str, file_id: &str) -> Result<File> {
-        query!(
-            self,
-            find_one,
-            COL,
-            doc! {
-                "_id": file_id,
-                "tag": tag
-            }
-        )?
-        .ok_or_else(|| create_error!(NotFound))
-    }
-
-    /// Fetch all deleted attachments.
-    async fn fetch_deleted_attachments(&self) -> Result<Vec<File>> {
-        query!(
-            self,
-            find,
-            COL,
-            doc! {
-                "deleted": true,
-                "reported": {
-                    "$ne": true
-                }
-            }
-        )
-    }
-
-    /// Fetch all dangling attachments.
-    async fn fetch_dangling_files(&self) -> Result<Vec<File>> {
-        query!(
-            self,
-            find,
-            COL,
-            doc! {
-                "used_for.type": {
-                    "$exists": 0
-                },
-                "deleted": {
-                    "$ne": true
-                }
-            }
-        )
-    }
-
-    /// Count references to a given hash.
-    async fn count_file_hash_references(&self, hash: &str) -> Result<usize> {
-        query!(
-            self,
-            count_documents,
-            COL,
-            doc! {
-                "hash": hash
-            }
-        )
-        .map(|count| count as usize)
-    }
-
-    /// Find an attachment by its details and mark it as used by a given parent.
-    async fn find_and_use_attachment(
-        &self,
-        id: &str,
-        tag: &str,
-        used_for: FileUsedFor,
-        uploader_id: String,
-    ) -> Result<File> {
-        let file = query!(
-            self,
-            find_one,
-            COL,
-            doc! {
-                "_id": id,
-                "tag": tag,
-                "used_for": {
-                    "$exists": false
-                }
-            }
-        )?
-        .ok_or_else(|| create_error!(NotFound))?;
-
-        self.col::<Document>(COL)
-            .update_one(
-                doc! {
-                    "_id": id
-                },
-                doc! {
-                    "$set": {
-                        "used_for": report_internal_error!(to_document(&used_for))?,
-                        "uploader_id": uploader_id
-                    }
-                },
-                None,
-            )
-            .await
-            .map_err(|_| create_database_error!("update_one", COL))?;
-
-        Ok(file)
-    }
-
-    /// Mark an attachment as having been reported.
-    async fn mark_attachment_as_reported(&self, id: &str) -> Result<()> {
-        self.col::<Document>(COL)
-            .update_one(
-                doc! {
-                    "_id": id
-                },
-                doc! {
-                    "$set": {
-                        "reported": true
-                    }
-                },
-                None,
-            )
-            .await
-            .map(|_| ())
-            .map_err(|_| create_database_error!("update_one", COL))
-    }
-
-    /// Mark an attachment as having been deleted.
-    async fn mark_attachment_as_deleted(&self, id: &str) -> Result<()> {
-        self.col::<Document>(COL)
-            .update_one(
-                doc! {
-                    "_id": id
-                },
-                doc! {
-                    "$set": {
-                        "deleted": true
-                    }
-                },
-                None,
-            )
-            .await
-            .map(|_| ())
-            .map_err(|_| create_database_error!("update_one", COL))
-    }
-
-    /// Mark multiple attachments as having been deleted.
-    async fn mark_attachments_as_deleted(&self, ids: &[String]) -> Result<()> {
-        self.col::<Document>(COL)
-            .update_many(
-                doc! {
-                    "_id": {
-                        "$in": ids
-                    }
-                },
-                doc! {
-                    "$set": {
-                        "deleted": true
-                    }
-                },
-                None,
-            )
-            .await
-            .map(|_| ())
-            .map_err(|_| create_database_error!("update_many", COL))
-    }
-
-    /// Delete the attachment entry.
-    async fn delete_attachment(&self, id: &str) -> Result<()> {
-        query!(self, delete_one_by_id, COL, id).map(|_| ())
-    }
-}
-
-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))
-    }
-}
@@ -1,144 +0,0 @@
-use revolt_result::Result;
-
-use crate::File;
-use crate::FileUsedFor;
-use crate::ReferenceDb;
-
-use super::AbstractAttachments;
-
-#[async_trait]
-impl AbstractAttachments for ReferenceDb {
-    /// Insert attachment into database.
-    async fn insert_attachment(&self, attachment: &File) -> Result<()> {
-        let mut attachments = self.files.lock().await;
-        if attachments.contains_key(&attachment.id) {
-            Err(create_database_error!("insert", "attachment"))
-        } else {
-            attachments.insert(attachment.id.to_string(), attachment.clone());
-            Ok(())
-        }
-    }
-
-    /// Fetch an attachment by its id.
-    async fn fetch_attachment(&self, tag: &str, file_id: &str) -> Result<File> {
-        let files = self.files.lock().await;
-        if let Some(file) = files.get(file_id) {
-            if file.tag == tag {
-                Ok(file.clone())
-            } else {
-                Err(create_error!(NotFound))
-            }
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-
-    /// Fetch all deleted attachments.
-    async fn fetch_deleted_attachments(&self) -> Result<Vec<File>> {
-        let files = self.files.lock().await;
-        Ok(files
-            .values()
-            .filter(|file| {
-                // file has been marked as deleted
-                file.deleted.is_some_and(|v| v)
-                    // and it has not been reported
-                    && !file.reported.is_some_and(|v| v)
-            })
-            .cloned()
-            .collect())
-    }
-
-    /// Fetch all dangling attachments.
-    async fn fetch_dangling_files(&self) -> Result<Vec<File>> {
-        let files = self.files.lock().await;
-        Ok(files
-            .values()
-            .filter(|file| file.used_for.is_none() && !file.deleted.is_some_and(|v| v))
-            .cloned()
-            .collect())
-    }
-
-    /// Count references to a given hash.
-    async fn count_file_hash_references(&self, hash: &str) -> Result<usize> {
-        let files = self.files.lock().await;
-        Ok(files
-            .values()
-            .filter(|file| file.hash.as_ref().is_some_and(|h| h == hash))
-            .cloned()
-            .count())
-    }
-
-    /// Find an attachment by its details and mark it as used by a given parent.
-    async fn find_and_use_attachment(
-        &self,
-        id: &str,
-        tag: &str,
-        used_for: FileUsedFor,
-        uploader_id: String,
-    ) -> Result<File> {
-        let mut files = self.files.lock().await;
-        if let Some(file) = files.get_mut(id) {
-            if file.tag == tag {
-                file.uploader_id = Some(uploader_id);
-                file.used_for = Some(used_for);
-
-                Ok(file.clone())
-            } else {
-                Err(create_error!(NotFound))
-            }
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-
-    /// Mark an attachment as having been reported.
-    async fn mark_attachment_as_reported(&self, id: &str) -> Result<()> {
-        let mut files = self.files.lock().await;
-        if let Some(file) = files.get_mut(id) {
-            file.reported = Some(true);
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-
-    /// Mark an attachment as having been deleted.
-    async fn mark_attachment_as_deleted(&self, id: &str) -> Result<()> {
-        let mut files = self.files.lock().await;
-        if let Some(file) = files.get_mut(id) {
-            file.deleted = Some(true);
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-
-    /// Mark multiple attachments as having been deleted.
-    async fn mark_attachments_as_deleted(&self, ids: &[String]) -> Result<()> {
-        let mut files = self.files.lock().await;
-
-        for id in ids {
-            if !files.contains_key(id) {
-                return Err(create_error!(NotFound));
-            }
-        }
-
-        for id in ids {
-            if let Some(file) = files.get_mut(id) {
-                file.reported = Some(true);
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Delete the attachment entry.
-    async fn delete_attachment(&self, id: &str) -> Result<()> {
-        let mut files = self.files.lock().await;
-        if files.remove(id).is_some() {
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-}
@@ -1,5 +0,0 @@
-mod model;
-mod ops;
-
-pub use model::*;
-pub use ops::*;
@@ -1,950 +0,0 @@
-use std::{collections::HashSet, hash::RandomState};
-
-use indexmap::{IndexMap, IndexSet};
-use iso8601_timestamp::Timestamp;
-use revolt_config::{config, FeaturesLimits};
-use revolt_models::v0::{
-    self, BulkMessageResponse, DataMessageSend, Embed, MessageAuthor, MessageFlags, 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::{bulk_permissions::BulkDatabasePermissionQuery, idempotency::IdempotencyKey},
-    Channel, Database, Emoji, File, User, AMQP,
-};
-
-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>,
-        /// Whether or not the message in pinned
-        #[serde(skip_serializing_if = "crate::if_option_false")]
-        pub pinned: Option<bool>,
-
-        /// Bitfield of message flags
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub flags: Option<i32>,
-    },
-    "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 },
-        #[serde(rename = "message_pinned")]
-        MessagePinned { id: String, by: String },
-        #[serde(rename = "message_unpinned")]
-        MessageUnpinned { id: String, by: 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>,
-        /// Search for pinned
-        pub pinned: Option<bool>,
-    }
-
-    /// 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,
-    }
-
-    /// Optional fields on message
-    pub enum FieldsMessage {
-        Pinned,
-    }
-);
-
-#[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,
-            flags: None,
-            pinned: None,
-        }
-    }
-}
-
-#[allow(clippy::disallowed_methods)]
-impl Message {
-    /// Create message from API data
-    #[allow(clippy::too_many_arguments)]
-    pub async fn create_from_api(
-        db: &Database,
-        amqp: Option<&AMQP>,
-        channel: Channel,
-        data: DataMessageSend,
-        author: MessageAuthor<'_>,
-        user: Option<v0::User>,
-        member: Option<v0::Member>,
-        limits: FeaturesLimits,
-        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(),
-            limits.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 flags are either not set or have permissible values
-        if let Some(flags) = &data.flags {
-            if flags != &0 && flags != &1 {
-                return Err(create_error!(InvalidProperty));
-            }
-        }
-
-        // 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().to_string(),
-            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()),
-            flags: data.flags.map(|v| v as i32),
-            ..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.global.message_replies {
-                return Err(create_error!(TooManyReplies {
-                    max: config.features.limits.global.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);
-            }
-        }
-
-        // Validate the mentions go to users in the channel/server
-        if !mentions.is_empty() {
-            match channel {
-                Channel::DirectMessage { ref recipients, .. }
-                | Channel::Group { ref recipients, .. } => {
-                    let recipients_hash: HashSet<&String, RandomState> =
-                        HashSet::from_iter(recipients);
-                    mentions.retain(|m| recipients_hash.contains(m));
-                }
-                Channel::TextChannel { ref server, .. }
-                | Channel::VoiceChannel { ref server, .. } => {
-                    let mentions_vec = Vec::from_iter(mentions.iter().cloned());
-
-                    let valid_members = db.fetch_members(server.as_str(), &mentions_vec[..]).await;
-                    if let Ok(valid_members) = valid_members {
-                        let valid_mentions: HashSet<&String, RandomState> =
-                            HashSet::from_iter(valid_members.iter().map(|m| &m.id.user));
-
-                        mentions.retain(|m| valid_mentions.contains(m)); // quick pass, validate mentions are in the server
-
-                        if !mentions.is_empty() {
-                            // if there are still mentions, drill down to a channel-level
-                            let member_channel_view_perms =
-                                BulkDatabasePermissionQuery::from_server_id(db, server)
-                                    .await
-                                    .channel(&channel)
-                                    .members(&valid_members)
-                                    .members_can_see_channel()
-                                    .await;
-
-                            mentions
-                                .retain(|m| *member_channel_view_perms.get(m).unwrap_or(&false));
-                        }
-                    } else {
-                        revolt_config::capture_error(&valid_members.unwrap_err());
-                        return Err(create_error!(InternalError));
-                    }
-                }
-                Channel::SavedMessages { .. } => {
-                    mentions.clear();
-                }
-            }
-        }
-
-        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() > limits.message_attachments)
-        {
-            return Err(create_error!(TooManyAttachments {
-                max: limits.message_attachments,
-            }));
-        }
-
-        if data
-            .embeds
-            .as_ref()
-            .is_some_and(|v| v.len() > config.features.limits.global.message_embeds)
-        {
-            return Err(create_error!(TooManyEmbeds {
-                max: config.features.limits.global.message_embeds,
-            }));
-        }
-
-        for attachment_id in data.attachments.as_deref().unwrap_or_default() {
-            attachments
-                .push(File::use_attachment(db, attachment_id, &message_id, author.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, amqp, author, user, member, &channel, generate_embeds)
-            .await?;
-
-        Ok(message)
-    }
-
-    /// Send a message without any notifications
-    pub async fn send_without_notifications(
-        &mut self,
-        db: &Database,
-        user: Option<v0::User>,
-        member: Option<v0::Member>,
-        is_dm: bool,
-        generate_embeds: bool,
-        // This determines if this function should queue the mentions task or if somewhere else will.
-        // If this is true, you MUST call tasks::ack::queue yourself.
-        mentions_elsewhere: bool,
-    ) -> Result<()> {
-        db.insert_message(self).await?;
-
-        // Fan out events
-        EventV1::Message(self.clone().into_model(user, member))
-            .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 !mentions_elsewhere {
-            if let Some(mentions) = &self.mentions {
-                tasks::ack::queue_message(
-                    self.channel.to_string(),
-                    AckEvent::ProcessMessage {
-                        messages: vec![(None, self.clone(), mentions.clone(), true)],
-                    },
-                )
-                .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
-    #[allow(clippy::too_many_arguments)]
-    pub async fn send(
-        &mut self,
-        db: &Database,
-        amqp: Option<&AMQP>, // this is optional mostly for tests.
-        author: MessageAuthor<'_>,
-        user: Option<v0::User>,
-        member: Option<v0::Member>,
-        channel: &Channel,
-        generate_embeds: bool,
-    ) -> Result<()> {
-        self.send_without_notifications(
-            db,
-            user.clone(),
-            member.clone(),
-            matches!(channel, Channel::DirectMessage { .. }),
-            generate_embeds,
-            true,
-        )
-        .await?;
-
-        if !self.has_suppressed_notifications() {
-            // send Push notifications
-            tasks::ack::queue_message(
-                self.channel.to_string(),
-                AckEvent::ProcessMessage {
-                    messages: vec![(
-                        Some(
-                            PushNotification::from(
-                                self.clone().into_model(user, member),
-                                Some(author),
-                                channel.to_owned().into(),
-                            )
-                            .await,
-                        ),
-                        self.clone(),
-                        match channel {
-                            Channel::DirectMessage { recipients, .. }
-                            | Channel::Group { recipients, .. } => recipients.clone(),
-                            Channel::TextChannel { .. } => {
-                                self.mentions.clone().unwrap_or_default()
-                            }
-                            _ => vec![],
-                        },
-                        self.has_suppressed_notifications(),
-                    )],
-                },
-            )
-            .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(File::use_attachment(db, &id, &self.id, &self.author).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,
-        }))
-    }
-
-    /// Whether this message has suppressed notifications
-    pub fn has_suppressed_notifications(&self) -> bool {
-        if let Some(flags) = self.flags {
-            flags & MessageFlags::SuppressNotifications as i32
-                == MessageFlags::SuppressNotifications as i32
-        } else {
-            false
-        }
-    }
-
-    /// Update message data
-    pub async fn update(
-        &mut self,
-        db: &Database,
-        partial: PartialMessage,
-        remove: Vec<FieldsMessage>,
-    ) -> Result<()> {
-        self.apply_options(partial.clone());
-
-        for field in &remove {
-            self.remove_field(field);
-        }
-
-        db.update_message(&self.id, &partial, remove.clone())
-            .await?;
-
-        EventV1::MessageUpdate {
-            id: self.id.clone(),
-            channel: self.channel.clone(),
-            data: partial.into(),
-            clear: remove.into_iter().map(|field| field.into()).collect(),
-        }
-        .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(|msg| msg.into_model(None, None))
-            .collect();
-
-        if let Some(true) = include_users {
-            let user_ids = messages
-                .iter()
-                .flat_map(|m| {
-                    let mut users = vec![m.author.clone()];
-                    if let Some(system) = &m.system {
-                        match system {
-                            v0::SystemMessage::ChannelDescriptionChanged { by } => {
-                                users.push(by.clone())
-                            }
-                            v0::SystemMessage::ChannelIconChanged { by } => users.push(by.clone()),
-                            v0::SystemMessage::ChannelOwnershipChanged { from, to, .. } => {
-                                users.push(from.clone());
-                                users.push(to.clone())
-                            }
-                            v0::SystemMessage::ChannelRenamed { by, .. } => users.push(by.clone()),
-                            v0::SystemMessage::UserAdded { by, id, .. }
-                            | v0::SystemMessage::UserRemove { by, id, .. } => {
-                                users.push(by.clone());
-                                users.push(id.clone());
-                            }
-                            v0::SystemMessage::UserBanned { id, .. }
-                            | v0::SystemMessage::UserKicked { id, .. }
-                            | v0::SystemMessage::UserJoined { id, .. }
-                            | v0::SystemMessage::UserLeft { id, .. } => {
-                                users.push(id.clone());
-                            }
-                            v0::SystemMessage::Text { .. } => {}
-                            v0::SystemMessage::MessagePinned { by, .. } => {
-                                users.push(by.clone());
-                            }
-                            v0::SystemMessage::MessageUnpinned { by, .. } => {
-                                users.push(by.clone());
-                            }
-                        }
-                    }
-                    users
-                })
-                .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(
-                File::use_attachment(db, &id, &self.id, &self.author)
-                    .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.global.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
-    }
-
-    pub fn remove_field(&mut self, field: &FieldsMessage) {
-        match field {
-            FieldsMessage::Pinned => self.pinned = None,
-        }
-    }
-}
-
-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.global.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()
-    }
-}
@@ -1,289 +0,0 @@
-use futures::future::try_join_all;
-use indexmap::IndexSet;
-use revolt_result::Result;
-
-use crate::{AppendMessage, FieldsMessage, 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;
-                    }
-                }
-
-                if let Some(pinned) = query.filter.pinned {
-                    if message.pinned.unwrap_or_default() == pinned {
-                        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, remove: Vec<FieldsMessage>) -> Result<()> {
-        let mut messages = self.messages.lock().await;
-        if let Some(message_data) = messages.get_mut(id) {
-            message_data.apply_options(message.to_owned());
-
-            for field in remove {
-                #[allow(clippy::disallowed_methods)]
-                message_data.remove_field(&field);
-            }
-            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(())
-    }
-}
@@ -1,77 +0,0 @@
-mod admin_migrations;
-mod bots;
-mod channel_invites;
-mod channel_unreads;
-mod channel_webhooks;
-mod channels;
-mod emojis;
-mod file_hashes;
-mod files;
-mod messages;
-mod ratelimit_events;
-mod safety_reports;
-mod safety_snapshots;
-mod server_bans;
-mod server_members;
-mod servers;
-mod user_settings;
-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 file_hashes::*;
-pub use files::*;
-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::*;
-pub use users::*;
-
-use crate::{Database, MongoDb, ReferenceDb};
-
-pub trait AbstractDatabase:
-    Sync
-    + Send
-    + admin_migrations::AbstractMigrations
-    + bots::AbstractBots
-    + channels::AbstractChannels
-    + channel_invites::AbstractChannelInvites
-    + channel_unreads::AbstractChannelUnreads
-    + channel_webhooks::AbstractWebhooks
-    + emojis::AbstractEmojis
-    + file_hashes::AbstractAttachmentHashes
-    + files::AbstractAttachments
-    + messages::AbstractMessages
-    + ratelimit_events::AbstractRatelimitEvents
-    + safety_reports::AbstractReport
-    + safety_snapshots::AbstractSnapshot
-    + server_bans::AbstractServerBans
-    + server_members::AbstractServerMembers
-    + servers::AbstractServers
-    + user_settings::AbstractUserSettings
-    + users::AbstractUsers
-{
-}
-
-impl AbstractDatabase for ReferenceDb {}
-impl AbstractDatabase for MongoDb {}
-
-impl std::ops::Deref for Database {
-    type Target = dyn AbstractDatabase;
-
-    fn deref(&self) -> &Self::Target {
-        match &self {
-            Database::Reference(dummy) => dummy,
-            Database::MongoDb(mongo) => mongo,
-        }
-    }
-}
@@ -1,5 +0,0 @@
-mod model;
-mod ops;
-
-pub use model::*;
-pub use ops::*;
@@ -1,47 +0,0 @@
-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
-    }
-}
@@ -1,20 +0,0 @@
-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>;
-}
@@ -1,40 +0,0 @@
-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))
-    }
-}
@@ -1,46 +0,0 @@
-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)
-    }
-}
@@ -1,5 +0,0 @@
-mod model;
-mod ops;
-
-pub use model::*;
-pub use ops::*;
--- a/Show More
+++ b/Show More