feat: policy changes API

chore: bump version to 0.8.7

.config/nextest.toml

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

.env.example

@@ -1,107 +0,0 @@
-# MongoDB URI
-MONGODB=mongodb://localhost
-AUTUMN_MONGO_URI=mongodb://database
-REDIS_URI=redis://localhost/
-
-# URL to where the Revolt app is publicly accessible
-REVOLT_APP_URL=http://local.revolt.chat:5000
-
-# URL to where the API is publicly accessible
-REVOLT_PUBLIC_URL=http://local.revolt.chat:8000
-VITE_API_URL=http://local.revolt.chat:8000
-
-# URL to where the WebSocket server is publicly accessible
-REVOLT_EXTERNAL_WS_URL=ws://local.revolt.chat:9000
-
-# URL to where Autumn is publicly available
-AUTUMN_PUBLIC_URL=http://local.revolt.chat:3000
-
-# URL to where January is publicly available
-JANUARY_PUBLIC_URL=http://local.revolt.chat:7000
-
-# URL to where Vortex is publicly available
-# VOSO_PUBLIC_URL=https://voso.revolt.chat
-
-
-##
-## hCaptcha Settings
-##
-
-# If you are sure that you don't want to use hCaptcha, set to 1.
-REVOLT_UNSAFE_NO_CAPTCHA=1
-
-# hCaptcha API key
-# REVOLT_HCAPTCHA_KEY=0x0000000000000000000000000000000000000000
-
-# hCaptcha site key
-# REVOLT_HCAPTCHA_SITEKEY=10000000-ffff-ffff-ffff-000000000001
-
-
-##
-## Email Settings
-##
-
-# If you are sure that you don't want to use email verification, set to 1.
-REVOLT_UNSAFE_NO_EMAIL=1
-
-# SMTP host
-# REVOLT_SMTP_HOST=smtp.example.com
-
-# SMTP username
-# REVOLT_SMTP_USERNAME=noreply@example.com
-
-# SMTP password
-# REVOLT_SMTP_PASSWORD=CHANGEME
-
-# SMTP From header
-# REVOLT_SMTP_FROM=Revolt <noreply@example.com>
-
-
-##
-## Application Settings
-##
-
-# Whether to enable staging only features
-REVOLT_IS_STAGING=1
-
-# Whether to only allow users to sign up if they have an invite code
-REVOLT_INVITE_ONLY=0
-
-# Maximum number of people that can be in a group chat
-REVOLT_MAX_GROUP_SIZE=150
-
-# VAPID keys for push notifications
-# Generate using this guide: https://gitlab.insrt.uk/revolt/delta/-/wikis/vapid
-# --> Please replace these keys before going into production! <--
-REVOLT_VAPID_PRIVATE_KEY=LS0tLS1CRUdJTiBFQyBQUklWQVRFIEtFWS0tLS0tCk1IY0NBUUVFSUJSUWpyTWxLRnBiVWhsUHpUbERvcEliYk1yeVNrNXpKYzVYVzIxSjJDS3hvQW9HQ0NxR1NNNDkKQXdFSG9VUURRZ0FFWnkrQkg2TGJQZ2hEa3pEempXOG0rUXVPM3pCajRXT1phdkR6ZU00c0pqbmFwd1psTFE0WAp1ZDh2TzVodU94QWhMQlU3WWRldVovWHlBdFpWZmNyQi9BPT0KLS0tLS1FTkQgRUMgUFJJVkFURSBLRVktLS0tLQo=
-REVOLT_VAPID_PUBLIC_KEY=BGcvgR-i2z4IQ5Mw841vJvkLjt8wY-FjmWrw83jOLCY52qcGZS0OF7nfLzuYbjsQISwVO2HXrmf18gLWVX3Kwfw=
-
-
-##
-## Vortex configuration
-##
-
-# VOSO_MANAGE_TOKEN=CHANGEME
-
-
-##
-## Autumn configuration
-##
-
-# S3 Region
-AUTUMN_S3_REGION=minio
-
-# S3 Endpoint
-AUTUMN_S3_ENDPOINT=http://minio:9000
-
-# MinIO Root User
-MINIO_ROOT_USER=minioautumn
-
-# MinIO Root Password
-MINIO_ROOT_PASSWORD=minioautumn
-
-# AWS Access Key ID
-AWS_ACCESS_KEY_ID=minioautumn
-
-# AWS Secret Key
-AWS_SECRET_ACCESS_KEY=minioautumn

.github/workflows/docker.yaml

@@ -2,24 +2,13 @@ name: Docker Test & Publish
 
 on:
   push:
-    branches:
-      - "main"
     tags:
       - "*"
-    paths-ignore:
-      - ".github/**"
-      - "!.github/workflows/docker.yml"
-      - ".vscode/**"
-      - "doc/**"
-      - ".gitignore"
-      - "LICENSE"
-      - "README"
   pull_request:
     branches:
       - "main"
     paths:
       - "Dockerfile"
-  workflow_dispatch:
 
 permissions:
   contents: read
@@ -27,8 +16,9 @@ permissions:
 
 jobs:
   base:
+    name: Test base image build
     runs-on: ubuntu-latest
-    name: Build base image
+    if: github.event_name == 'pull_request'
     steps:
       # Configure build environment
       - name: Checkout
@@ -36,33 +26,21 @@ jobs:
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v2
 
-      # Authenticate with GHCR
-      - name: Login to Github Container Registry
-        if: ${{ github.event_name != 'pull_request' }}
-        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: ${{ github.event_name != 'pull_request' }}
+          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:
-    needs: [base]
-    runs-on: ubuntu-latest
+    runs-on: self-hosted
     if: github.event_name != 'pull_request'
-    strategy:
-      matrix:
-        project: [delta, bonfire]
-    name: Build ${{ matrix.project }} image
+    name: Publish Docker images
     steps:
       # Configure build environment
       - name: Checkout
@@ -77,6 +55,7 @@ jobs:
           registry: docker.io
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
+
       - name: Login to Github Container Registry
         uses: docker/login-action@v2
         with:
@@ -84,42 +63,131 @@ jobs:
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
-      # Resolve the correct project
-      - uses: kanga333/variable-mapper@master
-        id: export
+      # Build the image
+      - name: Build base image
+        uses: docker/build-push-action@v4
         with:
-          key: "${{ matrix.project }}"
-          map: |
-            {
-              "delta": {
-                "path": "crates/delta",
-                "tag": "${{ github.repository_owner }}/server"
-              },
-              "bonfire": {
-                "path": "crates/bonfire",
-                "tag": "${{ github.repository_owner }}/bonfire"
-              }
-            }
-          export_to: output
+          context: .
+          push: true
+          platforms: linux/amd64,linux/arm64
+          tags: ghcr.io/${{ github.repository_owner }}/base:latest
 
-      # Configure metadata
+      # revoltchat/server
       - name: Docker meta
-        id: meta
+        id: meta-delta
         uses: docker/metadata-action@v4
         with:
           images: |
-            docker.io/${{ steps.export.outputs.tag }}
-            ghcr.io/${{ steps.export.outputs.tag }}
-
-      # Build crate image
+            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: ${{ steps.export.outputs.path }}/Dockerfile
-          tags: ${{ steps.meta.outputs.tags }}
+          file: crates/delta/Dockerfile
+          tags: ${{ steps.meta-delta.outputs.tags }}
           build-args: |
             BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
-          labels: ${{ steps.meta.outputs.labels }}
+          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

@@ -41,11 +41,7 @@ jobs:
 
       - name: Run services in background
         run: |
-          docker-compose -f docker-compose.db.yml up -d
-
-      - name: Copy .env.example
-        run: |
-          cp .env.example .env
+          docker compose -f compose.yml up -d
 
       - name: Run cargo test
         env:
@@ -71,7 +67,7 @@ jobs:
         if: github.event_name != 'pull_request' && github.ref_name == 'main'
         uses: nev7n/wait_for_response@v1
         with:
-          url: "http://localhost:8000/"
+          url: "http://localhost:14702/"
 
       - name: Checkout API repository
         if: github.event_name != 'pull_request' && github.ref_name == 'main'
@@ -83,7 +79,7 @@ jobs:
 
       - name: Download OpenAPI specification
         if: github.event_name != 'pull_request' && github.ref_name == 'main'
-        run: curl http://localhost:8000/openapi.json -o api/OpenAPI.json
+        run: curl http://localhost:14702/openapi.json -o api/OpenAPI.json
 
       - name: Commit changes
         if: github.event_name != 'pull_request' && github.ref_name == 'main'

.gitignore

@@ -1,9 +1,14 @@
 Rocket.toml
-Revolt.toml
+Revolt.*.toml
+compose.override.yml
 
 target
 .data
 .env
+.venv/
+venv/
 
 .vercel
 .DS_Store
+
+.idea

.vscode/settings.json

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

Cargo.toml

@@ -1,10 +1,20 @@
 [workspace]
 resolver = "2"
-members = ["crates/delta", "crates/bonfire", "crates/core/*"]
+
+members = [
+    "crates/delta",
+    "crates/bonfire",
+    "crates/core/*",
+    "crates/services/*",
+    "crates/daemons/*",
+]
 
 [patch.crates-io]
-# mobc-redis = { git = "https://github.com/insertish/mobc", rev = "8b880bb59f2ba80b4c7bc40c649c113d8857a186" }
-redis22 = { package = "redis", version = "0.22.3", git = "https://github.com/revoltchat/redis-rs", rev = "1a41faf356fd21aebba71cea7eb7eb2653e5f0ef" }
-redis23 = { package = "redis", version = "0.23.1", git = "https://github.com/revoltchat/redis-rs", rev = "f8ca28ab85da59d2ccde526b4d2fb390eff5a5f9" }
-# authifier = { package = "authifier", version = "1.0.8", path = "../authifier/crates/authifier" }
-# rocket_authifier = { package = "rocket_authifier", version = "1.0.8", path = "../authifier/crates/rocket_authifier" }
+redis23 = { package = "redis", version = "0.23.3", git = "https://github.com/revoltchat/redis-rs", rev = "523b2937367e17bd0073722bf6e23d06042cb4e4" }
+
+# 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,5 +1,5 @@
 # Build Stage
-FROM --platform="${BUILDPLATFORM}" rust:1.70.0-slim
+FROM --platform="${BUILDPLATFORM}" rust:1.86.0-slim-bookworm
 USER 0:0
 WORKDIR /home/rust/src
 
@@ -21,10 +21,16 @@ 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

Dockerfile.useCurrentArch

@@ -1,5 +1,5 @@
 # Build Stage
-FROM rust:1.70.0-slim
+FROM rust:1.86.0-slim-bookworm
 USER 0:0
 WORKDIR /home/rust/src
 
@@ -17,10 +17,16 @@ 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

LICENSE

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

README.md

@@ -1,26 +1,47 @@
-# Revolt Backend
+<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/>
 
-This is a monorepo for the Revolt backend.
+| Crate              | Path                                               | Description                         |                                                                                                                                                                                                                                                                                                           |
+| ------------------ | -------------------------------------------------- | ----------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `core/config`      | [crates/core/config](crates/core/config)           | Core: Configuration                 | ![Crates.io Version](https://img.shields.io/crates/v/revolt-config) ![Crates.io Version](https://img.shields.io/crates/msrv/revolt-config) ![Crates.io Version](https://img.shields.io/crates/size/revolt-config) ![Crates.io License](https://img.shields.io/crates/l/revolt-config)                     |
+| `core/database`    | [crates/core/database](crates/core/database)       | Core: Database Implementation       | ![Crates.io Version](https://img.shields.io/crates/v/revolt-database) ![Crates.io Version](https://img.shields.io/crates/msrv/revolt-database) ![Crates.io Version](https://img.shields.io/crates/size/revolt-database) ![Crates.io License](https://img.shields.io/crates/l/revolt-database)             |
+| `core/files`       | [crates/core/files](crates/core/files)             | Core: S3 and encryption subroutines | ![Crates.io Version](https://img.shields.io/crates/v/revolt-files) ![Crates.io Version](https://img.shields.io/crates/msrv/revolt-files) ![Crates.io Version](https://img.shields.io/crates/size/revolt-files) ![Crates.io License](https://img.shields.io/crates/l/revolt-files)                         |
+| `core/models`      | [crates/core/models](crates/core/models)           | Core: API Models                    | ![Crates.io Version](https://img.shields.io/crates/v/revolt-models) ![Crates.io Version](https://img.shields.io/crates/msrv/revolt-models) ![Crates.io Version](https://img.shields.io/crates/size/revolt-models) ![Crates.io License](https://img.shields.io/crates/l/revolt-models)                     |
+| `core/permissions` | [crates/core/permissions](crates/core/permissions) | Core: Permission Logic              | ![Crates.io Version](https://img.shields.io/crates/v/revolt-permissions) ![Crates.io Version](https://img.shields.io/crates/msrv/revolt-permissions) ![Crates.io Version](https://img.shields.io/crates/size/revolt-permissions) ![Crates.io License](https://img.shields.io/crates/l/revolt-permissions) |
+| `core/presence`    | [crates/core/presence](crates/core/presence)       | Core: User Presence                 | ![Crates.io Version](https://img.shields.io/crates/v/revolt-presence) ![Crates.io Version](https://img.shields.io/crates/msrv/revolt-presence) ![Crates.io Version](https://img.shields.io/crates/size/revolt-presence) ![Crates.io License](https://img.shields.io/crates/l/revolt-presence)             |
+| `core/result`      | [crates/core/result](crates/core/result)           | Core: Result and Error types        | ![Crates.io Version](https://img.shields.io/crates/v/revolt-result) ![Crates.io Version](https://img.shields.io/crates/msrv/revolt-result) ![Crates.io Version](https://img.shields.io/crates/size/revolt-result) ![Crates.io License](https://img.shields.io/crates/l/revolt-result)                     |
+| `delta`            | [crates/delta](crates/delta)                       | REST API server                     | ![License](https://img.shields.io/badge/license-AGPL--3.0--or--later-blue)                                                                                                                                                                                                                                |
+| `bonfire`          | [crates/bonfire](crates/bonfire)                   | WebSocket events server             | ![License](https://img.shields.io/badge/license-AGPL--3.0--or--later-blue)                                                                                                                                                                                                                                |
+| `services/january` | [crates/services/january](crates/services/january) | Proxy server                        | ![License](https://img.shields.io/badge/license-AGPL--3.0--or--later-blue)                                                                                                                                                                                                                                |
+| `services/autumn`  | [crates/services/autumn](crates/services/autumn)   | File server                         | ![License](https://img.shields.io/badge/license-AGPL--3.0--or--later-blue)                                                                                                                                                                                                                                |
+| `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)                                                                                                                                                                                                                                |
 
-| Crate              | Path                                               | Description                   |
-| ------------------ | -------------------------------------------------- | ----------------------------- |
-| `core/config`      | [crates/core/config](crates/core/config)           | Core: Configuration           |
-| `core/database`    | [crates/core/database](crates/core/database)       | Core: Database Implementation |
-| `core/models`      | [crates/core/models](crates/core/models)           | Core: API Models              |
-| `core/permissions` | [crates/core/permissions](crates/core/permissions) | Core: Permission Logic        |
-| `core/presence`    | [crates/core/presence](crates/core/presence)       | Core: User Presence           |
-| `core/result`      | [crates/core/result](crates/core/result)           | Core: Result and Error types  |
-| `delta`            | [crates/delta](crates/delta)                       | REST API server               |
-| `bonfire`          | [crates/bonfire](crates/bonfire)                   | WebSocket events server       |
-
-Note: `january`, `autumn`, and `vortex` are yet to be moved into this monorepo.
+</div>
+<br/>
 
 ## Minimum Supported Rust Version
 
-Rust 1.70 or higher.
+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)
@@ -31,6 +52,21 @@ Before getting started, you'll want to install:
 > 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
@@ -39,26 +75,77 @@ cd revolt-backend
 cargo build
 ```
 
-If you want to run the API and event servers:
+A default configuration `Revolt.toml` is present in this project that is suited for development.
+
+If you'd like to change anything, create a `Revolt.overrides.toml` file and specify relevant variables.
+
+> [!TIP]
+> Use Sentry to catch unexpected service errors:
+>
+> ```toml
+> # Revolt.overrides.toml
+> [sentry]
+> api = "https://abc@your.sentry/1"
+> events = "https://abc@your.sentry/1"
+> files = "https://abc@your.sentry/1"
+> proxy = "https://abc@your.sentry/1"
+> ```
+
+> [!TIP]
+> If you have port conflicts on common services, you can try the following:
+>
+> ```yaml
+> # compose.override.yml
+> services:
+>   redis:
+>     ports: !override
+>       - "14079:6379"
+>
+>   database:
+>     ports: !override
+>       - "14017:27017"
+>
+>   rabbit:
+>     ports: !override
+>       - "14072:5672"
+>       - "14672:15672"
+> ```
+>
+> And corresponding Revolt configuration:
+>
+> ```toml
+> # Revolt.overrides.toml
+> [database]
+> mongodb = "mongodb://127.0.0.1:14017"
+> redis = "redis://127.0.0.1:14079/"
+>
+> [rabbit]
+> port = 14072
+> ```
+
+Then continue:
 
 ```bash
-# create environment file (will be deprecated in future)
-cp .env.example .env
-
-# (optionally) copy the default configuration file
-cp crates/core/config/Revolt.toml Revolt.toml
-# configure as necessary...
-
 # start other necessary services
 docker compose up -d
 
+# run 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:
@@ -72,10 +159,13 @@ git clone --recursive https://github.com/revoltchat/revite
 cd revite
 yarn
 yarn build:deps
-yarn dev --port 3001
+echo "VITE_API_URL=http://local.revolt.chat:14702" > .env.local
+yarn dev --port 14701
 ```
 
-Then go to https://local.revolt.chat:3001
+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
 
@@ -105,6 +195,23 @@ Tag and push a new release by running:
 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).

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"

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/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-bonfire"
-version = "0.7.2"
+version = "0.8.7"
 license = "AGPL-3.0-or-later"
 edition = "2021"
 
@@ -14,6 +14,8 @@ 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"
@@ -34,11 +36,12 @@ async-std = { version = "1.8.0", features = [
 ] }
 
 # core
+authifier = { version = "1.0.15" }
 revolt-result = { path = "../core/result" }
 revolt-models = { path = "../core/models" }
 revolt-config = { path = "../core/config" }
 revolt-database = { path = "../core/database" }
-revolt-permissions = { version = "0.7.2", path = "../core/permissions" }
+revolt-permissions = { version = "0.8.7", path = "../core/permissions" }
 revolt-presence = { path = "../core/presence", features = ["redis-is-patched"] }
 
 # redis

crates/bonfire/Dockerfile

@@ -1,11 +1,12 @@
 # Build Stage
 FROM ghcr.io/revoltchat/base:latest AS builder
+FROM debian:12 AS debian
 
 # Bundle Stage
-FROM debian:bullseye-slim
-RUN apt-get update && \
-    apt-get install -y ca-certificates && \
-    apt-get clean
+FROM gcr.io/distroless/cc-debian12:nonroot
 COPY --from=builder /home/rust/src/target/release/revolt-bonfire ./
-EXPOSE 9000
+COPY --from=debian /usr/bin/uname /usr/bin/uname
+
+EXPOSE 14703
+USER nonroot
 CMD ["./revolt-bonfire"]

crates/bonfire/src/config.rs

@@ -1,5 +1,6 @@
 use async_tungstenite::tungstenite::{handshake, Message};
 use futures::channel::oneshot::Sender;
+use revolt_database::events::client::ReadyPayloadFields;
 use revolt_result::{create_error, Result};
 use serde::{Deserialize, Serialize};
 
@@ -83,6 +84,17 @@ impl ProtocolConfiguration {
     pub fn get_protocol_format(&self) -> &ProtocolFormat {
         &self.format
     }
+
+    /// Get ready payload fields
+    pub fn get_ready_payload_fields(&self) -> Vec<ReadyPayloadFields> {
+        vec![
+            ReadyPayloadFields::Users,
+            ReadyPayloadFields::Servers,
+            ReadyPayloadFields::Channels,
+            ReadyPayloadFields::Members,
+            ReadyPayloadFields::Emoji,
+        ]
+    }
 }
 
 /// Object holding one side of a channel for receiving the parsed information

crates/bonfire/src/events/impl.rs

@@ -1,8 +1,10 @@
 use std::collections::HashSet;
 
+use futures::future::join_all;
 use revolt_database::{
-    events::client::EventV1, util::permissions::DatabasePermissionQuery, Channel, Database, Member,
-    MemberCompositeKey, Presence, RelationshipStatus,
+    events::client::{EventV1, ReadyPayloadFields},
+    util::permissions::DatabasePermissionQuery,
+    Channel, Database, Member, MemberCompositeKey, Presence, RelationshipStatus,
 };
 use revolt_models::v0;
 use revolt_permissions::{calculate_channel_permissions, ChannelPermission};
@@ -21,11 +23,11 @@ impl Cache {
                 let server = self.servers.get(server);
                 let mut query =
                     DatabasePermissionQuery::new(db, self.users.get(&self.user_id).unwrap())
-                        .channel(&channel);
+                        .channel(channel);
                 // let mut perms = perms(self.users.get(&self.user_id).unwrap()).channel(channel);
 
                 if let Some(member) = member {
-                    query = query.member(&member);
+                    query = query.member(member);
                 }
 
                 if let Some(server) = server {
@@ -90,8 +92,25 @@ impl Cache {
 /// State Manager
 impl State {
     /// Generate a Ready packet for the current user
-    pub async fn generate_ready_payload(&mut self, db: &Database) -> Result<EventV1> {
+    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
@@ -149,14 +168,36 @@ impl State {
             .await?;
 
         // Fetch customisations.
-        let emojis = db
-            .fetch_emoji_by_parent_ids(
-                &servers
-                    .iter()
-                    .map(|x| x.id.to_string())
-                    .collect::<Vec<String>>(),
+        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?,
             )
-            .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();
@@ -170,39 +211,62 @@ impl State {
             .collect();
 
         // Make all users appear from our perspective.
-        let mut users: Vec<v0::User> = users
-            .into_iter()
-            .map(|other_user| {
-                let is_online = online_ids.contains(&other_user.id);
-                other_user.into_known(&user, is_online)
-            })
-            .collect();
+        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().await);
+        users.push(user.into_self(true).await);
 
         // Set subscription state internally.
-        self.reset_state();
-        self.insert_subscription(self.private_topic.clone());
+        self.reset_state().await;
+        self.insert_subscription(self.private_topic.clone()).await;
 
         for user in &users {
-            self.insert_subscription(user.id.clone());
+            self.insert_subscription(user.id.clone()).await;
         }
 
         for server in &servers {
-            self.insert_subscription(server.id.clone());
+            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());
+            self.insert_subscription(channel.id().to_string()).await;
         }
 
         Ok(EventV1::Ready {
-            users,
-            servers: servers.into_iter().map(Into::into).collect(),
-            channels: channels.into_iter().map(Into::into).collect(),
-            members: members.into_iter().map(Into::into).collect(),
-            emojis: emojis.into_iter().map(Into::into).collect(),
+            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,
         })
     }
 
@@ -236,11 +300,11 @@ impl State {
             let mut bulk_events = vec![];
 
             for id in added_channels {
-                self.insert_subscription(id);
+                self.insert_subscription(id).await;
             }
 
             for id in removed_channels {
-                self.remove_subscription(&id);
+                self.remove_subscription(&id).await;
                 self.cache.channels.remove(&id);
 
                 bulk_events.push(EventV1::ChannelDelete { id });
@@ -263,7 +327,7 @@ impl State {
                             .channels
                             .insert(channel.id().to_string(), channel.clone());
 
-                        self.insert_subscription(channel.id().to_string());
+                        self.insert_subscription(channel.id().to_string()).await;
                         bulk_events.push(EventV1::ChannelCreate(channel.into()));
                     }
                 }
@@ -336,7 +400,7 @@ impl State {
         match event {
             EventV1::ChannelCreate(channel) => {
                 let id = channel.id().to_string();
-                self.insert_subscription(id.clone());
+                self.insert_subscription(id.clone()).await;
                 self.cache.channels.insert(id, channel.clone().into());
             }
             EventV1::ChannelUpdate {
@@ -376,17 +440,17 @@ impl State {
                 }
             }
             EventV1::ChannelDelete { id } => {
-                self.remove_subscription(id);
+                self.remove_subscription(id).await;
                 self.cache.channels.remove(id);
             }
             EventV1::ChannelGroupJoin { user, .. } => {
-                self.insert_subscription(user.clone());
+                self.insert_subscription(user.clone()).await;
             }
             EventV1::ChannelGroupLeave { id, user, .. } => {
                 if user == &self.cache.user_id {
-                    self.remove_subscription(id);
+                    self.remove_subscription(id).await;
                 } else if !self.cache.can_subscribe_to_user(user) {
-                    self.remove_subscription(user);
+                    self.remove_subscription(user).await;
                 }
             }
 
@@ -396,7 +460,12 @@ impl State {
                 channels,
                 emojis: _,
             } => {
-                self.insert_subscription(id.clone());
+                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 {
@@ -433,13 +502,13 @@ impl State {
             EventV1::ServerMemberJoin { .. } => {
                 // We will always receive ServerCreate when joining a new server.
             }
-            EventV1::ServerMemberLeave { id, user } => {
+            EventV1::ServerMemberLeave { id, user, .. } => {
                 if user == &self.cache.user_id {
-                    self.remove_subscription(id);
+                    self.remove_subscription(id).await;
 
                     if let Some(server) = self.cache.servers.remove(id) {
                         for channel in &server.channels {
-                            self.remove_subscription(channel);
+                            self.remove_subscription(channel).await;
                             self.cache.channels.remove(channel);
                         }
                     }
@@ -447,11 +516,11 @@ impl State {
                 }
             }
             EventV1::ServerDelete { id } => {
-                self.remove_subscription(id);
+                self.remove_subscription(id).await;
 
                 if let Some(server) = self.cache.servers.remove(id) {
                     for channel in &server.channels {
-                        self.remove_subscription(channel);
+                        self.remove_subscription(channel).await;
                         self.cache.channels.remove(channel);
                     }
                 }
@@ -524,9 +593,23 @@ impl State {
                 self.cache.users.insert(id.clone(), user.clone().into());
 
                 if self.cache.can_subscribe_to_user(id) {
-                    self.insert_subscription(id.clone());
+                    self.insert_subscription(id.clone()).await;
                 } else {
-                    self.remove_subscription(id);
+                    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();
                 }
             }
 
@@ -540,11 +623,11 @@ impl State {
 
         // Sub / unsub accordingly.
         if let Some(id) = queue_add {
-            self.insert_subscription(id);
+            self.insert_subscription(id).await;
         }
 
         if let Some(id) = queue_remove {
-            self.remove_subscription(&id);
+            self.remove_subscription(&id).await;
         }
 
         true

crates/bonfire/src/events/state.rs

@@ -1,6 +1,12 @@
-use std::collections::{HashMap, HashSet};
+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
@@ -30,6 +36,7 @@ pub enum SubscriptionStateChange {
 #[derive(Debug)]
 pub struct Cache {
     pub user_id: String,
+    pub is_bot: bool,
 
     pub users: HashMap<String, User>,
     pub channels: HashMap<String, Channel>,
@@ -43,6 +50,7 @@ impl Default for Cache {
     fn default() -> Self {
         Cache {
             user_id: Default::default(),
+            is_bot: false,
 
             users: Default::default(),
             channels: Default::default(),
@@ -58,14 +66,17 @@ impl Default for Cache {
 pub struct State {
     pub cache: Cache,
 
+    pub session_id: String,
     pub private_topic: String,
-    subscribed: HashSet<String>,
-    state: SubscriptionStateChange,
+    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) -> State {
+    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());
@@ -80,22 +91,61 @@ impl State {
 
         State {
             cache,
-            subscribed,
+            subscribed: Arc::new(RwLock::new(subscribed)),
+            active_servers: Arc::new(Mutex::new(LruTimeCache::with_expiry_duration_and_capacity(
+                Duration::from_secs(900),
+                5,
+            ))),
+            session_id,
             private_topic,
             state: SubscriptionStateChange::Reset,
         }
     }
 
     /// Apply currently queued state
-    pub fn apply_state(&mut self) -> SubscriptionStateChange {
+    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 {
-                self.subscribed.insert(id.clone());
+                subscribed.insert(id.clone());
             }
 
             for id in remove {
-                self.subscribed.remove(id);
+                subscribed.remove(id);
             }
         }
 
@@ -107,20 +157,16 @@ impl State {
         self.cache.users.get(&self.cache.user_id).unwrap().clone()
     }
 
-    /// Iterate through all subscriptions
-    pub fn iter_subscriptions(&self) -> std::collections::hash_set::Iter<'_, std::string::String> {
-        self.subscribed.iter()
-    }
-
     /// Reset the current state
-    pub fn reset_state(&mut self) {
+    pub async fn reset_state(&mut self) {
         self.state = SubscriptionStateChange::Reset;
-        self.subscribed.clear();
+        self.subscribed.write().await.clear();
     }
 
     /// Add a new subscription
-    pub fn insert_subscription(&mut self, subscription: String) {
-        if self.subscribed.contains(&subscription) {
+    pub async fn insert_subscription(&mut self, subscription: String) {
+        let mut subscribed = self.subscribed.write().await;
+        if subscribed.contains(&subscription) {
             return;
         }
 
@@ -137,12 +183,13 @@ impl State {
             SubscriptionStateChange::Reset => {}
         }
 
-        self.subscribed.insert(subscription);
+        subscribed.insert(subscription);
     }
 
     /// Remove existing subscription
-    pub fn remove_subscription(&mut self, subscription: &str) {
-        if !self.subscribed.contains(&subscription.to_string()) {
+    pub async fn remove_subscription(&mut self, subscription: &str) {
+        let mut subscribed = self.subscribed.write().await;
+        if !subscribed.contains(&subscription.to_string()) {
             return;
         }
 
@@ -159,6 +206,6 @@ impl State {
             SubscriptionStateChange::Reset => panic!("Should not remove during a reset!"),
         }
 
-        self.subscribed.remove(subscription);
+        subscribed.remove(subscription);
     }
 }

crates/bonfire/src/main.rs

@@ -19,11 +19,14 @@ async fn main() {
     database::connect().await;
 
     // Clean up the current region information.
-    clear_region(None).await;
+    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 9000 on all interfaces.
-    let bind = env::var("HOST").unwrap_or_else(|_| "0.0.0.0:9000".into());
+    // 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");

crates/bonfire/src/websocket.rs

@@ -1,24 +1,33 @@
-use std::net::SocketAddr;
+use std::{collections::HashSet, net::SocketAddr, sync::Arc};
 
 use async_tungstenite::WebSocketStream;
+use authifier::AuthifierEvent;
 use fred::{
+    error::RedisErrorKind,
     interfaces::{ClientLike, EventInterface, PubsubInterface},
     types::RedisConfig,
 };
 use futures::{
     channel::oneshot,
-    pin_mut, select,
+    join, pin_mut, select,
     stream::{SplitSink, SplitStream},
     FutureExt, SinkExt, StreamExt, TryStreamExt,
 };
 use redis_kiss::{PayloadType, REDIS_PAYLOAD_TYPE, REDIS_URI};
+use revolt_config::report_internal_error;
 use revolt_database::{
     events::{client::EventV1, server::ClientMessage},
     Database, User, UserHint,
 };
 use revolt_presence::{create_session, delete_session};
 
-use async_std::{net::TcpStream, sync::Mutex};
+use async_std::{
+    net::TcpStream,
+    sync::{Mutex, RwLock},
+    task::spawn,
+};
+use revolt_result::create_error;
+use sentry::Level;
 
 use crate::config::{ProtocolConfiguration, WebsocketHandshakeCallback};
 use crate::events::state::{State, SubscriptionStateChange};
@@ -42,10 +51,12 @@ pub async fn client(db: &'static Database, stream: TcpStream, addr: SocketAddr)
     else {
         return;
     };
+
     // Verify we've received a valid config, otherwise we should just drop the connection.
     let Ok(mut config) = receiver.await else {
         return;
     };
+
     info!(
         "User {addr:?} provided protocol configuration (version = {}, format = {:?})",
         config.get_protocol_version(),
@@ -57,10 +68,8 @@ pub async fn client(db: &'static Database, stream: TcpStream, addr: SocketAddr)
 
     // If the user has not provided authentication, request information.
     if config.get_session_token().is_none() {
-        while let Ok(message) = read.try_next().await {
-            if let Ok(ClientMessage::Authenticate { token }) =
-                config.decode(message.as_ref().unwrap())
-            {
+        while let Ok(Some(message)) = read.try_next().await {
+            if let Ok(ClientMessage::Authenticate { token }) = config.decode(&message) {
                 config.set_session_token(token);
                 break;
             }
@@ -69,35 +78,48 @@ pub async fn client(db: &'static Database, stream: TcpStream, addr: SocketAddr)
 
     // 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 = match User::from_token(db, token, UserHint::Any).await {
+
+    let (user, session_id) = match User::from_token(db, token, UserHint::Any).await {
         Ok(user) => user,
         Err(err) => {
-            write.send(config.encode(&err)).await.ok();
+            write
+                .send(config.encode(&EventV1::Error { data: err }))
+                .await
+                .ok();
             return;
         }
     };
+
     info!("User {addr:?} authenticated as @{}", user.username);
 
     // Create local state.
-    let mut state = State::from(user);
+    let mut state = State::from(user, session_id);
     let user_id = state.cache.user_id.clone();
 
     // Notify socket we have authenticated.
-    if write
-        .send(config.encode(&EventV1::Authenticated))
-        .await
-        .is_err()
-    {
+    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 Ok(ready_payload) = state.generate_ready_payload(db).await else {
-        return;
+    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 write.send(config.encode(&ready_payload)).await.is_err() {
+
+    if report_internal_error!(write.send(config.encode(&ready_payload)).await).is_err() {
         return;
     }
 
@@ -110,20 +132,44 @@ pub async fn client(db: &'static Database, stream: TcpStream, addr: SocketAddr)
     }
 
     {
+        // Setup channels and mutexes
         let write = Mutex::new(write);
+        let subscribed = state.subscribed.clone();
+        let active_servers = state.active_servers.clone();
+        let (topic_signal_s, topic_signal_r) = async_channel::unbounded();
+
+        // TODO: this needs to be rewritten
+        // Create channels through which the tasks can signal to each other they need to clean up
+        let (kill_signal_1_s, kill_signal_1_r) = async_channel::bounded(1);
+        let (kill_signal_2_s, kill_signal_2_r) = async_channel::bounded(1);
+
         // Create a PubSub connection to poll on.
-        let listener = listener(db, &mut state, addr, &config, &write).fuse();
-        // Read from WebSocket stream.
-        let worker = worker(addr, user_id.clone(), &config, read, &write).fuse();
-
-        // Pin both tasks.
-        pin_mut!(listener, worker);
-
-        // Wait for either disconnect or for listener to die.
-        select!(
-            () = listener => {},
-            () = worker => {}
+        let listener = listener_with_kill_signal(
+            db,
+            &mut state,
+            addr,
+            &config,
+            topic_signal_r,
+            kill_signal_1_r,
+            &write,
+            kill_signal_2_s,
         );
+
+        // Read from WebSocket stream.
+        let worker = worker_with_kill_signal(
+            addr,
+            subscribed,
+            active_servers,
+            user_id.clone(),
+            &config,
+            topic_signal_s,
+            kill_signal_2_r,
+            read,
+            &write,
+            kill_signal_1_s,
+        );
+
+        join!(listener, worker);
     }
     // Clean up presence session.
     let last_session = delete_session(&user_id, session_id).await;
@@ -134,29 +180,79 @@ pub async fn client(db: &'static Database, stream: TcpStream, addr: SocketAddr)
     }
 }
 
+#[allow(clippy::too_many_arguments)]
+async fn listener_with_kill_signal(
+    db: &'static Database,
+    state: &mut State,
+    addr: SocketAddr,
+    config: &ProtocolConfiguration,
+    topic_signal_r: async_channel::Receiver<()>,
+    kill_signal_r: async_channel::Receiver<()>,
+    write: &Mutex<WsWriter>,
+    kill_signal_s: async_channel::Sender<()>,
+) {
+    listener(
+        db,
+        state,
+        addr,
+        config,
+        topic_signal_r,
+        kill_signal_r,
+        write,
+    )
+    .await;
+    kill_signal_s.send(()).await.ok();
+}
+
 async fn listener(
     db: &'static Database,
     state: &mut State,
     addr: SocketAddr,
     config: &ProtocolConfiguration,
+    topic_signal_r: async_channel::Receiver<()>,
+    kill_signal_r: async_channel::Receiver<()>,
     write: &Mutex<WsWriter>,
 ) {
     let redis_config = RedisConfig::from_url(&REDIS_URI).unwrap();
-    let Ok(subscriber) = fred::types::Builder::from_config(redis_config).build_subscriber_client()
-    else {
-        return;
+    let subscriber = match report_internal_error!(
+        fred::types::Builder::from_config(redis_config).build_subscriber_client()
+    ) {
+        Ok(subscriber) => subscriber,
+        Err(_) => return,
     };
-    if subscriber.init().await.is_err() {
+
+    if report_internal_error!(subscriber.init().await).is_err() {
         return;
-    };
+    }
+
+    // Handle Redis connection dropping
+    let (clean_up_s, clean_up_r) = async_channel::bounded(1);
+    let clean_up_s = Arc::new(Mutex::new(clean_up_s));
+    subscriber.on_error(move |err| {
+        if let RedisErrorKind::Canceled = err.kind() {
+            let clean_up_s = clean_up_s.clone();
+            spawn(async move {
+                clean_up_s.lock().await.send(()).await.ok();
+            });
+        }
+
+        Ok(())
+    });
+
     let mut message_rx = subscriber.message_rx();
-    loop {
+    'out: loop {
         // Check for state changes for subscriptions.
-        match state.apply_state() {
+        match state.apply_state().await {
             SubscriptionStateChange::Reset => {
-                subscriber.unsubscribe_all().await.unwrap();
-                for id in state.iter_subscriptions() {
-                    subscriber.subscribe(id).await.unwrap();
+                if report_internal_error!(subscriber.unsubscribe_all().await).is_err() {
+                    break 'out;
+                }
+
+                let subscribed = state.subscribed.read().await;
+                for id in subscribed.iter() {
+                    if report_internal_error!(subscriber.subscribe(id).await).is_err() {
+                        break 'out;
+                    }
                 }
 
                 #[cfg(debug_assertions)]
@@ -167,112 +263,242 @@ async fn listener(
                     #[cfg(debug_assertions)]
                     info!("{addr:?} unsubscribing from {id}");
 
-                    subscriber.unsubscribe(id).await.unwrap();
+                    if report_internal_error!(subscriber.unsubscribe(id).await).is_err() {
+                        break 'out;
+                    }
                 }
 
                 for id in add {
                     #[cfg(debug_assertions)]
                     info!("{addr:?} subscribing to {id}");
 
-                    subscriber.subscribe(id).await.unwrap();
+                    if report_internal_error!(subscriber.subscribe(id).await).is_err() {
+                        break 'out;
+                    }
                 }
             }
             SubscriptionStateChange::None => {}
         }
 
-        // Handle incoming events.
-        let Ok(message) = message_rx.recv().await.map_err(|e| {
-            warn!("Error while consuming pub/sub messages: {e:?}");
-            sentry::capture_error(&e);
-        }) else {
-            return;
-        };
-        let event = match *REDIS_PAYLOAD_TYPE {
-            PayloadType::Json => message
-                .value
-                .as_str()
-                .and_then(|s| serde_json::from_str::<EventV1>(s.as_ref()).ok()),
-            PayloadType::Msgpack => message
-                .value
-                .as_bytes()
-                .and_then(|b| rmp_serde::from_slice::<EventV1>(b).ok()),
-            PayloadType::Bincode => message
-                .value
-                .as_bytes()
-                .and_then(|b| bincode::deserialize::<EventV1>(b).ok()),
-        };
-        let Some(mut event) = event else {
-            warn!("Failed to deserialise an event for {}!", message.channel);
-            return;
-        };
-        let should_send = state.handle_incoming_event_v1(db, &mut event).await;
-        if !should_send {
-            continue;
-        }
+        let t1 = message_rx.recv().fuse();
+        let t2 = topic_signal_r.recv().fuse();
+        let t3 = kill_signal_r.recv().fuse();
+        let t4 = clean_up_r.recv().fuse();
 
-        let result = write.lock().await.send(config.encode(&event)).await;
-        if let Err(e) = result {
-            use async_tungstenite::tungstenite::Error;
-            if !matches!(e, Error::AlreadyClosed | Error::ConnectionClosed) {
-                warn!("Error while sending an event to {addr:?}: {e:?}");
+        pin_mut!(t1, t2, t3, t4);
+
+        select! {
+            _ = t4 => {
+                break 'out;
+            },
+            _ = t3 => {
+                break 'out;
+            },
+            _ = t2 => {},
+            message = t1 => {
+                // Handle incoming events.
+                let message = match report_internal_error!(message) {
+                    Ok(message) => message,
+                    Err(_) => break 'out
+                };
+
+                let event = match *REDIS_PAYLOAD_TYPE {
+                    PayloadType::Json => message
+                        .value
+                        .as_str()
+                        .and_then(|s| report_internal_error!(serde_json::from_str::<EventV1>(s.as_ref())).ok()),
+                    PayloadType::Msgpack => message
+                        .value
+                        .as_bytes()
+                        .and_then(|b| report_internal_error!(rmp_serde::from_slice::<EventV1>(b)).ok()),
+                    PayloadType::Bincode => message
+                        .value
+                        .as_bytes()
+                        .and_then(|b| report_internal_error!(bincode::deserialize::<EventV1>(b)).ok()),
+                };
+
+                let Some(mut event) = event else {
+                    let err = format!(
+                        "Failed to deserialise event for {}: `{:?}`",
+                        message.channel,
+                        message
+                            .value
+                    );
+
+                    error!("{}", err);
+                    sentry::capture_message(&err, Level::Error);
+                    break 'out;
+                };
+
+                if let EventV1::Auth(auth) = &event {
+                    if let AuthifierEvent::DeleteSession { session_id, .. } = auth {
+                        if &state.session_id == session_id {
+                            event = EventV1::Logout;
+                        }
+                    } else if let AuthifierEvent::DeleteAllSessions {
+                        exclude_session_id, ..
+                    } = auth
+                    {
+                        if let Some(excluded) = exclude_session_id {
+                            if &state.session_id != excluded {
+                                event = EventV1::Logout;
+                            }
+                        } else {
+                            event = EventV1::Logout;
+                        }
+                    }
+                } else {
+                    let should_send = state.handle_incoming_event_v1(db, &mut event).await;
+                    if !should_send {
+                        continue;
+                    }
+                }
+
+                let result = write.lock().await.send(config.encode(&event)).await;
+                if let Err(e) = result {
+                    use async_tungstenite::tungstenite::Error;
+                    if !matches!(e, Error::AlreadyClosed | Error::ConnectionClosed) {
+                        let err = format!("Error while sending an event to {addr:?}: {e:?}");
+                        warn!("{}", err);
+                        sentry::capture_message(&err, Level::Warning);
+                    }
+
+                    break 'out;
+                }
+
+                if let EventV1::Logout = event {
+                    info!("User {addr:?} received log out event!");
+                    break 'out;
+                }
             }
-            return;
         }
     }
+
+    report_internal_error!(subscriber.quit().await).ok();
 }
 
-async fn worker(
+#[allow(clippy::too_many_arguments)]
+async fn worker_with_kill_signal(
     addr: SocketAddr,
+    subscribed: Arc<RwLock<HashSet<String>>>,
+    active_servers: Arc<Mutex<lru_time_cache::LruCache<String, ()>>>,
     user_id: String,
     config: &ProtocolConfiguration,
+    topic_signal_s: async_channel::Sender<()>,
+    kill_signal_r: async_channel::Receiver<()>,
+    read: WsReader,
+    write: &Mutex<WsWriter>,
+    kill_signal_s: async_channel::Sender<()>,
+) {
+    worker(
+        addr,
+        subscribed,
+        active_servers,
+        user_id,
+        config,
+        topic_signal_s,
+        kill_signal_r,
+        read,
+        write,
+    )
+    .await;
+    kill_signal_s.send(()).await.ok();
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn worker(
+    addr: SocketAddr,
+    subscribed: Arc<RwLock<HashSet<String>>>,
+    active_servers: Arc<Mutex<lru_time_cache::LruCache<String, ()>>>,
+    user_id: String,
+    config: &ProtocolConfiguration,
+    topic_signal_s: async_channel::Sender<()>,
+    kill_signal_r: async_channel::Receiver<()>,
     mut read: WsReader,
     write: &Mutex<WsWriter>,
 ) {
     loop {
-        let result = read.try_next().await;
-        let msg = match result {
-            Ok(Some(msg)) => msg,
-            Ok(None) => return,
-            Err(e) => {
-                use async_tungstenite::tungstenite::Error;
-                if !matches!(e, Error::AlreadyClosed | Error::ConnectionClosed) {
-                    warn!("Error while reading an event from {addr:?}: {e:?}");
-                }
-                return;
-            }
-        };
+        let t1 = read.try_next().fuse();
+        let t2 = kill_signal_r.recv().fuse();
 
-        let Ok(payload) = config.decode(&msg) else {
-            continue;
-        };
-        match payload {
-            ClientMessage::BeginTyping { channel } => {
-                EventV1::ChannelStartTyping {
-                    id: channel.clone(),
-                    user: user_id.clone(),
-                }
-                .p(channel.clone())
-                .await;
-            }
-            ClientMessage::EndTyping { channel } => {
-                EventV1::ChannelStopTyping {
-                    id: channel.clone(),
-                    user: user_id.clone(),
-                }
-                .p(channel.clone())
-                .await;
-            }
-            ClientMessage::Ping { data, responded } => {
-                if responded.is_none() {
-                    write
-                        .lock()
-                        .await
-                        .send(config.encode(&EventV1::Pong { data }))
-                        .await
-                        .ok();
+        pin_mut!(t1, t2);
+
+        select! {
+            _ = t2 => {
+                return;
+            },
+            result = t1 => {
+                let msg = match result {
+                    Ok(Some(msg)) => msg,
+                    Ok(None) => {
+                        warn!("Received a None message!");
+                        sentry::capture_message("Received a None message!", Level::Warning);
+                        return;
+                    }
+                    Err(e) => {
+                        use async_tungstenite::tungstenite::Error;
+                        if !matches!(e, Error::AlreadyClosed | Error::ConnectionClosed) {
+                            let err = format!("Error while reading an event from {addr:?}: {e:?}");
+                            warn!("{}", err);
+                            sentry::capture_message(&err, Level::Warning);
+                        }
+
+                        return;
+                    }
+                };
+
+                let Ok(payload) = config.decode(&msg) else {
+                    continue;
+                };
+
+                match payload {
+                    ClientMessage::BeginTyping { channel } => {
+                        if !subscribed.read().await.contains(&channel) {
+                            continue;
+                        }
+
+                        EventV1::ChannelStartTyping {
+                            id: channel.clone(),
+                            user: user_id.clone(),
+                        }
+                        .p(channel.clone())
+                        .await;
+                    }
+                    ClientMessage::EndTyping { channel } => {
+                        if !subscribed.read().await.contains(&channel) {
+                            continue;
+                        }
+
+                        EventV1::ChannelStopTyping {
+                            id: channel.clone(),
+                            user: user_id.clone(),
+                        }
+                        .p(channel.clone())
+                        .await;
+                    }
+                    ClientMessage::Subscribe { server_id } => {
+                        let mut servers = active_servers.lock().await;
+                        let has_item = servers.contains_key(&server_id);
+                        servers.insert(server_id, ());
+
+                        if !has_item {
+                            // Poke the listener to adjust subscriptions
+                            topic_signal_s.send(()).await.ok();
+                        }
+                    }
+                    ClientMessage::Ping { data, responded } => {
+                        if responded.is_none() {
+                            write
+                                .lock()
+                                .await
+                                .send(config.encode(&EventV1::Pong { data }))
+                                .await
+                                .ok();
+                        }
+                    }
+                    _ => {}
                 }
             }
-            _ => {}
         }
     }
 }

crates/core/config/Cargo.toml

@@ -1,20 +1,21 @@
 [package]
 name = "revolt-config"
-version = "0.7.2"
+version = "0.8.7"
 edition = "2021"
-license = "AGPL-3.0-or-later"
+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"]
+default = ["test", "anyhow"]
 
 [dependencies]
 # Utility
-dotenv = "0.15.0"
 config = "0.13.3"
 cached = "0.44.0"
 once_cell = "1.18.0"
@@ -32,3 +33,7 @@ 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.7", 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

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

@@ -1,8 +1,19 @@
+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"
@@ -11,61 +22,258 @@ january = "http://local.revolt.chat/january"
 voso_legacy = ""
 voso_legacy_ws = ""
 
+[rabbit]
+host = "rabbit"
+port = 5672
+username = "rabbituser"
+password = "rabbitpass"
+
 [api]
 
 [api.registration]
+# Whether an invite should be required for registration
+# See https://github.com/revoltchat/self-hosted#making-your-instance-invite-only
 invite_only = false
 
 [api.smtp]
+# Email server configuration for verification
+# Defaults to no email verification (host field is empty)
 host = ""
 username = ""
 password = ""
-from_address = ""
+from_address = "noreply@example.com"
+# reply_to = "noreply@example.com"
+# port = 587
+# use_tls = true
 
-[api.vapid]
-private_key = "LS0tLS1CRUdJTiBFQyBQUklWQVRFIEtFWS0tLS0tCk1IY0NBUUVFSUJSUWpyTWxLRnBiVWhsUHpUbERvcEliYk1yeVNrNXpKYzVYVzIxSjJDS3hvQW9HQ0NxR1NNNDkKQXdFSG9VUURRZ0FFWnkrQkg2TGJQZ2hEa3pEempXOG0rUXVPM3pCajRXT1phdkR6ZU00c0pqbmFwd1psTFE0WAp1ZDh2TzVodU94QWhMQlU3WWRldVovWHlBdFpWZmNyQi9BPT0KLS0tLS1FTkQgRUMgUFJJVkFURSBLRVktLS0tLQo"
-public_key = "BGcvgR-i2z4IQ5Mw841vJvkLjt8wY-FjmWrw83jOLCY52qcGZS0OF7nfLzuYbjsQISwVO2HXrmf18gLWVX3Kwfw="
-
-[api.fcm]
-api_key = ""
 
 [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.default]
+[features.limits.global]
 group_size = 100
-bots = 5
-message_length = 2000
 message_embeds = 5
 message_replies = 5
-message_attachments = 5
 message_reactions = 20
-servers = 100
 server_emoji = 100
 server_roles = 200
 server_channels = 200
 
-attachment_size = 20000000
-avatar_size = 4000000
-background_size = 6000000
-icon_size = 2500000
-banner_size = 6000000
-emoji_size = 500000
+# 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

@@ -6,9 +6,61 @@ use futures_locks::RwLock;
 use once_cell::sync::Lazy;
 use serde::Deserialize;
 
-#[cfg(not(debug_assertions))]
-use std::env;
+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",
+];
+
+/// Configuration builder
 static CONFIG_BUILDER: Lazy<RwLock<Config>> = Lazy::new(|| {
     RwLock::new({
         let mut builder = Config::builder().add_source(File::from_str(
@@ -21,22 +73,32 @@ static CONFIG_BUILDER: Lazy<RwLock<Config>> = Lazy::new(|| {
                 include_str!("../Revolt.test.toml"),
                 FileFormat::Toml,
             ));
-        } else if std::path::Path::new("Revolt.toml").exists() {
-            builder = builder.add_source(File::new("Revolt.toml", FileFormat::Toml));
+        }
+
+        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()
     })
 });
 
-// https://gifbox.me/view/gT5mqxYKCZv-twilight-meow
-
 #[derive(Deserialize, Debug, Clone)]
 pub struct Database {
     pub mongodb: String,
     pub redis: String,
 }
 
+#[derive(Deserialize, Debug, Clone)]
+pub struct Rabbit {
+    pub host: String,
+    pub port: u16,
+    pub username: String,
+    pub password: String,
+}
+
 #[derive(Deserialize, Debug, Clone)]
 pub struct Hosts {
     pub app: String,
@@ -62,17 +124,38 @@ pub struct ApiSmtp {
     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 ApiVapid {
+pub struct PushVapid {
+    pub queue: String,
     pub private_key: String,
     pub public_key: String,
 }
 
 #[derive(Deserialize, Debug, Clone)]
-pub struct ApiFcm {
-    pub api_key: String,
+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)]
@@ -87,6 +170,7 @@ pub struct ApiSecurity {
     pub voso_legacy_token: String,
     pub captcha: ApiSecurityCaptcha,
     pub trust_cloudflare: bool,
+    pub easypwned: String,
 }
 
 #[derive(Deserialize, Debug, Clone)]
@@ -95,85 +179,195 @@ pub struct ApiWorkers {
 }
 
 #[derive(Deserialize, Debug, Clone)]
-pub struct Api {
-    pub registration: ApiRegistration,
-    pub smtp: ApiSmtp,
-    pub vapid: ApiVapid,
-    pub fcm: ApiFcm,
-    pub security: ApiSecurity,
-    pub workers: ApiWorkers,
+pub struct ApiUsers {
+    pub early_adopter_cutoff: Option<u64>,
 }
 
 #[derive(Deserialize, Debug, Clone)]
-pub struct FeaturesLimits {
+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 bots: usize,
-    pub message_length: usize,
-    pub message_replies: usize,
-    pub message_attachments: usize,
     pub message_embeds: usize,
+    pub message_replies: usize,
     pub message_reactions: usize,
-    pub servers: usize,
     pub server_emoji: usize,
     pub server_roles: usize,
     pub server_channels: usize,
 
-    pub attachment_size: usize,
-    pub avatar_size: usize,
-    pub background_size: usize,
-    pub icon_size: usize,
-    pub banner_size: usize,
-    pub emoji_size: usize,
+    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() {
-            #[cfg(not(debug_assertions))]
-            if !env::var("REVOLT_UNSAFE_NO_EMAIL").map_or(false, |v| v == *"1") {
-                panic!("Running in production without email is not recommended, set REVOLT_UNSAFE_NO_EMAIL=1 to override.");
-            }
-
-            #[cfg(debug_assertions)]
             log::warn!("No SMTP settings specified! Remember to configure email.");
         }
 
         if self.api.security.captcha.hcaptcha_key.is_empty() {
-            #[cfg(not(debug_assertions))]
-            if !env::var("REVOLT_UNSAFE_NO_CAPTCHA").map_or(false, |v| v == *"1") {
-                panic!("Running in production without CAPTCHA is not recommended, set REVOLT_UNSAFE_NO_CAPTCHA=1 to override.");
-            }
-
-            #[cfg(debug_assertions)]
             log::warn!("No Captcha key specified! Remember to add hCaptcha key.");
         }
     }
@@ -192,13 +386,18 @@ pub async fn read() -> Config {
 
 #[cached(time = 30)]
 pub async fn config() -> Settings {
-    read().await.try_deserialize::<Settings>().unwrap()
+    let mut config = read().await.try_deserialize::<Settings>().unwrap();
+
+    // auto-detect production nodes
+    if config.hosts.api.contains("https") && config.hosts.api.contains("revolt.chat") {
+        config.production = true;
+    }
+
+    config
 }
 
 /// Configure logging and common Rust variables
 pub async fn setup_logging(release: &'static str, dsn: String) -> Option<sentry::ClientInitGuard> {
-    dotenv::dotenv().ok();
-
     if std::env::var("RUST_LOG").is_err() {
         std::env::set_var("RUST_LOG", "info");
     }
@@ -207,6 +406,12 @@ pub async fn setup_logging(release: &'static str, dsn: String) -> Option<sentry:
         std::env::set_var("ROCKET_ADDRESS", "0.0.0.0");
     }
 
+    if std::env::var("REDIS_URL").is_err() {
+        // Configure redis-kiss library
+        let config = config().await;
+        std::env::set_var("REDIS_URI", config.database.redis);
+    }
+
     pretty_env_logger::init();
     log::info!("Starting {release}");
 

crates/core/database/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-database"
-version = "0.7.2"
+version = "0.8.7"
 edition = "2021"
 license = "AGPL-3.0-or-later"
 authors = ["Paul Makles <me@insrt.uk>"]
@@ -16,6 +16,7 @@ mongodb = ["dep:mongodb", "bson"]
 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
@@ -23,16 +24,19 @@ default = ["mongodb", "async-std-runtime", "tasks"]
 
 [dependencies]
 # Core
-revolt-config = { version = "0.7.2", path = "../config" }
-revolt-result = { version = "0.7.2", path = "../result" }
-revolt-models = { version = "0.7.2", path = "../models", features = [
+revolt-config = { version = "0.8.7", path = "../config", features = [
+    "report-macros",
+] }
+revolt-result = { version = "0.8.7", path = "../result" }
+revolt-models = { version = "0.8.7", path = "../models", features = [
     "validator",
 ] }
-revolt-presence = { version = "0.7.2", path = "../presence" }
-revolt-permissions = { version = "0.7.2", path = "../permissions", features = [
+revolt-presence = { version = "0.8.7", path = "../presence" }
+revolt-permissions = { version = "0.8.7", path = "../permissions", features = [
     "serde",
     "bson",
 ] }
+revolt-parser = { version = "0.8.7", path = "../parser" }
 
 # Utility
 log = "0.4"
@@ -61,7 +65,7 @@ redis-kiss = { version = "0.1.4" }
 
 # Database
 bson = { optional = true, version = "2.1.0" }
-mongodb = { optional = true, version = "2.1.0", default-features = false }
+mongodb = { optional = true, version = "3.1.0" }
 
 # Database Migration
 unicode-segmentation = "1.10.1"
@@ -76,17 +80,24 @@ 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.0-rc.2", default-features = false, features = [
+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.9.1", optional = true }
+revolt_rocket_okapi = { version = "0.10.0", optional = true }
 
 # Notifications
-fcm = "0.9.2"
+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.8" }
+authifier = { version = "1.0.15", features = ["rocket_impl"] }
+
+# RabbitMQ
+amqprs = { version = "1.7.0" }

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

@@ -1,6 +1,15 @@
 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;
 
@@ -87,3 +96,135 @@ impl DatabaseInfo {
         })
     }
 }
+
+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

@@ -31,17 +31,17 @@ impl MongoDb {
     }
 
     /// Get a collection by its name
-    pub fn col<T>(&self, collection: &str) -> mongodb::Collection<T> {
+    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>(
+    pub async fn insert_one<T: Serialize + Send + Sync>(
         &self,
         collection: &'static str,
         document: T,
     ) -> Result<InsertOneResult> {
-        self.col::<T>(collection).insert_one(document, None).await
+        self.col::<T>(collection).insert_one(document).await
     }
 
     /// Count documents by projection
@@ -51,7 +51,7 @@ impl MongoDb {
         projection: Document,
     ) -> Result<u64> {
         self.col::<Document>(collection)
-            .count_documents(projection, None)
+            .count_documents(projection)
             .await
     }
 
@@ -67,7 +67,8 @@ impl MongoDb {
     {
         Ok(self
             .col::<T>(collection)
-            .find(projection, options)
+            .find(projection)
+            .with_options(options)
             .await?
             .filter_map(|s| async {
                 if cfg!(debug_assertions) {
@@ -101,7 +102,8 @@ impl MongoDb {
         O: Into<Option<FindOneOptions>>,
     {
         self.col::<T>(collection)
-            .find_one(projection, options)
+            .find_one(projection)
+            .with_options(options)
             .await
     }
 
@@ -165,7 +167,7 @@ impl MongoDb {
         };
 
         self.col::<Document>(collection)
-            .update_one(projection, query, None)
+            .update_one(projection, query)
             .await
     }
 
@@ -200,7 +202,7 @@ impl MongoDb {
         projection: Document,
     ) -> Result<DeleteResult> {
         self.col::<Document>(collection)
-            .delete_one(projection, None)
+            .delete_one(projection)
             .await
     }
 

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

@@ -3,9 +3,9 @@ use std::{collections::HashMap, sync::Arc};
 use futures::lock::Mutex;
 
 use crate::{
-    Bot, Channel, ChannelCompositeKey, ChannelUnread, Emoji, File, Invite, Member,
-    MemberCompositeKey, Message, RatelimitEvent, Report, Server, ServerBan, Snapshot, User,
-    UserSettings, Webhook,
+    Bot, Channel, ChannelCompositeKey, ChannelUnread, Emoji, File, FileHash, Invite, Member,
+    MemberCompositeKey, Message, PolicyChange, RatelimitEvent, Report, Server, ServerBan, Snapshot,
+    User, UserSettings, Webhook,
 };
 
 database_derived!(
@@ -18,8 +18,10 @@ database_derived!(
         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>>>,

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

@@ -1,28 +1,16 @@
 use authifier::AuthifierEvent;
+use revolt_result::Error;
 use serde::{Deserialize, Serialize};
 
 use revolt_models::v0::{
-    AppendMessage, Channel, Emoji, FieldsChannel, FieldsMember, FieldsRole, FieldsServer,
-    FieldsUser, FieldsWebhook, Member, MemberCompositeKey, Message, PartialChannel, PartialMember,
-    PartialMessage, PartialRole, PartialServer, PartialUser, PartialWebhook, Report, Server, User,
-    UserSettings, Webhook,
+    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 revolt_result::Error;
 
 use crate::Database;
 
-/// WebSocket Client Errors
-#[derive(Serialize, Deserialize, Debug, Clone)]
-#[serde(tag = "error")]
-pub enum WebSocketError {
-    LabelMe,
-    InternalError { at: String },
-    InvalidSession,
-    OnboardingNotFinished,
-    AlreadyAuthenticated,
-    MalformedData { msg: String },
-}
-
 /// Ping Packet
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(untagged)]
@@ -31,12 +19,17 @@ pub enum Ping {
     Number(usize),
 }
 
-/// Untagged Error
-#[derive(Serialize)]
-#[serde(untagged)]
-pub enum ErrorEvent {
-    Error(WebSocketError),
-    APIError(Error),
+/// Fields provided in Ready payload
+#[derive(PartialEq)]
+pub enum ReadyPayloadFields {
+    Users,
+    Servers,
+    Channels,
+    Members,
+    Emoji,
+
+    UserSettings(Vec<String>),
+    ChannelUnreads,
 }
 
 /// Protocol Events
@@ -45,16 +38,32 @@ pub enum ErrorEvent {
 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 {
-        users: Vec<User>,
-        servers: Vec<Server>,
-        channels: Vec<Channel>,
-        members: Vec<Member>,
-        emojis: Vec<Emoji>,
+        #[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
@@ -67,6 +76,8 @@ pub enum EventV1 {
         id: String,
         channel: String,
         data: PartialMessage,
+        #[serde(default)]
+        clear: Vec<FieldsMessage>,
     },
 
     /// Append information to existing message
@@ -117,6 +128,7 @@ pub enum EventV1 {
     ServerUpdate {
         id: String,
         data: PartialServer,
+        #[serde(default)]
         clear: Vec<FieldsServer>,
     },
 
@@ -127,6 +139,7 @@ pub enum EventV1 {
     ServerMemberUpdate {
         id: MemberCompositeKey,
         data: PartialMember,
+        #[serde(default)]
         clear: Vec<FieldsMember>,
     },
 
@@ -134,13 +147,18 @@ pub enum EventV1 {
     ServerMemberJoin { id: String, user: String },
 
     /// User left server
-    ServerMemberLeave { id: String, user: String },
+    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>,
     },
 
@@ -151,6 +169,7 @@ pub enum EventV1 {
     UserUpdate {
         id: String,
         data: PartialUser,
+        #[serde(default)]
         clear: Vec<FieldsUser>,
         event_id: Option<String>,
     },
@@ -185,6 +204,7 @@ pub enum EventV1 {
     ChannelUpdate {
         id: String,
         data: PartialChannel,
+        #[serde(default)]
         clear: Vec<FieldsChannel>,
     },
 
@@ -247,7 +267,7 @@ impl EventV1 {
         // TODO: this should be captured by member list in the future and not immediately fanned out to users
         if let Ok(members) = db.fetch_all_memberships(&id).await {
             for member in members {
-                self.clone().p(member.id.server).await;
+                self.clone().server(member.id.server).await;
             }
         }
     }
@@ -257,6 +277,11 @@ impl EventV1 {
         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

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

@@ -8,5 +8,6 @@ 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

@@ -16,6 +16,8 @@ extern crate revolt_optional_struct;
 #[macro_use]
 extern crate revolt_result;
 
+pub use iso8601_timestamp;
+
 #[cfg(feature = "mongodb")]
 pub use mongodb;
 
@@ -23,6 +25,26 @@ pub use 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 )+ ) => {
         $(
@@ -83,7 +105,15 @@ 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/ops/mongodb.rs

@@ -10,7 +10,7 @@ impl AbstractMigrations for MongoDb {
     #[cfg(test)]
     /// Drop the database
     async fn drop_database(&self) {
-        self.db().drop(None).await.ok();
+        self.db().drop().await.ok();
     }
 
     /// Migrate the database
@@ -18,7 +18,7 @@ impl AbstractMigrations for MongoDb {
         info!("Migrating the database.");
 
         let list = self
-            .list_database_names(None, None)
+            .list_database_names()
             .await
             .expect("Failed to fetch database names.");
 

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

@@ -8,227 +8,258 @@ pub async fn create_database(db: &MongoDb) {
     info!("Creating database.");
     let db = db.db();
 
-    db.create_collection("accounts", None)
+    db.create_collection("accounts")
         .await
         .expect("Failed to create accounts collection.");
 
-    db.create_collection("users", None)
+    db.create_collection("users")
         .await
         .expect("Failed to create users collection.");
 
-    db.create_collection("channels", None)
+    db.create_collection("channels")
         .await
         .expect("Failed to create channels collection.");
 
-    db.create_collection("messages", None)
+    db.create_collection("messages")
         .await
         .expect("Failed to create messages collection.");
 
-    db.create_collection("servers", None)
+    db.create_collection("servers")
         .await
         .expect("Failed to create servers collection.");
 
-    db.create_collection("server_members", None)
+    db.create_collection("server_members")
         .await
         .expect("Failed to create server_members collection.");
 
-    db.create_collection("server_bans", None)
+    db.create_collection("server_bans")
         .await
         .expect("Failed to create server_bans collection.");
 
-    db.create_collection("channel_invites", None)
+    db.create_collection("channel_invites")
         .await
         .expect("Failed to create channel_invites collection.");
 
-    db.create_collection("channel_unreads", None)
+    db.create_collection("channel_unreads")
         .await
         .expect("Failed to create channel_unreads collection.");
 
-    db.create_collection("channel_webhooks", None)
+    db.create_collection("channel_webhooks")
         .await
         .expect("Failed to create channel_webhooks collection.");
 
-    db.create_collection("migrations", None)
+    db.create_collection("migrations")
         .await
         .expect("Failed to create migrations collection.");
 
-    db.create_collection("attachments", None)
+    db.create_collection("attachments")
         .await
         .expect("Failed to create attachments collection.");
 
-    db.create_collection("user_settings", None)
+    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("safety_reports", None)
+    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", None)
+    db.create_collection("safety_snapshots")
         .await
         .expect("Failed to create safety_snapshots collection.");
 
-    db.create_collection("safety_strikes", None)
+    db.create_collection("safety_strikes")
         .await
         .expect("Failed to create safety_strikes collection.");
 
-    db.create_collection("bots", None)
+    db.create_collection("bots")
         .await
         .expect("Failed to create bots collection.");
 
-    db.create_collection("ratelimit_events", None)
+    db.create_collection("ratelimit_events")
         .await
         .expect("Failed to create ratelimit_events collection.");
 
-    db.create_collection(
-        "pubsub",
-        CreateCollectionOptions::builder()
-            .capped(true)
-            .size(1_000_000)
-            .build(),
-    )
-    .await
-    .expect("Failed to create pubsub 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
-                    }
+    db.run_command(doc! {
+        "createIndexes": "users",
+        "indexes": [
+            {
+                "key": {
+                    "username": 1_i32
                 },
-                {
-                    "key": {
-                        "username": 1_i32,
-                        "discriminator": 1_i32
-                    },
-                    "name": "username_discriminator",
-                    "unique": true,
-                    "collation": {
-                        "locale": "en",
-                        "strength": 2_i32
-                    }
+                "name": "username",
+                "unique": false,
+                "collation": {
+                    "locale": "en",
+                    "strength": 2_i32
                 }
-            ]
-        },
-        None,
-    )
+            },
+            {
+                "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"
+    db.run_command(doc! {
+        "createIndexes": "messages",
+        "indexes": [
+            {
+                "key": {
+                    "content": "text"
                 },
-                {
-                    "key": {
-                        "channel": 1_i32,
-                        "_id": 1_i32
-                    },
-                    "name": "channel_id_compound"
+                "name": "content"
+            },
+            {
+                "key": {
+                    "channel": 1_i32,
+                    "_id": 1_i32
                 },
-                {
-                    "key": {
-                        "author": 1_i32
-                    },
-                    "name": "author"
-                }
-            ]
-        },
-        None,
-    )
+                "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"
+    db.run_command(doc! {
+        "createIndexes": "channel_unreads",
+        "indexes": [
+            {
+                "key": {
+                    "_id.channel": 1_i32,
+                    "_id.user": 1_i32,
                 },
-                {
-                    "key": {
-                        "_id.user": 1_i32,
-                    },
-                    "name": "user_id"
-                }
-            ]
-        },
-        None,
-    )
+                "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"
+    db.run_command(doc! {
+        "createIndexes": "server_members",
+        "indexes": [
+            {
+                "key": {
+                    "_id.server": 1_i32,
+                    "_id.user": 1_i32,
                 },
-                {
-                    "key": {
-                        "_id.user": 1_i32,
-                    },
-                    "name": "user_id"
-                }
-            ]
-        },
-        None,
-    )
+                "name": "compound_id"
+            },
+            {
+                "key": {
+                    "_id.user": 1_i32,
+                },
+                "name": "user_id"
+            }
+        ]
+    })
     .await
     .expect("Failed to create server_members index.");
 
-    db.collection("migrations")
-        .insert_one(
-            doc! {
-                "_id": 0_i32,
-                "revision": LATEST_REVISION
+    db.run_command(doc! {
+        "createIndexes": "attachments",
+        "indexes": [
+            {
+                "key": {
+                    "hash": 1_i32
+                },
+                "name": "hash"
             },
-            None,
-        )
+            {
+                "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"
-                }
-            ]
-        },
-        None,
-    )
+    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.");
 

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

@@ -5,12 +5,14 @@ use crate::{
         bson::{doc, from_bson, from_document, to_document, Bson, DateTime, Document},
         options::FindOptions,
     },
-    Invite, MongoDb, DISCRIMINATOR_SEARCH_SPACE,
+    AbstractChannels, AbstractServers, Channel, Invite, MongoDb, User, DISCRIMINATOR_SEARCH_SPACE,
 };
-use bson::oid::ObjectId;
+use bson::{oid::ObjectId, to_bson};
 use futures::StreamExt;
+use iso8601_timestamp::Timestamp;
 use rand::seq::SliceRandom;
 use revolt_permissions::DEFAULT_WEBHOOK_PERMISSIONS;
+use revolt_result::{Error, ErrorType};
 use serde::{Deserialize, Serialize};
 use unicode_segmentation::UnicodeSegmentation;
 
@@ -20,12 +22,12 @@ struct MigrationInfo {
     revision: i32,
 }
 
-pub const LATEST_REVISION: i32 = 27;
+pub const LATEST_REVISION: i32 = 41; // MUST BE +1 to last migration
 
 pub async fn migrate_database(db: &MongoDb) {
     let migrations = db.col::<Document>("migrations");
     let data = migrations
-        .find_one(None, None)
+        .find_one(doc! {})
         .await
         .expect("Failed to fetch migration data.");
 
@@ -45,7 +47,6 @@ pub async fn migrate_database(db: &MongoDb) {
                         "revision": revision
                     }
                 },
-                None,
             )
             .await
             .expect("Failed to commit migration information.");
@@ -73,7 +74,6 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
             .update_many(
                 doc! { "attachment": { "$exists": 1_i32 } },
                 doc! { "$set": { "attachment.tag": "attachments", "attachment.size": 0_i32 } },
-                None,
             )
             .await
             .expect("Failed to update messages.");
@@ -82,7 +82,6 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
             .update_many(
                 doc! {},
                 doc! { "$set": { "tag": "attachments", "size": 0_i32 } },
-                None,
             )
             .await
             .expect("Failed to update attachments.");
@@ -92,7 +91,7 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
         info!("Running migration [revision 2 / 2021-05-08]: Add servers collection.");
 
         db.db()
-            .create_collection("servers", None)
+            .create_collection("servers")
             .await
             .expect("Failed to create servers collection.");
     }
@@ -102,12 +101,12 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
 
         let messages = db.col::<Document>("messages");
         let mut cursor = messages
-            .find(
-                doc! {
-                    "attachment": {
-                        "$exists": 1_i32
-                    }
-                },
+            .find(doc! {
+                "attachment": {
+                    "$exists": 1_i32
+                }
+            })
+            .with_options(
                 FindOptions::builder()
                     .projection(doc! {
                         "_id": 1_i32,
@@ -127,19 +126,18 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
                 .update_one(
                     doc! { "_id": id },
                     doc! { "$unset": { "attachment": 1_i32 }, "$set": { "attachments": attachments } },
-                    None,
                 )
                 .await
                 .unwrap();
         }
 
         db.db()
-            .create_collection("channel_unreads", None)
+            .create_collection("channel_unreads")
             .await
             .expect("Failed to create channel_unreads collection.");
 
         db.db()
-            .create_collection("user_settings", None)
+            .create_collection("user_settings")
             .await
             .expect("Failed to create user_settings collection.");
     }
@@ -148,17 +146,17 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
         info!("Running migration [revision 4 / 2021-06-01]: Add more server collections.");
 
         db.db()
-            .create_collection("server_members", None)
+            .create_collection("server_members")
             .await
             .expect("Failed to create server_members collection.");
 
         db.db()
-            .create_collection("server_bans", None)
+            .create_collection("server_bans")
             .await
             .expect("Failed to create server_bans collection.");
 
         db.db()
-            .create_collection("channel_invites", None)
+            .create_collection("channel_invites")
             .await
             .expect("Failed to create channel_invites collection.");
     }
@@ -181,7 +179,6 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
                 doc! {
                     "$set": to_document(&server).unwrap()
                 },
-                None,
             )
             .await
             .expect("Failed to migrate servers.");
@@ -191,20 +188,17 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
         info!("Running migration [revision 6 / 2021-07-09]: Add message text index.");
 
         db.db()
-            .run_command(
-                doc! {
-                    "createIndexes": "messages",
-                    "indexes": [
-                        {
-                            "key": {
-                                "content": "text"
-                            },
-                            "name": "content"
-                        }
-                    ]
-                },
-                None,
-            )
+            .run_command(doc! {
+                "createIndexes": "messages",
+                "indexes": [
+                    {
+                        "key": {
+                            "content": "text"
+                        },
+                        "name": "content"
+                    }
+                ]
+            })
             .await
             .expect("Failed to create message index.");
     }
@@ -213,7 +207,7 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
         info!("Running migration [revision 7 / 2021-08-11]: Add message text index.");
 
         db.db()
-            .create_collection("bots", None)
+            .create_collection("bots")
             .await
             .expect("Failed to create bots collection.");
     }
@@ -222,22 +216,15 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
         info!("Running migration [revision 8 / 2021-09-10]: Update to Authifier version 1.");
 
         db.db()
-            .run_command(
-                doc! {
-                    "dropIndexes": "accounts",
-                    "index": ["email", "email_normalised"]
-                },
-                None,
-            )
+            .run_command(doc! {
+                "dropIndexes": "accounts",
+                "index": ["email", "email_normalised"]
+            })
             .await
             .expect("Failed to delete legacy account indexes.");
 
         let col = db.col::<Document>("sessions");
-        let mut cursor = db
-            .col::<Document>("accounts")
-            .find(doc! {}, None)
-            .await
-            .unwrap();
+        let mut cursor = db.col::<Document>("accounts").find(doc! {}).await.unwrap();
 
         while let Some(doc) = cursor.next().await {
             if let Ok(account) = doc {
@@ -266,7 +253,7 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
                             doc.insert("subscription", sub);
                         }
 
-                        col.insert_one(doc, None).await.ok();
+                        col.insert_one(doc).await.ok();
                     }
                 } else {
                     info!("Account doesn't have any sessions!");
@@ -287,7 +274,6 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
                         }
                     }
                 },
-                None,
             )
             .await
             .unwrap();
@@ -296,11 +282,7 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
     if revision <= 9 {
         info!("Running migration [revision 9 / 2021-09-14]: Switch from last_message to last_message_id.");
 
-        let mut cursor = db
-            .col::<Document>("channels")
-            .find(doc! {}, None)
-            .await
-            .unwrap();
+        let mut cursor = db.col::<Document>("channels").find(doc! {}).await.unwrap();
 
         while let Some(doc) = cursor.next().await {
             if let Ok(channel) = doc {
@@ -339,7 +321,6 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
                                     "last_message": 1_i32,
                                 }
                             },
-                            None,
                         )
                         .await
                         .unwrap();
@@ -361,7 +342,6 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
                         "nonce": 1_i32,
                     }
                 },
-                None,
             )
             .await
             .unwrap();
@@ -374,7 +354,6 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
                         "nonce": 1_i32,
                     }
                 },
-                None,
             )
             .await
             .unwrap();
@@ -384,70 +363,61 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
         info!("Running migration [revision 11 / 2021-11-14]: Add indexes to database.");
 
         db.db()
-            .run_command(
-                doc! {
-                    "createIndexes": "messages",
-                    "indexes": [
-                        {
-                            "key": {
-                                "channel": 1_i32
-                            },
-                            "name": "channel"
-                        }
-                    ]
-                },
-                None,
-            )
+            .run_command(doc! {
+                "createIndexes": "messages",
+                "indexes": [
+                    {
+                        "key": {
+                            "channel": 1_i32
+                        },
+                        "name": "channel"
+                    }
+                ]
+            })
             .await
             .expect("Failed to create message index.");
 
         db.db()
-            .run_command(
-                doc! {
-                    "createIndexes": "channel_unreads",
-                    "indexes": [
-                        {
-                            "key": {
-                                "_id.channel": 1_i32,
-                                "_id.user": 1_i32,
-                            },
-                            "name": "compound_id"
+            .run_command(doc! {
+                "createIndexes": "channel_unreads",
+                "indexes": [
+                    {
+                        "key": {
+                            "_id.channel": 1_i32,
+                            "_id.user": 1_i32,
                         },
-                        {
-                            "key": {
-                                "_id.user": 1_i32,
-                            },
-                            "name": "user_id"
-                        }
-                    ]
-                },
-                None,
-            )
+                        "name": "compound_id"
+                    },
+                    {
+                        "key": {
+                            "_id.user": 1_i32,
+                        },
+                        "name": "user_id"
+                    }
+                ]
+            })
             .await
             .expect("Failed to create channel_unreads index.");
 
         db.db()
-            .run_command(
-                doc! {
-                    "createIndexes": "server_members",
-                    "indexes": [
-                        {
-                            "key": {
-                                "_id.server": 1_i32,
-                                "_id.user": 1_i32,
-                            },
-                            "name": "compound_id"
+            .run_command(doc! {
+                "createIndexes": "server_members",
+                "indexes": [
+                    {
+                        "key": {
+                            "_id.server": 1_i32,
+                            "_id.user": 1_i32,
                         },
-                        {
-                            "key": {
-                                "_id.user": 1_i32,
-                            },
-                            "name": "user_id"
-                        }
-                    ]
-                },
-                None,
-            )
+                        "name": "compound_id"
+                    },
+                    {
+                        "key": {
+                            "_id.user": 1_i32,
+                        },
+                        "name": "user_id"
+                    }
+                ]
+            })
             .await
             .expect("Failed to create server_members index.");
     }
@@ -456,21 +426,18 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
         info!("Running migration [revision 12 / 2021-11-21]: Add indexes to database.");
 
         db.db()
-            .run_command(
-                doc! {
-                    "createIndexes": "messages",
-                    "indexes": [
-                        {
-                            "key": {
-                                "channel": 1_i32,
-                                "_id": 1_i32
-                            },
-                            "name": "channel_id_compound"
-                        }
-                    ]
-                },
-                None,
-            )
+            .run_command(doc! {
+                "createIndexes": "messages",
+                "indexes": [
+                    {
+                        "key": {
+                            "channel": 1_i32,
+                            "_id": 1_i32
+                        },
+                        "name": "channel_id_compound"
+                    }
+                ]
+            })
             .await
             .expect("Failed to create message index.");
     }
@@ -484,7 +451,7 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
         async_std::task::sleep(Duration::from_secs(10)).await;
 
         let servers = db.col::<Document>("servers");
-        let mut cursor = servers.find(doc! {}, None).await.unwrap();
+        let mut cursor = servers.find(doc! {}).await.unwrap();
 
         while let Some(Ok(mut document)) = cursor.next().await {
             let id = document.get_str("_id").unwrap().to_string();
@@ -528,13 +495,13 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
             }
 
             servers
-                .update_one(doc! { "_id": id }, doc! { "$set": update }, None)
+                .update_one(doc! { "_id": id }, doc! { "$set": update })
                 .await
                 .unwrap();
         }
 
         let channels = db.col::<Document>("channels");
-        let mut cursor = channels.find(doc! {}, None).await.unwrap();
+        let mut cursor = channels.find(doc! {}).await.unwrap();
 
         while let Some(Ok(document)) = cursor.next().await {
             let id = document.get_str("_id").unwrap().to_string();
@@ -574,7 +541,7 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
             }
 
             channels
-                .update_one(doc! { "_id": id }, update, None)
+                .update_one(doc! { "_id": id }, update)
                 .await
                 .unwrap();
         }
@@ -595,7 +562,6 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
                         "content": "system"
                     }
                 },
-                None,
             )
             .await
             .unwrap();
@@ -620,25 +586,22 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
             .unwrap();
 
         db.db()
-            .create_collection("emojis", None)
+            .create_collection("emojis")
             .await
             .expect("Failed to create emojis collection.");
 
         db.db()
-            .run_command(
-                doc! {
-                    "createIndexes": "emojis",
-                    "indexes": [
-                        {
-                            "key": {
-                                "parent.id": 1_i32,
-                            },
-                            "name": "parent_id"
-                        }
-                    ]
-                },
-                None,
-            )
+            .run_command(doc! {
+                "createIndexes": "emojis",
+                "indexes": [
+                    {
+                        "key": {
+                            "parent.id": 1_i32,
+                        },
+                        "name": "parent_id"
+                    }
+                ]
+            })
             .await
             .expect("Failed to create emoji parent index.");
     }
@@ -651,10 +614,9 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
                 doc! {},
                 doc! {
                     "$set": {
-                        "joined_at": DateTime::now().to_rfc3339_string()
+                        "joined_at": DateTime::now().try_to_rfc3339_string().expect("Failed to convert the date to rfc3339")
                     }
                 },
-                None,
             )
             .await
             .expect("Failed to update server members.");
@@ -665,13 +627,10 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
 
         if db
             .db()
-            .run_command(
-                doc! {
-                    "dropIndexes": "messages",
-                    "index": ["channel"]
-                },
-                None,
-            )
+            .run_command(doc! {
+                "dropIndexes": "messages",
+                "index": ["channel"]
+            })
             .await
             .is_err()
         {
@@ -679,20 +638,17 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
         }
 
         db.db()
-            .run_command(
-                doc! {
-                    "createIndexes": "messages",
-                    "indexes": [
-                        {
-                            "key": {
-                                "author": 1_i32,
-                            },
-                            "name": "author"
-                        }
-                    ]
-                },
-                None,
-            )
+            .run_command(doc! {
+                "createIndexes": "messages",
+                "indexes": [
+                    {
+                        "key": {
+                            "author": 1_i32,
+                        },
+                        "name": "author"
+                    }
+                ]
+            })
             .await
             .expect("Failed to create messages author index.");
     }
@@ -702,35 +658,26 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
             "Running migration [revision 19 / 27-02-2023]: Create report / snapshot collections."
         );
 
-        db.db()
-            .create_collection("safety_reports", None)
-            .await
-            .unwrap();
+        db.db().create_collection("safety_reports").await.unwrap();
 
-        db.db()
-            .create_collection("safety_snapshots", None)
-            .await
-            .unwrap();
+        db.db().create_collection("safety_snapshots").await.unwrap();
     }
 
     if revision <= 20 {
         info!("Running migration [revision 20 / 28-02-2023]: Add index `snapshot.report_id`.");
 
         db.db()
-            .run_command(
-                doc! {
-                    "createIndexes": "safety_snapshots",
-                    "indexes": [
-                        {
-                            "key": {
-                                "report_id": 1_i32
-                            },
-                            "name": "report_id"
-                        }
-                    ]
-                },
-                None,
-            )
+            .run_command(doc! {
+                "createIndexes": "safety_snapshots",
+                "indexes": [
+                    {
+                        "key": {
+                            "report_id": 1_i32
+                        },
+                        "name": "report_id"
+                    }
+                ]
+            })
             .await
             .expect("Failed to create safety snapshot index.");
     }
@@ -738,10 +685,7 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
     if revision <= 21 {
         info!("Running migration [revision 21 / 31-05-2023]: Add collection `safety_strikes`.");
 
-        db.db()
-            .create_collection("safety_strikes", None)
-            .await
-            .unwrap();
+        db.db().create_collection("safety_strikes").await.unwrap();
     }
 
     if revision <= 22 {
@@ -755,7 +699,6 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
                         "moderator_id": "01EX2NCWQ0CHS3QJF0FEQS1GR4"
                     }
                 },
-                None,
             )
             .await
             .expect("Failed to update server members.");
@@ -765,13 +708,10 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
         info!("Running migration [revision 23 / 10-06-2023]: Generate discriminators for users.");
 
         db.db()
-            .run_command(
-                doc! {
-                    "dropIndexes": "users",
-                    "index": "username"
-                },
-                None,
-            )
+            .run_command(doc! {
+                "dropIndexes": "users",
+                "index": "username"
+            })
             .await
             .expect("Failed to drop existing username index.");
 
@@ -786,7 +726,7 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
 
         let users: Vec<UserInformation> = db
             .col::<UserInformation>("users")
-            .find(doc! {}, None)
+            .find(doc! {})
             .await
             .unwrap()
             .map(|doc| doc.expect("id and username"))
@@ -838,7 +778,6 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
                                 "discriminator": discriminator
                             }
                         },
-                        None,
                     )
                     .await
                     .unwrap();
@@ -886,7 +825,6 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
                                 "display_name": &info.username
                             }
                         },
-                        None,
                     )
                     .await
                     .unwrap();
@@ -897,43 +835,37 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
     if revision <= 24 {
         info!("Running migration [revision 24 / 09-06-2023]: Add collection `channel_webhooks` if not exists, update users index.");
 
-        db.db()
-            .create_collection("channel_webhooks", None)
-            .await
-            .ok();
+        db.db().create_collection("channel_webhooks").await.ok();
 
         db.db()
-            .run_command(
-                doc! {
-                    "createIndexes": "users",
-                    "indexes": [
-                        {
-                            "key": {
-                                "username": 1_i32
-                            },
-                            "name": "username",
-                            "unique": false,
-                            "collation": {
-                                "locale": "en",
-                                "strength": 2_i32
-                            }
+            .run_command(doc! {
+                "createIndexes": "users",
+                "indexes": [
+                    {
+                        "key": {
+                            "username": 1_i32
                         },
-                        {
-                            "key": {
-                                "username": 1_i32,
-                                "discriminator": 1_i32
-                            },
-                            "name": "username_discriminator",
-                            "unique": true,
-                            "collation": {
-                                "locale": "en",
-                                "strength": 2_i32
-                            }
+                        "name": "username",
+                        "unique": false,
+                        "collation": {
+                            "locale": "en",
+                            "strength": 2_i32
                         }
-                    ]
-                },
-                None,
-            )
+                    },
+                    {
+                        "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.");
     };
@@ -949,7 +881,6 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
                         "permissions": *DEFAULT_WEBHOOK_PERMISSIONS as i64
                     }
                 },
-                None,
             )
             .await
             .expect("Failed to update webhooks.");
@@ -958,28 +889,22 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
     if revision <= 25 {
         info!("Running migration [revision 25 / 15-06-2023]: Add collection `ratelimit_events` with index.");
 
-        db.db()
-            .create_collection("ratelimit_events", None)
-            .await
-            .ok();
+        db.db().create_collection("ratelimit_events").await.ok();
 
         db.db()
-            .run_command(
-                doc! {
-                    "createIndexes": "ratelimit_events",
-                    "indexes": [
-                        {
-                            "key": {
-                                "_id": 1_i32,
-                                "target_id": 1_i32,
-                                "event_type": 1_i32,
-                            },
-                            "name": "compound_key"
-                        }
-                    ]
-                },
-                None,
-            )
+            .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.");
     }
@@ -1015,12 +940,9 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
         let invites = db
             .db()
             .collection::<Outer>("channel_invites")
-            .find(
-                doc! {
-                    "type": { "$exists": false }
-                },
-                None,
-            )
+            .find(doc! {
+                "type": { "$exists": false }
+            })
             .await
             .expect("failed to find invites")
             .filter_map(|s| async { s.ok() })
@@ -1051,25 +973,197 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
             })
             .collect::<Vec<Invite>>();
 
-        db.db()
-            .collection("channel_invites")
-            .insert_many(invites, None)
-            .await
-            .expect("failed to insert corrected invite");
+        if !invites.is_empty() {
+            db.db()
+                .collection("channel_invites")
+                .insert_many(invites)
+                .await
+                .expect("failed to insert corrected invite");
 
-        db.db()
-            .collection::<Outer>("channel_invites")
-            .delete_many(
-                doc! {
+            db.db()
+                .collection::<Outer>("channel_invites")
+                .delete_many(doc! {
                     "type": { "$exists": false }
-                },
-                None,
-            )
-            .await
-            .expect("failed to find invites");
+                })
+                .await
+                .expect("failed to find invites");
+        }
     }
 
-    // Need to migrate fields on attachments, change `user_id`, `object_id`, etc to `parent`.
+    if revision <= 27 {
+        info!("Running migration [revision 27 / 21-07-2024]: create message pinned index.");
+
+        db.db()
+            .run_command(doc! {
+                "createIndexes": "messages",
+                "indexes": [
+                    {
+                        "key": {
+                            "channel": 1_i32,
+                            "pinned": 1_i32
+                        },
+                        "name": "channel_pinned_compound"
+                    }
+                ]
+            })
+            .await
+            .expect("Failed to create message index.");
+    }
+
+    if revision <= 28 {
+        info!("Running migration [revision 28 / 10-09-2024]: Add support for new Autumn.");
+
+        db.db().create_collection("attachment_hashes").await.ok();
+
+        db.db()
+            .run_command(doc! {
+                "createIndexes": "attachments",
+                "indexes": [
+                    {
+                        "key": {
+                            "hash": 1_i32
+                        },
+                        "name": "hash"
+                    }
+                ]
+            })
+            .await
+            .expect("Failed to create attachments index.");
+
+        db.db()
+            .run_command(doc! {
+                "createIndexes": "attachment_hashes",
+                "indexes": [
+                    {
+                        "key": {
+                            "processed_hash": 1_i32
+                        },
+                        "name": "processed_hash"
+                    }
+                ]
+            })
+            .await
+            .expect("Failed to create attachment_hashes index.");
+    }
+
+    // Revision 29 omitted due to bug.
+
+    if revision <= 30 {
+        info!("Running migration [revision 30 / 29-09-2024]: Add index for used_for.id to attachments.");
+
+        db.db()
+            .run_command(doc! {
+                "createIndexes": "attachments",
+                "indexes": [
+                    {
+                        "key": {
+                            "used_for.id": 1_i32
+                        },
+                        "name": "used_for_id"
+                    }
+                ]
+            })
+            .await
+            .expect("Failed to create attachments index.");
+    }
+
+    if revision <= 31 {
+        info!("Running migration [revision 31 / 31-10-2024]: Add creator_id to webhooks and delete those whose channels don't exist.");
+
+        #[derive(serde::Serialize, serde::Deserialize)]
+        struct WebhookShell {
+            _id: String,
+            channel_id: String,
+        }
+
+        let webhooks = db
+            .db()
+            .collection::<WebhookShell>("channel_webhooks")
+            .find(doc! {})
+            .await
+            .expect("webhooks")
+            .filter_map(|s| async { s.ok() })
+            .collect::<Vec<WebhookShell>>()
+            .await;
+
+        for webhook in webhooks {
+            match db.fetch_channel(&webhook.channel_id).await {
+                Ok(channel) => {
+                    let creator_id = match channel {
+                        Channel::Group { owner, .. } => owner,
+                        Channel::TextChannel { server, .. }
+                        | Channel::VoiceChannel { server, .. } => {
+                            let server = db.fetch_server(&server).await.expect("server");
+                            server.owner
+                        }
+                        _ => unreachable!("not server or group channel!"),
+                    };
+
+                    db.db()
+                        .collection::<Document>("channel_webhooks")
+                        .update_one(
+                            doc! {
+                                "_id": webhook._id,
+                            },
+                            doc! {
+                                "$set" : {
+                                    "creator_id": creator_id
+                                }
+                            },
+                        )
+                        .await
+                        .expect("update webhook");
+                }
+                Err(Error {
+                    error_type: ErrorType::NotFound,
+                    ..
+                }) => {
+                    db.db()
+                        .collection::<WebhookShell>("channel_webhooks")
+                        .delete_one(doc! { "_id": webhook._id })
+                        .await
+                        .expect("failed to delete invalid webhook");
+                }
+                Err(err) => panic!("{err:?}"),
+            }
+        }
+    }
+
+    if revision <= 32 {
+        info!(
+            "Running migration [revision 32 / 12-05-2025]: (Authifier) Add last_seen to sessions."
+        );
+
+        let db = authifier::Database::MongoDb(authifier::database::MongoDb(db.db()));
+        db.run_migration(authifier::Migration::M2025_02_20AddLastSeenToSession)
+            .await
+            .unwrap();
+    }
+
+    if revision <= 40 {
+        info!(
+            "Running migration [revision |> 40 / 30-05-2025]: Set last policy acknowlegement date to now and create policy changes collection."
+        );
+
+        db.db()
+            .create_collection("policy_changes")
+            .await
+            .expect("Failed to create policy_changes collection.");
+
+        db.db()
+            .collection::<User>("users")
+            .update_many(
+                doc! {},
+                doc! {
+                    "$set": {
+                        "last_acknowledged_policy_change": to_bson(&Timestamp::now_utc())
+                            .expect("failed to serialise timestamp")
+                    }
+                },
+            )
+            .await
+            .expect("failed to update users");
+    }
 
     // Reminder to update LATEST_REVISION when adding new migrations.
     LATEST_REVISION.max(revision)

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

@@ -1,8 +1,7 @@
-use revolt_config::config;
 use revolt_result::Result;
 use ulid::Ulid;
 
-use crate::{BotInformation, Database, PartialUser, User};
+use crate::{events::client::EventV1, BotInformation, Database, PartialUser, User};
 
 auto_derived_partial!(
     /// Bot
@@ -72,7 +71,12 @@ impl Default for Bot {
 #[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>
+    pub async fn create<D>(
+        db: &Database,
+        username: String,
+        owner: &User,
+        data: D,
+    ) -> Result<(Bot, User)>
     where
         D: Into<Option<PartialBot>>,
     {
@@ -80,14 +84,13 @@ impl Bot {
             return Err(create_error!(IsBot));
         }
 
-        let config = config().await;
-        if db.get_number_of_bots_by_user(&owner.id).await? >= config.features.limits.default.bots {
+        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();
 
-        User::create(
+        let user = User::create(
             db,
             username,
             Some(id.to_string()),
@@ -112,7 +115,7 @@ impl Bot {
         }
 
         db.insert_bot(&bot).await?;
-        Ok(bot)
+        Ok((bot, user))
     }
 
     /// Remove a field from this object
@@ -142,6 +145,10 @@ impl Bot {
 
         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(())
     }
@@ -164,7 +171,7 @@ mod tests {
                 .await
                 .unwrap();
 
-            let bot = Bot::create(
+            let (bot, _) = Bot::create(
                 &db,
                 "Bot Name".to_string(),
                 &owner,

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

@@ -24,12 +24,9 @@ impl AbstractChannelInvites for MongoDb {
     async fn fetch_invites_for_server(&self, server_id: &str) -> Result<Vec<Invite>> {
         Ok(self
             .col::<Invite>(COL)
-            .find(
-                doc! {
-                    "server": server_id,
-                },
-                None,
-            )
+            .find(doc! {
+                "server": server_id,
+            })
             .await
             .map_err(|_| create_database_error!("find", COL))?
             .filter_map(|s| async {

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

@@ -7,13 +7,13 @@ mod reference;
 
 #[async_trait]
 pub trait AbstractChannelUnreads: Sync + Send {
-    /// Acknowledge a message.
+    /// Acknowledge a message, and returns updated channel unread.
     async fn acknowledge_message(
         &self,
         channel_id: &str,
         user_id: &str,
         message_id: &str,
-    ) -> Result<()>;
+    ) -> Result<Option<ChannelUnread>>;
 
     /// Acknowledge many channels.
     async fn acknowledge_channels(&self, user_id: &str, channel_ids: &[String]) -> Result<()>;
@@ -26,6 +26,20 @@ pub trait AbstractChannelUnreads: Sync + Send {
         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

@@ -1,4 +1,6 @@
 use bson::Document;
+use mongodb::options::FindOneAndUpdateOptions;
+use mongodb::options::ReturnDocument;
 use mongodb::options::UpdateOptions;
 use revolt_result::Result;
 use ulid::Ulid;
@@ -12,31 +14,37 @@ static COL: &str = "channel_unreads";
 
 #[async_trait]
 impl AbstractChannelUnreads for MongoDb {
-    /// Acknowledge a message.
+    /// Acknowledge a message, and returns updated channel unread.
     async fn acknowledge_message(
         &self,
         channel_id: &str,
         user_id: &str,
         message_id: &str,
-    ) -> Result<()> {
-        self.col::<Document>(COL)
-            .update_one(
+    ) -> Result<Option<ChannelUnread>> {
+        self.col::<ChannelUnread>(COL)
+            .find_one_and_update(
                 doc! {
                     "_id.channel": channel_id,
                     "_id.user": user_id,
                 },
                 doc! {
-                    "$unset": {
-                        "mentions": 1_i32
+                    "$pull": {
+                        "mentions": {
+                            "$lte": message_id
+                        }
                     },
                     "$set": {
                         "last_id": message_id
                     }
                 },
-                UpdateOptions::builder().upsert(true).build(),
+            )
+            .with_options(
+                FindOneAndUpdateOptions::builder()
+                    .upsert(true)
+                    .return_document(ReturnDocument::After)
+                    .build(),
             )
             .await
-            .map(|_| ())
             .map_err(|_| create_database_error!("update_one", COL))
     }
 
@@ -45,15 +53,12 @@ impl AbstractChannelUnreads for MongoDb {
         let current_time = Ulid::new().to_string();
 
         self.col::<Document>(COL)
-            .delete_many(
-                doc! {
-                    "_id.channel": {
-                        "$in": channel_ids
-                    },
-                    "_id.user": user_id
+            .delete_many(doc! {
+                "_id.channel": {
+                    "$in": channel_ids
                 },
-                None,
-            )
+                "_id.user": user_id
+            })
             .await
             .map_err(|_| create_database_error!("delete_many", COL))?;
 
@@ -71,7 +76,6 @@ impl AbstractChannelUnreads for MongoDb {
                         }
                     })
                     .collect::<Vec<Document>>(),
-                None,
             )
             .await
             .map(|_| ())
@@ -98,13 +102,42 @@ impl AbstractChannelUnreads for MongoDb {
                         }
                     }
                 },
-                UpdateOptions::builder().upsert(true).build(),
             )
+            .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!(
@@ -116,4 +149,29 @@ impl AbstractChannelUnreads for MongoDb {
             }
         )
     }
+
+    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

@@ -13,7 +13,7 @@ impl AbstractChannelUnreads for ReferenceDb {
         channel_id: &str,
         user_id: &str,
         message_id: &str,
-    ) -> Result<()> {
+    ) -> Result<Option<ChannelUnread>> {
         let mut unreads = self.channel_unreads.lock().await;
         let key = ChannelCompositeKey {
             channel: channel_id.to_string(),
@@ -27,14 +27,14 @@ impl AbstractChannelUnreads for ReferenceDb {
             unreads.insert(
                 key.clone(),
                 ChannelUnread {
-                    id: key,
+                    id: key.clone(),
                     last_id: Some(message_id.to_string()),
                     mentions: None,
                 },
             );
         }
 
-        Ok(())
+        Ok(unreads.get(&key).cloned())
     }
 
     /// Acknowledge many channels.
@@ -78,6 +78,47 @@ impl AbstractChannelUnreads for ReferenceDb {
         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;
@@ -87,4 +128,16 @@ impl AbstractChannelUnreads for ReferenceDb {
             .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/model.rs

@@ -17,6 +17,9 @@ auto_derived_partial!(
         #[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,
 
@@ -43,6 +46,7 @@ impl Default for Webhook {
             id: Default::default(),
             name: Default::default(),
             avatar: None,
+            creator_id: Default::default(),
             channel_id: Default::default(),
             permissions: Default::default(),
             token: Default::default(),
@@ -70,7 +74,7 @@ impl Webhook {
         if self.token.as_deref() == Some(token) {
             Ok(())
         } else {
-            Err(create_error!(InvalidCredentials))
+            Err(create_error!(NotAuthenticated))
         }
     }
 
@@ -138,7 +142,7 @@ mod tests {
                 ..Default::default()
             };
 
-            db.insert_webhook(&webhook).await.unwrap();
+            webhook.create(&db).await.unwrap();
 
             let mut updated_webhook = webhook.clone();
             updated_webhook

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

@@ -24,12 +24,9 @@ impl AbstractWebhooks for MongoDb {
     async fn fetch_webhooks_for_channel(&self, channel_id: &str) -> Result<Vec<Webhook>> {
         Ok(self
             .col::<Webhook>(COL)
-            .find(
-                doc! {
-                    "channel_id": channel_id,
-                },
-                None,
-            )
+            .find(doc! {
+                "channel_id": channel_id,
+            })
             .await
             .map_err(|_| create_database_error!("find", COL))?
             .filter_map(|s| async {

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

@@ -9,7 +9,7 @@ use ulid::Ulid;
 
 use crate::{
     events::client::EventV1, tasks::ack::AckEvent, Database, File, IntoDocumentPath, PartialServer,
-    Server, SystemMessage, User,
+    Server, SystemMessage, User, AMQP,
 };
 
 auto_derived!(
@@ -201,9 +201,9 @@ impl Channel {
         update_server: bool,
     ) -> Result<Channel> {
         let config = config().await;
-        if server.channels.len() > config.features.limits.default.server_channels {
+        if server.channels.len() > config.features.limits.global.server_channels {
             return Err(create_error!(TooManyChannels {
-                max: config.features.limits.default.server_channels,
+                max: config.features.limits.global.server_channels,
             }));
         };
 
@@ -263,22 +263,30 @@ impl Channel {
         data.users.insert(owner_id.to_string());
 
         let config = config().await;
-        if data.users.len() > config.features.limits.default.group_size {
+        if data.users.len() > config.features.limits.global.group_size {
             return Err(create_error!(GroupTooLarge {
-                max: config.features.limits.default.group_size,
+                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: ulid::Ulid::new().to_string(),
+            id,
 
             name: data.name,
             owner: owner_id,
             description: data.description,
             recipients: recipients.clone(),
 
-            icon: None,
+            icon,
             last_message_id: None,
 
             permissions: None,
@@ -320,13 +328,10 @@ impl Channel {
 
             db.insert_channel(&channel).await?;
 
-            match &channel {
-                Channel::DirectMessage { .. } => {
-                    let event = EventV1::ChannelCreate(channel.clone().into());
-                    event.clone().private(user_a.id.clone()).await;
-                    event.private(user_b.id.clone()).await;
-                }
-                _ => {}
+            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)
@@ -337,6 +342,7 @@ impl Channel {
     pub async fn add_user_to_group(
         &mut self,
         db: &Database,
+        amqp: &AMQP,
         user: &User,
         by_id: &str,
     ) -> Result<()> {
@@ -346,9 +352,9 @@ impl Channel {
             }
 
             let config = config().await;
-            if recipients.len() >= config.features.limits.default.group_size {
+            if recipients.len() >= config.features.limits.global.group_size {
                 return Err(create_error!(GroupTooLarge {
-                    max: config.features.limits.default.group_size
+                    max: config.features.limits.global.group_size
                 }));
             }
 
@@ -373,10 +379,13 @@ impl Channel {
                 .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,
                 )
@@ -415,13 +424,13 @@ impl Channel {
     }
 
     /// Clone this channel's id
-    pub fn id(&self) -> String {
+    pub fn id(&self) -> &str {
         match self {
             Channel::DirectMessage { id, .. }
             | Channel::Group { id, .. }
             | Channel::SavedMessages { id, .. }
             | Channel::TextChannel { id, .. }
-            | Channel::VoiceChannel { id, .. } => id.clone(),
+            | Channel::VoiceChannel { id, .. } => id,
         }
     }
 
@@ -637,7 +646,7 @@ impl Channel {
         .private(user.to_string())
         .await;
 
-        crate::tasks::ack::queue(
+        crate::tasks::ack::queue_ack(
             self.id().to_string(),
             user.to_string(),
             AckEvent::AckMessage {
@@ -653,6 +662,7 @@ impl Channel {
     pub async fn remove_user_from_group(
         &self,
         db: &Database,
+        amqp: &AMQP,
         user: &User,
         by_id: Option<&str>,
         silent: bool,
@@ -684,10 +694,13 @@ impl Channel {
                         .into_message(id.to_string())
                         .send(
                             db,
+                            Some(amqp),
                             MessageAuthor::System {
                                 username: name,
                                 avatar: None,
                             },
+                            None,
+                            None,
                             self,
                             false,
                         )
@@ -698,6 +711,8 @@ impl Channel {
                     }
                 }
 
+                db.remove_user_from_group(id, &user.id).await?;
+
                 EventV1::ChannelGroupLeave {
                     id: id.to_string(),
                     user: user.id.to_string(),
@@ -719,10 +734,13 @@ impl Channel {
                     .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,
                     )

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

@@ -23,14 +23,11 @@ impl AbstractChannels for MongoDb {
     async fn fetch_channels<'a>(&self, ids: &'a [String]) -> Result<Vec<Channel>> {
         Ok(self
             .col::<Channel>(COL)
-            .find(
-                doc! {
-                    "_id": {
-                        "$in": ids
-                    }
-                },
-                None,
-            )
+            .find(doc! {
+                "_id": {
+                    "$in": ids
+                }
+            })
             .await
             .map_err(|_| create_database_error!("fetch", "channels"))?
             .filter_map(|s| async {
@@ -119,7 +116,6 @@ impl AbstractChannels for MongoDb {
                         "recipients": user
                     }
                 },
-                None,
             )
             .await
             .map(|_| ())
@@ -141,7 +137,6 @@ impl AbstractChannels for MongoDb {
                     "role_permissions.".to_owned() + role: permissions
                 }
                 },
-                None,
             )
             .await
             .map(|_| ())
@@ -179,7 +174,6 @@ impl AbstractChannels for MongoDb {
                         "recipients": user
                     }
                 },
-                None,
             )
             .await
             .map(|_| ())
@@ -253,7 +247,6 @@ impl AbstractChannels for MongoDb {
                         "_id": server.id
                     },
                     update,
-                    None,
                 )
                 .await
                 .map_err(|_| create_database_error!("update_one", "servers"))?;
@@ -261,12 +254,12 @@ impl AbstractChannels for MongoDb {
 
         // Delete associated attachments
         self.delete_many_attachments(doc! {
-            "object_id": &id
+            "used_for.id": &id
         })
         .await?;
 
         // Delete the channel itself
-        query!(self, delete_one_by_id, COL, &channel.id()).map(|_| ())
+        query!(self, delete_one_by_id, COL, channel.id()).map(|_| ())
     }
 }
 
@@ -274,23 +267,17 @@ impl MongoDb {
     pub async fn delete_associated_channel_objects(&self, id: Bson) -> Result<()> {
         // Delete all invites to these channels.
         self.col::<Document>("channel_invites")
-            .delete_many(
-                doc! {
-                    "channel": &id
-                },
-                None,
-            )
+            .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
-                },
-                None,
-            )
+            .delete_many(doc! {
+                "_id.channel": &id
+            })
             .await
             .map_err(|_| create_database_error!("delete_many", "channel_unreads"))
             .map(|_| ())?;
@@ -299,12 +286,9 @@ impl MongoDb {
 
         // Delete all webhooks on this channel.
         self.col::<Document>("webhooks")
-            .delete_many(
-                doc! {
-                    "channel": &id
-                },
-                None,
-            )
+            .delete_many(doc! {
+                "channel": &id
+            })
             .await
             .map_err(|_| create_database_error!("delete_many", "webhooks"))
             .map(|_| ())

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

@@ -11,7 +11,7 @@ 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()) {
+        if let Entry::Vacant(entry) = channels.entry(channel.id().to_string()) {
             entry.insert(channel.clone());
             Ok(())
         } else {
@@ -148,7 +148,7 @@ impl AbstractChannels for ReferenceDb {
     // 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() {
+        if channels.remove(channel.id()).is_some() {
             Ok(())
         } else {
             Err(create_error!(NotFound))

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

@@ -60,7 +60,6 @@ impl AbstractEmojis for MongoDb {
                         }
                     }
                 },
-                None,
             )
             .await
             .map(|_| ())

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

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

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

@@ -0,0 +1,92 @@
+use iso8601_timestamp::Timestamp;
+
+use crate::File;
+
+auto_derived_partial!(
+    /// File hash
+    pub struct FileHash {
+        /// Sha256 hash of the file
+        #[serde(rename = "_id")]
+        pub id: String,
+        /// Sha256 hash of file after it has been processed
+        pub processed_hash: String,
+
+        /// When this file was created in system
+        pub created_at: Timestamp,
+
+        /// The bucket this file is stored in
+        pub bucket_id: String,
+        /// The path at which this file exists in
+        pub path: String,
+        /// Cryptographic nonce used to encrypt this file
+        pub iv: String,
+
+        /// Parsed metadata of this file
+        pub metadata: Metadata,
+        /// Raw content type of this file
+        pub content_type: String,
+        /// Size of this file (in bytes)
+        pub size: isize,
+    },
+    "PartialFileHash"
+);
+
+auto_derived!(
+    /// Metadata associated with a file
+    #[serde(tag = "type")]
+    #[derive(Default)]
+    pub enum Metadata {
+        /// File is just a generic uncategorised file
+        #[default]
+        File,
+        /// File contains textual data and should be displayed as such
+        Text,
+        /// File is an image with specific dimensions
+        Image {
+            width: isize,
+            height: isize,
+            // animated: bool // TODO: https://docs.rs/image/latest/image/trait.AnimationDecoder.html for APNG support
+        },
+        /// File is a video with specific dimensions
+        Video { width: isize, height: isize },
+        /// File is audio
+        Audio,
+    }
+);
+
+impl FileHash {
+    /// Create a file from a file hash
+    pub fn into_file(
+        &self,
+        id: String,
+        tag: String,
+        filename: String,
+        uploader_id: String,
+    ) -> File {
+        File {
+            id,
+            tag,
+            filename,
+            hash: Some(self.id.clone()),
+
+            uploaded_at: Some(Timestamp::now_utc()),
+            uploader_id: Some(uploader_id),
+
+            used_for: None,
+
+            deleted: None,
+            reported: None,
+
+            // TODO: remove this data
+            metadata: self.metadata.clone(),
+            content_type: self.content_type.clone(),
+            size: self.size,
+
+            // TODO: superseded by "used_for"
+            message_id: None,
+            object_id: None,
+            server_id: None,
+            user_id: None,
+        }
+    }
+}

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

@@ -0,0 +1,21 @@
+use revolt_result::Result;
+
+use crate::FileHash;
+
+mod mongodb;
+mod reference;
+
+#[async_trait]
+pub trait AbstractAttachmentHashes: Sync + Send {
+    /// Insert a new attachment hash into the database.
+    async fn insert_attachment_hash(&self, hash: &FileHash) -> Result<()>;
+
+    /// Fetch an attachment hash entry by sha256 hash.
+    async fn fetch_attachment_hash(&self, hash: &str) -> Result<FileHash>;
+
+    /// Update an attachment hash nonce value.
+    async fn set_attachment_hash_nonce(&self, hash: &str, nonce: &str) -> Result<()>;
+
+    /// Delete attachment hash by id.
+    async fn delete_attachment_hash(&self, id: &str) -> Result<()>;
+}

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

@@ -0,0 +1,55 @@
+use revolt_result::Result;
+
+use crate::FileHash;
+use crate::MongoDb;
+
+use super::AbstractAttachmentHashes;
+
+static COL: &str = "attachment_hashes";
+
+#[async_trait]
+impl AbstractAttachmentHashes for MongoDb {
+    /// Insert a new attachment hash into the database.
+    async fn insert_attachment_hash(&self, hash: &FileHash) -> Result<()> {
+        query!(self, insert_one, COL, &hash).map(|_| ())
+    }
+
+    /// Fetch an attachment hash entry by sha256 hash.
+    async fn fetch_attachment_hash(&self, hash: &str) -> Result<FileHash> {
+        query!(
+            self,
+            find_one,
+            COL,
+            doc! {
+                "$or": [
+                    {"_id": hash},
+                    {"processed_hash": hash}
+                ]
+            }
+        )?
+        .ok_or_else(|| create_error!(NotFound))
+    }
+
+    /// Update an attachment hash nonce value.
+    async fn set_attachment_hash_nonce(&self, hash: &str, nonce: &str) -> Result<()> {
+        self.col::<FileHash>(COL)
+            .update_one(
+                doc! {
+                    "_id": hash
+                },
+                doc! {
+                    "$set": {
+                        "iv": nonce
+                    }
+                },
+            )
+            .await
+            .map(|_| ())
+            .map_err(|_| create_database_error!("update_one", COL))
+    }
+
+    /// Delete attachment hash by id.
+    async fn delete_attachment_hash(&self, id: &str) -> Result<()> {
+        query!(self, delete_one_by_id, COL, id).map(|_| ())
+    }
+}

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

@@ -0,0 +1,51 @@
+use revolt_result::Result;
+
+use crate::FileHash;
+use crate::ReferenceDb;
+
+use super::AbstractAttachmentHashes;
+
+#[async_trait]
+impl AbstractAttachmentHashes for ReferenceDb {
+    /// Insert a new attachment hash into the database.
+    async fn insert_attachment_hash(&self, hash: &FileHash) -> Result<()> {
+        let mut hashes = self.file_hashes.lock().await;
+        if hashes.contains_key(&hash.id) {
+            Err(create_database_error!("insert", "attachment"))
+        } else {
+            hashes.insert(hash.id.to_string(), hash.clone());
+            Ok(())
+        }
+    }
+
+    /// Fetch an attachment hash entry by sha256 hash.
+    async fn fetch_attachment_hash(&self, hash_value: &str) -> Result<FileHash> {
+        let hashes = self.file_hashes.lock().await;
+        hashes
+            .values()
+            .find(|&hash| hash.id == hash_value || hash.processed_hash == hash_value)
+            .cloned()
+            .ok_or(create_error!(NotFound))
+    }
+
+    /// Update an attachment hash nonce value.
+    async fn set_attachment_hash_nonce(&self, hash: &str, nonce: &str) -> Result<()> {
+        let mut hashes = self.file_hashes.lock().await;
+        if let Some(file) = hashes.get_mut(hash) {
+            file.iv = nonce.to_owned();
+            Ok(())
+        } else {
+            Err(create_error!(NotFound))
+        }
+    }
+
+    /// Delete attachment hash by id.
+    async fn delete_attachment_hash(&self, id: &str) -> Result<()> {
+        let mut file_hashes = self.file_hashes.lock().await;
+        if file_hashes.remove(id).is_some() {
+            Ok(())
+        } else {
+            Err(create_error!(NotFound))
+        }
+    }
+}

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

@@ -1,5 +1,6 @@
-use crate::Database;
+use crate::{Database, FileHash, Metadata};
 
+use iso8601_timestamp::Timestamp;
 use revolt_result::Result;
 
 auto_derived_partial!(
@@ -12,12 +13,18 @@ auto_derived_partial!(
         pub tag: String,
         /// Original filename
         pub filename: String,
-        /// Parsed metadata of this file
-        pub metadata: Metadata,
-        /// Raw content type of this file
-        pub content_type: String,
-        /// Size of this file (in bytes)
-        pub size: isize,
+        /// Hash of this file
+        pub hash: Option<String>, // these are Option<>s to not break file uploads on legacy Autumn
+
+        /// When this file was uploaded
+        pub uploaded_at: Option<Timestamp>, // these are Option<>s to not break file uploads on legacy Autumn
+        /// ID of user who uploaded this file
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub uploader_id: Option<String>, // these are Option<>s to not break file uploads on legacy Autumn
+
+        /// What the file was used for
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub used_for: Option<FileUsedFor>,
 
         /// Whether this file was deleted
         #[serde(skip_serializing_if = "Option::is_none")]
@@ -26,6 +33,14 @@ auto_derived_partial!(
         #[serde(skip_serializing_if = "Option::is_none")]
         pub reported: Option<bool>,
 
+        // !!! DEPRECATED:
+        /// Parsed metadata of this file
+        pub metadata: Metadata,
+        /// Raw content type of this file
+        pub content_type: String,
+        /// Size of this file (in bytes)
+        pub size: isize,
+
         // TODO: migrate this mess to having:
         // - author_id
         // - parent: Parent { Message(id), User(id), etc }
@@ -44,64 +59,184 @@ auto_derived_partial!(
 );
 
 auto_derived!(
-    /// Metadata associated with a file
-    #[serde(tag = "type")]
-    #[derive(Default)]
-    pub enum Metadata {
-        /// File is just a generic uncategorised file
-        #[default]
-        File,
-        /// File contains textual data and should be displayed as such
-        Text,
-        /// File is an image with specific dimensions
-        Image { width: isize, height: isize },
-        /// File is a video with specific dimensions
-        Video { width: isize, height: isize },
-        /// File is audio
-        Audio,
+    /// Type of object file was used for
+    pub enum FileUsedForType {
+        Message,
+        ServerBanner,
+        Emoji,
+        UserAvatar,
+        WebhookAvatar,
+        UserProfileBackground,
+        LegacyGroupIcon,
+        ChannelIcon,
+        ServerIcon,
+    }
+
+    /// Information about what the file was used for
+    pub struct FileUsedFor {
+        /// Type of the object
+        #[serde(rename = "type")]
+        pub object_type: FileUsedForType,
+        /// ID of the object
+        pub id: String,
     }
 );
 
 impl File {
+    /// Get the hash entry for this file
+    pub async fn as_hash(&self, db: &Database) -> Result<FileHash> {
+        db.fetch_attachment_hash(self.hash.as_ref().unwrap()).await
+    }
+
     /// Use a file for a message attachment
-    pub async fn use_attachment(db: &Database, id: &str, parent: &str) -> Result<File> {
-        db.find_and_use_attachment(id, "attachments", "message", parent)
-            .await
+    pub async fn use_attachment(
+        db: &Database,
+        id: &str,
+        parent: &str,
+        uploader_id: &str,
+    ) -> Result<File> {
+        db.find_and_use_attachment(
+            id,
+            "attachments",
+            FileUsedFor {
+                id: parent.to_owned(),
+                object_type: FileUsedForType::Message,
+            },
+            uploader_id.to_owned(),
+        )
+        .await
     }
 
     /// Use a file for a user profile background
-    pub async fn use_background(db: &Database, id: &str, parent: &str) -> Result<File> {
-        db.find_and_use_attachment(id, "backgrounds", "user", parent)
-            .await
+    pub async fn use_background(
+        db: &Database,
+        id: &str,
+        parent: &str,
+        uploader_id: &str,
+    ) -> Result<File> {
+        db.find_and_use_attachment(
+            id,
+            "backgrounds",
+            FileUsedFor {
+                id: parent.to_owned(),
+                object_type: FileUsedForType::UserProfileBackground,
+            },
+            uploader_id.to_owned(),
+        )
+        .await
     }
 
     /// Use a file for a user avatar
-    pub async fn use_avatar(db: &Database, id: &str, parent: &str) -> Result<File> {
-        db.find_and_use_attachment(id, "avatars", "user", parent)
-            .await
+    pub async fn use_user_avatar(
+        db: &Database,
+        id: &str,
+        parent: &str,
+        uploader_id: &str,
+    ) -> Result<File> {
+        db.find_and_use_attachment(
+            id,
+            "avatars",
+            FileUsedFor {
+                id: parent.to_owned(),
+                object_type: FileUsedForType::UserAvatar,
+            },
+            uploader_id.to_owned(),
+        )
+        .await
     }
 
-    /// Use a file for an icon
-    pub async fn use_icon(db: &Database, id: &str, parent: &str) -> Result<File> {
-        db.find_and_use_attachment(id, "icons", "object", parent)
-            .await
+    /// Use a file for a webhook avatar
+    pub async fn use_webhook_avatar(
+        db: &Database,
+        id: &str,
+        parent: &str,
+        uploader_id: &str,
+    ) -> Result<File> {
+        db.find_and_use_attachment(
+            id,
+            "avatars",
+            FileUsedFor {
+                id: parent.to_owned(),
+                object_type: FileUsedForType::WebhookAvatar,
+            },
+            uploader_id.to_owned(),
+        )
+        .await
     }
 
     /// Use a file for a server icon
-    pub async fn use_server_icon(db: &Database, id: &str, parent: &str) -> Result<File> {
-        db.find_and_use_attachment(id, "icons", "object", parent)
-            .await
+    pub async fn use_server_icon(
+        db: &Database,
+        id: &str,
+        parent: &str,
+        uploader_id: &str,
+    ) -> Result<File> {
+        db.find_and_use_attachment(
+            id,
+            "icons",
+            FileUsedFor {
+                id: parent.to_owned(),
+                object_type: FileUsedForType::ServerIcon,
+            },
+            uploader_id.to_owned(),
+        )
+        .await
+    }
+
+    /// Use a file for a channel icon
+    pub async fn use_channel_icon(
+        db: &Database,
+        id: &str,
+        parent: &str,
+        uploader_id: &str,
+    ) -> Result<File> {
+        db.find_and_use_attachment(
+            id,
+            "icons",
+            FileUsedFor {
+                id: parent.to_owned(),
+                object_type: FileUsedForType::ChannelIcon,
+            },
+            uploader_id.to_owned(),
+        )
+        .await
     }
 
     /// Use a file for a server banner
-    pub async fn use_banner(db: &Database, id: &str, parent: &str) -> Result<File> {
-        db.find_and_use_attachment(id, "banners", "server", parent)
-            .await
+    pub async fn use_server_banner(
+        db: &Database,
+        id: &str,
+        parent: &str,
+        uploader_id: &str,
+    ) -> Result<File> {
+        db.find_and_use_attachment(
+            id,
+            "banners",
+            FileUsedFor {
+                id: parent.to_owned(),
+                object_type: FileUsedForType::ServerBanner,
+            },
+            uploader_id.to_owned(),
+        )
+        .await
     }
 
     /// Use a file for an emoji
-    pub async fn use_emoji(db: &Database, id: &str, parent: &str) -> Result<File> {
-        db.find_and_use_attachment(id, "emojis", "object", parent)
-            .await
+    pub async fn use_emoji(
+        db: &Database,
+        id: &str,
+        parent: &str,
+        uploader_id: &str,
+    ) -> Result<File> {
+        db.find_and_use_attachment(
+            id,
+            "emojis",
+            FileUsedFor {
+                id: parent.to_owned(),
+                object_type: FileUsedForType::Emoji,
+            },
+            uploader_id.to_owned(),
+        )
+        .await
     }
 }

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

@@ -2,6 +2,8 @@ use revolt_result::Result;
 
 use crate::File;
 
+use super::FileUsedFor;
+
 mod mongodb;
 mod reference;
 
@@ -10,13 +12,25 @@ pub trait AbstractAttachments: Sync + Send {
     /// Insert attachment into database.
     async fn insert_attachment(&self, attachment: &File) -> Result<()>;
 
+    /// Fetch an attachment by its id.
+    async fn fetch_attachment(&self, tag: &str, file_id: &str) -> Result<File>;
+
+    /// Fetch all deleted attachments.
+    async fn fetch_deleted_attachments(&self) -> Result<Vec<File>>;
+
+    /// Fetch all dangling attachments.
+    async fn fetch_dangling_files(&self) -> Result<Vec<File>>;
+
+    /// Count references to a given hash.
+    async fn count_file_hash_references(&self, hash: &str) -> Result<usize>;
+
     /// Find an attachment by its details and mark it as used by a given parent.
     async fn find_and_use_attachment(
         &self,
         id: &str,
         tag: &str,
-        parent_type: &str,
-        parent_id: &str,
+        used_for: FileUsedFor,
+        uploader_id: String,
     ) -> Result<File>;
 
     /// Mark an attachment as having been reported.
@@ -27,4 +41,7 @@ pub trait AbstractAttachments: Sync + Send {
 
     /// Mark multiple attachments as having been deleted.
     async fn mark_attachments_as_deleted(&self, ids: &[String]) -> Result<()>;
+
+    /// Delete the attachment entry.
+    async fn delete_attachment(&self, id: &str) -> Result<()>;
 }

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

@@ -1,7 +1,10 @@
+use bson::to_document;
 use bson::Document;
+use revolt_config::report_internal_error;
 use revolt_result::Result;
 
 use crate::File;
+use crate::FileUsedFor;
 use crate::MongoDb;
 
 use super::AbstractAttachments;
@@ -15,15 +18,73 @@ impl AbstractAttachments for MongoDb {
         query!(self, insert_one, COL, &attachment).map(|_| ())
     }
 
+    /// Fetch an attachment by its id.
+    async fn fetch_attachment(&self, tag: &str, file_id: &str) -> Result<File> {
+        query!(
+            self,
+            find_one,
+            COL,
+            doc! {
+                "_id": file_id,
+                "tag": tag
+            }
+        )?
+        .ok_or_else(|| create_error!(NotFound))
+    }
+
+    /// Fetch all deleted attachments.
+    async fn fetch_deleted_attachments(&self) -> Result<Vec<File>> {
+        query!(
+            self,
+            find,
+            COL,
+            doc! {
+                "deleted": true,
+                "reported": {
+                    "$ne": true
+                }
+            }
+        )
+    }
+
+    /// Fetch all dangling attachments.
+    async fn fetch_dangling_files(&self) -> Result<Vec<File>> {
+        query!(
+            self,
+            find,
+            COL,
+            doc! {
+                "used_for.type": {
+                    "$exists": 0
+                },
+                "deleted": {
+                    "$ne": true
+                }
+            }
+        )
+    }
+
+    /// Count references to a given hash.
+    async fn count_file_hash_references(&self, hash: &str) -> Result<usize> {
+        query!(
+            self,
+            count_documents,
+            COL,
+            doc! {
+                "hash": hash
+            }
+        )
+        .map(|count| count as usize)
+    }
+
     /// Find an attachment by its details and mark it as used by a given parent.
     async fn find_and_use_attachment(
         &self,
         id: &str,
         tag: &str,
-        parent_type: &str,
-        parent_id: &str,
+        used_for: FileUsedFor,
+        uploader_id: String,
     ) -> Result<File> {
-        let key = format!("{parent_type}_id");
         let file = query!(
             self,
             find_one,
@@ -31,7 +92,7 @@ impl AbstractAttachments for MongoDb {
             doc! {
                 "_id": id,
                 "tag": tag,
-                &key: {
+                "used_for": {
                     "$exists": false
                 }
             }
@@ -45,10 +106,10 @@ impl AbstractAttachments for MongoDb {
                 },
                 doc! {
                     "$set": {
-                        key: parent_id
+                        "used_for": report_internal_error!(to_document(&used_for))?,
+                        "uploader_id": uploader_id
                     }
                 },
-                None,
             )
             .await
             .map_err(|_| create_database_error!("update_one", COL))?;
@@ -68,7 +129,6 @@ impl AbstractAttachments for MongoDb {
                         "reported": true
                     }
                 },
-                None,
             )
             .await
             .map(|_| ())
@@ -87,7 +147,6 @@ impl AbstractAttachments for MongoDb {
                         "deleted": true
                     }
                 },
-                None,
             )
             .await
             .map(|_| ())
@@ -97,7 +156,7 @@ impl AbstractAttachments for MongoDb {
     /// Mark multiple attachments as having been deleted.
     async fn mark_attachments_as_deleted(&self, ids: &[String]) -> Result<()> {
         self.col::<Document>(COL)
-            .update_one(
+            .update_many(
                 doc! {
                     "_id": {
                         "$in": ids
@@ -108,11 +167,15 @@ impl AbstractAttachments for MongoDb {
                         "deleted": true
                     }
                 },
-                None,
             )
             .await
             .map(|_| ())
-            .map_err(|_| create_database_error!("update_one", COL))
+            .map_err(|_| create_database_error!("update_many", COL))
+    }
+
+    /// Delete the attachment entry.
+    async fn delete_attachment(&self, id: &str) -> Result<()> {
+        query!(self, delete_one_by_id, COL, id).map(|_| ())
     }
 }
 
@@ -126,7 +189,6 @@ impl MongoDb {
                         "deleted": true
                     }
                 },
-                None,
             )
             .await
             .map(|_| ())

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

@@ -1,6 +1,7 @@
 use revolt_result::Result;
 
 use crate::File;
+use crate::FileUsedFor;
 use crate::ReferenceDb;
 
 use super::AbstractAttachments;
@@ -18,24 +19,68 @@ impl AbstractAttachments for ReferenceDb {
         }
     }
 
+    /// Fetch an attachment by its id.
+    async fn fetch_attachment(&self, tag: &str, file_id: &str) -> Result<File> {
+        let files = self.files.lock().await;
+        if let Some(file) = files.get(file_id) {
+            if file.tag == tag {
+                Ok(file.clone())
+            } else {
+                Err(create_error!(NotFound))
+            }
+        } else {
+            Err(create_error!(NotFound))
+        }
+    }
+
+    /// Fetch all deleted attachments.
+    async fn fetch_deleted_attachments(&self) -> Result<Vec<File>> {
+        let files = self.files.lock().await;
+        Ok(files
+            .values()
+            .filter(|file| {
+                // file has been marked as deleted
+                file.deleted.is_some_and(|v| v)
+                    // and it has not been reported
+                    && !file.reported.is_some_and(|v| v)
+            })
+            .cloned()
+            .collect())
+    }
+
+    /// Fetch all dangling attachments.
+    async fn fetch_dangling_files(&self) -> Result<Vec<File>> {
+        let files = self.files.lock().await;
+        Ok(files
+            .values()
+            .filter(|file| file.used_for.is_none() && !file.deleted.is_some_and(|v| v))
+            .cloned()
+            .collect())
+    }
+
+    /// Count references to a given hash.
+    async fn count_file_hash_references(&self, hash: &str) -> Result<usize> {
+        let files = self.files.lock().await;
+        Ok(files
+            .values()
+            .filter(|file| file.hash.as_ref().is_some_and(|h| h == hash))
+            .cloned()
+            .count())
+    }
+
     /// Find an attachment by its details and mark it as used by a given parent.
     async fn find_and_use_attachment(
         &self,
         id: &str,
         tag: &str,
-        parent_type: &str,
-        parent_id: &str,
+        used_for: FileUsedFor,
+        uploader_id: String,
     ) -> Result<File> {
         let mut files = self.files.lock().await;
         if let Some(file) = files.get_mut(id) {
             if file.tag == tag {
-                match parent_type {
-                    "message" => file.message_id = Some(parent_id.to_owned()),
-                    "user" => file.user_id = Some(parent_id.to_owned()),
-                    "object" => file.object_id = Some(parent_id.to_owned()),
-                    "server" => file.server_id = Some(parent_id.to_owned()),
-                    _ => unreachable!(),
-                }
+                file.uploader_id = Some(uploader_id);
+                file.used_for = Some(used_for);
 
                 Ok(file.clone())
             } else {
@@ -86,4 +131,14 @@ impl AbstractAttachments for ReferenceDb {
 
         Ok(())
     }
+
+    /// Delete the attachment entry.
+    async fn delete_attachment(&self, id: &str) -> Result<()> {
+        let mut files = self.files.lock().await;
+        if files.remove(id).is_some() {
+            Ok(())
+        } else {
+            Err(create_error!(NotFound))
+        }
+    }
 }

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

@@ -1,22 +1,25 @@
-use std::collections::HashSet;
+use std::{collections::HashSet, hash::RandomState};
 
 use indexmap::{IndexMap, IndexSet};
 use iso8601_timestamp::Timestamp;
-use revolt_config::config;
+use revolt_config::{config, FeaturesLimits};
 use revolt_models::v0::{
-    self, BulkMessageResponse, DataMessageSend, Embed, MessageAuthor, MessageSort, MessageWebhook,
-    PushNotification, ReplyIntent, SendableEmbed, Text, RE_MENTION,
+    self, BulkMessageResponse, DataMessageSend, Embed, MessageAuthor, MessageFlags, MessageSort,
+    MessageWebhook, PushNotification, ReplyIntent, SendableEmbed, Text,
 };
-use revolt_permissions::{ChannelPermission, PermissionValue};
-use revolt_result::Result;
+use revolt_permissions::{calculate_channel_permissions, ChannelPermission, PermissionValue};
+use revolt_result::{ErrorType, Result};
 use ulid::Ulid;
 use validator::Validate;
 
 use crate::{
     events::client::EventV1,
     tasks::{self, ack::AckEvent},
-    util::idempotency::IdempotencyKey,
-    Channel, Database, Emoji, File, User,
+    util::{
+        bulk_permissions::BulkDatabasePermissionQuery, idempotency::IdempotencyKey,
+        permissions::DatabasePermissionQuery,
+    },
+    Channel, Database, Emoji, File, User, AMQP,
 };
 
 auto_derived_partial!(
@@ -53,6 +56,9 @@ auto_derived_partial!(
         /// Array of user ids mentioned in this message
         #[serde(skip_serializing_if = "Option::is_none")]
         pub mentions: Option<Vec<String>>,
+        /// Array of role ids mentioned in this message
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub role_mentions: Option<Vec<String>>,
         /// Array of message ids this message is replying to
         #[serde(skip_serializing_if = "Option::is_none")]
         pub replies: Option<Vec<String>>,
@@ -65,6 +71,13 @@ auto_derived_partial!(
         /// Name and / or avatar overrides for this message
         #[serde(skip_serializing_if = "Option::is_none")]
         pub masquerade: Option<Masquerade>,
+        /// Whether or not the message in pinned
+        #[serde(skip_serializing_if = "crate::if_option_false")]
+        pub pinned: Option<bool>,
+
+        /// Bitfield of message flags
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub flags: Option<u32>,
     },
     "PartialMessage"
 );
@@ -95,6 +108,10 @@ auto_derived!(
         ChannelIconChanged { by: String },
         #[serde(rename = "channel_ownership_changed")]
         ChannelOwnershipChanged { from: String, to: String },
+        #[serde(rename = "message_pinned")]
+        MessagePinned { id: String, by: String },
+        #[serde(rename = "message_unpinned")]
+        MessageUnpinned { id: String, by: String },
     }
 
     /// Name and / or avatar override information
@@ -164,6 +181,8 @@ auto_derived!(
         pub author: Option<String>,
         /// Search query
         pub query: Option<String>,
+        /// Search for pinned
+        pub pinned: Option<bool>,
     }
 
     /// Message Query
@@ -179,8 +198,37 @@ auto_derived!(
         #[serde(flatten)]
         pub time_period: MessageTimePeriod,
     }
+
+    /// Optional fields on message
+    pub enum FieldsMessage {
+        Pinned,
+    }
 );
 
+pub struct MessageFlagsValue(pub u32);
+
+impl MessageFlagsValue {
+    pub fn has(&self, flag: MessageFlags) -> bool {
+        self.has_value(flag as u32)
+    }
+    pub fn has_value(&self, bit: u32) -> bool {
+        let mask = 1 << bit;
+        self.0 & mask == mask
+    }
+
+    pub fn set(&mut self, flag: MessageFlags, toggle: bool) -> &mut Self {
+        self.set_value(flag as u32, toggle)
+    }
+    pub fn set_value(&mut self, bit: u32, toggle: bool) -> &mut Self {
+        if toggle {
+            self.0 |= 1 << bit;
+        } else {
+            self.0 &= !(1 << bit);
+        }
+        self
+    }
+}
+
 #[allow(clippy::derivable_impls)]
 impl Default for Message {
     fn default() -> Self {
@@ -196,10 +244,13 @@ impl Default for Message {
             edited: None,
             embeds: None,
             mentions: None,
+            role_mentions: None,
             replies: None,
             reactions: Default::default(),
             interactions: Default::default(),
             masquerade: None,
+            flags: None,
+            pinned: None,
         }
     }
 }
@@ -207,11 +258,16 @@ impl Default for Message {
 #[allow(clippy::disallowed_methods)]
 impl Message {
     /// Create message from API data
+    #[allow(clippy::too_many_arguments)]
     pub async fn create_from_api(
         db: &Database,
+        amqp: Option<&AMQP>,
         channel: Channel,
         data: DataMessageSend,
         author: MessageAuthor<'_>,
+        user: Option<v0::User>,
+        member: Option<v0::Member>,
+        limits: FeaturesLimits,
         mut idempotency: IdempotencyKey,
         generate_embeds: bool,
         allow_mentions: bool,
@@ -221,7 +277,7 @@ impl Message {
         Message::validate_sum(
             &data.content,
             data.embeds.as_deref().unwrap_or_default(),
-            config.features.limits.default.message_length,
+            limits.message_length,
         )?;
 
         idempotency
@@ -230,13 +286,50 @@ impl Message {
             .map_err(|_| create_error!(InvalidOperation))?;
 
         // Check the message is not empty
-        if (data.content.as_ref().map_or(true, |v| v.is_empty()))
-            && (data.attachments.as_ref().map_or(true, |v| v.is_empty()))
-            && (data.embeds.as_ref().map_or(true, |v| v.is_empty()))
+        if (data.content.as_ref().is_none_or(|v| v.is_empty()))
+            && (data.attachments.as_ref().is_none_or(|v| v.is_empty()))
+            && (data.embeds.as_ref().is_none_or(|v| v.is_empty()))
         {
             return Err(create_error!(EmptyMessage));
         }
 
+        let allow_mass_mentions = allow_mentions && config.features.mass_mentions_enabled;
+
+        let mut mentions_everyone = false;
+        let mut mentions_online = false;
+        let mut suppress_notifications = false;
+
+        if let Some(raw_flags) = &data.flags {
+            if raw_flags > &7 {
+                // quick path to failure: bigger than all the bits combined
+                return Err(create_error!(InvalidProperty));
+            }
+
+            // First step of mass mention resolution
+            let flags = MessageFlagsValue(*raw_flags);
+            suppress_notifications = flags.has(MessageFlags::SuppressNotifications);
+            mentions_everyone = allow_mentions && flags.has(MessageFlags::MentionsEveryone);
+            mentions_online = allow_mentions && flags.has(MessageFlags::MentionsOnline);
+
+            // Not a bot, and attempting to set mention flags
+            if user.as_ref().is_some_and(|u| u.bot.as_ref().is_none())
+                && (mentions_everyone || mentions_online)
+            {
+                return Err(create_error!(IsNotBot));
+            }
+
+            if mentions_everyone && mentions_online {
+                return Err(create_error!(InvalidFlagValue));
+            }
+        }
+
+        let server_id = match channel {
+            Channel::TextChannel { ref server, .. } | Channel::VoiceChannel { ref server, .. } => {
+                Some(server.clone())
+            }
+            _ => None,
+        };
+
         // Ensure restrict_reactions is not specified without reactions list
         if let Some(interactions) = &data.interactions {
             if interactions.restrict_reactions {
@@ -262,7 +355,7 @@ impl Message {
         let message_id = Ulid::new().to_string();
         let mut message = Message {
             id: message_id.clone(),
-            channel: channel.id(),
+            channel: channel.id().to_string(),
             masquerade: data.masquerade.map(|masquerade| masquerade.into()),
             interactions: data
                 .interactions
@@ -270,17 +363,76 @@ impl Message {
                 .unwrap_or_default(),
             author: author_id,
             webhook: webhook.map(|w| w.into()),
+            flags: data.flags,
             ..Default::default()
         };
 
         // Parse mentions in message.
-        let mut mentions = HashSet::new();
-        if allow_mentions {
-            if let Some(content) = &data.content {
-                for capture in RE_MENTION.captures_iter(content) {
-                    if let Some(mention) = capture.get(1) {
-                        mentions.insert(mention.as_str().to_string());
-                    }
+
+        let mut message_mentions = if let Some(raw_content) = &data.content {
+            revolt_parser::parse_message(raw_content)
+        } else {
+            revolt_parser::MessageResults::default()
+        };
+
+        message_mentions.mentions_everyone |= mentions_everyone;
+        message_mentions.mentions_online |= mentions_online;
+
+        let revolt_parser::MessageResults {
+            mut user_mentions,
+            mut role_mentions,
+            mut mentions_everyone,
+            mut mentions_online,
+        } = message_mentions;
+
+        if allow_mass_mentions && server_id.is_some() && !role_mentions.is_empty() {
+            let server_data = db
+                .fetch_server(server_id.unwrap().as_str())
+                .await
+                .expect("Failed to fetch server");
+
+            role_mentions.retain(|role_id| server_data.roles.contains_key(role_id));
+        }
+
+        // Validate the user can perform a mass mention
+        if !config.features.mass_mentions_enabled
+            && (mentions_everyone || mentions_online || !role_mentions.is_empty())
+        {
+            mentions_everyone = false;
+            mentions_online = false;
+            role_mentions.clear();
+        } else if mentions_everyone || mentions_online || !role_mentions.is_empty() {
+            debug!(
+                "Mentioned everyone: {}, mentioned online: {}, mentioned roles: {:?}",
+                mentions_everyone, mentions_online, &role_mentions
+            );
+            if let Some(user) = match author {
+                MessageAuthor::User(user) => Some(Ok(user)),
+                MessageAuthor::System { .. } => Some(Err(())), // DISALLOWED
+                MessageAuthor::Webhook(..) => None,            // Bypass check
+            } {
+                if user.is_err() {
+                    return Err(create_error!(InvalidProperty));
+                }
+                let owned_user: User = user.unwrap().to_owned().into();
+
+                let mut query = DatabasePermissionQuery::new(db, &owned_user).channel(&channel);
+                let perms = calculate_channel_permissions(&mut query).await;
+
+                if (mentions_everyone || mentions_online)
+                    && !perms.has_channel_permission(ChannelPermission::MentionEveryone)
+                {
+                    return Err(create_error!(MissingPermission {
+                        permission: ChannelPermission::MentionEveryone.to_string()
+                    }));
+                }
+
+                if !role_mentions.is_empty()
+                    && !perms.has_channel_permission(ChannelPermission::MentionRoles)
+                {
+                    return Err(create_error!(MissingPermission {
+                        permission: ChannelPermission::MentionRoles.to_string()
+                    }));
                 }
             }
         }
@@ -288,25 +440,95 @@ impl Message {
         // Verify replies are valid.
         let mut replies = HashSet::new();
         if let Some(entries) = data.replies {
-            if entries.len() > config.features.limits.default.message_replies {
+            if entries.len() > config.features.limits.global.message_replies {
                 return Err(create_error!(TooManyReplies {
-                    max: config.features.limits.default.message_replies,
+                    max: config.features.limits.global.message_replies,
                 }));
             }
 
-            for ReplyIntent { id, mention } in entries {
-                let message = db.fetch_message(&id).await?;
+            for ReplyIntent {
+                id,
+                mention,
+                fail_if_not_exists,
+            } in entries
+            {
+                match db.fetch_message(&id).await {
+                    // Referenced message exists
+                    Ok(message) => {
+                        if mention && allow_mentions {
+                            user_mentions.insert(message.author.to_owned());
+                        }
 
-                if mention && allow_mentions {
-                    mentions.insert(message.author.to_owned());
+                        replies.insert(message.id);
+                    }
+                    // If the referenced message doesn't exist and fail_if_not_exists
+                    // is set to false, send the message without the reply.
+                    Err(e) => {
+                        if !matches!(e.error_type, ErrorType::NotFound)
+                            || fail_if_not_exists.unwrap_or(true)
+                        {
+                            return Err(e);
+                        }
+                    }
                 }
-
-                replies.insert(message.id);
             }
         }
 
-        if !mentions.is_empty() {
-            message.mentions.replace(mentions.into_iter().collect());
+        // Validate the mentions go to users in the channel/server
+        if !user_mentions.is_empty() {
+            match channel {
+                Channel::DirectMessage { ref recipients, .. }
+                | Channel::Group { ref recipients, .. } => {
+                    let recipients_hash = HashSet::<&String, RandomState>::from_iter(recipients);
+                    user_mentions.retain(|m| recipients_hash.contains(m));
+                    role_mentions.clear();
+                }
+                Channel::TextChannel { ref server, .. }
+                | Channel::VoiceChannel { ref server, .. } => {
+                    let mentions_vec = Vec::from_iter(user_mentions.iter().cloned());
+
+                    let valid_members = db.fetch_members(server.as_str(), &mentions_vec[..]).await;
+                    if let Ok(valid_members) = valid_members {
+                        let valid_mentions = HashSet::<&String, RandomState>::from_iter(
+                            valid_members.iter().map(|m| &m.id.user),
+                        );
+
+                        user_mentions.retain(|m| valid_mentions.contains(m)); // quick pass, validate mentions are in the server
+
+                        if !user_mentions.is_empty() {
+                            // if there are still mentions, drill down to a channel-level
+                            let member_channel_view_perms =
+                                BulkDatabasePermissionQuery::from_server_id(db, server)
+                                    .await
+                                    .channel(&channel)
+                                    .members(&valid_members)
+                                    .members_can_see_channel()
+                                    .await;
+
+                            user_mentions
+                                .retain(|m| *member_channel_view_perms.get(m).unwrap_or(&false));
+                        }
+                    } else {
+                        revolt_config::capture_error(&valid_members.unwrap_err());
+                        return Err(create_error!(InternalError));
+                    }
+                }
+                Channel::SavedMessages { .. } => {
+                    user_mentions.clear();
+                }
+            }
+        }
+
+        if !user_mentions.is_empty() {
+            message
+                .mentions
+                .replace(user_mentions.into_iter().collect());
+        }
+
+        if !role_mentions.is_empty() {
+            message
+                .role_mentions
+                .replace(role_mentions.into_iter().collect());
         }
 
         if !replies.is_empty() {
@@ -315,33 +537,40 @@ impl Message {
                 .replace(replies.into_iter().collect::<Vec<String>>());
         }
 
+        // Calculate final message flags
+        let mut flag_value = MessageFlagsValue(0);
+        flag_value
+            .set(MessageFlags::SuppressNotifications, suppress_notifications)
+            .set(MessageFlags::MentionsEveryone, mentions_everyone)
+            .set(MessageFlags::MentionsOnline, mentions_online);
+
+        message.flags = Some(flag_value.0);
+
         // Add attachments to message.
         let mut attachments = vec![];
         if data
             .attachments
             .as_ref()
-            .is_some_and(|v| v.len() > config.features.limits.default.message_attachments)
+            .is_some_and(|v| v.len() > limits.message_attachments)
         {
             return Err(create_error!(TooManyAttachments {
-                max: config.features.limits.default.message_attachments,
+                max: limits.message_attachments,
             }));
         }
 
         if data
             .embeds
             .as_ref()
-            .is_some_and(|v| v.len() > config.features.limits.default.message_embeds)
+            .is_some_and(|v| v.len() > config.features.limits.global.message_embeds)
         {
             return Err(create_error!(TooManyEmbeds {
-                max: config.features.limits.default.message_embeds,
+                max: config.features.limits.global.message_embeds,
             }));
         }
 
         for attachment_id in data.attachments.as_deref().unwrap_or_default() {
-            attachments.push(
-                db.find_and_use_attachment(attachment_id, "attachments", "message", &message_id)
-                    .await?,
-            );
+            attachments
+                .push(File::use_attachment(db, attachment_id, &message_id, author.id()).await?);
         }
 
         if !attachments.is_empty() {
@@ -360,7 +589,9 @@ impl Message {
         message.nonce = Some(idempotency.into_key());
 
         // Send the message
-        message.send(db, author, &channel, generate_embeds).await?;
+        message
+            .send(db, amqp, author, user, member, &channel, generate_embeds)
+            .await?;
 
         Ok(message)
     }
@@ -369,13 +600,18 @@ impl Message {
     pub async fn send_without_notifications(
         &mut self,
         db: &Database,
+        user: Option<v0::User>,
+        member: Option<v0::Member>,
         is_dm: bool,
         generate_embeds: bool,
+        // This determines if this function should queue the mentions task or if somewhere else will.
+        // If this is true, you MUST call tasks::ack::queue yourself.
+        mentions_elsewhere: bool,
     ) -> Result<()> {
         db.insert_message(self).await?;
 
         // Fan out events
-        EventV1::Message(self.clone().into())
+        EventV1::Message(self.clone().into_model(user, member))
             .p(self.channel.to_string())
             .await;
 
@@ -383,13 +619,17 @@ impl Message {
         tasks::last_message_id::queue(self.channel.to_string(), self.id.to_string(), is_dm).await;
 
         // Add mentions for affected users
-        if let Some(mentions) = &self.mentions {
-            for user in mentions {
-                tasks::ack::queue(
+        if !mentions_elsewhere {
+            if let Some(mentions) = &self.mentions {
+                tasks::ack::queue_message(
                     self.channel.to_string(),
-                    user.to_string(),
-                    AckEvent::AddMention {
-                        ids: vec![self.id.to_string()],
+                    AckEvent::ProcessMessage {
+                        messages: vec![(
+                            None,
+                            self.clone(),
+                            mentions.clone(),
+                            self.has_suppressed_notifications(),
+                        )],
                     },
                 )
                 .await;
@@ -412,33 +652,58 @@ impl Message {
     }
 
     /// Send a message
+    #[allow(clippy::too_many_arguments)]
     pub async fn send(
         &mut self,
         db: &Database,
+        _amqp: Option<&AMQP>, // this is optional mostly for tests.
         author: MessageAuthor<'_>,
+        user: Option<v0::User>,
+        member: Option<v0::Member>,
         channel: &Channel,
         generate_embeds: bool,
     ) -> Result<()> {
         self.send_without_notifications(
             db,
+            user.clone(),
+            member.clone(),
             matches!(channel, Channel::DirectMessage { .. }),
             generate_embeds,
+            true,
         )
         .await?;
 
-        // Push out Web Push notifications
-        crate::tasks::web_push::queue(
-            {
-                match channel {
-                    Channel::DirectMessage { recipients, .. }
-                    | Channel::Group { recipients, .. } => recipients.clone(),
-                    Channel::TextChannel { .. } => self.mentions.clone().unwrap_or_default(),
-                    _ => vec![],
-                }
-            },
-            PushNotification::from(self.clone().into(), Some(author), &channel.id()).await,
-        )
-        .await;
+        if !self.has_suppressed_notifications()
+            && (self.mentions.is_some() || self.contains_mass_push_mention())
+        {
+            // send Push notifications
+            tasks::ack::queue_message(
+                self.channel.to_string(),
+                AckEvent::ProcessMessage {
+                    messages: vec![(
+                        Some(
+                            PushNotification::from(
+                                self.clone().into_model(user, member),
+                                Some(author),
+                                channel.to_owned().into(),
+                            )
+                            .await,
+                        ),
+                        self.clone(),
+                        match channel {
+                            Channel::DirectMessage { recipients, .. }
+                            | Channel::Group { recipients, .. } => recipients.clone(),
+                            Channel::TextChannel { .. } => {
+                                self.mentions.clone().unwrap_or_default()
+                            }
+                            _ => vec![],
+                        },
+                        false, // branch already dictates this
+                    )],
+                },
+            )
+            .await;
+        }
 
         Ok(())
     }
@@ -452,10 +717,7 @@ impl Message {
         })?;
 
         let media = if let Some(id) = embed.media {
-            Some(
-                db.find_and_use_attachment(&id, "attachments", "message", &self.id)
-                    .await?,
-            )
+            Some(File::use_attachment(db, &id, &self.id, &self.author).await?)
         } else {
             None
         };
@@ -470,15 +732,48 @@ impl Message {
         }))
     }
 
+    /// Whether this message has suppressed notifications
+    pub fn has_suppressed_notifications(&self) -> bool {
+        if let Some(flags) = self.flags {
+            flags & MessageFlags::SuppressNotifications as u32
+                == MessageFlags::SuppressNotifications as u32
+        } else {
+            false
+        }
+    }
+
+    pub fn contains_mass_push_mention(&self) -> bool {
+        let ping = if let Some(flags) = self.flags {
+            let flags = MessageFlagsValue(flags);
+            flags.has(MessageFlags::MentionsEveryone)
+        } else {
+            false
+        };
+
+        ping || self.role_mentions.is_some()
+    }
+
     /// Update message data
-    pub async fn update(&mut self, db: &Database, partial: PartialMessage) -> Result<()> {
+    pub async fn update(
+        &mut self,
+        db: &Database,
+        partial: PartialMessage,
+        remove: Vec<FieldsMessage>,
+    ) -> Result<()> {
         self.apply_options(partial.clone());
-        db.update_message(&self.id, &partial).await?;
+
+        for field in &remove {
+            self.remove_field(field);
+        }
+
+        db.update_message(&self.id, &partial, remove.clone())
+            .await?;
 
         EventV1::MessageUpdate {
             id: self.id.clone(),
             channel: self.channel.clone(),
             data: partial.into(),
+            clear: remove.into_iter().map(|field| field.into()).collect(),
         }
         .p(self.channel.clone())
         .await;
@@ -498,13 +793,47 @@ impl Message {
             .fetch_messages(query)
             .await?
             .into_iter()
-            .map(Into::into)
+            .map(|msg| msg.into_model(None, None))
             .collect();
 
         if let Some(true) = include_users {
             let user_ids = messages
                 .iter()
-                .map(|m| m.author.clone())
+                .flat_map(|m| {
+                    let mut users = vec![m.author.clone()];
+                    if let Some(system) = &m.system {
+                        match system {
+                            v0::SystemMessage::ChannelDescriptionChanged { by } => {
+                                users.push(by.clone())
+                            }
+                            v0::SystemMessage::ChannelIconChanged { by } => users.push(by.clone()),
+                            v0::SystemMessage::ChannelOwnershipChanged { from, to, .. } => {
+                                users.push(from.clone());
+                                users.push(to.clone())
+                            }
+                            v0::SystemMessage::ChannelRenamed { by, .. } => users.push(by.clone()),
+                            v0::SystemMessage::UserAdded { by, id, .. }
+                            | v0::SystemMessage::UserRemove { by, id, .. } => {
+                                users.push(by.clone());
+                                users.push(id.clone());
+                            }
+                            v0::SystemMessage::UserBanned { id, .. }
+                            | v0::SystemMessage::UserKicked { id, .. }
+                            | v0::SystemMessage::UserJoined { id, .. }
+                            | v0::SystemMessage::UserLeft { id, .. } => {
+                                users.push(id.clone());
+                            }
+                            v0::SystemMessage::Text { .. } => {}
+                            v0::SystemMessage::MessagePinned { by, .. } => {
+                                users.push(by.clone());
+                            }
+                            v0::SystemMessage::MessageUnpinned { by, .. } => {
+                                users.push(by.clone());
+                            }
+                        }
+                    }
+                    users
+                })
                 .collect::<HashSet<String>>()
                 .into_iter()
                 .collect::<Vec<String>>();
@@ -558,7 +887,7 @@ impl Message {
     ) -> Result<()> {
         let media: Option<v0::File> = if let Some(id) = embed.media {
             Some(
-                db.find_and_use_attachment(&id, "attachments", "message", &self.id)
+                File::use_attachment(db, &id, &self.id, &self.author)
                     .await?
                     .into(),
             )
@@ -588,7 +917,7 @@ impl Message {
     pub async fn add_reaction(&self, db: &Database, user: &User, emoji: &str) -> Result<()> {
         // Check how many reactions are already on the message
         let config = config().await;
-        if self.reactions.len() >= config.features.limits.default.message_reactions
+        if self.reactions.len() >= config.features.limits.global.message_reactions
             && !self.reactions.contains_key(emoji)
         {
             return Err(create_error!(InvalidOperation));
@@ -730,6 +1059,12 @@ impl Message {
         // Write to database
         db.clear_reaction(&self.id, emoji).await
     }
+
+    pub fn remove_field(&mut self, field: &FieldsMessage) {
+        match field {
+            FieldsMessage::Pinned => self.pinned = None,
+        }
+    }
 }
 
 impl SystemMessage {
@@ -753,7 +1088,7 @@ impl Interactions {
         if let Some(reactions) = &self.reactions {
             permissions.throw_if_lacking_channel_permission(ChannelPermission::React)?;
 
-            if reactions.len() > config.features.limits.default.message_reactions {
+            if reactions.len() > config.features.limits.global.message_reactions {
                 return Err(create_error!(InvalidOperation));
             }
 

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

@@ -1,6 +1,6 @@
 use revolt_result::Result;
 
-use crate::{AppendMessage, Message, MessageQuery, PartialMessage};
+use crate::{AppendMessage, FieldsMessage, Message, MessageQuery, PartialMessage};
 
 mod mongodb;
 mod reference;
@@ -20,7 +20,7 @@ pub trait AbstractMessages: Sync + Send {
     async fn fetch_messages_by_id(&self, ids: &[String]) -> Result<Vec<Message>>;
 
     /// Update a given message with new information
-    async fn update_message(&self, id: &str, message: &PartialMessage) -> Result<()>;
+    async fn update_message(&self, id: &str, message: &PartialMessage, remove: Vec<FieldsMessage>) -> Result<()>;
 
     /// Append information to a given message
     async fn append_message(&self, id: &str, append: &AppendMessage) -> Result<()>;

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

@@ -5,7 +5,8 @@ use revolt_models::v0::MessageSort;
 use revolt_result::Result;
 
 use crate::{
-    AppendMessage, DocumentId, Message, MessageQuery, MessageTimePeriod, MongoDb, PartialMessage,
+    AppendMessage, DocumentId, FieldsMessage, IntoDocumentPath, Message, MessageQuery,
+    MessageTimePeriod, MongoDb, PartialMessage,
 };
 
 use super::AbstractMessages;
@@ -50,6 +51,10 @@ impl AbstractMessages for MongoDb {
             false
         };
 
+        if let Some(pinned) = query.filter.pinned {
+            filter.insert("pinned", pinned);
+        };
+
         // 2. Find query limit
         let limit = query.limit.unwrap_or(50);
 
@@ -90,7 +95,7 @@ impl AbstractMessages for MongoDb {
                         COL,
                         older_message_filter,
                         FindOptions::builder()
-                            .limit(limit / 2)
+                            .limit(limit / 2 + 1)
                             .sort(doc! {
                                 "_id": -1_i32
                             })
@@ -166,7 +171,7 @@ impl AbstractMessages for MongoDb {
         self.find_with_options(
             COL,
             doc! {
-                "ids": {
+                "_id": {
                     "$in": ids
                 }
             },
@@ -177,8 +182,22 @@ impl AbstractMessages for MongoDb {
     }
 
     /// Update a given message with new information
-    async fn update_message(&self, id: &str, message: &PartialMessage) -> Result<()> {
-        query!(self, update_one_by_id, COL, id, message, vec![], None).map(|_| ())
+    async fn update_message(
+        &self,
+        id: &str,
+        message: &PartialMessage,
+        remove: Vec<FieldsMessage>,
+    ) -> Result<()> {
+        query!(
+            self,
+            update_one_by_id,
+            COL,
+            id,
+            message,
+            remove.iter().map(|x| x as &dyn IntoDocumentPath).collect(),
+            None
+        )
+        .map(|_| ())
     }
 
     /// Append information to a given message
@@ -209,7 +228,6 @@ impl AbstractMessages for MongoDb {
                     "_id": id
                 },
                 query,
-                None,
             )
             .await
             .map(|_| ())
@@ -228,7 +246,6 @@ impl AbstractMessages for MongoDb {
                         format!("reactions.{emoji}"): user
                     }
                 },
-                None,
             )
             .await
             .map(|_| ())
@@ -247,7 +264,6 @@ impl AbstractMessages for MongoDb {
                         format!("reactions.{emoji}"): user
                     }
                 },
-                None,
             )
             .await
             .map(|_| ())
@@ -266,7 +282,6 @@ impl AbstractMessages for MongoDb {
                         format!("reactions.{emoji}"): 1
                     }
                 },
-                None,
             )
             .await
             .map(|_| ())
@@ -281,21 +296,26 @@ impl AbstractMessages for MongoDb {
     /// Delete messages from a channel by their ids and corresponding channel id
     async fn delete_messages(&self, channel: &str, ids: &[String]) -> Result<()> {
         self.col::<Document>(COL)
-            .delete_many(
-                doc! {
-                    "channel": channel,
-                    "_id": {
-                        "$in": ids
-                    }
-                },
-                None,
-            )
+            .delete_many(doc! {
+                "channel": channel,
+                "_id": {
+                    "$in": ids
+                }
+            })
             .await
             .map(|_| ())
             .map_err(|_| create_database_error!("delete_many", COL))
     }
 }
 
+impl IntoDocumentPath for FieldsMessage {
+    fn as_path(&self) -> Option<&'static str> {
+        Some(match self {
+            FieldsMessage::Pinned => "pinned",
+        })
+    }
+}
+
 impl MongoDb {
     pub async fn delete_bulk_messages(&self, projection: Document) -> Result<()> {
         let mut for_attachments = projection.clone();
@@ -335,7 +355,6 @@ impl MongoDb {
                             "deleted": true
                         }
                     },
-                    None,
                 )
                 .await
                 .map_err(|_| create_database_error!("update_many", "attachments"))?;
@@ -343,7 +362,7 @@ impl MongoDb {
 
         // And then delete said messages.
         self.col::<Document>(COL)
-            .delete_many(projection, None)
+            .delete_many(projection)
             .await
             .map(|_| ())
             .map_err(|_| create_database_error!("delete_many", COL))

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

@@ -2,7 +2,7 @@ use futures::future::try_join_all;
 use indexmap::IndexSet;
 use revolt_result::Result;
 
-use crate::{AppendMessage, Message, MessageQuery, PartialMessage, ReferenceDb};
+use crate::{AppendMessage, FieldsMessage, Message, MessageQuery, PartialMessage, ReferenceDb};
 
 use super::AbstractMessages;
 
@@ -56,6 +56,12 @@ impl AbstractMessages for ReferenceDb {
                     }
                 }
 
+                if let Some(pinned) = query.filter.pinned {
+                    if message.pinned.unwrap_or_default() == pinned {
+                        return false
+                    }
+                }
+
                 true
             })
             .cloned()
@@ -183,10 +189,15 @@ impl AbstractMessages for ReferenceDb {
     }
 
     /// Update a given message with new information
-    async fn update_message(&self, id: &str, message: &PartialMessage) -> Result<()> {
+    async fn update_message(&self, id: &str, message: &PartialMessage, remove: Vec<FieldsMessage>) -> Result<()> {
         let mut messages = self.messages.lock().await;
         if let Some(message_data) = messages.get_mut(id) {
             message_data.apply_options(message.to_owned());
+
+            for field in remove {
+                #[allow(clippy::disallowed_methods)]
+                message_data.remove_field(&field);
+            }
             Ok(())
         } else {
             Err(create_error!(NotFound))

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

@@ -5,8 +5,10 @@ mod channel_unreads;
 mod channel_webhooks;
 mod channels;
 mod emojis;
+mod file_hashes;
 mod files;
 mod messages;
+mod policy_changes;
 mod ratelimit_events;
 mod safety_reports;
 mod safety_snapshots;
@@ -23,8 +25,10 @@ pub use channel_unreads::*;
 pub use channel_webhooks::*;
 pub use channels::*;
 pub use emojis::*;
+pub use file_hashes::*;
 pub use files::*;
 pub use messages::*;
+pub use policy_changes::*;
 pub use ratelimit_events::*;
 pub use safety_reports::*;
 pub use safety_snapshots::*;
@@ -46,8 +50,10 @@ pub trait AbstractDatabase:
     + channel_unreads::AbstractChannelUnreads
     + channel_webhooks::AbstractWebhooks
     + emojis::AbstractEmojis
+    + file_hashes::AbstractAttachmentHashes
     + files::AbstractAttachments
     + messages::AbstractMessages
+    + policy_changes::AbstractPolicyChange
     + ratelimit_events::AbstractRatelimitEvents
     + safety_reports::AbstractReport
     + safety_snapshots::AbstractSnapshot

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

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

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

@@ -0,0 +1,20 @@
+use iso8601_timestamp::Timestamp;
+
+auto_derived!(
+    /// Platform policy change
+    pub struct PolicyChange {
+        /// Unique Id
+        #[serde(rename = "_id")]
+        pub id: String,
+
+        /// Time at which this policy was created
+        pub created_time: Timestamp,
+        /// Time at which this policy is effective
+        pub effective_time: Timestamp,
+
+        /// Message shown to users
+        pub description: String,
+        /// URL with details about changes
+        pub url: String,
+    }
+);

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

@@ -0,0 +1,15 @@
+use revolt_result::Result;
+
+use crate::PolicyChange;
+
+mod mongodb;
+mod reference;
+
+#[async_trait]
+pub trait AbstractPolicyChange: Sync + Send {
+    /// Fetch all policy changes
+    async fn fetch_policy_changes(&self) -> Result<Vec<PolicyChange>>;
+
+    /// Acknowledge policy changes
+    async fn acknowledge_policy_changes(&self, user_id: &str) -> Result<()>;
+}

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

@@ -0,0 +1,46 @@
+use bson::to_bson;
+use iso8601_timestamp::Timestamp;
+use revolt_result::Result;
+
+use crate::MongoDb;
+use crate::PolicyChange;
+use crate::User;
+
+use super::AbstractPolicyChange;
+
+static COL: &str = "policy_changes";
+
+#[async_trait]
+impl AbstractPolicyChange for MongoDb {
+    /// Fetch all policy changes
+    async fn fetch_policy_changes(&self) -> Result<Vec<PolicyChange>> {
+        query!(self, find, COL, doc! {})
+    }
+
+    /// Acknowledge policy changes
+    async fn acknowledge_policy_changes(&self, user_id: &str) -> Result<()> {
+        let latest_policy = self
+            .fetch_policy_changes()
+            .await?
+            .into_iter()
+            .map(|policy| policy.created_time)
+            .max()
+            .unwrap_or(Timestamp::UNIX_EPOCH);
+
+        self.col::<User>("users")
+            .update_one(
+                doc! {
+                    "_id": user_id
+                },
+                doc! {
+                    "$set": {
+                        "last_acknowledged_policy_change": to_bson(&latest_policy)
+                            .map_err(|_| create_database_error!("to_bson", "timestamp"))?
+                    }
+                },
+            )
+            .await
+            .map(|_| ())
+            .map_err(|_| create_database_error!("update_one", COL))
+    }
+}

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

@@ -0,0 +1,31 @@
+use iso8601_timestamp::Timestamp;
+use revolt_result::Result;
+
+use crate::PolicyChange;
+use crate::ReferenceDb;
+
+use super::AbstractPolicyChange;
+
+#[async_trait]
+impl AbstractPolicyChange for ReferenceDb {
+    /// Fetch all policy changes
+    async fn fetch_policy_changes(&self) -> Result<Vec<PolicyChange>> {
+        let policy_changes = self.policy_changes.lock().await;
+        Ok(policy_changes.values().cloned().collect())
+    }
+
+    /// Acknowledge policy changes
+    async fn acknowledge_policy_changes(&self, user_id: &str) -> Result<()> {
+        let mut users = self.users.lock().await;
+        let user = users.get_mut(user_id).expect("user doesn't exist");
+        user.last_acknowledged_policy_change = self
+            .fetch_policy_changes()
+            .await?
+            .into_iter()
+            .map(|policy| policy.created_time)
+            .max()
+            .unwrap_or(Timestamp::UNIX_EPOCH);
+
+        Ok(())
+    }
+}

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

@@ -23,16 +23,13 @@ impl AbstractRatelimitEvents for MongoDb {
         count: usize,
     ) -> Result<bool> {
         self.col::<RatelimitEvent>(COL)
-            .count_documents(
-                doc! {
-                    "_id": {
-                        "$gte": Ulid::from_datetime(SystemTime::now() - period).to_string()
-                    },
-                    "target_id": target_id,
-                    "event_type": event_type.to_string()
+            .count_documents(doc! {
+                "_id": {
+                    "$gte": Ulid::from_datetime(SystemTime::now() - period).to_string()
                 },
-                None,
-            )
+                "target_id": target_id,
+                "event_type": event_type.to_string()
+            })
             .await
             .map(|c| c as usize >= count)
             .map_err(|_| create_database_error!("count_documents", COL))

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

@@ -85,8 +85,8 @@ impl SnapshotContent {
         Ok((
             SnapshotContent::Message {
                 message,
-                prior_context: prior_context.into_iter().map(Into::into).collect(),
-                leading_context: leading_context.into_iter().map(Into::into).collect(),
+                prior_context: prior_context.into_iter().collect(),
+                leading_context: leading_context.into_iter().collect(),
             },
             files,
         ))

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

@@ -13,6 +13,7 @@ auto_derived!(
     }
 );
 
+#[allow(clippy::disallowed_methods)]
 impl ServerBan {
     /// Create ban
     pub async fn create(

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

@@ -81,7 +81,7 @@ impl Member {
         server: &Server,
         user: &User,
         channels: Option<Vec<Channel>>,
-    ) -> Result<Vec<Channel>> {
+    ) -> Result<(Member, Vec<Channel>)> {
         if db.fetch_ban(&server.id, &user.id).await.is_ok() {
             return Err(create_error!(Banned));
         }
@@ -150,16 +150,16 @@ impl Member {
                 id: user.id.clone(),
             }
             .into_message(id.to_string())
-            .send_without_notifications(db, false, false)
+            .send_without_notifications(db, None, None, false, false, false)
             .await
             .ok();
         }
 
-        Ok(channels)
+        Ok((member, channels))
     }
 
     /// Update member data
-    pub async fn update<'a>(
+    pub async fn update(
         &mut self,
         db: &Database,
         partial: PartialMember,
@@ -229,6 +229,7 @@ impl Member {
         EventV1::ServerMemberLeave {
             id: self.id.server.to_string(),
             user: self.id.user.to_string(),
+            reason: intention.clone().into(),
         }
         .p(self.id.server.to_string())
         .await;
@@ -250,7 +251,7 @@ impl Member {
                 }
                 .into_message(id.to_string())
                 // TODO: support notifications here in the future?
-                .send_without_notifications(db, false, false)
+                .send_without_notifications(db, None, None, false, false, false)
                 .await
                 .ok();
             }

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

@@ -1,3 +1,4 @@
+use ::mongodb::SessionCursor;
 use revolt_result::Result;
 
 use crate::{FieldsMember, Member, MemberCompositeKey, PartialMember};
@@ -5,6 +6,66 @@ use crate::{FieldsMember, Member, MemberCompositeKey, PartialMember};
 mod mongodb;
 mod reference;
 
+#[derive(Debug)]
+pub enum ChunkedServerMembersGenerator {
+    #[cfg(feature = "mongodb")]
+    MongoDb {
+        session: ::mongodb::ClientSession,
+        cursor: Option<SessionCursor<Member>>,
+    },
+
+    Reference {
+        offset: i32,
+        data: Option<Vec<Member>>,
+    },
+}
+
+impl ChunkedServerMembersGenerator {
+    #[cfg(feature = "mongodb")]
+    pub fn new_mongo(session: ::mongodb::ClientSession, cursor: SessionCursor<Member>) -> Self {
+        ChunkedServerMembersGenerator::MongoDb {
+            session,
+            cursor: Some(cursor),
+        }
+    }
+
+    pub fn new_reference(data: Vec<Member>) -> Self {
+        ChunkedServerMembersGenerator::Reference {
+            offset: 0,
+            data: Some(data),
+        }
+    }
+
+    pub async fn next(&mut self) -> Option<Member> {
+        match self {
+            #[cfg(feature = "mongodb")]
+            ChunkedServerMembersGenerator::MongoDb { session, cursor } => {
+                if let Some(cursor) = cursor {
+                    let value = cursor.next(session).await;
+                    value.map(|val| val.expect("Failed to fetch the next member"))
+                } else {
+                    warn!("Attempted to access a (MongoDb) server member generator without first setting a cursor");
+                    None
+                }
+            }
+            ChunkedServerMembersGenerator::Reference { offset, data } => {
+                if let Some(data) = data {
+                    if data.len() as i32 >= *offset {
+                        None
+                    } else {
+                        let resp = &data[*offset as usize];
+                        *offset += 1;
+                        Some(resp.clone())
+                    }
+                } else {
+                    warn!("Attempted to access a (Reference) server member generator without first providing data");
+                    None
+                }
+            }
+        }
+    }
+}
+
 #[async_trait]
 pub trait AbstractServerMembers: Sync + Send {
     /// Insert a new server member into the database
@@ -16,6 +77,24 @@ pub trait AbstractServerMembers: Sync + Send {
     /// Fetch all members in a server
     async fn fetch_all_members<'a>(&self, server_id: &str) -> Result<Vec<Member>>;
 
+    /// Fetch all members in a server as an iterator
+    async fn fetch_all_members_chunked(
+        &self,
+        server_id: &str,
+    ) -> Result<ChunkedServerMembersGenerator>;
+
+    async fn fetch_all_members_with_roles(
+        &self,
+        server_id: &str,
+        roles: &[String],
+    ) -> Result<Vec<Member>>;
+
+    async fn fetch_all_members_with_roles_chunked(
+        &self,
+        server_id: &str,
+        roles: &[String],
+    ) -> Result<ChunkedServerMembersGenerator>;
+
     /// Fetch all memberships for a user
     async fn fetch_all_memberships<'a>(&self, user_id: &str) -> Result<Vec<Member>>;
 

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

@@ -1,10 +1,11 @@
 use futures::StreamExt;
+use mongodb::options::ReadConcern;
 use revolt_result::Result;
 
 use crate::{FieldsMember, Member, MemberCompositeKey, PartialMember};
 use crate::{IntoDocumentPath, MongoDb};
 
-use super::AbstractServerMembers;
+use super::{AbstractServerMembers, ChunkedServerMembersGenerator};
 
 static COL: &str = "server_members";
 
@@ -33,12 +34,9 @@ impl AbstractServerMembers for MongoDb {
     async fn fetch_all_members<'a>(&self, server_id: &str) -> Result<Vec<Member>> {
         Ok(self
             .col::<Member>(COL)
-            .find(
-                doc! {
-                    "_id.server": server_id
-                },
-                None,
-            )
+            .find(doc! {
+                "_id.server": server_id
+            })
             .await
             .map_err(|_| create_database_error!("find", COL))?
             .filter_map(|s| async {
@@ -52,16 +50,101 @@ impl AbstractServerMembers for MongoDb {
             .await)
     }
 
+    /// Fetch all members in a server as a generator.
+    /// Uses config key pushd.mass_mention_chunk_size as the batch size.
+    async fn fetch_all_members_chunked(
+        &self,
+        server_id: &str,
+    ) -> Result<ChunkedServerMembersGenerator> {
+        let config = revolt_config::config().await;
+
+        let mut session = self
+            .start_session()
+            .await
+            .map_err(|_| create_database_error!("start_session", COL))?;
+
+        session
+            .start_transaction()
+            .read_concern(ReadConcern::snapshot())
+            .await
+            .map_err(|_| create_database_error!("start_transaction", COL))?;
+
+        let cursor = self
+            .col::<Member>(COL)
+            .find(doc! {
+                "_id.server": server_id
+            })
+            .session(&mut session)
+            .batch_size(config.pushd.mass_mention_chunk_size as u32)
+            .await
+            .map_err(|_| create_database_error!("find", COL))?;
+
+        Ok(ChunkedServerMembersGenerator::new_mongo(session, cursor))
+    }
+
+    async fn fetch_all_members_with_roles(
+        &self,
+        server_id: &str,
+        roles: &[String],
+    ) -> Result<Vec<Member>> {
+        Ok(self
+            .col::<Member>(COL)
+            .find(doc! {
+                "_id.server": server_id,
+                "roles": {"$in": roles}
+            })
+            .await
+            .map_err(|_| create_database_error!("find", COL))?
+            .filter_map(|s| async {
+                if cfg!(debug_assertions) {
+                    Some(s.unwrap())
+                } else {
+                    s.ok()
+                }
+            })
+            .collect()
+            .await)
+    }
+
+    async fn fetch_all_members_with_roles_chunked(
+        &self,
+        server_id: &str,
+        roles: &[String],
+    ) -> Result<ChunkedServerMembersGenerator> {
+        let config = revolt_config::config().await;
+
+        let mut session = self
+            .start_session()
+            .await
+            .map_err(|_| create_database_error!("start_session", COL))?;
+
+        session
+            .start_transaction()
+            .read_concern(ReadConcern::snapshot())
+            .await
+            .map_err(|_| create_database_error!("start_transaction", COL))?;
+
+        let cursor = self
+            .col::<Member>(COL)
+            .find(doc! {
+                "_id.server": server_id,
+                "roles": {"$in": roles}
+            })
+            .session(&mut session)
+            .batch_size(config.pushd.mass_mention_chunk_size as u32)
+            .await
+            .map_err(|_| create_database_error!("find", COL))?;
+
+        return Ok(ChunkedServerMembersGenerator::new_mongo(session, cursor));
+    }
+
     /// Fetch all memberships for a user
     async fn fetch_all_memberships<'a>(&self, user_id: &str) -> Result<Vec<Member>> {
         Ok(self
             .col::<Member>(COL)
-            .find(
-                doc! {
-                    "_id.user": user_id
-                },
-                None,
-            )
+            .find(doc! {
+                "_id.user": user_id
+            })
             .await
             .map_err(|_| create_database_error!("find", COL))?
             .filter_map(|s| async {
@@ -79,15 +162,12 @@ impl AbstractServerMembers for MongoDb {
     async fn fetch_members<'a>(&self, server_id: &str, ids: &'a [String]) -> Result<Vec<Member>> {
         Ok(self
             .col::<Member>(COL)
-            .find(
-                doc! {
-                    "_id.server": server_id,
-                    "_id.user": {
-                        "$in": ids
-                    }
-                },
-                None,
-            )
+            .find(doc! {
+                "_id.server": server_id,
+                "_id.user": {
+                    "$in": ids
+                }
+            })
             .await
             .map_err(|_| create_database_error!("find", COL))?
             .filter_map(|s| async {
@@ -104,12 +184,9 @@ impl AbstractServerMembers for MongoDb {
     /// Fetch member count of a server
     async fn fetch_member_count(&self, server_id: &str) -> Result<usize> {
         self.col::<Member>(COL)
-            .count_documents(
-                doc! {
-                    "_id.server": server_id
-                },
-                None,
-            )
+            .count_documents(doc! {
+                "_id.server": server_id
+            })
             .await
             .map(|c| c as usize)
             .map_err(|_| create_database_error!("count_documents", COL))
@@ -118,12 +195,9 @@ impl AbstractServerMembers for MongoDb {
     /// Fetch server count of a user
     async fn fetch_server_count(&self, user_id: &str) -> Result<usize> {
         self.col::<Member>(COL)
-            .count_documents(
-                doc! {
-                    "_id.user": user_id
-                },
-                None,
-            )
+            .count_documents(doc! {
+                "_id.user": user_id
+            })
             .await
             .map(|c| c as usize)
             .map_err(|_| create_database_error!("count_documents", COL))

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

@@ -3,7 +3,7 @@ use revolt_result::Result;
 use crate::ReferenceDb;
 use crate::{FieldsMember, Member, MemberCompositeKey, PartialMember};
 
-use super::AbstractServerMembers;
+use super::{AbstractServerMembers, ChunkedServerMembersGenerator};
 
 #[async_trait]
 impl AbstractServerMembers for ReferenceDb {
@@ -40,6 +40,70 @@ impl AbstractServerMembers for ReferenceDb {
             .collect())
     }
 
+    /// Fetch all members in a server as an iterator
+    async fn fetch_all_members_chunked(
+        &self,
+        server_id: &str,
+    ) -> Result<ChunkedServerMembersGenerator> {
+        let server_members = self.server_members.lock().await;
+
+        let members = server_members
+            .clone()
+            .into_values()
+            .filter(move |member| member.id.server == server_id)
+            .collect();
+
+        // this is inefficient as shit but its the reference db so its fine
+        Ok(ChunkedServerMembersGenerator::new_reference(members))
+    }
+
+    /// Fetch all members that have any of the roles given
+    async fn fetch_all_members_with_roles(
+        &self,
+        server_id: &str,
+        roles: &[String],
+    ) -> Result<Vec<Member>> {
+        let server_members = self.server_members.lock().await;
+
+        Ok(server_members
+            .clone()
+            .into_values()
+            .filter(|member| {
+                member.id.server == server_id
+                    && !member
+                        .roles
+                        .iter()
+                        .filter(|p| roles.contains(*p))
+                        .collect::<Vec<&String>>()
+                        .is_empty()
+            })
+            .collect())
+    }
+
+    async fn fetch_all_members_with_roles_chunked(
+        &self,
+        server_id: &str,
+        roles: &[String],
+    ) -> Result<ChunkedServerMembersGenerator> {
+        let server_members = self.server_members.lock().await;
+
+        let resp = server_members
+            .clone()
+            .into_values()
+            .filter(|member| {
+                member.id.server == server_id
+                    && !member
+                        .roles
+                        .iter()
+                        .filter(|p| roles.contains(*p))
+                        .collect::<Vec<&String>>()
+                        .is_empty()
+            })
+            .collect();
+
+        return Ok(ChunkedServerMembersGenerator::new_reference(resp));
+    }
+
     /// Fetch all memberships for a user
     async fn fetch_all_memberships<'a>(&self, user_id: &str) -> Result<Vec<Member>> {
         let server_members = self.server_members.lock().await;
@@ -53,17 +117,17 @@ impl AbstractServerMembers for ReferenceDb {
     /// Fetch multiple members by their ids
     async fn fetch_members<'a>(&self, server_id: &str, ids: &'a [String]) -> Result<Vec<Member>> {
         let server_members = self.server_members.lock().await;
-        ids.iter()
-            .map(|id| {
+        Ok(ids
+            .iter()
+            .filter_map(|id| {
                 server_members
                     .get(&MemberCompositeKey {
                         server: server_id.to_string(),
                         user: id.to_string(),
                     })
                     .cloned()
-                    .ok_or_else(|| create_error!(NotFound))
             })
-            .collect()
+            .collect())
     }
 
     /// Fetch member count of a server

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

@@ -175,7 +175,7 @@ impl Server {
             vec![]
         };
 
-        server.channels = channels.iter().map(|c| c.id()).collect();
+        server.channels = channels.iter().map(|c| c.id().to_string()).collect();
         db.insert_server(&server).await?;
         Ok((server, channels))
     }
@@ -285,7 +285,7 @@ impl Role {
     }
 
     /// Update server data
-    pub async fn update<'a>(
+    pub async fn update(
         &mut self,
         db: &Database,
         server_id: &str,

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

@@ -25,14 +25,11 @@ impl AbstractServers for MongoDb {
     async fn fetch_servers<'a>(&self, ids: &'a [String]) -> Result<Vec<Server>> {
         Ok(self
             .col::<Server>(COL)
-            .find(
-                doc! {
-                    "_id": {
-                        "$in": ids
-                    }
-                },
-                None,
-            )
+            .find(doc! {
+                "_id": {
+                    "$in": ids
+                }
+            })
             .await
             .map_err(|_| create_database_error!("find", "servers"))?
             .filter_map(|s| async {
@@ -84,7 +81,6 @@ impl AbstractServers for MongoDb {
                             .map_err(|_| create_database_error!("to_document", "role"))?
                     }
                 },
-                None,
             )
             .await
             .map(|_| ())
@@ -125,7 +121,6 @@ impl AbstractServers for MongoDb {
                         "roles": &role_id
                     }
                 },
-                None,
             )
             .await
             .map_err(|_| create_database_error!("update_many", "server_members"))?;
@@ -140,7 +135,6 @@ impl AbstractServers for MongoDb {
                         "role_permissions.".to_owned() + role_id: 1_i32
                     }
                 },
-                None,
             )
             .await
             .map_err(|_| create_database_error!("update_one", "channels"))?;
@@ -155,7 +149,6 @@ impl AbstractServers for MongoDb {
                         "roles.".to_owned() + role_id: 1_i32
                     }
                 },
-                None,
             )
             .await
             .map(|_| ())
@@ -188,12 +181,9 @@ impl MongoDb {
         // Find all channels
         let channels: Vec<String> = self
             .col::<Document>("channels")
-            .find(
-                doc! {
-                    "server": server_id
-                },
-                None,
-            )
+            .find(doc! {
+                "server": server_id
+            })
             .await
             .map_err(|_| create_database_error!("find", "channels"))?
             .filter_map(|s| async {
@@ -214,23 +204,26 @@ impl MongoDb {
 
         // Delete all emoji.
         self.col::<Document>("emojis")
-            .delete_many(
+            .update_many(
                 doc! {
                     "parent.id": &server_id
                 },
-                None,
+                doc! {
+                    "$set": {
+                        "parent": {
+                            "type": "Detached"
+                        }
+                    }
+                },
             )
             .await
-            .map_err(|_| create_database_error!("delete_many", "emojis"))?;
+            .map_err(|_| create_database_error!("update_many", "emojis"))?;
 
         // Delete all channels.
         self.col::<Document>("channels")
-            .delete_many(
-                doc! {
-                    "server": &server_id
-                },
-                None,
-            )
+            .delete_many(doc! {
+                "server": &server_id
+            })
             .await
             .map_err(|_| create_database_error!("delete_many", "channels"))?;
 
@@ -241,19 +234,16 @@ impl MongoDb {
         // Delete members and bans.
         for with in &["server_members", "server_bans"] {
             self.col::<Document>(with)
-                .delete_many(
-                    doc! {
-                        "_id.server": &server_id
-                    },
-                    None,
-                )
+                .delete_many(doc! {
+                    "_id.server": &server_id
+                })
                 .await
                 .map_err(|_| create_database_error!("delete_many", with))?;
         }
 
         // Update many attachments with parent id.
         self.delete_many_attachments(doc! {
-            "object_id": &server_id
+            "used_for.id": &server_id
         })
         .await?;
 

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

@@ -53,8 +53,8 @@ impl AbstractUserSettings for MongoDb {
                 doc! {
                     "$set": set
                 },
-                UpdateOptions::builder().upsert(true).build(),
             )
+            .with_options(UpdateOptions::builder().upsert(true).build())
             .await
             .map(|_| ())
             .map_err(|_| create_database_error!("update_one", "user_settings"))

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

@@ -0,0 +1,24 @@
+use axum::{extract::FromRequestParts, http::request::Parts};
+
+use revolt_result::{create_error, Error, Result};
+
+use crate::{Database, User};
+
+#[async_trait::async_trait]
+impl FromRequestParts<Database> for User {
+    type Rejection = Error;
+
+    async fn from_request_parts(parts: &mut Parts, db: &Database) -> Result<User> {
+        if let Some(Ok(bot_token)) = parts.headers.get("x-bot-token").map(|v| v.to_str()) {
+            let bot = db.fetch_bot_by_token(bot_token).await?;
+            db.fetch_user(&bot.id).await
+        } else if let Some(Ok(session_token)) =
+            parts.headers.get("x-session-token").map(|v| v.to_str())
+        {
+            let session = db.fetch_session_by_token(session_token).await?;
+            db.fetch_user(&session.user_id).await
+        } else {
+            Err(create_error!(NotAuthenticated))
+        }
+    }
+}

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

@@ -1,3 +1,5 @@
+#[cfg(feature = "axum-impl")]
+mod axum;
 mod model;
 mod ops;
 #[cfg(feature = "rocket-impl")]
@@ -5,6 +7,8 @@ mod rocket;
 #[cfg(feature = "rocket-impl")]
 mod schema;
 
+#[cfg(feature = "axum-impl")]
+pub use self::axum::*;
 #[cfg(feature = "rocket-impl")]
 pub use self::rocket::*;
 #[cfg(feature = "rocket-impl")]

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

@@ -1,13 +1,17 @@
-use std::{collections::HashSet, time::Duration};
+use std::{collections::HashSet, str::FromStr, time::Duration};
 
-use crate::{events::client::EventV1, Database, File, RatelimitEvent};
+use crate::{events::client::EventV1, Database, File, RatelimitEvent, AMQP};
 
+use authifier::config::{EmailVerificationConfig, Template};
+use futures::future::join_all;
+use iso8601_timestamp::Timestamp;
 use once_cell::sync::Lazy;
 use rand::seq::SliceRandom;
-use revolt_config::config;
-use revolt_models::v0;
+use revolt_config::{config, FeaturesLimits};
+use revolt_models::v0::{self, UserBadges, UserFlags};
 use revolt_presence::filter_online;
 use revolt_result::{create_error, Result};
+use serde_json::json;
 use ulid::Ulid;
 
 auto_derived_partial!(
@@ -49,6 +53,12 @@ auto_derived_partial!(
         /// Bot information
         #[serde(skip_serializing_if = "Option::is_none")]
         pub bot: Option<BotInformation>,
+
+        /// Time until user is unsuspended
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub suspended_until: Option<Timestamp>,
+        /// Last acknowledged policy change
+        pub last_acknowledged_policy_change: Timestamp,
     },
     "PartialUser"
 );
@@ -61,6 +71,11 @@ auto_derived!(
         StatusPresence,
         ProfileContent,
         ProfileBackground,
+        DisplayName,
+
+        // internal fields
+        Suspension,
+        None,
     }
 
     /// User's relationship with another user (or themselves)
@@ -140,7 +155,7 @@ pub static DISCRIMINATOR_SEARCH_SPACE: Lazy<HashSet<String>> = Lazy::new(|| {
         .collect::<HashSet<String>>();
 
     for discrim in [
-        123, 1234, 1111, 2222, 3333, 4444, 5555, 6666, 7777, 8888, 9999,
+        123, 1234, 1111, 2222, 3333, 4444, 5555, 6666, 7777, 8888, 9999, 1488,
     ] {
         set.remove(&format!("{:0>4}", discrim));
     }
@@ -164,6 +179,8 @@ impl Default for User {
             flags: Default::default(),
             privileged: Default::default(),
             bot: Default::default(),
+            suspended_until: Default::default(),
+            last_acknowledged_policy_change: Timestamp::UNIX_EPOCH,
         }
     }
 }
@@ -186,6 +203,7 @@ impl User {
             id: account_id.into().unwrap_or_else(|| Ulid::new().to_string()),
             discriminator: User::find_discriminator(db, &username, None).await?,
             username,
+            last_acknowledged_policy_change: Timestamp::now_utc(),
             ..Default::default()
         };
 
@@ -197,6 +215,22 @@ impl User {
         Ok(user)
     }
 
+    /// Get limits for this user
+    pub async fn limits(&self) -> FeaturesLimits {
+        let config = config().await;
+        if ulid::Ulid::from_str(&self.id)
+            .expect("`ulid`")
+            .datetime()
+            .elapsed()
+            .expect("time went backwards")
+            <= Duration::from_secs(3600u64 * config.features.limits.global.new_user_hours as u64)
+        {
+            config.features.limits.new_user
+        } else {
+            config.features.limits.default
+        }
+    }
+
     /// Get the relationship with another user
     pub fn relationship_with(&self, user_b: &str) -> RelationshipStatus {
         if self.id == user_b {
@@ -235,12 +269,11 @@ impl User {
 
     /// Check if this user can acquire another server
     pub async fn can_acquire_server(&self, db: &Database) -> Result<()> {
-        let config = config().await;
-        if db.fetch_server_count(&self.id).await? <= config.features.limits.default.servers {
+        if db.fetch_server_count(&self.id).await? <= self.limits().await.servers {
             Ok(())
         } else {
             Err(create_error!(TooManyServers {
-                max: config.features.limits.default.servers
+                max: self.limits().await.servers
             }))
         }
     }
@@ -265,7 +298,14 @@ impl User {
         }
 
         // Ensure none of the following substrings show up in the username
-        const BLOCKED_SUBSTRINGS: &[&str] = &["```"];
+        const BLOCKED_SUBSTRINGS: &[&str] = &[
+            "```",
+            "discord.gg",
+            "rvlt.gg",
+            "guilded.gg",
+            "https://",
+            "http://",
+        ];
 
         for substr in BLOCKED_SUBSTRINGS {
             if username_lowercase.contains(substr) {
@@ -276,23 +316,27 @@ impl User {
         Ok(username)
     }
 
-    /// Find a user from a given token and hint
+    /// Find a user and session ID from a given token and hint
     #[async_recursion]
-    pub async fn from_token(db: &Database, token: &str, hint: UserHint) -> Result<User> {
+    pub async fn from_token(db: &Database, token: &str, hint: UserHint) -> Result<(User, String)> {
         match hint {
-            UserHint::Bot => {
+            UserHint::Bot => Ok((
                 db.fetch_user(
                     &db.fetch_bot_by_token(token)
                         .await
                         .map_err(|_| create_error!(InvalidSession))?
                         .id,
                 )
-                .await
+                .await?,
+                String::new(),
+            )),
+            UserHint::User => {
+                let session = db.fetch_session_by_token(token).await?;
+                Ok((db.fetch_user(&session.user_id).await?, session.id))
             }
-            UserHint::User => db.fetch_user_by_token(token).await,
             UserHint::Any => {
-                if let Ok(user) = User::from_token(db, token, UserHint::User).await {
-                    Ok(user)
+                if let Ok(result) = User::from_token(db, token, UserHint::User).await {
+                    Ok(result)
                 } else {
                     User::from_token(db, token, UserHint::Bot).await
                 }
@@ -309,15 +353,13 @@ impl User {
     ) -> Result<Vec<v0::User>> {
         let online_ids = filter_online(ids).await;
 
-        Ok(db
-            .fetch_users(ids)
-            .await?
-            .into_iter()
-            .map(|user| {
+        Ok(
+            join_all(db.fetch_users(ids).await?.into_iter().map(|user| async {
                 let is_online = online_ids.contains(&user.id);
-                user.into_known(perspective, is_online)
-            })
-            .collect())
+                user.into_known(perspective, is_online).await
+            }))
+            .await,
+        )
     }
 
     /// Find a free discriminator for a given username
@@ -465,7 +507,12 @@ impl User {
     }
 
     /// Add another user as a friend
-    pub async fn add_friend(&mut self, db: &Database, target: &mut User) -> Result<()> {
+    pub async fn add_friend(
+        &mut self,
+        db: &Database,
+        amqp: &AMQP,
+        target: &mut User,
+    ) -> Result<()> {
         match self.relationship_with(&target.id) {
             RelationshipStatus::User => Err(create_error!(NoEffect)),
             RelationshipStatus::Friend => Err(create_error!(AlreadyFriends)),
@@ -473,6 +520,9 @@ impl User {
             RelationshipStatus::Blocked => Err(create_error!(Blocked)),
             RelationshipStatus::BlockedOther => Err(create_error!(BlockedByOther)),
             RelationshipStatus::Incoming => {
+                // Accept incoming friend request
+                _ = amqp.friend_request_accepted(self, target).await;
+
                 self.apply_relationship(
                     db,
                     target,
@@ -482,6 +532,28 @@ impl User {
                 .await
             }
             RelationshipStatus::None => {
+                // Get this user's current count of outgoing friend requests
+                let count = self
+                    .relations
+                    .as_ref()
+                    .map(|relations| {
+                        relations
+                            .iter()
+                            .filter(|r| matches!(r.status, RelationshipStatus::Outgoing))
+                            .count()
+                    })
+                    .unwrap_or_default();
+
+                // If we're over the limit, don't allow creating more requests
+                if count >= self.limits().await.outgoing_friend_requests {
+                    return Err(create_error!(TooManyPendingFriendRequests {
+                        max: self.limits().await.outgoing_friend_requests
+                    }));
+                }
+
+                _ = amqp.friend_request_received(target, self).await;
+
+                // Send the friend request
                 self.apply_relationship(
                     db,
                     target,
@@ -568,7 +640,7 @@ impl User {
     }
 
     /// Update user data
-    pub async fn update<'a>(
+    pub async fn update(
         &mut self,
         db: &Database,
         partial: PartialUser,
@@ -617,9 +689,107 @@ impl User {
                     x.background = None;
                 }
             }
+            FieldsUser::DisplayName => self.display_name = None,
+            FieldsUser::Suspension => self.suspended_until = None,
+            FieldsUser::None => {}
         }
     }
 
+    /// Suspend the user
+    ///
+    /// - If a duration is specified, the user will be automatically unsuspended after the given time.
+    /// - If a reason is specified, an email will be sent.
+    pub async fn suspend(
+        &mut self,
+        db: &Database,
+        duration_days: Option<usize>,
+        reason: Option<Vec<String>>,
+    ) -> Result<()> {
+        let authifier = db.clone().to_authifier().await;
+        let mut account = authifier
+            .database
+            .find_account(&self.id)
+            .await
+            .map_err(|_| create_error!(InternalError))?;
+
+        account
+            .disable(&authifier)
+            .await
+            .map_err(|_| create_error!(InternalError))?;
+
+        account
+            .delete_all_sessions(&authifier, None)
+            .await
+            .map_err(|_| create_error!(InternalError))?;
+
+        self.update(
+            db,
+            PartialUser {
+                flags: Some(UserFlags::SuspendedUntil as i32),
+                suspended_until: duration_days.and_then(|dur| {
+                    Timestamp::now_utc().checked_add(iso8601_timestamp::Duration::days(dur as i64))
+                }),
+                ..Default::default()
+            },
+            vec![],
+        )
+        .await?;
+
+        if let Some(reason) = reason {
+            if let EmailVerificationConfig::Enabled { smtp, .. } =
+                authifier.config.email_verification
+            {
+                smtp.send_email(
+                    account.email.clone(),
+                    // maybe move this to common area?
+                    &Template {
+                        title: "Account Suspension".to_string(),
+                        html: Some(include_str!("../../../templates/suspension.html").to_owned()),
+                        text: include_str!("../../../templates/suspension.txt").to_owned(),
+                        url: Default::default(),
+                    },
+                    json!({
+                        "email": account.email,
+                        "list": reason.join(", "),
+                        "duration": duration_days,
+                        "duration_display": if duration_days.is_some() {
+                            "block"
+                        } else {
+                            "none"
+                        }
+                    }),
+                )
+                .map_err(|_| create_error!(InternalError))?;
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Unsuspend the user
+    pub async fn unsuspend(&mut self, db: &Database) -> Result<()> {
+        self.update(
+            db,
+            PartialUser {
+                flags: Some(0),
+                suspended_until: None,
+                ..Default::default()
+            },
+            vec![],
+        )
+        .await?;
+
+        unimplemented!()
+    }
+
+    /// Permanently ban the user
+    ///
+    /// - If a reason is specified, an email will be sent.
+    pub async fn ban(&mut self, _db: &Database, _reason: Option<String>) -> Result<()> {
+        // Send ban email (if reason provided)
+        unimplemented!()
+    }
+
     /// Mark as deleted
     pub async fn mark_deleted(&mut self, db: &Database) -> Result<()> {
         self.update(
@@ -635,8 +805,23 @@ impl User {
                 FieldsUser::StatusPresence,
                 FieldsUser::ProfileContent,
                 FieldsUser::ProfileBackground,
+                FieldsUser::Suspension,
             ],
         )
         .await
     }
+
+    /// Gets the user's badges along with calculating any dynamic badges
+    pub async fn get_badges(&self) -> u32 {
+        let config = config().await;
+        let badges = self.badges.unwrap_or_default() as u32;
+
+        if let Some(cutoff) = config.api.users.early_adopter_cutoff {
+            if Ulid::from_string(&self.id).unwrap().timestamp_ms() < cutoff {
+                return badges + UserBadges::EarlyAdopter as u32;
+            };
+        };
+
+        badges
+    }
 }

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

@@ -1,3 +1,4 @@
+use authifier::models::Session;
 use revolt_result::Result;
 
 use crate::{FieldsUser, PartialUser, RelationshipStatus, User};
@@ -16,8 +17,8 @@ pub trait AbstractUsers: Sync + Send {
     /// Fetch a user from the database by their username
     async fn fetch_user_by_username(&self, username: &str, discriminator: &str) -> Result<User>;
 
-    /// Fetch a user from the database by their session token
-    async fn fetch_user_by_token(&self, token: &str) -> Result<User>;
+    /// Fetch a session from the database by token
+    async fn fetch_session_by_token(&self, token: &str) -> Result<Session>;
 
     /// Fetch multiple users by their ids
     async fn fetch_users<'a>(&self, ids: &'a [String]) -> Result<Vec<User>>;
@@ -57,4 +58,7 @@ pub trait AbstractUsers: Sync + Send {
 
     /// Delete a user by their id
     async fn delete_user(&self, id: &str) -> Result<()>;
+
+    /// Remove push subscription for a session by session id (TODO: remove)
+    async fn remove_push_subscription_by_session_id(&self, session_id: &str) -> Result<()>;
 }

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

@@ -46,35 +46,26 @@ impl AbstractUsers for MongoDb {
         .ok_or_else(|| create_error!(NotFound))
     }
 
-    /// Fetch a user from the database by their session token
-    async fn fetch_user_by_token(&self, token: &str) -> Result<User> {
-        let session = self
-            .col::<Session>("sessions")
-            .find_one(
-                doc! {
-                    "token": token
-                },
-                None,
-            )
+    /// Fetch a session from the database by token
+    async fn fetch_session_by_token(&self, token: &str) -> Result<Session> {
+        self.col::<Session>("sessions")
+            .find_one(doc! {
+                "token": token
+            })
             .await
             .map_err(|_| create_database_error!("find_one", "sessions"))?
-            .ok_or_else(|| create_error!(InvalidSession))?;
-
-        self.fetch_user(&session.user_id).await
+            .ok_or_else(|| create_error!(InvalidSession))
     }
 
     /// Fetch multiple users by their ids
     async fn fetch_users<'a>(&self, ids: &'a [String]) -> Result<Vec<User>> {
         Ok(self
             .col::<User>(COL)
-            .find(
-                doc! {
-                    "_id": {
-                        "$in": ids
-                    }
-                },
-                None,
-            )
+            .find(doc! {
+                "_id": {
+                    "$in": ids
+                }
+            })
             .await
             .map_err(|_| create_database_error!("find", COL))?
             .filter_map(|s| async {
@@ -97,10 +88,10 @@ impl AbstractUsers for MongoDb {
 
         Ok(self
             .col::<UserDocument>(COL)
-            .find(
-                doc! {
-                    "username": username
-                },
+            .find(doc! {
+                "username": username
+            })
+            .with_options(
                 FindOptions::builder()
                     .collation(
                         Collation::builder()
@@ -125,15 +116,13 @@ impl AbstractUsers for MongoDb {
     async fn fetch_mutual_user_ids(&self, user_a: &str, user_b: &str) -> Result<Vec<String>> {
         Ok(self
             .col::<DocumentId>(COL)
-            .find(
-                doc! {
-                    "$and": [
-                        { "relations": { "$elemMatch": { "_id": &user_a, "status": "Friend" } } },
-                        { "relations": { "$elemMatch": { "_id": &user_b, "status": "Friend" } } }
-                    ]
-                },
-                FindOptions::builder().projection(doc! { "_id": 1 }).build(),
-            )
+            .find(doc! {
+                "$and": [
+                    { "relations": { "$elemMatch": { "_id": &user_a, "status": "Friend" } } },
+                    { "relations": { "$elemMatch": { "_id": &user_b, "status": "Friend" } } }
+                ]
+            })
+            .with_options(FindOptions::builder().projection(doc! { "_id": 1 }).build())
             .await
             .map_err(|_| create_database_error!("find", COL))?
             .filter_map(|s| async { s.ok() })
@@ -146,17 +135,15 @@ impl AbstractUsers for MongoDb {
     async fn fetch_mutual_channel_ids(&self, user_a: &str, user_b: &str) -> Result<Vec<String>> {
         Ok(self
             .col::<DocumentId>("channels")
-            .find(
-                doc! {
-                    "channel_type": {
-                        "$in": ["Group", "DirectMessage"]
-                    },
-                    "recipients": {
-                        "$all": [ user_a, user_b ]
-                    }
+            .find(doc! {
+                "channel_type": {
+                    "$in": ["Group", "DirectMessage"]
                 },
-                FindOptions::builder().projection(doc! { "_id": 1 }).build(),
-            )
+                "recipients": {
+                    "$all": [ user_a, user_b ]
+                }
+            })
+            .with_options(FindOptions::builder().projection(doc! { "_id": 1 }).build())
             .await
             .map_err(|_| create_database_error!("find", "channels"))?
             .filter_map(|s| async { s.ok() })
@@ -169,49 +156,46 @@ impl AbstractUsers for MongoDb {
     async fn fetch_mutual_server_ids(&self, user_a: &str, user_b: &str) -> Result<Vec<String>> {
         Ok(self
             .col::<DocumentId>("server_members")
-            .aggregate(
-                vec![
-                    doc! {
-                        "$match": {
-                            "_id.user": user_a
-                        }
-                    },
-                    doc! {
-                        "$lookup": {
-                            "from": "server_members",
-                            "as": "members",
-                            "let": {
-                                "server": "$_id.server"
-                            },
-                            "pipeline": [
-                                {
-                                    "$match": {
-                                        "$expr": {
-                                            "$and": [
-                                                { "$eq": [ "$_id.user", user_b ] },
-                                                { "$eq": [ "$_id.server", "$$server" ] }
-                                            ]
-                                        }
+            .aggregate(vec![
+                doc! {
+                    "$match": {
+                        "_id.user": user_a
+                    }
+                },
+                doc! {
+                    "$lookup": {
+                        "from": "server_members",
+                        "as": "members",
+                        "let": {
+                            "server": "$_id.server"
+                        },
+                        "pipeline": [
+                            {
+                                "$match": {
+                                    "$expr": {
+                                        "$and": [
+                                            { "$eq": [ "$_id.user", user_b ] },
+                                            { "$eq": [ "$_id.server", "$$server" ] }
+                                        ]
                                     }
                                 }
-                            ]
-                        }
-                    },
-                    doc! {
-                        "$match": {
-                            "members": {
-                                "$size": 1_i32
                             }
+                        ]
+                    }
+                },
+                doc! {
+                    "$match": {
+                        "members": {
+                            "$size": 1_i32
                         }
-                    },
-                    doc! {
-                        "$project": {
-                            "_id": "$_id.server"
-                        }
-                    },
-                ],
-                None,
-            )
+                    }
+                },
+                doc! {
+                    "$project": {
+                        "_id": "$_id.server"
+                    }
+                },
+            ])
             .await
             .map_err(|_| create_database_error!("aggregate", "server_members"))?
             .filter_map(|s| async { s.ok() })
@@ -287,7 +271,6 @@ impl AbstractUsers for MongoDb {
                         }
                     }
                 }],
-                None,
             )
             .await
             .map(|_| ())
@@ -308,7 +291,6 @@ impl AbstractUsers for MongoDb {
                         }
                     }
                 },
-                None,
             )
             .await
             .map(|_| ())
@@ -319,6 +301,24 @@ impl AbstractUsers for MongoDb {
     async fn delete_user(&self, id: &str) -> Result<()> {
         query!(self, delete_one_by_id, COL, id).map(|_| ())
     }
+
+    /// Remove push subscription for a session by session id (TODO: remove)
+    async fn remove_push_subscription_by_session_id(&self, session_id: &str) -> Result<()> {
+        self.col::<User>("sessions")
+            .update_one(
+                doc! {
+                    "_id": session_id
+                },
+                doc! {
+                    "$unset": {
+                        "subscription": 1
+                    }
+                },
+            )
+            .await
+            .map(|_| ())
+            .map_err(|_| create_database_error!("update_one", COL))
+    }
 }
 
 impl IntoDocumentPath for FieldsUser {
@@ -329,6 +329,9 @@ impl IntoDocumentPath for FieldsUser {
             FieldsUser::ProfileContent => "profile.content",
             FieldsUser::StatusPresence => "status.presence",
             FieldsUser::StatusText => "status.text",
+            FieldsUser::DisplayName => "display_name",
+            FieldsUser::Suspension => "suspended_until",
+            FieldsUser::None => "none",
         })
     }
 }

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

@@ -1,3 +1,4 @@
+use authifier::models::Session;
 use revolt_result::Result;
 
 use crate::{FieldsUser, PartialUser, RelationshipStatus, User};
@@ -40,8 +41,8 @@ impl AbstractUsers for ReferenceDb {
             .ok_or_else(|| create_error!(NotFound))
     }
 
-    /// Fetch a user from the database by their session token
-    async fn fetch_user_by_token(&self, _token: &str) -> Result<User> {
+    /// Fetch a session from the database by token
+    async fn fetch_session_by_token(&self, _token: &str) -> Result<Session> {
         todo!()
     }
 
@@ -162,4 +163,9 @@ impl AbstractUsers for ReferenceDb {
             Err(create_error!(NotFound))
         }
     }
+
+    /// Remove push subscription for a session by session id (TODO: remove)
+    async fn remove_push_subscription_by_session_id(&self, _session_id: &str) -> Result<()> {
+        todo!()
+    }
 }

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

@@ -38,7 +38,7 @@ impl<'r> FromRequest<'r> for User {
         if let Some(user) = user {
             Outcome::Success(user.clone())
         } else {
-            Outcome::Failure((Status::Unauthorized, authifier::Error::InvalidSession))
+            Outcome::Error((Status::Unauthorized, authifier::Error::InvalidSession))
         }
     }
 }

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

@@ -6,7 +6,7 @@ use revolt_rocket_okapi::{
 
 use crate::User;
 
-impl<'r> OpenApiFromRequest<'r> for User {
+impl OpenApiFromRequest<'_> for User {
     fn from_request_input(
         _gen: &mut OpenApiGenerator,
         _name: String,

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

@@ -1,19 +1,28 @@
 // Queue Type: Debounced
-use crate::Database;
+use crate::{Database, Message, AMQP};
 
 use deadqueue::limited::Queue;
 use once_cell::sync::Lazy;
-use std::{collections::HashMap, time::Duration};
+use revolt_config::capture_message;
+use revolt_models::v0::PushNotification;
+use std::{
+    collections::{HashMap, HashSet},
+    time::Duration,
+};
+use validator::HasLen;
+
+use revolt_result::Result;
 
 use super::DelayedTask;
+use crate::Channel::{TextChannel, VoiceChannel};
 
 /// Enumeration of possible events
 #[derive(Debug, Eq, PartialEq)]
 pub enum AckEvent {
-    /// Add mentions for a user in a channel
-    AddMention {
-        /// Message IDs
-        ids: Vec<String>,
+    /// Add mentions for a channel
+    ProcessMessage {
+        /// push notification, message, recipients, push silenced
+        messages: Vec<(Option<PushNotification>, Message, Vec<String>, bool)>,
     },
 
     /// Acknowledge message in a channel for a user
@@ -28,7 +37,7 @@ struct Data {
     /// Channel to ack
     channel: String,
     /// User to ack for
-    user: String,
+    user: Option<String>,
     /// Event
     event: AckEvent,
 }
@@ -41,21 +50,170 @@ struct Task {
 static Q: Lazy<Queue<Data>> = Lazy::new(|| Queue::new(10_000));
 
 /// Queue a new task for a worker
-pub async fn queue(channel: String, user: String, event: AckEvent) {
+pub async fn queue_ack(channel: String, user: String, event: AckEvent) {
     Q.try_push(Data {
         channel,
-        user,
+        user: Some(user),
         event,
     })
     .ok();
 
-    info!("Queue is using {} slots from {}.", Q.len(), Q.capacity());
+    info!(
+        "Queue is using {} slots from {}. Queued type: ACK",
+        Q.len(),
+        Q.capacity()
+    );
+}
+
+/// Do not add more than one message per event.
+pub async fn queue_message(channel: String, event: AckEvent) {
+    Q.try_push(Data {
+        channel,
+        user: None,
+        event,
+    })
+    .ok();
+
+    info!(
+        "Queue is using {} slots from {}. Queued type: MENTION",
+        Q.len(),
+        Q.capacity()
+    );
+}
+
+pub async fn handle_ack_event(
+    event: &AckEvent,
+    db: &Database,
+    amqp: &AMQP,
+    user: &Option<String>,
+    channel: &str,
+) -> Result<()> {
+    match &event {
+        #[allow(clippy::disallowed_methods)] // event is sent by higher level function
+        AckEvent::AckMessage { id } => {
+            let user = user.as_ref().unwrap();
+            let user: &str = user.as_str();
+
+            let unread = db.fetch_unread(user, channel).await?;
+            let updated = db.acknowledge_message(channel, user, id).await?;
+
+            if let (Some(before), Some(after)) = (unread, updated) {
+                let before_mentions = before.mentions.unwrap_or_default().len();
+                let after_mentions = after.mentions.unwrap_or_default().len();
+
+                let mentions_acked = before_mentions - after_mentions;
+
+                if mentions_acked > 0 {
+                    if let Err(err) = amqp
+                        .ack_message(user.to_string(), channel.to_string(), id.to_owned())
+                        .await
+                    {
+                        revolt_config::capture_error(&err);
+                    }
+                };
+            }
+        }
+        AckEvent::ProcessMessage { messages } => {
+            let mut users: HashSet<&String> = HashSet::new();
+            info!(
+                "Processing {} messages from channel {}",
+                messages.len(),
+                messages[0].1.channel
+            );
+
+            // find all the users we'll be notifying
+            messages.iter().for_each(|(_, _, recipents, _)| {
+                users.extend(recipents.iter());
+            });
+
+            info!("Found {} users to notify.", users.len());
+
+            for user in users {
+                let message_ids: Vec<String> = messages
+                    .iter()
+                    .filter_map(|(_, message, recipients, _)| {
+                        if recipients.contains(user) {
+                            Some(message.id.clone())
+                        } else {
+                            None
+                        }
+                    })
+                    .collect();
+
+                if !message_ids.is_empty() {
+                    db.add_mention_to_unread(channel, user, &message_ids)
+                        .await?;
+                }
+                info!("Added {} mentions for user {}", message_ids.len(), &user);
+            }
+
+            let mut mass_mentions = vec![];
+
+            for (push, message, recipients, silenced) in messages {
+                if *silenced
+                    || push.is_none()
+                    || (recipients.is_empty() && !message.contains_mass_push_mention())
+                {
+                    debug!(
+                        "Rejecting push: silenced: {}, recipient count: {}, push exists: {:?}",
+                        *silenced,
+                        recipients.length(),
+                        push.is_some()
+                    );
+                    continue;
+                }
+
+                debug!(
+                    "Sending push event to AMQP; message {} for {} users",
+                    push.as_ref().unwrap().message.id,
+                    recipients.len()
+                );
+                if let Err(err) = amqp
+                    .message_sent(recipients.clone(), push.clone().unwrap())
+                    .await
+                {
+                    revolt_config::capture_error(&err);
+                }
+
+                if message.contains_mass_push_mention() {
+                    mass_mentions.push(push.clone().unwrap());
+                }
+            }
+
+            if !mass_mentions.is_empty() {
+                debug!(
+                    "Sending mass mention push event to AMQP; channel {}",
+                    &mass_mentions[0].message.channel
+                );
+
+                let channel = db
+                    .fetch_channel(&mass_mentions[0].message.channel)
+                    .await
+                    .expect("Failed to fetch channel from db");
+
+                match channel {
+                    TextChannel { server, .. } | VoiceChannel { server, .. } => {
+                        if let Err(err) =
+                            amqp.mass_mention_message_sent(server, mass_mentions).await
+                        {
+                            revolt_config::capture_error(&err);
+                        }
+                    }
+                    _ => {
+                        panic!("Unknown channel type when sending mass mention event");
+                    }
+                }
+            }
+        }
+    };
+
+    Ok(())
 }
 
 /// Start a new worker
-pub async fn worker(db: Database) {
-    let mut tasks = HashMap::<(String, String), DelayedTask<Task>>::new();
-    let mut keys = vec![];
+pub async fn worker(db: Database, amqp: AMQP) {
+    let mut tasks = HashMap::<(Option<String>, String, u8), DelayedTask<Task>>::new();
+    let mut keys: Vec<(Option<String>, String, u8)> = vec![];
 
     loop {
         // Find due tasks.
@@ -69,18 +227,13 @@ pub async fn worker(db: Database) {
         for key in &keys {
             if let Some(task) = tasks.remove(key) {
                 let Task { event } = task.data;
-                let (user, channel) = key;
+                let (user, channel, _) = key;
 
-                if let Err(err) = match &event {
-                    #[allow(clippy::disallowed_methods)] // event is sent by higher level function
-                    AckEvent::AckMessage { id } => db.acknowledge_message(channel, user, id).await,
-                    AckEvent::AddMention { ids } => {
-                        db.add_mention_to_unread(channel, user, ids).await
-                    }
-                } {
-                    error!("{err:?} for {event:?}. ({user}, {channel})");
+                if let Err(err) = handle_ack_event(&event, &db, &amqp, user, channel).await {
+                    revolt_config::capture_error(&err);
+                    error!("{err:?} for {event:?}. ({user:?}, {channel})");
                 } else {
-                    info!("User {user} ack in {channel} with {event:?}");
+                    info!("User {user:?} ack in {channel} with {event:?}");
                 }
             }
         }
@@ -95,20 +248,56 @@ pub async fn worker(db: Database) {
             mut event,
         }) = Q.try_pop()
         {
-            let key = (user, channel);
-            if let Some(task) = tasks.get_mut(&key) {
-                task.delay();
+            info!("Took next ack from queue, now {} remaining", Q.len());
 
+            let key: (Option<String>, String, u8) = (
+                user,
+                channel,
+                match &event {
+                    AckEvent::AckMessage { .. } => 0,
+                    AckEvent::ProcessMessage { .. } => 1,
+                },
+            );
+            if let Some(task) = tasks.get_mut(&key) {
                 match &mut event {
-                    AckEvent::AddMention { ids } => {
-                        if let AckEvent::AddMention { ids: existing } = &mut task.data.event {
-                            existing.append(ids);
+                    AckEvent::ProcessMessage { messages: new_data } => {
+                        if let AckEvent::ProcessMessage { messages: existing } =
+                            &mut task.data.event
+                        {
+                            if let Some(new_event) = new_data.pop() {
+                                // if the message contains a mass mention, do not delay it any further.
+                                if new_event.1.contains_mass_push_mention() {
+                                    // add the new message to the list of messages to be processed.
+                                    existing.push(new_event);
+                                    task.run_immediately();
+                                    continue;
+                                }
+
+                                existing.push(new_event);
+
+                                // put a cap on the amount of messages that can be queued, for particularly active channels
+                                if (existing.length() as u16)
+                                    < revolt_config::config()
+                                        .await
+                                        .features
+                                        .advanced
+                                        .process_message_delay_limit
+                                {
+                                    task.delay();
+                                }
+                            } else {
+                                let err_msg = format!("Got zero-length message event: {event:?}");
+                                capture_message(&err_msg, revolt_config::Level::Warning);
+                                info!("{err_msg}")
+                            }
                         } else {
-                            task.data.event = event;
+                            panic!("Somehow got an ack message in the add mention arm");
                         }
                     }
                     AckEvent::AckMessage { .. } => {
+                        // replace the last acked message with the new acked message
                         task.data.event = event;
+                        task.delay();
                     }
                 }
             } else {

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

@@ -0,0 +1,29 @@
+use async_std::channel::{unbounded, Receiver, Sender};
+use authifier::AuthifierEvent;
+use once_cell::sync::Lazy;
+
+use crate::events::client::EventV1;
+
+static Q: Lazy<(Sender<AuthifierEvent>, Receiver<AuthifierEvent>)> = Lazy::new(|| unbounded());
+
+/// Get sender
+pub fn sender() -> Sender<AuthifierEvent> {
+    Q.0.clone()
+}
+
+/// Start a new worker
+pub async fn worker() {
+    loop {
+        let event = Q.1.recv().await.unwrap();
+        match &event {
+            AuthifierEvent::CreateSession { .. } | AuthifierEvent::CreateAccount { .. } => {
+                EventV1::Auth(event).global().await
+            }
+            AuthifierEvent::DeleteSession { user_id, .. }
+            | AuthifierEvent::DeleteAllSessions { user_id, .. } => {
+                let id = user_id.to_string();
+                EventV1::Auth(event).private(id).await
+            }
+        }
+    }
+}

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

@@ -1,6 +1,6 @@
 //! Semi-important background task management
 
-use crate::Database;
+use crate::{Database, AMQP};
 
 use async_std::task;
 use std::time::Instant;
@@ -8,23 +8,25 @@ use std::time::Instant;
 const WORKER_COUNT: usize = 5;
 
 pub mod ack;
+pub mod authifier_relay;
 pub mod last_message_id;
 pub mod process_embeds;
-pub mod web_push;
 
 /// Spawn background workers
-pub async fn start_workers(db: Database, authifier_db: authifier::Database) {
+pub fn start_workers(db: Database, amqp: AMQP) {
+    task::spawn(authifier_relay::worker());
+
     for _ in 0..WORKER_COUNT {
-        task::spawn(ack::worker(db.clone()));
+        task::spawn(ack::worker(db.clone(), amqp.clone()));
         task::spawn(last_message_id::worker(db.clone()));
         task::spawn(process_embeds::worker(db.clone()));
-        task::spawn(web_push::worker(authifier_db.clone()));
     }
 }
 
 /// Task with additional information on when it should run
 pub struct DelayedTask<T> {
     pub data: T,
+    run_now: bool,
     last_updated: Instant,
     first_seen: Instant,
 }
@@ -40,6 +42,7 @@ impl<T> DelayedTask<T> {
     pub fn new(data: T) -> Self {
         DelayedTask {
             data,
+            run_now: false,
             last_updated: Instant::now(),
             first_seen: Instant::now(),
         }
@@ -50,9 +53,15 @@ impl<T> DelayedTask<T> {
         self.last_updated = Instant::now()
     }
 
+    /// Flag the task to run right away, regardless of the time
+    pub fn run_immediately(&mut self) {
+        self.run_now = true
+    }
+
     /// Check if a task should run yet
     pub fn should_run(&self) -> bool {
-        self.first_seen.elapsed().as_secs() > EXPIRE_CONSTANT
+        self.run_now
+            || self.first_seen.elapsed().as_secs() > EXPIRE_CONSTANT
             || self.last_updated.elapsed().as_secs() > SAVE_CONSTANT
     }
 }

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

@@ -56,7 +56,7 @@ pub async fn worker(db: Database) {
             let embeds = generate(
                 task.content,
                 &config.hosts.january,
-                config.features.limits.default.message_embeds,
+                config.features.limits.global.message_embeds,
                 semaphore,
             )
             .await;

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

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

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

@@ -1,3 +1,4 @@
+use iso8601_timestamp::Timestamp;
 use revolt_models::v0::*;
 use revolt_permissions::{calculate_user_permissions, UserPermission};
 
@@ -108,6 +109,7 @@ impl From<crate::Webhook> for Webhook {
             id: value.id,
             name: value.name,
             avatar: value.avatar.map(|file| file.into()),
+            creator_id: value.creator_id,
             channel_id: value.channel_id,
             token: value.token,
             permissions: value.permissions,
@@ -121,6 +123,7 @@ impl From<crate::PartialWebhook> for PartialWebhook {
             id: value.id,
             name: value.name,
             avatar: value.avatar.map(|file| file.into()),
+            creator_id: value.creator_id,
             channel_id: value.channel_id,
             token: value.token,
             permissions: value.permissions,
@@ -419,6 +422,10 @@ impl From<File> for crate::File {
             user_id: value.user_id,
             server_id: value.server_id,
             object_id: value.object_id,
+            hash: None,
+            uploaded_at: None,
+            uploader_id: None,
+            used_for: None,
         }
     }
 }
@@ -459,26 +466,31 @@ impl From<Metadata> for crate::Metadata {
     }
 }
 
-impl From<crate::Message> for Message {
-    fn from(value: crate::Message) -> Self {
+impl crate::Message {
+    pub fn into_model(self, user: Option<User>, member: Option<Member>) -> Message {
         Message {
-            id: value.id,
-            nonce: value.nonce,
-            channel: value.channel,
-            author: value.author,
-            webhook: value.webhook,
-            content: value.content,
-            system: value.system.map(|system| system.into()),
-            attachments: value
+            id: self.id,
+            nonce: self.nonce,
+            channel: self.channel,
+            author: self.author,
+            user,
+            member,
+            webhook: self.webhook,
+            content: self.content,
+            system: self.system.map(Into::into),
+            attachments: self
                 .attachments
                 .map(|v| v.into_iter().map(|f| f.into()).collect()),
-            edited: value.edited,
-            embeds: value.embeds,
-            mentions: value.mentions,
-            replies: value.replies,
-            reactions: value.reactions,
-            interactions: value.interactions.into(),
-            masquerade: value.masquerade.map(|masq| masq.into()),
+            edited: self.edited,
+            embeds: self.embeds,
+            mentions: self.mentions,
+            role_mentions: self.role_mentions,
+            replies: self.replies,
+            reactions: self.reactions,
+            interactions: self.interactions.into(),
+            masquerade: self.masquerade.map(Into::into),
+            flags: self.flags.unwrap_or_default(),
+            pinned: self.pinned,
         }
     }
 }
@@ -490,19 +502,24 @@ impl From<crate::PartialMessage> for PartialMessage {
             nonce: value.nonce,
             channel: value.channel,
             author: value.author,
+            user: None,
+            member: None,
             webhook: value.webhook,
             content: value.content,
-            system: value.system.map(|system| system.into()),
+            system: value.system.map(Into::into),
             attachments: value
                 .attachments
                 .map(|v| v.into_iter().map(|f| f.into()).collect()),
             edited: value.edited,
             embeds: value.embeds,
             mentions: value.mentions,
+            role_mentions: value.role_mentions,
             replies: value.replies,
             reactions: value.reactions,
-            interactions: value.interactions.map(|interactions| interactions.into()),
-            masquerade: value.masquerade.map(|masq| masq.into()),
+            interactions: value.interactions.map(Into::into),
+            masquerade: value.masquerade.map(Into::into),
+            flags: value.flags,
+            pinned: value.pinned,
         }
     }
 }
@@ -525,6 +542,8 @@ impl From<crate::SystemMessage> for SystemMessage {
             crate::SystemMessage::UserKicked { id } => Self::UserKicked { id },
             crate::SystemMessage::UserLeft { id } => Self::UserLeft { id },
             crate::SystemMessage::UserRemove { id, by } => Self::UserRemove { id, by },
+            crate::SystemMessage::MessagePinned { id, by } => Self::MessagePinned { id, by },
+            crate::SystemMessage::MessageUnpinned { id, by } => Self::MessageUnpinned { id, by },
         }
     }
 }
@@ -579,6 +598,17 @@ impl From<Masquerade> for crate::Masquerade {
     }
 }
 
+impl From<crate::PolicyChange> for PolicyChange {
+    fn from(value: crate::PolicyChange) -> Self {
+        PolicyChange {
+            created_time: value.created_time,
+            effective_time: value.effective_time,
+            description: value.description,
+            url: value.url,
+        }
+    }
+}
+
 impl From<crate::Report> for Report {
     fn from(value: crate::Report) -> Self {
         Report {
@@ -976,6 +1006,8 @@ impl crate::User {
             (RelationshipStatus::None, false)
         };
 
+        let badges = self.get_badges().await;
+
         User {
             username: self.username,
             discriminator: self.discriminator,
@@ -994,14 +1026,18 @@ impl crate::User {
             } else {
                 vec![]
             },
-            badges: self.badges.unwrap_or_default() as u32,
+            badges,
+            online: can_see_profile
+                && revolt_presence::is_online(&self.id).await
+                && !matches!(
+                    self.status,
+                    Some(crate::UserStatus {
+                        presence: Some(crate::Presence::Invisible),
+                        ..
+                    })
+                ),
             status: if can_see_profile {
-                self.status.map(|status| status.into())
-            } else {
-                None
-            },
-            profile: if can_see_profile {
-                self.profile.map(|profile| profile.into())
+                self.status.and_then(|status| status.into(true))
             } else {
                 None
             },
@@ -1009,13 +1045,14 @@ impl crate::User {
             privileged: self.privileged,
             bot: self.bot.map(|bot| bot.into()),
             relationship,
-            online: can_see_profile && revolt_presence::is_online(&self.id).await,
             id: self.id,
         }
     }
 
     /// Convert user object into user model assuming mutual connection
-    pub fn into_known<'a, P>(self, perspective: P, is_online: bool) -> User
+    ///
+    /// Relations will never be included, i.e. when we process ourselves
+    pub async fn into_known<'a, P>(self, perspective: P, is_online: bool) -> User
     where
         P: Into<Option<&'a crate::User>>,
     {
@@ -1045,32 +1082,26 @@ impl crate::User {
             (RelationshipStatus::None, false)
         };
 
+        let badges = self.get_badges().await;
+
         User {
             username: self.username,
             discriminator: self.discriminator,
             display_name: self.display_name,
             avatar: self.avatar.map(|file| file.into()),
-            relations: if let Some(crate::User { id, .. }) = perspective {
-                if id == &self.id {
-                    self.relations
-                        .unwrap_or_default()
-                        .into_iter()
-                        .map(|relation| relation.into())
-                        .collect()
-                } else {
-                    vec![]
-                }
-            } else {
-                vec![]
-            },
-            badges: self.badges.unwrap_or_default() as u32,
+            relations: vec![],
+            badges,
+            online: can_see_profile
+                && is_online
+                && !matches!(
+                    self.status,
+                    Some(crate::UserStatus {
+                        presence: Some(crate::Presence::Invisible),
+                        ..
+                    })
+                ),
             status: if can_see_profile {
-                self.status.map(|status| status.into())
-            } else {
-                None
-            },
-            profile: if can_see_profile {
-                self.profile.map(|profile| profile.into())
+                self.status.and_then(|status| status.into(true))
             } else {
                 None
             },
@@ -1078,12 +1109,41 @@ impl crate::User {
             privileged: self.privileged,
             bot: self.bot.map(|bot| bot.into()),
             relationship,
-            online: can_see_profile && is_online,
             id: self.id,
         }
     }
 
-    pub async fn into_self(self) -> User {
+    /// Convert user object into user model without presence information
+    pub async fn into_known_static<'a>(self, is_online: bool) -> User {
+        let badges = self.get_badges().await;
+
+        User {
+            username: self.username,
+            discriminator: self.discriminator,
+            display_name: self.display_name,
+            avatar: self.avatar.map(|file| file.into()),
+            relations: vec![],
+            badges,
+            online: is_online
+                && !matches!(
+                    self.status,
+                    Some(crate::UserStatus {
+                        presence: Some(crate::Presence::Invisible),
+                        ..
+                    })
+                ),
+            status: self.status.and_then(|status| status.into(true)),
+            flags: self.flags.unwrap_or_default() as u32,
+            privileged: self.privileged,
+            bot: self.bot.map(|bot| bot.into()),
+            relationship: RelationshipStatus::None, // events client will populate this from cache
+            id: self.id,
+        }
+    }
+
+    pub async fn into_self(self, force_online: bool) -> User {
+        let badges = self.get_badges().await;
+
         User {
             username: self.username,
             discriminator: self.discriminator,
@@ -1098,14 +1158,20 @@ impl crate::User {
                         .collect()
                 })
                 .unwrap_or_default(),
-            badges: self.badges.unwrap_or_default() as u32,
-            status: self.status.map(|status| status.into()),
-            profile: self.profile.map(|profile| profile.into()),
+            badges,
+            online: (force_online || revolt_presence::is_online(&self.id).await)
+                && !matches!(
+                    self.status,
+                    Some(crate::UserStatus {
+                        presence: Some(crate::Presence::Invisible),
+                        ..
+                    })
+                ),
+            status: self.status.and_then(|status| status.into(true)),
             flags: self.flags.unwrap_or_default() as u32,
             privileged: self.privileged,
             bot: self.bot.map(|bot| bot.into()),
             relationship: RelationshipStatus::User,
-            online: revolt_presence::is_online(&self.id).await,
             id: self.id,
         }
     }
@@ -1129,10 +1195,12 @@ impl From<User> for crate::User {
             relations: None,
             badges: Some(value.badges as i32),
             status: value.status.map(Into::into),
-            profile: value.profile.map(Into::into),
+            profile: None,
             flags: Some(value.flags as i32),
             privileged: value.privileged,
             bot: value.bot.map(Into::into),
+            suspended_until: None,
+            last_acknowledged_policy_change: Timestamp::UNIX_EPOCH,
         }
     }
 }
@@ -1151,8 +1219,7 @@ impl From<crate::PartialUser> for PartialUser {
                     .collect()
             }),
             badges: value.badges.map(|badges| badges as u32),
-            status: value.status.map(|status| status.into()),
-            profile: value.profile.map(|profile| profile.into()),
+            status: value.status.and_then(|status| status.into(false)),
             flags: value.flags.map(|flags| flags as u32),
             privileged: value.privileged,
             bot: value.bot.map(|bot| bot.into()),
@@ -1171,6 +1238,9 @@ impl From<FieldsUser> for crate::FieldsUser {
             FieldsUser::ProfileContent => crate::FieldsUser::ProfileContent,
             FieldsUser::StatusPresence => crate::FieldsUser::StatusPresence,
             FieldsUser::StatusText => crate::FieldsUser::StatusText,
+            FieldsUser::DisplayName => crate::FieldsUser::DisplayName,
+
+            FieldsUser::Internal => crate::FieldsUser::None,
         }
     }
 }
@@ -1183,6 +1253,10 @@ impl From<crate::FieldsUser> for FieldsUser {
             crate::FieldsUser::ProfileContent => FieldsUser::ProfileContent,
             crate::FieldsUser::StatusPresence => FieldsUser::StatusPresence,
             crate::FieldsUser::StatusText => FieldsUser::StatusText,
+            crate::FieldsUser::DisplayName => FieldsUser::DisplayName,
+
+            crate::FieldsUser::Suspension => FieldsUser::Internal,
+            crate::FieldsUser::None => FieldsUser::Internal,
         }
     }
 }
@@ -1234,11 +1308,23 @@ impl From<Presence> for crate::Presence {
     }
 }
 
-impl From<crate::UserStatus> for UserStatus {
-    fn from(value: crate::UserStatus) -> Self {
-        UserStatus {
-            text: value.text,
-            presence: value.presence.map(|presence| presence.into()),
+impl crate::UserStatus {
+    fn into(self, discard_invisible: bool) -> Option<UserStatus> {
+        let status = UserStatus {
+            text: self.text,
+            presence: self.presence.and_then(|presence| {
+                if discard_invisible && presence == crate::Presence::Invisible {
+                    None
+                } else {
+                    Some(presence.into())
+                }
+            }),
+        };
+
+        if status.text.is_none() && status.presence.is_none() {
+            None
+        } else {
+            Some(status)
         }
     }
 }
@@ -1285,3 +1371,18 @@ impl From<BotInformation> for crate::BotInformation {
         }
     }
 }
+
+impl From<crate::FieldsMessage> for FieldsMessage {
+    fn from(value: crate::FieldsMessage) -> Self {
+        match value {
+            crate::FieldsMessage::Pinned => FieldsMessage::Pinned,
+        }
+    }
+}
+impl From<FieldsMessage> for crate::FieldsMessage {
+    fn from(value: FieldsMessage) -> Self {
+        match value {
+            FieldsMessage::Pinned => crate::FieldsMessage::Pinned,
+        }
+    }
+}

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

@@ -0,0 +1,360 @@
+use std::{collections::HashMap, hash::RandomState};
+
+use revolt_permissions::{
+    ChannelPermission, ChannelType, Override, OverrideField, PermissionValue, ALLOW_IN_TIMEOUT,
+    DEFAULT_PERMISSION_DIRECT_MESSAGE,
+};
+
+use crate::{Channel, Database, Member, Server, User};
+
+#[derive(Clone)]
+pub struct BulkDatabasePermissionQuery<'a> {
+    #[allow(dead_code)]
+    database: &'a Database,
+
+    server: Server,
+    channel: Option<Channel>,
+    users: Option<Vec<User>>,
+    members: Option<Vec<Member>>,
+
+    // In case the users or members are fetched as part of the permissions checking operation
+    pub(crate) cached_users: Option<Vec<User>>,
+    pub(crate) cached_members: Option<Vec<Member>>,
+
+    cached_member_perms: Option<HashMap<String, PermissionValue>>,
+}
+
+impl<'z, 'x> BulkDatabasePermissionQuery<'x> {
+    pub async fn members_can_see_channel(&'z mut self) -> HashMap<String, bool>
+    where
+        'z: 'x,
+    {
+        let member_perms = if self.cached_member_perms.is_some() {
+            // This isn't done as an if let to prevent borrow checker errors with the mut self call when the perms aren't cached.
+            let perms = self.cached_member_perms.as_ref().unwrap();
+            perms
+                .iter()
+                .map(|(m, p)| {
+                    (
+                        m.clone(),
+                        p.has_channel_permission(ChannelPermission::ViewChannel),
+                    )
+                })
+                .collect()
+        } else {
+            calculate_members_permissions(self)
+                .await
+                .iter()
+                .map(|(m, p)| {
+                    (
+                        m.clone(),
+                        p.has_channel_permission(ChannelPermission::ViewChannel),
+                    )
+                })
+                .collect()
+        };
+        member_perms
+    }
+}
+
+impl<'z> BulkDatabasePermissionQuery<'z> {
+    pub fn new(database: &Database, server: Server) -> BulkDatabasePermissionQuery<'_> {
+        BulkDatabasePermissionQuery {
+            database,
+            server,
+            channel: None,
+            users: None,
+            members: None,
+            cached_members: None,
+            cached_users: None,
+            cached_member_perms: None,
+        }
+    }
+
+    pub async fn from_server_id<'a>(
+        db: &'a Database,
+        server: &str,
+    ) -> BulkDatabasePermissionQuery<'a> {
+        BulkDatabasePermissionQuery {
+            database: db,
+            server: db.fetch_server(server).await.unwrap(),
+            channel: None,
+            users: None,
+            members: None,
+            cached_members: None,
+            cached_users: None,
+            cached_member_perms: None,
+        }
+    }
+
+    pub fn channel(self, channel: &'z Channel) -> BulkDatabasePermissionQuery<'z> {
+        BulkDatabasePermissionQuery {
+            channel: Some(channel.clone()),
+            ..self
+        }
+    }
+
+    pub async fn from_channel_id(self, channel_id: String) -> BulkDatabasePermissionQuery<'z> {
+        let channel = self
+            .database
+            .fetch_channel(channel_id.as_str())
+            .await
+            .expect("Valid channel id");
+
+        drop(channel_id);
+
+        BulkDatabasePermissionQuery {
+            channel: Some(channel),
+            ..self
+        }
+    }
+
+    pub fn members(self, members: &'z [Member]) -> BulkDatabasePermissionQuery<'z> {
+        BulkDatabasePermissionQuery {
+            members: Some(members.to_owned()),
+            cached_member_perms: None,
+            users: None,
+            cached_members: None,
+            cached_users: None,
+            ..self
+        }
+    }
+
+    pub fn users(self, users: &'z [User]) -> BulkDatabasePermissionQuery<'z> {
+        BulkDatabasePermissionQuery {
+            users: Some(users.to_owned()),
+            cached_member_perms: None,
+            members: None,
+            cached_members: None,
+            cached_users: None,
+            ..self
+        }
+    }
+
+    /// Get the default channel permissions
+    /// Group channel defaults should be mapped to an allow-only override
+    #[allow(dead_code)]
+    async fn get_default_channel_permissions(&mut self) -> Override {
+        if let Some(channel) = &self.channel {
+            match channel {
+                Channel::Group { permissions, .. } => Override {
+                    allow: permissions.unwrap_or(*DEFAULT_PERMISSION_DIRECT_MESSAGE as i64) as u64,
+                    deny: 0,
+                },
+                Channel::TextChannel {
+                    default_permissions,
+                    ..
+                }
+                | Channel::VoiceChannel {
+                    default_permissions,
+                    ..
+                } => default_permissions.unwrap_or_default().into(),
+                _ => Default::default(),
+            }
+        } else {
+            Default::default()
+        }
+    }
+
+    #[allow(dead_code)]
+    fn get_channel_type(&mut self) -> ChannelType {
+        if let Some(channel) = &self.channel {
+            match channel {
+                Channel::DirectMessage { .. } => ChannelType::DirectMessage,
+                Channel::Group { .. } => ChannelType::Group,
+                Channel::SavedMessages { .. } => ChannelType::SavedMessages,
+                Channel::TextChannel { .. } | Channel::VoiceChannel { .. } => {
+                    ChannelType::ServerChannel
+                }
+            }
+        } else {
+            ChannelType::Unknown
+        }
+    }
+
+    /// Get the ordered role overrides (from lowest to highest) for this member in this channel
+    #[allow(dead_code)]
+    async fn get_channel_role_overrides(&mut self) -> &HashMap<String, OverrideField> {
+        if let Some(channel) = &self.channel {
+            match channel {
+                Channel::TextChannel {
+                    role_permissions, ..
+                }
+                | Channel::VoiceChannel {
+                    role_permissions, ..
+                } => role_permissions,
+                _ => panic!("Not supported for non-server channels"),
+            }
+        } else {
+            panic!("No channel added to query")
+        }
+    }
+}
+
+/// Calculate members permissions in a server channel.
+async fn calculate_members_permissions<'a>(
+    query: &'a mut BulkDatabasePermissionQuery<'a>,
+) -> HashMap<String, PermissionValue> {
+    let mut resp = HashMap::new();
+
+    let (_, channel_role_permissions, channel_default_permissions) = match query
+        .channel
+        .as_ref()
+        .expect("A channel must be assigned to calculate channel permissions")
+        .clone()
+    {
+        Channel::TextChannel {
+            id,
+            role_permissions,
+            default_permissions,
+            ..
+        }
+        | Channel::VoiceChannel {
+            id,
+            role_permissions,
+            default_permissions,
+            ..
+        } => (id, role_permissions, default_permissions),
+        _ => panic!("Calculation of member permissions must be done on a server channel"),
+    };
+
+    if query.users.is_none() {
+        let ids: Vec<String> = query
+            .members
+            .as_ref()
+            .expect("No users or members added to the query")
+            .iter()
+            .map(|m| m.id.user.clone())
+            .collect();
+
+        query.cached_users = Some(
+            query
+                .database
+                .fetch_users(&ids[..])
+                .await
+                .expect("Failed to get data from the db"),
+        );
+
+        query.users = Some(query.cached_users.as_ref().unwrap().to_vec())
+    }
+
+    let users = query.users.as_ref().unwrap();
+
+    if query.members.is_none() {
+        let ids: Vec<String> = query
+            .users
+            .as_ref()
+            .expect("No users or members added to the query")
+            .iter()
+            .map(|m| m.id.clone())
+            .collect();
+
+        query.cached_members = Some(
+            query
+                .database
+                .fetch_members(&query.server.id, &ids[..])
+                .await
+                .expect("Failed to get data from the db"),
+        );
+        query.members = Some(query.cached_members.as_ref().unwrap().to_vec())
+    }
+
+    let members: HashMap<&String, &Member, RandomState> = HashMap::from_iter(
+        query
+            .members
+            .as_ref()
+            .unwrap()
+            .iter()
+            .map(|m| (&m.id.user, m)),
+    );
+
+    for user in users {
+        let member = members.get(&user.id);
+
+        // User isn't a part of the server
+        if member.is_none() {
+            resp.insert(user.id.clone(), 0_u64.into());
+            continue;
+        }
+
+        let member = *member.unwrap();
+
+        if user.privileged {
+            resp.insert(
+                user.id.clone(),
+                PermissionValue::from(ChannelPermission::GrantAllSafe),
+            );
+            continue;
+        }
+
+        if user.id == query.server.owner {
+            resp.insert(
+                user.id.clone(),
+                PermissionValue::from(ChannelPermission::GrantAllSafe),
+            );
+            continue;
+        }
+
+        // Get the user's server permissions
+        let mut permission = calculate_server_permissions(&query.server, user, member);
+
+        if let Some(defaults) = channel_default_permissions {
+            permission.apply(defaults.into());
+        }
+
+        // Get the applicable role overrides
+        let mut roles = channel_role_permissions
+            .iter()
+            .filter(|(id, _)| member.roles.contains(id))
+            .filter_map(|(id, permission)| {
+                query.server.roles.get(id).map(|role| {
+                    let v: Override = (*permission).into();
+                    (role.rank, v)
+                })
+            })
+            .collect::<Vec<(i64, Override)>>();
+
+        roles.sort_by(|a, b| b.0.cmp(&a.0));
+        let overrides = roles.into_iter().map(|(_, v)| v);
+
+        for role_override in overrides {
+            permission.apply(role_override)
+        }
+
+        resp.insert(user.id.clone(), permission);
+    }
+
+    resp
+}
+
+/// Calculates a member's server permissions
+fn calculate_server_permissions(server: &Server, user: &User, member: &Member) -> PermissionValue {
+    if user.privileged || server.owner == user.id {
+        return ChannelPermission::GrantAllSafe.into();
+    }
+
+    let mut permissions: PermissionValue = server.default_permissions.into();
+
+    let mut roles = server
+        .roles
+        .iter()
+        .filter(|(id, _)| member.roles.contains(id))
+        .map(|(_, role)| {
+            let v: Override = role.permissions.into();
+            (role.rank, v)
+        })
+        .collect::<Vec<(i64, Override)>>();
+
+    roles.sort_by(|a, b| b.0.cmp(&a.0));
+    let role_overrides: Vec<Override> = roles.into_iter().map(|(_, v)| v).collect();
+
+    for role in role_overrides {
+        permissions.apply(role);
+    }
+
+    if member.in_timeout() {
+        permissions.restrict(*ALLOW_IN_TIMEOUT);
+    }
+
+    permissions
+}

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

@@ -18,6 +18,10 @@ static TOKEN_CACHE: Lazy<Mutex<lru::LruCache<String, ()>>> =
     Lazy::new(|| Mutex::new(lru::LruCache::new(NonZeroUsize::new(1000).unwrap())));
 
 impl IdempotencyKey {
+    pub fn unchecked_from_string(key: String) -> Self {
+        Self { key }
+    }
+
     // Backwards compatibility.
     // Issue #109
     pub async fn consume_nonce(&mut self, v: Option<String>) -> Result<()> {
@@ -98,7 +102,7 @@ impl<'r> FromRequest<'r> for IdempotencyKey {
             .map(|k| k.to_string())
         {
             if key.len() > 64 {
-                return Outcome::Failure((
+                return Outcome::Error((
                     Status::BadRequest,
                     create_error!(FailedValidation {
                         error: "idempotency key too long".to_string(),
@@ -109,7 +113,7 @@ impl<'r> FromRequest<'r> for IdempotencyKey {
             let idempotency = IdempotencyKey { key };
             let mut cache = TOKEN_CACHE.lock().await;
             if cache.get(&idempotency.key).is_some() {
-                return Outcome::Failure((Status::Conflict, create_error!(DuplicateNonce)));
+                return Outcome::Error((Status::Conflict, create_error!(DuplicateNonce)));
             }
 
             cache.put(idempotency.key.clone(), ());

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

@@ -1,4 +1,5 @@
 pub mod bridge;
+pub mod bulk_permissions;
 pub mod idempotency;
 pub mod permissions;
 pub mod reference;

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

@@ -53,6 +53,12 @@ impl PermissionQuery for DatabasePermissionQuery<'_> {
         if let Some(other_user) = &self.user {
             if self.perspective.id == other_user.id {
                 return RelationshipStatus::User;
+            } else if let Some(bot) = &other_user.bot {
+                // For the purposes of permissions checks,
+                // assume owner is the same as bot
+                if self.perspective.id == bot.owner {
+                    return RelationshipStatus::User;
+                }
             }
 
             if let Some(relations) = &self.perspective.relations {
@@ -299,16 +305,14 @@ impl PermissionQuery for DatabasePermissionQuery<'_> {
 
     /// Are we a recipient of this channel?
     async fn are_we_part_of_the_channel(&mut self) -> bool {
-        if let Some(channel) = &self.channel {
-            match channel {
-                Cow::Borrowed(Channel::DirectMessage { recipients, .. })
-                | Cow::Owned(Channel::DirectMessage { recipients, .. })
-                | Cow::Borrowed(Channel::Group { recipients, .. })
-                | Cow::Owned(Channel::Group { recipients, .. }) => {
-                    recipients.contains(&self.perspective.id)
-                }
-                _ => false,
-            }
+        if let Some(
+            Cow::Borrowed(Channel::DirectMessage { recipients, .. })
+            | Cow::Owned(Channel::DirectMessage { recipients, .. })
+            | Cow::Borrowed(Channel::Group { recipients, .. })
+            | Cow::Owned(Channel::Group { recipients, .. }),
+        ) = &self.channel
+        {
+            recipients.contains(&self.perspective.id)
         } else {
             false
         }
@@ -414,7 +418,7 @@ impl<'a> DatabasePermissionQuery<'a> {
     }
 
     /// Use user
-    pub fn user(self, user: &'a User) -> DatabasePermissionQuery {
+    pub fn user(self, user: &'a User) -> DatabasePermissionQuery<'a> {
         DatabasePermissionQuery {
             user: Some(Cow::Borrowed(user)),
             ..self
@@ -422,7 +426,7 @@ impl<'a> DatabasePermissionQuery<'a> {
     }
 
     /// Use channel
-    pub fn channel(self, channel: &'a Channel) -> DatabasePermissionQuery {
+    pub fn channel(self, channel: &'a Channel) -> DatabasePermissionQuery<'a> {
         DatabasePermissionQuery {
             channel: Some(Cow::Borrowed(channel)),
             ..self
@@ -430,7 +434,7 @@ impl<'a> DatabasePermissionQuery<'a> {
     }
 
     /// Use server
-    pub fn server(self, server: &'a Server) -> DatabasePermissionQuery {
+    pub fn server(self, server: &'a Server) -> DatabasePermissionQuery<'a> {
         DatabasePermissionQuery {
             server: Some(Cow::Borrowed(server)),
             ..self
@@ -438,7 +442,7 @@ impl<'a> DatabasePermissionQuery<'a> {
     }
 
     /// Use member
-    pub fn member(self, member: &'a Member) -> DatabasePermissionQuery {
+    pub fn member(self, member: &'a Member) -> DatabasePermissionQuery<'a> {
         DatabasePermissionQuery {
             member: Some(Cow::Borrowed(member)),
             ..self

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

@@ -1,3 +1,5 @@
+use std::str::FromStr;
+
 use revolt_result::Result;
 #[cfg(feature = "rocket-impl")]
 use rocket::request::FromParam;
@@ -44,9 +46,27 @@ impl Reference {
         db.fetch_channel(&self.id).await
     }
 
-    /// Fetch invite from Ref
+    /// Fetch invite from Ref or create invite to server if discoverable
     pub async fn as_invite(&self, db: &Database) -> Result<Invite> {
-        db.fetch_invite(&self.id).await
+        if ulid::Ulid::from_str(&self.id).is_ok() {
+            let server = self.as_server(db).await?;
+            if !server.discoverable {
+                return Err(create_error!(NotFound));
+            }
+
+            Ok(Invite::Server {
+                code: self.id.to_string(),
+                server: server.id,
+                creator: server.owner,
+                channel: server
+                    .channels
+                    .into_iter()
+                    .next()
+                    .ok_or(create_error!(NotFound))?,
+            })
+        } else {
+            db.fetch_invite(&self.id).await
+        }
     }
 
     /// Fetch message from Ref

crates/core/database/templates/deletion.html

@@ -1,7 +1,7 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
 <html>
   <head>
-    <!-- Compiled with Bootstrap Email version: 1.3.1 --><meta http-equiv="x-ua-compatible" content="ie=edge">
+    <!-- Compiled with Bootstrap Email version: 1.5.1 --><meta http-equiv="x-ua-compatible" content="ie=edge">
     <meta name="x-apple-disable-message-reformatting">
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <meta name="format-detection" content="telephone=no, date=no, address=no, email=no">
@@ -70,7 +70,10 @@
                                         </tr>
                                       </tbody>
                                     </table>
-                                    <p class="" style="line-height: 24px; font-size: 16px; width: 100%; margin: 0;" align="left">You requested to have your account deleted, if you did not perform this action please take measures to secure your account immediately.</p>
+                                    <p class="" style="line-height: 24px; font-size: 16px; width: 100%; margin: 0;" align="left">
+                                      You requested to have your account deleted, if you did not perform
+                                      this action please take measures to secure your account immediately.
+                                    </p>
                                     <table class="s-4 w-full" role="presentation" border="0" cellpadding="0" cellspacing="0" style="width: 100%;" width="100%">
                                       <tbody>
                                         <tr>
@@ -105,7 +108,7 @@
                             <div class="text-muted text-center" style="color: #718096;" align="center">
                               This email is intended for {{email}}<br>
                               Sent from Revolt<br>
-                              Made in the EU
+                              Made in Europe
                             </div>
                             <table class="s-6 w-full" role="presentation" border="0" cellpadding="0" cellspacing="0" style="width: 100%;" width="100%">
                               <tbody>
@@ -116,6 +119,40 @@
                                 </tr>
                               </tbody>
                             </table>
+                            <table class="s-6 w-full" role="presentation" border="0" cellpadding="0" cellspacing="0" style="width: 100%;" width="100%">
+                              <tbody>
+                                <tr>
+                                  <td style="line-height: 24px; font-size: 24px; width: 100%; height: 24px; margin: 0;" align="left" width="100%" height="24">
+                                    &#160;
+                                  </td>
+                                </tr>
+                              </tbody>
+                            </table>
+                            <table class="ax-center" role="presentation" align="center" border="0" cellpadding="0" cellspacing="0" style="margin: 0 auto;">
+                              <tbody>
+                                <tr>
+                                  <td style="line-height: 24px; font-size: 16px; margin: 0;" align="left">
+                                    <div class="text-muted text-xs" style="color: #718096; font-size: 12px; line-height: 14.4px;">
+                                      Revolt Platforms Ltd. is a company incorporated and registered under the
+                                      laws of England and Wales.<br>
+                                      Registered Company Number: 16260658<br>
+                                      Registered Office:<br>
+                                      Suite 5703 Unit 3A, 34-35 Hatton Garden,<br>
+                                      Holborn, United Kingdom, EC1N 8DX
+                                    </div>
+                                  </td>
+                                </tr>
+                              </tbody>
+                            </table>
+                            <table class="s-6 w-full" role="presentation" border="0" cellpadding="0" cellspacing="0" style="width: 100%;" width="100%">
+                              <tbody>
+                                <tr>
+                                  <td style="line-height: 24px; font-size: 24px; width: 100%; height: 24px; margin: 0;" align="left" width="100%" height="24">
+                                    &#160;
+                                  </td>
+                                </tr>
+                              </tbody>
+                            </table>
                           </td>
                         </tr>
                       </tbody>