chore: ignore WS protocol errors

refactor: redo the bonfire client structure

.config/nextest.toml

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

.dockerignore

@@ -1,3 +1,4 @@
+Dockerfile
 target
 .mongo
 .env

.github/workflows/book.yml

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

.github/workflows/docker.yaml

@@ -0,0 +1,193 @@
+name: Docker Test & Publish
+
+on:
+  push:
+    tags:
+      - "*"
+  pull_request:
+    branches:
+      - "main"
+    paths:
+      - "Dockerfile"
+
+permissions:
+  contents: read
+  packages: write
+
+jobs:
+  base:
+    name: Test base image build
+    runs-on: ubuntu-latest
+    if: github.event_name == 'pull_request'
+    steps:
+      # Configure build environment
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+
+      # Build the image
+      - name: Build base image
+        uses: docker/build-push-action@v4
+        with:
+          context: .
+          push: false
+          platforms: linux/amd64,linux/arm64
+          tags: ghcr.io/${{ github.repository_owner }}/base:latest
+          cache-from: type=gha,scope=buildx-base-multi-arch
+          cache-to: type=gha,scope=buildx-base-multi-arch,mode=max
+
+  publish:
+    runs-on: self-hosted
+    if: github.event_name != 'pull_request'
+    name: Publish Docker images
+    steps:
+      # Configure build environment
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+
+      # Authenticate with Docker Hub and GHCR
+      - name: Login to DockerHub
+        uses: docker/login-action@v2
+        with:
+          registry: docker.io
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Login to Github Container Registry
+        uses: docker/login-action@v2
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      # Build the image
+      - name: Build base image
+        uses: docker/build-push-action@v4
+        with:
+          context: .
+          push: true
+          platforms: linux/amd64,linux/arm64
+          tags: ghcr.io/${{ github.repository_owner }}/base:latest
+
+      # revoltchat/server
+      - name: Docker meta
+        id: meta-delta
+        uses: docker/metadata-action@v4
+        with:
+          images: |
+            docker.io/revoltchat/server
+            ghcr.io/revoltchat/server
+      - name: Publish
+        uses: docker/build-push-action@v4
+        with:
+          context: .
+          push: true
+          platforms: linux/amd64,linux/arm64
+          file: crates/delta/Dockerfile
+          tags: ${{ steps.meta-delta.outputs.tags }}
+          build-args: |
+            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
+          labels: ${{ steps.meta-delta.outputs.labels }}
+
+      # revoltchat/bonfire
+      - name: Docker meta
+        id: meta-bonfire
+        uses: docker/metadata-action@v4
+        with:
+          images: |
+            docker.io/revoltchat/bonfire
+            ghcr.io/revoltchat/bonfire
+      - name: Publish
+        uses: docker/build-push-action@v4
+        with:
+          context: .
+          push: true
+          platforms: linux/amd64,linux/arm64
+          file: crates/bonfire/Dockerfile
+          tags: ${{ steps.meta-bonfire.outputs.tags }}
+          build-args: |
+            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
+          labels: ${{ steps.meta-bonfire.outputs.labels }}
+
+      # revoltchat/autumn
+      - name: Docker meta
+        id: meta-autumn
+        uses: docker/metadata-action@v4
+        with:
+          images: |
+            docker.io/revoltchat/autumn
+            ghcr.io/revoltchat/autumn
+      - name: Publish
+        uses: docker/build-push-action@v4
+        with:
+          context: .
+          push: true
+          platforms: linux/amd64,linux/arm64
+          file: crates/services/autumn/Dockerfile
+          tags: ${{ steps.meta-autumn.outputs.tags }}
+          build-args: |
+            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
+          labels: ${{ steps.meta-autumn.outputs.labels }}
+
+      # revoltchat/january
+      - name: Docker meta
+        id: meta-january
+        uses: docker/metadata-action@v4
+        with:
+          images: |
+            docker.io/revoltchat/january
+            ghcr.io/revoltchat/january
+      - name: Publish
+        uses: docker/build-push-action@v4
+        with:
+          context: .
+          push: true
+          platforms: linux/amd64,linux/arm64
+          file: crates/services/january/Dockerfile
+          tags: ${{ steps.meta-january.outputs.tags }}
+          build-args: |
+            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
+          labels: ${{ steps.meta-january.outputs.labels }}
+
+      # revoltchat/crond
+      - name: Docker meta
+        id: meta-crond
+        uses: docker/metadata-action@v4
+        with:
+          images: |
+            docker.io/revoltchat/crond
+            ghcr.io/revoltchat/crond
+      - name: Publish
+        uses: docker/build-push-action@v4
+        with:
+          context: .
+          push: true
+          platforms: linux/amd64,linux/arm64
+          file: crates/daemons/crond/Dockerfile
+          tags: ${{ steps.meta-crond.outputs.tags }}
+          build-args: |
+            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
+          labels: ${{ steps.meta-crond.outputs.labels }}
+
+      # revoltchat/pushd
+      - name: Docker meta
+        id: meta-pushd
+        uses: docker/metadata-action@v4
+        with:
+          images: |
+            docker.io/revoltchat/pushd
+            ghcr.io/revoltchat/pushd
+      - name: Publish
+        uses: docker/build-push-action@v4
+        with:
+          context: .
+          push: true
+          platforms: linux/amd64,linux/arm64
+          file: crates/daemons/pushd/Dockerfile
+          tags: ${{ steps.meta-pushd.outputs.tags }}
+          build-args: |
+            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
+          labels: ${{ steps.meta-pushd.outputs.labels }}

.github/workflows/rust.yaml

@@ -0,0 +1,92 @@
+name: Rust build, test, and generate specification
+
+on:
+  push:
+    paths-ignore:
+      - ".github/**"
+      - "!.github/workflows/rust.yaml"
+      - ".vscode/**"
+      - "doc/**"
+      - ".gitignore"
+      - "LICENSE"
+      - "README"
+  pull_request:
+    branches: [main]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  check:
+    name: Rust project
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Install latest stable
+        uses: actions-rs/toolchain@v1
+        with:
+          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
+
+      - name: Run cargo test (with MongoDB)
+        env:
+          TEST_DB: MONGODB
+          MONGODB: mongodb://localhost
+        run: |
+          cargo nextest run
+
+      - name: Start API in background
+        if: github.event_name != 'pull_request' && github.ref_name == 'main'
+        env:
+          TEST_DB: REFERENCE
+        run: |
+          cargo build --bin revolt-delta && (cargo run --bin revolt-delta &)
+
+      - name: Wait for API to go up
+        if: github.event_name != 'pull_request' && github.ref_name == 'main'
+        uses: nev7n/wait_for_response@v1
+        with:
+          url: "http://localhost:14702/"
+
+      - name: Checkout API repository
+        if: github.event_name != 'pull_request' && github.ref_name == 'main'
+        uses: actions/checkout@v3
+        with:
+          repository: revoltchat/api
+          path: api
+          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
+
+      - name: Commit changes
+        if: github.event_name != 'pull_request' && github.ref_name == 'main'
+        uses: EndBug/add-and-commit@v4
+        with:
+          cwd: "api"
+          add: "*.json"
+          author_name: Revolt CI
+          author_email: revolt-ci@users.noreply.github.com
+          message: "chore: generate OpenAPI specification"

.github/workflows/triage_issue.yml

@@ -0,0 +1,54 @@
+name: Add Issue to Board
+
+on:
+  issues:
+    types: [opened]
+
+jobs:
+  track_issue:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get project data
+        env:
+          GITHUB_TOKEN: ${{ secrets.PAT }}
+        run: |
+          gh api graphql -f query='
+            query {
+              organization(login: "revoltchat"){
+                projectV2(number: 3) {
+                  id
+                  fields(first:20) {
+                    nodes {
+                      ... on ProjectV2SingleSelectField {
+                        id
+                        name
+                        options {
+                          id
+                          name
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }' > project_data.json
+
+          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 'TODO_OPTION_ID='$(jq '.data.organization.projectV2.fields.nodes[] | select(.name== "Status") | .options[] | select(.name=="Todo") |.id' project_data.json) >> $GITHUB_ENV
+
+      - name: Add issue to project
+        env:
+          GITHUB_TOKEN: ${{ secrets.PAT }}
+          ISSUE_ID: ${{ github.event.issue.node_id }}
+        run: |
+          item_id="$( gh api graphql -f query='
+            mutation($project:ID!, $issue:ID!) {
+              addProjectV2ItemById(input: {projectId: $project, contentId: $issue}) {
+                item {
+                  id
+                }
+              }
+            }' -f project=$PROJECT_ID -f issue=$ISSUE_ID --jq '.data.addProjectV2ItemById.item.id')"
+
+          echo 'ITEM_ID='$item_id >> $GITHUB_ENV

.github/workflows/triage_pr.yml

@@ -0,0 +1,79 @@
+name: Add PR to Board
+
+on:
+  pull_request_target:
+    types: [opened, synchronize, ready_for_review, review_requested]
+
+jobs:
+  track_pr:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get project data
+        env:
+          GITHUB_TOKEN: ${{ secrets.PAT }}
+        run: |
+          gh api graphql -f query='
+            query {
+              organization(login: "revoltchat"){
+                projectV2(number: 5) {
+                  id
+                  fields(first:20) {
+                    nodes {
+                      ... on ProjectV2SingleSelectField {
+                        id
+                        name
+                        options {
+                          id
+                          name
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }' > project_data.json
+
+          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
+
+      - name: Add PR to project
+        env:
+          GITHUB_TOKEN: ${{ secrets.PAT }}
+          PR_ID: ${{ github.event.pull_request.node_id }}
+        run: |
+          item_id="$( gh api graphql -f query='
+            mutation($project:ID!, $pr:ID!) {
+              addProjectV2ItemById(input: {projectId: $project, contentId: $pr}) {
+                item {
+                  id
+                }
+              }
+            }' -f project=$PROJECT_ID -f pr=$PR_ID --jq '.data.addProjectV2ItemById.item.id')"
+
+          echo 'ITEM_ID='$item_id >> $GITHUB_ENV
+
+      - name: Set fields
+        env:
+          GITHUB_TOKEN: ${{ secrets.PAT }}
+        run: |
+          gh api graphql -f query='
+            mutation (
+              $project: ID!
+              $item: ID!
+              $status_field: ID!
+              $status_value: String!
+            ) {
+              set_status: updateProjectV2ItemFieldValue(input: {
+                projectId: $project
+                itemId: $item
+                fieldId: $status_field
+                value: {
+                  singleSelectOptionId: $status_value
+                }
+              }) {
+                projectV2Item {
+                  id
+                }
+              }
+            }' -f project=$PROJECT_ID -f item=$ITEM_ID -f status_field=$STATUS_FIELD_ID -f status_value=${{ env.INCOMING_OPTION_ID }} --silent

.gitignore

@@ -1,7 +1,14 @@
 Rocket.toml
-/target
-/target_backup
-**/*.rs.bk
-.mongo
+Revolt.*.toml
+compose.override.yml
+
+target
+.data
 .env
-avatar.png
+.venv/
+venv/
+
+.vercel
+.DS_Store
+
+.idea

.gitlab-ci.yml

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

.vscode/settings.json

@@ -1,5 +1,6 @@
 {
-    "rust-analyzer.diagnostics.disabled": [
-        "unresolved-macro-call"
-    ]
-}
+  "editor.formatOnSave": true,
+  "rust-analyzer.check.command": "clippy",
+  "nixEnvSelector.suggestion": false,
+  "nixEnvSelector.nixFile": "${workspaceFolder}/default.nix"
+}

Cargo.toml

@@ -1,48 +1,22 @@
-[package]
-name = "revolt"
-# To help optimise CI and Docker builds.
-# Version here is left as 0.0.0, please
-# adjust and run ./set_version.sh instead.
-version = "0.0.0"
-authors = ["Paul Makles <paulmakles@gmail.com>"]
-edition = "2018"
+[workspace]
+resolver = "2"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+members = [
+    "crates/delta",
+    "crates/bonfire",
+    "crates/core/*",
+    "crates/services/*",
+    "crates/daemons/*",
+]
 
-[dependencies]
-regex = "1"
-md5 = "0.7.0"
-log = "0.4.11"
-ulid = "0.4.1"
-rand = "0.7.3"
-time = "0.2.16"
-nanoid = "0.4.0"
-base64 = "0.13.0"
-linkify = "0.6.0"
-dotenv = "0.15.0"
-futures = "0.3.8"
-chrono = "0.4.15"
-num_enum = "0.5.1"
-impl_ops = "0.1.1"
-web-push = "0.7.2"
-once_cell = "1.4.1"
-bitfield = "0.13.2"
-env_logger = "0.7.1"
-serde_json = "1.0.57"
-lazy_static = "1.4.0"
-urlencoding = "1.1.1"
-many-to-many = "0.1.2"
-lettre = "0.10.0-alpha.1"
-reqwest = { version = "0.10.8", features = ["json"] }
-serde = { version = "1.0.115", features = ["derive"] }
-validator = { version = "0.11", features = ["derive"] }
-ctrlc = { version = "3.0", features = ["termination"] }
-hive_pubsub = { version = "0.4.4", features = ["mongo"] }
-async-std = { version = "1.8.0", features = ["tokio02", "attributes"] }
-async-tungstenite = { version = "0.10.0", features = ["async-std-runtime"] }
-rocket_cors = { git = "https://github.com/insertish/rocket_cors", branch = "master" }
-mongodb = { version = "1.1.1", features = ["tokio-runtime"], default-features = false }
-rauth = { git = "https://gitlab.insrt.uk/insert/rauth", rev = "1db825a0059639144ea8802f6d51b5d27c5b986e" }
-rocket_contrib = { git = "https://github.com/SergioBenitez/Rocket", rev = "031948c1daaa146128d8a435be116476f2adde00" }
-rocket_prometheus = { git = "https://github.com/insertish/rocket_prometheus", rev = "3d825aedb42793246c306a81fe67c5b187948983" }
-rocket = { git = "https://github.com/SergioBenitez/Rocket", rev = "031948c1daaa146128d8a435be116476f2adde00", default-features = false }
+[patch.crates-io]
+redis23 = { package = "redis", version = "0.23.3", git = "https://github.com/revoltchat/redis-rs", rev = "523b2937367e17bd0073722bf6e23d06042cb4e4" }
+#authifier = { package = "authifier", version = "1.0.10", path = "../authifier/crates/authifier" }
+#rocket_authifier = { package = "rocket_authifier", version = "1.0.10", 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 (that is now).
+[profile.release]
+lto = true

Dockerfile

@@ -1,25 +1,38 @@
 # Build Stage
-FROM ekidd/rust-musl-builder:nightly-2021-01-01 AS builder
+FROM --platform="${BUILDPLATFORM}" rust:1.86.0-slim-bookworm
 USER 0:0
 WORKDIR /home/rust/src
 
-RUN USER=root cargo new --bin revolt
-WORKDIR /home/rust/src/revolt
+ARG TARGETARCH
+
+# Install build requirements
+RUN dpkg --add-architecture "${TARGETARCH}"
+RUN apt-get update && \
+    apt-get install -y \
+    make \
+    pkg-config \
+    libssl-dev:"${TARGETARCH}"
+COPY scripts/build-image-layer.sh /tmp/
+RUN sh /tmp/build-image-layer.sh tools
+
+# Build all dependencies
 COPY Cargo.toml Cargo.lock ./
-COPY src/bin/dummy.rs ./src/bin/dummy.rs
-RUN cargo build --release --bin dummy
+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/parser/Cargo.toml ./crates/core/parser/
+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
 
-COPY assets/templates ./assets/templates
-COPY src ./src
-RUN cargo build --release
-
-# Bundle Stage
-FROM alpine:latest
-RUN apk update && apk add ca-certificates && rm -rf /var/cache/apk/*
-COPY --from=builder /home/rust/src/revolt/target/x86_64-unknown-linux-musl/release/revolt ./
-COPY assets ./assets
-EXPOSE 8000
-EXPOSE 9000
-ENV ROCKET_ADDRESS 0.0.0.0
-ENV ROCKET_PORT 8000
-CMD ["./revolt"]
+# Build all apps
+COPY crates ./crates
+RUN sh /tmp/build-image-layer.sh apps

Dockerfile.useCurrentArch

@@ -0,0 +1,34 @@
+# Build Stage
+FROM rust:1.86.0-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/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/parser/Cargo.toml ./crates/core/parser/
+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

LICENSE

@@ -1,7 +1,10 @@
-                    GNU AFFERO GENERAL PUBLIC LICENSE
+With the exception of crates that specify their own LICENSE file,
+the following license applies to the source code of this project.
+
+GNU AFFERO GENERAL PUBLIC LICENSE
                        Version 3, 19 November 2007
 
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
  Everyone is permitted to copy and distribute verbatim copies
  of this license document, but changing it is not allowed.
 
@@ -629,8 +632,8 @@ to attach them to the start of each source file to most effectively
 state the exclusion of warranty; and each file should have at least
 the "copyright" line and a pointer to where the full notice is found.
 
-    Server
-    Copyright (C) 2021  REVOLT
+    Revolt Project
+    Copyright (C) 2022 Pawel Makles
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU Affero General Public License as published
@@ -643,7 +646,7 @@ the "copyright" line and a pointer to where the full notice is found.
     GNU Affero General Public License for more details.
 
     You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 Also add information on how to contact you by electronic and paper mail.
 
@@ -658,4 +661,4 @@ specific requirements.
   You should also get your employer (if you work as a programmer) or school,
 if any, to sign a "copyright disclaimer" for the program, if necessary.
 For more information on this, and how to apply and follow the GNU AGPL, see
-<https://www.gnu.org/licenses/>.
+<http://www.gnu.org/licenses/>.

README.md

@@ -1,20 +1,220 @@
-![](assets/banner.png)
+<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/>
 
-Delta is a **blazing fast API server** built with Rust for the REVOLT platform.
+| 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)                                                                                                                                                                                                                                |
+| `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)                                                                                                                                                                                                                                |
 
-Features:
-- Robust and efficient API routes for running a chat platform.
-- Distributed notification system, allowing any node to be seamlessly connected.
-- Simple deployment, based mostly on pure Rust code and libraries.
-- Hooks up to a MongoDB deployment, provide URI and no extra work needed.
+</div>
+<br/>
 
-## Docker Helper Scripts
+## Minimum Supported Rust Version
 
-If you have Docker installed, you can use the helper scripts to deploy Revolt in your development environment.
+Rust 1.86.0 or higher.
+
+> [!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). This is currently solved by build time options but we are looking for a proper fix.
+
+## Development Guide
+
+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/).
+
+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
-./build.sh   # build Docker image
-./run.sh     # run Docker container
-./monitor.sh # view container logs
-./remove.sh  # kill and remove container
+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
+> # and Revolt.test-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
+```
+
+## 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!**

Revolt.toml

@@ -0,0 +1,53 @@
+# ⚠️ This configuration is intended for development environment.
+# If you'd like to override anything, create a Revolt.overrides.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
+use_starttls = 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"

STYLE_GUIDE.md

@@ -0,0 +1,73 @@
+# 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.

assets/templates/reset.html

@@ -1,62 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" lang="en-GB">
-<head>
-	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-	<title>Reset your password.</title>
-	<meta name="viewport" content="width=device-width, initial-scale=1.0"/>
-
-	<style type="text/css">
-		a[x-apple-data-detectors] {color: inherit !important;}
-	</style>
-
-</head>
-<body style="margin: 0; padding: 0;">
-	<table role="presentation" border="0" cellpadding="0" cellspacing="0" width="100%">
-		<tr>
-			<td style="padding: 20px 0 30px 0;">
-
-<table align="center" border="0" cellpadding="0" cellspacing="0" width="600" style="border-collapse: collapse; border: 1px solid #cccccc;">
-	<tr>
-		<td align="center" bgcolor="#ff4654">
-			<img src="https://revolt.chat/header.png" alt="REVOLT logo" width="600" height="168" style="display: block;" />
-		</td>
-	</tr>
-	<tr>
-		<td bgcolor="#ffffff" style="padding: 40px 30px 40px 30px;">
-			<table border="0" cellpadding="0" cellspacing="0" width="100%" style="border-collapse: collapse;">
-				<tr>
-					<td style="color: #153643; font-family: Arial, sans-serif;">
-						<h1 style="font-size: 24px; margin: 0;">Reset your password!</h1>
-					</td>
-				</tr>
-				<tr>
-					<td style="color: #153643; font-family: Arial, sans-serif; font-size: 16px; line-height: 24px; padding: 20px 0 0 0;">
-						<p style="margin: 0;">
-              Reset your password by <a href="{{url}}">clicking here</a>.
-            </p>
-            <p>
-              Or by manually navigating to the URL: {{url}}
-            </p>
-					</td>
-				</tr>
-			</table>
-		</td>
-	</tr>
-	<tr>
-		<td bgcolor="#ff4654" style="padding: 30px 30px;">
-    		<table border="0" cellpadding="0" cellspacing="0" width="100%" style="border-collapse: collapse;">
-				<tr>
-					<td style="color: #ffffff; font-family: Arial, sans-serif; font-size: 14px;">
-            <p style="margin: 0;">Sent by REVOLT. &middot; <a style="color: white;" href="https://revolt.chat">Website</a> &middot; <a style="color: white;" href="https://gitlab.insrt.uk/revolt">Source Code</a></p>
-					</td>
-				</tr>
-			</table>
-		</td>
-	</tr>
-</table>
-
-			</td>
-		</tr>
-	</table>
-</body>
-</html>

assets/templates/verify.html

@@ -1,62 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" lang="en-GB">
-<head>
-	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-	<title>Verify your account.</title>
-	<meta name="viewport" content="width=device-width, initial-scale=1.0"/>
-
-	<style type="text/css">
-		a[x-apple-data-detectors] {color: inherit !important;}
-	</style>
-
-</head>
-<body style="margin: 0; padding: 0;">
-	<table role="presentation" border="0" cellpadding="0" cellspacing="0" width="100%">
-		<tr>
-			<td style="padding: 20px 0 30px 0;">
-
-<table align="center" border="0" cellpadding="0" cellspacing="0" width="600" style="border-collapse: collapse; border: 1px solid #cccccc;">
-	<tr>
-		<td align="center" bgcolor="#ff4654">
-			<img src="https://revolt.chat/header.png" alt="REVOLT logo" width="600" height="168" style="display: block;" />
-		</td>
-	</tr>
-	<tr>
-		<td bgcolor="#ffffff" style="padding: 40px 30px 40px 30px;">
-			<table border="0" cellpadding="0" cellspacing="0" width="100%" style="border-collapse: collapse;">
-				<tr>
-					<td style="color: #153643; font-family: Arial, sans-serif;">
-						<h1 style="font-size: 24px; margin: 0;">Verify your account!</h1>
-					</td>
-				</tr>
-				<tr>
-					<td style="color: #153643; font-family: Arial, sans-serif; font-size: 16px; line-height: 24px; padding: 20px 0 0 0;">
-						<p style="margin: 0;">
-              Please verify your account by <a href="{{url}}">clicking here</a>.
-            </p>
-            <p>
-              Or by manually navigating to the URL: {{url}}
-            </p>
-					</td>
-				</tr>
-			</table>
-		</td>
-	</tr>
-	<tr>
-		<td bgcolor="#ff4654" style="padding: 30px 30px;">
-    		<table border="0" cellpadding="0" cellspacing="0" width="100%" style="border-collapse: collapse;">
-				<tr>
-					<td style="color: #ffffff; font-family: Arial, sans-serif; font-size: 14px;">
-            <p style="margin: 0;">Sent by REVOLT. &middot; <a style="color: white;" href="https://revolt.chat">Website</a> &middot; <a style="color: white;" href="https://gitlab.insrt.uk/revolt">Source Code</a></p>
-					</td>
-				</tr>
-			</table>
-		</td>
-	</tr>
-</table>
-
-			</td>
-		</tr>
-	</table>
-</body>
-</html>

clippy.toml

@@ -0,0 +1,28 @@
+disallowed-methods = [
+    # Shouldn't need to access these directly
+    "revolt_database::models::bots::model::Bot::remove_field",
+    "revolt_database::models::messages::model::Message::attach_sendable_embed",
+    "revolt_database::models::users::model::User::set_relationship",
+    "revolt_database::models::users::model::User::apply_relationship",
+
+    # Prefer to use Object::create()
+    "revolt_database::models::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",
+]

compose.yml

@@ -0,0 +1,66 @@
+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

crates/bonfire/.gitignore

@@ -0,0 +1 @@
+/target

crates/bonfire/Cargo.toml

@@ -0,0 +1,53 @@
+[package]
+name = "revolt-bonfire"
+version = "0.8.8"
+license = "AGPL-3.0-or-later"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+# util
+log = "*"
+rand = "*"
+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"
+
+# serde
+bincode = "1.3.3"
+serde_json = "1.0.79"
+rmp-serde = "1.0.0"
+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.15" }
+revolt-result = { path = "../core/result" }
+revolt-broker = { path = "../core/broker" }
+revolt-models = { path = "../core/models" }
+revolt-config = { path = "../core/config" }
+revolt-database = { path = "../core/database" }
+revolt-permissions = { version = "0.8.8", path = "../core/permissions" }
+revolt-presence = { path = "../core/presence", features = ["redis-is-patched"] }
+
+# redis
+fred = { version = "8.0.1", features = ["subscriber-client"] }
+
+# rabbit
+lapin = { version = "3.0.0" }

crates/bonfire/Dockerfile

@@ -0,0 +1,12 @@
+# Build Stage
+FROM ghcr.io/revoltchat/base:latest AS builder
+FROM debian:12 AS debian
+
+# Bundle Stage
+FROM gcr.io/distroless/cc-debian12:nonroot
+COPY --from=builder /home/rust/src/target/release/revolt-bonfire ./
+COPY --from=debian /usr/bin/uname /usr/bin/uname
+
+EXPOSE 14703
+USER nonroot
+CMD ["./revolt-bonfire"]

crates/bonfire/LICENSE

@@ -0,0 +1 @@
+../../LICENSE

crates/bonfire/src/client/core.rs

@@ -0,0 +1,129 @@
+use async_std::{net::TcpStream, sync::Mutex};
+use async_tungstenite::WebSocketStream;
+use futures::{join, SinkExt, StreamExt, TryStreamExt};
+use revolt_config::report_internal_error;
+use revolt_database::{
+    events::{client::EventV1, server::ClientMessage},
+    iso8601_timestamp::Timestamp,
+    Database, User, UserHint,
+};
+use revolt_presence::{create_session, delete_session};
+use revolt_result::create_error;
+
+use crate::{
+    client::{
+        subscriber::client_subscriber,
+        worker::{client_worker, WorkerRef},
+    },
+    config::ProtocolConfiguration,
+    events::state::State,
+};
+
+/// Core event loop of gateway clients
+pub async fn client_core(
+    db: &'static Database,
+    ws: WebSocketStream<TcpStream>,
+    mut config: ProtocolConfiguration,
+) {
+    // 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!(
+        "Authenticated user {}#{}",
+        user.username, user.discriminator
+    );
+
+    db.update_session_last_seen(&session_id, Timestamp::now_utc())
+        .await
+        .ok();
+
+    // 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;
+    }
+
+    {
+        let worker_ref = WorkerRef::from(&state);
+        let write = Mutex::new(write);
+        let (reload, reloaded) = async_channel::bounded(1);
+        let (cancel_1, cancelled_1) = async_channel::bounded(1);
+        let (cancel_2, cancelled_2) = async_channel::bounded(1);
+
+        join!(
+            async {
+                client_subscriber(&write, cancelled_1, reloaded, &config, db, &mut state).await;
+                cancel_2.send(()).await.ok();
+            },
+            async {
+                client_worker(read, &write, cancelled_2, reload, &config, worker_ref).await;
+                cancel_1.send(()).await.ok();
+            }
+        );
+    }
+
+    // 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;
+    }
+}

crates/bonfire/src/client/mod.rs

@@ -0,0 +1,3 @@
+pub mod core;
+pub mod subscriber;
+pub mod worker;

crates/bonfire/src/client/subscriber.rs

@@ -0,0 +1,112 @@
+use async_channel::Receiver;
+use async_std::{net::TcpStream, sync::Mutex};
+use async_tungstenite::WebSocketStream;
+use authifier::AuthifierEvent;
+use futures::{pin_mut, select, stream::SplitSink, FutureExt, SinkExt};
+use revolt_broker::event_stream;
+use revolt_database::{events::client::EventV1, Database};
+use sentry::Level;
+
+use crate::{
+    config::ProtocolConfiguration,
+    events::state::{State, SubscriptionStateChange},
+};
+
+/// Event subscriber loop
+pub async fn client_subscriber(
+    write: &Mutex<SplitSink<WebSocketStream<TcpStream>, async_tungstenite::tungstenite::Message>>,
+    cancelled: Receiver<()>,
+    reloaded: Receiver<()>,
+    protocol_config: &ProtocolConfiguration,
+    db: &'static Database,
+    state: &mut State,
+) {
+    let mut consumer = event_stream::Consumer::new().await;
+    consumer.set_topics(state.subscribed.read().await.clone());
+
+    let mut cancel = false;
+
+    loop {
+        // Reload consumer if subscriptions change
+        if !matches!(state.apply_state().await, SubscriptionStateChange::None) {
+            consumer.set_topics(state.subscribed.read().await.clone());
+        }
+
+        // Read incoming events
+        loop {
+            let reloaded = reloaded.recv().fuse();
+            let cancelled = cancelled.recv().fuse();
+            let delivery = consumer.next().fuse();
+            pin_mut!(delivery, reloaded, cancelled);
+
+            select! {
+                _ = reloaded => {
+                    break;
+                }
+                _ = cancelled => {
+                    cancel = true;
+                    break;
+                }
+                event = delivery => {
+                    if let Some(mut event) = event {
+                        // Handle the event
+                        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(protocol_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: {e:?}");
+                                warn!("{}", err);
+                                sentry::capture_message(&err, Level::Warning);
+                            }
+
+                            cancel = true;
+                            break;
+                        }
+
+                        if let EventV1::Logout = event {
+                            info!("User {} received log out event!", state.user_id);
+                            cancel = true;
+                            break;
+                        }
+
+                        break;
+                    } else {
+                        cancel = true;
+                        break;
+                    }
+                }
+            }
+        }
+
+        // Break out if cancelled
+        if cancel {
+            break;
+        }
+    }
+
+    consumer.dispose_channel().await;
+}

crates/bonfire/src/client/worker.rs

@@ -0,0 +1,124 @@
+use std::{collections::HashSet, sync::Arc};
+
+use async_channel::{Receiver, Sender};
+use async_std::{
+    net::TcpStream,
+    sync::{Mutex, RwLock},
+};
+use async_tungstenite::WebSocketStream;
+use futures::{
+    pin_mut, select,
+    stream::{SplitSink, SplitStream},
+    FutureExt, SinkExt, TryStreamExt,
+};
+use revolt_database::events::{client::EventV1, server::ClientMessage};
+use sentry::Level;
+
+use crate::{config::ProtocolConfiguration, events::state::State};
+
+pub struct WorkerRef {
+    user_id: String,
+    active_servers: Arc<Mutex<lru_time_cache::LruCache<String, ()>>>,
+    subscribed: Arc<RwLock<HashSet<String>>>,
+}
+
+impl WorkerRef {
+    pub fn from(state: &State) -> WorkerRef {
+        WorkerRef {
+            user_id: state.user_id.clone(),
+            active_servers: state.active_servers.clone(),
+            subscribed: state.subscribed.clone(),
+        }
+    }
+}
+
+/// Incoming message handling
+pub async fn client_worker(
+    mut read: SplitStream<WebSocketStream<TcpStream>>,
+    write: &Mutex<SplitSink<WebSocketStream<TcpStream>, async_tungstenite::tungstenite::Message>>,
+    cancelled: Receiver<()>,
+    reload: Sender<()>,
+    config: &ProtocolConfiguration,
+    state: WorkerRef,
+) {
+    loop {
+        let read = read.try_next().fuse();
+        let cancelled = cancelled.recv().fuse();
+        pin_mut!(read, cancelled);
+
+        select! {
+            _ = cancelled => { return; },
+            msg = read => {
+                let msg = match msg {
+                    Ok(Some(msg)) => msg,
+                    Ok(None) => {
+                        warn!("Received a None message!");
+                        return;
+                    }
+                    Err(e) => {
+                        use async_tungstenite::tungstenite::Error;
+                        if !matches!(e, Error::AlreadyClosed | Error::ConnectionClosed | Error::Protocol(_)) {
+                            let err = format!("Error while reading an event: {e:?}");
+                            warn!("{}", err);
+                            sentry::capture_message(&err, Level::Warning);
+                        }
+
+                        return;
+                    }
+                };
+
+                let Ok(payload) = config.decode(&msg) else {
+                    continue;
+                };
+
+                match payload {
+                    ClientMessage::BeginTyping { channel } => {
+                        if !state.subscribed.read().await.contains(&channel) {
+                            continue;
+                        }
+
+                        EventV1::ChannelStartTyping {
+                            id: channel.clone(),
+                            user: state.user_id.clone(),
+                        }
+                        .p(channel.clone())
+                        .await;
+                    }
+                    ClientMessage::EndTyping { channel } => {
+                        if !state.subscribed.read().await.contains(&channel) {
+                            continue;
+                        }
+
+                        EventV1::ChannelStopTyping {
+                            id: channel.clone(),
+                            user: state.user_id.clone(),
+                        }
+                        .p(channel.clone())
+                        .await;
+                    }
+                    ClientMessage::Subscribe { server_id } => {
+                        let mut servers = state.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
+                            reload.send(()).await.ok();
+                        }
+                    }
+                    ClientMessage::Ping { data, responded } => {
+                        if responded.is_none() {
+                            write
+                                .lock()
+                                .await
+                                .send(config.encode(&EventV1::Pong { data }))
+                                .await
+                                .ok();
+                        }
+                    }
+                    _ => {}
+                }
+            }
+        }
+    }
+}

crates/bonfire/src/config.rs

@@ -0,0 +1,162 @@
+use async_tungstenite::tungstenite::{handshake, Message};
+use futures::channel::oneshot::Sender;
+use revolt_database::events::client::ReadyPayloadFields;
+use revolt_result::{create_error, Result};
+use serde::{Deserialize, Serialize};
+
+/// Enumeration of supported protocol formats
+#[derive(Debug)]
+pub enum ProtocolFormat {
+    Json,
+    Msgpack,
+}
+
+/// User-provided protocol configuration
+#[derive(Debug)]
+pub struct ProtocolConfiguration {
+    protocol_version: i32,
+    format: ProtocolFormat,
+    session_token: Option<String>,
+}
+
+impl ProtocolConfiguration {
+    /// Create a new protocol configuration object from provided data
+    pub fn from(
+        protocol_version: i32,
+        format: ProtocolFormat,
+        session_token: Option<String>,
+    ) -> Self {
+        Self {
+            protocol_version,
+            format,
+            session_token,
+        }
+    }
+
+    /// Decode some WebSocket message into a T: Deserialize using the client's specified protocol format
+    pub fn decode<'a, T: Deserialize<'a>>(&self, msg: &'a Message) -> Result<T> {
+        match self.format {
+            ProtocolFormat::Json => {
+                if let Message::Text(text) = msg {
+                    serde_json::from_str(text).map_err(|_| create_error!(InternalError))
+                } else {
+                    Err(create_error!(InternalError))
+                }
+            }
+            ProtocolFormat::Msgpack => {
+                if let Message::Binary(buf) = msg {
+                    rmp_serde::from_slice(buf).map_err(|_| create_error!(InternalError))
+                } else {
+                    Err(create_error!(InternalError))
+                }
+            }
+        }
+    }
+
+    /// Encode T: Serialize into a WebSocket message using the client's specified protocol format
+    pub fn encode<T: Serialize>(&self, data: &T) -> Message {
+        match self.format {
+            ProtocolFormat::Json => {
+                Message::Text(serde_json::to_string(data).expect("Failed to serialise (as json)."))
+            }
+            ProtocolFormat::Msgpack => Message::Binary(
+                rmp_serde::to_vec_named(data).expect("Failed to serialise (as msgpack)."),
+            ),
+        }
+    }
+
+    /// Set the current session token
+    pub fn set_session_token(&mut self, token: String) {
+        self.session_token.replace(token);
+    }
+
+    /// Get the current session token
+    pub fn get_session_token(&self) -> &Option<String> {
+        &self.session_token
+    }
+
+    /// Get the protocol version specified
+    pub fn get_protocol_version(&self) -> i32 {
+        self.protocol_version
+    }
+
+    /// Get the protocol format specified
+    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
+pub struct WebsocketHandshakeCallback {
+    sender: Sender<ProtocolConfiguration>,
+}
+
+impl WebsocketHandshakeCallback {
+    /// Create a callback using a given sender
+    pub fn from(sender: Sender<ProtocolConfiguration>) -> Self {
+        Self { sender }
+    }
+}
+
+impl handshake::server::Callback for WebsocketHandshakeCallback {
+    /// Handle request to create a new WebSocket connection
+    fn on_request(
+        self,
+        request: &handshake::server::Request,
+        response: handshake::server::Response,
+    ) -> Result<handshake::server::Response, handshake::server::ErrorResponse> {
+        // Take and parse query parameters from the URI.
+        let query = request.uri().query().unwrap_or_default();
+        let params = querystring::querify(query);
+
+        // Set default values for the protocol.
+        let mut protocol_version = 1;
+        let mut format = ProtocolFormat::Json;
+        let mut session_token = None;
+
+        // Parse and map parameters from key-value to known variables.
+        for (key, value) in params {
+            match key {
+                "version" => {
+                    if let Ok(version) = value.parse() {
+                        protocol_version = version;
+                    }
+                }
+                "format" => match value {
+                    "json" => format = ProtocolFormat::Json,
+                    "msgpack" => format = ProtocolFormat::Msgpack,
+                    _ => {}
+                },
+                "token" => session_token = Some(value.into()),
+                _ => {}
+            }
+        }
+
+        // Send configuration information back from this callback.
+        // We have to use a channel as this function does not borrow mutably.
+        if self
+            .sender
+            .send(ProtocolConfiguration {
+                protocol_version,
+                format,
+                session_token,
+            })
+            .is_ok()
+        {
+            Ok(response)
+        } else {
+            Err(handshake::server::ErrorResponse::new(None))
+        }
+    }
+}

crates/bonfire/src/database.rs

@@ -0,0 +1,21 @@
+use once_cell::sync::OnceCell;
+use revolt_database::{Database, DatabaseInfo};
+
+static DBCONN: OnceCell<Database> = OnceCell::new();
+
+/// Connect Bonfire to the database.
+pub async fn connect() {
+    let database = DatabaseInfo::Auto
+        .connect()
+        .await
+        .expect("Failed to connect to the database.");
+
+    if DBCONN.set(database).is_err() {
+        panic!("couldn't set database")
+    }
+}
+
+/// Get a reference to the current database.
+pub fn get_db() -> &'static Database {
+    DBCONN.get().expect("Valid `Database`")
+}

crates/bonfire/src/events/impl.rs

@@ -0,0 +1,635 @@
+use std::collections::HashSet;
+
+use futures::future::join_all;
+use revolt_database::{
+    events::client::{EventV1, ReadyPayloadFields},
+    util::permissions::DatabasePermissionQuery,
+    Channel, Database, Member, MemberCompositeKey, Presence, RelationshipStatus,
+};
+use revolt_models::v0;
+use revolt_permissions::{calculate_channel_permissions, ChannelPermission};
+use revolt_presence::filter_online;
+use revolt_result::Result;
+
+use super::state::{Cache, State};
+
+/// Cache Manager
+impl Cache {
+    /// Check whether the current user can view a channel
+    pub async fn can_view_channel(&self, db: &Database, channel: &Channel) -> bool {
+        match &channel {
+            Channel::TextChannel { server, .. } | Channel::VoiceChannel { server, .. } => {
+                let member = self.members.get(server);
+                let server = self.servers.get(server);
+                let mut query =
+                    DatabasePermissionQuery::new(db, self.users.get(&self.user_id).unwrap())
+                        .channel(channel);
+                // let mut perms = perms(self.users.get(&self.user_id).unwrap()).channel(channel);
+
+                if let Some(member) = member {
+                    query = query.member(member);
+                }
+
+                if let Some(server) = server {
+                    query = query.server(server);
+                }
+
+                calculate_channel_permissions(&mut query)
+                    .await
+                    .has_channel_permission(ChannelPermission::ViewChannel)
+            }
+            _ => true,
+        }
+    }
+
+    /// Filter a given vector of channels to only include the ones we can access
+    pub async fn filter_accessible_channels(
+        &self,
+        db: &Database,
+        channels: Vec<Channel>,
+    ) -> Vec<Channel> {
+        let mut viewable_channels = vec![];
+        for channel in channels {
+            if self.can_view_channel(db, &channel).await {
+                viewable_channels.push(channel);
+            }
+        }
+
+        viewable_channels
+    }
+
+    /// Check whether we can subscribe to another user
+    pub fn can_subscribe_to_user(&self, user_id: &str) -> bool {
+        if let Some(user) = self.users.get(&self.user_id) {
+            match user.relationship_with(user_id) {
+                RelationshipStatus::Friend
+                | RelationshipStatus::Incoming
+                | RelationshipStatus::Outgoing
+                | RelationshipStatus::User => true,
+                _ => {
+                    let user_id = &user_id.to_string();
+                    for channel in self.channels.values() {
+                        match channel {
+                            Channel::DirectMessage { recipients, .. }
+                            | Channel::Group { recipients, .. } => {
+                                if recipients.contains(user_id) {
+                                    return true;
+                                }
+                            }
+                            _ => {}
+                        }
+                    }
+
+                    false
+                }
+            }
+        } else {
+            false
+        }
+    }
+}
+
+/// State Manager
+impl State {
+    /// Generate a Ready packet for the current user
+    pub async fn generate_ready_payload(
+        &mut self,
+        db: &Database,
+        fields: Vec<ReadyPayloadFields>,
+    ) -> Result<EventV1> {
+        let user = self.clone_user();
+        self.cache.is_bot = user.bot.is_some();
+
+        // Fetch pending policy changes.
+        let policy_changes = if user.bot.is_some() {
+            vec![]
+        } else {
+            db.fetch_policy_changes()
+                .await?
+                .into_iter()
+                .filter(|policy| policy.created_time > user.last_acknowledged_policy_change)
+                .map(Into::into)
+                .collect()
+        };
+
+        // Find all relationships to the user.
+        let mut user_ids: HashSet<String> = user
+            .relations
+            .as_ref()
+            .map(|arr| arr.iter().map(|x| x.id.to_string()).collect())
+            .unwrap_or_default();
+
+        // Fetch all memberships with their corresponding servers.
+        let members: Vec<Member> = db.fetch_all_memberships(&user.id).await?;
+        self.cache.members = members
+            .iter()
+            .cloned()
+            .map(|x| (x.id.server.clone(), x))
+            .collect();
+
+        let server_ids: Vec<String> = members.iter().map(|x| x.id.server.clone()).collect();
+        let servers = db.fetch_servers(&server_ids).await?;
+        self.cache.servers = servers.iter().cloned().map(|x| (x.id.clone(), x)).collect();
+
+        // Collect channel ids from servers.
+        let mut channel_ids = vec![];
+        for server in &servers {
+            channel_ids.append(&mut server.channels.clone());
+        }
+
+        // Fetch DMs and server channels.
+        let mut channels = db.find_direct_messages(&user.id).await?;
+        channels.append(&mut db.fetch_channels(&channel_ids).await?);
+
+        // Filter server channels by permission.
+        let channels = self.cache.filter_accessible_channels(db, channels).await;
+
+        // Append known user IDs from DMs.
+        for channel in &channels {
+            match channel {
+                Channel::DirectMessage { recipients, .. } | Channel::Group { recipients, .. } => {
+                    user_ids.extend(&mut recipients.clone().into_iter());
+                }
+                _ => {}
+            }
+        }
+
+        // Fetch presence data for known users.
+        let online_ids = filter_online(&user_ids.iter().cloned().collect::<Vec<String>>()).await;
+
+        // Fetch user data.
+        let users = db
+            .fetch_users(
+                &user_ids
+                    .into_iter()
+                    .filter(|x| x != &user.id)
+                    .collect::<Vec<String>>(),
+            )
+            .await?;
+
+        // Fetch customisations.
+        let emojis = if fields.contains(&ReadyPayloadFields::Emoji) {
+            Some(
+                db.fetch_emoji_by_parent_ids(
+                    &servers
+                        .iter()
+                        .map(|x| x.id.to_string())
+                        .collect::<Vec<String>>(),
+                )
+                .await?,
+            )
+        } else {
+            None
+        };
+
+        // Fetch user settings
+        let user_settings = if let Some(ReadyPayloadFields::UserSettings(keys)) = fields
+            .iter()
+            .find(|e| matches!(e, ReadyPayloadFields::UserSettings(_)))
+        {
+            Some(db.fetch_user_settings(&user.id, keys).await?)
+        } else {
+            None
+        };
+
+        // Fetch channel unreads
+        let channel_unreads = if fields.contains(&ReadyPayloadFields::ChannelUnreads) {
+            Some(db.fetch_unreads(&user.id).await?)
+        } else {
+            None
+        };
+
+        // Copy data into local state cache.
+        self.cache.users = users.iter().cloned().map(|x| (x.id.clone(), x)).collect();
+        self.cache
+            .users
+            .insert(self.cache.user_id.clone(), user.clone());
+        self.cache.channels = channels
+            .iter()
+            .cloned()
+            .map(|x| (x.id().to_string(), x))
+            .collect();
+
+        // Make all users appear from our perspective.
+        let mut users: Vec<v0::User> = join_all(users.into_iter().map(|other_user| async {
+            let is_online = online_ids.contains(&other_user.id);
+            other_user.into_known(&user, is_online).await
+        }))
+        .await;
+
+        // Make sure we see our own user correctly.
+        users.push(user.into_self(true).await);
+
+        // Set subscription state internally.
+        self.reset_state().await;
+        self.insert_subscription(self.private_topic.clone()).await;
+
+        for user in &users {
+            self.insert_subscription(user.id.clone()).await;
+        }
+
+        for server in &servers {
+            self.insert_subscription(server.id.clone()).await;
+
+            if self.cache.is_bot {
+                self.insert_subscription(format!("{}u", server.id)).await;
+            }
+        }
+
+        for channel in &channels {
+            self.insert_subscription(channel.id().to_string()).await;
+        }
+
+        Ok(EventV1::Ready {
+            users: if fields.contains(&ReadyPayloadFields::Users) {
+                Some(users)
+            } else {
+                None
+            },
+            servers: if fields.contains(&ReadyPayloadFields::Servers) {
+                Some(servers.into_iter().map(Into::into).collect())
+            } else {
+                None
+            },
+            channels: if fields.contains(&ReadyPayloadFields::Channels) {
+                Some(channels.into_iter().map(Into::into).collect())
+            } else {
+                None
+            },
+            members: if fields.contains(&ReadyPayloadFields::Members) {
+                Some(members.into_iter().map(Into::into).collect())
+            } else {
+                None
+            },
+            emojis: emojis.map(|vec| vec.into_iter().map(Into::into).collect()),
+
+            user_settings,
+            channel_unreads: channel_unreads.map(|vec| vec.into_iter().map(Into::into).collect()),
+
+            policy_changes,
+        })
+    }
+
+    /// Re-determine the currently accessible server channels
+    pub async fn recalculate_server(&mut self, db: &Database, id: &str, event: &mut EventV1) {
+        if let Some(server) = self.cache.servers.get(id) {
+            let mut channel_ids = HashSet::new();
+            let mut added_channels = vec![];
+            let mut removed_channels = vec![];
+
+            let id = &id.to_string();
+            for (channel_id, channel) in &self.cache.channels {
+                match channel {
+                    Channel::TextChannel { server, .. } | Channel::VoiceChannel { server, .. } => {
+                        if server == id {
+                            channel_ids.insert(channel_id.clone());
+
+                            if self.cache.can_view_channel(db, channel).await {
+                                added_channels.push(channel_id.clone());
+                            } else {
+                                removed_channels.push(channel_id.clone());
+                            }
+                        }
+                    }
+                    _ => {}
+                }
+            }
+
+            let known_ids = server.channels.iter().cloned().collect::<HashSet<String>>();
+
+            let mut bulk_events = vec![];
+
+            for id in added_channels {
+                self.insert_subscription(id).await;
+            }
+
+            for id in removed_channels {
+                self.remove_subscription(&id).await;
+                self.cache.channels.remove(&id);
+
+                bulk_events.push(EventV1::ChannelDelete { id });
+            }
+
+            // * NOTE: currently all channels should be cached
+            // * provided that a server was loaded from payload
+            let unknowns = known_ids
+                .difference(&channel_ids)
+                .cloned()
+                .collect::<Vec<String>>();
+
+            if !unknowns.is_empty() {
+                if let Ok(channels) = db.fetch_channels(&unknowns).await {
+                    let viewable_channels =
+                        self.cache.filter_accessible_channels(db, channels).await;
+
+                    for channel in viewable_channels {
+                        self.cache
+                            .channels
+                            .insert(channel.id().to_string(), channel.clone());
+
+                        self.insert_subscription(channel.id().to_string()).await;
+                        bulk_events.push(EventV1::ChannelCreate(channel.into()));
+                    }
+                }
+            }
+
+            if !bulk_events.is_empty() {
+                let mut new_event = EventV1::Bulk { v: bulk_events };
+                std::mem::swap(&mut new_event, event);
+
+                if let EventV1::Bulk { v } = event {
+                    v.push(new_event);
+                }
+            }
+        }
+    }
+
+    /// Push presence change to the user and all associated server topics
+    pub async fn broadcast_presence_change(&self, target: bool) {
+        if if let Some(status) = &self.cache.users.get(&self.cache.user_id).unwrap().status {
+            status.presence != Some(Presence::Invisible)
+        } else {
+            true
+        } {
+            let event = EventV1::UserUpdate {
+                id: self.cache.user_id.clone(),
+                data: v0::PartialUser {
+                    online: Some(target),
+                    ..Default::default()
+                },
+                clear: vec![],
+                event_id: Some(ulid::Ulid::new().to_string()),
+            };
+
+            for server in self.cache.servers.keys() {
+                event.clone().p(server.clone()).await;
+            }
+
+            event.p(self.cache.user_id.clone()).await;
+        }
+    }
+
+    /// Handle an incoming event for protocol version 1
+    pub async fn handle_incoming_event_v1(&mut self, db: &Database, event: &mut EventV1) -> bool {
+        /* Superseded by private topics.
+          if match event {
+            EventV1::UserRelationship { id, .. }
+            | EventV1::UserSettingsUpdate { id, .. }
+            | EventV1::ChannelAck { id, .. } => id != &self.cache.user_id,
+            EventV1::ServerCreate { server, .. } => server.owner != self.cache.user_id,
+            EventV1::ChannelCreate(channel) => match channel {
+                Channel::SavedMessages { user, .. } => user != &self.cache.user_id,
+                Channel::DirectMessage { recipients, .. } | Channel::Group { recipients, .. } => {
+                    !recipients.contains(&self.cache.user_id)
+                }
+                _ => false,
+            },
+            _ => false,
+        } {
+            return false;
+        }*/
+
+        // An event may trigger recalculation of an entire server's permission.
+        // Keep track of whether we need to do anything.
+        let mut queue_server = None;
+
+        // It may also need to sub or unsub a single value.
+        let mut queue_add = None;
+        let mut queue_remove = None;
+
+        match event {
+            EventV1::ChannelCreate(channel) => {
+                let id = channel.id().to_string();
+                self.insert_subscription(id.clone()).await;
+                self.cache.channels.insert(id, channel.clone().into());
+            }
+            EventV1::ChannelUpdate {
+                id, data, clear, ..
+            } => {
+                let could_view: bool = if let Some(channel) = self.cache.channels.get(id) {
+                    self.cache.can_view_channel(db, channel).await
+                } else {
+                    false
+                };
+
+                if let Some(channel) = self.cache.channels.get_mut(id) {
+                    for field in clear {
+                        channel.remove_field(&field.clone().into());
+                    }
+
+                    channel.apply_options(data.clone().into());
+                }
+
+                if !self.cache.channels.contains_key(id) {
+                    if let Ok(channel) = db.fetch_channel(id).await {
+                        self.cache.channels.insert(id.clone(), channel);
+                    }
+                }
+
+                if let Some(channel) = self.cache.channels.get(id) {
+                    let can_view = self.cache.can_view_channel(db, channel).await;
+                    if could_view != can_view {
+                        if can_view {
+                            queue_add = Some(id.clone());
+                            *event = EventV1::ChannelCreate(channel.clone().into());
+                        } else {
+                            queue_remove = Some(id.clone());
+                            *event = EventV1::ChannelDelete { id: id.clone() };
+                        }
+                    }
+                }
+            }
+            EventV1::ChannelDelete { id } => {
+                self.remove_subscription(id).await;
+                self.cache.channels.remove(id);
+            }
+            EventV1::ChannelGroupJoin { user, .. } => {
+                self.insert_subscription(user.clone()).await;
+            }
+            EventV1::ChannelGroupLeave { id, user, .. } => {
+                if user == &self.cache.user_id {
+                    self.remove_subscription(id).await;
+                } else if !self.cache.can_subscribe_to_user(user) {
+                    self.remove_subscription(user).await;
+                }
+            }
+
+            EventV1::ServerCreate {
+                id,
+                server,
+                channels,
+                emojis: _,
+            } => {
+                self.insert_subscription(id.clone()).await;
+
+                if self.cache.is_bot {
+                    self.insert_subscription(format!("{}u", id)).await;
+                }
+
+                self.cache.servers.insert(id.clone(), server.clone().into());
+                let member = Member {
+                    id: MemberCompositeKey {
+                        server: server.id.clone(),
+                        user: self.cache.user_id.clone(),
+                    },
+                    ..Default::default()
+                };
+                self.cache.members.insert(id.clone(), member);
+
+                for channel in channels {
+                    self.cache
+                        .channels
+                        .insert(channel.id().to_string(), channel.clone().into());
+                }
+
+                queue_server = Some(id.clone());
+            }
+            EventV1::ServerUpdate {
+                id, data, clear, ..
+            } => {
+                if let Some(server) = self.cache.servers.get_mut(id) {
+                    for field in clear {
+                        server.remove_field(&field.clone().into());
+                    }
+
+                    server.apply_options(data.clone().into());
+                }
+
+                if data.default_permissions.is_some() {
+                    queue_server = Some(id.clone());
+                }
+            }
+            EventV1::ServerMemberJoin { .. } => {
+                // We will always receive ServerCreate when joining a new server.
+            }
+            EventV1::ServerMemberLeave { id, user, .. } => {
+                if user == &self.cache.user_id {
+                    self.remove_subscription(id).await;
+
+                    if let Some(server) = self.cache.servers.remove(id) {
+                        for channel in &server.channels {
+                            self.remove_subscription(channel).await;
+                            self.cache.channels.remove(channel);
+                        }
+                    }
+                    self.cache.members.remove(id);
+                }
+            }
+            EventV1::ServerDelete { id } => {
+                self.remove_subscription(id).await;
+
+                if let Some(server) = self.cache.servers.remove(id) {
+                    for channel in &server.channels {
+                        self.remove_subscription(channel).await;
+                        self.cache.channels.remove(channel);
+                    }
+                }
+                self.cache.members.remove(id);
+            }
+            EventV1::ServerMemberUpdate { id, data, clear } => {
+                if id.user == self.cache.user_id {
+                    if let Some(member) = self.cache.members.get_mut(&id.server) {
+                        for field in &clear.clone() {
+                            member.remove_field(&field.clone().into());
+                        }
+
+                        member.apply_options(data.clone().into());
+                    }
+
+                    if data.roles.is_some() || clear.contains(&v0::FieldsMember::Roles) {
+                        queue_server = Some(id.server.clone());
+                    }
+                }
+            }
+            EventV1::ServerRoleUpdate {
+                id,
+                role_id,
+                data,
+                clear,
+                ..
+            } => {
+                if let Some(server) = self.cache.servers.get_mut(id) {
+                    if let Some(role) = server.roles.get_mut(role_id) {
+                        for field in &clear.clone() {
+                            role.remove_field(&field.clone().into());
+                        }
+
+                        role.apply_options(data.clone().into());
+                    }
+                }
+
+                if data.rank.is_some() || data.permissions.is_some() {
+                    if let Some(member) = self.cache.members.get(id) {
+                        if member.roles.contains(role_id) {
+                            queue_server = Some(id.clone());
+                        }
+                    }
+                }
+            }
+            EventV1::ServerRoleDelete { id, role_id } => {
+                if let Some(server) = self.cache.servers.get_mut(id) {
+                    server.roles.remove(role_id);
+                }
+
+                if let Some(member) = self.cache.members.get(id) {
+                    if member.roles.contains(role_id) {
+                        queue_server = Some(id.clone());
+                    }
+                }
+            }
+
+            EventV1::UserUpdate { event_id, .. } => {
+                if let Some(id) = event_id {
+                    if self.cache.seen_events.contains(id) {
+                        return false;
+                    }
+
+                    self.cache.seen_events.put(id.to_string(), ());
+                }
+
+                *event_id = None;
+            }
+            EventV1::UserRelationship { id, user, .. } => {
+                self.cache.users.insert(id.clone(), user.clone().into());
+
+                if self.cache.can_subscribe_to_user(id) {
+                    self.insert_subscription(id.clone()).await;
+                } else {
+                    self.remove_subscription(id).await;
+                }
+            }
+
+            EventV1::Message(message) => {
+                // Since Message events are fanned out to many clients,
+                // we must reconstruct the relationship value at this end.
+                if let Some(user) = &mut message.user {
+                    user.relationship = self
+                        .cache
+                        .users
+                        .get(&self.cache.user_id)
+                        .expect("missing self?")
+                        .relationship_with(&message.author)
+                        .into();
+                }
+            }
+
+            _ => {}
+        }
+
+        // Calculate server permissions if requested.
+        if let Some(server_id) = queue_server {
+            self.recalculate_server(db, &server_id, event).await;
+        }
+
+        // Sub / unsub accordingly.
+        if let Some(id) = queue_add {
+            self.insert_subscription(id).await;
+        }
+
+        if let Some(id) = queue_remove {
+            self.remove_subscription(&id).await;
+        }
+
+        true
+    }
+}

crates/bonfire/src/events/mod.rs

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

crates/bonfire/src/events/state.rs

@@ -0,0 +1,214 @@
+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 user_id: String,
+    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()
+        };
+
+        let user_id = user.id.clone();
+        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,
+            ))),
+            user_id,
+            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);
+    }
+}

crates/bonfire/src/main.rs

@@ -0,0 +1,43 @@
+use std::env;
+
+use async_std::net::TcpListener;
+use revolt_presence::clear_region;
+
+#[macro_use]
+extern crate log;
+
+pub mod client;
+
+mod config;
+mod database;
+mod events;
+mod websocket;
+
+#[async_std::main]
+async fn main() {
+    // Configure requirements for Bonfire.
+    revolt_config::configure!(events);
+    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;
+    }
+
+    // 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());
+    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:?}");
+        });
+    }
+}

crates/bonfire/src/websocket.rs

@@ -0,0 +1,39 @@
+use std::net::SocketAddr;
+
+use async_std::net::TcpStream;
+use futures::channel::oneshot;
+use revolt_database::Database;
+
+use crate::client::core::client_core;
+use crate::config::WebsocketHandshakeCallback;
+
+/// Start 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;
+    };
+
+    // Verify we've received a valid config, otherwise we should just drop the connection.
+    let Ok(config) = receiver.await else {
+        return;
+    };
+
+    info!(
+        "User {addr:?} provided protocol configuration (version = {}, format = {:?})",
+        config.get_protocol_version(),
+        config.get_protocol_format()
+    );
+
+    client_core(db, ws, config).await;
+}

crates/core/broker/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "revolt-broker"
+version = "0.8.8"
+edition = "2024"
+license = "AGPL-3.0-or-later"
+authors = ["Paul Makles <me@insrt.uk>"]
+description = "Revolt Backend: Event Broker"
+
+[dependencies]
+# Utility
+log = "0.4"
+rand = "0.9.1"
+
+# RabbitMQ/AMQP client
+lapin = "3.0.0"
+
+# Async runtime
+async-std = { version = "1.8.0" }
+
+# Serialisation
+serde = "1"
+rmp-serde = "1.3.0"
+
+# Core
+revolt-config = { version = "0.8.8", path = "../config" }

crates/core/broker/src/event_stream/consumer.rs

@@ -0,0 +1,180 @@
+use std::{
+    collections::{HashMap, HashSet},
+    sync::Arc,
+};
+
+use async_std::stream::StreamExt;
+use lapin::{
+    Channel, Connection,
+    options::BasicAckOptions,
+    types::{AMQPValue, FieldArray, FieldTable, LongLongInt},
+};
+use log::info;
+use rand::Rng;
+use revolt_config::{capture_internal_error, config};
+use serde::de::DeserializeOwned;
+
+use crate::event_stream::{create_channel, get_connection};
+
+pub struct Consumer {
+    #[allow(dead_code)]
+    conn: Arc<Connection>,
+    channel: Channel,
+    tag: String,
+    topics: HashSet<String>,
+    topics_changed: bool,
+    consumer: Option<lapin::Consumer>,
+    offset: Option<LongLongInt>,
+}
+
+impl Consumer {
+    /// Create a new event stream consumer
+    pub async fn new() -> Consumer {
+        let config = config().await;
+        let conn = get_connection().await;
+        let channel = create_channel(&conn, config.rabbit.event_stream).await;
+
+        Consumer {
+            conn,
+            channel,
+            tag: rand::rng()
+                .sample_iter::<char, _>(&rand::distr::StandardUniform)
+                .take(32)
+                .collect(),
+            topics: HashSet::new(),
+            topics_changed: false,
+            consumer: None,
+            offset: None,
+        }
+    }
+
+    /// Update the set of topics
+    pub fn set_topics(&mut self, topics: HashSet<String>) {
+        self.topics = topics;
+        self.topics_changed = true;
+    }
+
+    /// Get the current consumer
+    pub async fn ensure_consumer(&mut self) {
+        if self.topics_changed {
+            info!("Topics changed, disposing the consumer.");
+            self.dispose_consumer().await;
+            self.topics_changed = false;
+        }
+
+        if self.consumer.is_none() {
+            info!("Creating a new consumer, tag={}", self.tag);
+            let config = config().await;
+
+            // Build arguments for consumer
+            let mut args: FieldTable = Default::default();
+
+            // Configure stream filter to select topics we are listening for
+            {
+                let mut filter: FieldArray = Default::default();
+                for topic in &self.topics {
+                    filter.push(AMQPValue::LongString(topic.as_str().into()));
+                }
+
+                args.insert("x-stream-filter".into(), AMQPValue::FieldArray(filter));
+            }
+
+            // Set stream offset if applicable
+            if let Some(offset) = self.offset {
+                args.insert("x-stream-offset".into(), AMQPValue::LongLongInt(offset));
+            }
+
+            // Create the consumer
+            self.consumer = Some(
+                self.channel
+                    .basic_consume(
+                        &config.rabbit.event_stream.queue,
+                        &self.tag,
+                        Default::default(),
+                        args,
+                    )
+                    .await
+                    .unwrap(),
+            );
+        }
+    }
+
+    /// Close the active consumer if one exists
+    pub async fn dispose_consumer(&mut self) {
+        if let Some(consumer) = self.consumer.as_ref() {
+            if consumer.state().is_active() {
+                if let Err(err) = self
+                    .channel
+                    .basic_cancel(&self.tag, Default::default())
+                    .await
+                {
+                    eprintln!("Failed to close consumer! {:?}", err);
+                }
+
+                // is this necessary?
+                // else {
+                // Read the consumer to the end
+                //     while let Some(delivery) = consumer.next().await {
+                //         let delivery = delivery.expect("error in consumer");
+                //         delivery.ack(BasicAckOptions::default()).await.expect("ack");
+                //     }
+                // }
+            }
+
+            self.consumer = None;
+        }
+    }
+
+    /// Close the active channel
+    pub async fn dispose_channel(&mut self) {
+        // Close the channel -- don't do this actually
+        capture_internal_error!(self.channel.close(0, "closing channel").await);
+    }
+
+    /// Get the next item
+    pub async fn next<T: DeserializeOwned>(&mut self) -> Option<T> {
+        self.ensure_consumer().await;
+
+        let consumer = self.consumer.as_mut().unwrap();
+
+        while let Some(Ok(delivery)) = consumer.next().await {
+            // Acknowledgement is required
+            delivery.ack(BasicAckOptions::default()).await.expect("ack");
+
+            // Parse the delivery headers
+            let headers: HashMap<String, AMQPValue> = delivery
+                .properties
+                .headers()
+                .as_ref()
+                .map(|table| {
+                    table
+                        .into_iter()
+                        .map(|(k, v)| (k.to_string(), v.clone()))
+                        .collect()
+                })
+                .unwrap_or_default();
+
+            // Keep track of the current offset
+            let stream_offset = headers
+                .get("x-stream-offset")
+                .expect("`x-stream-offset` not present in message!");
+
+            self.offset = Some(stream_offset.as_long_long_int().unwrap() + 1);
+
+            // Client-side topic filtering (broker uses Bloom filter so may have false-positives)
+            let filter_value = headers
+                .get("x-stream-filter-value")
+                .expect("`x-stream-filter-value` not present in message!")
+                .as_long_string()
+                .expect("`string`")
+                .to_string();
+
+            if self.topics.contains(&filter_value) {
+                // Deserialise the data
+                return Some(rmp_serde::from_slice(&delivery.data).expect("`data`"));
+            }
+        }
+
+        None
+    }
+}

crates/core/broker/src/event_stream/mod.rs

@@ -0,0 +1,7 @@
+mod consumer;
+mod pool;
+mod publish;
+
+pub use consumer::Consumer;
+pub use pool::{create_channel, get_connection};
+pub use publish::publish_event;

crates/core/broker/src/event_stream/pool.rs

@@ -0,0 +1,99 @@
+use async_std::sync::Mutex;
+use lapin::{
+    Connection,
+    options::QueueDeclareOptions,
+    types::{AMQPValue, FieldTable},
+};
+use log::{debug, warn};
+use revolt_config::{RabbitEventStream, config};
+use std::sync::Arc;
+
+use crate::create_client;
+
+/// Get a handle to the event stream
+pub async fn get_connection() -> Arc<Connection> {
+    let config = config().await;
+
+    static CONNECTIONS: Mutex<Vec<Arc<Connection>>> = Mutex::new(Vec::new());
+
+    let mut connections = CONNECTIONS.lock().await;
+    connections.retain(|item| {
+        if item.status().connected() {
+            true
+        } else {
+            warn!(
+                "Dropping connection with status {:?}",
+                item.status().state()
+            );
+
+            false
+        }
+    });
+
+    debug!(
+        "Connections: {}, Clients: {:?}",
+        connections.len(),
+        connections
+            .iter()
+            .map(Arc::strong_count)
+            .collect::<Vec<usize>>()
+    );
+
+    for conn in connections.iter() {
+        if Arc::strong_count(conn) < config.rabbit.event_stream.channels_per_conn {
+            return conn.clone();
+        }
+    }
+
+    let conn = Arc::new(create_client().await);
+
+    connections.push(conn.clone());
+    conn
+}
+
+/// Create a channel
+pub async fn create_channel(
+    conn: &lapin::Connection,
+    event_stream: RabbitEventStream,
+) -> lapin::Channel {
+    let channel = conn.create_channel().await.unwrap();
+
+    let mut args: FieldTable = Default::default();
+
+    args.insert(
+        // set queue type to stream
+        "x-queue-type".into(),
+        AMQPValue::LongString("stream".into()),
+    );
+
+    args.insert(
+        // max. size of the stream
+        "x-max-length-bytes".into(),
+        AMQPValue::LongLongInt(event_stream.stream_max_length_bytes),
+    );
+
+    args.insert(
+        // size of the Bloom filter
+        "x-stream-filter-size-bytes".into(),
+        AMQPValue::LongLongInt(event_stream.filter_size_bytes),
+    );
+
+    channel
+        .queue_declare(
+            &event_stream.queue,
+            QueueDeclareOptions {
+                durable: true,
+                ..Default::default()
+            },
+            args,
+        )
+        .await
+        .unwrap();
+
+    channel
+        .basic_qos(event_stream.qos_prefetch, Default::default())
+        .await
+        .unwrap();
+
+    channel
+}

crates/core/broker/src/event_stream/publish.rs

@@ -0,0 +1,37 @@
+use lapin::{
+    Error,
+    protocol::basic::AMQPProperties,
+    publisher_confirm::PublisherConfirm,
+    types::{AMQPValue, FieldTable},
+};
+use revolt_config::config;
+use serde::Serialize;
+
+use crate::event_stream::{create_channel, get_connection};
+
+/// Publish an event to the message broker
+pub async fn publish_event<T: Serialize>(
+    channel: &str,
+    data: &T,
+) -> Result<PublisherConfirm, Error> {
+    let config = config().await;
+
+    let mut headers: FieldTable = Default::default();
+    headers.insert(
+        "x-stream-filter-value".into(),
+        AMQPValue::LongString(channel.into()),
+    );
+
+    let conn = get_connection().await;
+
+    create_channel(&conn, config.rabbit.event_stream.clone())
+        .await
+        .basic_publish(
+            &config.rabbit.event_stream.exchange,
+            &config.rabbit.event_stream.queue,
+            Default::default(),
+            &rmp_serde::to_vec_named(data).unwrap(),
+            AMQPProperties::default().with_headers(headers),
+        )
+        .await
+}

crates/core/broker/src/lib.rs

@@ -0,0 +1,18 @@
+use revolt_config::config;
+
+pub mod event_stream;
+
+/// Create a lapin client
+pub async fn create_client() -> lapin::Connection {
+    let config = config().await;
+
+    lapin::Connection::connect(
+        &format!(
+            "amqp://{}:{}@{}:{}/%2f",
+            config.rabbit.username, config.rabbit.password, config.rabbit.host, config.rabbit.port
+        ),
+        Default::default(),
+    )
+    .await
+    .unwrap()
+}

crates/core/config/Cargo.toml

@@ -0,0 +1,39 @@
+[package]
+name = "revolt-config"
+version = "0.8.8"
+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]
+anyhow = ["dep:sentry-anyhow"]
+report-macros = ["revolt-result"]
+test = ["async-std"]
+default = ["test", "anyhow"]
+
+[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"
+sentry-anyhow = { version = "0.38.1", optional = true }
+
+# Core
+revolt-result = { version = "0.8.8", path = "../result", optional = true }

crates/core/config/LICENSE

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

crates/core/config/Revolt.test.toml

@@ -0,0 +1,12 @@
+[database]
+mongodb = "mongodb://localhost"
+redis = "redis://localhost/"
+
+[rabbit]
+host = "127.0.0.1"
+port = 5672
+username = "rabbituser"
+password = "rabbitpass"
+
+[features]
+webhooks_enabled = true

crates/core/config/Revolt.toml

@@ -0,0 +1,293 @@
+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"
+
+[rabbit.event_stream]
+# Configuration for event brokerage
+# Using default/direct exchange
+exchange = ""
+queue = "revolt.events"
+# Number of channels that can be opened per single TCP connection
+channels_per_conn = 128
+# Maximum size of the stream
+stream_max_length_bytes = 5_000_000_000
+# Size of the Bloom filter
+filter_size_bytes = 26
+# Number of messages to prefetch
+qos_prefetch = 100
+
+[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
+# easypwned endpoint
+easypwned = ""
+
+[api.security.captcha]
+# hCaptcha configuration
+hcaptcha_key = ""
+hcaptcha_sitekey = ""
+
+[api.workers]
+# Maximum concurrent connections (to proxy server)
+max_concurrent_connections = 50
+
+[api.users]
+
+
+[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
+
+# Changes how many users are processed in each chunk when resolving role/everyone mentions.
+# Increasing this will resolve mentions faster, but will consume more memory while resolving.
+mass_mention_chunk_size = 200
+
+# none of these should need changing
+exchange = "revolt.notifications"
+message_queue = "notifications.origin.message"
+mass_mention_queue = "notifications.origin.mass_mention" # handles messages that contain role or everyone mentions
+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]
+# Feature gate options
+webhooks_enabled = false
+# Enable push notifications for mass pings (everyone, online, roles)
+# When false this will still ping in-client but will not send notifications from pushd
+mass_mentions_send_notifications = true
+# Can role/everyone pings be used at all
+mass_mentions_enabled = true
+
+[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 = ""
+pushd = ""
+crond = ""

crates/core/config/src/lib.rs

@@ -0,0 +1,480 @@
+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};
+pub use sentry_anyhow::capture_anyhow;
+
+#[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",
+];
+
+/// Path to search for test overrides
+static TEST_OVERRIDE_PATH: &str = "Revolt.test-overrides.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,
+            ));
+
+            // recursively search upwards for an overrides file (if there is one)
+            if let Ok(cwd) = std::env::current_dir() {
+                let mut path = Some(cwd.as_path());
+                while let Some(current_path) = path {
+                    let target_path = current_path.join(TEST_OVERRIDE_PATH);
+                    if target_path.exists() {
+                        builder = builder
+                            .add_source(File::new(target_path.to_str().unwrap(), FileFormat::Toml));
+                    }
+
+                    path = current_path.parent();
+                }
+            }
+        }
+
+        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 RabbitEventStream {
+    pub exchange: String,
+    pub queue: String,
+    pub channels_per_conn: usize,
+    pub stream_max_length_bytes: i64,
+    pub filter_size_bytes: i64,
+    pub qos_prefetch: u16,
+}
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct Rabbit {
+    pub host: String,
+    pub port: u16,
+    pub username: String,
+    pub password: String,
+
+    pub event_stream: RabbitEventStream,
+}
+
+#[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>,
+    pub use_starttls: 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,
+    pub easypwned: String,
+}
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct ApiWorkers {
+    pub max_concurrent_connections: usize,
+}
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct ApiUsers {
+    pub early_adopter_cutoff: Option<u64>,
+}
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct Api {
+    pub registration: ApiRegistration,
+    pub smtp: ApiSmtp,
+    pub security: ApiSecurity,
+    pub workers: ApiWorkers,
+    pub users: ApiUsers,
+}
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct Pushd {
+    pub production: bool,
+    pub exchange: String,
+    pub mass_mention_chunk_size: usize,
+
+    // Queues
+    pub message_queue: String,
+    pub mass_mention_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_mass_mention_routing_key(&self) -> String {
+        self.get_routing_key(self.mass_mention_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,
+    pub mass_mentions_send_notifications: bool,
+    pub mass_mentions_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 pushd: 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();
+
+    // inject REDIS_URI for redis-kiss library
+    if std::env::var("REDIS_URL").is_err() {
+        std::env::set_var("REDIS_URI", config.database.redis.clone());
+    }
+
+    // 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");
+    }
+
+    pretty_env_logger::init();
+    log::info!("Starting {release}");
+
+    if dsn.is_empty() {
+        None
+    } else {
+        Some(sentry::init((
+            dsn,
+            sentry::ClientOptions {
+                release: Some(release.into()),
+                ..Default::default()
+            },
+        )))
+    }
+}
+
+#[macro_export]
+macro_rules! configure {
+    ($application: ident) => {
+        let config = $crate::config().await;
+        let _sentry = $crate::setup_logging(
+            concat!(env!("CARGO_PKG_NAME"), "@", env!("CARGO_PKG_VERSION")),
+            config.sentry.$application,
+        )
+        .await;
+    };
+}
+
+#[cfg(feature = "test")]
+#[cfg(test)]
+mod tests {
+    use crate::init;
+
+    #[async_std::test]
+    async fn it_works() {
+        init().await;
+    }
+}

crates/core/database/Cargo.toml

@@ -0,0 +1,106 @@
+[package]
+name = "revolt-database"
+version = "0.8.8"
+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.8", path = "../config", features = [
+    "report-macros",
+] }
+revolt-result = { version = "0.8.8", path = "../result" }
+revolt-models = { version = "0.8.8", path = "../models", features = [
+    "validator",
+] }
+revolt-presence = { version = "0.8.8", path = "../presence" }
+revolt-permissions = { version = "0.8.8", path = "../permissions", features = [
+    "serde",
+    "bson",
+] }
+revolt-parser = { version = "0.8.8", path = "../parser" }
+revolt-broker = { version = "0.8.8", path = "../broker" }
+
+# 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"
+rmp-serde = "1.0.0"
+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 = "3.1.0" }
+
+# 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.15", features = ["rocket_impl"] }
+
+# RabbitMQ
+amqprs = { version = "1.7.0" }
+lapin = { version = "3.0.0" }

crates/core/database/fixtures/group_with_members.json

@@ -0,0 +1,34 @@
+[
+  {
+    "_object_type": "User",
+    "_id": "__ID:0__",
+    "username": "Owner",
+    "last_acknowledged_policy_change": "2025-06-07T04:04:48+0000",
+    "discriminator": "0001"
+  },
+  {
+    "_object_type": "User",
+    "_id": "__ID:1__",
+    "username": "Member",
+    "last_acknowledged_policy_change": "2025-06-07T04:04:48+0000",
+    "discriminator": "0001"
+  },
+  {
+    "_object_type": "User",
+    "_id": "__ID:2__",
+    "username": "Member",
+    "last_acknowledged_policy_change": "2025-06-07T04:04:48+0000",
+    "discriminator": "0002"
+  },
+  {
+    "_object_type": "Channel",
+    "_id": "__ID:3__",
+    "channel_type": "Group",
+    "name": "My Group",
+    "owner": "__ID:0__",
+    "recipients": [
+      "__ID:0__",
+      "__ID:1__"
+    ]
+  }
+]

crates/core/database/fixtures/server_with_roles.json

@@ -0,0 +1,98 @@
+[
+  {
+    "_object_type": "User",
+    "_id": "__ID:0__",
+    "username": "Owner",
+    "last_acknowledged_policy_change": "2025-06-07T04:04:48+0000",
+    "discriminator": "0001"
+  },
+  {
+    "_object_type": "User",
+    "_id": "__ID:1__",
+    "username": "Moderator",
+    "last_acknowledged_policy_change": "2025-06-07T04:04:48+0000",
+    "discriminator": "0001"
+  },
+  {
+    "_object_type": "User",
+    "_id": "__ID:2__",
+    "username": "User",
+    "last_acknowledged_policy_change": "2025-06-07T04:04:48+0000",
+    "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": 1
+      },
+      "__ID:6__": {
+        "name": "Owner",
+        "permissions": {
+          "a": 0,
+          "d": 0
+        },
+        "rank": 0
+      }
+    },
+    "default_permissions": 4000322560
+  },
+  {
+    "_object_type": "ServerMember",
+    "_id": {
+      "user": "__ID:0__",
+      "server": "__ID:4__"
+    },
+    "roles": [
+      "__ID:6__"
+    ],
+    "joined_at": 1698318340195
+  },
+  {
+    "_object_type": "ServerMember",
+    "_id": {
+      "user": "__ID:1__",
+      "server": "__ID:4__"
+    },
+    "roles": [
+      "__ID:5__"
+    ],
+    "joined_at": 1698318340195
+  },
+  {
+    "_object_type": "ServerMember",
+    "_id": {
+      "user": "__ID:2__",
+      "server": "__ID:4__"
+    },
+    "joined_at": 1698318340195
+  }
+]

crates/core/database/src/amqp/amqp.rs

@@ -0,0 +1,243 @@
+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 mass_mention_message_sent(
+        &self,
+        server_id: String,
+        payload: Vec<PushNotification>,
+    ) -> Result<(), AMQPError> {
+        let config = revolt_config::config().await;
+
+        let payload = MassMessageSentPayload {
+            notifications: payload,
+            server_id,
+        };
+        let payload = to_string(&payload).unwrap();
+
+        let routing_key = config.pushd.get_mass_mention_routing_key();
+
+        debug!(
+            "Sending mass mention payload on channel {}: {}",
+            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, routing_key.as_str()),
+            )
+            .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
+    }
+}

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

@@ -0,0 +1,2 @@
+#[allow(clippy::module_inception)]
+pub mod amqp;

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

@@ -0,0 +1,230 @@
+mod mongodb;
+mod reference;
+
+use authifier::config::Captcha;
+use authifier::config::EmailVerificationConfig;
+use authifier::config::PasswordScanning;
+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 {
+            password_scanning: if config.api.security.easypwned.is_empty() {
+                Default::default()
+            } else {
+                PasswordScanning::EasyPwned {
+                    endpoint: config.api.security.easypwned,
+                }
+            },
+            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,
+                        use_starttls: config.api.smtp.use_starttls,
+                    },
+                    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()),
+                            },
+                            reset_existing: Template {
+                                title: "You already have a Revolt account, reset your password."
+                                    .into(),
+                                text: include_str!("../../templates/reset-existing.txt").into(),
+                                url: format!("{}/login/reset/", config.hosts.app),
+                                html: Some(
+                                    include_str!("../../templates/reset-existing.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,
+                            },
+                            reset_existing: 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()),
+        }
+    }
+}

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

@@ -0,0 +1,245 @@
+use std::collections::HashMap;
+use std::ops::Deref;
+
+use futures::StreamExt;
+use mongodb::bson::{doc, to_document, Document};
+use mongodb::error::Result;
+use mongodb::options::{FindOneOptions, FindOptions};
+use mongodb::results::{DeleteResult, InsertOneResult, UpdateResult};
+use serde::de::DeserializeOwned;
+use serde::Serialize;
+
+database_derived!(
+    #[cfg(feature = "mongodb")]
+    /// MongoDB implementation
+    pub struct MongoDb(pub ::mongodb::Client, pub String);
+);
+
+impl Deref for MongoDb {
+    type Target = mongodb::Client;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+#[allow(dead_code)]
+impl MongoDb {
+    /// Get the Revolt database
+    pub fn db(&self) -> mongodb::Database {
+        self.database(&self.1)
+    }
+
+    /// Get a collection by its name
+    pub fn col<T: Send + Sync>(&self, collection: &str) -> mongodb::Collection<T> {
+        self.db().collection(collection)
+    }
+
+    /// Insert one document into a collection
+    pub async fn insert_one<T: Serialize + Send + Sync>(
+        &self,
+        collection: &'static str,
+        document: T,
+    ) -> Result<InsertOneResult> {
+        self.col::<T>(collection).insert_one(document).await
+    }
+
+    /// Count documents by projection
+    pub async fn count_documents(
+        &self,
+        collection: &'static str,
+        projection: Document,
+    ) -> Result<u64> {
+        self.col::<Document>(collection)
+            .count_documents(projection)
+            .await
+    }
+
+    /// Find multiple documents in a collection with options
+    pub async fn find_with_options<O, T: DeserializeOwned + Unpin + Send + Sync>(
+        &self,
+        collection: &'static str,
+        projection: Document,
+        options: O,
+    ) -> Result<Vec<T>>
+    where
+        O: Into<Option<FindOptions>>,
+    {
+        Ok(self
+            .col::<T>(collection)
+            .find(projection)
+            .with_options(options)
+            .await?
+            .filter_map(|s| async {
+                if cfg!(debug_assertions) {
+                    // Hard fail on invalid documents
+                    Some(s.unwrap())
+                } else {
+                    s.ok()
+                }
+            })
+            .collect::<Vec<T>>()
+            .await)
+    }
+
+    /// Find multiple documents in a collection
+    pub async fn find<T: DeserializeOwned + Unpin + Send + Sync>(
+        &self,
+        collection: &'static str,
+        projection: Document,
+    ) -> Result<Vec<T>> {
+        self.find_with_options(collection, projection, None).await
+    }
+
+    /// Find one document with options
+    pub async fn find_one_with_options<O, T: DeserializeOwned + Unpin + Send + Sync>(
+        &self,
+        collection: &'static str,
+        projection: Document,
+        options: O,
+    ) -> Result<Option<T>>
+    where
+        O: Into<Option<FindOneOptions>>,
+    {
+        self.col::<T>(collection)
+            .find_one(projection)
+            .with_options(options)
+            .await
+    }
+
+    /// Find one document
+    pub async fn find_one<T: DeserializeOwned + Unpin + Send + Sync>(
+        &self,
+        collection: &'static str,
+        projection: Document,
+    ) -> Result<Option<T>> {
+        self.find_one_with_options(collection, projection, None)
+            .await
+    }
+
+    /// Find one document by its ID
+    pub async fn find_one_by_id<T: DeserializeOwned + Unpin + Send + Sync>(
+        &self,
+        collection: &'static str,
+        id: &str,
+    ) -> Result<Option<T>> {
+        self.find_one(
+            collection,
+            doc! {
+                "_id": id
+            },
+        )
+        .await
+    }
+
+    /// Update one document given a projection, partial document, and list of paths to unset
+    pub async fn update_one<P, T: Serialize>(
+        &self,
+        collection: &'static str,
+        projection: Document,
+        partial: T,
+        remove: Vec<&dyn IntoDocumentPath>,
+        prefix: P,
+    ) -> Result<UpdateResult>
+    where
+        P: Into<Option<String>>,
+    {
+        let prefix = prefix.into();
+
+        let mut unset = doc! {};
+        for field in remove {
+            if let Some(path) = field.as_path() {
+                if let Some(prefix) = &prefix {
+                    unset.insert(prefix.to_owned() + path, 1_i32);
+                } else {
+                    unset.insert(path, 1_i32);
+                }
+            }
+        }
+
+        let query = doc! {
+            "$unset": unset,
+            "$set": if let Some(prefix) = &prefix {
+                to_document(&prefix_keys(&partial, prefix))
+            } else {
+                to_document(&partial)
+            }?
+        };
+
+        self.col::<Document>(collection)
+            .update_one(projection, query)
+            .await
+    }
+
+    /// Update one document given an ID, partial document, and list of paths to unset
+    pub async fn update_one_by_id<P, T: Serialize>(
+        &self,
+        collection: &'static str,
+        id: &str,
+        partial: T,
+        remove: Vec<&dyn IntoDocumentPath>,
+        prefix: P,
+    ) -> Result<UpdateResult>
+    where
+        P: Into<Option<String>>,
+    {
+        self.update_one(
+            collection,
+            doc! {
+                "_id": id
+            },
+            partial,
+            remove,
+            prefix,
+        )
+        .await
+    }
+
+    /// Delete one document by the given projection
+    pub async fn delete_one(
+        &self,
+        collection: &'static str,
+        projection: Document,
+    ) -> Result<DeleteResult> {
+        self.col::<Document>(collection)
+            .delete_one(projection)
+            .await
+    }
+
+    /// Delete one document by the given ID
+    pub async fn delete_one_by_id(
+        &self,
+        collection: &'static str,
+        id: &str,
+    ) -> Result<DeleteResult> {
+        self.delete_one(
+            collection,
+            doc! {
+                "_id": id
+            },
+        )
+        .await
+    }
+}
+
+/// Just a string ID struct
+#[derive(Deserialize)]
+pub struct DocumentId {
+    #[serde(rename = "_id")]
+    pub id: String,
+}
+
+pub trait IntoDocumentPath: Send + Sync {
+    /// Create JSON key path
+    fn as_path(&self) -> Option<&'static str>;
+}
+
+/// Prefix keys on an arbitrary object
+pub fn prefix_keys<T: Serialize>(t: &T, prefix: &str) -> HashMap<String, serde_json::Value> {
+    let v: String = serde_json::to_string(t).unwrap();
+    let v: HashMap<String, serde_json::Value> = serde_json::from_str(&v).unwrap();
+    v.into_iter()
+        .filter(|(_k, v)| !v.is_null())
+        .map(|(k, v)| (format!("{}{}", prefix.to_owned(), k), v))
+        .collect()
+}

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

@@ -0,0 +1,34 @@
+use std::{collections::HashMap, sync::Arc};
+
+use futures::lock::Mutex;
+
+use crate::{
+    Bot, Channel, ChannelCompositeKey, ChannelUnread, Emoji, File, FileHash, Invite, Member,
+    MemberCompositeKey, Message, PolicyChange, 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 policy_changes: Arc<Mutex<HashMap<String, PolicyChange>>>,
+        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>>>,
+    }
+);

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

@@ -0,0 +1,295 @@
+use authifier::AuthifierEvent;
+use revolt_broker::event_stream;
+use revolt_result::Error;
+use serde::{Deserialize, Serialize};
+
+use revolt_models::v0::{
+    AppendMessage, Channel, ChannelUnread, Emoji, FieldsChannel, FieldsMember, FieldsMessage,
+    FieldsRole, FieldsServer, FieldsUser, FieldsWebhook, Member, MemberCompositeKey, Message,
+    PartialChannel, PartialMember, PartialMessage, PartialRole, PartialServer, PartialUser,
+    PartialWebhook, PolicyChange, RemovalIntention, Report, Server, User, UserSettings, Webhook,
+};
+
+use crate::Database;
+
+/// Ping Packet
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(untagged)]
+pub enum Ping {
+    Binary(Vec<u8>),
+    Number(usize),
+}
+
+/// Fields provided in Ready payload
+#[derive(PartialEq)]
+pub enum ReadyPayloadFields {
+    Users,
+    Servers,
+    Channels,
+    Members,
+    Emoji,
+
+    UserSettings(Vec<String>),
+    ChannelUnreads,
+}
+
+/// Protocol Events
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(tag = "type")]
+pub enum EventV1 {
+    /// Multiple events
+    Bulk { v: Vec<EventV1> },
+    /// Error event
+    Error { data: Error },
+
+    /// Successfully authenticated
+    Authenticated,
+    /// Logged out
+    Logout,
+    /// Basic data to cache
+    Ready {
+        #[serde(skip_serializing_if = "Option::is_none")]
+        users: Option<Vec<User>>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        servers: Option<Vec<Server>>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        channels: Option<Vec<Channel>>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        members: Option<Vec<Member>>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        emojis: Option<Vec<Emoji>>,
+
+        #[serde(skip_serializing_if = "Option::is_none")]
+        user_settings: Option<UserSettings>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        channel_unreads: Option<Vec<ChannelUnread>>,
+
+        policy_changes: Vec<PolicyChange>,
+    },
+
+    /// Ping response
+    Pong { data: Ping },
+    /// New message
+    Message(Message),
+
+    /// Update existing message
+    MessageUpdate {
+        id: String,
+        channel: String,
+        data: PartialMessage,
+        #[serde(default)]
+        clear: Vec<FieldsMessage>,
+    },
+
+    /// Append information to existing message
+    MessageAppend {
+        id: String,
+        channel: String,
+        append: AppendMessage,
+    },
+
+    /// Delete message
+    MessageDelete { id: String, channel: String },
+
+    /// New reaction to a message
+    MessageReact {
+        id: String,
+        channel_id: String,
+        user_id: String,
+        emoji_id: String,
+    },
+
+    /// Remove user's reaction from message
+    MessageUnreact {
+        id: String,
+        channel_id: String,
+        user_id: String,
+        emoji_id: String,
+    },
+
+    /// Remove a reaction from message
+    MessageRemoveReaction {
+        id: String,
+        channel_id: String,
+        emoji_id: String,
+    },
+
+    /// Bulk delete messages
+    BulkMessageDelete { channel: String, ids: Vec<String> },
+
+    /// New server
+    ServerCreate {
+        id: String,
+        server: Server,
+        channels: Vec<Channel>,
+        emojis: Vec<Emoji>,
+    },
+
+    /// Update existing server
+    ServerUpdate {
+        id: String,
+        data: PartialServer,
+        #[serde(default)]
+        clear: Vec<FieldsServer>,
+    },
+
+    /// Delete server
+    ServerDelete { id: String },
+
+    /// Update existing server member
+    ServerMemberUpdate {
+        id: MemberCompositeKey,
+        data: PartialMember,
+        #[serde(default)]
+        clear: Vec<FieldsMember>,
+    },
+
+    /// User joins server
+    ServerMemberJoin { id: String, user: String },
+
+    /// User left server
+    ServerMemberLeave {
+        id: String,
+        user: String,
+        reason: RemovalIntention,
+    },
+
+    /// Server role created or updated
+    ServerRoleUpdate {
+        id: String,
+        role_id: String,
+        data: PartialRole,
+        #[serde(default)]
+        clear: Vec<FieldsRole>,
+    },
+
+    /// Server role deleted
+    ServerRoleDelete { id: String, role_id: String },
+
+    /// Server roles ranks updated
+    ServerRoleRanksUpdate { id: String, ranks: Vec<String> },
+
+    /// Update existing user
+    UserUpdate {
+        id: String,
+        data: PartialUser,
+        #[serde(default)]
+        clear: Vec<FieldsUser>,
+        event_id: Option<String>,
+    },
+
+    /// Relationship with another user changed
+    UserRelationship { id: String, user: User },
+    /// Settings updated remotely
+    UserSettingsUpdate { id: String, update: UserSettings },
+
+    /// User has been platform banned or deleted their account
+    ///
+    /// Clients should remove the following associated data:
+    /// - Messages
+    /// - DM Channels
+    /// - Relationships
+    /// - Server Memberships
+    ///
+    /// User flags are specified to explain why a wipe is occurring though not all reasons will necessarily ever appear.
+    UserPlatformWipe { user_id: String, flags: i32 },
+    /// New emoji
+    EmojiCreate(Emoji),
+
+    /// Delete emoji
+    EmojiDelete { id: String },
+
+    /// New report
+    ReportCreate(Report),
+    /// New channel
+    ChannelCreate(Channel),
+
+    /// Update existing channel
+    ChannelUpdate {
+        id: String,
+        data: PartialChannel,
+        #[serde(default)]
+        clear: Vec<FieldsChannel>,
+    },
+
+    /// Delete channel
+    ChannelDelete { id: String },
+
+    /// User joins a group
+    ChannelGroupJoin { id: String, user: String },
+
+    /// User leaves a group
+    ChannelGroupLeave { id: String, user: String },
+
+    /// User started typing in a channel
+    ChannelStartTyping { id: String, user: String },
+
+    /// User stopped typing in a channel
+    ChannelStopTyping { id: String, user: String },
+
+    /// User acknowledged message in channel
+    ChannelAck {
+        id: String,
+        user: String,
+        message_id: String,
+    },
+
+    /// New webhook
+    WebhookCreate(Webhook),
+
+    /// Update existing webhook
+    WebhookUpdate {
+        id: String,
+        data: PartialWebhook,
+        remove: Vec<FieldsWebhook>,
+    },
+
+    /// Delete webhook
+    WebhookDelete { id: String },
+
+    /// Auth events
+    Auth(AuthifierEvent),
+}
+
+impl EventV1 {
+    /// Publish helper wrapper
+    pub async fn p(self, channel: String) {
+        #[cfg(debug_assertions)]
+        info!("Publishing event to {channel}: {self:?}");
+
+        let result = event_stream::publish_event(&channel, &self).await;
+
+        #[cfg(not(debug_assertions))]
+        result.ok();
+
+        #[cfg(debug_assertions)]
+        result.unwrap();
+    }
+
+    /// Publish user event
+    pub async fn p_user(self, id: String, db: &Database) {
+        self.clone().p(id.clone()).await;
+
+        // TODO: this should be captured by member list in the future and not immediately fanned out to users
+        if let Ok(members) = db.fetch_all_memberships(&id).await {
+            for member in members {
+                self.clone().server(member.id.server).await;
+            }
+        }
+    }
+
+    /// Publish private event
+    pub async fn private(self, id: String) {
+        self.p(format!("{id}!")).await;
+    }
+
+    /// Publish server member event
+    pub async fn server(self, id: String) {
+        self.p(format!("{id}u")).await;
+    }
+
+    /// Publish internal global event
+    pub async fn global(self) {
+        self.p("global".to_string()).await;
+    }
+}

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

@@ -0,0 +1,3 @@
+pub mod client;
+pub mod rabbit;
+pub mod server;

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

@@ -0,0 +1,65 @@
+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)]
+pub struct MassMessageSentPayload {
+    pub notifications: Vec<PushNotification>,
+    pub server_id: 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,
+}

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

@@ -0,0 +1,13 @@
+use serde::Deserialize;
+
+use super::client::Ping;
+
+#[derive(Deserialize, Debug)]
+#[serde(tag = "type")]
+pub enum ClientMessage {
+    Authenticate { token: String },
+    BeginTyping { channel: String },
+    EndTyping { channel: String },
+    Subscribe { server_id: String },
+    Ping { data: Ping, responded: Option<()> },
+}

crates/core/database/src/lib.rs

@@ -0,0 +1,119 @@
+#[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)
+}

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

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

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

@@ -0,0 +1,24 @@
+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();
+        });
+    }
+}

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

@@ -0,0 +1,12 @@
+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<(), ()>;
+}

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

@@ -0,0 +1,33 @@
+use crate::MongoDb;
+
+use super::AbstractMigrations;
+
+mod init;
+mod scripts;
+
+#[async_trait]
+impl AbstractMigrations for MongoDb {
+    #[cfg(test)]
+    /// Drop the database
+    async fn drop_database(&self) {
+        self.db().drop().await.ok();
+    }
+
+    /// Migrate the database
+    async fn migrate_database(&self) -> Result<(), ()> {
+        info!("Migrating the database.");
+
+        let list = self
+            .list_database_names()
+            .await
+            .expect("Failed to fetch database names.");
+
+        if list.iter().any(|x| x == &self.1) {
+            scripts::migrate_database(self).await;
+        } else {
+            init::create_database(self).await;
+        }
+
+        Ok(())
+    }
+}

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

@@ -0,0 +1,267 @@
+use super::scripts::LATEST_REVISION;
+
+use crate::mongodb::bson::doc;
+use crate::mongodb::options::CreateCollectionOptions;
+use crate::MongoDb;
+
+pub async fn create_database(db: &MongoDb) {
+    info!("Creating database.");
+    let db = db.db();
+
+    db.create_collection("accounts")
+        .await
+        .expect("Failed to create accounts collection.");
+
+    db.create_collection("users")
+        .await
+        .expect("Failed to create users collection.");
+
+    db.create_collection("channels")
+        .await
+        .expect("Failed to create channels collection.");
+
+    db.create_collection("messages")
+        .await
+        .expect("Failed to create messages collection.");
+
+    db.create_collection("servers")
+        .await
+        .expect("Failed to create servers collection.");
+
+    db.create_collection("server_members")
+        .await
+        .expect("Failed to create server_members collection.");
+
+    db.create_collection("server_bans")
+        .await
+        .expect("Failed to create server_bans collection.");
+
+    db.create_collection("channel_invites")
+        .await
+        .expect("Failed to create channel_invites collection.");
+
+    db.create_collection("channel_unreads")
+        .await
+        .expect("Failed to create channel_unreads collection.");
+
+    db.create_collection("channel_webhooks")
+        .await
+        .expect("Failed to create channel_webhooks collection.");
+
+    db.create_collection("migrations")
+        .await
+        .expect("Failed to create migrations collection.");
+
+    db.create_collection("attachments")
+        .await
+        .expect("Failed to create attachments collection.");
+
+    db.create_collection("attachment_hashes")
+        .await
+        .expect("Failed to create attachment_hashes collection.");
+
+    db.create_collection("user_settings")
+        .await
+        .expect("Failed to create user_settings collection.");
+
+    db.create_collection("policy_changes")
+        .await
+        .expect("Failed to create policy_changes collection.");
+
+    db.create_collection("safety_reports")
+        .await
+        .expect("Failed to create safety_reports collection.");
+
+    db.create_collection("safety_snapshots")
+        .await
+        .expect("Failed to create safety_snapshots collection.");
+
+    db.create_collection("safety_strikes")
+        .await
+        .expect("Failed to create safety_strikes collection.");
+
+    db.create_collection("bots")
+        .await
+        .expect("Failed to create bots collection.");
+
+    db.create_collection("ratelimit_events")
+        .await
+        .expect("Failed to create ratelimit_events collection.");
+
+    db.create_collection("pubsub")
+        .with_options(
+            CreateCollectionOptions::builder()
+                .capped(true)
+                .size(1_000_000)
+                .build(),
+        )
+        .await
+        .expect("Failed to create pubsub collection.");
+
+    db.run_command(doc! {
+        "createIndexes": "users",
+        "indexes": [
+            {
+                "key": {
+                    "username": 1_i32
+                },
+                "name": "username",
+                "unique": false,
+                "collation": {
+                    "locale": "en",
+                    "strength": 2_i32
+                }
+            },
+            {
+                "key": {
+                    "username": 1_i32,
+                    "discriminator": 1_i32
+                },
+                "name": "username_discriminator",
+                "unique": true,
+                "collation": {
+                    "locale": "en",
+                    "strength": 2_i32
+                }
+            }
+        ]
+    })
+    .await
+    .expect("Failed to create username index.");
+
+    db.run_command(doc! {
+        "createIndexes": "messages",
+        "indexes": [
+            {
+                "key": {
+                    "content": "text"
+                },
+                "name": "content"
+            },
+            {
+                "key": {
+                    "channel": 1_i32,
+                    "_id": 1_i32
+                },
+                "name": "channel_id_compound"
+            },
+            {
+                "key": {
+                    "author": 1_i32
+                },
+                "name": "author"
+            },
+            {
+                "key": {
+                    "channel": 1_i32,
+                    "pinned": 1_i32
+                },
+                "name": "channel_pinned_compound"
+            },
+        ]
+    })
+    .await
+    .expect("Failed to create message index.");
+
+    db.run_command(doc! {
+        "createIndexes": "channel_unreads",
+        "indexes": [
+            {
+                "key": {
+                    "_id.channel": 1_i32,
+                    "_id.user": 1_i32,
+                },
+                "name": "compound_id"
+            },
+            {
+                "key": {
+                    "_id.user": 1_i32,
+                },
+                "name": "user_id"
+            }
+        ]
+    })
+    .await
+    .expect("Failed to create channel_unreads index.");
+
+    db.run_command(doc! {
+        "createIndexes": "server_members",
+        "indexes": [
+            {
+                "key": {
+                    "_id.server": 1_i32,
+                    "_id.user": 1_i32,
+                },
+                "name": "compound_id"
+            },
+            {
+                "key": {
+                    "_id.user": 1_i32,
+                },
+                "name": "user_id"
+            }
+        ]
+    })
+    .await
+    .expect("Failed to create server_members index.");
+
+    db.run_command(doc! {
+        "createIndexes": "attachments",
+        "indexes": [
+            {
+                "key": {
+                    "hash": 1_i32
+                },
+                "name": "hash"
+            },
+            {
+                "key": {
+                    "used_for.id": 1_i32
+                },
+                "name": "used_for_id"
+            }
+        ]
+    })
+    .await
+    .expect("Failed to create attachments index.");
+
+    db.run_command(doc! {
+        "createIndexes": "attachment_hashes",
+        "indexes": [
+            {
+                "key": {
+                    "processed_hash": 1_i32
+                },
+                "name": "processed_hash"
+            }
+        ]
+    })
+    .await
+    .expect("Failed to create attachment_hashes index.");
+
+    db.collection("migrations")
+        .insert_one(doc! {
+            "_id": 0_i32,
+            "revision": LATEST_REVISION
+        })
+        .await
+        .expect("Failed to save migration info.");
+
+    db.run_command(doc! {
+        "createIndexes": "ratelimit_events",
+        "indexes": [
+            {
+                "key": {
+                    "_id": 1_i32,
+                    "target_id": 1_i32,
+                    "event_type": 1_i32,
+                },
+                "name": "compound_key"
+            }
+        ]
+    })
+    .await
+    .expect("Failed to create ratelimit_events index.");
+
+    info!("Created database.");
+}

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

@@ -0,0 +1,16 @@
+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(())
+    }
+}

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

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

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

@@ -0,0 +1,222 @@
+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))
+        });
+    }
+}

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

@@ -0,0 +1,35 @@
+use revolt_result::Result;
+
+use crate::{Bot, FieldsBot, PartialBot};
+
+mod mongodb;
+mod reference;
+
+#[async_trait]
+pub trait AbstractBots: Sync + Send {
+    /// Insert new bot into the database
+    async fn insert_bot(&self, bot: &Bot) -> Result<()>;
+
+    /// Fetch a bot by its id
+    async fn fetch_bot(&self, id: &str) -> Result<Bot>;
+
+    /// Fetch a bot by its token
+    async fn fetch_bot_by_token(&self, token: &str) -> Result<Bot>;
+
+    /// Fetch bots owned by a user
+    async fn fetch_bots_by_user(&self, user_id: &str) -> Result<Vec<Bot>>;
+
+    /// Get the number of bots owned by a user
+    async fn get_number_of_bots_by_user(&self, user_id: &str) -> Result<usize>;
+
+    /// Update bot with new information
+    async fn update_bot(
+        &self,
+        id: &str,
+        partial: &PartialBot,
+        remove: Vec<FieldsBot>,
+    ) -> Result<()>;
+
+    /// Delete a bot from the database
+    async fn delete_bot(&self, id: &str) -> Result<()>;
+}

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

@@ -0,0 +1,92 @@
+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,
+        }
+    }
+}

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

@@ -0,0 +1,82 @@
+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))
+        }
+    }
+}

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

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

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

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

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

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

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

@@ -0,0 +1,47 @@
+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,
+            })
+            .await
+            .map_err(|_| create_database_error!("find", COL))?
+            .filter_map(|s| async {
+                if cfg!(debug_assertions) {
+                    Some(s.unwrap())
+                } else {
+                    s.ok()
+                }
+            })
+            .collect()
+            .await)
+    }
+
+    /// Delete an invite by its code
+    async fn delete_invite(&self, code: &str) -> Result<()> {
+        query!(self, delete_one_by_id, COL, code).map(|_| ())
+    }
+}

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

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

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

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

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

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

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

@@ -0,0 +1,45 @@
+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<()>;
+
+    /// Add a mention.
+    async fn add_mention_to_many_unreads<'a>(
+        &self,
+        channel_id: &str,
+        user_ids: &[String],
+        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>>;
+}

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

@@ -0,0 +1,177 @@
+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
+                    }
+                },
+            )
+            .with_options(
+                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
+            })
+            .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>>(),
+            )
+            .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
+                        }
+                    }
+                },
+            )
+            .with_options(UpdateOptions::builder().upsert(true).build())
+            .await
+            .map(|_| ())
+            .map_err(|_| create_database_error!("update_one", COL))
+    }
+
+    /// Add a mention to multiple users.
+    async fn add_mention_to_many_unreads<'a>(
+        &self,
+        channel_id: &str,
+        user_ids: &[String],
+        message_ids: &[String],
+    ) -> Result<()> {
+        self.col::<Document>(COL)
+            .update_many(
+                doc! {
+                    "_id.channel": channel_id,
+                    "_id.user": {
+                        "$in": user_ids
+                    },
+                },
+                doc! {
+                    "$push": {
+                        "mentions": {
+                            "$each": message_ids
+                        }
+                    }
+                },
+            )
+            .with_options(UpdateOptions::builder().upsert(true).build())
+            .await
+            .map(|_| ())
+            .map_err(|_| create_database_error!("update_many", 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
+            }
+        )
+    }
+}

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

@@ -0,0 +1,143 @@
+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(())
+    }
+
+    /// Add a mention to multiple users.
+    async fn add_mention_to_many_unreads<'a>(
+        &self,
+        channel_id: &str,
+        user_ids: &[String],
+        message_ids: &[String],
+    ) -> Result<()> {
+        let mut unreads = self.channel_unreads.lock().await;
+
+        for user_id in user_ids {
+            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())
+    }
+}

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

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

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

@@ -0,0 +1,179 @@
+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()
+            };
+
+            webhook.create(&db).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()
+            )
+        });
+    }
+}

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

@@ -0,0 +1,29 @@
+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<()>;
+}

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

@@ -0,0 +1,74 @@
+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,
+            })
+            .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",
+        })
+    }
+}

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

@@ -0,0 +1,70 @@
+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))
+        }
+    }
+}

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

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

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

@@ -0,0 +1,836 @@
+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 id = ulid::Ulid::new().to_string();
+
+        let icon = if let Some(icon_id) = data.icon {
+            Some(File::use_channel_icon(db, &icon_id, &id, &owner_id).await?)
+        } else {
+            None
+        };
+
+        let recipients = data.users.into_iter().collect::<Vec<String>>();
+        let channel = Channel::Group {
+            id,
+
+            name: data.name,
+            owner: owner_id,
+            description: data.description,
+            recipients: recipients.clone(),
+
+            icon,
+            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?;
+
+            if let Channel::DirectMessage { .. } = &channel {
+                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));
+        });
+    }
+}

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

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

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

@@ -0,0 +1,296 @@
+use super::AbstractChannels;
+use crate::{AbstractServers, Channel, FieldsChannel, IntoDocumentPath, MongoDb, PartialChannel};
+use bson::{Bson, Document};
+use futures::StreamExt;
+use revolt_permissions::OverrideField;
+use revolt_result::Result;
+
+static COL: &str = "channels";
+
+#[async_trait]
+impl AbstractChannels for MongoDb {
+    /// Insert a new channel in the database
+    async fn insert_channel(&self, channel: &Channel) -> Result<()> {
+        query!(self, insert_one, COL, &channel).map(|_| ())
+    }
+
+    /// Fetch a channel from the database
+    async fn fetch_channel(&self, channel_id: &str) -> Result<Channel> {
+        query!(self, find_one_by_id, COL, channel_id)?.ok_or_else(|| create_error!(NotFound))
+    }
+
+    /// Fetch all channels from the database
+    async fn fetch_channels<'a>(&self, ids: &'a [String]) -> Result<Vec<Channel>> {
+        Ok(self
+            .col::<Channel>(COL)
+            .find(doc! {
+                "_id": {
+                    "$in": ids
+                }
+            })
+            .await
+            .map_err(|_| create_database_error!("fetch", "channels"))?
+            .filter_map(|s| async {
+                if cfg!(debug_assertions) {
+                    Some(s.unwrap())
+                } else {
+                    s.ok()
+                }
+            })
+            .collect()
+            .await)
+    }
+
+    /// Fetch all direct messages for a user
+    async fn find_direct_messages(&self, user_id: &str) -> Result<Vec<Channel>> {
+        query!(
+            self,
+            find,
+            COL,
+            doc! {
+                "$or": [
+                    {
+                        "$or": [
+                            {
+                                "channel_type": "DirectMessage"
+                            },
+                            {
+                                "channel_type": "Group"
+                            }
+                        ],
+                        "recipients": user_id
+                    },
+                    {
+                        "channel_type": "SavedMessages",
+                        "user": user_id
+                    }
+                ]
+            }
+        )
+    }
+
+    // Fetch saved messages channel
+    async fn find_saved_messages_channel(&self, user_id: &str) -> Result<Channel> {
+        query!(
+            self,
+            find_one,
+            COL,
+            doc! {
+                "channel_type": "SavedMessages",
+                "user": user_id
+            }
+        )?
+        .ok_or_else(|| create_error!(InternalError))
+    }
+
+    // Fetch direct message channel (DM or Saved Messages)
+    async fn find_direct_message_channel(&self, user_a: &str, user_b: &str) -> Result<Channel> {
+        let doc = match (user_a, user_b) {
+            self_user if self_user.0 == self_user.1 => {
+                doc! {
+                    "channel_type": "SavedMessages",
+                    "user": self_user.0
+                }
+            }
+            users => {
+                doc! {
+                    "channel_type": "DirectMessage",
+                    "recipients": {
+                        "$all": [ users.0, users.1 ]
+                    }
+                }
+            }
+        };
+        query!(self, find_one, COL, doc)?.ok_or_else(|| create_error!(NotFound))
+    }
+
+    /// Insert a user to a group
+    async fn add_user_to_group(&self, channel: &str, user: &str) -> Result<()> {
+        self.col::<Document>(COL)
+            .update_one(
+                doc! {
+                    "_id": channel
+                },
+                doc! {
+                    "$push": {
+                        "recipients": user
+                    }
+                },
+            )
+            .await
+            .map(|_| ())
+            .map_err(|_| create_database_error!("update_one", "channel"))
+    }
+
+    /// Insert channel role permissions
+    async fn set_channel_role_permission(
+        &self,
+        channel: &str,
+        role: &str,
+        permissions: OverrideField,
+    ) -> Result<()> {
+        self.col::<Document>(COL)
+            .update_one(
+                doc! { "_id": channel },
+                doc! {
+                "$set": {
+                    "role_permissions.".to_owned() + role: permissions
+                }
+                },
+            )
+            .await
+            .map(|_| ())
+            .map_err(|_| create_database_error!("update_one", "channel"))
+    }
+
+    // Update channel
+    async fn update_channel(
+        &self,
+        id: &str,
+        channel: &PartialChannel,
+        remove: Vec<FieldsChannel>,
+    ) -> Result<()> {
+        query!(
+            self,
+            update_one_by_id,
+            COL,
+            id,
+            channel,
+            remove.iter().map(|x| x as &dyn IntoDocumentPath).collect(),
+            None
+        )
+        .map(|_| ())
+    }
+
+    // Remove a user from a group
+    async fn remove_user_from_group(&self, channel: &str, user: &str) -> Result<()> {
+        self.col::<Document>(COL)
+            .update_one(
+                doc! {
+                    "_id": channel
+                },
+                doc! {
+                    "$pull": {
+                        "recipients": user
+                    }
+                },
+            )
+            .await
+            .map(|_| ())
+            .map_err(|_| create_database_error!("update_one", "channels"))
+    }
+
+    // Delete a channel
+    async fn delete_channel(&self, channel: &Channel) -> Result<()> {
+        let id = channel.id().to_string();
+        let server_id = match channel {
+            Channel::TextChannel { server, .. } | Channel::VoiceChannel { server, .. } => {
+                Some(server)
+            }
+            _ => None,
+        };
+
+        // Delete invites and unreads.
+        self.delete_associated_channel_objects(Bson::String(id.to_string()))
+            .await?;
+
+        // Delete messages.
+        self.delete_bulk_messages(doc! {
+            "channel": &id
+        })
+        .await?;
+
+        // Remove from server object.
+        if let Some(server) = server_id {
+            let server = self.fetch_server(server).await?;
+            let mut update = doc! {
+                "$pull": {
+                    "channels": &id
+                }
+            };
+
+            if let Some(sys) = &server.system_messages {
+                let mut unset = doc! {};
+
+                if let Some(cid) = &sys.user_joined {
+                    if &id == cid {
+                        unset.insert("system_messages.user_joined", 1_i32);
+                    }
+                }
+
+                if let Some(cid) = &sys.user_left {
+                    if &id == cid {
+                        unset.insert("system_messages.user_left", 1_i32);
+                    }
+                }
+
+                if let Some(cid) = &sys.user_kicked {
+                    if &id == cid {
+                        unset.insert("system_messages.user_kicked", 1_i32);
+                    }
+                }
+
+                if let Some(cid) = &sys.user_banned {
+                    if &id == cid {
+                        unset.insert("system_messages.user_banned", 1_i32);
+                    }
+                }
+
+                if !unset.is_empty() {
+                    update.insert("$unset", unset);
+                }
+            }
+
+            self.col::<Document>("servers")
+                .update_one(
+                    doc! {
+                        "_id": server.id
+                    },
+                    update,
+                )
+                .await
+                .map_err(|_| create_database_error!("update_one", "servers"))?;
+        }
+
+        // Delete associated attachments
+        self.delete_many_attachments(doc! {
+            "used_for.id": &id
+        })
+        .await?;
+
+        // Delete the channel itself
+        query!(self, delete_one_by_id, COL, channel.id()).map(|_| ())
+    }
+}
+
+impl MongoDb {
+    pub async fn delete_associated_channel_objects(&self, id: Bson) -> Result<()> {
+        // Delete all invites to these channels.
+        self.col::<Document>("channel_invites")
+            .delete_many(doc! {
+                "channel": &id
+            })
+            .await
+            .map_err(|_| create_database_error!("delete_many", "channel_invites"))?;
+
+        // Delete unread message objects on channels.
+        self.col::<Document>("channel_unreads")
+            .delete_many(doc! {
+                "_id.channel": &id
+            })
+            .await
+            .map_err(|_| create_database_error!("delete_many", "channel_unreads"))
+            .map(|_| ())?;
+
+        // update many attachments with parent id
+
+        // Delete all webhooks on this channel.
+        self.col::<Document>("webhooks")
+            .delete_many(doc! {
+                "channel": &id
+            })
+            .await
+            .map_err(|_| create_database_error!("delete_many", "webhooks"))
+            .map(|_| ())
+    }
+}

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

@@ -0,0 +1,157 @@
+use std::collections::hash_map::Entry;
+
+use super::AbstractChannels;
+use crate::ReferenceDb;
+use crate::{Channel, FieldsChannel, PartialChannel};
+use revolt_permissions::OverrideField;
+use revolt_result::Result;
+
+#[async_trait]
+impl AbstractChannels for ReferenceDb {
+    /// Insert a new channel in the database
+    async fn insert_channel(&self, channel: &Channel) -> Result<()> {
+        let mut channels = self.channels.lock().await;
+        if let Entry::Vacant(entry) = channels.entry(channel.id().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))
+        }
+    }
+}

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

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

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

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