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

README.md

@@ -1,23 +1,42 @@
-# 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
 
@@ -33,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
@@ -41,34 +75,53 @@ 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.
 
-```bash
-# create environment file (will be deprecated in future)
-cp .env.example .env
+If you'd like to change anything, create a `Revolt.overrides.toml` file and specify relevant variables.
 
-# (optionally) copy the default configuration file
-cp crates/core/config/Revolt.toml Revolt.toml
-# configure as necessary...
-```
+> [!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"
+> ```
 
-You may want to copy the following configuration:
-
-```toml
-# Revolt.toml
-[database]
-mongodb = "mongodb://localhost"
-redis = "redis://localhost"
-
-[hosts]
-app = "http://local.revolt.chat"
-api = "http://local.revolt.chat:8000"
-events = "ws://local.revolt.chat:9000"
-autumn = "http://local.revolt.chat:3000"
-january = "http://local.revolt.chat:7000"
-voso_legacy = ""
-voso_legacy_ws = ""
-```
+> [!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:
 
@@ -76,13 +129,23 @@ Then continue:
 # 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:
@@ -96,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
 
@@ -143,7 +209,7 @@ Now run tests for whichever database:
 
 ```sh
 TEST_DB=REFERENCE cargo nextest run
-TEST_DB=MONGOBD cargo nextest run
+TEST_DB=MONGODB cargo nextest run
 ```
 
 ## 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.12"
+version = "0.8.7"
 license = "AGPL-3.0-or-later"
 edition = "2021"
 
@@ -36,12 +36,12 @@ async-std = { version = "1.8.0", features = [
 ] }
 
 # core
-authifier = { version = "1.0.8" }
+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.12", 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};
@@ -90,10 +92,26 @@ 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
             .relations
@@ -150,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();
@@ -171,13 +211,11 @@ 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(true).await);
@@ -203,11 +241,32 @@ impl State {
         }
 
         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,
         })
     }
 
@@ -443,7 +502,7 @@ 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).await;
 

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

@@ -3,7 +3,7 @@ use std::{collections::HashSet, net::SocketAddr, sync::Arc};
 use async_tungstenite::WebSocketStream;
 use authifier::AuthifierEvent;
 use fred::{
-    error::{RedisError, RedisErrorKind},
+    error::RedisErrorKind,
     interfaces::{ClientLike, EventInterface, PubsubInterface},
     types::RedisConfig,
 };
@@ -14,6 +14,7 @@ use futures::{
     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,
@@ -78,7 +79,9 @@ 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(&create_error!(InvalidSession)))
+            .send(config.encode(&EventV1::Error {
+                data: create_error!(InvalidSession),
+            }))
             .await
             .ok();
         return;
@@ -87,7 +90,10 @@ pub async fn client(db: &'static Database, stream: TcpStream, addr: SocketAddr)
     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;
         }
     };
@@ -99,24 +105,21 @@ pub async fn client(db: &'static Database, stream: TcpStream, addr: SocketAddr)
     let user_id = state.cache.user_id.clone();
 
     // Notify socket we have authenticated.
-    if let Err(err) = write.send(config.encode(&EventV1::Authenticated)).await {
-        error!("Failed to write: {err:?}");
-        sentry::capture_error(&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 ready_payload = match state.generate_ready_payload(db).await {
+    let ready_payload = match report_internal_error!(
+        state
+            .generate_ready_payload(db, config.get_ready_payload_fields())
+            .await
+    ) {
         Ok(ready_payload) => ready_payload,
-        Err(err) => {
-            sentry::capture_error(&err);
-            return;
-        }
+        Err(_) => return,
     };
 
-    if let Err(err) = write.send(config.encode(&ready_payload)).await {
-        error!("Failed to write: {err:?}");
-        sentry::capture_error(&err);
+    if report_internal_error!(write.send(config.encode(&ready_payload)).await).is_err() {
         return;
     }
 
@@ -211,21 +214,16 @@ async fn listener(
     write: &Mutex<WsWriter>,
 ) {
     let redis_config = RedisConfig::from_url(&REDIS_URI).unwrap();
-    let subscriber = match fred::types::Builder::from_config(redis_config).build_subscriber_client()
-    {
+    let subscriber = match report_internal_error!(
+        fred::types::Builder::from_config(redis_config).build_subscriber_client()
+    ) {
         Ok(subscriber) => subscriber,
-        Err(err) => {
-            error!("Failed to build a subscriber: {err:?}");
-            sentry::capture_error(&err);
-            return;
-        }
+        Err(_) => return,
     };
 
-    if let Err(err) = subscriber.init().await {
-        error!("Failed to init subscriber: {err:?}");
-        sentry::capture_error(&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);
@@ -246,17 +244,13 @@ async fn listener(
         // Check for state changes for subscriptions.
         match state.apply_state().await {
             SubscriptionStateChange::Reset => {
-                if let Err(err) = subscriber.unsubscribe_all().await {
-                    error!("Unsubscribe all failed: {err:?}");
-                    sentry::capture_error(&err);
+                if report_internal_error!(subscriber.unsubscribe_all().await).is_err() {
                     break 'out;
                 }
 
                 let subscribed = state.subscribed.read().await;
                 for id in subscribed.iter() {
-                    if let Err(err) = subscriber.subscribe(id).await {
-                        error!("Subscribe failed: {err:?}");
-                        sentry::capture_error(&err);
+                    if report_internal_error!(subscriber.subscribe(id).await).is_err() {
                         break 'out;
                     }
                 }
@@ -269,9 +263,7 @@ async fn listener(
                     #[cfg(debug_assertions)]
                     info!("{addr:?} unsubscribing from {id}");
 
-                    if let Err(err) = subscriber.unsubscribe(id).await {
-                        error!("Unsubscribe failed: {err:?}");
-                        sentry::capture_error(&err);
+                    if report_internal_error!(subscriber.unsubscribe(id).await).is_err() {
                         break 'out;
                     }
                 }
@@ -280,9 +272,7 @@ async fn listener(
                     #[cfg(debug_assertions)]
                     info!("{addr:?} subscribing to {id}");
 
-                    if let Err(err) = subscriber.subscribe(id).await {
-                        error!("Subscribe failed: {err:?}");
-                        sentry::capture_error(&err);
+                    if report_internal_error!(subscriber.subscribe(id).await).is_err() {
                         break 'out;
                     }
                 }
@@ -307,38 +297,32 @@ async fn listener(
             _ = t2 => {},
             message = t1 => {
                 // Handle incoming events.
-                let message = match message {
+                let message = match report_internal_error!(message) {
                     Ok(message) => message,
-                    Err(e) => {
-                        error!("Error while consuming pub/sub messages: {e:?}");
-                        sentry::capture_error(&e);
-                        break 'out;
-                    }
+                    Err(_) => break 'out
                 };
 
                 let event = match *REDIS_PAYLOAD_TYPE {
                     PayloadType::Json => message
                         .value
                         .as_str()
-                        .and_then(|s| serde_json::from_str::<EventV1>(s.as_ref()).ok()),
+                        .and_then(|s| report_internal_error!(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()),
+                        .and_then(|b| report_internal_error!(rmp_serde::from_slice::<EventV1>(b)).ok()),
                     PayloadType::Bincode => message
                         .value
                         .as_bytes()
-                        .and_then(|b| bincode::deserialize::<EventV1>(b).ok()),
+                        .and_then(|b| report_internal_error!(bincode::deserialize::<EventV1>(b)).ok()),
                 };
 
                 let Some(mut event) = event else {
                     let err = format!(
-                        "Failed to deserialise an event for {}! Introspection: `{:?}`",
+                        "Failed to deserialise event for {}: `{:?}`",
                         message.channel,
                         message
                             .value
-                            .as_string()
-                            .map(|x| x.chars().take(32).collect::<String>())
                     );
 
                     error!("{}", err);
@@ -390,10 +374,7 @@ async fn listener(
         }
     }
 
-    if let Err(err) = subscriber.quit().await {
-        error!("{}", err);
-        sentry::capture_error(&err);
-    }
+    report_internal_error!(subscriber.quit().await).ok();
 }
 
 #[allow(clippy::too_many_arguments)]

crates/core/config/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-config"
-version = "0.7.12"
+version = "0.8.7"
 edition = "2021"
 license = "MIT"
 authors = ["Paul Makles <me@insrt.uk>"]
@@ -9,12 +9,13 @@ 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/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,38 +22,175 @@ 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]
 
@@ -55,38 +203,77 @@ server_emoji = 100
 server_roles = 200
 server_channels = 200
 
-new_user_days = 3
+# 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_length = 2000
-message_attachments = 5
-servers = 100
 
-attachment_size = 20000000
-avatar_size = 4000000
-background_size = 6000000
-icon_size = 2500000
-banner_size = 6000000
-emoji_size = 500000
+# 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
 
-attachment_size = 20000000
-avatar_size = 4000000
-background_size = 6000000
-icon_size = 2500000
-banner_size = 6000000
-emoji_size = 500000
+[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)]
@@ -94,14 +178,101 @@ pub struct ApiWorkers {
     pub max_concurrent_connections: usize,
 }
 
+#[derive(Deserialize, Debug, Clone)]
+pub struct ApiUsers {
+    pub early_adopter_cutoff: Option<u64>,
+}
+
 #[derive(Deserialize, Debug, Clone)]
 pub struct Api {
     pub registration: ApiRegistration,
     pub smtp: ApiSmtp,
-    pub vapid: ApiVapid,
-    pub fcm: ApiFcm,
     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)]
@@ -114,7 +285,9 @@ pub struct GlobalLimits {
     pub server_roles: usize,
     pub server_channels: usize,
 
-    pub new_user_days: usize,
+    pub new_user_hours: usize,
+
+    pub body_limit_size: usize,
 }
 
 #[derive(Deserialize, Debug, Clone)]
@@ -126,12 +299,7 @@ pub struct FeaturesLimits {
     pub message_attachments: usize,
     pub servers: 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 file_upload_size_limit: HashMap<String, usize>,
 }
 
 #[derive(Deserialize, Debug, Clone)]
@@ -145,46 +313,61 @@ pub struct FeaturesLimitsCollection {
     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.");
         }
     }
@@ -203,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");
     }
@@ -218,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.12"
+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.12", path = "../config" }
-revolt-result = { version = "0.7.12", path = "../result" }
-revolt-models = { version = "0.7.12", 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.12", path = "../presence" }
-revolt-permissions = { version = "0.7.12", 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,6 +38,8 @@ pub enum ErrorEvent {
 pub enum EventV1 {
     /// Multiple events
     Bulk { v: Vec<EventV1> },
+    /// Error event
+    Error { data: Error },
 
     /// Successfully authenticated
     Authenticated,
@@ -52,11 +47,23 @@ pub enum EventV1 {
     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
@@ -69,6 +76,8 @@ pub enum EventV1 {
         id: String,
         channel: String,
         data: PartialMessage,
+        #[serde(default)]
+        clear: Vec<FieldsMessage>,
     },
 
     /// Append information to existing message
@@ -119,6 +128,7 @@ pub enum EventV1 {
     ServerUpdate {
         id: String,
         data: PartialServer,
+        #[serde(default)]
         clear: Vec<FieldsServer>,
     },
 
@@ -129,6 +139,7 @@ pub enum EventV1 {
     ServerMemberUpdate {
         id: MemberCompositeKey,
         data: PartialMember,
+        #[serde(default)]
         clear: Vec<FieldsMember>,
     },
 
@@ -136,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>,
     },
 
@@ -153,6 +169,7 @@ pub enum EventV1 {
     UserUpdate {
         id: String,
         data: PartialUser,
+        #[serde(default)]
         clear: Vec<FieldsUser>,
         event_id: Option<String>,
     },
@@ -187,6 +204,7 @@ pub enum EventV1 {
     ChannelUpdate {
         id: String,
         data: PartialChannel,
+        #[serde(default)]
         clear: Vec<FieldsChannel>,
     },
 

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/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() })
@@ -1054,24 +976,194 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
         if !invites.is_empty() {
             db.db()
                 .collection("channel_invites")
-                .insert_many(invites, None)
+                .insert_many(invites)
                 .await
                 .expect("failed to insert corrected invite");
 
             db.db()
                 .collection::<Outer>("channel_invites")
-                .delete_many(
-                    doc! {
-                        "type": { "$exists": false }
-                    },
-                    None,
-                )
+                .delete_many(doc! {
+                    "type": { "$exists": false }
+                })
                 .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,4 +1,3 @@
-use revolt_config::config;
 use revolt_result::Result;
 use ulid::Ulid;
 
@@ -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>>,
     {
@@ -86,7 +90,7 @@ impl Bot {
 
         let id = Ulid::new().to_string();
 
-        User::create(
+        let user = User::create(
             db,
             username,
             Some(id.to_string()),
@@ -111,7 +115,7 @@ impl Bot {
         }
 
         db.insert_bot(&bot).await?;
-        Ok(bot)
+        Ok((bot, user))
     }
 
     /// Remove a field from this object
@@ -167,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!(
@@ -269,16 +269,24 @@ impl Channel {
             }));
         }
 
+        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<()> {
@@ -373,6 +379,7 @@ 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()),
@@ -417,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,
         }
     }
 
@@ -639,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 {
@@ -655,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,
@@ -686,6 +694,7 @@ impl Channel {
                         .into_message(id.to_string())
                         .send(
                             db,
+                            Some(amqp),
                             MessageAuthor::System {
                                 username: name,
                                 avatar: None,
@@ -702,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(),
@@ -723,6 +734,7 @@ 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()),

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, FeaturesLimits};
 use revolt_models::v0::{
     self, BulkMessageResponse, DataMessageSend, Embed, MessageAuthor, MessageFlags, MessageSort,
-    MessageWebhook, PushNotification, ReplyIntent, SendableEmbed, Text, RE_MENTION,
+    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,10 +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<i32>,
+        pub flags: Option<u32>,
     },
     "PartialMessage"
 );
@@ -99,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
@@ -168,6 +181,8 @@ auto_derived!(
         pub author: Option<String>,
         /// Search query
         pub query: Option<String>,
+        /// Search for pinned
+        pub pinned: Option<bool>,
     }
 
     /// Message Query
@@ -183,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 {
@@ -200,11 +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,
         }
     }
 }
@@ -215,6 +261,7 @@ impl Message {
     #[allow(clippy::too_many_arguments)]
     pub async fn create_from_api(
         db: &Database,
+        amqp: Option<&AMQP>,
         channel: Channel,
         data: DataMessageSend,
         author: MessageAuthor<'_>,
@@ -239,20 +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));
         }
 
-        // Ensure flags are either not set or have permissible values
-        if let Some(flags) = &data.flags {
-            if flags != &0 && flags != &1 {
+        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 {
@@ -278,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
@@ -286,18 +363,76 @@ impl Message {
                 .unwrap_or_default(),
             author: author_id,
             webhook: webhook.map(|w| w.into()),
-            flags: data.flags.map(|v| v as i32),
+            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()
+                    }));
                 }
             }
         }
@@ -311,19 +446,89 @@ impl Message {
                 }));
             }
 
-            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() {
@@ -332,6 +537,15 @@ 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
@@ -355,10 +569,8 @@ impl Message {
         }
 
         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() {
@@ -378,7 +590,7 @@ impl Message {
 
         // Send the message
         message
-            .send(db, author, user, member, &channel, generate_embeds)
+            .send(db, amqp, author, user, member, &channel, generate_embeds)
             .await?;
 
         Ok(message)
@@ -392,6 +604,9 @@ impl Message {
         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?;
 
@@ -404,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;
@@ -433,9 +652,11 @@ 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>,
@@ -444,30 +665,42 @@ impl Message {
     ) -> Result<()> {
         self.send_without_notifications(
             db,
-            user,
-            member,
+            user.clone(),
+            member.clone(),
             matches!(channel, Channel::DirectMessage { .. }),
             generate_embeds,
+            true,
         )
         .await?;
 
-        if !self.has_suppressed_notifications() {
-            // 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![],
-                    }
+        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
+                    )],
                 },
-                PushNotification::from(
-                    self.clone().into_model(None, None),
-                    Some(author),
-                    &channel.id(),
-                )
-                .await,
             )
             .await;
         }
@@ -484,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
         };
@@ -505,22 +735,45 @@ impl Message {
     /// Whether this message has suppressed notifications
     pub fn has_suppressed_notifications(&self) -> bool {
         if let Some(flags) = self.flags {
-            flags & MessageFlags::SupressNotifications as i32
-                == MessageFlags::SupressNotifications as i32
+            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;
@@ -571,6 +824,12 @@ impl Message {
                                 users.push(id.clone());
                             }
                             v0::SystemMessage::Text { .. } => {}
+                            v0::SystemMessage::MessagePinned { by, .. } => {
+                                users.push(by.clone());
+                            }
+                            v0::SystemMessage::MessageUnpinned { by, .. } => {
+                                users.push(by.clone());
+                            }
                         }
                     }
                     users
@@ -628,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(),
             )
@@ -800,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 {

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, None, None, 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, None, None, 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, 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, FeaturesLimits};
-use revolt_models::v0;
+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"
 );
@@ -62,6 +72,10 @@ auto_derived!(
         ProfileContent,
         ProfileBackground,
         DisplayName,
+
+        // internal fields
+        Suspension,
+        None,
     }
 
     /// User's relationship with another user (or themselves)
@@ -141,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));
     }
@@ -165,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,
         }
     }
 }
@@ -187,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()
         };
 
@@ -206,7 +223,7 @@ impl User {
             .datetime()
             .elapsed()
             .expect("time went backwards")
-            <= Duration::from_secs(86400u64 * config.features.limits.global.new_user_days as u64)
+            <= Duration::from_secs(3600u64 * config.features.limits.global.new_user_hours as u64)
         {
             config.features.limits.new_user
         } else {
@@ -281,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) {
@@ -329,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
@@ -485,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)),
@@ -494,6 +521,8 @@ impl User {
             RelationshipStatus::BlockedOther => Err(create_error!(BlockedByOther)),
             RelationshipStatus::Incoming => {
                 // Accept incoming friend request
+                _ = amqp.friend_request_accepted(self, target).await;
+
                 self.apply_relationship(
                     db,
                     target,
@@ -522,6 +551,8 @@ impl User {
                     }));
                 }
 
+                _ = amqp.friend_request_received(target, self).await;
+
                 // Send the friend request
                 self.apply_relationship(
                     db,
@@ -609,7 +640,7 @@ impl User {
     }
 
     /// Update user data
-    pub async fn update<'a>(
+    pub async fn update(
         &mut self,
         db: &Database,
         partial: PartialUser,
@@ -659,9 +690,106 @@ impl User {
                 }
             }
             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(
@@ -677,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

@@ -58,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

@@ -49,12 +49,9 @@ impl AbstractUsers for MongoDb {
     /// 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
-                },
-                None,
-            )
+            .find_one(doc! {
+                "token": token
+            })
             .await
             .map_err(|_| create_database_error!("find_one", "sessions"))?
             .ok_or_else(|| create_error!(InvalidSession))
@@ -64,14 +61,11 @@ impl AbstractUsers for MongoDb {
     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 {
@@ -94,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()
@@ -122,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() })
@@ -143,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() })
@@ -166,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() })
@@ -284,7 +271,6 @@ impl AbstractUsers for MongoDb {
                         }
                     }
                 }],
-                None,
             )
             .await
             .map(|_| ())
@@ -305,7 +291,6 @@ impl AbstractUsers for MongoDb {
                         }
                     }
                 },
-                None,
             )
             .await
             .map(|_| ())
@@ -316,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 {
@@ -327,6 +330,8 @@ impl IntoDocumentPath for FieldsUser {
             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

@@ -163,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/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,
         }
     }
 }
@@ -477,11 +484,13 @@ impl crate::Message {
             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.map(|flags| flags as u32).unwrap_or_default(),
+            flags: self.flags.unwrap_or_default(),
+            pinned: self.pinned,
         }
     }
 }
@@ -504,11 +513,13 @@ impl From<crate::PartialMessage> for PartialMessage {
             edited: value.edited,
             embeds: value.embeds,
             mentions: value.mentions,
+            role_mentions: value.role_mentions,
             replies: value.replies,
             reactions: value.reactions,
             interactions: value.interactions.map(Into::into),
             masquerade: value.masquerade.map(Into::into),
-            flags: value.flags.map(|flags| flags as u32),
+            flags: value.flags,
+            pinned: value.pinned,
         }
     }
 }
@@ -531,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 },
         }
     }
 }
@@ -585,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 {
@@ -982,6 +1006,8 @@ impl crate::User {
             (RelationshipStatus::None, false)
         };
 
+        let badges = self.get_badges().await;
+
         User {
             username: self.username,
             discriminator: self.discriminator,
@@ -1000,7 +1026,7 @@ 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!(
@@ -1011,7 +1037,7 @@ impl crate::User {
                     })
                 ),
             status: if can_see_profile {
-                self.status.map(|status| status.into())
+                self.status.and_then(|status| status.into(true))
             } else {
                 None
             },
@@ -1024,7 +1050,9 @@ impl crate::User {
     }
 
     /// 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>>,
     {
@@ -1054,25 +1082,15 @@ 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!(
@@ -1083,7 +1101,7 @@ impl crate::User {
                     })
                 ),
             status: if can_see_profile {
-                self.status.map(|status| status.into())
+                self.status.and_then(|status| status.into(true))
             } else {
                 None
             },
@@ -1096,14 +1114,16 @@ impl crate::User {
     }
 
     /// Convert user object into user model without presence information
-    pub fn into_known_static<'a>(self, is_online: bool) -> User {
+    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: self.badges.unwrap_or_default() as u32,
+            badges,
             online: is_online
                 && !matches!(
                     self.status,
@@ -1112,7 +1132,7 @@ impl crate::User {
                         ..
                     })
                 ),
-            status: self.status.map(|status| status.into()),
+            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()),
@@ -1122,6 +1142,8 @@ impl crate::User {
     }
 
     pub async fn into_self(self, force_online: bool) -> User {
+        let badges = self.get_badges().await;
+
         User {
             username: self.username,
             discriminator: self.discriminator,
@@ -1136,7 +1158,7 @@ impl crate::User {
                         .collect()
                 })
                 .unwrap_or_default(),
-            badges: self.badges.unwrap_or_default() as u32,
+            badges,
             online: (force_online || revolt_presence::is_online(&self.id).await)
                 && !matches!(
                     self.status,
@@ -1145,7 +1167,7 @@ impl crate::User {
                         ..
                     })
                 ),
-            status: self.status.map(|status| status.into()),
+            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()),
@@ -1177,6 +1199,8 @@ impl From<User> for crate::User {
             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,
         }
     }
 }
@@ -1195,7 +1219,7 @@ impl From<crate::PartialUser> for PartialUser {
                     .collect()
             }),
             badges: value.badges.map(|badges| badges as u32),
-            status: value.status.map(|status| status.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()),
@@ -1215,6 +1239,8 @@ impl From<FieldsUser> for crate::FieldsUser {
             FieldsUser::StatusPresence => crate::FieldsUser::StatusPresence,
             FieldsUser::StatusText => crate::FieldsUser::StatusText,
             FieldsUser::DisplayName => crate::FieldsUser::DisplayName,
+
+            FieldsUser::Internal => crate::FieldsUser::None,
         }
     }
 }
@@ -1228,6 +1254,9 @@ impl From<crate::FieldsUser> for FieldsUser {
             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,
         }
     }
 }
@@ -1279,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)
         }
     }
 }
@@ -1330,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

@@ -305,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
         }
@@ -420,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
@@ -428,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
@@ -436,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
@@ -444,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/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>

crates/core/database/templates/deletion.original.html

@@ -23,7 +23,15 @@
       <div class="text-muted text-center my-6">
         This email is intended for {{email}}<br />
         Sent from Revolt<br />
-        Made in the EU
+        Made in Europe
+      </div>
+      <div class="text-muted text-xs my-6 ax-center">
+        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>
     </div>
   </body>

crates/core/database/templates/deletion.txt

@@ -0,0 +1,14 @@
+You requested to have your account deleted, if you did not perform this action please take measures to secure your account immediately.
+
+Please navigate to: {{url}}
+
+This email is intended for {{email}}
+Sent by Revolt
+Made in Europe
+
+Revolt Platforms Ltd. is a company incorporated and registered under the laws of England and Wales.
+
+Registration Number: 16260658
+Registered Office:
+Suite 5703 Unit 3A, 34-35 Hatton Garden,
+Holborn, United Kingdom, EC1N 8DX

crates/core/database/templates/deletion.whitelabel.txt

@@ -3,5 +3,7 @@ You requested to have your account deleted, if you did not perform this action p
 Please navigate to: {{url}}
 
 This email is intended for {{email}}
-Sent by Revolt
-Made in the EU
+
+This email has no association with Revolt or Revolt Platforms Ltd.
+Learn more about third party instances here:
+https://developers.revolt.chat/faq.html

crates/core/database/templates/policy-change.original.html

@@ -0,0 +1,53 @@
+<html>
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <style>
+      /* Add custom classes and styles that you want inlined here */
+    </style>
+  </head>
+  <body class="bg-light">
+    <div class="container">
+      <img
+        alt="Revolt Logo"
+        class="ax-center my-10 w-24"
+        src="https://app.revolt.chat/assets/logo_round.png"
+      />
+      <div class="card p-6 p-lg-10 space-y-4">
+        <h1 class="h3 fw-700">Notice of Terms &amp; Policy Change</h1>
+        <p>
+          This email is to notify you that we're updating all of our policy
+          documents.
+        </p>
+        <p>
+          You can read our updated Terms of Service and Privacy Policy below:<br />
+          Effective. 24th March 2025
+        </p>
+        <a class="p-3 fw-700" href="https://revolt.chat/terms"
+          >Terms of Service</a
+        >
+        <a class="p-3 fw-700" href="https://revolt.chat/terms"
+          >Privacy Policy</a
+        >
+        <p>
+          Our Community Guidelines have also been updated to help us better
+          protect and safeguard the platform. You can check them out here:
+        </p>
+        <a class="p-3 fw-700" href="https://revolt.chat/terms"
+          >Community Guidelines</a
+        >
+      </div>
+      <div class="text-muted text-center my-6">
+        Sent by Revolt<br />
+        Made in Europe
+      </div>
+      <div class="text-muted text-xs my-6 ax-center">
+        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>
+    </div>
+  </body>
+</html>

crates/core/database/templates/reset-existing.html

@@ -0,0 +1,188 @@
+<!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.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">
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+    <style type="text/css">
+      body,table,td{font-family:Helvetica,Arial,sans-serif !important}.ExternalClass{width:100%}.ExternalClass,.ExternalClass p,.ExternalClass span,.ExternalClass font,.ExternalClass td,.ExternalClass div{line-height:150%}a{text-decoration:none}*{color:inherit}a[x-apple-data-detectors],u+#body a,#MessageViewBody a{color:inherit;text-decoration:none;font-size:inherit;font-family:inherit;font-weight:inherit;line-height:inherit}img{-ms-interpolation-mode:bicubic}table:not([class^=s-]){font-family:Helvetica,Arial,sans-serif;mso-table-lspace:0pt;mso-table-rspace:0pt;border-spacing:0px;border-collapse:collapse}table:not([class^=s-]) td{border-spacing:0px;border-collapse:collapse}@media screen and (max-width: 600px){.w-full,.w-full>tbody>tr>td{width:100% !important}.w-24,.w-24>tbody>tr>td{width:96px !important}.p-lg-10:not(table),.p-lg-10:not(.btn)>tbody>tr>td,.p-lg-10.btn td a{padding:0 !important}.p-3:not(table),.p-3:not(.btn)>tbody>tr>td,.p-3.btn td a{padding:12px !important}.p-6:not(table),.p-6:not(.btn)>tbody>tr>td,.p-6.btn td a{padding:24px !important}*[class*=s-lg-]>tbody>tr>td{font-size:0 !important;line-height:0 !important;height:0 !important}.s-4>tbody>tr>td{font-size:16px !important;line-height:16px !important;height:16px !important}.s-6>tbody>tr>td{font-size:24px !important;line-height:24px !important;height:24px !important}.s-10>tbody>tr>td{font-size:40px !important;line-height:40px !important;height:40px !important}}
+    </style>
+  </head>
+  <body class="bg-light" style="outline: 0; width: 100%; min-width: 100%; height: 100%; -webkit-text-size-adjust: 100%; -ms-text-size-adjust: 100%; font-family: Helvetica, Arial, sans-serif; line-height: 24px; font-weight: normal; font-size: 16px; -moz-box-sizing: border-box; -webkit-box-sizing: border-box; box-sizing: border-box; color: #000000; margin: 0; padding: 0; border-width: 0;" bgcolor="#f7fafc">
+    <table class="bg-light body" valign="top" role="presentation" border="0" cellpadding="0" cellspacing="0" style="outline: 0; width: 100%; min-width: 100%; height: 100%; -webkit-text-size-adjust: 100%; -ms-text-size-adjust: 100%; font-family: Helvetica, Arial, sans-serif; line-height: 24px; font-weight: normal; font-size: 16px; -moz-box-sizing: border-box; -webkit-box-sizing: border-box; box-sizing: border-box; color: #000000; margin: 0; padding: 0; border-width: 0;" bgcolor="#f7fafc">
+      <tbody>
+        <tr>
+          <td valign="top" style="line-height: 24px; font-size: 16px; margin: 0;" align="left" bgcolor="#f7fafc">
+            <table class="container" role="presentation" border="0" cellpadding="0" cellspacing="0" style="width: 100%;">
+              <tbody>
+                <tr>
+                  <td align="center" style="line-height: 24px; font-size: 16px; margin: 0; padding: 0 16px;">
+                    <!--[if (gte mso 9)|(IE)]>
+                      <table align="center" role="presentation">
+                        <tbody>
+                          <tr>
+                            <td width="600">
+                    <![endif]-->
+                    <table align="center" role="presentation" border="0" cellpadding="0" cellspacing="0" style="width: 100%; max-width: 600px; margin: 0 auto;">
+                      <tbody>
+                        <tr>
+                          <td style="line-height: 24px; font-size: 16px; margin: 0;" align="left">
+                            <table class="s-10 w-full" role="presentation" border="0" cellpadding="0" cellspacing="0" style="width: 100%;" width="100%">
+                              <tbody>
+                                <tr>
+                                  <td style="line-height: 40px; font-size: 40px; width: 100%; height: 40px; margin: 0;" align="left" width="100%" height="40">
+                                    &#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">
+                                    <img class="w-24" src="https://app.revolt.chat/assets/logo_round.png" style="height: auto; line-height: 100%; outline: none; text-decoration: none; display: block; width: 96px; border-style: none; border-width: 0;" width="96">
+                                  </td>
+                                </tr>
+                              </tbody>
+                            </table>
+                            <table class="s-10 w-full" role="presentation" border="0" cellpadding="0" cellspacing="0" style="width: 100%;" width="100%">
+                              <tbody>
+                                <tr>
+                                  <td style="line-height: 40px; font-size: 40px; width: 100%; height: 40px; margin: 0;" align="left" width="100%" height="40">
+                                    &#160;
+                                  </td>
+                                </tr>
+                              </tbody>
+                            </table>
+                            <table class="card p-6 p-lg-10 space-y-4" role="presentation" border="0" cellpadding="0" cellspacing="0" style="border-radius: 6px; border-collapse: separate !important; width: 100%; overflow: hidden; border: 1px solid #e2e8f0;" bgcolor="#ffffff">
+                              <tbody>
+                                <tr>
+                                  <td style="line-height: 24px; font-size: 16px; width: 100%; margin: 0; padding: 40px;" align="left" bgcolor="#ffffff">
+                                    <h1 class="h3 fw-700" style="padding-top: 0; padding-bottom: 0; font-weight: 700 !important; vertical-align: baseline; font-size: 28px; line-height: 33.6px; margin: 0;" align="left">Password Reset</h1>
+                                    <table class="s-4 w-full" role="presentation" border="0" cellpadding="0" cellspacing="0" style="width: 100%;" width="100%">
+                                      <tbody>
+                                        <tr>
+                                          <td style="line-height: 16px; font-size: 16px; width: 100%; height: 16px; margin: 0;" align="left" width="100%" height="16">
+                                            &#160;
+                                          </td>
+                                        </tr>
+                                      </tbody>
+                                    </table>
+                                    <p class="" style="line-height: 24px; font-size: 16px; width: 100%; margin: 0;" align="left">
+                                      You tried to create a new account with or try to re-verify this email
+                                      but there is already an existing verified account under this email.
+                                    </p>
+                                    <table class="s-4 w-full" role="presentation" border="0" cellpadding="0" cellspacing="0" style="width: 100%;" width="100%">
+                                      <tbody>
+                                        <tr>
+                                          <td style="line-height: 16px; font-size: 16px; width: 100%; height: 16px; margin: 0;" align="left" width="100%" height="16">
+                                            &#160;
+                                          </td>
+                                        </tr>
+                                      </tbody>
+                                    </table>
+                                    <p class="" style="line-height: 24px; font-size: 16px; width: 100%; margin: 0;" align="left">
+                                      If you wish, you can now proceed to reset the password on it, click
+                                      below to continue.
+                                    </p>
+                                    <table class="s-4 w-full" role="presentation" border="0" cellpadding="0" cellspacing="0" style="width: 100%;" width="100%">
+                                      <tbody>
+                                        <tr>
+                                          <td style="line-height: 16px; font-size: 16px; width: 100%; height: 16px; margin: 0;" align="left" width="100%" height="16">
+                                            &#160;
+                                          </td>
+                                        </tr>
+                                      </tbody>
+                                    </table>
+                                    <table class="btn btn-primary p-3 fw-700" role="presentation" border="0" cellpadding="0" cellspacing="0" style="border-radius: 6px; border-collapse: separate !important; font-weight: 700 !important;">
+                                      <tbody>
+                                        <tr>
+                                          <td style="line-height: 24px; font-size: 16px; border-radius: 6px; font-weight: 700 !important; margin: 0;" align="center" bgcolor="#0d6efd">
+                                            <a href="{{url}}" style="color: #ffffff; font-size: 16px; font-family: Helvetica, Arial, sans-serif; text-decoration: none; border-radius: 6px; line-height: 20px; display: block; font-weight: 700 !important; white-space: nowrap; background-color: #0d6efd; padding: 12px; border: 1px solid #0d6efd;">Reset</a>
+                                          </td>
+                                        </tr>
+                                      </tbody>
+                                    </table>
+                                  </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>
+                            <div class="text-muted text-center" style="color: #718096;" align="center">
+                              This email is intended for {{email}}<br>
+                              Sent from Revolt<br>
+                              Made in Europe
+                            </div>
+                            <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="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>
+                    </table>
+                    <!--[if (gte mso 9)|(IE)]>
+                    </td>
+                  </tr>
+                </tbody>
+              </table>
+                    <![endif]-->
+                  </td>
+                </tr>
+              </tbody>
+            </table>
+          </td>
+        </tr>
+      </tbody>
+    </table>
+  </body>
+</html>

crates/core/database/templates/reset-existing.original.html

@@ -0,0 +1,41 @@
+<html>
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <style>
+      /* Add custom classes and styles that you want inlined here */
+    </style>
+  </head>
+  <body class="bg-light">
+    <div class="container">
+      <img
+        class="ax-center my-10 w-24"
+        src="https://app.revolt.chat/assets/logo_round.png"
+      />
+      <div class="card p-6 p-lg-10 space-y-4">
+        <h1 class="h3 fw-700">Password Reset</h1>
+        <p>
+          You tried to create a new account with or try to re-verify this email
+          but there is already an existing verified account under this email.
+        </p>
+        <p>
+          If you wish, you can now proceed to reset the password on it, click
+          below to continue.
+        </p>
+        <a class="btn btn-primary p-3 fw-700" href="{{url}}">Reset</a>
+      </div>
+      <div class="text-muted text-center my-6">
+        This email is intended for {{email}}<br />
+        Sent from Revolt<br />
+        Made in Europe
+      </div>
+      <div class="text-muted text-xs my-6 ax-center">
+        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>
+    </div>
+  </body>
+</html>