chore(images): Build all images.

chore(images): s/handmade-revolt/handmade-revolt-backend/
chore(pushd/ci): Build image pushd image in-fork.
2026-06-27 11:31:14 -07:00 · 2026-06-27 11:28:34 -07:00 · 2026-06-27 00:34:53 -07:00 · 2026-06-27 00:12:11 -07:00 · 2026-06-27 00:06:05 -07:00
272 changed files with 6798 additions and 9587 deletions
@@ -1,2 +1,2 @@
 [profile.default]
-slow-timeout = { period = "5s", terminate-after = 10 }
+slow-timeout = { period = "3s", terminate-after = 2 }
@@ -1,193 +1,113 @@
-name: Docker Test & Publish
+name: Docker

 on:
  push:
-    tags:
-      - "*"
+    branches:
+    - "handmade"
  pull_request:
    branches:
-      - "main"
-    paths:
-      - "Dockerfile"
+    - "handmade"
+  release:
+    types:
+    - published

 permissions:
-  contents: read
-  packages: write
+    contents: read

 jobs:
-  base:
-    name: Test base image build
-    runs-on: ubuntu-latest
-    if: github.event_name == 'pull_request'
-    steps:
-      # Configure build environment
-      - name: Checkout
-        uses: actions/checkout@v3
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
+    # Builds the shared base image: the whole Rust workspace compiled once.
+    # Every service image (currently only pushd) is derived from this so the
+    # workspace is built a single time per release. On non-release events this
+    # still runs as a compile check, but nothing is pushed.
+    base:
+        runs-on: ubuntu-latest
+        steps:
+            - name: Checkout
+              uses: actions/checkout@v4
+            - name: Set up Docker Buildx
+              uses: docker/setup-buildx-action@v3
+            - name: Resolve registry host and owner
+              id: registry
+              # Owner is lowercased: Docker repository names must be lowercase.
+              run: |
+                  echo "host=${GITHUB_SERVER_URL#*://}" >> "$GITHUB_OUTPUT"
+                  echo "owner=$(echo "$GITHUB_REPOSITORY_OWNER" | tr '[:upper:]' '[:lower:]')" >> "$GITHUB_OUTPUT"
+            - name: Base image ref
+              id: base
+              run: echo "image=${{ steps.registry.outputs.host }}/${{ steps.registry.outputs.owner }}/handmade-revolt-backend-base" >> "$GITHUB_OUTPUT"
+            - name: Login to registry
+              uses: docker/login-action@v3
+              if: github.event_name == 'release'
+              with:
+                  registry: ${{ steps.registry.outputs.host }}
+                  username: ${{ secrets.PACKAGE_PUBLISH_USERNAME }}
+                  password: ${{ secrets.PACKAGE_PUBLISH_TOKEN }}
+            - name: Build base image
+              uses: docker/build-push-action@v6
+              with:
+                  context: .
+                  file: Dockerfile
+                  push: ${{ github.event_name == 'release' }}
+                  platforms: linux/amd64
+                  # Pinned to the commit so the publish job below consumes this
+                  # exact base.
+                  tags: |
+                      ${{ steps.base.outputs.image }}:latest
+                      ${{ steps.base.outputs.image }}:${{ github.sha }}

-      # Build the image
-      - name: Build base image
-        uses: docker/build-push-action@v4
-        with:
-          context: .
-          push: false
-          platforms: linux/amd64,linux/arm64
-          tags: ghcr.io/${{ github.repository_owner }}/base:latest
-          cache-from: type=gha,scope=buildx-base-multi-arch
-          cache-to: type=gha,scope=buildx-base-multi-arch,mode=max
-
-  publish:
-    runs-on: self-hosted
-    if: github.event_name != 'pull_request'
-    name: Publish Docker images
-    steps:
-      # Configure build environment
-      - name: Checkout
-        uses: actions/checkout@v3
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
-
-      # Authenticate with Docker Hub and GHCR
-      - name: Login to DockerHub
-        uses: docker/login-action@v2
-        with:
-          registry: docker.io
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Login to Github Container Registry
-        uses: docker/login-action@v2
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      # Build the image
-      - name: Build base image
-        uses: docker/build-push-action@v4
-        with:
-          context: .
-          push: true
-          platforms: linux/amd64,linux/arm64
-          tags: ghcr.io/${{ github.repository_owner }}/base:latest
-
-      # revoltchat/server
-      - name: Docker meta
-        id: meta-delta
-        uses: docker/metadata-action@v4
-        with:
-          images: |
-            docker.io/revoltchat/server
-            ghcr.io/revoltchat/server
-      - name: Publish
-        uses: docker/build-push-action@v4
-        with:
-          context: .
-          push: true
-          platforms: linux/amd64,linux/arm64
-          file: crates/delta/Dockerfile
-          tags: ${{ steps.meta-delta.outputs.tags }}
-          build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
-          labels: ${{ steps.meta-delta.outputs.labels }}
-
-      # revoltchat/bonfire
-      - name: Docker meta
-        id: meta-bonfire
-        uses: docker/metadata-action@v4
-        with:
-          images: |
-            docker.io/revoltchat/bonfire
-            ghcr.io/revoltchat/bonfire
-      - name: Publish
-        uses: docker/build-push-action@v4
-        with:
-          context: .
-          push: true
-          platforms: linux/amd64,linux/arm64
-          file: crates/bonfire/Dockerfile
-          tags: ${{ steps.meta-bonfire.outputs.tags }}
-          build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
-          labels: ${{ steps.meta-bonfire.outputs.labels }}
-
-      # revoltchat/autumn
-      - name: Docker meta
-        id: meta-autumn
-        uses: docker/metadata-action@v4
-        with:
-          images: |
-            docker.io/revoltchat/autumn
-            ghcr.io/revoltchat/autumn
-      - name: Publish
-        uses: docker/build-push-action@v4
-        with:
-          context: .
-          push: true
-          platforms: linux/amd64,linux/arm64
-          file: crates/services/autumn/Dockerfile
-          tags: ${{ steps.meta-autumn.outputs.tags }}
-          build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
-          labels: ${{ steps.meta-autumn.outputs.labels }}
-
-      # revoltchat/january
-      - name: Docker meta
-        id: meta-january
-        uses: docker/metadata-action@v4
-        with:
-          images: |
-            docker.io/revoltchat/january
-            ghcr.io/revoltchat/january
-      - name: Publish
-        uses: docker/build-push-action@v4
-        with:
-          context: .
-          push: true
-          platforms: linux/amd64,linux/arm64
-          file: crates/services/january/Dockerfile
-          tags: ${{ steps.meta-january.outputs.tags }}
-          build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
-          labels: ${{ steps.meta-january.outputs.labels }}
-
-      # revoltchat/crond
-      - name: Docker meta
-        id: meta-crond
-        uses: docker/metadata-action@v4
-        with:
-          images: |
-            docker.io/revoltchat/crond
-            ghcr.io/revoltchat/crond
-      - name: Publish
-        uses: docker/build-push-action@v4
-        with:
-          context: .
-          push: true
-          platforms: linux/amd64,linux/arm64
-          file: crates/daemons/crond/Dockerfile
-          tags: ${{ steps.meta-crond.outputs.tags }}
-          build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
-          labels: ${{ steps.meta-crond.outputs.labels }}
-
-      # revoltchat/pushd
-      - name: Docker meta
-        id: meta-pushd
-        uses: docker/metadata-action@v4
-        with:
-          images: |
-            docker.io/revoltchat/pushd
-            ghcr.io/revoltchat/pushd
-      - name: Publish
-        uses: docker/build-push-action@v4
-        with:
-          context: .
-          push: true
-          platforms: linux/amd64,linux/arm64
-          file: crates/daemons/pushd/Dockerfile
-          tags: ${{ steps.meta-pushd.outputs.tags }}
-          build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
-          labels: ${{ steps.meta-pushd.outputs.labels }}
+    # Builds individual service images from the base. Only runs on release.
+    publish:
+        needs: [base]
+        runs-on: ubuntu-latest
+        if: github.event_name == 'release'
+        strategy:
+            matrix:
+                include:
+                    - { project: pushd,   path: crates/daemons/pushd,     image: handmade-revolt-backend-pushd }
+                    - { project: delta,   path: crates/delta,             image: handmade-revolt-backend-server  }
+                    - { project: bonfire, path: crates/bonfire,           image: handmade-revolt-backend-bonfire }
+                    - { project: autumn,  path: crates/services/autumn,   image: handmade-revolt-backend-autumn  }
+                    - { project: january, path: crates/services/january,  image: handmade-revolt-backend-january }
+                    - { project: crond,   path: crates/daemons/crond,     image: handmade-revolt-backend-crond   }
+        name: Build ${{ matrix.project }} image
+        steps:
+            - name: Checkout
+              uses: actions/checkout@v4
+            - name: Set up Docker Buildx
+              uses: docker/setup-buildx-action@v3
+            - name: Resolve registry host and owner
+              id: registry
+              # Owner is lowercased: Docker repository names must be lowercase,
+              # but the org (e.g. HMC) may be uppercase.
+              run: |
+                  echo "host=${GITHUB_SERVER_URL#*://}" >> "$GITHUB_OUTPUT"
+                  echo "owner=$(echo "$GITHUB_REPOSITORY_OWNER" | tr '[:upper:]' '[:lower:]')" >> "$GITHUB_OUTPUT"
+            - name: Docker meta
+              id: meta
+              uses: docker/metadata-action@v5
+              with:
+                  images: ${{ steps.registry.outputs.host }}/${{ steps.registry.outputs.owner }}/${{ matrix.image }}
+                  tags: |
+                      type=semver,pattern={{version}}
+                      type=semver,pattern={{major}}.{{minor}}
+                      type=raw,value=latest
+              env:
+                  DOCKER_METADATA_ANNOTATIONS_LEVELS: manifest,index
+            - name: Login to registry
+              uses: docker/login-action@v3
+              with:
+                  registry: ${{ steps.registry.outputs.host }}
+                  username: ${{ secrets.PACKAGE_PUBLISH_USERNAME }}
+                  password: ${{ secrets.PACKAGE_PUBLISH_TOKEN }}
+            - name: Build and publish
+              uses: docker/build-push-action@v6
+              with:
+                  context: .
+                  file: ${{ matrix.path }}/Dockerfile
+                  push: true
+                  platforms: linux/amd64
+                  build-args: |
+                      BASE_IMAGE=${{ steps.registry.outputs.host }}/${{ steps.registry.outputs.owner }}/handmade-revolt-backend-base:${{ github.sha }}
+                  tags: ${{ steps.meta.outputs.tags }}
+                  annotations: ${{ steps.meta.outputs.annotations }}
+                  labels: ${{ steps.meta.outputs.labels }}
@@ -5,8 +5,6 @@ compose.override.yml
 target
 .data
 .env
-.venv/
-venv/

 .vercel
 .DS_Store
@@ -1,6 +1,6 @@
 {
  "editor.formatOnSave": true,
-  "rust-analyzer.check.command": "clippy",
+  "rust-analyzer.checkOnSave.command": "clippy",
  "nixEnvSelector.suggestion": false,
  "nixEnvSelector.nixFile": "${workspaceFolder}/default.nix"
-}
+}
@@ -6,17 +6,19 @@ members = [
    "crates/bonfire",
    "crates/core/*",
    "crates/services/*",
+    "crates/bindings/*",
    "crates/daemons/*",
 ]

 [patch.crates-io]
-redis23 = { package = "redis", version = "0.23.3", git = "https://github.com/revoltchat/redis-rs", rev = "523b2937367e17bd0073722bf6e23d06042cb4e4" }
-#authifier = { package = "authifier", version = "1.0.10", path = "../authifier/crates/authifier" }
-#rocket_authifier = { package = "rocket_authifier", version = "1.0.10", path = "../authifier/crates/rocket_authifier" }
+redis22 = { package = "redis", version = "0.22.3", git = "https://github.com/revoltchat/redis-rs", rev = "1a41faf356fd21aebba71cea7eb7eb2653e5f0ef" }
+redis23 = { package = "redis", version = "0.23.1", git = "https://github.com/revoltchat/redis-rs", rev = "f8ca28ab85da59d2ccde526b4d2fb390eff5a5f9" }
+# authifier = { package = "authifier", version = "1.0.8", path = "../authifier/crates/authifier" }
+# rocket_authifier = { package = "rocket_authifier", version = "1.0.8", path = "../authifier/crates/rocket_authifier" }

 # I'm 99% sure this is overloading the GitHub worker
 # hence builds have been failing since, let's just
 # disable it for now. In the future, we could use this
-# if we were rolling our own CI (that is now).
-[profile.release]
-lto = true
+# if we were rolling our own CI.
+# [profile.release]
+# lto = true
@@ -1,5 +1,5 @@
 # Build Stage
-FROM --platform="${BUILDPLATFORM}" rust:1.86.0-slim-bookworm
+FROM --platform="${BUILDPLATFORM}" rust:1.77.2-slim-bookworm
 USER 0:0
 WORKDIR /home/rust/src

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

 # Build all dependencies
 COPY Cargo.toml Cargo.lock ./
+COPY crates/bindings/node/Cargo.toml ./crates/bindings/node/
 COPY crates/bonfire/Cargo.toml ./crates/bonfire/
 COPY crates/delta/Cargo.toml ./crates/delta/
 COPY crates/core/config/Cargo.toml ./crates/core/config/
 COPY crates/core/database/Cargo.toml ./crates/core/database/
 COPY crates/core/files/Cargo.toml ./crates/core/files/
 COPY crates/core/models/Cargo.toml ./crates/core/models/
-COPY crates/core/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/
@@ -1,5 +1,5 @@
 # Build Stage
-FROM rust:1.86.0-slim-bookworm
+FROM rust:1.77.2-slim-bookworm
 USER 0:0
 WORKDIR /home/rust/src

@@ -13,13 +13,13 @@ COPY scripts/build-image-layer.sh /tmp/

 # Build all dependencies
 COPY Cargo.toml Cargo.lock ./
+COPY crates/bindings/node/Cargo.toml ./crates/bindings/node/
 COPY crates/bonfire/Cargo.toml ./crates/bonfire/
 COPY crates/delta/Cargo.toml ./crates/delta/
 COPY crates/core/config/Cargo.toml ./crates/core/config/
 COPY crates/core/database/Cargo.toml ./crates/core/database/
 COPY crates/core/files/Cargo.toml ./crates/core/files/
 COPY crates/core/models/Cargo.toml ./crates/core/models/
-COPY crates/core/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/
@@ -12,31 +12,32 @@
 The services and libraries that power the Revolt service.<br/>
 <br/>

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

 </div>
 <br/>

 ## Minimum Supported Rust Version

-Rust 1.86.0 or higher.
+Rust 1.76 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.
+> 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).

 ## Development Guide

@@ -114,8 +115,7 @@ If you'd like to change anything, create a `Revolt.overrides.toml` file and spec
 > And corresponding Revolt configuration:
 >
 > ```toml
-> #     Revolt.overrides.toml
-> # and Revolt.test-overrides.toml
+> # Revolt.overrides.toml
 > [database]
 > mongodb = "mongodb://127.0.0.1:14017"
 > redis = "redis://127.0.0.1:14079/"
@@ -1,5 +1,5 @@
 # ⚠️ This configuration is intended for development environment.
-# If you'd like to override anything, create a Revolt.overrides.toml
+# If you'd like to override anything, create a Revolt.override.toml

 [database]
 # MongoDB connection URL
@@ -38,7 +38,6 @@ from_address = "development@revolt.chat"
 reply_to = "support@revolt.chat"
 port = 14025
 use_tls = false
-use_starttls = false

 [files.s3]
 # S3 protocol endpoint
@@ -34,7 +34,7 @@ services:
      - minio
    entrypoint: >
      /bin/sh -c "while ! /usr/bin/mc ready minio; do
-        /usr/bin/mc alias set minio http://minio:9000 minioautumn minioautumn;
+        /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;"

@@ -0,0 +1,7 @@
+target
+index.node
+**/node_modules
+**/.DS_Store
+npm-debug.log*
+cargo.log
+cross.log
@@ -0,0 +1,25 @@
+[package]
+name = "revolt-nodejs-bindings"
+version = "0.8.2"
+description = "Node.js bindings for the Revolt software"
+authors = ["Paul Makles <me@insrt.uk>"]
+license = "MIT"
+edition = "2021"
+exclude = ["index.node"]
+
+[lib]
+crate-type = ["cdylib"]
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+neon = "1.0.0"
+neon-serde4 = "1.0.0"
+
+serde = { version = "1", features = ["derive"] }
+
+async-std = "1.12.0"
+
+revolt-config = { version = "0.8.2", path = "../../core/config" }
+revolt-result = { version = "0.8.2", path = "../../core/result" }
+revolt-database = { version = "0.8.2", path = "../../core/database" }
@@ -0,0 +1,92 @@
+# revolt.node
+
+**revolt.node:** Node.js bindings for the Revolt software
+
+This project was bootstrapped by [create-neon](https://www.npmjs.com/package/create-neon).
+
+## Building revolt.node
+
+Building revolt.node requires a [supported version of Node and Rust](https://github.com/neon-bindings/neon#platform-support).
+
+To run the build, run:
+
+```sh
+$ npm run build
+```
+
+This command uses the [@neon-rs/cli](https://www.npmjs.com/package/@neon-rs/cli) utility to assemble the binary Node addon from the output of `cargo`.
+
+## Exploring revolt.node
+
+After building revolt.node, you can explore its exports at the Node console:
+
+```sh
+$ npm i
+$ npm run build
+$ node
+> require('.').hello()
+'hello node'
+```
+
+## Available Scripts
+
+In the project directory, you can run:
+
+#### `npm install`
+
+Installs the project, including running `npm run build`.
+
+#### `npm run build`
+
+Builds the Node addon (`index.node`) from source, generating a release build with `cargo --release`.
+
+Additional [`cargo build`](https://doc.rust-lang.org/cargo/commands/cargo-build.html) arguments may be passed to `npm run build` and similar commands. For example, to enable a [cargo feature](https://doc.rust-lang.org/cargo/reference/features.html):
+
+```
+npm run build -- --feature=beetle
+```
+
+#### `npm run debug`
+
+Similar to `npm run build` but generates a debug build with `cargo`.
+
+#### `npm run cross`
+
+Similar to `npm run build` but uses [cross-rs](https://github.com/cross-rs/cross) to cross-compile for another platform. Use the [`CARGO_BUILD_TARGET`](https://doc.rust-lang.org/cargo/reference/config.html#buildtarget) environment variable to select the build target.
+
+#### `npm test`
+
+Runs the unit tests by calling `cargo test`. You can learn more about [adding tests to your Rust code](https://doc.rust-lang.org/book/ch11-01-writing-tests.html) from the [Rust book](https://doc.rust-lang.org/book/).
+
+## Project Layout
+
+The directory structure of this project is:
+
+```
+revolt.node/
+├── Cargo.toml
+├── README.md
+├── src/
+|   └── lib.rs
+├── index.node
+├── package.json
+└── target/
+```
+
+| Entry          | Purpose                                                                                                                                  |
+|----------------|------------------------------------------------------------------------------------------------------------------------------------------|
+| `Cargo.toml`   | The Cargo [manifest file](https://doc.rust-lang.org/cargo/reference/manifest.html), which informs the `cargo` command.                   |
+| `README.md`    | This file.                                                                                                                               |
+| `src/`         | The directory tree containing the Rust source code for the project.                                                                      |
+| `lib.rs`       | Entry point for the Rust source code.                                                                                                          |
+| `index.node`   | The main module, a [Node addon](https://nodejs.org/api/addons.html) generated by the build and pointed to by `"main"` in `package.json`. |
+| `package.json` | The npm [manifest file](https://docs.npmjs.com/cli/v7/configuring-npm/package-json), which informs the `npm` command.                    |
+| `target/`      | Binary artifacts generated by the Rust build.                                                                                            |
+
+## Learn More
+
+Learn more about:
+
+- [Neon](https://neon-bindings.com).
+- [Rust](https://www.rust-lang.org).
+- [Node](https://nodejs.org).
@@ -0,0 +1,84 @@
+import { Channel, User } from "revolt-api";
+
+/**
+ * Opaque type for Revolt database
+ */
+export declare interface Database {}
+
+/**
+ * Opaque type for Revolt database
+ */
+export declare interface OpaqueUser {}
+
+/**
+ * Error type from Revolt backend
+ */
+export declare interface Err {
+  type: string;
+  location: string;
+}
+
+/**
+ * Initialises background tasks and logging, must be called before anything else!
+ * Can be called multiple times!
+ */
+export declare function init();
+
+/**
+ * Gets a new handle to the Revolt database
+ * @returns {Database} Handle
+ */
+export declare function database(): Database;
+
+/**
+ * Fetch user from database
+ * @param {string} userId User's ID
+ * @this {Database}
+ */
+export declare function database_fetch_user(userId: string): OpaqueUser;
+
+/**
+ * Fetch user from database
+ * @param {string} username Username
+ * @param {string} discriminator Discriminator
+ * @this {Database}
+ */
+export declare function database_fetch_user_by_username(
+  username: string,
+  discriminator: string
+): OpaqueUser;
+
+/**
+ * Gets model data as JSON
+ * @this {OpaqueUser}
+ */
+export declare function model_data(): User;
+
+/**
+ * Gets error if the model failed to fetch
+ * @this {OpaqueUser}
+ */
+export declare function model_error(): Err;
+
+/**
+ * Open a direct message channel between two users
+ * @param {string} userA User A ID
+ * @param {string} userB User B ID
+ * @returns Existing or newly created channel
+ */
+export declare function proc_channels_create_dm(
+  userA: string,
+  userB: string
+): Promise<Channel & { error: Err }>;
+
+/**
+ * Suspend a user
+ * @param {string} user User
+ * @param {number} duration Duration (in days), set to 0 for indefinite
+ * @param {string} reason Pipe-separated list of reasons (e.g. reason1|reason2|reason3)
+ */
+export declare function proc_users_suspend(
+  user: OpaqueUser,
+  duration: number,
+  reason: string
+): Promise<{ error: Err }>;
@@ -0,0 +1,36 @@
+{
+  "name": "revolt-nodejs-bindings",
+  "version": "0.7.15-rev0.0.3",
+  "description": "Node.js bindings for the Revolt software",
+  "main": "index.node",
+  "scripts": {
+    "test": "cargo test",
+    "cargo-build": "cargo build --message-format=json > cargo.log",
+    "cross-build": "cross build --message-format=json > cross.log",
+    "postcargo-build": "neon dist < cargo.log",
+    "postcross-build": "neon dist -m /target < cross.log",
+    "debug": "npm run cargo-build --",
+    "build": "npm run cargo-build -- --release",
+    "cross": "npm run cross-build -- --release"
+  },
+  "author": "Paul Makles",
+  "license": "AGPL-3.0",
+  "devDependencies": {
+    "@neon-rs/cli": "0.1.73"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/revoltchat/backend"
+  },
+  "keywords": [
+    "revolt",
+    "chat"
+  ],
+  "bugs": {
+    "url": "https://github.com/revoltchat/backend/issues"
+  },
+  "homepage": "https://github.com/revoltchat/backend#readme",
+  "dependencies": {
+    "revolt-api": "^0.7.15"
+  }
+}
@@ -0,0 +1,117 @@
+lockfileVersion: '6.0'
+
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false
+
+dependencies:
+  revolt-api:
+    specifier: ^0.7.15
+    version: 0.7.15
+
+devDependencies:
+  '@neon-rs/cli':
+    specifier: 0.1.73
+    version: 0.1.73
+
+packages:
+
+  /@cargo-messages/android-arm-eabi@0.1.72:
+    resolution: {integrity: sha512-gGZxIM1mj+Y5x+ULND6ZCNr7f70OJi9wDlycSK8hGONy9wrChN6JAIHryddC5cqcwlYAoQ6IDcDFElnhAYbybA==}
+    cpu: [arm]
+    os: [android]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@cargo-messages/darwin-arm64@0.1.72:
+    resolution: {integrity: sha512-EAzN5MLaXPljZKZDO5qR+aBs44eSq2ZbEnS7AI/FziE3MzeXbrGOS3fLba5+7yWPFXJyZolXzePm8N1EBv8ovg==}
+    cpu: [arm64]
+    os: [darwin]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@cargo-messages/darwin-x64@0.1.72:
+    resolution: {integrity: sha512-RLo6j8s3nYbjdd1LDct4wamfChyRit7zokUuxtIYCu9XOlltkN5vnj1vwnrPvoqCMZ/7CbbuHFwSTn9A71de/w==}
+    cpu: [x64]
+    os: [darwin]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@cargo-messages/linux-arm-gnueabihf@0.1.72:
+    resolution: {integrity: sha512-tHsRshuzfjrX6SDW3jg6al8vMNLTMgczGnVYl5RuBZf/yrAUuwe30KxA9ge6w6mW6Ox797DyBchzAc9OLgTgmQ==}
+    cpu: [arm]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@cargo-messages/linux-x64-gnu@0.1.72:
+    resolution: {integrity: sha512-VGtL6CCnUbhsP4aYuBNT5kfrAL7o0qjrxw97a+ax13t+nJd26tVEEIKHMu5drvvS/Nm/hn7sLT8zMnnCv0pvHg==}
+    cpu: [x64]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@cargo-messages/win32-arm64-msvc@0.1.72:
+    resolution: {integrity: sha512-V93Cgz39K+yqa3MveNbhh29pYCp8izK5uEavjPoxlNxAbsMCWH+s0verGDdUcfGxjR1H2V7oZ4FszPqR2SqMRQ==}
+    cpu: [arm64]
+    os: [win32]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@cargo-messages/win32-x64-msvc@0.1.72:
+    resolution: {integrity: sha512-knz3uSrO0OSbq3U5VWfCY8FB4NsM43BOWLZ7x4sfaMOC1XWv+IyvDdkLe6DhJx8KUw46KIAimYs9YROrp6l46Q==}
+    cpu: [x64]
+    os: [win32]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@neon-rs/cli@0.1.73:
+    resolution: {integrity: sha512-1kv8S/feB6UQWQQwsnGfkSkEBOtlFDNExnioL81E2BwvUWgjQPaseHgpi2EpWVgsPUgur5eBm4QowmlpWkD4/w==}
+    hasBin: true
+    optionalDependencies:
+      '@cargo-messages/android-arm-eabi': 0.1.72
+      '@cargo-messages/darwin-arm64': 0.1.72
+      '@cargo-messages/darwin-x64': 0.1.72
+      '@cargo-messages/linux-arm-gnueabihf': 0.1.72
+      '@cargo-messages/linux-x64-gnu': 0.1.72
+      '@cargo-messages/win32-arm64-msvc': 0.1.72
+      '@cargo-messages/win32-x64-msvc': 0.1.72
+    dev: true
+
+  /axios@0.26.1:
+    resolution: {integrity: sha512-fPwcX4EvnSHuInCMItEhAGnaSEXRBjtzh9fOtsE6E1G6p7vl7edEeZe11QHf18+6+9gR5PbKV/sGKNaD8YaMeA==}
+    dependencies:
+      follow-redirects: 1.15.6
+    transitivePeerDependencies:
+      - debug
+    dev: false
+
+  /follow-redirects@1.15.6:
+    resolution: {integrity: sha512-wWN62YITEaOpSK584EZXJafH1AGpO8RVgElfkuXbTOrPX4fIfOyEpW/CsiNd8JdYrAoOvafRTOEnvsO++qCqFA==}
+    engines: {node: '>=4.0'}
+    peerDependencies:
+      debug: '*'
+    peerDependenciesMeta:
+      debug:
+        optional: true
+    dev: false
+
+  /lodash.defaultsdeep@4.6.1:
+    resolution: {integrity: sha512-3j8wdDzYuWO3lM3Reg03MuQR957t287Rpcxp1njpEa8oDrikb+FwGdW3n+FELh/A6qib6yPit0j/pv9G/yeAqA==}
+    dev: false
+
+  /revolt-api@0.7.15:
+    resolution: {integrity: sha512-rWRnjBFvoXt/RHRxHg9KuP+x1Jk61KdsOpKOczVJg5tIqGDmqp/6QZHw5rJTtG+wCH3Ah3YKwY+MM5NHfg1W3Q==}
+    dependencies:
+      axios: 0.26.1
+      lodash.defaultsdeep: 4.6.1
+    transitivePeerDependencies:
+      - debug
+    dev: false
@@ -0,0 +1,221 @@
+#[macro_use]
+extern crate serde;
+
+use std::sync::OnceLock;
+
+use neon::prelude::*;
+use revolt_database::{Database, DatabaseInfo};
+
+fn js_init(mut cx: FunctionContext) -> JsResult<JsUndefined> {
+    // static INIT: OnceLock<()> = OnceLock::new();
+    // if INIT.get().is_none() {
+    //     INIT.get_or_init(|| {
+    //         async_std::task::block_on(async {
+    //             revolt_config::configure!(api);
+
+    //             match DatabaseInfo::Auto.connect().await {
+    //                 Ok(db) => {
+    //                     let authifier_db = db.clone().to_authifier().await.database;
+    //                     revolt_database::tasks::start_workers(db, authifier_db);
+    //                     Ok(())
+    //                 }
+    //                 Err(err) => Err(err),
+    //             }
+    //         })
+    //         .or_else(|err| cx.throw_error(err))
+    //         .unwrap();
+    //     });
+    // }
+
+    Ok(cx.undefined())
+}
+
+struct DatabaseBinding(Database, Channel);
+impl Finalize for DatabaseBinding {}
+impl DatabaseBinding {
+    fn take(&self) -> (Database, Channel) {
+        (self.0.clone(), self.1.clone())
+    }
+}
+
+fn js_database(mut cx: FunctionContext) -> JsResult<JsBox<DatabaseBinding>> {
+    let db = async_std::task::block_on(DatabaseInfo::Auto.connect())
+        .or_else(|err| cx.throw_error(err))?;
+
+    let channel = cx.channel();
+    Ok(cx.boxed(DatabaseBinding(db, channel)))
+}
+
+// Implementations for models
+#[derive(Clone)]
+#[allow(clippy::large_enum_variant)]
+enum Model {
+    User(revolt_database::User),
+    Error(revolt_result::Error),
+}
+
+impl Model {
+    fn give(&self) -> Model {
+        self.clone()
+    }
+}
+
+impl Finalize for Model {}
+
+macro_rules! shim_boxed {
+    ($cx: ident, $name: ident, $model: ident, $( $variable: ident $type: ident $id: expr )+, $cmd: ident, $( $arg: expr, )+) => {
+        fn $name(mut cx: FunctionContext) -> JsResult<JsPromise> {
+            $(
+                let $variable = cx.argument::<$type>($id)?.value(&mut cx);
+            )+
+
+            let (db, channel) = cx.this::<JsBox<DatabaseBinding>>()?.take();
+            let (deferred, promise) = cx.promise();
+
+            async_std::task::spawn(async move {
+                let result = db.$cmd($($arg,)+).await;
+                deferred.settle_with(&channel, move |mut cx| {
+                    Ok(cx.boxed(match result {
+                        Ok(value) => Model::$model(value),
+                        Err(error) => Model::Error(error)
+                    }))
+                })
+            });
+
+            Ok(promise)
+        }
+
+        $cx.export_function(stringify!($name), $name)?;
+    };
+}
+
+fn js_data(mut cx: FunctionContext) -> JsResult<JsValue> {
+    match cx.this::<JsBox<Model>>()?.give() {
+        Model::Error(_) => neon_serde4::to_value(&mut cx, &None::<()>),
+        Model::User(user) => neon_serde4::to_value(&mut cx, &user),
+    }
+    .or_else(|e| cx.throw_error(e.to_string()))
+}
+
+fn js_error(mut cx: FunctionContext) -> JsResult<JsValue> {
+    let value = match cx.this::<JsBox<Model>>()?.give() {
+        Model::Error(err) => Some(err),
+        _ => None,
+    };
+
+    neon_serde4::to_value(&mut cx, &value).or_else(|e| cx.throw_error(e.to_string()))
+}
+
+// Basic data implementation
+#[derive(Serialize, Deserialize)]
+struct ResultBinding<T> {
+    #[serde(flatten)]
+    value: Option<T>,
+    error: Option<revolt_result::Error>,
+}
+
+macro_rules! shim {
+    ($cx: ident, $name: ident, $( $variable: ident $type: ident $id: expr )*, $( $model: ident $modelType: ident $modelId: expr )*, | $db: ident | $closure: expr, $( $arg: expr, )+) => {
+        fn $name(mut cx: FunctionContext) -> JsResult<JsPromise> {
+            $(
+                let $variable = cx.argument::<$type>($id)?.value(&mut cx);
+            )*
+
+            $(
+                let mut $model = if let Model::$modelType(value) = cx.argument::<JsBox<Model>>($modelId)?.give() {
+                    value
+                } else {
+                    unreachable!()
+                };
+            )*
+
+            let (db, channel) = cx.this::<JsBox<DatabaseBinding>>()?.take();
+            let (deferred, promise) = cx.promise();
+
+            async_std::task::spawn(async move {
+                #[allow(clippy::redundant_closure_call)]
+                let result = (|$db: $crate::Database| $closure)(db.clone()).await;
+                deferred.settle_with(&channel, move |mut cx| {
+                    neon_serde4::to_value(
+                        &mut cx,
+                        &match result {
+                            Ok(value) => ResultBinding {
+                                value: Some(value),
+                                error: None,
+                            },
+                            Err(error) => ResultBinding {
+                                value: None,
+                                error: Some(error),
+                            },
+                        },
+                    )
+                    .or_else(|e| cx.throw_error(e.to_string()))
+                })
+            });
+
+            Ok(promise)
+        }
+
+        $cx.export_function(stringify!($name), $name)?;
+    };
+}
+
+#[neon::main]
+fn main(mut cx: ModuleContext) -> NeonResult<()> {
+    // initialise required background stuff
+    cx.export_function("init", js_init)?;
+
+    // database & model stuff
+    cx.export_function("database", js_database)?;
+    cx.export_function("model_data", js_data)?;
+    cx.export_function("model_error", js_error)?;
+
+    shim_boxed!(
+        cx,
+        database_fetch_user,
+        User,
+        user_id JsString 0,
+        fetch_user,
+        &user_id,
+    );
+
+    shim_boxed!(
+        cx,
+        database_fetch_user_by_username,
+        User,
+        username JsString 0
+        discriminator JsString 1,
+        fetch_user_by_username,
+        &username, &discriminator,
+    );
+
+    // procedure calls
+    shim!(
+        cx,
+        proc_channels_create_dm,
+        user_a JsString 0
+        user_b JsString 1,
+        ,
+        |db| async move {
+            let user_a = db.fetch_user(&user_a).await?;
+            let user_b = db.fetch_user(&user_b).await?;
+            revolt_database::Channel::create_dm(&db, &user_a, &user_b).await
+        },
+        &userA, &userB,
+    );
+
+    shim!(
+        cx,
+        proc_users_suspend,
+        duration JsNumber 1
+        reason JsString 2,
+        user User 0,
+        |db| async move {
+            let duration = duration as usize;
+            user.suspend(&db, if duration == 0 { None } else { Some(duration) }, Some(reason.split('|').map(|x| x.to_owned()).collect())).await
+        },
+        &user,
+    );
+
+    Ok(())
+}
@@ -0,0 +1,53 @@
+const Internal = require(".");
+
+// playing around with class wrapper, not practical
+class Model {
+  constructor(model) {
+    this.model = model;
+  }
+
+  data() {
+    return Internal.model_data.bind(this.model)();
+  }
+
+  error() {
+    return Internal.model_error.bind(this.model)();
+  }
+}
+
+class User extends Model {
+  constructor(db, user) {
+    super(user);
+    this.db = db;
+  }
+}
+
+class Database {
+  constructor() {
+    this.db = Internal.database();
+  }
+
+  async fetchUser(userId) {
+    return new User(
+      this,
+      await Internal.database_fetch_user.bind(this.db)(userId)
+    );
+  }
+
+  async fetchUserByUsername(username, discriminator) {
+    return new User(
+      this,
+      await Internal.database_fetch_user_by_username.bind(this.db)(
+        username,
+        discriminator
+      )
+    );
+  }
+}
+
+const db = new Database();
+db.fetchUserByUsername("dos", "7624").then((user) => console.info(user.data()));
+db.fetchUserByUsername("dos", "1111").then((user) => console.info(user.data()));
+db.fetchUserByUsername("dos", "1111").then((user) =>
+  console.info(user.error())
+);
@@ -0,0 +1,6 @@
+{
+  "name": "bindings",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {}
+}
@@ -1,6 +1,6 @@
 [package]
 name = "revolt-bonfire"
-version = "0.8.8"
+version = "0.8.2"
 license = "AGPL-3.0-or-later"
 edition = "2021"

@@ -36,12 +36,12 @@ async-std = { version = "1.8.0", features = [
 ] }

 # core
-authifier = { version = "1.0.15" }
+authifier = { version = "1.0.9" }
 revolt-result = { path = "../core/result" }
 revolt-models = { path = "../core/models" }
 revolt-config = { path = "../core/config" }
 revolt-database = { path = "../core/database" }
-revolt-permissions = { version = "0.8.8", path = "../core/permissions" }
+revolt-permissions = { version = "0.8.2", path = "../core/permissions" }
 revolt-presence = { path = "../core/presence", features = ["redis-is-patched"] }

 # redis
@@ -1,6 +1,5 @@
 use std::collections::HashSet;

-use futures::future::join_all;
 use revolt_database::{
    events::client::{EventV1, ReadyPayloadFields},
    util::permissions::DatabasePermissionQuery,
@@ -100,18 +99,6 @@ impl State {
        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
@@ -187,7 +174,7 @@ impl State {
            .iter()
            .find(|e| matches!(e, ReadyPayloadFields::UserSettings(_)))
        {
-            Some(db.fetch_user_settings(&user.id, keys).await?)
+            Some(db.fetch_user_settings(&user.id, &keys).await?)
        } else {
            None
        };
@@ -211,11 +198,13 @@ impl State {
            .collect();

        // Make all users appear from our perspective.
-        let mut users: Vec<v0::User> = join_all(users.into_iter().map(|other_user| async {
-            let is_online = online_ids.contains(&other_user.id);
-            other_user.into_known(&user, is_online).await
-        }))
-        .await;
+        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();

        // Make sure we see our own user correctly.
        users.push(user.into_self(true).await);
@@ -239,7 +228,6 @@ impl State {
        for channel in &channels {
            self.insert_subscription(channel.id().to_string()).await;
        }
-
        Ok(EventV1::Ready {
            users: if fields.contains(&ReadyPayloadFields::Users) {
                Some(users)
@@ -265,8 +253,6 @@ impl State {

            user_settings,
            channel_unreads: channel_unreads.map(|vec| vec.into_iter().map(Into::into).collect()),
-
-            policy_changes,
        })
    }

@@ -3,7 +3,7 @@ use std::{collections::HashSet, net::SocketAddr, sync::Arc};
 use async_tungstenite::WebSocketStream;
 use authifier::AuthifierEvent;
 use fred::{
-    error::RedisErrorKind,
+    error::{RedisError, RedisErrorKind},
    interfaces::{ClientLike, EventInterface, PubsubInterface},
    types::RedisConfig,
 };
@@ -17,7 +17,6 @@ use redis_kiss::{PayloadType, REDIS_PAYLOAD_TYPE, REDIS_URI};
 use revolt_config::report_internal_error;
 use revolt_database::{
    events::{client::EventV1, server::ClientMessage},
-    iso8601_timestamp::Timestamp,
    Database, User, UserHint,
 };
 use revolt_presence::{create_session, delete_session};
@@ -101,10 +100,6 @@ pub async fn client(db: &'static Database, stream: TcpStream, addr: SocketAddr)

    info!("User {addr:?} authenticated as @{}", user.username);

-    db.update_session_last_seen(&session_id, Timestamp::now_utc())
-        .await
-        .ok();
-
    // Create local state.
    let mut state = State::from(user, session_id);
    let user_id = state.cache.user_id.clone();
@@ -1,6 +1,6 @@
 [package]
 name = "revolt-config"
-version = "0.8.8"
+version = "0.8.2"
 edition = "2021"
 license = "MIT"
 authors = ["Paul Makles <me@insrt.uk>"]
@@ -9,11 +9,9 @@ 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"]
-sentry = ["dep:sentry"]
 test = ["async-std"]
-default = ["test", "sentry"]
+default = ["test"]

 [dependencies]
 # Utility
@@ -33,8 +31,7 @@ log = "0.4.14"
 pretty_env_logger = "0.4.0"

 # Sentry
-sentry = { version = "0.31.5", optional = true }
-sentry-anyhow = { version = "0.38.1", optional = true }
+sentry = "0.31.5"

 # Core
-revolt-result = { version = "0.8.8", path = "../result", optional = true }
+revolt-result = { version = "0.8.2", path = "../result", optional = true }
@@ -7,6 +7,3 @@ host = "127.0.0.1"
 port = 5672
 username = "rabbituser"
 password = "rabbitpass"
-
-[features]
-webhooks_enabled = true
@@ -1,5 +1,3 @@
-production = false
-
 [database]
 # MongoDB connection URL
 # Defaults to the container name specified in self-hosted
@@ -54,8 +52,6 @@ authifier_shield_key = ""
 voso_legacy_token = ""
 # Whether services are behind the Cloudflare network
 trust_cloudflare = false
-# easypwned endpoint
-easypwned = ""

 [api.security.captcha]
 # hCaptcha configuration
@@ -66,28 +62,19 @@ hcaptcha_sitekey = ""
 # 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
-
+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"
@@ -184,13 +171,9 @@ default_bucket = "revolt-uploads"


 [features]
+# Bucket to upload to by default
 # 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]

@@ -275,5 +258,4 @@ api = ""
 events = ""
 files = ""
 proxy = ""
-pushd = ""
 crond = ""
@@ -6,12 +6,9 @@ use futures_locks::RwLock;
 use once_cell::sync::Lazy;
 use serde::Deserialize;

-#[cfg(feature = "sentry")]
 pub use sentry::{capture_error, capture_message, Level};
-#[cfg(feature = "anyhow")]
-pub use sentry_anyhow::capture_anyhow;

-#[cfg(all(feature = "report-macros", feature = "sentry"))]
+#[cfg(feature = "report-macros")]
 #[macro_export]
 macro_rules! report_error {
    ( $expr: expr, $error: ident $( $tt:tt )? ) => {
@@ -26,7 +23,7 @@ macro_rules! report_error {
    };
 }

-#[cfg(all(feature = "report-macros", feature = "sentry"))]
+#[cfg(feature = "report-macros")]
 #[macro_export]
 macro_rules! capture_internal_error {
    ( $expr: expr ) => {
@@ -37,7 +34,7 @@ macro_rules! capture_internal_error {
    };
 }

-#[cfg(all(feature = "report-macros", feature = "sentry"))]
+#[cfg(feature = "report-macros")]
 #[macro_export]
 macro_rules! report_internal_error {
    ( $expr: expr ) => {
@@ -62,9 +59,6 @@ static CONFIG_SEARCH_PATHS: [&str; 3] = [
    "/Revolt.toml",
 ];

-/// Path to search for test overrides
-static TEST_OVERRIDE_PATH: &str = "Revolt.test-overrides.toml";
-
 /// Configuration builder
 static CONFIG_BUILDER: Lazy<RwLock<Config>> = Lazy::new(|| {
    RwLock::new({
@@ -78,20 +72,6 @@ static CONFIG_BUILDER: Lazy<RwLock<Config>> = Lazy::new(|| {
                include_str!("../Revolt.test.toml"),
                FileFormat::Toml,
            ));
-
-            // recursively search upwards for an overrides file (if there is one)
-            if let Ok(cwd) = std::env::current_dir() {
-                let mut path = Some(cwd.as_path());
-                while let Some(current_path) = path {
-                    let target_path = current_path.join(TEST_OVERRIDE_PATH);
-                    if target_path.exists() {
-                        builder = builder
-                            .add_source(File::new(target_path.to_str().unwrap(), FileFormat::Toml));
-                    }
-
-                    path = current_path.parent();
-                }
-            }
        }

        for path in CONFIG_SEARCH_PATHS {
@@ -143,7 +123,6 @@ 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)]
@@ -189,7 +168,6 @@ pub struct ApiSecurity {
    pub voso_legacy_token: String,
    pub captcha: ApiSecurityCaptcha,
    pub trust_cloudflare: bool,
-    pub easypwned: String,
 }

 #[derive(Deserialize, Debug, Clone)]
@@ -197,29 +175,19 @@ pub struct ApiWorkers {
    pub max_concurrent_connections: usize,
 }

-#[derive(Deserialize, Debug, Clone)]
-pub struct ApiUsers {
-    pub early_adopter_cutoff: Option<u64>,
-}
-
 #[derive(Deserialize, Debug, Clone)]
 pub struct Api {
    pub registration: ApiRegistration,
    pub smtp: ApiSmtp,
    pub security: ApiSecurity,
    pub workers: ApiWorkers,
-    pub users: ApiUsers,
 }

 #[derive(Deserialize, Debug, Clone)]
 pub struct Pushd {
    pub production: bool,
    pub exchange: String,
-    pub mass_mention_chunk_size: usize,
-
-    // Queues
    pub message_queue: String,
-    pub mass_mention_queue: String,
    pub fr_accepted_queue: String,
    pub fr_received_queue: String,
    pub generic_queue: String,
@@ -246,10 +214,6 @@ impl Pushd {
        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())
    }
@@ -350,9 +314,6 @@ impl Default for FeaturesAdvanced {
 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,
 }
@@ -363,7 +324,6 @@ pub struct Sentry {
    pub events: String,
    pub files: String,
    pub proxy: String,
-    pub pushd: String,
    pub crond: String,
 }

@@ -377,7 +337,6 @@ pub struct Settings {
    pub files: Files,
    pub features: Features,
    pub sentry: Sentry,
-    pub production: bool,
 }

 impl Settings {
@@ -405,23 +364,10 @@ pub async fn read() -> Config {

 #[cached(time = 30)]
 pub async fn config() -> Settings {
-    let mut config = read().await.try_deserialize::<Settings>().unwrap();
-
-    // inject REDIS_URI for redis-kiss library
-    if std::env::var("REDIS_URL").is_err() {
-        std::env::set_var("REDIS_URI", config.database.redis.clone());
-    }
-
-    // auto-detect production nodes
-    if config.hosts.api.contains("https") && config.hosts.api.contains("revolt.chat") {
-        config.production = true;
-    }
-
-    config
+    read().await.try_deserialize::<Settings>().unwrap()
 }

 /// Configure logging and common Rust variables
-#[cfg(feature = "sentry")]
 pub async fn setup_logging(release: &'static str, dsn: String) -> Option<sentry::ClientInitGuard> {
    if std::env::var("RUST_LOG").is_err() {
        std::env::set_var("RUST_LOG", "info");
@@ -431,6 +377,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}");

@@ -447,7 +399,6 @@ pub async fn setup_logging(release: &'static str, dsn: String) -> Option<sentry:
    }
 }

-#[cfg(feature = "sentry")]
 #[macro_export]
 macro_rules! configure {
    ($application: ident) => {
@@ -1,6 +1,6 @@
 [package]
 name = "revolt-database"
-version = "0.8.8"
+version = "0.8.2"
 edition = "2021"
 license = "AGPL-3.0-or-later"
 authors = ["Paul Makles <me@insrt.uk>"]
@@ -10,12 +10,12 @@ description = "Revolt Backend: Database Implementation"

 [features]
 # Databases
-mongodb = ["dep:mongodb", "bson", "authifier/database-mongodb"]
+mongodb = ["dep:mongodb", "bson"]

 # ... Other
 tasks = ["isahc", "linkify", "url-escape"]
-async-std-runtime = ["async-std", "authifier/async-std-runtime"]
-rocket-impl = ["rocket", "schemars", "revolt_okapi", "revolt_rocket_okapi", "authifier/rocket_impl"]
+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"]

@@ -24,19 +24,18 @@ default = ["mongodb", "async-std-runtime", "tasks"]

 [dependencies]
 # Core
-revolt-config = { version = "0.8.8", path = "../config", features = [
+revolt-config = { version = "0.8.2", path = "../config", features = [
    "report-macros",
 ] }
-revolt-result = { version = "0.8.8", path = "../result" }
-revolt-models = { version = "0.8.8", path = "../models", features = [
+revolt-result = { version = "0.8.2", path = "../result" }
+revolt-models = { version = "0.8.2", path = "../models", features = [
    "validator",
 ] }
-revolt-presence = { version = "0.8.8", path = "../presence" }
-revolt-permissions = { version = "0.8.8", path = "../permissions", features = [
+revolt-presence = { version = "0.8.2", path = "../presence" }
+revolt-permissions = { version = "0.8.2", path = "../permissions", features = [
    "serde",
    "bson",
 ] }
-revolt-parser = { version = "0.8.8", path = "../parser" }

 # Utility
 log = "0.4"
@@ -65,7 +64,7 @@ redis-kiss = { version = "0.1.4" }

 # Database
 bson = { optional = true, version = "2.1.0" }
-mongodb = { optional = true, version = "3.1.0" }
+mongodb = { optional = true, version = "2.1.0", default-features = false }

 # Database Migration
 unicode-segmentation = "1.10.1"
@@ -91,8 +90,13 @@ rocket = { version = "0.5.1", default-features = false, features = [
 revolt_okapi = { version = "0.9.1", optional = true }
 revolt_rocket_okapi = { version = "0.10.0", optional = true }

+# Notifications
+fcm_v1 = "0.3.0"
+web-push = "0.10.0"
+revolt_a2 = { version = "0.10", default-features = false, features = ["ring"] }
+
 # Authifier
-authifier = { version = "1.0.15" }
+authifier = { version = "1.0.9", features = ["rocket_impl"] }

 # RabbitMQ
 amqprs = { version = "1.7.0" }
@@ -3,21 +3,18 @@
    "_object_type": "User",
    "_id": "__ID:0__",
    "username": "Owner",
-    "last_acknowledged_policy_change": "2025-06-07T04:04:48+0000",
    "discriminator": "0001"
  },
  {
    "_object_type": "User",
    "_id": "__ID:1__",
    "username": "Member",
-    "last_acknowledged_policy_change": "2025-06-07T04:04:48+0000",
    "discriminator": "0001"
  },
  {
    "_object_type": "User",
    "_id": "__ID:2__",
    "username": "Member",
-    "last_acknowledged_policy_change": "2025-06-07T04:04:48+0000",
    "discriminator": "0002"
  },
  {
@@ -26,9 +23,6 @@
    "channel_type": "Group",
    "name": "My Group",
    "owner": "__ID:0__",
-    "recipients": [
-      "__ID:0__",
-      "__ID:1__"
-    ]
+    "recipients": ["__ID:0__", "__ID:1__"]
  }
-]
+]
@@ -3,21 +3,18 @@
    "_object_type": "User",
    "_id": "__ID:0__",
    "username": "Owner",
-    "last_acknowledged_policy_change": "2025-06-07T04:04:48+0000",
    "discriminator": "0001"
  },
  {
    "_object_type": "User",
    "_id": "__ID:1__",
    "username": "Moderator",
-    "last_acknowledged_policy_change": "2025-06-07T04:04:48+0000",
    "discriminator": "0001"
  },
  {
    "_object_type": "User",
    "_id": "__ID:2__",
    "username": "User",
-    "last_acknowledged_policy_change": "2025-06-07T04:04:48+0000",
    "discriminator": "0001"
  },
  {
@@ -42,9 +39,7 @@
    "_id": "__ID:4__",
    "owner": "__ID:0__",
    "name": "Server",
-    "channels": [
-      "__ID:3__"
-    ],
+    "channels": ["__ID:3__"],
    "roles": {
      "__ID:5__": {
        "name": "Moderator",
@@ -52,7 +47,7 @@
          "a": 545270208,
          "d": 0
        },
-        "rank": 1
+        "rank": 3
      },
      "__ID:6__": {
        "name": "Owner",
@@ -71,9 +66,7 @@
      "user": "__ID:0__",
      "server": "__ID:4__"
    },
-    "roles": [
-      "__ID:6__"
-    ],
+    "roles": ["__ID:6__"],
    "joined_at": 1698318340195
  },
  {
@@ -82,9 +75,7 @@
      "user": "__ID:1__",
      "server": "__ID:4__"
    },
-    "roles": [
-      "__ID:5__"
-    ],
+    "roles": ["__ID:5__"],
    "joined_at": 1698318340195
  },
  {
@@ -95,4 +86,4 @@
    },
    "joined_at": 1698318340195
  }
-]
+]
@@ -170,38 +170,6 @@ impl AMQP {
            .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,
@@ -1,10 +1,8 @@
-#[cfg(feature = "mongodb")]
 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;
@@ -14,7 +12,6 @@ use authifier::Authifier;
 use rand::Rng;
 use revolt_config::config;

-#[cfg(feature = "mongodb")]
 pub use self::mongodb::*;
 pub use self::reference::*;

@@ -27,10 +24,8 @@ pub enum DatabaseInfo {
    /// Use the mock database
    Reference,
    /// Connect to MongoDB
-    #[cfg(feature = "mongodb")]
    MongoDb { uri: String, database_name: String },
    /// Use existing MongoDB connection
-    #[cfg(feature = "mongodb")]
    MongoDbFromClient(::mongodb::Client, String),
 }

@@ -40,7 +35,6 @@ pub enum Database {
    /// Mock database
    Reference(ReferenceDb),
    /// MongoDB database
-    #[cfg(feature = "mongodb")]
    MongoDb(MongoDb),
 }

@@ -50,7 +44,7 @@ impl DatabaseInfo {
    pub async fn connect(self) -> Result<Database, String> {
        let config = config().await;

-        match self {
+        Ok(match self {
            DatabaseInfo::Auto => {
                if std::env::var("TEST_DB").is_ok() {
                    DatabaseInfo::Test(format!(
@@ -58,20 +52,16 @@ impl DatabaseInfo {
                        rand::thread_rng().gen_range(1_000_000..10_000_000)
                    ))
                    .connect()
-                    .await
+                    .await?
                } else if !config.database.mongodb.is_empty() {
-                    #[cfg(feature = "mongodb")]
-                    return DatabaseInfo::MongoDb {
+                    DatabaseInfo::MongoDb {
                        uri: config.database.mongodb,
                        database_name: "revolt".to_string(),
                    }
                    .connect()
-                    .await;
-
-                    #[cfg(not(feature = "mongodb"))]
-                    return Err("MongoDB not enabled.".to_string())
+                    .await?
                } else {
-                    DatabaseInfo::Reference.connect().await
+                    DatabaseInfo::Reference.connect().await?
                }
            }
            DatabaseInfo::Test(database_name) => {
@@ -79,36 +69,30 @@ impl DatabaseInfo {
                    .expect("`TEST_DB` environment variable should be set to REFERENCE or MONGODB")
                    .as_str()
                {
-                    "REFERENCE" => DatabaseInfo::Reference.connect().await,
+                    "REFERENCE" => DatabaseInfo::Reference.connect().await?,
                    "MONGODB" => {
-                        #[cfg(feature = "mongodb")]
-                        return DatabaseInfo::MongoDb {
+                        DatabaseInfo::MongoDb {
                            uri: config.database.mongodb,
                            database_name,
                        }
                        .connect()
-                        .await;
-
-                        #[cfg(not(feature = "mongodb"))]
-                        return Err("MongoDB not enabled.".to_string())
+                        .await?
                    }
                    _ => unreachable!("must specify REFERENCE or MONGODB"),
                }
            }
-            DatabaseInfo::Reference => Ok(Database::Reference(Default::default())),
-            #[cfg(feature = "mongodb")]
+            DatabaseInfo::Reference => Database::Reference(Default::default()),
            DatabaseInfo::MongoDb { uri, database_name } => {
                let client = ::mongodb::Client::with_uri_str(uri)
                    .await
                    .map_err(|_| "Failed to init db connection.".to_string())?;

-                Ok(Database::MongoDb(MongoDb(client, database_name)))
+                Database::MongoDb(MongoDb(client, database_name))
            }
-            #[cfg(feature = "mongodb")]
            DatabaseInfo::MongoDbFromClient(client, database_name) => {
-                Ok(Database::MongoDb(MongoDb(client, database_name)))
+                Database::MongoDb(MongoDb(client, database_name))
            }
-        }
+        })
    }
 }

@@ -118,13 +102,6 @@ impl Database {
        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 {
@@ -141,69 +118,28 @@ impl Database {
                        ),
                        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,
-                        }
+                    templates: Templates {
+                        verify: Template {
+                            title: "Verify your Revolt account.".into(),
+                            text: include_str!("../../templates/verify.txt").into(),
+                            url: format!("{}/login/verify/", config.hosts.app),
+                            html: Some(include_str!("../../templates/verify.html").into()),
+                        },
+                        reset: Template {
+                            title: "Reset your Revolt password.".into(),
+                            text: include_str!("../../templates/reset.txt").into(),
+                            url: format!("{}/login/reset/", config.hosts.app),
+                            html: Some(include_str!("../../templates/reset.html").into()),
+                        },
+                        deletion: Template {
+                            title: "Confirm account deletion.".into(),
+                            text: include_str!("../../templates/deletion.txt").into(),
+                            url: format!("{}/delete/", config.hosts.app),
+                            html: Some(include_str!("../../templates/deletion.html").into()),
+                        },
+                        welcome: None,
                    },
                }
            } else {
@@ -234,16 +170,12 @@ impl Database {
        Authifier {
            database: match self {
                Database::Reference(_) => Default::default(),
-                #[cfg(feature = "mongodb")]
                Database::MongoDb(MongoDb(client, _)) => authifier::Database::MongoDb(
                    authifier::database::MongoDb(client.database("revolt")),
                ),
            },
            config: auth_config,
-            #[cfg(feature = "tasks")]
            event_channel: Some(crate::tasks::authifier_relay::sender()),
-            #[cfg(not(feature = "tasks"))]
-            event_channel: None,
        }
    }
 }
@@ -10,6 +10,7 @@ use serde::de::DeserializeOwned;
 use serde::Serialize;

 database_derived!(
+    #[cfg(feature = "mongodb")]
    /// MongoDB implementation
    pub struct MongoDb(pub ::mongodb::Client, pub String);
 );
@@ -30,17 +31,17 @@ impl MongoDb {
    }

    /// Get a collection by its name
-    pub fn col<T: Send + Sync>(&self, collection: &str) -> mongodb::Collection<T> {
+    pub fn col<T>(&self, collection: &str) -> mongodb::Collection<T> {
        self.db().collection(collection)
    }

    /// Insert one document into a collection
-    pub async fn insert_one<T: Serialize + Send + Sync>(
+    pub async fn insert_one<T: Serialize>(
        &self,
        collection: &'static str,
        document: T,
    ) -> Result<InsertOneResult> {
-        self.col::<T>(collection).insert_one(document).await
+        self.col::<T>(collection).insert_one(document, None).await
    }

    /// Count documents by projection
@@ -50,7 +51,7 @@ impl MongoDb {
        projection: Document,
    ) -> Result<u64> {
        self.col::<Document>(collection)
-            .count_documents(projection)
+            .count_documents(projection, None)
            .await
    }

@@ -66,8 +67,7 @@ impl MongoDb {
    {
        Ok(self
            .col::<T>(collection)
-            .find(projection)
-            .with_options(options)
+            .find(projection, options)
            .await?
            .filter_map(|s| async {
                if cfg!(debug_assertions) {
@@ -101,8 +101,7 @@ impl MongoDb {
        O: Into<Option<FindOneOptions>>,
    {
        self.col::<T>(collection)
-            .find_one(projection)
-            .with_options(options)
+            .find_one(projection, options)
            .await
    }

@@ -166,7 +165,7 @@ impl MongoDb {
        };

        self.col::<Document>(collection)
-            .update_one(projection, query)
+            .update_one(projection, query, None)
            .await
    }

@@ -201,7 +200,7 @@ impl MongoDb {
        projection: Document,
    ) -> Result<DeleteResult> {
        self.col::<Document>(collection)
-            .delete_one(projection)
+            .delete_one(projection, None)
            .await
    }

@@ -4,8 +4,8 @@ use futures::lock::Mutex;

 use crate::{
    Bot, Channel, ChannelCompositeKey, ChannelUnread, Emoji, File, FileHash, Invite, Member,
-    MemberCompositeKey, Message, PolicyChange, RatelimitEvent, Report, Server, ServerBan, Snapshot,
-    User, UserSettings, Webhook,
+    MemberCompositeKey, Message, RatelimitEvent, Report, Server, ServerBan, Snapshot, User,
+    UserSettings, Webhook,
 };

 database_derived!(
@@ -21,7 +21,6 @@ database_derived!(
        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>>>,
@@ -6,7 +6,7 @@ use revolt_models::v0::{
    AppendMessage, Channel, ChannelUnread, Emoji, FieldsChannel, FieldsMember, FieldsMessage,
    FieldsRole, FieldsServer, FieldsUser, FieldsWebhook, Member, MemberCompositeKey, Message,
    PartialChannel, PartialMember, PartialMessage, PartialRole, PartialServer, PartialUser,
-    PartialWebhook, PolicyChange, RemovalIntention, Report, Server, User, UserSettings, Webhook,
+    PartialWebhook, RemovalIntention, Report, Server, User, UserSettings, Webhook,
 };

 use crate::Database;
@@ -62,8 +62,6 @@ pub enum EventV1 {
        user_settings: Option<UserSettings>,
        #[serde(skip_serializing_if = "Option::is_none")]
        channel_unreads: Option<Vec<ChannelUnread>>,
-
-        policy_changes: Vec<PolicyChange>,
    },

    /// Ping response
@@ -144,13 +142,7 @@ pub enum EventV1 {
    },

    /// User joins server
-    ServerMemberJoin {
-        id: String,
-        // Deprecated: use member.id.user
-        #[deprecated = "Use member.id.user instead"]
-        user: String,
-        member: Member,
-    },
+    ServerMemberJoin { id: String, user: String },

    /// User left server
    ServerMemberLeave {
@@ -171,9 +163,6 @@ pub enum EventV1 {
    /// Server role deleted
    ServerRoleDelete { id: String, role_id: String },

-    /// Server roles ranks updated
-    ServerRoleRanksUpdate { id: String, ranks: Vec<String> },
-
    /// Update existing user
    UserUpdate {
        id: String,
@@ -11,12 +11,6 @@ pub struct MessageSentPayload {
    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,
@@ -1,8 +1,8 @@
-use serde::{Serialize, Deserialize};
+use serde::Deserialize;

 use super::client::Ping;

-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Deserialize, Debug)]
 #[serde(tag = "type")]
 pub enum ClientMessage {
    Authenticate { token: String },
@@ -25,9 +25,6 @@ pub use mongodb;
 #[macro_use]
 extern crate bson;

-#[cfg(not(feature = "async-std-runtime"))]
-compile_error!("async-std-runtime feature must be enabled.");
-
 #[macro_export]
 #[cfg(debug_assertions)]
 macro_rules! query {
@@ -106,7 +103,6 @@ pub mod util;
 pub use models::*;

 pub mod events;
-#[cfg(feature = "tasks")]
 pub mod tasks;

 mod amqp;
@@ -1,4 +1,3 @@
-#[cfg(feature = "mongodb")]
 mod mongodb;
 mod reference;

@@ -10,7 +10,7 @@ impl AbstractMigrations for MongoDb {
    #[cfg(test)]
    /// Drop the database
    async fn drop_database(&self) {
-        self.db().drop().await.ok();
+        self.db().drop(None).await.ok();
    }

    /// Migrate the database
@@ -18,7 +18,7 @@ impl AbstractMigrations for MongoDb {
        info!("Migrating the database.");

        let list = self
-            .list_database_names()
+            .list_database_names(None, None)
            .await
            .expect("Failed to fetch database names.");

@@ -8,258 +8,278 @@ pub async fn create_database(db: &MongoDb) {
    info!("Creating database.");
    let db = db.db();

-    db.create_collection("accounts")
+    db.create_collection("accounts", None)
        .await
        .expect("Failed to create accounts collection.");

-    db.create_collection("users")
+    db.create_collection("users", None)
        .await
        .expect("Failed to create users collection.");

-    db.create_collection("channels")
+    db.create_collection("channels", None)
        .await
        .expect("Failed to create channels collection.");

-    db.create_collection("messages")
+    db.create_collection("messages", None)
        .await
        .expect("Failed to create messages collection.");

-    db.create_collection("servers")
+    db.create_collection("servers", None)
        .await
        .expect("Failed to create servers collection.");

-    db.create_collection("server_members")
+    db.create_collection("server_members", None)
        .await
        .expect("Failed to create server_members collection.");

-    db.create_collection("server_bans")
+    db.create_collection("server_bans", None)
        .await
        .expect("Failed to create server_bans collection.");

-    db.create_collection("channel_invites")
+    db.create_collection("channel_invites", None)
        .await
        .expect("Failed to create channel_invites collection.");

-    db.create_collection("channel_unreads")
+    db.create_collection("channel_unreads", None)
        .await
        .expect("Failed to create channel_unreads collection.");

-    db.create_collection("channel_webhooks")
+    db.create_collection("channel_webhooks", None)
        .await
        .expect("Failed to create channel_webhooks collection.");

-    db.create_collection("migrations")
+    db.create_collection("migrations", None)
        .await
        .expect("Failed to create migrations collection.");

-    db.create_collection("attachments")
+    db.create_collection("attachments", None)
        .await
        .expect("Failed to create attachments collection.");

-    db.create_collection("attachment_hashes")
+    db.create_collection("attachment_hashes", None)
        .await
        .expect("Failed to create attachment_hashes collection.");

-    db.create_collection("user_settings")
+    db.create_collection("user_settings", None)
        .await
        .expect("Failed to create user_settings collection.");

-    db.create_collection("policy_changes")
-        .await
-        .expect("Failed to create policy_changes collection.");
-
-    db.create_collection("safety_reports")
+    db.create_collection("safety_reports", None)
        .await
        .expect("Failed to create safety_reports collection.");

-    db.create_collection("safety_snapshots")
+    db.create_collection("safety_snapshots", None)
        .await
        .expect("Failed to create safety_snapshots collection.");

-    db.create_collection("safety_strikes")
+    db.create_collection("safety_strikes", None)
        .await
        .expect("Failed to create safety_strikes collection.");

-    db.create_collection("bots")
+    db.create_collection("bots", None)
        .await
        .expect("Failed to create bots collection.");

-    db.create_collection("ratelimit_events")
+    db.create_collection("ratelimit_events", None)
        .await
        .expect("Failed to create ratelimit_events collection.");

-    db.create_collection("pubsub")
-        .with_options(
-            CreateCollectionOptions::builder()
-                .capped(true)
-                .size(1_000_000)
-                .build(),
-        )
-        .await
-        .expect("Failed to create pubsub collection.");
+    db.create_collection(
+        "pubsub",
+        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
+    db.run_command(
+        doc! {
+            "createIndexes": "users",
+            "indexes": [
+                {
+                    "key": {
+                        "username": 1_i32
+                    },
+                    "name": "username",
+                    "unique": false,
+                    "collation": {
+                        "locale": "en",
+                        "strength": 2_i32
+                    }
                },
-                "name": "username",
-                "unique": false,
-                "collation": {
-                    "locale": "en",
-                    "strength": 2_i32
+                {
+                    "key": {
+                        "username": 1_i32,
+                        "discriminator": 1_i32
+                    },
+                    "name": "username_discriminator",
+                    "unique": true,
+                    "collation": {
+                        "locale": "en",
+                        "strength": 2_i32
+                    }
                }
-            },
-            {
-                "key": {
-                    "username": 1_i32,
-                    "discriminator": 1_i32
-                },
-                "name": "username_discriminator",
-                "unique": true,
-                "collation": {
-                    "locale": "en",
-                    "strength": 2_i32
-                }
-            }
-        ]
-    })
+            ]
+        },
+        None,
+    )
    .await
    .expect("Failed to create username index.");

-    db.run_command(doc! {
-        "createIndexes": "messages",
-        "indexes": [
-            {
-                "key": {
-                    "content": "text"
+    db.run_command(
+        doc! {
+            "createIndexes": "messages",
+            "indexes": [
+                {
+                    "key": {
+                        "content": "text"
+                    },
+                    "name": "content"
                },
-                "name": "content"
-            },
-            {
-                "key": {
-                    "channel": 1_i32,
-                    "_id": 1_i32
+                {
+                    "key": {
+                        "channel": 1_i32,
+                        "_id": 1_i32
+                    },
+                    "name": "channel_id_compound"
                },
-                "name": "channel_id_compound"
-            },
-            {
-                "key": {
-                    "author": 1_i32
+                {
+                    "key": {
+                        "author": 1_i32
+                    },
+                    "name": "author"
                },
-                "name": "author"
-            },
-            {
-                "key": {
-                    "channel": 1_i32,
-                    "pinned": 1_i32
+                {
+                    "key": {
+                        "channel": 1_i32,
+                        "pinned": 1_i32
+                    },
+                    "name": "channel_pinned_compound"
                },
-                "name": "channel_pinned_compound"
-            },
-        ]
-    })
+            ]
+        },
+        None,
+    )
    .await
    .expect("Failed to create message index.");

-    db.run_command(doc! {
-        "createIndexes": "channel_unreads",
-        "indexes": [
-            {
-                "key": {
-                    "_id.channel": 1_i32,
-                    "_id.user": 1_i32,
+    db.run_command(
+        doc! {
+            "createIndexes": "channel_unreads",
+            "indexes": [
+                {
+                    "key": {
+                        "_id.channel": 1_i32,
+                        "_id.user": 1_i32,
+                    },
+                    "name": "compound_id"
                },
-                "name": "compound_id"
-            },
-            {
-                "key": {
-                    "_id.user": 1_i32,
-                },
-                "name": "user_id"
-            }
-        ]
-    })
+                {
+                    "key": {
+                        "_id.user": 1_i32,
+                    },
+                    "name": "user_id"
+                }
+            ]
+        },
+        None,
+    )
    .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,
+    db.run_command(
+        doc! {
+            "createIndexes": "server_members",
+            "indexes": [
+                {
+                    "key": {
+                        "_id.server": 1_i32,
+                        "_id.user": 1_i32,
+                    },
+                    "name": "compound_id"
                },
-                "name": "compound_id"
-            },
-            {
-                "key": {
-                    "_id.user": 1_i32,
-                },
-                "name": "user_id"
-            }
-        ]
-    })
+                {
+                    "key": {
+                        "_id.user": 1_i32,
+                    },
+                    "name": "user_id"
+                }
+            ]
+        },
+        None,
+    )
    .await
    .expect("Failed to create server_members index.");

-    db.run_command(doc! {
-        "createIndexes": "attachments",
-        "indexes": [
-            {
-                "key": {
-                    "hash": 1_i32
+    db.run_command(
+        doc! {
+            "createIndexes": "attachments",
+            "indexes": [
+                {
+                    "key": {
+                        "hash": 1_i32
+                    },
+                    "name": "hash"
                },
-                "name": "hash"
-            },
-            {
-                "key": {
-                    "used_for.id": 1_i32
-                },
-                "name": "used_for_id"
-            }
-        ]
-    })
+                {
+                    "key": {
+                        "used_for.id": 1_i32
+                    },
+                    "name": "used_for_id"
+                }
+            ]
+        },
+        None,
+    )
    .await
    .expect("Failed to create attachments index.");

-    db.run_command(doc! {
-        "createIndexes": "attachment_hashes",
-        "indexes": [
-            {
-                "key": {
-                    "processed_hash": 1_i32
-                },
-                "name": "processed_hash"
-            }
-        ]
-    })
+    db.run_command(
+        doc! {
+            "createIndexes": "attachment_hashes",
+            "indexes": [
+                {
+                    "key": {
+                        "processed_hash": 1_i32
+                    },
+                    "name": "processed_hash"
+                }
+            ]
+        },
+        None,
+    )
    .await
    .expect("Failed to create attachment_hashes index.");

    db.collection("migrations")
-        .insert_one(doc! {
-            "_id": 0_i32,
-            "revision": LATEST_REVISION
-        })
+        .insert_one(
+            doc! {
+                "_id": 0_i32,
+                "revision": LATEST_REVISION
+            },
+            None,
+        )
        .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"
-            }
-        ]
-    })
+    db.run_command(
+        doc! {
+            "createIndexes": "ratelimit_events",
+            "indexes": [
+                {
+                    "key": {
+                        "_id": 1_i32,
+                        "target_id": 1_i32,
+                        "event_type": 1_i32,
+                    },
+                    "name": "compound_key"
+                }
+            ]
+        },
+        None,
+    )
    .await
    .expect("Failed to create ratelimit_events index.");

@@ -1,3 +1,4 @@
+use revolt_config::config;
 use revolt_result::Result;
 use ulid::Ulid;

@@ -2,7 +2,6 @@ use revolt_result::Result;

 use crate::{Bot, FieldsBot, PartialBot};

-#[cfg(feature = "mongodb")]
 mod mongodb;
 mod reference;

@@ -2,7 +2,6 @@ use revolt_result::Result;

 use crate::Invite;

-#[cfg(feature = "mongodb")]
 mod mongodb;
 mod reference;

@@ -24,9 +24,12 @@ 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,
-            })
+            .find(
+                doc! {
+                    "server": server_id,
+                },
+                None,
+            )
            .await
            .map_err(|_| create_database_error!("find", COL))?
            .filter_map(|s| async {
@@ -2,7 +2,6 @@ use revolt_result::Result;

 use crate::ChannelUnread;

-#[cfg(feature = "mongodb")]
 mod mongodb;
 mod reference;

@@ -27,14 +26,6 @@ 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>>;

@@ -37,8 +37,6 @@ impl AbstractChannelUnreads for MongoDb {
                        "last_id": message_id
                    }
                },
-            )
-            .with_options(
                FindOneAndUpdateOptions::builder()
                    .upsert(true)
                    .return_document(ReturnDocument::After)
@@ -53,12 +51,15 @@ impl AbstractChannelUnreads for MongoDb {
        let current_time = Ulid::new().to_string();

        self.col::<Document>(COL)
-            .delete_many(doc! {
-                "_id.channel": {
-                    "$in": channel_ids
+            .delete_many(
+                doc! {
+                    "_id.channel": {
+                        "$in": channel_ids
+                    },
+                    "_id.user": user_id
                },
-                "_id.user": user_id
-            })
+                None,
+            )
            .await
            .map_err(|_| create_database_error!("delete_many", COL))?;

@@ -76,6 +77,7 @@ impl AbstractChannelUnreads for MongoDb {
                        }
                    })
                    .collect::<Vec<Document>>(),
+                None,
            )
            .await
            .map(|_| ())
@@ -102,42 +104,13 @@ 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!(
@@ -78,38 +78,6 @@ 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
@@ -142,7 +142,7 @@ mod tests {
                ..Default::default()
            };

-            webhook.create(&db).await.unwrap();
+            db.insert_webhook(&webhook).await.unwrap();

            let mut updated_webhook = webhook.clone();
            updated_webhook
@@ -2,7 +2,6 @@ use revolt_result::Result;

 use crate::{FieldsWebhook, PartialWebhook, Webhook};

-#[cfg(feature = "mongodb")]
 mod mongodb;
 mod reference;

@@ -24,9 +24,12 @@ 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,
-            })
+            .find(
+                doc! {
+                    "channel_id": channel_id,
+                },
+                None,
+            )
            .await
            .map_err(|_| create_database_error!("find", COL))?
            .filter_map(|s| async {
@@ -8,13 +8,10 @@ use serde::{Deserialize, Serialize};
 use ulid::Ulid;

 use crate::{
-    events::client::EventV1, Database, File, PartialServer,
+    events::client::EventV1, tasks::ack::AckEvent, Database, File, IntoDocumentPath, PartialServer,
    Server, SystemMessage, User, AMQP,
 };

-#[cfg(feature = "mongodb")]
-use crate::IntoDocumentPath;
-
 auto_derived!(
    #[serde(tag = "channel_type")]
    pub enum Channel {
@@ -272,24 +269,16 @@ 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,
+            id: ulid::Ulid::new().to_string(),

            name: data.name,
            owner: owner_id,
            description: data.description,
            recipients: recipients.clone(),

-            icon,
+            icon: None,
            last_message_id: None,

            permissions: None,
@@ -331,10 +320,13 @@ impl Channel {

            db.insert_channel(&channel).await?;

-            if let Channel::DirectMessage { .. } = &channel {
-                let event = EventV1::ChannelCreate(channel.clone().into());
-                event.clone().private(user_a.id.clone()).await;
-                event.private(user_b.id.clone()).await;
+            match &channel {
+                Channel::DirectMessage { .. } => {
+                    let event = EventV1::ChannelCreate(channel.clone().into());
+                    event.clone().private(user_a.id.clone()).await;
+                    event.private(user_b.id.clone()).await;
+                }
+                _ => {}
            };

            Ok(channel)
@@ -649,11 +641,10 @@ impl Channel {
        .private(user.to_string())
        .await;

-        #[cfg(feature = "tasks")]
        crate::tasks::ack::queue_ack(
            self.id().to_string(),
            user.to_string(),
-            crate::tasks::ack::AckEvent::AckMessage {
+            AckEvent::AckMessage {
                id: message.to_string(),
            },
        )
@@ -770,7 +761,6 @@ impl Channel {
    }
 }

-#[cfg(feature = "mongodb")]
 impl IntoDocumentPath for FieldsChannel {
    fn as_path(&self) -> Option<&'static str> {
        Some(match self {
@@ -1,7 +1,5 @@
 use crate::{revolt_result::Result, Channel, FieldsChannel, PartialChannel};
 use revolt_permissions::OverrideField;
-
-#[cfg(feature = "mongodb")]
 mod mongodb;
 mod reference;

@@ -23,11 +23,14 @@ 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
-                }
-            })
+            .find(
+                doc! {
+                    "_id": {
+                        "$in": ids
+                    }
+                },
+                None,
+            )
            .await
            .map_err(|_| create_database_error!("fetch", "channels"))?
            .filter_map(|s| async {
@@ -116,6 +119,7 @@ impl AbstractChannels for MongoDb {
                        "recipients": user
                    }
                },
+                None,
            )
            .await
            .map(|_| ())
@@ -137,6 +141,7 @@ impl AbstractChannels for MongoDb {
                    "role_permissions.".to_owned() + role: permissions
                }
                },
+                None,
            )
            .await
            .map(|_| ())
@@ -174,6 +179,7 @@ impl AbstractChannels for MongoDb {
                        "recipients": user
                    }
                },
+                None,
            )
            .await
            .map(|_| ())
@@ -247,6 +253,7 @@ impl AbstractChannels for MongoDb {
                        "_id": server.id
                    },
                    update,
+                    None,
                )
                .await
                .map_err(|_| create_database_error!("update_one", "servers"))?;
@@ -267,17 +274,23 @@ 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
-            })
+            .delete_many(
+                doc! {
+                    "channel": &id
+                },
+                None,
+            )
            .await
            .map_err(|_| create_database_error!("delete_many", "channel_invites"))?;

        // Delete unread message objects on channels.
        self.col::<Document>("channel_unreads")
-            .delete_many(doc! {
-                "_id.channel": &id
-            })
+            .delete_many(
+                doc! {
+                    "_id.channel": &id
+                },
+                None,
+            )
            .await
            .map_err(|_| create_database_error!("delete_many", "channel_unreads"))
            .map(|_| ())?;
@@ -286,9 +299,12 @@ impl MongoDb {

        // Delete all webhooks on this channel.
        self.col::<Document>("webhooks")
-            .delete_many(doc! {
-                "channel": &id
-            })
+            .delete_many(
+                doc! {
+                    "channel": &id
+                },
+                None,
+            )
            .await
            .map_err(|_| create_database_error!("delete_many", "webhooks"))
            .map(|_| ())
@@ -2,7 +2,6 @@ use revolt_result::Result;

 use crate::Emoji;

-#[cfg(feature = "mongodb")]
 mod mongodb;
 mod reference;

@@ -60,6 +60,7 @@ impl AbstractEmojis for MongoDb {
                        }
                    }
                },
+                None,
            )
            .await
            .map(|_| ())
@@ -28,7 +28,7 @@ auto_derived_partial!(
        /// Size of this file (in bytes)
        pub size: isize,
    },
-    "PartialFileHash"
+    "PartialFile"
 );

 auto_derived!(
@@ -2,7 +2,6 @@ use revolt_result::Result;

 use crate::FileHash;

-#[cfg(feature = "mongodb")]
 mod mongodb;
 mod reference;

@@ -42,6 +42,7 @@ impl AbstractAttachmentHashes for MongoDb {
                        "iv": nonce
                    }
                },
+                None,
            )
            .await
            .map(|_| ())
@@ -4,7 +4,6 @@ use crate::File;

 use super::FileUsedFor;

-#[cfg(feature = "mongodb")]
 mod mongodb;
 mod reference;

@@ -110,6 +110,7 @@ impl AbstractAttachments for MongoDb {
                        "uploader_id": uploader_id
                    }
                },
+                None,
            )
            .await
            .map_err(|_| create_database_error!("update_one", COL))?;
@@ -129,6 +130,7 @@ impl AbstractAttachments for MongoDb {
                        "reported": true
                    }
                },
+                None,
            )
            .await
            .map(|_| ())
@@ -147,6 +149,7 @@ impl AbstractAttachments for MongoDb {
                        "deleted": true
                    }
                },
+                None,
            )
            .await
            .map(|_| ())
@@ -167,6 +170,7 @@ impl AbstractAttachments for MongoDb {
                        "deleted": true
                    }
                },
+                None,
            )
            .await
            .map(|_| ())
@@ -189,6 +193,7 @@ impl MongoDb {
                        "deleted": true
                    }
                },
+                None,
            )
            .await
            .map(|_| ())
@@ -5,25 +5,20 @@ 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,
+    MessageWebhook, PushNotification, ReplyIntent, SendableEmbed, Text, RE_MENTION,
 };
-use revolt_permissions::{calculate_channel_permissions, ChannelPermission, PermissionValue};
-use revolt_result::{ErrorType, Result};
+use revolt_permissions::{ChannelPermission, PermissionValue};
+use revolt_result::Result;
 use ulid::Ulid;
 use validator::Validate;

 use crate::{
    events::client::EventV1,
-    util::{
-        bulk_permissions::BulkDatabasePermissionQuery, idempotency::IdempotencyKey,
-        permissions::DatabasePermissionQuery,
-    },
+    tasks::{self, ack::AckEvent},
+    util::{bulk_permissions::BulkDatabasePermissionQuery, idempotency::IdempotencyKey},
    Channel, Database, Emoji, File, User, AMQP,
 };

-#[cfg(feature = "tasks")]
-use crate::tasks::{self, ack::AckEvent};
-
 auto_derived_partial!(
    /// Message
    pub struct Message {
@@ -58,9 +53,6 @@ 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>>,
@@ -79,7 +71,7 @@ auto_derived_partial!(

        /// Bitfield of message flags
        #[serde(skip_serializing_if = "Option::is_none")]
-        pub flags: Option<u32>,
+        pub flags: Option<i32>,
    },
    "PartialMessage"
 );
@@ -207,30 +199,6 @@ auto_derived!(
    }
 );

-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 {
@@ -246,7 +214,6 @@ impl Default for Message {
            edited: None,
            embeds: None,
            mentions: None,
-            role_mentions: None,
            replies: None,
            reactions: Default::default(),
            interactions: Default::default(),
@@ -288,50 +255,20 @@ impl Message {
            .map_err(|_| create_error!(InvalidOperation))?;

        // Check the message is not 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()))
+        if (data.content.as_ref().map_or(true, |v| v.is_empty()))
+            && (data.attachments.as_ref().map_or(true, |v| v.is_empty()))
+            && (data.embeds.as_ref().map_or(true, |v| v.is_empty()))
        {
            return Err(create_error!(EmptyMessage));
        }

-        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
+        // Ensure flags are either not set or have permissible values
+        if let Some(flags) = &data.flags {
+            if flags != &0 && flags != &1 {
                return Err(create_error!(InvalidProperty));
            }
-
-            // 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 {
@@ -365,76 +302,18 @@ impl Message {
                .unwrap_or_default(),
            author: author_id,
            webhook: webhook.map(|w| w.into()),
-            flags: data.flags,
+            flags: data.flags.map(|v| v as i32),
            ..Default::default()
        };

        // Parse mentions in message.
-
-        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()
-                    }));
+        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());
+                    }
                }
            }
        }
@@ -448,56 +327,38 @@ impl Message {
                }));
            }

-            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());
-                        }
+            for ReplyIntent { id, mention } in entries {
+                let message = db.fetch_message(&id).await?;

-                        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);
-                        }
-                    }
+                if mention && allow_mentions {
+                    mentions.insert(message.author.to_owned());
                }
+
+                replies.insert(message.id);
            }
        }

        // Validate the mentions go to users in the channel/server
-        if !user_mentions.is_empty() {
+        if !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();
+                    let recipients_hash: HashSet<&String, RandomState> =
+                        HashSet::from_iter(recipients);
+                    mentions.retain(|m| recipients_hash.contains(m));
                }
                Channel::TextChannel { ref server, .. }
                | Channel::VoiceChannel { ref server, .. } => {
-                    let mentions_vec = Vec::from_iter(user_mentions.iter().cloned());
+                    let mentions_vec = Vec::from_iter(mentions.iter().cloned());

                    let valid_members = db.fetch_members(server.as_str(), &mentions_vec[..]).await;
                    if let Ok(valid_members) = valid_members {
-                        let valid_mentions = HashSet::<&String, RandomState>::from_iter(
-                            valid_members.iter().map(|m| &m.id.user),
-                        );
+                        let valid_mentions: HashSet<&String, RandomState> =
+                            HashSet::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
+                        mentions.retain(|m| valid_mentions.contains(m)); // quick pass, validate mentions are in the server

-                        if !user_mentions.is_empty() {
+                        if !mentions.is_empty() {
                            // if there are still mentions, drill down to a channel-level
                            let member_channel_view_perms =
                                BulkDatabasePermissionQuery::from_server_id(db, server)
@@ -507,7 +368,7 @@ impl Message {
                                    .members_can_see_channel()
                                    .await;

-                            user_mentions
+                            mentions
                                .retain(|m| *member_channel_view_perms.get(m).unwrap_or(&false));
                        }
                    } else {
@@ -516,21 +377,13 @@ impl Message {
                    }
                }
                Channel::SavedMessages { .. } => {
-                    user_mentions.clear();
+                    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 !mentions.is_empty() {
+            message.mentions.replace(mentions.into_iter().collect());
        }

        if !replies.is_empty() {
@@ -539,15 +392,6 @@ 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
@@ -618,22 +462,15 @@ impl Message {
            .await;

        // Update last_message_id
-        #[cfg(feature = "tasks")]
        tasks::last_message_id::queue(self.channel.to_string(), self.id.to_string(), is_dm).await;

        // Add mentions for affected users
-        #[cfg(feature = "tasks")]
        if !mentions_elsewhere {
            if let Some(mentions) = &self.mentions {
                tasks::ack::queue_message(
                    self.channel.to_string(),
                    AckEvent::ProcessMessage {
-                        messages: vec![(
-                            None,
-                            self.clone(),
-                            mentions.clone(),
-                            self.has_suppressed_notifications(),
-                        )],
+                        messages: vec![(None, self.clone(), mentions.clone(), true)],
                    },
                )
                .await;
@@ -641,7 +478,6 @@ impl Message {
        }

        // Generate embeds
-        #[cfg(feature = "tasks")]
        if generate_embeds {
            if let Some(content) = &self.content {
                tasks::process_embeds::queue(
@@ -661,7 +497,7 @@ impl Message {
    pub async fn send(
        &mut self,
        db: &Database,
-        _amqp: Option<&AMQP>, // this is optional mostly for tests.
+        amqp: Option<&AMQP>, // this is optional mostly for tests.
        author: MessageAuthor<'_>,
        user: Option<v0::User>,
        member: Option<v0::Member>,
@@ -678,12 +514,8 @@ impl Message {
        )
        .await?;

-
-        if !self.has_suppressed_notifications()
-            && (self.mentions.is_some() || self.contains_mass_push_mention())
-        {
+        if !self.has_suppressed_notifications() {
            // send Push notifications
-            #[cfg(feature = "tasks")]
            tasks::ack::queue_message(
                self.channel.to_string(),
                AckEvent::ProcessMessage {
@@ -705,7 +537,7 @@ impl Message {
                            }
                            _ => vec![],
                        },
-                        false, // branch already dictates this
+                        self.has_suppressed_notifications(),
                    )],
                },
            )
@@ -742,24 +574,13 @@ impl Message {
    /// Whether this message has suppressed notifications
    pub fn has_suppressed_notifications(&self) -> bool {
        if let Some(flags) = self.flags {
-            flags & MessageFlags::SuppressNotifications as u32
-                == MessageFlags::SuppressNotifications as u32
+            flags & MessageFlags::SuppressNotifications as i32
+                == MessageFlags::SuppressNotifications as i32
        } 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,
@@ -2,7 +2,6 @@ use revolt_result::Result;

 use crate::{AppendMessage, FieldsMessage, Message, MessageQuery, PartialMessage};

-#[cfg(feature = "mongodb")]
 mod mongodb;
 mod reference;

@@ -228,6 +228,7 @@ impl AbstractMessages for MongoDb {
                    "_id": id
                },
                query,
+                None,
            )
            .await
            .map(|_| ())
@@ -246,6 +247,7 @@ impl AbstractMessages for MongoDb {
                        format!("reactions.{emoji}"): user
                    }
                },
+                None,
            )
            .await
            .map(|_| ())
@@ -264,6 +266,7 @@ impl AbstractMessages for MongoDb {
                        format!("reactions.{emoji}"): user
                    }
                },
+                None,
            )
            .await
            .map(|_| ())
@@ -282,6 +285,7 @@ impl AbstractMessages for MongoDb {
                        format!("reactions.{emoji}"): 1
                    }
                },
+                None,
            )
            .await
            .map(|_| ())
@@ -296,12 +300,15 @@ 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
-                }
-            })
+            .delete_many(
+                doc! {
+                    "channel": channel,
+                    "_id": {
+                        "$in": ids
+                    }
+                },
+                None,
+            )
            .await
            .map(|_| ())
            .map_err(|_| create_database_error!("delete_many", COL))
@@ -355,6 +362,7 @@ impl MongoDb {
                            "deleted": true
                        }
                    },
+                    None,
                )
                .await
                .map_err(|_| create_database_error!("update_many", "attachments"))?;
@@ -362,7 +370,7 @@ impl MongoDb {

        // And then delete said messages.
        self.col::<Document>(COL)
-            .delete_many(projection)
+            .delete_many(projection, None)
            .await
            .map(|_| ())
            .map_err(|_| create_database_error!("delete_many", COL))
@@ -8,7 +8,6 @@ mod emojis;
 mod file_hashes;
 mod files;
 mod messages;
-mod policy_changes;
 mod ratelimit_events;
 mod safety_reports;
 mod safety_snapshots;
@@ -28,7 +27,6 @@ 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::*;
@@ -38,10 +36,7 @@ pub use servers::*;
 pub use user_settings::*;
 pub use users::*;

-use crate::{Database, ReferenceDb};
-
-#[cfg(feature = "mongodb")]
-use crate::MongoDb;
+use crate::{Database, MongoDb, ReferenceDb};

 pub trait AbstractDatabase:
    Sync
@@ -56,7 +51,6 @@ pub trait AbstractDatabase:
    + file_hashes::AbstractAttachmentHashes
    + files::AbstractAttachments
    + messages::AbstractMessages
-    + policy_changes::AbstractPolicyChange
    + ratelimit_events::AbstractRatelimitEvents
    + safety_reports::AbstractReport
    + safety_snapshots::AbstractSnapshot
@@ -69,8 +63,6 @@ pub trait AbstractDatabase:
 }

 impl AbstractDatabase for ReferenceDb {}
-
-#[cfg(feature = "mongodb")]
 impl AbstractDatabase for MongoDb {}

 impl std::ops::Deref for Database {
@@ -79,7 +71,6 @@ impl std::ops::Deref for Database {
    fn deref(&self) -> &Self::Target {
        match &self {
            Database::Reference(dummy) => dummy,
-            #[cfg(feature = "mongodb")]
            Database::MongoDb(mongo) => mongo,
        }
    }
@@ -1,5 +0,0 @@
-mod model;
-mod ops;
-
-pub use model::*;
-pub use ops::*;
@@ -1,20 +0,0 @@
-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,
-    }
-);
@@ -1,16 +0,0 @@
-use revolt_result::Result;
-
-use crate::PolicyChange;
-
-#[cfg(feature = "mongodb")]
-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<()>;
-}
@@ -1,46 +0,0 @@
-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))
-    }
-}
@@ -1,31 +0,0 @@
-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(())
-    }
-}
@@ -1,8 +1,6 @@
 use std::time::Duration;

 use crate::{revolt_result::Result, RatelimitEvent, RatelimitEventType};
-
-#[cfg(feature = "mongodb")]
 mod mongodb;
 mod reference;

@@ -23,13 +23,16 @@ 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()
+            .count_documents(
+                doc! {
+                    "_id": {
+                        "$gte": Ulid::from_datetime(SystemTime::now() - period).to_string()
+                    },
+                    "target_id": target_id,
+                    "event_type": event_type.to_string()
                },
-                "target_id": target_id,
-                "event_type": event_type.to_string()
-            })
+                None,
+            )
            .await
            .map(|c| c as usize >= count)
            .map_err(|_| create_database_error!("count_documents", COL))
@@ -2,7 +2,6 @@ use revolt_result::Result;

 use crate::Report;

-#[cfg(feature = "mongodb")]
 mod mongodb;
 mod reference;

@@ -85,8 +85,8 @@ impl SnapshotContent {
        Ok((
            SnapshotContent::Message {
                message,
-                prior_context: prior_context.into_iter().collect(),
-                leading_context: leading_context.into_iter().collect(),
+                prior_context: prior_context.into_iter().map(Into::into).collect(),
+                leading_context: leading_context.into_iter().map(Into::into).collect(),
            },
            files,
        ))
@@ -2,7 +2,6 @@ use revolt_result::Result;

 use crate::Snapshot;

-#[cfg(feature = "mongodb")]
 mod mongodb;
 mod reference;

@@ -13,7 +13,6 @@ auto_derived!(
    }
 );

-#[allow(clippy::disallowed_methods)]
 impl ServerBan {
    /// Create ban
    pub async fn create(
@@ -2,7 +2,6 @@ use revolt_result::Result;

 use crate::{MemberCompositeKey, ServerBan};

-#[cfg(feature = "mongodb")]
 mod mongodb;
 mod reference;

@@ -30,9 +30,6 @@ auto_derived_partial!(
        /// Timestamp this member is timed out until
        #[serde(skip_serializing_if = "Option::is_none")]
        pub timeout: Option<Timestamp>,
-        // This value only exists in the database, not the models.
-        // If it is not-None, the database layer should return None to member fetching queries.
-        // pub pending_deletion_at: Option<Timestamp>
    },
    "PartialMember"
 );
@@ -53,7 +50,6 @@ auto_derived!(
        Avatar,
        Roles,
        Timeout,
-        JoinedAt,
    }

    /// Member removal intention
@@ -94,7 +90,7 @@ impl Member {
            return Err(create_error!(AlreadyInServer));
        }

-        let mut member = Member {
+        let member = Member {
            id: MemberCompositeKey {
                server: server.id.to_string(),
                user: user.id.to_string(),
@@ -102,9 +98,7 @@ impl Member {
            ..Default::default()
        };

-        if let Some(updated) = db.insert_or_merge_member(&member).await? {
-            member = updated;
-        }
+        db.insert_member(&member).await?;

        let should_fetch = channels.is_none();
        let mut channels = channels.unwrap_or_default();
@@ -130,7 +124,6 @@ impl Member {
        EventV1::ServerMemberJoin {
            id: server.id.clone(),
            user: user.id.clone(),
-            member: member.clone().into(),
        }
        .p(server.id.clone())
        .await;
@@ -166,7 +159,7 @@ impl Member {
    }

    /// Update member data
-    pub async fn update(
+    pub async fn update<'a>(
        &mut self,
        db: &Database,
        partial: PartialMember,
@@ -193,7 +186,6 @@ impl Member {

    pub fn remove_field(&mut self, field: &FieldsMember) {
        match field {
-            FieldsMember::JoinedAt => (),
            FieldsMember::Avatar => self.avatar = None,
            FieldsMember::Nickname => self.nickname = None,
            FieldsMember::Roles => self.roles.clear(),
@@ -232,7 +224,7 @@ impl Member {
        intention: RemovalIntention,
        silent: bool,
    ) -> Result<()> {
-        db.soft_delete_member(&self.id).await?;
+        db.delete_member(&self.id).await?;

        EventV1::ServerMemberLeave {
            id: self.id.server.to_string(),
@@ -268,74 +260,3 @@ impl Member {
        Ok(())
    }
 }
-
-#[cfg(test)]
-mod tests {
-    use iso8601_timestamp::{Duration, Timestamp};
-    use revolt_models::v0::DataCreateServer;
-
-    use crate::{Member, PartialMember, RemovalIntention, Server, User};
-
-    #[async_std::test]
-    async fn muted_member_rejoin() {
-        database_test!(|db| async move {
-            match db {
-                crate::Database::Reference(_) => return,
-                crate::Database::MongoDb(_) => (),
-            }
-            let owner = User::create(&db, "Server Owner".to_string(), None, None)
-                .await
-                .unwrap();
-
-            let kickable_user = User::create(&db, "Member".to_string(), None, None)
-                .await
-                .unwrap();
-
-            let server = Server::create(
-                &db,
-                DataCreateServer {
-                    name: "Server".to_string(),
-                    description: None,
-                    nsfw: None,
-                },
-                &owner,
-                false,
-            )
-            .await
-            .unwrap()
-            .0;
-
-            Member::create(&db, &server, &owner, None).await.unwrap();
-            let mut kickable_member = Member::create(&db, &server, &kickable_user, None)
-                .await
-                .unwrap()
-                .0;
-
-            kickable_member
-                .update(
-                    &db,
-                    PartialMember {
-                        timeout: Some(Timestamp::now_utc() + Duration::minutes(5)),
-                        ..Default::default()
-                    },
-                    vec![],
-                )
-                .await
-                .unwrap();
-
-            assert!(kickable_member.in_timeout());
-
-            kickable_member
-                .remove(&db, &server, RemovalIntention::Kick, false)
-                .await
-                .unwrap();
-
-            let kickable_member = Member::create(&db, &server, &kickable_user, None)
-                .await
-                .unwrap()
-                .0;
-
-            assert!(kickable_member.in_timeout())
-        });
-    }
-}
@@ -1,109 +1,26 @@
-#[cfg(feature = "mongodb")]
-use ::mongodb::{ClientSession, SessionCursor};
-
 use revolt_result::Result;

 use crate::{FieldsMember, Member, MemberCompositeKey, PartialMember};

-#[cfg(feature = "mongodb")]
 mod mongodb;
 mod reference;

-#[derive(Debug)]
-#[allow(clippy::large_enum_variant)]
-pub enum ChunkedServerMembersGenerator {
-    #[cfg(feature = "mongodb")]
-    MongoDb {
-        session: ClientSession,
-        cursor: Option<SessionCursor<Member>>,
-    },
-
-    Reference {
-        offset: i32,
-        data: Option<Vec<Member>>,
-    },
-}
-
-impl ChunkedServerMembersGenerator {
-    #[cfg(feature = "mongodb")]
-    pub fn new_mongo(session: 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
-    async fn insert_or_merge_member(&self, member: &Member) -> Result<Option<Member>>;
+    async fn insert_member(&self, member: &Member) -> Result<()>;

    /// Fetch a server member by their id
    async fn fetch_member(&self, server_id: &str, user_id: &str) -> Result<Member>;

    /// Fetch all members in a server
-    async fn fetch_all_members(&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>;
+    async fn fetch_all_members<'a>(&self, server_id: &str) -> Result<Vec<Member>>;

    /// Fetch all memberships for a user
-    async fn fetch_all_memberships(&self, user_id: &str) -> Result<Vec<Member>>;
+    async fn fetch_all_memberships<'a>(&self, user_id: &str) -> Result<Vec<Member>>;

    /// Fetch multiple members by their ids
-    async fn fetch_members(&self, server_id: &str, ids: &[String]) -> Result<Vec<Member>>;
+    async fn fetch_members<'a>(&self, server_id: &str, ids: &'a [String]) -> Result<Vec<Member>>;

    /// Fetch member count of a server
    async fn fetch_member_count(&self, server_id: &str) -> Result<usize>;
@@ -119,14 +36,6 @@ pub trait AbstractServerMembers: Sync + Send {
        remove: Vec<FieldsMember>,
    ) -> Result<()>;

-    /// Marks a user as no longer a member of a server, while retaining the database value.
-    /// This is used to keep information such as timeouts in place, but will remove information such as join date and applied roles.
-    async fn soft_delete_member(&self, id: &MemberCompositeKey) -> Result<()>;
-
-    /// Forcibly delete a server member by their id.
-    /// This will cancel any pending timeouts or other longer term actions, and they will not be reapplied on rejoin.
-    async fn force_delete_member(&self, id: &MemberCompositeKey) -> Result<()>;
-
-    /// Fetch all members who have been marked for deletion.
-    async fn remove_dangling_members(&self) -> Result<()>;
+    /// Delete a server member by their id
+    async fn delete_member(&self, id: &MemberCompositeKey) -> Result<()>;
 }
@@ -1,54 +1,18 @@
-use bson::Document;
 use futures::StreamExt;
-use iso8601_timestamp::Timestamp;
-use mongodb::options::ReadConcern;
 use revolt_result::Result;

 use crate::{FieldsMember, Member, MemberCompositeKey, PartialMember};
 use crate::{IntoDocumentPath, MongoDb};

-use super::{AbstractServerMembers, ChunkedServerMembersGenerator};
+use super::AbstractServerMembers;

 static COL: &str = "server_members";

 #[async_trait]
 impl AbstractServerMembers for MongoDb {
-    /// Insert a new server member (or use the existing member if one is found)
-    async fn insert_or_merge_member(&self, member: &Member) -> Result<Option<Member>> {
-        let existing: Result<Option<Document>> = query!(
-            self,
-            find_one,
-            COL,
-            doc! {
-                "_id.server": &member.id.server,
-                "_id.user": &member.id.user,
-                "pending_deletion_at": {"$exists": true}
-            }
-        );
-        // Update the existing record if it exist, otherwise make a new record
-        if existing.is_ok_and(|x| x.is_some()) {
-            self.col::<Member>(COL)
-                .find_one_and_update(
-                    doc! {
-                        "_id.server": &member.id.server,
-                        "_id.user": &member.id.user,
-                    },
-                    doc! {
-                        "$set": {
-                            "joined_at": member.joined_at.duration_since(Timestamp::UNIX_EPOCH).whole_seconds(),
-                        },
-                        "$unset": {
-                            "pending_deletion_at": ""
-                        }
-                    },
-                )
-                .return_document(mongodb::options::ReturnDocument::After)
-                .await
-                .map_err(|_| create_database_error!("update_one", COL))
-        } else {
-            query!(self, insert_one, COL, &member).map(|_| ())?;
-            Ok(None)
-        }
+    /// Insert a new server member into the database
+    async fn insert_member(&self, member: &Member) -> Result<()> {
+        query!(self, insert_one, COL, &member).map(|_| ())
    }

    /// Fetch a server member by their id
@@ -59,21 +23,22 @@ impl AbstractServerMembers for MongoDb {
            COL,
            doc! {
                "_id.server": server_id,
-                "_id.user": user_id,
-                "pending_deletion_at": {"$exists": false}
+                "_id.user": user_id
            }
        )?
        .ok_or_else(|| create_error!(NotFound))
    }

    /// Fetch all members in a server
-    async fn fetch_all_members(&self, server_id: &str) -> Result<Vec<Member>> {
+    async fn fetch_all_members<'a>(&self, server_id: &str) -> Result<Vec<Member>> {
        Ok(self
            .col::<Member>(COL)
-            .find(doc! {
-                "_id.server": server_id,
-                "pending_deletion_at": {"$exists": false}
-            })
+            .find(
+                doc! {
+                    "_id.server": server_id
+                },
+                None,
+            )
            .await
            .map_err(|_| create_database_error!("find", COL))?
            .filter_map(|s| async {
@@ -87,102 +52,16 @@ 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(&self, user_id: &str) -> Result<Vec<Member>> {
+    async fn fetch_all_memberships<'a>(&self, user_id: &str) -> Result<Vec<Member>> {
        Ok(self
            .col::<Member>(COL)
-            .find(doc! {
-                "_id.user": user_id,
-                "pending_deletion_at": {"$exists": false}
-            })
+            .find(
+                doc! {
+                    "_id.user": user_id
+                },
+                None,
+            )
            .await
            .map_err(|_| create_database_error!("find", COL))?
            .filter_map(|s| async {
@@ -197,16 +76,18 @@ impl AbstractServerMembers for MongoDb {
    }

    /// Fetch multiple members by their ids
-    async fn fetch_members(&self, server_id: &str, ids: &[String]) -> Result<Vec<Member>> {
+    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,
-                "pending_deletion_at": {"$exists": false},
-                "_id.user": {
-                    "$in": ids
-                }
-            })
+            .find(
+                doc! {
+                    "_id.server": server_id,
+                    "_id.user": {
+                        "$in": ids
+                    }
+                },
+                None,
+            )
            .await
            .map_err(|_| create_database_error!("find", COL))?
            .filter_map(|s| async {
@@ -223,10 +104,12 @@ 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,
-                "pending_deletion_at": {"$exists": false}
-            })
+            .count_documents(
+                doc! {
+                    "_id.server": server_id
+                },
+                None,
+            )
            .await
            .map(|c| c as usize)
            .map_err(|_| create_database_error!("count_documents", COL))
@@ -235,10 +118,12 @@ 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,
-                "pending_deletion_at": {"$exists": false}
-            })
+            .count_documents(
+                doc! {
+                    "_id.user": user_id
+                },
+                None,
+            )
            .await
            .map(|c| c as usize)
            .map_err(|_| create_database_error!("count_documents", COL))
@@ -266,42 +151,8 @@ impl AbstractServerMembers for MongoDb {
        .map(|_| ())
    }

-    /// Marks a member for deletion.
-    /// This will remove the record if the user has no pending actions (eg. timeout),
-    /// otherwise will slate the record for deletion by revolt_crond once the actions expire.
-    async fn soft_delete_member(&self, id: &MemberCompositeKey) -> Result<()> {
-        let member = self.fetch_member(&id.server, &id.user).await;
-        if let Ok(member) = member {
-            if member.in_timeout() {
-                self.col::<Document>(COL)
-                    .update_many(
-                        doc! {
-                            "_id.server": &id.server,
-                            "_id.user": &id.user,
-                        },
-                        doc! {
-                            "$set": {"pending_deletion_at": format!("{}", member.timeout.unwrap().format())},
-                            "$unset": {
-                                "joined_at": "",
-                                "avatar": "",
-                                "nickname": "",
-                                "roles": ""
-                            }
-                        },
-                    )
-                    .await
-                    .map(|_| ())
-                    .map_err(|_| create_database_error!("update_many", COL))
-            } else {
-                self.force_delete_member(id).await
-            }
-        } else {
-            Err(create_database_error!("fetch_member", COL))
-        }
-    }
-
    /// Delete a server member by their id
-    async fn force_delete_member(&self, id: &MemberCompositeKey) -> Result<()> {
+    async fn delete_member(&self, id: &MemberCompositeKey) -> Result<()> {
        query!(
            self,
            delete_one,
@@ -313,25 +164,11 @@ impl AbstractServerMembers for MongoDb {
        )
        .map(|_| ())
    }
-
-    async fn remove_dangling_members(&self) -> Result<()> {
-        let now = Timestamp::now_utc();
-        let date = bson::to_bson(&now).expect("Failed to serialize timestamp");
-
-        self.col::<Document>(COL)
-            .delete_many(doc! {
-                "pending_deletion_at": {"$lt": date}
-            })
-            .await
-            .map(|_| ())
-            .map_err(|_| create_database_error!("count_documents", COL))
-    }
 }

 impl IntoDocumentPath for FieldsMember {
    fn as_path(&self) -> Option<&'static str> {
        Some(match self {
-            FieldsMember::JoinedAt => "joined_at",
            FieldsMember::Avatar => "avatar",
            FieldsMember::Nickname => "nickname",
            FieldsMember::Roles => "roles",
@@ -3,18 +3,18 @@ use revolt_result::Result;
 use crate::ReferenceDb;
 use crate::{FieldsMember, Member, MemberCompositeKey, PartialMember};

-use super::{AbstractServerMembers, ChunkedServerMembersGenerator};
+use super::AbstractServerMembers;

 #[async_trait]
 impl AbstractServerMembers for ReferenceDb {
    /// Insert a new server member into the database
-    async fn insert_or_merge_member(&self, member: &Member) -> Result<Option<Member>> {
+    async fn insert_member(&self, member: &Member) -> Result<()> {
        let mut server_members = self.server_members.lock().await;
        if server_members.contains_key(&member.id) {
            Err(create_database_error!("insert", "member"))
        } else {
            server_members.insert(member.id.clone(), member.clone());
-            Ok(None)
+            Ok(())
        }
    }

@@ -31,7 +31,7 @@ impl AbstractServerMembers for ReferenceDb {
    }

    /// Fetch all members in a server
-    async fn fetch_all_members(&self, server_id: &str) -> Result<Vec<Member>> {
+    async fn fetch_all_members<'a>(&self, server_id: &str) -> Result<Vec<Member>> {
        let server_members = self.server_members.lock().await;
        Ok(server_members
            .values()
@@ -40,72 +40,8 @@ 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(&self, user_id: &str) -> Result<Vec<Member>> {
+    async fn fetch_all_memberships<'a>(&self, user_id: &str) -> Result<Vec<Member>> {
        let server_members = self.server_members.lock().await;
        Ok(server_members
            .values()
@@ -115,7 +51,7 @@ impl AbstractServerMembers for ReferenceDb {
    }

    /// Fetch multiple members by their ids
-    async fn fetch_members(&self, server_id: &str, ids: &[String]) -> Result<Vec<Member>> {
+    async fn fetch_members<'a>(&self, server_id: &str, ids: &'a [String]) -> Result<Vec<Member>> {
        let server_members = self.server_members.lock().await;
        Ok(ids
            .iter()
@@ -169,26 +105,8 @@ impl AbstractServerMembers for ReferenceDb {
        }
    }

-    /// Soft delete a member
-    async fn soft_delete_member(&self, id: &MemberCompositeKey) -> Result<()> {
-        let mut server_members = self.server_members.lock().await;
-
-        let member = server_members.get_mut(id);
-        if let Some(member) = member {
-            if member.in_timeout() {
-                panic!("Soft deletion is not implemented.")
-            } else if server_members.remove(id).is_some() {
-                Ok(())
-            } else {
-                Err(create_error!(NotFound))
-            }
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-
    /// Delete a server member by their id
-    async fn force_delete_member(&self, id: &MemberCompositeKey) -> Result<()> {
+    async fn delete_member(&self, id: &MemberCompositeKey) -> Result<()> {
        let mut server_members = self.server_members.lock().await;
        if server_members.remove(id).is_some() {
            Ok(())
@@ -196,8 +114,4 @@ impl AbstractServerMembers for ReferenceDb {
            Err(create_error!(NotFound))
        }
    }
-
-    async fn remove_dangling_members(&self) -> Result<()> {
-        todo!()
-    }
 }
@@ -181,7 +181,7 @@ impl Server {
    }

    /// Update server data
-    pub async fn update(
+    pub async fn update<'a>(
        &mut self,
        db: &Database,
        partial: PartialServer,
@@ -228,13 +228,6 @@ impl Server {
        }
    }

-    /// Ordered roles list
-    pub fn ordered_roles(&self) -> Vec<(String, Role)> {
-        let mut ordered_roles = self.roles.clone().into_iter().collect::<Vec<_>>();
-        ordered_roles.sort_by(|(_, role_a), (_, role_b)| role_a.rank.cmp(&role_b.rank));
-        ordered_roles
-    }
-
    /// Set role permission on a server
    pub async fn set_role_permission(
        &mut self,
@@ -260,37 +253,6 @@ impl Server {
            Err(create_error!(NotFound))
        }
    }
-
-    /// Reorders the server's roles rankings
-    pub async fn set_role_ordering(&mut self, db: &Database, new_order: Vec<String>) -> Result<()> {
-        // New order must always contain every role
-        debug_assert_eq!(self.roles.len(), new_order.len());
-
-        // Set the role's ranks to the positions in the vec
-        for (rank, id) in new_order.iter().enumerate() {
-            self.roles.get_mut(id).unwrap().rank = rank as i64;
-        }
-
-        db.update_server(
-            &self.id,
-            &PartialServer {
-                roles: Some(self.roles.clone()),
-                ..Default::default()
-            },
-            Vec::new(),
-        )
-        .await?;
-
-        // Publish bulk update event
-        EventV1::ServerRoleRanksUpdate {
-            id: self.id.clone(),
-            ranks: new_order,
-        }
-        .p(self.id.clone())
-        .await;
-
-        Ok(())
-    }
 }

 impl Role {
@@ -323,7 +285,7 @@ impl Role {
    }

    /// Update server data
-    pub async fn update(
+    pub async fn update<'a>(
        &mut self,
        db: &Database,
        server_id: &str,
@@ -2,7 +2,6 @@ use revolt_result::Result;

 use crate::{FieldsRole, FieldsServer, PartialRole, PartialServer, Role, Server};

-#[cfg(feature = "mongodb")]
 mod mongodb;
 mod reference;

@@ -25,11 +25,14 @@ 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
-                }
-            })
+            .find(
+                doc! {
+                    "_id": {
+                        "$in": ids
+                    }
+                },
+                None,
+            )
            .await
            .map_err(|_| create_database_error!("find", "servers"))?
            .filter_map(|s| async {
@@ -81,6 +84,7 @@ impl AbstractServers for MongoDb {
                            .map_err(|_| create_database_error!("to_document", "role"))?
                    }
                },
+                None,
            )
            .await
            .map(|_| ())
@@ -121,6 +125,7 @@ impl AbstractServers for MongoDb {
                        "roles": &role_id
                    }
                },
+                None,
            )
            .await
            .map_err(|_| create_database_error!("update_many", "server_members"))?;
@@ -135,6 +140,7 @@ impl AbstractServers for MongoDb {
                        "role_permissions.".to_owned() + role_id: 1_i32
                    }
                },
+                None,
            )
            .await
            .map_err(|_| create_database_error!("update_one", "channels"))?;
@@ -149,6 +155,7 @@ impl AbstractServers for MongoDb {
                        "roles.".to_owned() + role_id: 1_i32
                    }
                },
+                None,
            )
            .await
            .map(|_| ())
@@ -181,9 +188,12 @@ impl MongoDb {
        // Find all channels
        let channels: Vec<String> = self
            .col::<Document>("channels")
-            .find(doc! {
-                "server": server_id
-            })
+            .find(
+                doc! {
+                    "server": server_id
+                },
+                None,
+            )
            .await
            .map_err(|_| create_database_error!("find", "channels"))?
            .filter_map(|s| async {
@@ -215,15 +225,19 @@ impl MongoDb {
                        }
                    }
                },
+                None,
            )
            .await
            .map_err(|_| create_database_error!("update_many", "emojis"))?;

        // Delete all channels.
        self.col::<Document>("channels")
-            .delete_many(doc! {
-                "server": &server_id
-            })
+            .delete_many(
+                doc! {
+                    "server": &server_id
+                },
+                None,
+            )
            .await
            .map_err(|_| create_database_error!("delete_many", "channels"))?;

@@ -234,9 +248,12 @@ impl MongoDb {
        // Delete members and bans.
        for with in &["server_members", "server_bans"] {
            self.col::<Document>(with)
-                .delete_many(doc! {
-                    "_id.server": &server_id
-                })
+                .delete_many(
+                    doc! {
+                        "_id.server": &server_id
+                    },
+                    None,
+                )
                .await
                .map_err(|_| create_database_error!("delete_many", with))?;
        }
@@ -2,7 +2,6 @@ use revolt_result::Result;

 use crate::UserSettings;

-#[cfg(feature = "mongodb")]
 mod mongodb;
 mod reference;

@@ -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"))
@@ -1,21 +1,14 @@
-use axum::{
-    extract::{FromRef, FromRequestParts},
-    http::request::Parts,
-};
+use axum::{extract::FromRequestParts, http::request::Parts};

 use revolt_result::{create_error, Error, Result};

 use crate::{Database, User};

 #[async_trait::async_trait]
-impl<S: Send + Sync> FromRequestParts<S> for User
-where
-    Database: FromRef<S>,
-{
+impl FromRequestParts<Database> for User {
    type Rejection = Error;

-    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<User> {
-        let db = Database::from_ref(state);
+    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
@@ -7,5 +7,11 @@ 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")]
+pub use self::schema::*;
 pub use model::*;
 pub use ops::*;
@@ -3,12 +3,11 @@ use std::{collections::HashSet, str::FromStr, time::Duration};
 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::{self, UserBadges, UserFlags};
+use revolt_models::v0::{self, UserFlags};
 use revolt_presence::filter_online;
 use revolt_result::{create_error, Result};
 use serde_json::json;
@@ -57,8 +56,6 @@ auto_derived_partial!(
        /// 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"
 );
@@ -180,7 +177,6 @@ impl Default for User {
            privileged: Default::default(),
            bot: Default::default(),
            suspended_until: Default::default(),
-            last_acknowledged_policy_change: Timestamp::UNIX_EPOCH,
        }
    }
 }
@@ -203,7 +199,6 @@ 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()
        };

@@ -353,13 +348,15 @@ impl User {
    ) -> Result<Vec<v0::User>> {
        let online_ids = filter_online(ids).await;

-        Ok(
-            join_all(db.fetch_users(ids).await?.into_iter().map(|user| async {
+        Ok(db
+            .fetch_users(ids)
+            .await?
+            .into_iter()
+            .map(|user| {
                let is_online = online_ids.contains(&user.id);
-                user.into_known(perspective, is_online).await
-            }))
-            .await,
-        )
+                user.into_known(perspective, is_online)
+            })
+            .collect())
    }

    /// Find a free discriminator for a given username
@@ -640,7 +637,7 @@ impl User {
    }

    /// Update user data
-    pub async fn update(
+    pub async fn update<'a>(
        &mut self,
        db: &Database,
        partial: PartialUser,
@@ -810,18 +807,4 @@ impl User {
        )
        .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
-    }
 }
@@ -1,10 +1,8 @@
 use authifier::models::Session;
-use iso8601_timestamp::Timestamp;
 use revolt_result::Result;

 use crate::{FieldsUser, PartialUser, RelationshipStatus, User};

-#[cfg(feature = "mongodb")]
 mod mongodb;
 mod reference;

@@ -63,6 +61,4 @@ pub trait AbstractUsers: Sync + Send {

    /// Remove push subscription for a session by session id (TODO: remove)
    async fn remove_push_subscription_by_session_id(&self, session_id: &str) -> Result<()>;
-
-    async fn update_session_last_seen(&self, session_id: &str, when: Timestamp) -> Result<()>;
 }
@@ -1,7 +1,6 @@
 use ::mongodb::options::{Collation, CollationStrength, FindOneOptions, FindOptions};
 use authifier::models::Session;
 use futures::StreamExt;
-use iso8601_timestamp::Timestamp;
 use revolt_result::Result;

 use crate::DocumentId;
@@ -50,9 +49,12 @@ 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
-            })
+            .find_one(
+                doc! {
+                    "token": token
+                },
+                None,
+            )
            .await
            .map_err(|_| create_database_error!("find_one", "sessions"))?
            .ok_or_else(|| create_error!(InvalidSession))
@@ -62,11 +64,14 @@ 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
-                }
-            })
+            .find(
+                doc! {
+                    "_id": {
+                        "$in": ids
+                    }
+                },
+                None,
+            )
            .await
            .map_err(|_| create_database_error!("find", COL))?
            .filter_map(|s| async {
@@ -89,10 +94,10 @@ impl AbstractUsers for MongoDb {

        Ok(self
            .col::<UserDocument>(COL)
-            .find(doc! {
-                "username": username
-            })
-            .with_options(
+            .find(
+                doc! {
+                    "username": username
+                },
                FindOptions::builder()
                    .collation(
                        Collation::builder()
@@ -117,13 +122,15 @@ 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" } } }
-                ]
-            })
-            .with_options(FindOptions::builder().projection(doc! { "_id": 1 }).build())
+            .find(
+                doc! {
+                    "$and": [
+                        { "relations": { "$elemMatch": { "_id": &user_a, "status": "Friend" } } },
+                        { "relations": { "$elemMatch": { "_id": &user_b, "status": "Friend" } } }
+                    ]
+                },
+                FindOptions::builder().projection(doc! { "_id": 1 }).build(),
+            )
            .await
            .map_err(|_| create_database_error!("find", COL))?
            .filter_map(|s| async { s.ok() })
@@ -136,15 +143,17 @@ 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"]
+            .find(
+                doc! {
+                    "channel_type": {
+                        "$in": ["Group", "DirectMessage"]
+                    },
+                    "recipients": {
+                        "$all": [ user_a, user_b ]
+                    }
                },
-                "recipients": {
-                    "$all": [ user_a, user_b ]
-                }
-            })
-            .with_options(FindOptions::builder().projection(doc! { "_id": 1 }).build())
+                FindOptions::builder().projection(doc! { "_id": 1 }).build(),
+            )
            .await
            .map_err(|_| create_database_error!("find", "channels"))?
            .filter_map(|s| async { s.ok() })
@@ -157,46 +166,49 @@ 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! {
-                    "$project": {
-                        "_id": "$_id.server"
-                    }
-                },
-            ])
+                    },
+                    doc! {
+                        "$match": {
+                            "members": {
+                                "$size": 1_i32
+                            }
+                        }
+                    },
+                    doc! {
+                        "$project": {
+                            "_id": "$_id.server"
+                        }
+                    },
+                ],
+                None,
+            )
            .await
            .map_err(|_| create_database_error!("aggregate", "server_members"))?
            .filter_map(|s| async { s.ok() })
@@ -212,34 +224,16 @@ impl AbstractUsers for MongoDb {
        partial: &PartialUser,
        remove: Vec<FieldsUser>,
    ) -> Result<()> {
-        if remove.contains(&FieldsUser::StatusText) && partial.status.is_some() {
-            // stupid-ass workaround to fix mongo conflicting the same item
-            let _: Result<()> = query!(
-                self,
-                update_one_by_id,
-                COL,
-                id,
-                PartialUser {
-                    ..Default::default()
-                },
-                remove.iter().map(|x| x as &dyn IntoDocumentPath).collect(),
-                None
-            )
-            .map(|_| ());
-
-            query!(self, update_one_by_id, COL, id, partial, vec![], None).map(|_| ())
-        } else {
-            query!(
-                self,
-                update_one_by_id,
-                COL,
-                id,
-                partial,
-                remove.iter().map(|x| x as &dyn IntoDocumentPath).collect(),
-                None
-            )
-            .map(|_| ())
-        }
+        query!(
+            self,
+            update_one_by_id,
+            COL,
+            id,
+            partial,
+            remove.iter().map(|x| x as &dyn IntoDocumentPath).collect(),
+            None
+        )
+        .map(|_| ())
    }

    /// Set relationship with another user
@@ -290,6 +284,7 @@ impl AbstractUsers for MongoDb {
                        }
                    }
                }],
+                None,
            )
            .await
            .map(|_| ())
@@ -310,6 +305,7 @@ impl AbstractUsers for MongoDb {
                        }
                    }
                },
+                None,
            )
            .await
            .map(|_| ())
@@ -333,29 +329,11 @@ impl AbstractUsers for MongoDb {
                        "subscription": 1
                    }
                },
+                None,
            )
            .await
            .map(|_| ())
-            .map_err(|_| create_database_error!("update_one", "sessions"))
-    }
-
-    async fn update_session_last_seen(&self, session_id: &str, when: Timestamp) -> Result<()> {
-        let formatted: &str = &when.format();
-
-        self.col::<Session>("sessions")
-            .update_one(
-                doc! {
-                    "_id": session_id
-                },
-                doc! {
-                    "$set": {
-                        "last_seen": formatted
-                    }
-                },
-            )
-            .await
-            .map(|_| ())
-            .map_err(|_| create_database_error!("update_one", "sessions"))
+            .map_err(|_| create_database_error!("update_one", COL))
    }
 }

@@ -1,5 +1,4 @@
 use authifier::models::Session;
-use iso8601_timestamp::Timestamp;
 use revolt_result::Result;

 use crate::{FieldsUser, PartialUser, RelationshipStatus, User};
@@ -169,8 +168,4 @@ impl AbstractUsers for ReferenceDb {
    async fn remove_push_subscription_by_session_id(&self, _session_id: &str) -> Result<()> {
        todo!()
    }
-
-    async fn update_session_last_seen(&self, _session_id: &str, _when: Timestamp) -> Result<()> {
-        todo!()
-    }
 }
@@ -6,7 +6,7 @@ use revolt_rocket_okapi::{

 use crate::User;

-impl OpenApiFromRequest<'_> for User {
+impl<'r> OpenApiFromRequest<'r> for User {
    fn from_request_input(
        _gen: &mut OpenApiGenerator,
        _name: String,
@@ -3,8 +3,8 @@ use crate::{Database, Message, AMQP};

 use deadqueue::limited::Queue;
 use once_cell::sync::Lazy;
-use revolt_config::capture_message;
 use revolt_models::v0::PushNotification;
+use rocket::form::validate::Contains;
 use std::{
    collections::{HashMap, HashSet},
    time::Duration,
@@ -14,7 +14,6 @@ use validator::HasLen;
 use revolt_result::Result;

 use super::DelayedTask;
-use crate::Channel::{TextChannel, VoiceChannel};

 /// Enumeration of possible events
 #[derive(Debug, Eq, PartialEq)]
@@ -65,7 +64,6 @@ pub async fn queue_ack(channel: String, user: String, event: AckEvent) {
    );
 }

-/// Do not add more than one message per event.
 pub async fn queue_message(channel: String, event: AckEvent) {
    Q.try_push(Data {
        channel,
@@ -115,50 +113,40 @@ pub async fn handle_ack_event(
        }
        AckEvent::ProcessMessage { messages } => {
            let mut users: HashSet<&String> = HashSet::new();
-            info!(
+            debug!(
                "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());
-            });
+            messages
+                .iter()
+                .for_each(|(_, _, recipents, _)| users.extend(recipents.iter()));

-            info!("Found {} users to notify.", users.len());
+            debug!("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
-                        }
-                    })
+                    .filter(|(_, _, recipients, _)| recipients.contains(user))
+                    .map(|(_, message, _, _)| message.id.clone())
                    .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);
+                debug!("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())
-                {
+            for (push, _, recipients, silenced) in messages {
+                if *silenced || recipients.is_empty() || push.is_none() {
                    debug!(
                        "Rejecting push: silenced: {}, recipient count: {}, push exists: {:?}",
                        *silenced,
                        recipients.length(),
-                        push.is_some()
+                        push
                    );
                    continue;
                }
@@ -174,35 +162,6 @@ pub async fn handle_ack_event(
                {
                    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");
-                    }
-                }
            }
        }
    };
@@ -248,8 +207,6 @@ pub async fn worker(db: Database, amqp: AMQP) {
            mut event,
        }) = Q.try_pop()
        {
-            info!("Took next ack from queue, now {} remaining", Q.len());
-
            let key: (Option<String>, String, u8) = (
                user,
                channel,
@@ -264,31 +221,18 @@ pub async fn worker(db: Database, amqp: AMQP) {
                        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;
-                                }
+                            // add the new message to the list of messages to be processed.
+                            existing.append(new_data);

-                                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}")
+                            // 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 {
                            panic!("Somehow got an ack message in the add mention arm");
@@ -4,7 +4,7 @@ use once_cell::sync::Lazy;

 use crate::events::client::EventV1;

-static Q: Lazy<(Sender<AuthifierEvent>, Receiver<AuthifierEvent>)> = Lazy::new(unbounded);
+static Q: Lazy<(Sender<AuthifierEvent>, Receiver<AuthifierEvent>)> = Lazy::new(|| unbounded());

 /// Get sender
 pub fn sender() -> Sender<AuthifierEvent> {
@@ -26,7 +26,6 @@ pub fn start_workers(db: Database, amqp: AMQP) {
 /// 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,
 }
@@ -42,7 +41,6 @@ impl<T> DelayedTask<T> {
    pub fn new(data: T) -> Self {
        DelayedTask {
            data,
-            run_now: false,
            last_updated: Instant::now(),
            first_seen: Instant::now(),
        }
@@ -53,15 +51,9 @@ 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.run_now
-            || self.first_seen.elapsed().as_secs() > EXPIRE_CONSTANT
+        self.first_seen.elapsed().as_secs() > EXPIRE_CONSTANT
            || self.last_updated.elapsed().as_secs() > SAVE_CONSTANT
    }
 }
@@ -1,8 +1,7 @@
-use iso8601_timestamp::Timestamp;
 use revolt_models::v0::*;
 use revolt_permissions::{calculate_user_permissions, UserPermission};

-use crate::{util::permissions::DatabasePermissionQuery, Database};
+use crate::{util::permissions::DatabasePermissionQuery, Database, FileUsedFor};

 impl crate::Bot {
    pub fn into_public_bot(self, user: crate::User) -> PublicBot {
@@ -15,7 +14,8 @@ impl crate::Bot {
            avatar: user.avatar.map(|x| x.id).unwrap_or_default(),
            description: user
                .profile
-                .and_then(|profile| profile.content)
+                .map(|profile| profile.content)
+                .flatten()
                .unwrap_or_default(),
        }
    }
@@ -483,12 +483,11 @@ 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.unwrap_or_default(),
+            flags: self.flags.map(|flags| flags as u32).unwrap_or_default(),
            pinned: self.pinned,
        }
    }
@@ -512,12 +511,11 @@ 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,
+            flags: value.flags.map(|flags| flags as u32),
            pinned: value.pinned,
        }
    }
@@ -597,17 +595,6 @@ 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 {
@@ -707,7 +694,6 @@ impl From<crate::FieldsMember> for FieldsMember {
            crate::FieldsMember::Nickname => FieldsMember::Nickname,
            crate::FieldsMember::Roles => FieldsMember::Roles,
            crate::FieldsMember::Timeout => FieldsMember::Timeout,
-            crate::FieldsMember::JoinedAt => FieldsMember::JoinedAt,
        }
    }
 }
@@ -719,7 +705,6 @@ impl From<FieldsMember> for crate::FieldsMember {
            FieldsMember::Nickname => crate::FieldsMember::Nickname,
            FieldsMember::Roles => crate::FieldsMember::Roles,
            FieldsMember::Timeout => crate::FieldsMember::Timeout,
-            FieldsMember::JoinedAt => crate::FieldsMember::JoinedAt,
        }
    }
 }
@@ -1007,8 +992,6 @@ impl crate::User {
            (RelationshipStatus::None, false)
        };

-        let badges = self.get_badges().await;
-
        User {
            username: self.username,
            discriminator: self.discriminator,
@@ -1027,7 +1010,7 @@ impl crate::User {
            } else {
                vec![]
            },
-            badges,
+            badges: self.badges.unwrap_or_default() as u32,
            online: can_see_profile
                && revolt_presence::is_online(&self.id).await
                && !matches!(
@@ -1038,7 +1021,7 @@ impl crate::User {
                    })
                ),
            status: if can_see_profile {
-                self.status.and_then(|status| status.into(true))
+                self.status.map(|status| status.into())
            } else {
                None
            },
@@ -1053,7 +1036,7 @@ impl crate::User {
    /// Convert user object into user model assuming mutual connection
    ///
    /// 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
+    pub fn into_known<'a, P>(self, perspective: P, is_online: bool) -> User
    where
        P: Into<Option<&'a crate::User>>,
    {
@@ -1083,15 +1066,13 @@ 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: vec![],
-            badges,
+            badges: self.badges.unwrap_or_default() as u32,
            online: can_see_profile
                && is_online
                && !matches!(
@@ -1102,7 +1083,7 @@ impl crate::User {
                    })
                ),
            status: if can_see_profile {
-                self.status.and_then(|status| status.into(true))
+                self.status.map(|status| status.into())
            } else {
                None
            },
@@ -1115,16 +1096,14 @@ impl crate::User {
    }

    /// Convert user object into user model without presence information
-    pub async fn into_known_static(self, is_online: bool) -> User {
-        let badges = self.get_badges().await;
-
+    pub fn into_known_static<'a>(self, is_online: bool) -> User {
        User {
            username: self.username,
            discriminator: self.discriminator,
            display_name: self.display_name,
            avatar: self.avatar.map(|file| file.into()),
            relations: vec![],
-            badges,
+            badges: self.badges.unwrap_or_default() as u32,
            online: is_online
                && !matches!(
                    self.status,
@@ -1133,7 +1112,7 @@ impl crate::User {
                        ..
                    })
                ),
-            status: self.status.and_then(|status| status.into(true)),
+            status: self.status.map(|status| status.into()),
            flags: self.flags.unwrap_or_default() as u32,
            privileged: self.privileged,
            bot: self.bot.map(|bot| bot.into()),
@@ -1143,8 +1122,6 @@ 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,
@@ -1159,7 +1136,7 @@ impl crate::User {
                        .collect()
                })
                .unwrap_or_default(),
-            badges,
+            badges: self.badges.unwrap_or_default() as u32,
            online: (force_online || revolt_presence::is_online(&self.id).await)
                && !matches!(
                    self.status,
@@ -1168,7 +1145,7 @@ impl crate::User {
                        ..
                    })
                ),
-            status: self.status.and_then(|status| status.into(true)),
+            status: self.status.map(|status| status.into()),
            flags: self.flags.unwrap_or_default() as u32,
            privileged: self.privileged,
            bot: self.bot.map(|bot| bot.into()),
@@ -1201,7 +1178,6 @@ impl From<User> for crate::User {
            privileged: value.privileged,
            bot: value.bot.map(Into::into),
            suspended_until: None,
-            last_acknowledged_policy_change: Timestamp::UNIX_EPOCH,
        }
    }
 }
@@ -1220,7 +1196,7 @@ impl From<crate::PartialUser> for PartialUser {
                    .collect()
            }),
            badges: value.badges.map(|badges| badges as u32),
-            status: value.status.and_then(|status| status.into(false)),
+            status: value.status.map(|status| status.into()),
            flags: value.flags.map(|flags| flags as u32),
            privileged: value.privileged,
            bot: value.bot.map(|bot| bot.into()),
@@ -1309,23 +1285,11 @@ impl From<Presence> for crate::Presence {
    }
 }

-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)
+impl From<crate::UserStatus> for UserStatus {
+    fn from(value: crate::UserStatus) -> Self {
+        UserStatus {
+            text: value.text,
+            presence: value.presence.map(|presence| presence.into()),
        }
    }
 }
@@ -87,46 +87,23 @@ impl<'z> BulkDatabasePermissionQuery<'z> {
        }
    }

-    pub fn channel(self, channel: &'z Channel) -> BulkDatabasePermissionQuery<'z> {
+    pub fn channel(self, channel: &'z Channel) -> BulkDatabasePermissionQuery {
        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> {
+    pub fn members(self, members: &'z [Member]) -> BulkDatabasePermissionQuery {
        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> {
+    pub fn users(self, users: &'z [User]) -> BulkDatabasePermissionQuery {
        BulkDatabasePermissionQuery {
            users: Some(users.to_owned()),
-            cached_member_perms: None,
-            members: None,
-            cached_members: None,
-            cached_users: None,
            ..self
        }
    }
@@ -54,7 +54,7 @@ use revolt_rocket_okapi::{
 use schemars::schema::{InstanceType, SchemaObject, SingleOrVec};

 #[cfg(feature = "rocket-impl")]
-impl OpenApiFromRequest<'_> for IdempotencyKey {
+impl<'r> OpenApiFromRequest<'r> for IdempotencyKey {
    fn from_request_input(
        _gen: &mut OpenApiGenerator,
        _name: String,
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
jmug	35cfb9a489	chore(images): Build all images.	2026-06-27 11:31:14 -07:00
jmug	7297a64856	chore(images): s/handmade-revolt/handmade-revolt-backend/	2026-06-27 11:28:34 -07:00
jmug	720cd46879	chore(pushd/ci): Build image pushd image in-fork.	2026-06-27 00:34:53 -07:00
jmug	7d099d5ae7	feat(pushd): Guard against malformed vapid web pushes.	2026-06-27 00:12:11 -07:00
jmug	8847b3c5ba	feat(pushd): Fix typo in inbound notification handling.	2026-06-27 00:06:05 -07:00